go/src/v.io/x/playground/lib/storage/model_test.go - release.projects.playground - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Tests for the storage model.
 // These tests only test the exported API of the storage model.
 //
 // NOTE: These tests cannot be run in parallel on the same machine because they
 // interact with a fixed database on the machine.

 package storage_test

 import (
 	"fmt"
 	"testing"

 	"github.com/rubenv/sql-migrate"

 	"v.io/x/lib/dbutil"
 	"v.io/x/playground/lib/storage"
 )

 var (
 	dataSourceName = "playground_test@tcp(localhost:3306)/playground_test?parseTime=true"
 )

 // setup cleans the database, runs migrations, and connects to the database.
 // It returns a teardown function that closes the database connection.
 func setup(t *testing.T) func() {
 	// Migrate down then up.
 	migrations := &migrate.FileMigrationSource{
 		Dir: "../../migrations",
 	}
 	migrate.SetTable("migrations")

 	sqlConfig := dbutil.SqlConfig{
 		DataSourceName: dataSourceName,
 		TLSDisable:     true,
 	}
 	activeSqlConfig, err := sqlConfig.Activate("")

 	db, err := activeSqlConfig.NewSqlDBConn("SERIALIZABLE")
 	if err != nil {
 		t.Fatalf("Error opening database: %v", err)
 	}

 	// Remove any existing tables.
 	tableNames := []string{"bundle_link", "bundle_data", "migrations"}
 	for _, tableName := range tableNames {
 		db.Exec("DROP TABLE " + tableName)
 	}

 	if _, err = migrate.Exec(db, "mysql", migrations, migrate.Up); err != nil {
 		t.Fatalf("Error migrating up: %v", err)
 	}
 	if err := db.Close(); err != nil {
 		t.Fatalf("db.Close() failed: %v", err)
 	}

 	// Connect to the storage.
 	if err := storage.Connect(activeSqlConfig); err != nil {
 		t.Fatalf("storage.Connect(%v) failed: %v", activeSqlConfig, err)
 	}

 	teardown := func() {
 		if err := storage.Close(); err != nil {
 			t.Fatalf("storage.Close() failed: %v", err)
 		}
 	}
 	return teardown
 }

 func TestGetBundleDataByLinkId(t *testing.T) {
 	defer setup(t)()

 	// Get with a unknown id should return ErrNotFound.
 	id := "foobar"
 	if _, _, err := storage.GetBundleByLinkIdOrSlug(id); err != storage.ErrNotFound {
 		t.Errorf("Expected GetBundleByLinkIdOrSlug with unknown id to return ErrNotFound, but instead got: %v", err)
 	}

 	// Add a bundle.
 	json := "mock_json_data"
 	bLink, _, err := storage.StoreBundleLinkAndData(json)
 	if err != nil {
 		t.Fatalf("Expected StoreBundleLinkAndData(%v) not to error, but got: %v", json, err)
 	}

 	// Bundle should exist.
 	gotBLink, gotBdata, err := storage.GetBundleByLinkIdOrSlug(bLink.Id)
 	if err != nil {
 		t.Errorf("Expected GetBundleDataByLinkIdOrSlug(%v) not to error, but got: %v", bLink.Id, err)
 	}

 	// Bundle should have expected id.
 	if got, want := gotBLink.Id, bLink.Id; got != want {
 		t.Errorf("Expected %v to equal %v.", got, want)
 	}

 	// Bundle should have expected json.
 	if got, want := gotBdata.Json, string(json); got != want {
 		t.Errorf("Expected %v to equal %v.", got, want)
 	}
 }

 func assertValidLinkDataPair(json string, bLink *storage.BundleLink, bData *storage.BundleData) error {
 	if string(bLink.Hash) != string(bData.Hash) {
 		return fmt.Errorf("Expected %v to equal %v", string(bLink.Hash), string(bData.Hash))
 	}

 	if bLink.Id == "" {
 		return fmt.Errorf("Expected bundle link to have id.")
 	}

 	if bData.Json != json {
 		return fmt.Errorf("Expected %v to equal %v", bData.Json, json)
 	}
 	return nil
 }

 func TestStoreBundleLinkAndData(t *testing.T) {
 	defer setup(t)()

 	mockJson := "bizbaz"

 	// Storing the json once should succeed.
 	bLink1, bData1, err := storage.StoreBundleLinkAndData(mockJson)
 	if err != nil {
 		t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson, err)
 	}
 	if err := assertValidLinkDataPair(string(mockJson), bLink1, bData1); err != nil {
 		t.Fatalf("Got invalid link data pair: %v", err)
 	}

 	// Storing the bundle again should succeed.
 	bLink2, bData2, err := storage.StoreBundleLinkAndData(mockJson)
 	if err != nil {
 		t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson, err)
 	}
 	if err := assertValidLinkDataPair(string(mockJson), bLink2, bData2); err != nil {
 		t.Errorf("Got invalid link data pair: %v", err)
 	}

 	// Bundle links should have different ids.
 	if bLink1.Id == bLink2.Id {
 		t.Errorf("Expected bundle links to have different ids, but got %v and %v", bLink1.Id, bLink2.Id)
 	}

 	// Bundle datas should have equal hashes.
 	if want, got := string(bData1.Hash), string(bData2.Hash); want != got {
 		t.Errorf("Expected bundle datas to have equal hashes, but got %v and %v", want, got)
 	}
 }

 func makeMockNamedBundle(mockSlug, mockJson string) *storage.NewBundle {
 	return &storage.NewBundle{
 		BundleDesc: storage.BundleDesc{
 			Slug: storage.EmptyNullString(mockSlug),
 		},
 		Json: mockJson,
 	}
 }

 func expectDefaultBundles(got []*storage.BundleLink, want []*storage.NewBundle) error {
 	if len(got) != len(want) {
 		return fmt.Errorf("Expected %d, got %d bundles.", len(want), len(got))
 	}

 	for _, listBLink := range got {
 		// For each listed BundleLink, get corresponding BundleData.
 		gotBLink, gotBData, err := storage.GetBundleByLinkIdOrSlug(listBLink.Id)
 		if err != nil {
 			return fmt.Errorf("Expected GetBundleDataByLinkIdOrSlug(%v) not to error, but got: %v", listBLink.Id, err)
 		}

 		// Check that the bundle is non-anonymous and default.
 		if gotBLink.Slug == "" {
 			return fmt.Errorf("Expected bundle for %v to have non-empty slug", gotBLink.Id)
 		}
 		if !gotBLink.IsDefault {
 			return fmt.Errorf("Expected bundle %v to be marked as default", gotBLink.Slug)
 		}

 		// Find expected NewBundle with slug matching the retrieved bundle.
 		var original *storage.NewBundle
 		for _, newBundle := range want {
 			if newBundle.Slug == gotBLink.Slug {
 				original = newBundle
 				break
 			}
 		}
 		if original == nil {
 			return fmt.Errorf("Unexpected bundle with slug %v", gotBLink.Slug)
 		}

 		// Check that the retrieved bundle is valid and matches expected JSON.
 		if err := assertValidLinkDataPair(original.Json, gotBLink, gotBData); err != nil {
 			return fmt.Errorf("Got invalid link data pair: %v", err)
 		}
 	}
 	return nil
 }

 func expectNonDefaultBundle(bId, wantJson string) error {
 	bLink, bData, err := storage.GetBundleByLinkIdOrSlug(bId)
 	if err != nil {
 		return fmt.Errorf("GetBundleDataByLinkIdOrSlug(%v) failed: %v", bId, err)
 	}
 	if bLink.Slug != "" {
 		return fmt.Errorf("Expected anonymous bundle for %v, got slug %v", bId, bLink.Slug)
 	}
 	if bLink.IsDefault {
 		return fmt.Errorf("Expected non-default bundle for %v", bId)
 	}
 	if err := assertValidLinkDataPair(wantJson, bLink, bData); err != nil {
 		return fmt.Errorf("Got invalid link data pair: %v", err)
 	}
 	return nil
 }

 func TestDefaultBundles(t *testing.T) {
 	defer setup(t)()

 	mockSlugs := []string{"one", "two", "three", "four"}
 	mockJson := []string{"forty-two", "forty-seven", "leet"}

 	defBundlesA := []*storage.NewBundle{
 		makeMockNamedBundle(mockSlugs[0], mockJson[0]),
 		makeMockNamedBundle(mockSlugs[1], mockJson[0]),
 	}

 	// Storing default bundles should succeed.
 	if err := storage.ReplaceDefaultBundles(defBundlesA); err != nil {
 		t.Fatalf("A: ReplaceDefaultBundles(%v) failed: %v", defBundlesA, err)
 	}

 	// Storing a non-default bundle should succeed.
 	nondBLink, _, err := storage.StoreBundleLinkAndData(mockJson[2])
 	if err != nil {
 		t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson[2], err)
 	}

 	defBundlesDup := []*storage.NewBundle{
 		makeMockNamedBundle(mockSlugs[1], mockJson[1]),
 		makeMockNamedBundle(mockSlugs[1], mockJson[1]),
 	}

 	// Trying to store default bundles with duplicate slugs should fail and be
 	// rolled back (not affect subsequent assertions).
 	if err := storage.ReplaceDefaultBundles(defBundlesDup); err == nil {
 		t.Fatalf("Dup: ReplaceDefaultBundles(%v) with duplicate slugs should have failed", defBundlesDup)
 	}

 	// Listing default bundles should succeed.
 	storedDefBundlesA, err := storage.GetDefaultBundleList()
 	if err != nil {
 		t.Fatalf("A: GetDefaultBundleList() failed: %v", err)
 	}

 	// Default bundle list should not contain the non-default bundle.
 	if err := expectDefaultBundles(storedDefBundlesA, defBundlesA); err != nil {
 		t.Errorf("A: Default bundle mismatch: %v", err)
 	}

 	// Non-default bundle should be untouched.
 	if err := expectNonDefaultBundle(nondBLink.Id, mockJson[2]); err != nil {
 		t.Errorf("Non-default bundle mismatch: %v", err)
 	}

 	defBundlesB := []*storage.NewBundle{
 		makeMockNamedBundle(mockSlugs[1], mockJson[2]),
 		makeMockNamedBundle(mockSlugs[2], mockJson[1]),
 		makeMockNamedBundle(mockSlugs[3], mockJson[0]),
 	}

 	// Replacing default bundles should succeed.
 	if err := storage.ReplaceDefaultBundles(defBundlesB); err != nil {
 		t.Fatalf("B: ReplaceDefaultBundles(%v) failed: %v", defBundlesB, err)
 	}

 	// Listing default bundles should succeed.
 	storedDefBundlesB, err := storage.GetDefaultBundleList()
 	if err != nil {
 		t.Fatalf("B: GetDefaultBundleList() failed: %v", err)
 	}

 	// Default bundle list should not contain the old default bundles.
 	if err := expectDefaultBundles(storedDefBundlesB, defBundlesB); err != nil {
 		t.Fatalf("B: Default bundle mismatch: %v", err)
 	}

 	// Non-default bundle should still be untouched.
 	if err := expectNonDefaultBundle(nondBLink.Id, mockJson[2]); err != nil {
 		t.Errorf("Non-default bundle mismatch: %v", err)
 	}

 	// Old default bundles should still be reachable by id.
 	if err := expectNonDefaultBundle(storedDefBundlesA[0].Id, mockJson[0]); err != nil {
 		t.Errorf("Old default bundle mismatch: %v", err)
 	}
 	// But not by slug.
 	if _, _, err := storage.GetBundleByLinkIdOrSlug(mockSlugs[0]); err != storage.ErrNotFound {
 		t.Errorf("Expected GetBundleByLinkIdOrSlug with old slug to return ErrNotFound, but instead got: %v", err)
 	}

 	// New bundle should be reachable by slug.
 	niBLink, niBData, err := storage.GetBundleByLinkIdOrSlug(mockSlugs[1])
 	if err != nil {
 		t.Fatalf("GetBundleDataByLinkIdOrSlug(%v) failed: %v", mockSlugs[1], err)
 	}
 	if err := assertValidLinkDataPair(mockJson[2], niBLink, niBData); err != nil {
 		t.Errorf("Got invalid link data pair: %v", err)
 	}
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Tests for the storage model.
	// These tests only test the exported API of the storage model.
	//
	// NOTE: These tests cannot be run in parallel on the same machine because they
	// interact with a fixed database on the machine.

	package storage_test

	import (
	"fmt"
	"testing"

	"github.com/rubenv/sql-migrate"

	"v.io/x/lib/dbutil"
	"v.io/x/playground/lib/storage"
	)

	var (
	dataSourceName = "playground_test@tcp(localhost:3306)/playground_test?parseTime=true"
	)

	// setup cleans the database, runs migrations, and connects to the database.
	// It returns a teardown function that closes the database connection.
	func setup(t *testing.T) func() {
	// Migrate down then up.
	migrations := &migrate.FileMigrationSource{
	Dir: "../../migrations",
	}
	migrate.SetTable("migrations")

	sqlConfig := dbutil.SqlConfig{
	DataSourceName: dataSourceName,
	TLSDisable: true,
	}
	activeSqlConfig, err := sqlConfig.Activate("")

	db, err := activeSqlConfig.NewSqlDBConn("SERIALIZABLE")
	if err != nil {
	t.Fatalf("Error opening database: %v", err)
	}

	// Remove any existing tables.
	tableNames := []string{"bundle_link", "bundle_data", "migrations"}
	for _, tableName := range tableNames {
	db.Exec("DROP TABLE " + tableName)
	}

	if _, err = migrate.Exec(db, "mysql", migrations, migrate.Up); err != nil {
	t.Fatalf("Error migrating up: %v", err)
	}
	if err := db.Close(); err != nil {
	t.Fatalf("db.Close() failed: %v", err)
	}

	// Connect to the storage.
	if err := storage.Connect(activeSqlConfig); err != nil {
	t.Fatalf("storage.Connect(%v) failed: %v", activeSqlConfig, err)
	}

	teardown := func() {
	if err := storage.Close(); err != nil {
	t.Fatalf("storage.Close() failed: %v", err)
	}
	}
	return teardown
	}

	func TestGetBundleDataByLinkId(t *testing.T) {
	defer setup(t)()

	// Get with a unknown id should return ErrNotFound.
	id := "foobar"
	if _, _, err := storage.GetBundleByLinkIdOrSlug(id); err != storage.ErrNotFound {
	t.Errorf("Expected GetBundleByLinkIdOrSlug with unknown id to return ErrNotFound, but instead got: %v", err)
	}

	// Add a bundle.
	json := "mock_json_data"
	bLink, _, err := storage.StoreBundleLinkAndData(json)
	if err != nil {
	t.Fatalf("Expected StoreBundleLinkAndData(%v) not to error, but got: %v", json, err)
	}

	// Bundle should exist.
	gotBLink, gotBdata, err := storage.GetBundleByLinkIdOrSlug(bLink.Id)
	if err != nil {
	t.Errorf("Expected GetBundleDataByLinkIdOrSlug(%v) not to error, but got: %v", bLink.Id, err)
	}

	// Bundle should have expected id.
	if got, want := gotBLink.Id, bLink.Id; got != want {
	t.Errorf("Expected %v to equal %v.", got, want)
	}

	// Bundle should have expected json.
	if got, want := gotBdata.Json, string(json); got != want {
	t.Errorf("Expected %v to equal %v.", got, want)
	}
	}

	func assertValidLinkDataPair(json string, bLink storage.BundleLink, bData storage.BundleData) error {
	if string(bLink.Hash) != string(bData.Hash) {
	return fmt.Errorf("Expected %v to equal %v", string(bLink.Hash), string(bData.Hash))
	}

	if bLink.Id == "" {
	return fmt.Errorf("Expected bundle link to have id.")
	}

	if bData.Json != json {
	return fmt.Errorf("Expected %v to equal %v", bData.Json, json)
	}
	return nil
	}

	func TestStoreBundleLinkAndData(t *testing.T) {
	defer setup(t)()

	mockJson := "bizbaz"

	// Storing the json once should succeed.
	bLink1, bData1, err := storage.StoreBundleLinkAndData(mockJson)
	if err != nil {
	t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson, err)
	}
	if err := assertValidLinkDataPair(string(mockJson), bLink1, bData1); err != nil {
	t.Fatalf("Got invalid link data pair: %v", err)
	}

	// Storing the bundle again should succeed.
	bLink2, bData2, err := storage.StoreBundleLinkAndData(mockJson)
	if err != nil {
	t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson, err)
	}
	if err := assertValidLinkDataPair(string(mockJson), bLink2, bData2); err != nil {
	t.Errorf("Got invalid link data pair: %v", err)
	}

	// Bundle links should have different ids.
	if bLink1.Id == bLink2.Id {
	t.Errorf("Expected bundle links to have different ids, but got %v and %v", bLink1.Id, bLink2.Id)
	}

	// Bundle datas should have equal hashes.
	if want, got := string(bData1.Hash), string(bData2.Hash); want != got {
	t.Errorf("Expected bundle datas to have equal hashes, but got %v and %v", want, got)
	}
	}

	func makeMockNamedBundle(mockSlug, mockJson string) *storage.NewBundle {
	return &storage.NewBundle{
	BundleDesc: storage.BundleDesc{
	Slug: storage.EmptyNullString(mockSlug),
	},
	Json: mockJson,
	}
	}

	func expectDefaultBundles(got []storage.BundleLink, want []storage.NewBundle) error {
	if len(got) != len(want) {
	return fmt.Errorf("Expected %d, got %d bundles.", len(want), len(got))
	}

	for _, listBLink := range got {
	// For each listed BundleLink, get corresponding BundleData.
	gotBLink, gotBData, err := storage.GetBundleByLinkIdOrSlug(listBLink.Id)
	if err != nil {
	return fmt.Errorf("Expected GetBundleDataByLinkIdOrSlug(%v) not to error, but got: %v", listBLink.Id, err)
	}

	// Check that the bundle is non-anonymous and default.
	if gotBLink.Slug == "" {
	return fmt.Errorf("Expected bundle for %v to have non-empty slug", gotBLink.Id)
	}
	if !gotBLink.IsDefault {
	return fmt.Errorf("Expected bundle %v to be marked as default", gotBLink.Slug)
	}

	// Find expected NewBundle with slug matching the retrieved bundle.
	var original *storage.NewBundle
	for _, newBundle := range want {
	if newBundle.Slug == gotBLink.Slug {
	original = newBundle
	break
	}
	}
	if original == nil {
	return fmt.Errorf("Unexpected bundle with slug %v", gotBLink.Slug)
	}

	// Check that the retrieved bundle is valid and matches expected JSON.
	if err := assertValidLinkDataPair(original.Json, gotBLink, gotBData); err != nil {
	return fmt.Errorf("Got invalid link data pair: %v", err)
	}
	}
	return nil
	}

	func expectNonDefaultBundle(bId, wantJson string) error {
	bLink, bData, err := storage.GetBundleByLinkIdOrSlug(bId)
	if err != nil {
	return fmt.Errorf("GetBundleDataByLinkIdOrSlug(%v) failed: %v", bId, err)
	}
	if bLink.Slug != "" {
	return fmt.Errorf("Expected anonymous bundle for %v, got slug %v", bId, bLink.Slug)
	}
	if bLink.IsDefault {
	return fmt.Errorf("Expected non-default bundle for %v", bId)
	}
	if err := assertValidLinkDataPair(wantJson, bLink, bData); err != nil {
	return fmt.Errorf("Got invalid link data pair: %v", err)
	}
	return nil
	}

	func TestDefaultBundles(t *testing.T) {
	defer setup(t)()

	mockSlugs := []string{"one", "two", "three", "four"}
	mockJson := []string{"forty-two", "forty-seven", "leet"}

	defBundlesA := []*storage.NewBundle{
	makeMockNamedBundle(mockSlugs[0], mockJson[0]),
	makeMockNamedBundle(mockSlugs[1], mockJson[0]),
	}

	// Storing default bundles should succeed.
	if err := storage.ReplaceDefaultBundles(defBundlesA); err != nil {
	t.Fatalf("A: ReplaceDefaultBundles(%v) failed: %v", defBundlesA, err)
	}

	// Storing a non-default bundle should succeed.
	nondBLink, _, err := storage.StoreBundleLinkAndData(mockJson[2])
	if err != nil {
	t.Fatalf("StoreBundleLinkAndData(%v) failed: %v", mockJson[2], err)
	}

	defBundlesDup := []*storage.NewBundle{
	makeMockNamedBundle(mockSlugs[1], mockJson[1]),
	makeMockNamedBundle(mockSlugs[1], mockJson[1]),
	}

	// Trying to store default bundles with duplicate slugs should fail and be
	// rolled back (not affect subsequent assertions).
	if err := storage.ReplaceDefaultBundles(defBundlesDup); err == nil {
	t.Fatalf("Dup: ReplaceDefaultBundles(%v) with duplicate slugs should have failed", defBundlesDup)
	}

	// Listing default bundles should succeed.
	storedDefBundlesA, err := storage.GetDefaultBundleList()
	if err != nil {
	t.Fatalf("A: GetDefaultBundleList() failed: %v", err)
	}

	// Default bundle list should not contain the non-default bundle.
	if err := expectDefaultBundles(storedDefBundlesA, defBundlesA); err != nil {
	t.Errorf("A: Default bundle mismatch: %v", err)
	}

	// Non-default bundle should be untouched.
	if err := expectNonDefaultBundle(nondBLink.Id, mockJson[2]); err != nil {
	t.Errorf("Non-default bundle mismatch: %v", err)
	}

	defBundlesB := []*storage.NewBundle{
	makeMockNamedBundle(mockSlugs[1], mockJson[2]),
	makeMockNamedBundle(mockSlugs[2], mockJson[1]),
	makeMockNamedBundle(mockSlugs[3], mockJson[0]),
	}

	// Replacing default bundles should succeed.
	if err := storage.ReplaceDefaultBundles(defBundlesB); err != nil {
	t.Fatalf("B: ReplaceDefaultBundles(%v) failed: %v", defBundlesB, err)
	}

	// Listing default bundles should succeed.
	storedDefBundlesB, err := storage.GetDefaultBundleList()
	if err != nil {
	t.Fatalf("B: GetDefaultBundleList() failed: %v", err)
	}

	// Default bundle list should not contain the old default bundles.
	if err := expectDefaultBundles(storedDefBundlesB, defBundlesB); err != nil {
	t.Fatalf("B: Default bundle mismatch: %v", err)
	}

	// Non-default bundle should still be untouched.
	if err := expectNonDefaultBundle(nondBLink.Id, mockJson[2]); err != nil {
	t.Errorf("Non-default bundle mismatch: %v", err)
	}

	// Old default bundles should still be reachable by id.
	if err := expectNonDefaultBundle(storedDefBundlesA[0].Id, mockJson[0]); err != nil {
	t.Errorf("Old default bundle mismatch: %v", err)
	}
	// But not by slug.
	if _, _, err := storage.GetBundleByLinkIdOrSlug(mockSlugs[0]); err != storage.ErrNotFound {
	t.Errorf("Expected GetBundleByLinkIdOrSlug with old slug to return ErrNotFound, but instead got: %v", err)
	}

	// New bundle should be reachable by slug.
	niBLink, niBData, err := storage.GetBundleByLinkIdOrSlug(mockSlugs[1])
	if err != nil {
	t.Fatalf("GetBundleDataByLinkIdOrSlug(%v) failed: %v", mockSlugs[1], err)
	}
	if err := assertValidLinkDataPair(mockJson[2], niBLink, niBData); err != nil {
	t.Errorf("Got invalid link data pair: %v", err)
	}
	}