Add database interface for shows and episode

This abstracts getting the data from the database. In the commit there
are 2 implementations: consul and sql.

Author: Wojciech Bednarzak

go.mod

@@ -5,8 +5,10 @@ go 1.16
 require (
 	cloud.google.com/go v0.78.0 // indirect
 	github.com/go-sql-driver/mysql v1.4.0
+	github.com/go-test/deep v1.0.7
 	github.com/gorilla/mux v1.6.2
 	github.com/gorilla/sessions v1.1.2
+	github.com/hashicorp/consul/api v1.8.1
 	github.com/mattn/go-sqlite3 v1.14.6
 	golang.org/x/net v0.0.0-20210119194325-5f4716e94777
 	golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99

go.sum

@@ -0,0 +1,96 @@
+package consul
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path"
+	"strings"
+
+	"github.com/hashicorp/consul/api"
+
+	"tracker/internal/database"
+)
+
+// Database contains methods for getting the data about shows and episodes
+type Database struct {
+	kv KV
+
+	prefix string
+}
+
+func NewDatabase(prefix string, opts ...Option) (*Database, error) {
+	client, err := api.NewClient(api.DefaultConfig())
+	if err != nil {
+		return nil, fmt.Errorf("unable to create client: %w", err)
+	}
+
+	db := &Database{
+		kv:     client.KV(),
+		prefix: prefix,
+	}
+
+	for _, opt := range opts {
+		opt(db)
+	}
+
+	return db, nil
+}
+
+// get value from the database
+func (db *Database) get(ctx context.Context, key string, value interface{}) error {
+	opt := &api.QueryOptions{}
+	opt = opt.WithContext(ctx)
+
+	p := path.Join(db.prefix, key)
+
+	kv, _, err := db.kv.Get(p, opt)
+	if err != nil {
+		return fmt.Errorf("unable to fetch %s: %w", p, err)
+	}
+	if kv == nil {
+		return fmt.Errorf("%s not found: %w", p, database.ErrNotFound)
+	}
+
+	if err := json.Unmarshal(kv.Value, value); err != nil {
+		return fmt.Errorf("unable to unmarshal data: %w", err)
+	}
+
+	return nil
+}
+
+func (db *Database) list(ctx context.Context, prefix string) (map[string][]byte, error) {
+	opt := &api.QueryOptions{}
+	opt = opt.WithContext(ctx)
+
+	p := path.Join(db.prefix, prefix)
+
+	kvs, _, err := db.kv.List(p, opt)
+	if err != nil {
+		return nil, fmt.Errorf("unable to list %s: %w", p, err)
+	}
+
+	m := make(map[string][]byte, len(kvs))
+	for _, kv := range kvs {
+		// Remove all the prefixes from the keys.
+		m[strings.TrimPrefix(kv.Key, p+"/")] = kv.Value
+	}
+
+	return m, nil
+}
+
+// Option allows to set options for the Consul database.
+type Option func(*Database)
+
+func KVClient(kv KV) Option {
+	return func(db *Database) {
+		db.kv = kv
+	}
+}
+
+// KV abstracts over consul KV interface, for testability
+type KV interface {
+	Put(p *api.KVPair, q *api.WriteOptions) (*api.WriteMeta, error)
+	Get(key string, q *api.QueryOptions) (*api.KVPair, *api.QueryMeta, error)
+	List(prefix string, q *api.QueryOptions) (api.KVPairs, *api.QueryMeta, error)
+}

internal/database/consul/database.go

@@ -0,0 +1,81 @@
+package consul
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path"
+
+	"tracker/internal/types/show"
+)
+
+type ShowsDatabase struct {
+	db     *Database
+	prefix string
+}
+
+func (db *Database) Shows() *ShowsDatabase {
+	return &ShowsDatabase{
+		db:     db,
+		prefix: "shows",
+	}
+}
+
+func (db *ShowsDatabase) List(ctx context.Context) ([]*show.Show, error) {
+	showIDs, err := db.list(ctx, "list")
+	if err != nil {
+		return nil, fmt.Errorf("unable to get show IDs")
+	}
+
+	// TODO: Speed up by running these in parallel
+	var shows []*show.Show
+	for showID := range showIDs {
+		show, err := db.showDetails(ctx, showID)
+		if err != nil {
+			return nil, fmt.Errorf("unable to get show %s: %w", showID, err)
+		}
+		shows = append(shows, show)
+	}
+
+	return shows, nil
+}
+
+func (db *ShowsDatabase) Details(ctx context.Context, id string) (*show.Show, error) {
+	// TODO: Run getting show details and show episodes in parallel
+	s, err := db.showDetails(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("unable to get details about %s: %w", id, err)
+	}
+
+	episodes, err := db.list(ctx, path.Join("episodes", id))
+	if err != nil {
+		return nil, fmt.Errorf("unable to get episodes for %s: %w", id, err)
+	}
+
+	for _, ep := range episodes {
+		var episode show.Episode
+		if err := json.Unmarshal(ep, &episode); err != nil {
+			return nil, fmt.Errorf("unable to parse episode: %w", err)
+		}
+		s.Episodes = append(s.Episodes, &episode)
+	}
+
+	return s, nil
+}
+
+func (db *ShowsDatabase) showDetails(ctx context.Context, id string) (*show.Show, error) {
+	var show show.Show
+	if err := db.get(ctx, path.Join("list", id), &show); err != nil {
+		return nil, err
+	}
+
+	return &show, nil
+}
+
+func (db *ShowsDatabase) get(ctx context.Context, key string, value interface{}) error {
+	return db.db.get(ctx, path.Join(db.prefix, key), value)
+}
+
+func (db *ShowsDatabase) list(ctx context.Context, prefix string) (map[string][]byte, error) {
+	return db.db.list(ctx, path.Join(db.prefix, prefix))
+}

internal/database/consul/shows.go

@@ -0,0 +1,100 @@
+package consul
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"tracker/internal/types/show"
+
+	"github.com/go-test/deep"
+	"github.com/hashicorp/consul/api"
+)
+
+var errNotFound = errors.New("kv: not found")
+
+var testData = map[string][]byte{
+	"tracker/shows/list/westworld":            []byte(`{"id": 1, "name": "Westworld"}`),
+	"tracker/shows/episodes/westworld_s01e01": []byte(`{"title":"The Original", "season": 1, "episode": 1}`),
+
+	"tracker/shows/list/expanse": []byte(`{"id": 2, "name": "The Expanse"}`),
+}
+
+func TestList(t *testing.T) {
+	kv := &testKV{m: testData}
+	db, err := NewDatabase("tracker", KVClient(kv))
+	if err != nil {
+		t.Fatalf("unable to setup database: %v", err)
+	}
+
+	showsDB := db.Shows()
+
+	want := []*show.Show{
+		{ID: 2, Name: "The Expanse"},
+		{ID: 1, Name: "Westworld"},
+	}
+
+	got, err := showsDB.List(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error listing shows: %v", err)
+	}
+
+	if diff := deep.Equal(got, want); diff != nil {
+		t.Fatalf("List() = %v, want %v, diff = %v", got, want, diff)
+	}
+}
+
+func TestDetails(t *testing.T) {
+	kv := &testKV{m: testData}
+	db, err := NewDatabase("tracker", KVClient(kv))
+	if err != nil {
+		t.Fatalf("unable to setup database: %v", err)
+	}
+
+	showsDB := db.Shows()
+
+	want := &show.Show{
+		ID:   1,
+		Name: "Westworld",
+		Episodes: []*show.Episode{
+			{Title: "The Original", Season: 1, Episode: 1},
+		},
+	}
+
+	got, err := showsDB.Details(context.Background(), "westworld")
+	if err != nil {
+		t.Fatalf("unexpected error getting details: %v", err)
+	}
+
+	if diff := deep.Equal(got, want); diff != nil {
+		t.Fatalf("Details() = %v, want %v, diff = %v", got, want, diff)
+	}
+
+}
+
+type testKV struct {
+	m map[string][]byte
+}
+
+func (kv *testKV) Get(key string, _ *api.QueryOptions) (*api.KVPair, *api.QueryMeta, error) {
+	if v, exists := kv.m[key]; exists {
+		return &api.KVPair{Key: key, Value: v}, nil, nil
+	} else {
+		return nil, nil, errNotFound
+	}
+}
+
+func (kv *testKV) List(prefix string, _ *api.QueryOptions) (api.KVPairs, *api.QueryMeta, error) {
+	var pairs []*api.KVPair
+	for key, value := range kv.m {
+		if strings.HasPrefix(key, prefix) {
+			pairs = append(pairs, &api.KVPair{Key: key, Value: value})
+		}
+	}
+
+	return api.KVPairs(pairs), nil, nil
+}
+
+func (kv *testKV) Put(_ *api.KVPair, _ *api.WriteOptions) (*api.WriteMeta, error) {
+	return nil, nil
+}

internal/database/consul/shows_test.go

@@ -0,0 +1,28 @@
+package database
+
+import (
+	"context"
+	"tracker/internal/types/show"
+)
+
+type Error string
+
+func (e Error) Error() string {
+	return string(e)
+}
+
+const (
+	ErrNotFound = Error("not found")
+)
+
+// Database
+type Database interface {
+	Shows() ShowsDatabase
+}
+
+type ShowsDatabase interface {
+	// List returns the list of shows. The episode list is empty in each show.
+	List(context.Context) ([]*show.Show, error)
+	// Details gives details about a show by a show ID, including the episodes.
+	Details(context.Context, int) (*show.Show, error)
+}

internal/database/database.go

@@ -0,0 +1,11 @@
+package sql
+
+import "database/sql"
+
+type Database struct {
+	db *sql.DB
+}
+
+func NewDatabase(db *sql.DB) *Database {
+	return &Database{db: db}
+}