Add Task DB implementation using a local BoltDB.

build_scheduler/go/db/task_test.go

 package db
 
 import (
+        "bytes"
+        "encoding/gob"
         "fmt"
+        "sort"
         "testing"
         "time"
 
         "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         assert "github.com/stretchr/testify/require"
 
         "go.skia.org/infra/go/testutils"
 )
 
 func TestUpdateFromSwarming(t *testing.T) {
@@ skipping 149 matching lines @@
                 Id:             "C",
                 Name:           "C",
                 Repo:           "C",
                 Revision:       "C",
                 Created:        now.Add(2 * time.Hour),
                 Status:         TASK_STATUS_FAILURE,
                 IsolatedOutput: "D",
                 Swarming:       s,
         })
 }
+
+// Test that sort.Sort(TaskSlice(...)) works correctly.
+func TestSort(t *testing.T) {
+        tasks := []*Task{}
+        addTask := func(ts time.Time) {
+                task := &Task{
+                        Created: ts,
+                }
+                tasks = append(tasks, task)
+        }
+
+        // Add tasks with various creation timestamps.
+        addTask(time.Date(2008, time.August, 8, 8, 8, 8, 8, time.UTC))               // 0
+        addTask(time.Date(1776, time.July, 4, 13, 0, 0, 0, time.UTC))                // 1
+        addTask(time.Date(2016, time.December, 31, 23, 59, 59, 999999999, time.UTC)) // 2
+        addTask(time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC))              // 3
+
+        // Manually sort.
+        expected := []*Task{tasks[1], tasks[3], tasks[0], tasks[2]}
+
+        sort.Sort(TaskSlice(tasks))
+
+        testutils.AssertDeepEqual(t, expected, tasks)
+}
+
+func TestTaskEncoder(t *testing.T) {
+        // TODO(benjaminwagner): Is there any way to cause an error?
+        e := TaskEncoder{}
+        expectedTasks := map[*Task][]byte{}
+        for i := 0; i < 25; i++ {
+                task := &Task{}
+                task.Id = fmt.Sprintf("Id-%d", i)
+                task.Name = "Bingo-was-his-name-o"
+                task.Commits = []string{fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i+1)}
+                var buf bytes.Buffer
+                err := gob.NewEncoder(&buf).Encode(task)
+                assert.NoError(t, err)
+                expectedTasks[task] = buf.Bytes()
+                assert.True(t, e.Process(task))
+        }
+
+        actualTasks := map[*Task][]byte{}
+        for task, serialized, err := e.Next(); task != nil; task, serialized, err = e.Next() {
+                assert.NoError(t, err)
+                actualTasks[task] = serialized
+        }
+        testutils.AssertDeepEqual(t, expectedTasks, actualTasks)
+}
+
+func TestTaskEncoderNoTasks(t *testing.T) {
+        e := TaskEncoder{}
+        task, serialized, err := e.Next()
+        assert.NoError(t, err)
+        assert.Nil(t, task)
+        assert.Nil(t, serialized)
+}
+
+func TestTaskDecoder(t *testing.T) {
+        d := TaskDecoder{}
+        expectedTasks := map[string]*Task{}
+        for i := 0; i < 25; i++ {
+                task := &Task{}
+                task.Id = fmt.Sprintf("Id-%d", i)
+                task.Name = "Bingo-was-his-name-o"
+                task.Commits = []string{fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i+1)}
+                var buf bytes.Buffer
+                err := gob.NewEncoder(&buf).Encode(task)
+                assert.NoError(t, err)
+                expectedTasks[task.Id] = task
+                assert.True(t, d.Process(buf.Bytes()))
+        }
+
+        actualTasks := map[string]*Task{}
+        result, err := d.Result()
+        assert.NoError(t, err)
+        assert.Equal(t, len(expectedTasks), len(result))
+        for _, task := range result {
+                actualTasks[task.Id] = task
+        }
+        testutils.AssertDeepEqual(t, expectedTasks, actualTasks)
+}
+
+func TestTaskDecoderNoTasks(t *testing.T) {
+        d := TaskDecoder{}
+        result, err := d.Result()
+        assert.NoError(t, err)
+        assert.Equal(t, 0, len(result))
+}
+
+func TestTaskDecoderError(t *testing.T) {
+        task := &Task{}
+        task.Id = "Id"
+        var buf bytes.Buffer
+        err := gob.NewEncoder(&buf).Encode(task)
+        assert.NoError(t, err)
+        serialized := buf.Bytes()
+        invalid := append([]byte("Hi Mom!"), serialized...)
+
+        d := TaskDecoder{}
+        // Process should return true before it encounters an invalid result.
+        assert.True(t, d.Process(serialized))
+        assert.True(t, d.Process(serialized))
+        // Process may return true or false after encountering an invalid value.
+        _ = d.Process(invalid)
+        _ = d.Process(serialized)
+
+        // Result should return error.
+        result, err := d.Result()
+        assert.Error(t, err)
+        assert.Equal(t, 0, len(result))
+}