nicolas
/
golang-url-shortener
mirror of https://github.com/nmasse-itix/golang-url-shortener
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

improved stores unit tests

dependabot/npm_and_yarn/web/prismjs-1.21.0
Max Schmitt 8 years ago
parent
4efc23eda8
commit
e02433d895
3 changed files with 68 additions and 164 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 67
      stores/boltdb/boltdb_test.go
  2. 5
      stores/store.go
  3. 158
      stores/store_test.go

67
stores/boltdb/boltdb_test.go
View File

@ -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()
}

5
stores/store.go
View File

@ -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
}

158
stores/store_test.go
View File

@ -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) {
util.SetConfig(util.Configuration{
var testData = struct {
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) {
t.Run("create store with correct arguments", func(r *testing.T) {
if err := util.ReadInConfig(); err != nil {
t.Fatalf("could not read in config: %v", err)
func TestStore(t *testing.T) {
util.SetConfig(util.Configuration{
DataDir: testData.DataDir,
ShortedIDLength: 4,
})
if err := os.MkdirAll(testData.DataDir, 0644); err != nil {
t.Errorf("could not create data dir: %v", err)
}
store, err := New()
if err != nil {
t.Fatalf("unexpected error: %v", err)
t.Errorf("could not create store: %v", err)
}
cleanup(store)
})
}
func TestCreateEntry(t *testing.T) {
store, err := New()
entryID, deletionHmac, err := store.CreateEntry(testData.Entry, "", testData.Password)
if err != nil {
t.Fatalf("unexpected error: %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)
}
t.Errorf("could not create entry: %v", err)
}
}
func TestGetEntryByID(t *testing.T) {
store, err := New()
entryBeforeIncreasement, err := store.GetEntryByID(entryID)
if err != nil {
t.Fatalf("unexpected error: %v", err)
t.Errorf("could not get 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)
}
}
func TestDelete(t *testing.T) {
store, err := New()
entry, err := store.GetEntryAndIncrease(entryID)
if err != nil {
t.Fatalf("could not create store: %v", err)
t.Errorf("could not increase entry: %v", err)
}
defer cleanup(store)
entryID, delHMac, err := store.CreateEntry(shared.Entry{
Public: shared.EntryPublicData{
URL: "https://golang.org/",
},
}, "", "")
entryAfterIncreasement, err := store.GetEntryByID(entryID)
if err != nil {
t.Fatalf("could not create entry: %v", err)
}
if err := store.DeleteEntry(entryID, delHMac); err != nil {
t.Fatalf("could not delete entry: %v", err)
t.Errorf("could not get entry: %v", err)
}
if _, err := store.GetEntryByID(entryID); !strings.Contains(err.Error(), shared.ErrNoEntryFound.Error()) {
t.Fatalf("unexpected error: %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)
}
}
func TestGetURLAndIncrease(t *testing.T) {
store, err := New()
if err != nil {
t.Fatalf("could not create store: %v", err)
if entryAfterIncreasement.Public.VisitCount != entry.Public.VisitCount {
t.Errorf("returned entry from increasement does not mach visitor count; got: %d; expected: %d", entry.Public.VisitCount, entryAfterIncreasement.Public.VisitCount)
}
defer cleanup(store)
const url = "https://golang.org/"
entryID, _, err := store.CreateEntry(shared.Entry{
Public: shared.EntryPublicData{
URL: url,
},
}, "", "")
store.RegisterVisit(entryID, testData.Visitor)
visitors, err := store.GetVisitors(entryID)
if err != nil {
t.Fatalf("could not create entry: %v", err)
t.Errorf("could not get visitors: %v", err)
}
entryOne, err := store.GetEntryByID(entryID)
if err != nil {
t.Fatalf("could not get entry: %v", err)
visitor := visitors[0]
if visitor.IP != testData.Visitor.IP && visitor.Referer != testData.Visitor.Referer {
t.Errorf("received visitor does not match")
}
entry, err := store.GetEntryAndIncrease(entryID)
if err != nil {
t.Fatalf("could not get URL and increase the visitor counter: %v", err)
if err := store.DeleteEntry(entryID, deletionHmac); err != nil {
t.Errorf("could not delete entry: %v", err)
}
if entry.Public.URL != url {
t.Fatalf("url is not the expected one")
if _, err := store.GetEntryByID(entryID); errors.Cause(err) != shared.ErrNoEntryFound {
t.Errorf("error is not expected one: %v", err)
}
entryTwo, err := store.GetEntryByID(entryID)
if err != nil {
t.Fatalf("could not get entry: %v", err)
if err := store.Close(); err != nil {
t.Errorf("could not close store: %v", err)
}
if entryOne.Public.VisitCount+1 != entryTwo.Public.VisitCount {
t.Fatalf("visitor count does not increase")
if err := os.RemoveAll(testData.DataDir); err != nil {
t.Errorf("could not remove database: %v", err)
}
}
func cleanup(s *Store) {
s.Close()
}

Write Preview
Loading…
Cancel
Save