Lab7 - Errors

07_errors/jimbotech/error_test.go

@@ -0,0 +1,45 @@
+package main
+
+func (s *storesSuite) TestReadFailure() {
+	pup2, err := s.store.ReadPuppy(1)
+	s.Require().Nil(pup2)
+	s.Require().Equal(ErrIDNotFound, err)
+	s.Require().NotEmpty(err.Error())
+}
+
+func (s *storesSuite) TestNegReadFailure() {
+	pup2, err := s.store.ReadPuppy(-1)
+	s.Require().Nil(pup2)
+	s.Require().Equal(ErrValueBelowZero, err)
+}
+
+func (s *storesSuite) TestUpdateError() {
+	create(s)
+	pup2 := Puppy{Breed: "kelpie", Colour: "black", Value: "indispensable"}
+	err := s.store.UpdatePuppy(1, &pup2)
+	s.Require().Equal(ErrIDNotFound, err)
+}
+
+func (s *storesSuite) TestNegUpdateError() {
+	create(s)
+	pup2 := Puppy{Breed: "kelpie", Colour: "black", Value: "indispensable"}
+	err := s.store.UpdatePuppy(-1, &pup2)
+	s.Require().Equal(ErrValueBelowZero, err)
+}
+
+func (s *storesSuite) TestNegDeleteFailure() {
+	err := s.store.DeletePuppy(-1)
+	s.Require().Equal(ErrValueBelowZero, err)
+}
+
+func (s *storesSuite) TestDeleteFailure() {
+	err := s.store.DeletePuppy(1)
+	s.Require().Equal(ErrIDNotFound, err)
+}
+
+func (s *storesSuite) TestError() {
+	var err = &Error{}
+	err = nil
+	res := err.Error()
+	s.Assert().Equal("<nil>", res)
+}

07_errors/jimbotech/mapstore.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"math/rand"
+)
+
+// MapStore stores puppies.
+type MapStore map[int32]*Puppy
+
+// length used for testing.
+func (s MapStore) length() int {
+	return len(s)
+}
+
+// CreatePuppy add a puppy to storage
+// choose a unique member id that is currently not in the collection
+// but will modify the member ID.
+func (s MapStore) CreatePuppy(p *Puppy) (int32, error) {
+	if s == nil {
+		return 0, ErrNotConstructed
+	}
+	for notUnique := true; notUnique; p.ID = rand.Int31() {
+		_, notUnique = s[p.ID]
+	}
+	sp := *p
+	s[p.ID] = &sp
+	return p.ID, nil
+}
+
+// ReadPuppy retrieve your puppy.
+func (s MapStore) ReadPuppy(id int32) (*Puppy, error) {
+	if s == nil {
+		return nil, ErrNotConstructed
+	}
+	if id < 0 {
+		return nil, ErrValueBelowZero
+	}
+	val, found := s[id]
+	if !found {
+		return nil, ErrIDNotFound
+	}
+	retVal := *val
+	return &retVal, nil
+}
+
+// UpdatePuppy update your puppy store.
+func (s MapStore) UpdatePuppy(id int32, puppy *Puppy) error {
+	if s == nil {
+		return ErrNotConstructed
+	}
+	if _, err := s.ReadPuppy(id); err != nil {
+		return err
+	}
+	puppy.ID = id
+	sp := *puppy
+	s[id] = &sp
+	return nil
+}
+
+// DeletePuppy remove the puppy from store.
+func (s MapStore) DeletePuppy(id int32) error {
+	if s == nil {
+		return ErrNotConstructed
+	}
+	if _, err := s.ReadPuppy(id); err != nil {
+		return err
+	}
+	delete(s, id)
+	return nil
+}
+
+// NewMapStore constructor creates the map.
+func NewMapStore() MapStore {
+	return MapStore{}
+}

07_errors/jimbotech/mapstore_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestMapStoreWithoutContructor may not be required as it may not be
+// possible to create an instance of that type without using the constructor
+func TestMapStoreWithoutContructor(t *testing.T) {
+	var puppyStore MapStore
+	pup := Puppy{1, "kelpie", "brown", "indispensable"}
+
+	_, err := puppyStore.CreatePuppy(&pup)
+	assert.Equal(t, ErrNotConstructed, err)
+	err = puppyStore.UpdatePuppy(1, &pup)
+	assert.Equal(t, ErrNotConstructed, err)
+	_, err = puppyStore.ReadPuppy(1)
+	assert.Equal(t, ErrNotConstructed, err)
+	err = puppyStore.DeletePuppy(1)
+	assert.Equal(t, ErrNotConstructed, err)
+}

07_errors/jimbotech/puppy.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+var out io.Writer = os.Stdout
+
+func main() {
+	var puppyStore Storer = NewMapStore()
+	pup := Puppy{Breed: "kelpie", Colour: "brown", Value: "indispensable"}
+	id, _ := puppyStore.CreatePuppy(&pup)
+	if pup, err := puppyStore.ReadPuppy(id); err == nil {
+		fmt.Fprintf(out, "retrieved: %v %v %v\n", pup.Breed, pup.Colour, pup.Value)
+	}
+}

07_errors/jimbotech/puppy_test.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestMain(t *testing.T) {
+	expected := "retrieved: kelpie brown indispensable\n"
+	var buf bytes.Buffer
+	out = &buf
+	main()
+	actual := buf.String()
+	if actual != expected {
+		t.Errorf("expected %v, actual %v", expected, actual)
+	}
+}

07_errors/jimbotech/storer.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"strconv"
+)
+
+// Storer defines standard CRUD operations for Puppy
+type Storer interface {
+	CreatePuppy(p *Puppy) (int32, error)
+	ReadPuppy(ID int32) (*Puppy, error)
+	UpdatePuppy(ID int32, Puppy *Puppy) error
+	DeletePuppy(ID int32) error
+}
+
+// Puppy stores puppy details.
+type Puppy struct {
+	ID     int32
+	Breed  string
+	Colour string
+	Value  string
+}
+
+// mapTest used during testing to verify underlaying map changes
+type mapTest interface {
+	length() int
+}
+
+// Error is a custom error
+type Error struct {
+	Message string
+	Code    int
+}
+
+func (e *Error) Error() string {
+	if e == nil {
+		return "<nil>"
+	}
+	return e.Message + " Error Code: " + strconv.Itoa(e.Code)
+}
+
+const (
+	// ecNegativeID error number if id is negative
+	ecNegativeID = iota
+	// ecNotFound error number if id not found
+	ecNotFound = iota
+	// ecNotConstructed if the interface was called without being constructed first
+	ecNotConstructed = iota
+)
+
+// ErrValueBelowZero error generated if the calu is below zero
+var ErrValueBelowZero = &Error{Message: "id below 0", Code: ecNegativeID}
+
+// ErrIDNotFound error if the requested ID is not in the store
+var ErrIDNotFound = &Error{Message: "id not found", Code: ecNotFound}
+
+// ErrNotConstructed returned if the interface was called without
+// first constructing the underlaying structure.
+var ErrNotConstructed = &Error{Message: "store not created", Code: ecNotConstructed}