cli_test.go

package dewy

import (
	"bytes"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/linyows/dewy/container"
)

func TestRunCLI(t *testing.T) {
	tests := []struct {
		name         string
		args         []string
		expectExit   int
		expectOutput string
		expectError  string
	}{
		{
			name:         "help flag",
			args:         []string{"--help"},
			expectExit:   ExitErr,
			expectOutput: "Usage: dewy",
		},
		{
			name:         "version flag",
			args:         []string{"--version"},
			expectExit:   ExitOK,
			expectOutput: "dewy version: test-version",
		},
		{
			name:        "no command",
			args:        []string{},
			expectExit:  ExitErr,
			expectError: "Error: command is not available",
		},
		{
			name:        "invalid command",
			args:        []string{"invalid"},
			expectExit:  ExitErr,
			expectError: "Error: command is not available",
		},
		{
			name:        "server command without registry",
			args:        []string{"server", "myapp"},
			expectExit:  ExitErr,
			expectError: "Error: --registry is not set",
		},
		{
			name:        "assets command without registry",
			args:        []string{"assets"},
			expectExit:  ExitErr,
			expectError: "Error: --registry is not set",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var outBuf, errBuf bytes.Buffer
			env := Env{
				Out:  &outBuf,
				Err:  &errBuf,
				Args: tt.args,
				Info: &Info{
					Version: "test-version",
					Commit:  "test-commit",
					Date:    "test-date",
				},
			}

			exitCode := RunCLI(env)

			if exitCode != tt.expectExit {
				t.Errorf("Expected exit code %d, got %d", tt.expectExit, exitCode)
			}

			if tt.expectOutput != "" {
				output := outBuf.String()
				if !strings.Contains(output, tt.expectOutput) {
					t.Errorf("Expected output to contain %q, got %q", tt.expectOutput, output)
				}
			}

			if tt.expectError != "" {
				errOutput := errBuf.String()
				if !strings.Contains(errOutput, tt.expectError) {
					t.Errorf("Expected error to contain %q, got %q", tt.expectError, errOutput)
				}
			}
		})
	}
}

func TestCLI_NotifierArgument(t *testing.T) {
	var outBuf, errBuf bytes.Buffer
	env := Env{
		Out:  &outBuf,
		Err:  &errBuf,
		Args: []string{"--notifier", "slack://test", "--registry", "ghr://test/test", "assets"},
		Info: &Info{
			Version: "test-version",
			Commit:  "test-commit",
			Date:    "test-date",
		},
	}

	cli := &cli{env: env, Interval: -1}
	cli.Notifier = "slack://test"
	cli.Registry = "ghr://test/test"

	conf := DefaultConfig()
	conf.Notifier = cli.Notifier

	if conf.Notifier != "slack://test" {
		t.Errorf("Expected notifier to be set to slack://test, got %s", conf.Notifier)
	}
}

func TestCLI_ConfigurationParsing(t *testing.T) {
	tests := []struct {
		name           string
		args           []string
		expectInterval int
		expectLogLevel string
		expectPort     string
		expectCommand  Command
	}{
		{
			name:           "default interval",
			args:           []string{"--registry", "ghr://test/test", "assets"},
			expectInterval: 10,
			expectLogLevel: "ERROR",
			expectCommand:  ASSETS,
		},
		{
			name:           "custom interval",
			args:           []string{"--interval", "30", "--registry", "ghr://test/test", "assets"},
			expectInterval: 30,
			expectLogLevel: "ERROR",
			expectCommand:  ASSETS,
		},
		{
			name:           "custom log level",
			args:           []string{"--log-level", "debug", "--registry", "ghr://test/test", "assets"},
			expectInterval: 10,
			expectLogLevel: "DEBUG",
			expectCommand:  ASSETS,
		},
		{
			name:           "server command with port",
			args:           []string{"--port", "8080", "--registry", "ghr://test/test", "server", "myapp"},
			expectInterval: 10,
			expectLogLevel: "ERROR",
			expectPort:     "8080",
			expectCommand:  SERVER,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var outBuf, errBuf bytes.Buffer
			env := Env{
				Out:  &outBuf,
				Err:  &errBuf,
				Args: tt.args,
				Info: &Info{
					Version: "test-version",
					Commit:  "test-commit",
					Date:    "test-date",
				},
			}

			// Mock the CLI parsing
			cli := &cli{env: env, Interval: -1}

			// Parse arguments manually for testing
			for i, arg := range tt.args {
				switch arg {
				case "--interval":
					if i+1 < len(tt.args) {
						if tt.args[i+1] == "30" {
							cli.Interval = 30
						}
					}
				case "--log-level":
					if i+1 < len(tt.args) {
						cli.LogLevel = tt.args[i+1]
					}
				case "--port":
					if i+1 < len(tt.args) {
						cli.Ports = []string{tt.args[i+1]}
					}
				case "--registry":
					if i+1 < len(tt.args) {
						cli.Registry = tt.args[i+1]
					}
				case "assets":
					cli.command = "assets"
				case "server":
					cli.command = "server"
				}
			}

			// Apply default interval logic
			if cli.Interval < 0 {
				cli.Interval = 10
			}

			// Apply default log level logic
			if cli.LogLevel != "" {
				cli.LogLevel = strings.ToUpper(cli.LogLevel)
			} else {
				cli.LogLevel = "ERROR"
			}

			// Test configuration
			conf := DefaultConfig()
			conf.Registry = cli.Registry

			if cli.command == "server" {
				conf.Command = SERVER
			} else {
				conf.Command = ASSETS
			}

			// Verify expectations
			if cli.Interval != tt.expectInterval {
				t.Errorf("Expected interval %d, got %d", tt.expectInterval, cli.Interval)
			}
			if cli.LogLevel != tt.expectLogLevel {
				t.Errorf("Expected log level %s, got %s", tt.expectLogLevel, cli.LogLevel)
			}
			if len(cli.Ports) == 1 && cli.Ports[0] != tt.expectPort {
				t.Errorf("Expected port %s, got %s", tt.expectPort, cli.Ports[0])
			} else if len(cli.Ports) != 1 && tt.expectPort != "" {
				t.Errorf("Expected single port %s, got %v", tt.expectPort, cli.Ports)
			}
			if conf.Command != tt.expectCommand {
				t.Errorf("Expected command %v, got %v", tt.expectCommand, conf.Command)
			}
		})
	}
}

func TestCLI_BuildHelp(t *testing.T) {
	cli := &cli{}

	help := cli.buildHelp([]string{"LogLevel", "Interval", "Registry"})

	if len(help) != 3 {
		t.Errorf("Expected 3 help lines, got %d", len(help))
	}

	// Check that help contains expected format
	for _, line := range help {
		if !strings.Contains(line, "--") {
			t.Errorf("Help line should contain '--', got: %s", line)
		}
	}

	// Test with non-existent field
	helpEmpty := cli.buildHelp([]string{"NonExistentField"})
	if len(helpEmpty) != 0 {
		t.Errorf("Expected 0 help lines for non-existent field, got %d", len(helpEmpty))
	}
}

func TestCLI_HookConfiguration(t *testing.T) {
	tests := []struct {
		name             string
		beforeDeployHook string
		afterDeployHook  string
		expectBeforeHook string
		expectAfterHook  string
	}{
		{
			name:             "no hooks",
			beforeDeployHook: "",
			afterDeployHook:  "",
			expectBeforeHook: "",
			expectAfterHook:  "",
		},
		{
			name:             "before hook only",
			beforeDeployHook: "echo before",
			afterDeployHook:  "",
			expectBeforeHook: "echo before",
			expectAfterHook:  "",
		},
		{
			name:             "after hook only",
			beforeDeployHook: "",
			afterDeployHook:  "echo after",
			expectBeforeHook: "",
			expectAfterHook:  "echo after",
		},
		{
			name:             "both hooks",
			beforeDeployHook: "echo before",
			afterDeployHook:  "echo after",
			expectBeforeHook: "echo before",
			expectAfterHook:  "echo after",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cli := &cli{
				BeforeDeployHook: tt.beforeDeployHook,
				AfterDeployHook:  tt.afterDeployHook,
			}

			conf := DefaultConfig()
			conf.BeforeDeployHook = cli.BeforeDeployHook
			conf.AfterDeployHook = cli.AfterDeployHook

			if conf.BeforeDeployHook != tt.expectBeforeHook {
				t.Errorf("Expected before hook %q, got %q", tt.expectBeforeHook, conf.BeforeDeployHook)
			}
			if conf.AfterDeployHook != tt.expectAfterHook {
				t.Errorf("Expected after hook %q, got %q", tt.expectAfterHook, conf.AfterDeployHook)
			}
		})
	}
}

func TestParsePorts(t *testing.T) {
	tests := []struct {
		name     string
		input    []string
		expected []string
		wantErr  bool
	}{
		{
			name:     "empty input",
			input:    []string{},
			expected: nil,
			wantErr:  false,
		},
		{
			name:     "single port",
			input:    []string{"8080"},
			expected: []string{"8080"},
			wantErr:  false,
		},
		{
			name:     "multiple single ports",
			input:    []string{"8080", "8081", "8082"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "comma-separated ports",
			input:    []string{"8080,8081,8082"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "port range",
			input:    []string{"8080-8082"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "mixed formats",
			input:    []string{"8080", "8085,8086", "8090-8092"},
			expected: []string{"8080", "8085", "8086", "8090", "8091", "8092"},
			wantErr:  false,
		},
		{
			name:     "duplicates removed",
			input:    []string{"8080", "8081", "8080"},
			expected: []string{"8080", "8081"},
			wantErr:  false,
		},
		{
			name:     "sorted output",
			input:    []string{"8082", "8080", "8081"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:    "invalid port",
			input:   []string{"invalid"},
			wantErr: true,
		},
		{
			name:    "port out of range high",
			input:   []string{"70000"},
			wantErr: true,
		},
		{
			name:    "port out of range low",
			input:   []string{"0"},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parsePorts(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("parsePorts() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
				t.Errorf("parsePorts() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestParsePortSpec(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected []string
		wantErr  bool
	}{
		{
			name:     "empty string",
			input:    "",
			expected: nil,
			wantErr:  false,
		},
		{
			name:     "single port",
			input:    "8080",
			expected: []string{"8080"},
			wantErr:  false,
		},
		{
			name:     "comma-separated ports",
			input:    "8080,8081,8082",
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "comma-separated with spaces",
			input:    "8080, 8081 , 8082",
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "port range",
			input:    "8080-8082",
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "mixed comma and range",
			input:    "8080,8085-8087,8090",
			expected: []string{"8080", "8085", "8086", "8087", "8090"},
			wantErr:  false,
		},
		{
			name:    "invalid port in comma-separated",
			input:   "8080,invalid,8082",
			wantErr: true,
		},
		{
			name:    "invalid range format",
			input:   "8080-8081-8082",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parsePortSpec(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("parsePortSpec() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
				t.Errorf("parsePortSpec() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestParsePortRange(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected []string
		wantErr  bool
	}{
		{
			name:     "valid range",
			input:    "8080-8082",
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "single port range",
			input:    "8080-8080",
			expected: []string{"8080"},
			wantErr:  false,
		},
		{
			name:     "range with spaces",
			input:    " 8080 - 8082 ",
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:    "reverse range",
			input:   "8082-8080",
			wantErr: true,
		},
		{
			name:    "invalid format",
			input:   "8080-8081-8082",
			wantErr: true,
		},
		{
			name:    "non-numeric start",
			input:   "abc-8082",
			wantErr: true,
		},
		{
			name:    "non-numeric end",
			input:   "8080-abc",
			wantErr: true,
		},
		{
			name:    "range too large",
			input:   "8000-8200",
			wantErr: true,
		},
		{
			name:    "invalid port in range",
			input:   "70000-70002",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := parsePortRange(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("parsePortRange() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
				t.Errorf("parsePortRange() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestValidatePort(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		wantErr bool
	}{
		{
			name:    "valid port",
			input:   "8080",
			wantErr: false,
		},
		{
			name:    "minimum valid port",
			input:   "1",
			wantErr: false,
		},
		{
			name:    "maximum valid port",
			input:   "65535",
			wantErr: false,
		},
		{
			name:    "non-numeric",
			input:   "abc",
			wantErr: true,
		},
		{
			name:    "port too low",
			input:   "0",
			wantErr: true,
		},
		{
			name:    "port too high",
			input:   "65536",
			wantErr: true,
		},
		{
			name:    "negative port",
			input:   "-1",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := validatePort(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("validatePort() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestValidateAndDeduplicatePorts(t *testing.T) {
	tests := []struct {
		name     string
		input    []string
		expected []string
		wantErr  bool
	}{
		{
			name:     "empty slice",
			input:    []string{},
			expected: []string{},
			wantErr:  false,
		},
		{
			name:     "no duplicates",
			input:    []string{"8080", "8081", "8082"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "with duplicates",
			input:    []string{"8080", "8081", "8080", "8082"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "unsorted input",
			input:    []string{"8082", "8080", "8081"},
			expected: []string{"8080", "8081", "8082"},
			wantErr:  false,
		},
		{
			name:     "mixed order with duplicates",
			input:    []string{"8085", "8080", "8082", "8080", "8081"},
			expected: []string{"8080", "8081", "8082", "8085"},
			wantErr:  false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := validateAndDeduplicatePorts(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("validateAndDeduplicatePorts() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
				t.Errorf("validateAndDeduplicatePorts() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestExtractAppNameFromRegistry(t *testing.T) {
	tests := []struct {
		name     string
		registry string
		want     string
	}{
		// img:// (OCI registry) - container command
		{
			name:     "img - ghcr.io with tag",
			registry: "img://ghcr.io/owner/myapp:latest",
			want:     "myapp",
		},
		{
			name:     "img - ghcr.io without tag",
			registry: "img://ghcr.io/owner/myapp",
			want:     "myapp",
		},
		{
			name:     "img - docker.io library",
			registry: "img://docker.io/library/nginx:1.21",
			want:     "nginx",
		},
		{
			name:     "img - gcr.io",
			registry: "img://gcr.io/my-project/myapp",
			want:     "myapp",
		},
		{
			name:     "img - simple image name",
			registry: "img://myapp:latest",
			want:     "myapp",
		},
		{
			name:     "img - with query parameters",
			registry: "img://ghcr.io/owner/myapp?pre-release=true",
			want:     "myapp",
		},
		{
			name:     "img - with tag and query parameters",
			registry: "img://ghcr.io/owner/myapp:v1.0.0?pre-release=true",
			want:     "myapp",
		},
		// ghr:// (GitHub Releases)
		{
			name:     "ghr - owner/repo",
			registry: "ghr://owner/myrepo",
			want:     "myrepo",
		},
		// s3://
		{
			name:     "s3 - simple path",
			registry: "s3://us-east-1/bucket/myapp",
			want:     "myapp",
		},
		{
			name:     "s3 - nested path",
			registry: "s3://us-east-1/bucket/path/to/myapp",
			want:     "myapp",
		},
		// Invalid cases
		{
			name:     "invalid format - no scheme",
			registry: "invalid-url",
			want:     "",
		},
		{
			name:     "empty string",
			registry: "",
			want:     "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := extractAppNameFromRegistry(tt.registry)
			if got != tt.want {
				t.Errorf("extractAppNameFromRegistry(%q) = %q, want %q", tt.registry, got, tt.want)
			}
		})
	}
}

func TestCLI_ConfigureServerCommand(t *testing.T) {
	tests := []struct {
		name        string
		ports       []string
		args        []string
		logFormat   string
		expectPorts []string
		expectCmd   string
		expectArgs  []string
		wantErr     bool
	}{
		{
			name:        "with port",
			ports:       []string{"8080"},
			args:        []string{"/opt/app/current/app", "arg1", "arg2"},
			logFormat:   "text",
			expectPorts: []string{"8080"},
			expectCmd:   "/opt/app/current/app",
			expectArgs:  []string{"arg1", "arg2"},
			wantErr:     false,
		},
		{
			name:        "without port (job worker)",
			ports:       []string{},
			args:        []string{"/opt/worker/current/worker"},
			logFormat:   "json",
			expectPorts: nil,
			expectCmd:   "/opt/worker/current/worker",
			expectArgs:  nil,
			wantErr:     false,
		},
		{
			name:        "with multiple ports",
			ports:       []string{"8080,8081,8082"},
			args:        []string{"/opt/app/current/app"},
			logFormat:   "text",
			expectPorts: []string{"8080", "8081", "8082"},
			expectCmd:   "/opt/app/current/app",
			expectArgs:  nil,
			wantErr:     false,
		},
		{
			name:      "with invalid port",
			ports:     []string{"invalid"},
			args:      []string{"/opt/app/current/app"},
			logFormat: "text",
			wantErr:   true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var errBuf bytes.Buffer
			cli := &cli{
				Ports:     tt.ports,
				args:      tt.args,
				LogFormat: tt.logFormat,
				env: Env{
					Err: &errBuf,
				},
			}

			conf := DefaultConfig()
			err := cli.configureServerCommand(&conf)

			if (err != nil) != tt.wantErr {
				t.Errorf("configureServerCommand() error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			if !tt.wantErr {
				if conf.Command != SERVER {
					t.Errorf("Expected command SERVER, got %v", conf.Command)
				}

				if conf.Starter == nil {
					t.Fatal("Expected Starter to be set")
				}

				if !reflect.DeepEqual(conf.Starter.Ports(), tt.expectPorts) {
					t.Errorf("Expected ports %v, got %v", tt.expectPorts, conf.Starter.Ports())
				}

				if conf.Starter.Command() != tt.expectCmd {
					t.Errorf("Expected command %q, got %q", tt.expectCmd, conf.Starter.Command())
				}

				if !reflect.DeepEqual(conf.Starter.Args(), tt.expectArgs) {
					t.Errorf("Expected args %v, got %v", tt.expectArgs, conf.Starter.Args())
				}

				if conf.Starter.LogFormat() != tt.logFormat {
					t.Errorf("Expected logformat %q, got %q", tt.logFormat, conf.Starter.LogFormat())
				}
			}
		})
	}
}

func TestDisplayContainerList(t *testing.T) {
	tests := []struct {
		name       string
		containers []*container.Info
		wantOutput string
	}{
		{
			name:       "empty list",
			containers: []*container.Info{},
			wantOutput: "No containers found.\n",
		},
		{
			name: "single container",
			containers: []*container.Info{
				{
					ID:         "abc123",
					Name:       "myapp-0",
					Image:      "nginx:latest",
					Status:     "running",
					IPPort:     "127.0.0.1:8080",
					StartedAt:  time.Date(2025, 1, 15, 10, 0, 0, 0, time.UTC),
					DeployedAt: time.Date(2025, 1, 15, 10, 0, 0, 0, time.UTC),
				},
			},
			wantOutput: "UPSTREAM",
		},
		{
			name: "multiple containers sorted by name",
			containers: []*container.Info{
				{
					ID:         "def456",
					Name:       "myapp-2",
					Image:      "nginx:latest",
					Status:     "running",
					IPPort:     "127.0.0.1:8082",
					StartedAt:  time.Date(2025, 1, 15, 10, 2, 0, 0, time.UTC),
					DeployedAt: time.Date(2025, 1, 15, 10, 2, 0, 0, time.UTC),
				},
				{
					ID:         "abc123",
					Name:       "myapp-0",
					Image:      "nginx:latest",
					Status:     "running",
					IPPort:     "127.0.0.1:8080",
					StartedAt:  time.Date(2025, 1, 15, 10, 0, 0, 0, time.UTC),
					DeployedAt: time.Date(2025, 1, 15, 10, 0, 0, 0, time.UTC),
				},
				{
					ID:         "ghi789",
					Name:       "myapp-1",
					Image:      "nginx:latest",
					Status:     "running",
					IPPort:     "127.0.0.1:8081",
					StartedAt:  time.Date(2025, 1, 15, 10, 1, 0, 0, time.UTC),
					DeployedAt: time.Date(2025, 1, 15, 10, 1, 0, 0, time.UTC),
				},
			},
			wantOutput: "myapp-0",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var buf bytes.Buffer
			c := &cli{
				env: Env{
					Out: &buf,
					Err: &buf,
				},
			}

			c.displayContainerList(tt.containers)

			got := buf.String()
			if !strings.Contains(got, tt.wantOutput) {
				t.Errorf("displayContainerList() output does not contain %q\nGot:\n%s", tt.wantOutput, got)
			}

			// For multiple containers, verify they are sorted
			if tt.name == "multiple containers sorted by name" {
				lines := strings.Split(strings.TrimSpace(got), "\n")
				if len(lines) < 4 {
					t.Errorf("Expected at least 4 lines (header + 3 containers), got %d", len(lines))
					return
				}

				// Check that myapp-0 comes before myapp-1, which comes before myapp-2
				output := strings.Join(lines, "\n")
				idx0 := strings.Index(output, "myapp-0")
				idx1 := strings.Index(output, "myapp-1")
				idx2 := strings.Index(output, "myapp-2")

				if idx0 == -1 || idx1 == -1 || idx2 == -1 {
					t.Errorf("Not all container names found in output")
					return
				}

				if idx0 >= idx1 || idx1 >= idx2 {
					t.Errorf("Containers are not sorted correctly: myapp-0 at %d, myapp-1 at %d, myapp-2 at %d",
						idx0, idx1, idx2)
				}
			}
		})
	}
}