Skip to content

Modern Docker Management, Designed for Everyone

9.7 KB
Raw Blame
package projects

import (
	"testing"
	"time"

	composetypes "github.com/compose-spec/compose-go/v2/types"
	"github.com/stretchr/testify/assert"
)

func TestResolveServiceImagePullMode(t *testing.T) {
	tests := []struct {
		name     string
		service  composetypes.ServiceConfig
		expected ImagePullStep
	}{
		{
			name:     "default policy is missing",
			service:  composetypes.ServiceConfig{},
			expected: ImagePullStep{Mode: ImagePullModeIfMissing},
		},
		{
			name:     "always policy",
			service:  composetypes.ServiceConfig{PullPolicy: composetypes.PullPolicyAlways},
			expected: ImagePullStep{Mode: ImagePullModeAlways},
		},
		{
			name:     "bare refresh policy has a zero refresh window",
			service:  composetypes.ServiceConfig{PullPolicy: composetypes.PullPolicyRefresh},
			expected: ImagePullStep{Mode: ImagePullModeRefresh, RefreshAfter: 0},
		},
		{
			name:     "daily policy is a 24h refresh window",
			service:  composetypes.ServiceConfig{PullPolicy: "daily"},
			expected: ImagePullStep{Mode: ImagePullModeRefresh, RefreshAfter: 24 * time.Hour},
		},
		{
			name:     "weekly policy is a 7d refresh window",
			service:  composetypes.ServiceConfig{PullPolicy: "weekly"},
			expected: ImagePullStep{Mode: ImagePullModeRefresh, RefreshAfter: 7 * 24 * time.Hour},
		},
		{
			name:     "every_12h policy parses its window",
			service:  composetypes.ServiceConfig{PullPolicy: "every_12h"},
			expected: ImagePullStep{Mode: ImagePullModeRefresh, RefreshAfter: 12 * time.Hour},
		},
		{
			name:     "every with invalid duration defaults to missing behavior",
			service:  composetypes.ServiceConfig{PullPolicy: "every_bogus"},
			expected: ImagePullStep{Mode: ImagePullModeIfMissing},
		},
		{
			name:     "missing policy",
			service:  composetypes.ServiceConfig{PullPolicy: composetypes.PullPolicyMissing},
			expected: ImagePullStep{Mode: ImagePullModeIfMissing},
		},
		{
			name:     "if not present policy",
			service:  composetypes.ServiceConfig{PullPolicy: composetypes.PullPolicyIfNotPresent},
			expected: ImagePullStep{Mode: ImagePullModeIfMissing},
		},
		{
			name:     "never policy",
			service:  composetypes.ServiceConfig{PullPolicy: composetypes.PullPolicyNever},
			expected: ImagePullStep{Mode: ImagePullModeNever},
		},
		{
			name:     "invalid policy defaults to missing behavior",
			service:  composetypes.ServiceConfig{PullPolicy: "definitely_invalid"},
			expected: ImagePullStep{Mode: ImagePullModeIfMissing},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, tt.expected, ResolveServiceImagePullMode(tt.service))
		})
	}
}

func TestBuildProjectImagePullPlan(t *testing.T) {
	project := &composetypes.Project{
		Name: "demo",
		Services: composetypes.Services{
			"web": {
				Name:       "web",
				Image:      "redis:latest",
				PullPolicy: composetypes.PullPolicyIfNotPresent,
			},
			"worker": {
				Name:       "worker",
				Image:      "redis:latest",
				PullPolicy: composetypes.PullPolicyAlways,
			},
			"api": {
				Name:       "api",
				Image:      "nginx:latest",
				PullPolicy: composetypes.PullPolicyNever,
			},
			"empty-image": {
				Name:       "empty-image",
				Image:      "",
				PullPolicy: composetypes.PullPolicyAlways,
			},
		},
	}

	plan := BuildImagePullPlan(project)

	assert.Len(t, plan, 2)
	assert.Equal(t, ImagePullStep{Mode: ImagePullModeAlways}, plan["redis:latest"])
	assert.Equal(t, ImagePullStep{Mode: ImagePullModeNever}, plan["nginx:latest"])
}

func TestBuildImagePullPlanRefreshMerge(t *testing.T) {
	project := &composetypes.Project{
		Name: "demo",
		Services: composetypes.Services{
			"daily": {
				Name:       "daily",
				Image:      "shared:latest",
				PullPolicy: "daily",
			},
			"hourly": {
				Name:       "hourly",
				Image:      "shared:latest",
				PullPolicy: "every_1h",
			},
			"missing": {
				Name:       "missing",
				Image:      "shared:latest",
				PullPolicy: composetypes.PullPolicyMissing,
			},
			"weekly": {
				Name:       "weekly",
				Image:      "other:latest",
				PullPolicy: "weekly",
			},
			"always": {
				Name:       "always",
				Image:      "other:latest",
				PullPolicy: composetypes.PullPolicyAlways,
			},
		},
	}

	plan := BuildImagePullPlan(project)

	// shortest refresh window wins over longer windows and pull-if-missing
	assert.Equal(t, ImagePullStep{Mode: ImagePullModeRefresh, RefreshAfter: time.Hour}, plan["shared:latest"])
	// always wins over any refresh window
	assert.Equal(t, ImagePullStep{Mode: ImagePullModeAlways}, plan["other:latest"])
}

func TestBuildImagePullPlanDependentImages(t *testing.T) {
	project := &composetypes.Project{
		Name: "demo",
		Services: composetypes.Services{
			"web": {
				Name:  "web",
				Image: "nginx:latest",
				PreStart: []composetypes.PreStartHook{{ContainerSpec: composetypes.ContainerSpec{
					Image: "busybox:stable", Command: composetypes.ShellCommand{"true"},
				}}},
				Volumes: []composetypes.ServiceVolumeConfig{
					{Type: composetypes.VolumeTypeImage, Source: "content:latest", Target: "/data"},
				},
			},
			"local": {
				Name:       "local",
				Image:      "local:dev",
				PullPolicy: composetypes.PullPolicyNever,
				PreStart: []composetypes.PreStartHook{{ContainerSpec: composetypes.ContainerSpec{
					Image: "skipped:hook", Command: composetypes.ShellCommand{"true"},
				}}},
			},
		},
	}

	plan := BuildImagePullPlan(project)

	assert.Equal(t, ImagePullStep{Mode: ImagePullModeIfMissing}, plan["busybox:stable"])
	assert.Equal(t, ImagePullStep{Mode: ImagePullModeIfMissing}, plan["content:latest"])
	assert.NotContains(t, plan, "skipped:hook")
}

func TestNormalizePullPolicy(t *testing.T) {
	assert.Equal(t, "missing", NormalizePullPolicy("if_not_present"))
	assert.Equal(t, "build", NormalizePullPolicy(" BUILD "))
	assert.Empty(t, NormalizePullPolicy(""))
}

func TestDecideDeployImageAction(t *testing.T) {
	t.Run("build service with explicit build policy", func(t *testing.T) {
		svc := composetypes.ServiceConfig{
			PullPolicy: "build",
			Build:      &composetypes.BuildConfig{Context: "."},
		}

		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.Build)
		assert.False(t, decision.PullAlways)
	})

	t.Run("build service default policy uses pull then fallback build", func(t *testing.T) {
		svc := composetypes.ServiceConfig{Build: &composetypes.BuildConfig{Context: "."}}
		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.PullIfMissing)
		assert.True(t, decision.FallbackBuildOnPullFail)
		assert.False(t, decision.Build)
	})

	t.Run("non-build service never policy requires local only", func(t *testing.T) {
		svc := composetypes.ServiceConfig{PullPolicy: "never"}
		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.RequireLocalOnly)
		assert.False(t, decision.PullIfMissing)
	})

	t.Run("compose pull policy wins over deploy override", func(t *testing.T) {
		svc := composetypes.ServiceConfig{PullPolicy: "never"}
		decision := DecideDeployImageAction(svc, "always")
		assert.True(t, decision.RequireLocalOnly)
		assert.False(t, decision.PullAlways)
	})

	t.Run("refresh policy pulls when stale instead of always", func(t *testing.T) {
		svc := composetypes.ServiceConfig{PullPolicy: "daily"}
		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.PullIfStale)
		assert.Equal(t, 24*time.Hour, decision.StaleAfter)
		assert.False(t, decision.PullAlways)
	})

	t.Run("refresh policy on build service pulls when stale", func(t *testing.T) {
		svc := composetypes.ServiceConfig{
			PullPolicy: "every_6h",
			Build:      &composetypes.BuildConfig{Context: "."},
		}
		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.PullIfStale)
		assert.Equal(t, 6*time.Hour, decision.StaleAfter)
		assert.True(t, decision.FallbackBuildOnPullFail)
		assert.False(t, decision.Build)
	})

	t.Run("build service with deploy missing override falls back to build", func(t *testing.T) {
		svc := composetypes.ServiceConfig{Build: &composetypes.BuildConfig{Context: "."}}
		decision := DecideDeployImageAction(svc, "missing")
		assert.True(t, decision.PullIfMissing)
		assert.True(t, decision.FallbackBuildOnPullFail)
		assert.False(t, decision.Build)
	})

	t.Run("build service with always policy falls back to build", func(t *testing.T) {
		svc := composetypes.ServiceConfig{
			PullPolicy: "always",
			Build:      &composetypes.BuildConfig{Context: "."},
		}
		decision := DecideDeployImageAction(svc, "")
		assert.True(t, decision.PullAlways)
		assert.True(t, decision.FallbackBuildOnPullFail)
		assert.False(t, decision.Build)
	})

	t.Run("non-build service never falls back to build", func(t *testing.T) {
		decision := DecideDeployImageAction(composetypes.ServiceConfig{}, "always")
		assert.True(t, decision.PullAlways)
		assert.False(t, decision.FallbackBuildOnPullFail)
	})
}

func TestShouldPullDeployImage(t *testing.T) {
	refresh := DeployImageDecision{PullIfStale: true, StaleAfter: 24 * time.Hour}

	t.Run("always pulls regardless of presence", func(t *testing.T) {
		assert.True(t, ShouldPullDeployImage(DeployImageDecision{PullAlways: true}, true, time.Now()))
	})

	t.Run("missing image pulls under refresh policy", func(t *testing.T) {
		assert.True(t, ShouldPullDeployImage(refresh, false, time.Time{}))
	})

	t.Run("fresh image within window skips pull", func(t *testing.T) {
		assert.False(t, ShouldPullDeployImage(refresh, true, time.Now().Add(-time.Hour)))
	})

	t.Run("image older than window pulls", func(t *testing.T) {
		assert.True(t, ShouldPullDeployImage(refresh, true, time.Now().Add(-25*time.Hour)))
	})

	t.Run("unknown last-tag time counts as stale", func(t *testing.T) {
		assert.True(t, ShouldPullDeployImage(refresh, true, time.Time{}))
	})

	t.Run("pull-if-missing skips present image", func(t *testing.T) {
		assert.False(t, ShouldPullDeployImage(DeployImageDecision{PullIfMissing: true}, true, time.Time{}))
	})
}