Create CRUD puppy solution with map and syncMap

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${fileDirname}",
+            "env": {},
+            "args": []
+        }
+    ]
+}

06_puppy/hsy3418/main.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+var out io.Writer = os.Stdout
+
+func main() {
+	p1 := Puppy{Breed: "Poodle", Colour: "White", Value: 1280.5}
+	p2 := Puppy{Breed: "Poodle", Colour: "Grey", Value: 1340.5}
+	mapStore := NewMapStore()
+	syncStore := NewSyncStore()
+	_ = mapStore.CreatePuppy(p1)
+	_ = syncStore.CreatePuppy(p2)
+	puppy, _ := mapStore.ReadPuppy(0)
+	puppy2, _ := syncStore.ReadPuppy(0)
+	fmt.Fprintf(out, "Puppy ID %d is %v", puppy.ID, puppy.Value)
+	fmt.Fprintf(out, "Puppy ID %d is %v", puppy2.ID, puppy2.Value)
+}

06_puppy/hsy3418/main_test.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMain(t *testing.T) {
+	assert := assert.New(t)
+	var buf bytes.Buffer
+	out = &buf
+	main()
+	expected := "Puppy ID 0 is 1280.5Puppy ID 0 is 1340.5"
+	actual := buf.String()
+	assert.Equal(expected, actual)
+}

06_puppy/hsy3418/mapStore.go

@@ -0,0 +1,50 @@
+package main
+
+import "fmt"
+
+// MapStore is a implementation of storer for the storage of puppies
+type MapStore struct {
+	puppies map[int32]Puppy
+	nextID  int32
+}
+
+// NewMapStore creates a new mapStore
+func NewMapStore() *MapStore {
+	return &MapStore{
+		puppies: map[int32]Puppy{},
+	}
+}
+
+// CreatePuppy adds a nuw puppy to the puppy store and returns the id for the puppy
+func (m *MapStore) CreatePuppy(puppy Puppy) int32 {
+	puppy.ID = m.nextID
+	m.nextID++
+	m.puppies[puppy.ID] = puppy
+	return puppy.ID
+}
+
+// ReadPuppy retrieves the puppy for a given id from puppies store
+func (m *MapStore) ReadPuppy(id int32) (Puppy, error) {
+	if _, ok := m.puppies[id]; !ok {
+		return Puppy{}, fmt.Errorf("puppy with %d ID does not exist", id)
+	}
+	return m.puppies[id], nil
+}
+
+//UpdatePuppy updates the puppy for the given id
+func (m *MapStore) UpdatePuppy(puppy Puppy) error {
+	if _, ok := m.puppies[puppy.ID]; !ok {
+		return fmt.Errorf("puppy with %d ID does not exist", puppy.ID)
+	}
+	m.puppies[puppy.ID] = puppy
+	return nil
+}
+
+//DeletePuppy delete the puppy for the given id from puppies store
+func (m *MapStore) DeletePuppy(id int32) error {
+	if _, ok := m.puppies[id]; !ok {
+		return fmt.Errorf("puppy with %d ID does not exist", id)
+	}
+	delete(m.puppies, id)
+	return nil
+}

06_puppy/hsy3418/store_test.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+func (suite *storerTestSuite) SetupTest() {
+	suite.store = suite.makeStore()
+	suite.nonExistPuppy = Puppy{ID: 123456, Breed: "Poodle", Colour: "White", Value: 1000.5}
+	suite.toBeCreatedPuppy = Puppy{Breed: "Poodle", Colour: "White", Value: 1000.5}
+	suite.existsPuppy = Puppy{Breed: "Poodle", Colour: "White", Value: 1280.5}
+	suite.toBeUpdatedPuppy = Puppy{ID: suite.existsPuppy.ID, Breed: "Poodle", Colour: "White", Value: 2000}
+	suite.store.CreatePuppy(suite.existsPuppy)
+}
+
+type storerTestSuite struct {
+	suite.Suite
+	store            Storer
+	makeStore        func() Storer
+	toBeCreatedPuppy Puppy
+	existsPuppy      Puppy
+	toBeUpdatedPuppy Puppy
+	nonExistPuppy    Puppy
+}
+
+func (suite *storerTestSuite) TestCreatePuppy() {
+	assert := assert.New(suite.T())
+	testCases := []struct {
+		title string
+		input Puppy
+	}{
+		{"Create new puppy", suite.toBeCreatedPuppy},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		suite.T().Run(tc.title, func(t *testing.T) {
+			id := suite.store.CreatePuppy(tc.input)
+			assert.True(id > 0)
+		})
+	}
+}
+
+func (suite *storerTestSuite) TestUpdatePuppy() {
+	assert := assert.New(suite.T())
+	testCases := []struct {
+		title         string
+		inputPuppy    Puppy
+		expectedError error
+	}{
+		{"Update puppy successfully", suite.toBeUpdatedPuppy, nil},
+		{"Update non-existing puppy", suite.nonExistPuppy,
+			fmt.Errorf("puppy with %d ID does not exist", suite.nonExistPuppy.ID)},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		suite.T().Run(tc.title, func(t *testing.T) {
+			err := suite.store.UpdatePuppy(tc.inputPuppy)
+			assert.Equal(tc.expectedError, err)
+		})
+	}
+}
+
+func (suite *storerTestSuite) TestReadPuppy() {
+	assert := assert.New(suite.T())
+	testCases := []struct {
+		title         string
+		input         int32
+		expected      Puppy
+		expectedError error
+	}{
+		{"Read puppy successfully", suite.existsPuppy.ID, suite.existsPuppy, nil},
+		{"Read non-existing puppy", suite.nonExistPuppy.ID, Puppy{},
+			fmt.Errorf("puppy with %d ID does not exist", suite.nonExistPuppy.ID)},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		suite.T().Run(tc.title, func(t *testing.T) {
+			readPuppy, err := suite.store.ReadPuppy(tc.input)
+			assert.Equal(tc.expected, readPuppy)
+			assert.Equal(tc.expectedError, err)
+		})
+	}
+}
+
+func (suite *storerTestSuite) TestDeletePuppy() {
+	assert := assert.New(suite.T())
+	testCases := []struct {
+		title         string
+		input         int32
+		expectedError error
+	}{
+		{"Delete puppy successfully", suite.existsPuppy.ID, nil},
+		{"Delete non-existing puppy", suite.nonExistPuppy.ID,
+			fmt.Errorf("puppy with %d ID does not exist", suite.nonExistPuppy.ID)},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		suite.T().Run(tc.title, func(t *testing.T) {
+			err := suite.store.DeletePuppy(tc.input)
+			assert.Equal(tc.expectedError, err)
+		})
+	}
+}
+
+func TestStorers(t *testing.T) {
+	suite.Run(t, &storerTestSuite{
+		makeStore: func() Storer { return NewMapStore() },
+	})
+	suite.Run(t, &storerTestSuite{
+		makeStore: func() Storer { return NewSyncStore() },
+	})
+}