improved stores unit tests

stores/boltdb/boltdb_test.go

@@ -1,67 +0,0 @@
-package boltdb
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/maxibanki/golang-url-shortener/stores/shared"
-)
-
-func getStore(t *testing.T) (*BoltStore, func()) {
-	store, err := New("test.db")
-	if err != nil {
-		t.Errorf("could not get store: %v", err)
-	}
-	return store, func() {
-		store.Close()
-		os.Remove("test.db")
-	}
-}
-
-func TestBoltDB(t *testing.T) {
-	store, cleanup := getStore(t)
-	givenEntryID := "x1df"
-	givenEntry := shared.Entry{
-		DeletionURL: "foo",
-		RemoteAddr:  "127.0.0.1",
-		Public: shared.EntryPublicData{
-			CreatedOn: time.Now(),
-			URL:       "google.com",
-		},
-	}
-	if err := store.CreateEntry(givenEntry, givenEntryID, "google01234"); err != nil {
-		t.Errorf("could not create entry: %v", err)
-	}
-	entryBeforeIncreasement, err := store.GetEntryByID(givenEntryID)
-	if err != nil {
-		t.Errorf("could not get entry: %v", err)
-	}
-	if err := store.IncreaseVisitCounter(givenEntryID); err != nil {
-		t.Errorf("could not increase visit counter: %v", err)
-	}
-	entryAfterIncreasement, err := store.GetEntryByID(givenEntryID)
-	if err != nil {
-		t.Errorf("could not get entry: %v", err)
-	}
-	if entryBeforeIncreasement.Public.VisitCount+1 != entryAfterIncreasement.Public.VisitCount {
-		t.Errorf("Visit counter hasn't increased; before: %d, after: %d", entryBeforeIncreasement.Public.VisitCount, entryAfterIncreasement.Public.VisitCount)
-	}
-	if err := store.RegisterVisitor(givenEntryID, "whooop", shared.Visitor{
-		IP:      "foo",
-		Referer: "foo",
-	}); err != nil {
-		t.Errorf("Failed to register visitor: %v", err)
-	}
-	visitors, err := store.GetVisitors(givenEntryID)
-	if err != nil {
-		t.Errorf("could not get visitors: %v", err)
-	}
-	if len(visitors) != 1 {
-		t.Errorf("Expected visitor length: %d; got: %d", err)
-	}
-	if err := store.DeleteEntry(givenEntryID); err != nil {
-		t.Errorf("could not delte entry: %v", err)
-	}
-	cleanup()
-}

stores/store.go

@@ -69,6 +69,7 @@ func (s *Store) GetEntryAndIncrease(id string) (*shared.Entry, error) {
 	if err := s.storage.IncreaseVisitCounter(id); err != nil {
 		return nil, errors.Wrap(err, "could not increase visitor counter")
 	}
+	entry.Public.VisitCount++
 	return entry, nil
 }
 
@@ -87,14 +88,14 @@ func (s *Store) CreateEntry(entry shared.Entry, givenID, password string) (strin
 	}
 	// try it 10 times to make a short URL
 	for i := 1; i <= 10; i++ {
-		id, delID, err := s.createEntry(entry, givenID)
+		id, passwordHash, err := s.createEntry(entry, givenID)
 		if err != nil && givenID != "" {
 			return "", nil, err
 		} else if err != nil {
 			logrus.Debugf("Could not create entry: %v", err)
 			continue
 		}
-		return id, delID, nil
+		return id, passwordHash, nil
 	}
 	return "", nil, ErrGeneratingIDFailed
 }

stores/store_test.go

@@ -1,18 +1,43 @@
 package stores
 
 import (
-	"strings"
+	"os"
 	"testing"
 
+	"github.com/pkg/errors"
+
 	"github.com/maxibanki/golang-url-shortener/stores/shared"
+
 	"github.com/maxibanki/golang-url-shortener/util"
 )
 
-func TestGenerateRandomString(t *testing.T) {
+var testData = struct {
-	util.SetConfig(util.Configuration{
+	ID            string
+	Password      string
+	oAuthProvider string
+	oAuthID       string
+	Entry         shared.Entry
+	Visitor       shared.Visitor
+	DataDir       string
+}{
+	ID:            "such-a-great-id",
+	Password:      "sooo secret",
+	oAuthProvider: "google",
+	oAuthID:       "12345678",
+	Entry: shared.Entry{
+		Public: shared.EntryPublicData{
+			URL: "https://google.com",
+		},
+		RemoteAddr: "203.0.113.6",
+	},
+	Visitor: shared.Visitor{
+		IP:      "foo",
+		Referer: "foo",
+	},
 	DataDir: "./data",
-		ShortedIDLength: 4,
+}
-	})
+
+func TestGenerateRandomString(t *testing.T) {
 	tt := []struct {
 		name   string
 		length int
@@ -37,114 +62,59 @@ func TestGenerateRandomString(t *testing.T) {
 	}
 }
 
-func TestNewStore(t *testing.T) {
+func TestStore(t *testing.T) {
-	t.Run("create store with correct arguments", func(r *testing.T) {
+	util.SetConfig(util.Configuration{
-		if err := util.ReadInConfig(); err != nil {
+		DataDir:         testData.DataDir,
-			t.Fatalf("could not read in config: %v", err)
+		ShortedIDLength: 4,
-		}
-		store, err := New()
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		cleanup(store)
 	})
+	if err := os.MkdirAll(testData.DataDir, 0644); err != nil {
+		t.Errorf("could not create data dir: %v", err)
 	}
-
-func TestCreateEntry(t *testing.T) {
 	store, err := New()
 	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Errorf("could not create store: %v", err)
-	}
-	defer cleanup(store)
-	_, _, err = store.CreateEntry(shared.Entry{}, "", "")
-	if err != ErrNoValidURL {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	for i := 1; i <= 100; i++ {
-		_, _, err := store.CreateEntry(shared.Entry{
-			Public: shared.EntryPublicData{
-				URL: "https://golang.org/",
-			},
-		}, "", "")
-		if err != nil && err != ErrGeneratingIDFailed {
-			t.Fatalf("unexpected error during creating entry: %v", err)
 	}
-	}
+	entryID, deletionHmac, err := store.CreateEntry(testData.Entry, "", testData.Password)
-}
-
-func TestGetEntryByID(t *testing.T) {
-	store, err := New()
 	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Errorf("could not create entry: %v", err)
-	}
-	defer cleanup(store)
-	_, err = store.GetEntryByID("something that not exists")
-	if !strings.Contains(err.Error(), shared.ErrNoEntryFound.Error()) {
-		t.Fatalf("could not get expected '%v' error: %v", shared.ErrNoEntryFound, err)
-	}
-	_, err = store.GetEntryByID("")
-	if !strings.Contains(err.Error(), shared.ErrNoEntryFound.Error()) {
-		t.Fatalf("could not get expected '%v' error: %v", shared.ErrNoEntryFound, err)
-	}
 	}
-
+	entryBeforeIncreasement, err := store.GetEntryByID(entryID)
-func TestDelete(t *testing.T) {
-	store, err := New()
 	if err != nil {
-		t.Fatalf("could not create store: %v", err)
+		t.Errorf("could not get entry: %v", err)
 	}
-	defer cleanup(store)
+	entry, err := store.GetEntryAndIncrease(entryID)
-	entryID, delHMac, err := store.CreateEntry(shared.Entry{
-		Public: shared.EntryPublicData{
-			URL: "https://golang.org/",
-		},
-	}, "", "")
 	if err != nil {
-		t.Fatalf("could not create entry: %v", err)
+		t.Errorf("could not increase entry: %v", err)
-	}
-	if err := store.DeleteEntry(entryID, delHMac); err != nil {
-		t.Fatalf("could not delete entry: %v", err)
 	}
-	if _, err := store.GetEntryByID(entryID); !strings.Contains(err.Error(), shared.ErrNoEntryFound.Error()) {
+	entryAfterIncreasement, err := store.GetEntryByID(entryID)
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestGetURLAndIncrease(t *testing.T) {
-	store, err := New()
 	if err != nil {
-		t.Fatalf("could not create store: %v", err)
+		t.Errorf("could not get entry: %v", err)
 	}
-	defer cleanup(store)
+	if entryBeforeIncreasement.Public.VisitCount+1 != entryAfterIncreasement.Public.VisitCount {
-	const url = "https://golang.org/"
+		t.Errorf("Visit counter hasn't increased; before: %d, after: %d", entryBeforeIncreasement.Public.VisitCount, entryAfterIncreasement.Public.VisitCount)
-	entryID, _, err := store.CreateEntry(shared.Entry{
-		Public: shared.EntryPublicData{
-			URL: url,
-		},
-	}, "", "")
-	if err != nil {
-		t.Fatalf("could not create entry: %v", err)
 	}
-	entryOne, err := store.GetEntryByID(entryID)
+	if entryAfterIncreasement.Public.VisitCount != entry.Public.VisitCount {
-	if err != nil {
+		t.Errorf("returned entry from increasement does not mach visitor count; got: %d; expected: %d", entry.Public.VisitCount, entryAfterIncreasement.Public.VisitCount)
-		t.Fatalf("could not get entry: %v", err)
 	}
-	entry, err := store.GetEntryAndIncrease(entryID)
+	store.RegisterVisit(entryID, testData.Visitor)
+	visitors, err := store.GetVisitors(entryID)
 	if err != nil {
-		t.Fatalf("could not get URL and increase the visitor counter: %v", err)
+		t.Errorf("could not get visitors: %v", err)
 	}
-	if entry.Public.URL != url {
+	visitor := visitors[0]
-		t.Fatalf("url is not the expected one")
+	if visitor.IP != testData.Visitor.IP && visitor.Referer != testData.Visitor.Referer {
+		t.Errorf("received visitor does not match")
 	}
-	entryTwo, err := store.GetEntryByID(entryID)
+	if err := store.DeleteEntry(entryID, deletionHmac); err != nil {
-	if err != nil {
+		t.Errorf("could not delete entry: %v", err)
-		t.Fatalf("could not get entry: %v", err)
 	}
-	if entryOne.Public.VisitCount+1 != entryTwo.Public.VisitCount {
+	if _, err := store.GetEntryByID(entryID); errors.Cause(err) != shared.ErrNoEntryFound {
-		t.Fatalf("visitor count does not increase")
+		t.Errorf("error is not expected one: %v", err)
 	}
+	if err := store.Close(); err != nil {
+		t.Errorf("could not close store: %v", err)
+	}
+	if err := os.RemoveAll(testData.DataDir); err != nil {
+		t.Errorf("could not remove database: %v", err)
 	}
-
-func cleanup(s *Store) {
-	s.Close()
 }