feat: initial commit

pkg/storage/testsuite/blob_store.go

@@ -0,0 +1,14 @@
+package testsuite
+
+import (
+	"testing"
+
+	"forge.cadoles.com/arcad/edge/pkg/storage"
+)
+
+func TestBlobStore(t *testing.T, store storage.BlobStore) {
+	t.Run("Ops", func(t *testing.T) {
+		// t.Parallel()
+		testBlobStoreOps(t, store)
+	})
+}

pkg/storage/testsuite/blob_store_ops.go

@@ -0,0 +1,129 @@
+package testsuite
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"testing"
+
+	"forge.cadoles.com/arcad/edge/pkg/storage"
+	"github.com/pkg/errors"
+)
+
+type blobStoreTestCase struct {
+	Name string
+	Run  func(ctx context.Context, store storage.BlobStore) error
+}
+
+var blobStoreTestCases = []blobStoreTestCase{
+	{
+		Name: "Open new bucket",
+		Run: func(ctx context.Context, store storage.BlobStore) error {
+			bucket, err := store.OpenBucket(ctx, "open-new-bucket")
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			if bucket == nil {
+				return errors.New("bucket should not be nil")
+			}
+
+			size, err := bucket.Size(ctx)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			if e, g := int64(0), size; e != g {
+				return errors.Errorf("bucket size: expected '%v', got '%v'", e, g)
+			}
+
+			blobs, err := bucket.List(ctx)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			if e, g := 0, len(blobs); e != g {
+				return errors.Errorf("len(blobs): expected '%v', got '%v'", e, g)
+			}
+
+			if err := bucket.Close(); err != nil {
+				return errors.WithStack(err)
+			}
+
+			return nil
+		},
+	},
+	{
+		Name: "Create blob",
+		Run: func(ctx context.Context, store storage.BlobStore) error {
+			bucket, err := store.OpenBucket(ctx, "create-blob")
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			blobID := storage.NewBlobID()
+
+			writer, err := bucket.NewWriter(ctx, blobID)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			data := []byte("foo")
+
+			written, err := writer.Write(data)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			if e, g := len(data), written; e != g {
+				return errors.Errorf("length of written data: expected '%v', got '%v'", e, g)
+			}
+
+			if err := writer.Close(); err != nil {
+				panic(errors.WithStack(err))
+			}
+
+			reader, err := bucket.NewReader(ctx, blobID)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			var buf bytes.Buffer
+
+			written64, err := io.Copy(&buf, reader)
+			if err != nil {
+				return errors.WithStack(err)
+			}
+
+			if e, g := int64(len(data)), written64; e != g {
+				return errors.Errorf("length of written data: expected '%v', got '%v'", e, g)
+			}
+
+			if err := reader.Close(); err != nil {
+				panic(errors.WithStack(err))
+			}
+
+			if err := bucket.Close(); err != nil {
+				return errors.WithStack(err)
+			}
+
+			return nil
+		},
+	},
+}
+
+func testBlobStoreOps(t *testing.T, store storage.BlobStore) {
+	for _, tc := range blobStoreTestCases {
+		func(tc blobStoreTestCase) {
+			t.Run(tc.Name, func(t *testing.T) {
+				t.Parallel()
+
+				ctx := context.Background()
+
+				if err := tc.Run(ctx, store); err != nil {
+					t.Errorf("%+v", errors.WithStack(err))
+				}
+			})
+		}(tc)
+	}
+}

pkg/storage/testsuite/document_store.go

@@ -0,0 +1,14 @@
+package testsuite
+
+import (
+	"testing"
+
+	"forge.cadoles.com/arcad/edge/pkg/storage"
+)
+
+func TestDocumentStore(t *testing.T, store storage.DocumentStore) {
+	t.Run("Query", func(t *testing.T) {
+		// t.Parallel()
+		testDocumentStoreQuery(t, store)
+	})
+}

pkg/storage/testsuite/document_store_query.go

@@ -0,0 +1,85 @@
+package testsuite
+
+import (
+	"context"
+	"testing"
+
+	"forge.cadoles.com/arcad/edge/pkg/storage"
+	"forge.cadoles.com/arcad/edge/pkg/storage/filter"
+	"github.com/pkg/errors"
+)
+
+type documentStoreQueryTestCase struct {
+	Name              string
+	Before            func(ctx context.Context, store storage.DocumentStore) error
+	Collection        string
+	Filter            *filter.Filter
+	QueryOptionsFuncs []storage.QueryOptionFunc
+	After             func(t *testing.T, results []storage.Document, err error)
+}
+
+var documentStoreQueryTestCases = []documentStoreQueryTestCase{
+	{
+		Name: "Simple select",
+		Before: func(ctx context.Context, store storage.DocumentStore) error {
+			doc1 := storage.Document{
+				"attr1": "Foo",
+			}
+
+			if _, err := store.Upsert(ctx, "simple_select", doc1); err != nil {
+				return errors.WithStack(err)
+			}
+
+			doc2 := storage.Document{
+				"attr1": "Bar",
+			}
+
+			if _, err := store.Upsert(ctx, "simple_select", doc2); err != nil {
+				return errors.WithStack(err)
+			}
+
+			return nil
+		},
+		Collection: "simple_select",
+		Filter: filter.New(
+			filter.NewEqOperator(map[string]interface{}{
+				"attr1": "Foo",
+			}),
+		),
+		After: func(t *testing.T, results []storage.Document, err error) {
+			if err != nil {
+				t.Fatalf("%+v", errors.WithStack(err))
+			}
+
+			if e, g := 1, len(results); e != g {
+				t.Errorf("len(results): expected '%v', got '%v'", e, g)
+			}
+
+			if e, g := "Foo", results[0]["attr1"]; e != g {
+				t.Errorf("results[0][\"Attr1\"]: expected '%v', got '%v'", e, g)
+			}
+		},
+	},
+}
+
+func testDocumentStoreQuery(t *testing.T, store storage.DocumentStore) {
+	for _, tc := range documentStoreQueryTestCases {
+		func(tc documentStoreQueryTestCase) {
+			t.Run(tc.Name, func(t *testing.T) {
+				// t.Parallel()
+
+				ctx := context.Background()
+
+				if tc.Before != nil {
+					if err := tc.Before(ctx, store); err != nil {
+						t.Fatalf("%+v", errors.WithStack(err))
+					}
+				}
+
+				documents, err := store.Query(ctx, tc.Collection, tc.Filter, tc.QueryOptionsFuncs...)
+
+				tc.After(t, documents, err)
+			})
+		}(tc)
+	}
+}