From 177be3221687ff388353290d0b442b1b06f1fda5 Mon Sep 17 00:00:00 2001 From: Marcin Niemira Date: Tue, 25 Jun 2019 08:39:54 +1000 Subject: [PATCH] Complete lab09 --- 09_json/n0npax/README.md | 32 +++ 09_json/n0npax/cmd/puppy-server/main.go | 57 +++++ 09_json/n0npax/cmd/puppy-server/main_test.go | 47 ++++ 09_json/n0npax/pkg/puppy/errors.go | 31 +++ 09_json/n0npax/pkg/puppy/errors_test.go | 14 ++ .../n0npax/pkg/puppy/store/leveldbStore.go | 97 ++++++++ .../pkg/puppy/store/leveldbStore_test.go | 17 ++ 09_json/n0npax/pkg/puppy/store/memStore.go | 57 +++++ 09_json/n0npax/pkg/puppy/store/store_test.go | 216 ++++++++++++++++++ 09_json/n0npax/pkg/puppy/store/syncStore.go | 70 ++++++ 09_json/n0npax/pkg/puppy/types.go | 17 ++ 09_json/n0npax/pkg/puppy/types_test.go | 24 ++ 12 files changed, 679 insertions(+) create mode 100644 09_json/n0npax/README.md create mode 100644 09_json/n0npax/cmd/puppy-server/main.go create mode 100644 09_json/n0npax/cmd/puppy-server/main_test.go create mode 100644 09_json/n0npax/pkg/puppy/errors.go create mode 100644 09_json/n0npax/pkg/puppy/errors_test.go create mode 100644 09_json/n0npax/pkg/puppy/store/leveldbStore.go create mode 100644 09_json/n0npax/pkg/puppy/store/leveldbStore_test.go create mode 100644 09_json/n0npax/pkg/puppy/store/memStore.go create mode 100644 09_json/n0npax/pkg/puppy/store/store_test.go create mode 100644 09_json/n0npax/pkg/puppy/store/syncStore.go create mode 100644 09_json/n0npax/pkg/puppy/types.go create mode 100644 09_json/n0npax/pkg/puppy/types_test.go diff --git a/09_json/n0npax/README.md b/09_json/n0npax/README.md new file mode 100644 index 000000000..29c374a16 --- /dev/null +++ b/09_json/n0npax/README.md @@ -0,0 +1,32 @@ +# n0npax's puppy + +This project is source completed lab08 from [go course](https://github.com/anz-bank/go-course/) + +## Prerequisites + +- Install `go 1.12` according to [official installation instruction](https://golang.org/doc/install) +- Clone this project outside your `$GOPATH` to enable [Go Modules](https://github.com/golang/go/wiki/Modules) +- Install `golangci-lint` according to [instructions](https://github.com/golangci/golangci-lint#local-installation) + +## Build, execute, test, lint + +Build and install this project with + + go install ./... + +Build and execute its binary with + + go build -o lab08 cmd/puppy-server/main.go + ./lab08 + +Test it with + + go test ./... + +Lint it with + + golangci-lint run + +Review coverage with + + go test -coverprofile=coverage.out ./... && go tool cover -html=coverage.out diff --git a/09_json/n0npax/cmd/puppy-server/main.go b/09_json/n0npax/cmd/puppy-server/main.go new file mode 100644 index 000000000..44b7bf131 --- /dev/null +++ b/09_json/n0npax/cmd/puppy-server/main.go @@ -0,0 +1,57 @@ +package main + +import ( + "encoding/json" + "fmt" + "io" + "io/ioutil" + "os" + + "gopkg.in/alecthomas/kingpin.v2" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" + store "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy/store" +) + +var out io.Writer = os.Stdout + +var ( + args = os.Args[1:] + puppyFilePath = kingpin.Flag("data", "path to file with puppies data").Short('d').ExistingFile() +) + +func main() { + _, err := kingpin.CommandLine.Parse(args) + checkError(err) + if *puppyFilePath != "" { + puppies := readPuppies(*puppyFilePath) + store := store.MemStore{} + feedStore(store, puppies) + } +} + +func readPuppies(path string) []puppy.Puppy { + b, err := ioutil.ReadFile(path) + checkError(err) + + var puppies []puppy.Puppy + err = json.Unmarshal(b, &puppies) + checkError(err) + return puppies +} + +func feedStore(s puppy.Storer, puppies []puppy.Puppy) { + for _, p := range puppies { + p := p + _, err := s.CreatePuppy(&p) + checkError(err) + } +} + +func checkError(err error) { + if err != nil { + fmt.Fprintln(out, err) + os.Exit(1) + } + +} diff --git a/09_json/n0npax/cmd/puppy-server/main_test.go b/09_json/n0npax/cmd/puppy-server/main_test.go new file mode 100644 index 000000000..d308844b2 --- /dev/null +++ b/09_json/n0npax/cmd/puppy-server/main_test.go @@ -0,0 +1,47 @@ +package main + +import ( + "bytes" + "os" + "testing" + + "bou.ke/monkey" + + "github.com/stretchr/testify/assert" +) + +func TestMainNoArgs(t *testing.T) { + var buf bytes.Buffer + out = &buf + args = []string{} + main() + + expected := "" + actual := buf.String() + assert.Equal(t, expected, actual) +} + +func TestMainWithArgs(t *testing.T) { + var buf bytes.Buffer + out = &buf + args = []string{"--data", "../../test-data/data.json"} + main() + + expected := "" + actual := buf.String() + assert.Equal(t, expected, actual) +} + +func TestMainCorruptedData(t *testing.T) { + fakeExit := func(int) { + panic("os.Exit called") + } + patch := monkey.Patch(os.Exit, fakeExit) + defer patch.Unpatch() + + var buf bytes.Buffer + out = &buf + args = []string{"--data", "/dev/null"} + + assert.PanicsWithValue(t, "os.Exit called", main, "os.Exit was not called") +} diff --git a/09_json/n0npax/pkg/puppy/errors.go b/09_json/n0npax/pkg/puppy/errors.go new file mode 100644 index 000000000..25186aefb --- /dev/null +++ b/09_json/n0npax/pkg/puppy/errors.go @@ -0,0 +1,31 @@ +package puppy + +import ( + "fmt" +) + +// Error codes +const ( + ErrInvalidInputCode = 400 + ErrNotFoundCode = 404 + ErrInternalErrorCode = 500 +) + +// Error wrapps errors with code, message and error itself +type Error struct { + Message string + Code int +} + +// Error returns error as a string +func (e *Error) Error() string { + return fmt.Sprintf("Error code: %v, message : %v", e.Code, e.Message) +} + +// Errorf creates a new Error with formatting +func Errorf(code int, format string, args ...interface{}) *Error { + return &Error{ + Message: fmt.Sprintf(format, args...), + Code: code, + } +} diff --git a/09_json/n0npax/pkg/puppy/errors_test.go b/09_json/n0npax/pkg/puppy/errors_test.go new file mode 100644 index 000000000..91ecfa808 --- /dev/null +++ b/09_json/n0npax/pkg/puppy/errors_test.go @@ -0,0 +1,14 @@ +package puppy + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestErrorf(t *testing.T) { + err := Errorf(ErrInternalErrorCode, "internal error") + assert.Equal(t, ErrInternalErrorCode, err.Code) + errMessage := err.Error() + assert.Equal(t, "Error code: 500, message : internal error", errMessage) +} diff --git a/09_json/n0npax/pkg/puppy/store/leveldbStore.go b/09_json/n0npax/pkg/puppy/store/leveldbStore.go new file mode 100644 index 000000000..126b75d97 --- /dev/null +++ b/09_json/n0npax/pkg/puppy/store/leveldbStore.go @@ -0,0 +1,97 @@ +package store + +import ( + "encoding/json" + "fmt" + "strconv" + "sync" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" + + "github.com/syndtr/goleveldb/leveldb" +) + +var levelDBPath = "/tmp/leveldb" + +// LevelDBStore provides sync for leveldb +type LevelDBStore struct { + ldb *leveldb.DB + sync.Mutex + nextID int +} + +// NewLevelDBStorer creates new storer for leveldb +func NewLevelDBStorer() *LevelDBStore { + db, err := leveldb.OpenFile(levelDBPath, nil) + dbErrorPanic(err) + return &LevelDBStore{nextID: 0, ldb: db} +} + +// CreatePuppy creates puppy +func (l *LevelDBStore) CreatePuppy(p *puppy.Puppy) (int, error) { + l.Lock() + defer l.Unlock() + id, err := l.putPuppy(l.nextID, p) + l.nextID++ + return id, err +} + +// ReadPuppy reads puppy from backend +func (l *LevelDBStore) ReadPuppy(id int) (*puppy.Puppy, error) { + byteID := []byte(strconv.Itoa(id)) + if puppyData, err := l.ldb.Get(byteID, nil); err == nil { + var p puppy.Puppy + err := json.Unmarshal(puppyData, &p) + if err != nil { + return nil, puppy.Errorf(puppy.ErrInternalErrorCode, "Internal error. Could not cast stored data to puppy object") + } + return &p, nil + } + return nil, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) +} + +// UpdatePuppy updates puppy +func (l *LevelDBStore) UpdatePuppy(id int, p *puppy.Puppy) error { + if id != p.ID { + return puppy.Errorf(puppy.ErrInvalidInputCode, "ID is corrupted. Please ensure object ID matched provided ID") + } + l.Lock() + defer l.Unlock() + if _, err := l.ReadPuppy(id); err != nil { + return puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + _, err := l.putPuppy(id, p) + return err +} + +// DeletePuppy deletes puppy +func (l *LevelDBStore) DeletePuppy(id int) (bool, error) { + l.Lock() + defer l.Unlock() + if _, err := l.ReadPuppy(id); err != nil { + return false, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + byteID := []byte(strconv.Itoa(id)) + err := l.ldb.Delete(byteID, nil) + dbErrorPanic(err) + return true, nil +} + +// putPuppy stores puppy in backend +func (l *LevelDBStore) putPuppy(id int, p *puppy.Puppy) (int, error) { + if p.Value < 0 { + return -1, puppy.Errorf(puppy.ErrInvalidInputCode, "Puppy value have to be positive number") + } + puppyByte, _ := json.Marshal(p) + byteID := []byte(strconv.Itoa(id)) + err := l.ldb.Put(byteID, puppyByte, nil) + dbErrorPanic(err) + return id, nil +} + +// dbErrorPanic causes panic in error is not nil +func dbErrorPanic(err error) { + if err != nil { + panic(err) + } +} diff --git a/09_json/n0npax/pkg/puppy/store/leveldbStore_test.go b/09_json/n0npax/pkg/puppy/store/leveldbStore_test.go new file mode 100644 index 000000000..188440113 --- /dev/null +++ b/09_json/n0npax/pkg/puppy/store/leveldbStore_test.go @@ -0,0 +1,17 @@ +package store + +import ( + "testing" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" +) + +func TestDbErrorPanic(t *testing.T) { + defer func() { + if r := recover(); r == nil { + t.Errorf("Panic expected") + } + }() + err := puppy.Errorf(puppy.ErrInvalidInputCode, "test invalid input") + dbErrorPanic(err) +} diff --git a/09_json/n0npax/pkg/puppy/store/memStore.go b/09_json/n0npax/pkg/puppy/store/memStore.go new file mode 100644 index 000000000..d0f79191f --- /dev/null +++ b/09_json/n0npax/pkg/puppy/store/memStore.go @@ -0,0 +1,57 @@ +package store + +import ( + "fmt" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" +) + +// MemStore map based type for storing puppies data +type MemStore map[int]puppy.Puppy + +// NewMemStore creates new storer for map +func NewMemStore() MemStore { + return MemStore{} +} + +// CreatePuppy creates puppy +func (m MemStore) CreatePuppy(p *puppy.Puppy) (int, error) { + if p.Value < 0 { + return -1, puppy.Errorf(puppy.ErrInvalidInputCode, "Puppy value have to be positive number") + } + id := len(m) + m[id] = *p + return id, nil +} + +// ReadPuppy reads puppy from backend +func (m MemStore) ReadPuppy(id int) (*puppy.Puppy, error) { + if puppy, ok := m[id]; ok { + return &puppy, nil + } + return nil, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) +} + +// UpdatePuppy updates puppy +func (m MemStore) UpdatePuppy(id int, p *puppy.Puppy) error { + if p.Value < 0 { + return puppy.Errorf(puppy.ErrInvalidInputCode, "Puppy value have to be positive number") + } + if id != p.ID { + return puppy.Errorf(puppy.ErrInvalidInputCode, "ID is corrupted. Please ensure object ID matched provided ID") + } + if _, ok := m[id]; !ok { + return puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + m[id] = *p + return nil +} + +// DeletePuppy deletes puppy +func (m MemStore) DeletePuppy(id int) (bool, error) { + if _, ok := m[id]; !ok { + return false, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + delete(m, id) + return true, nil +} diff --git a/09_json/n0npax/pkg/puppy/store/store_test.go b/09_json/n0npax/pkg/puppy/store/store_test.go new file mode 100644 index 000000000..fee44fa70 --- /dev/null +++ b/09_json/n0npax/pkg/puppy/store/store_test.go @@ -0,0 +1,216 @@ +package store + +import ( + "encoding/json" + "os" + "strconv" + "testing" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" + "github.com/stretchr/testify/assert" + tassert "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + "github.com/syndtr/goleveldb/leveldb" +) + +type storerImpl int + +const ( + syncStorer storerImpl = iota + memStorer + leveldbStorer +) + +var ( + puppy0 = func() puppy.Puppy { + return puppy.Puppy{ + Breed: "Type A", + Colour: "Grey", + Value: 300, + } + } + puppy1 = func() puppy.Puppy { + return puppy.Puppy{ + Breed: "Type B", + Colour: "Brown", + Value: 400, + } + } + puppyNegativeValue = func() puppy.Puppy { + return puppy.Puppy{ + Breed: "Type C", + Colour: "Red", + Value: -1, + } + } + puppyNegativeID = func() puppy.Puppy { + return puppy.Puppy{ + Breed: "Type D", + Colour: "Blue", + Value: 100, + ID: -1, + } + } +) + +type storerSuite struct { + suite.Suite + store puppy.Storer + impl storerImpl +} + +func (s *storerSuite) SetupSuite() { + // Remove old db if exists + os.RemoveAll(levelDBPath) +} + +func (s *storerSuite) TearDownTest() { + if ldbs, ok := s.store.(*LevelDBStore); ok { + ldbs.ldb.Close() + } +} + +func (s *storerSuite) SetupTest() { + switch s.impl { + case syncStorer: + s.store = NewSyncStore() + case memStorer: + s.store = NewMemStore() + case leveldbStorer: + s.store = NewLevelDBStorer() + default: + panic("Unrecognised storer implementation") + } + p := puppy0() + _, err := s.store.CreatePuppy(&p) + if err != nil { + panic(err) + } +} + +func (s *storerSuite) TestCreatePuppySuccessful() { + assert := tassert.New(s.T()) + newPuppy0, newPuppy1 := puppy0(), puppy1() + id0, err := s.store.CreatePuppy(&newPuppy0) + assert.NoError(err, "Creating p should be ok") + id1, err := s.store.CreatePuppy(&newPuppy1) + assert.NoError(err, "Creating p should be ok") + assert.Equal(id0, id1-1, "2nd id should be 1st +1, got %v and %v", id0, id1) +} + +func (s *storerSuite) TestCreatePuppyNegativeValue() { + assert := tassert.New(s.T()) + newPuppy := puppyNegativeValue() + _, err := s.store.CreatePuppy(&newPuppy) + assert.Error(err, "negative ID should cause an error") +} + +func (s *storerSuite) TestReadPuppySuccessful() { + assert := tassert.New(s.T()) + newPuppy := puppy0() + id, err := s.store.CreatePuppy(&newPuppy) + assert.NoError(err, "Creating p should be ok") + readPuppy, err := s.store.ReadPuppy(id) + if assert.NoError(err, "Should be able to read puppy0 from store") { + assert.Equal(&newPuppy, readPuppy, "store should return identic puppy") + } +} + +func (s *storerSuite) TestReadPuppyIDDoesNotExist() { + assert := tassert.New(s.T()) + _, err := s.store.ReadPuppy(1000) + assert.Error(err, "Should get an error when attempting to read an non-existing puppy") +} + +func (s *storerSuite) TestReadPuppyNegativeID() { + assert := tassert.New(s.T()) + _, err := s.store.ReadPuppy(-1) + assert.Error(err, "negative ID should cause an error") +} + +func (s *storerSuite) TestUpdatePuppy() { + assert := tassert.New(s.T()) + existingPuppy, err := s.store.ReadPuppy(0) + assert.NoError(err, "Reading p should not return error") + existingPuppy.Colour = "Purple" + err = s.store.UpdatePuppy(0, existingPuppy) + assert.NoError(err, "Update should not return any error") + p, err := s.store.ReadPuppy(0) + assert.NoError(err, "Reading p should not return error") + assert.Equal(existingPuppy.Colour, p.Colour, "Updated colour missmatch") +} + +func (s *storerSuite) TestUpdatePuppyCorruptedID() { + assert := tassert.New(s.T()) + existingPuppy, err := s.store.ReadPuppy(0) + assert.NoError(err, "Reading p should be ok") + err = s.store.UpdatePuppy(1000, existingPuppy) + assert.Error(err, "Should get an error when attempting to update with corrupted id") +} + +func (s *storerSuite) TestUpdatePuppyIDDoesNotExist() { + assert := tassert.New(s.T()) + newPuppy := puppy0() + err := s.store.UpdatePuppy(1000, &newPuppy) + assert.Error(err, "Should get an error when attempting to update an non-existing puppy") +} + +func (s *storerSuite) TestUpdatePuppyNegativeID() { + assert := tassert.New(s.T()) + newPuppy := puppyNegativeID() + err := s.store.UpdatePuppy(newPuppy.ID, &newPuppy) + assert.Error(err, "negative ID should cause an error") +} + +func (s *storerSuite) TestUpdatePuppyNegativeValue() { + assert := tassert.New(s.T()) + newPuppy := puppyNegativeValue() + err := s.store.UpdatePuppy(newPuppy.ID, &newPuppy) + assert.Error(err, "negative ID should cause an error") +} + +func (s *storerSuite) TestDeletePuppySuccessful() { + assert := tassert.New(s.T()) + existingPuppy := puppy0() + deleted, err := s.store.DeletePuppy(0) + assert.NoError(err, "Delete should successfully delete a puppy") + assert.True(deleted, "Delete should return true indicating a p was deleted") + _, err = s.store.ReadPuppy(existingPuppy.ID) + assert.Error(err, "Should not be able to read a deleted ID") +} + +func (s *storerSuite) TestDeletePuppyIDDoesNotExist() { + assert := tassert.New(s.T()) + _, err := s.store.DeletePuppy(1000) + assert.Error(err, "Should not be able to delete p with non existing ID") +} + +func (s *storerSuite) TestDeletePuppyNegativeID() { + assert := tassert.New(s.T()) + _, err := s.store.DeletePuppy(-1) + assert.Error(err, "negative ID should cause an error") +} + +func TestStorer(t *testing.T) { + suite.Run(t, &storerSuite{impl: syncStorer}) + suite.Run(t, &storerSuite{impl: memStorer}) + suite.Run(t, &storerSuite{impl: leveldbStorer}) +} + +func TestBrokenDataInLevelDB(t *testing.T) { + // Prepare corrupted data to cause internal error + func() { + assert := tassert.New(t) + db, _ := leveldb.OpenFile(levelDBPath, nil) + defer db.Close() + puppyByte, err := json.Marshal("this string cannot be casted to puppy") + assert.NoError(err, "no error expected during marshaling string") + byteID := []byte(strconv.Itoa(999)) + err = db.Put(byteID, puppyByte, nil) + assert.NoError(err, "no error expected during preparing corrupted data in db") + }() + s := NewLevelDBStorer() + defer s.ldb.Close() + _, err := s.ReadPuppy(999) + assert.Error(t, err) +} diff --git a/09_json/n0npax/pkg/puppy/store/syncStore.go b/09_json/n0npax/pkg/puppy/store/syncStore.go new file mode 100644 index 000000000..999741db5 --- /dev/null +++ b/09_json/n0npax/pkg/puppy/store/syncStore.go @@ -0,0 +1,70 @@ +package store + +import ( + "fmt" + "sync" + + puppy "github.com/anz-bank/go-course/09_json/n0npax/pkg/puppy" +) + +//SyncStore sync.Map based type for storing puppies data +type SyncStore struct { + sync.Map + sync.Mutex + nextID int +} + +// NewSyncStore creates new storer for SyncMap +func NewSyncStore() *SyncStore { + return &SyncStore{} +} + +// CreatePuppy creates puppy +func (s *SyncStore) CreatePuppy(p *puppy.Puppy) (int, error) { + if p.Value < 0 { + return -1, puppy.Errorf(puppy.ErrInvalidInputCode, "Puppy value have to be positive number") + } + s.Lock() + defer s.Unlock() + p.ID = s.nextID + s.nextID++ + s.Store(p.ID, *p) + return p.ID, nil +} + +// ReadPuppy reads puppy from backend +func (s *SyncStore) ReadPuppy(id int) (*puppy.Puppy, error) { + if puppyData, ok := s.Load(id); ok { + p := puppyData.(puppy.Puppy) + return &p, nil + } + return nil, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) +} + +// UpdatePuppy updates puppy +func (s *SyncStore) UpdatePuppy(id int, p *puppy.Puppy) error { + if p.Value < 0 { + return puppy.Errorf(puppy.ErrInvalidInputCode, "Puppy value have to be positive number") + } + if id != p.ID { + return puppy.Errorf(puppy.ErrInvalidInputCode, "ID is corrupted. Please ensure object ID matched provided ID") + } + s.Lock() + defer s.Unlock() + if _, ok := s.Load(id); !ok { + return puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + s.Store(id, *p) + return nil +} + +// DeletePuppy deletes puppy +func (s *SyncStore) DeletePuppy(id int) (bool, error) { + s.Lock() + defer s.Unlock() + if _, ok := s.Load(id); !ok { + return false, puppy.Errorf(puppy.ErrNotFoundCode, fmt.Sprintf("Puppy with ID (%v) not found", id)) + } + s.Delete(id) + return true, nil +} diff --git a/09_json/n0npax/pkg/puppy/types.go b/09_json/n0npax/pkg/puppy/types.go new file mode 100644 index 000000000..e5bfaa93c --- /dev/null +++ b/09_json/n0npax/pkg/puppy/types.go @@ -0,0 +1,17 @@ +package puppy + +// Puppy contains information about single puppy +type Puppy struct { + ID int `json:"id"` + Value int `json:"value"` + Breed string `json:"breed"` + Colour string `json:"colour"` +} + +// Storer interface for Store implementations +type Storer interface { + ReadPuppy(ID int) (*Puppy, error) + UpdatePuppy(ID int, puppy *Puppy) error + CreatePuppy(puppy *Puppy) (int, error) + DeletePuppy(ID int) (bool, error) +} diff --git a/09_json/n0npax/pkg/puppy/types_test.go b/09_json/n0npax/pkg/puppy/types_test.go new file mode 100644 index 000000000..38dcbb73c --- /dev/null +++ b/09_json/n0npax/pkg/puppy/types_test.go @@ -0,0 +1,24 @@ +package puppy + +import ( + "encoding/json" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestJson(t *testing.T) { + testCases := []struct { + object Puppy + marshaled string + }{ + {marshaled: `{"id":0,"value":222,"breed":"Type: R","colour":"Red"}`, + object: Puppy{Colour: "Red", Value: 222, Breed: "Type: R"}}, + {marshaled: `{"id":0,"value":0,"breed":"","colour":""}`, + object: Puppy{}}, + } + for _, test := range testCases { + b, _ := json.Marshal(test.object) + assert.Equal(t, test.marshaled, string(b)) + } +}