Add Task DB implementation using a local BoltDB.

build_scheduler/go/db/task_test.go

Index: build_scheduler/go/db/task_test.go
diff --git a/build_scheduler/go/db/task_test.go b/build_scheduler/go/db/task_test.go
index f3cdd0019ac19c5567e0acbdf964bad2e3351320..cbca008af1c4088277a74517260612f90a599ccf 100644
--- a/build_scheduler/go/db/task_test.go
+++ b/build_scheduler/go/db/task_test.go
@@ -1,7 +1,10 @@
 package db
 
 import (
+	"bytes"
+	"encoding/gob"
 	"fmt"
+	"sort"
 	"testing"
 	"time"
 
@@ -160,3 +163,114 @@ func TestUpdateFromSwarming(t *testing.T) {
 		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))
+}