| package recent_rolls |
| |
| import ( |
| "context" |
| "testing" |
| "time" |
| |
| "github.com/google/uuid" |
| "github.com/stretchr/testify/require" |
| "go.skia.org/infra/go/autoroll" |
| "go.skia.org/infra/go/deepequal/assertdeep" |
| "go.skia.org/infra/go/ds" |
| "go.skia.org/infra/go/ds/testutil" |
| ) |
| |
| // TestRecentRolls verifies that we correctly track roll history. |
| func TestRecentRolls(t *testing.T) { |
| ctx := context.Background() |
| testutil.InitDatastore(t, ds.KIND_AUTOROLL_ROLL) |
| |
| // Create the RecentRolls. |
| r, err := NewRecentRolls(ctx, NewDatastoreRollsDB(ctx), "test-roller") |
| require.NoError(t, err) |
| |
| // Use this function for checking expectations. |
| check := func(current, last *autoroll.AutoRollIssue, history []*autoroll.AutoRollIssue) { |
| assertdeep.Equal(t, history, r.GetRecentRolls()) |
| assertdeep.Equal(t, current, r.CurrentRoll()) |
| assertdeep.Equal(t, last, r.LastRoll()) |
| } |
| |
| // Add one issue. |
| now := time.Now().UTC() |
| ari1 := &autoroll.AutoRollIssue{ |
| Closed: false, |
| Committed: false, |
| Created: now, |
| IsDryRun: false, |
| Issue: 1010101, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_IN_PROGRESS, |
| Subject: "FAKE DEPS ROLL 1", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| expect := []*autoroll.AutoRollIssue{ari1} |
| require.NoError(t, r.Add(ctx, ari1)) |
| check(ari1, nil, expect) |
| |
| // Try to add it again. We should log an error but not fail. |
| require.NoError(t, r.Add(ctx, ari1)) |
| check(ari1, nil, expect) |
| |
| // Close the issue as successful. Ensure that it's now the last roll |
| // instead of the current roll. |
| ari1.Closed = true |
| ari1.Committed = true |
| ari1.CqFinished = true |
| ari1.CqSuccess = true |
| ari1.Result = autoroll.ROLL_RESULT_SUCCESS |
| require.NoError(t, r.Update(ctx, ari1)) |
| check(nil, ari1, expect) |
| |
| // Add another issue. Ensure that it's the current roll with the |
| // previously-added roll as the last roll. |
| now = time.Now().UTC() |
| ari2 := &autoroll.AutoRollIssue{ |
| Closed: false, |
| Committed: false, |
| Created: now, |
| Issue: 1010102, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_IN_PROGRESS, |
| Subject: "FAKE DEPS ROLL 2", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| require.NoError(t, r.Add(ctx, ari2)) |
| expect = []*autoroll.AutoRollIssue{ari2, ari1} |
| check(ari2, ari1, expect) |
| |
| // Try to add another active issue. We should log an error but not fail. |
| now = time.Now().UTC() |
| ari3 := &autoroll.AutoRollIssue{ |
| Closed: false, |
| Committed: false, |
| Created: now, |
| Issue: 1010103, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_IN_PROGRESS, |
| Subject: "FAKE DEPS ROLL 3", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| require.NoError(t, r.Add(ctx, ari3)) |
| expect = []*autoroll.AutoRollIssue{ari3, ari2, ari1} |
| check(ari3, ari2, expect) |
| |
| // Close the issue as failed. Ensure that it's now the last roll |
| // instead of the current roll. |
| ari2.Closed = true |
| ari2.Committed = false |
| ari2.CqFinished = true |
| ari2.CqSuccess = false |
| ari2.Result = autoroll.ROLL_RESULT_FAILURE |
| require.NoError(t, r.Update(ctx, ari2)) |
| check(ari3, ari2, expect) |
| |
| // Same with ari3. |
| ari3.Closed = true |
| ari3.Committed = false |
| ari3.CqFinished = true |
| ari3.CqSuccess = false |
| ari3.Result = autoroll.ROLL_RESULT_FAILURE |
| require.NoError(t, r.Update(ctx, ari3)) |
| check(nil, ari3, expect) |
| |
| // Try to add a bogus issue. |
| now = time.Now().UTC() |
| bad2 := &autoroll.AutoRollIssue{ |
| Closed: false, |
| Committed: true, |
| Created: now, |
| Issue: 1010104, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_FAILURE, |
| Subject: "FAKE DEPS ROLL 4", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| require.Error(t, r.Add(ctx, bad2)) |
| |
| // Add one more roll. Ensure that it's the current roll. |
| now = time.Now().UTC() |
| ari4 := &autoroll.AutoRollIssue{ |
| Closed: false, |
| Committed: false, |
| Created: now, |
| Issue: 1010105, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_IN_PROGRESS, |
| Subject: "FAKE DEPS ROLL 5", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| require.NoError(t, r.Add(ctx, ari4)) |
| expect = []*autoroll.AutoRollIssue{ari4, ari3, ari2, ari1} |
| check(ari4, ari3, expect) |
| } |
| |
| func TestRecentRolls_NumFailuresAndLastSucessfulRollTime(t *testing.T) { |
| ctx := context.Background() |
| testutil.InitDatastore(t, ds.KIND_AUTOROLL_ROLL) |
| |
| db := NewDatastoreRollsDB(ctx) |
| r, err := NewRecentRolls(ctx, NewDatastoreRollsDB(ctx), "test-roller") |
| require.NoError(t, err) |
| |
| issue := int64(0) |
| const startTs int64 = 1678218051 |
| now := time.Unix(startTs, 0) // Arbitrary starting point. |
| createAndInsertRoll := func(result string) { |
| issue += 1 |
| now = now.Add(time.Second) |
| require.NoError(t, db.Put(ctx, r.roller, &autoroll.AutoRollIssue{ |
| Closed: true, |
| Committed: result != autoroll.ROLL_RESULT_IN_PROGRESS, |
| Created: now, |
| Issue: issue, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: result, |
| Subject: "fake roll", |
| TryResults: []*autoroll.TryResult(nil), |
| })) |
| } |
| |
| // One successful roll followed by a number of failures. We should see the |
| // correct number of failed rolls and the timestamp of the successful roll. |
| createAndInsertRoll(autoroll.ROLL_RESULT_SUCCESS) |
| for i := 0; i < 2*RecentRollsLength; i++ { |
| createAndInsertRoll(autoroll.ROLL_RESULT_FAILURE) |
| } |
| require.NoError(t, r.refreshRecentRolls(ctx)) |
| |
| require.Equal(t, 2*RecentRollsLength, r.NumFailedRolls()) |
| require.Equal(t, time.Unix(startTs+int64(1), 0), r.LastSuccessfulRollTime()) |
| |
| // Add a new successful roll. The number of failures should be zero, and |
| // last successful roll timestamp should be updated. |
| createAndInsertRoll(autoroll.ROLL_RESULT_SUCCESS) |
| require.NoError(t, r.refreshRecentRolls(ctx)) |
| require.Equal(t, 0, r.NumFailedRolls()) |
| require.Equal(t, time.Unix(startTs+int64(2*RecentRollsLength+2), 0), r.LastSuccessfulRollTime()) |
| |
| // Add an in-progress roll. It shouldn't throw off the number of failures. |
| createAndInsertRoll(autoroll.ROLL_RESULT_IN_PROGRESS) |
| require.NoError(t, r.refreshRecentRolls(ctx)) |
| require.Equal(t, 0, r.NumFailedRolls()) |
| require.Equal(t, time.Unix(startTs+int64(2*RecentRollsLength+2), 0), r.LastSuccessfulRollTime()) |
| } |
| |
| func TestDatastoreRollsDB_GetRolls(t *testing.T) { |
| ctx := context.Background() |
| testutil.InitDatastore(t, ds.KIND_AUTOROLL_ROLL) |
| db := NewDatastoreRollsDB(ctx) |
| roller := uuid.New().String() |
| |
| issue := int64(0) |
| now := time.Unix(1678218051, 0) // Arbitrary starting point. |
| makeRoll := func() *autoroll.AutoRollIssue { |
| issue += 1 |
| now = now.Add(time.Second) |
| return &autoroll.AutoRollIssue{ |
| Closed: true, |
| Committed: true, |
| Created: now, |
| Issue: issue, |
| Modified: now, |
| Patchsets: []int64{1}, |
| Result: autoroll.ROLL_RESULT_SUCCESS, |
| Subject: "fake roll", |
| TryResults: []*autoroll.TryResult(nil), |
| } |
| } |
| |
| // Ensure no error when no rolls exist. |
| rolls, cursor, err := db.GetRolls(ctx, roller, "") |
| require.NoError(t, err) |
| require.Equal(t, "", cursor) |
| require.Equal(t, 0, len(rolls)) |
| |
| // Insert a single roll. |
| r1 := makeRoll() |
| require.NoError(t, db.Put(ctx, roller, r1)) |
| rolls, cursor, err = db.GetRolls(ctx, roller, "") |
| require.NoError(t, err) |
| require.Equal(t, "", cursor) |
| require.Equal(t, 1, len(rolls)) |
| require.Equal(t, rolls[0], r1) |
| |
| // Insert enough rolls to necessitate multiple pages. |
| for i := 0; i < 3*loadRollsPageSize; i++ { |
| require.NoError(t, db.Put(ctx, roller, makeRoll())) |
| } |
| allRolls := []*autoroll.AutoRollIssue{} |
| // Batch 1. |
| rolls, cursor, err = db.GetRolls(ctx, roller, "") |
| require.NoError(t, err) |
| require.NotEqual(t, "", cursor) |
| require.Equal(t, loadRollsPageSize, len(rolls)) |
| allRolls = append(allRolls, rolls...) |
| // Batch 2. |
| rolls, cursor, err = db.GetRolls(ctx, roller, cursor) |
| require.NoError(t, err) |
| require.NotEqual(t, "", cursor) |
| require.Equal(t, loadRollsPageSize, len(rolls)) |
| allRolls = append(allRolls, rolls...) |
| // Batch 3. |
| rolls, cursor, err = db.GetRolls(ctx, roller, cursor) |
| require.NoError(t, err) |
| require.NotEqual(t, "", cursor) |
| require.Equal(t, loadRollsPageSize, len(rolls)) |
| allRolls = append(allRolls, rolls...) |
| // Batch 4. Only one roll left to retrieve. Cursor should be empty. |
| rolls, cursor, err = db.GetRolls(ctx, roller, cursor) |
| require.NoError(t, err) |
| require.Equal(t, "", cursor) |
| require.Equal(t, 1, len(rolls)) |
| allRolls = append(allRolls, rolls...) |
| // Ensure that we found all of the rolls we expected. |
| require.Equal(t, 76, len(allRolls)) |
| |
| // Test Get(). |
| for _, expect := range allRolls { |
| actual, err := db.Get(ctx, roller, expect.Issue) |
| require.NoError(t, err) |
| require.Equal(t, expect, actual) |
| } |
| } |
