209 lines
8.0 KiB
Go
209 lines
8.0 KiB
Go
//go:build integration
|
|
|
|
package store
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/shcizo/package-updater/internal/master/model"
|
|
"github.com/shcizo/package-updater/internal/protocol"
|
|
)
|
|
|
|
func TestServicesByRepo(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
id := newAgent(t, s, "node-2")
|
|
other := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "o", ComposeService: "o", Image: "gitea.shcizo.se/shcizo/Slusk:1", Status: "running"}
|
|
gone := protocol.Service{Kind: protocol.KindCompose, ComposeProject: "g", ComposeService: "g", Image: "gitea.shcizo.se/shcizo/slusk:0.9", Status: "running"}
|
|
require.NoError(t, s.ApplySnapshot(ctx, id, worker, []protocol.Service{slusk, other, gone, adhoc}, t0))
|
|
require.NoError(t, s.RemoveService(ctx, id, "", gone.Key(), t0))
|
|
|
|
got, err := s.ServicesByRepo(ctx, "gitea.shcizo.se/shcizo/slusk")
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, []string{"slusk/web"}, names(got), "removed rows and rows of other (case-sensitive) repos are excluded")
|
|
assert.Equal(t, "node-2", got[0].AgentName)
|
|
|
|
none, err := s.ServicesByRepo(ctx, "nope")
|
|
require.NoError(t, err)
|
|
assert.Empty(t, none)
|
|
}
|
|
|
|
func TestSetAvailable_RoundTrip(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
_, svc := jobFixture(t, s, "a")
|
|
|
|
require.NoError(t, s.SetAvailable(ctx, svc, model.Available{Ref: "r:2", Source: model.SourceWebhook, At: t0}))
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "r:2", got.AvailableRef)
|
|
assert.Equal(t, model.SourceWebhook, got.AvailableSource)
|
|
require.NotNil(t, got.AvailableAt)
|
|
assert.True(t, t0.Equal(*got.AvailableAt))
|
|
}
|
|
|
|
func TestSetUpdateMode(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
|
|
require.NoError(t, s.SetUpdateMode(ctx, svc, model.ModeAuto))
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, model.ModeAuto, got.UpdateMode)
|
|
|
|
require.NoError(t, s.SetUpdateMode(ctx, svc, model.ModeManual))
|
|
got, _ = s.GetService(ctx, svc)
|
|
assert.Equal(t, model.ModeManual, got.UpdateMode)
|
|
|
|
assert.ErrorIs(t, s.SetUpdateMode(ctx, 99999, model.ModeAuto), model.ErrNotFound)
|
|
|
|
require.NoError(t, s.RemoveService(ctx, agent, "", slusk.Key(), t0))
|
|
assert.ErrorIs(t, s.SetUpdateMode(ctx, svc, model.ModeAuto), model.ErrNotFound)
|
|
}
|
|
|
|
func TestUpsertKeepsUpdateMode(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, model.ModeManual, got.UpdateMode, "a new service starts manual")
|
|
|
|
require.NoError(t, s.SetUpdateMode(ctx, svc, model.ModeAuto))
|
|
changed := slusk
|
|
changed.Image = "gitea.shcizo.se/shcizo/slusk:1.5.0"
|
|
require.NoError(t, s.UpsertService(ctx, agent, "", changed, t0.Add(time.Minute)))
|
|
require.NoError(t, s.ApplySnapshot(ctx, agent, worker, []protocol.Service{changed}, t0.Add(2*time.Minute)))
|
|
|
|
got, err = s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, model.ModeAuto, got.UpdateMode)
|
|
}
|
|
|
|
func TestFinishJob_ClearsAvailableOnlyWhenThatVersionWasDeployed(t *testing.T) {
|
|
succeed := model.JobFinish{Status: model.JobSucceeded, Ref: "r:2@sha256:d", StartedAt: t0, FinishedAt: t0}
|
|
tests := []struct {
|
|
name string
|
|
availableRef string
|
|
availableDigest string
|
|
availableAt time.Time // the job is created at t0
|
|
toRef string // the job's to_ref as created
|
|
finish model.JobFinish
|
|
wantCleared bool
|
|
}{
|
|
{"same ref, suggestion before the job", "r:2", "", t0.Add(-time.Minute), "r:2", succeed, true},
|
|
{"same ref, suggestion at the same instant", "r:2", "", t0, "r:2", succeed, true},
|
|
{"same ref, suggestion after the job was created", "r:2", "", t0.Add(time.Minute), "r:2", succeed, false},
|
|
{"different ref keeps the suggestion", "r:3", "", t0.Add(-time.Minute), "r:2", succeed, false},
|
|
{"failed job keeps the suggestion", "r:2", "", t0.Add(-time.Minute), "r:2",
|
|
model.JobFinish{Status: model.JobFailed, Error: "boom", StartedAt: t0, FinishedAt: t0}, false},
|
|
{"tag job clears a poll suggestion with a digest", "r:2", "sha256:new", t0.Add(-time.Minute), "r:2", succeed, true},
|
|
{"pick of the suggested digest clears it", "r:2", "sha256:new", t0.Add(-time.Minute), "r:2@sha256:new", succeed, true},
|
|
{"rollback to an older digest keeps the newer suggestion", "r:2", "sha256:new", t0.Add(-time.Minute), "r:2@sha256:old", succeed, false},
|
|
{"digest pick keeps a suggestion without digest", "r:2", "", t0.Add(-time.Minute), "r:2@sha256:old", succeed, false},
|
|
{"tagless pick keeps the suggestion", "r:2", "sha256:new", t0.Add(-time.Minute), "r@sha256:old", succeed, false},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
require.NoError(t, s.SetAvailable(ctx, svc, model.Available{Ref: tt.availableRef, Digest: tt.availableDigest, Source: model.SourcePoll, At: tt.availableAt}))
|
|
nj := newJob(svc, agent)
|
|
nj.ToRef = tt.toRef
|
|
j, err := s.CreateJob(ctx, nj)
|
|
require.NoError(t, err)
|
|
|
|
ok, err := s.FinishJob(ctx, agent, j.ID, tt.finish)
|
|
require.NoError(t, err)
|
|
require.True(t, ok)
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
if tt.wantCleared {
|
|
assert.Empty(t, got.AvailableRef)
|
|
assert.Empty(t, got.AvailableDigest)
|
|
assert.Empty(t, got.AvailableSource)
|
|
assert.Nil(t, got.AvailableAt)
|
|
} else {
|
|
assert.Equal(t, tt.availableRef, got.AvailableRef)
|
|
assert.Equal(t, tt.availableDigest, got.AvailableDigest)
|
|
assert.Equal(t, model.SourcePoll, got.AvailableSource)
|
|
assert.NotNil(t, got.AvailableAt)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFinishJob_WithoutAvailableLeavesItEmpty(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
j, err := s.CreateJob(ctx, newJob(svc, agent))
|
|
require.NoError(t, err)
|
|
|
|
ok, err := s.FinishJob(ctx, agent, j.ID, model.JobFinish{Status: model.JobSucceeded, Ref: "r:1@sha256:d", StartedAt: t0, FinishedAt: t0})
|
|
require.NoError(t, err)
|
|
require.True(t, ok)
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, got.AvailableRef)
|
|
assert.Nil(t, got.AvailableAt)
|
|
assert.Equal(t, "r:1@sha256:d", got.DesiredRef)
|
|
}
|
|
|
|
func TestFinishJob_RemembersTheDeployedDigestOfATagJob(t *testing.T) {
|
|
good := "sha256:" + strings.Repeat("a", 64)
|
|
old := "sha256:" + strings.Repeat("b", 64)
|
|
ok := func(ref string) model.JobFinish {
|
|
return model.JobFinish{Status: model.JobSucceeded, Ref: ref, StartedAt: t0, FinishedAt: t0}
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
trigger model.JobTrigger
|
|
toRef string
|
|
finish model.JobFinish
|
|
want string
|
|
}{
|
|
{"webhook tag job", model.TriggerWebhook, "r:2", ok("r:2@" + good), good},
|
|
{"manual tag job", model.TriggerManual, "r:2", ok("r:2@" + good), good},
|
|
{"poll tag job", model.TriggerPoll, "r:2", ok("r:2@" + good), good},
|
|
{"pinned pick leaves it", model.TriggerManual, "r:2@" + old, ok("r:2@" + old), "sha256:before"},
|
|
{"tagless pick leaves it", model.TriggerManual, "r@" + old, ok("r@" + old), "sha256:before"},
|
|
{"failed job leaves it", model.TriggerWebhook, "r:2",
|
|
model.JobFinish{Status: model.JobFailed, Error: "boom", Ref: "r:2@" + good, StartedAt: t0, FinishedAt: t0}, "sha256:before"},
|
|
{"malformed digest leaves it", model.TriggerWebhook, "r:2", ok("r:2@sha256:d"), "sha256:before"},
|
|
{"no pinned ref leaves it", model.TriggerWebhook, "r:2", ok(""), "sha256:before"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := openTestStore(t)
|
|
ctx := context.Background()
|
|
agent, svc := jobFixture(t, s, "a")
|
|
require.NoError(t, s.SetLastTagDigest(ctx, svc, "sha256:before"))
|
|
nj := newJob(svc, agent)
|
|
nj.ToRef, nj.Trigger = tt.toRef, tt.trigger
|
|
j, err := s.CreateJob(ctx, nj)
|
|
require.NoError(t, err)
|
|
|
|
done, err := s.FinishJob(ctx, agent, j.ID, tt.finish)
|
|
require.NoError(t, err)
|
|
require.True(t, done)
|
|
|
|
got, err := s.GetService(ctx, svc)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.want, got.LastTagDigest)
|
|
})
|
|
}
|
|
}
|