Create book library project with book inserter

Author: rafaelhl

.gitignore

@@ -0,0 +1 @@
+.idea

books/booksinserter/booksinserter.go

@@ -0,0 +1,45 @@
+//go:generate mockery -name=InserterEngine
+//go:generate mockery -name=ShelfFinder
+
+package booksinserter
+
+import (
+	"context"
+	"errors"
+
+	"github.com/rafaelhl/library-rel-lib/books"
+)
+
+type (
+	InserterEngine interface {
+		InsertBook(ctx context.Context, book books.Book) error
+	}
+
+	ShelfFinder interface {
+		FindShelf(ctx context.Context, shelfID int) (books.Shelf, error)
+	}
+
+	Inserter struct {
+		inserterEngine InserterEngine
+		shelfFinder    ShelfFinder
+	}
+)
+
+func New(repository InserterEngine, shelfFinder ShelfFinder) Inserter {
+	return Inserter{
+		inserterEngine: repository,
+		shelfFinder:    shelfFinder,
+	}
+}
+
+func (i Inserter) InsertBook(ctx context.Context, book books.Book) error {
+	shelf, err := i.shelfFinder.FindShelf(ctx, book.BookShelf.ID)
+	if err != nil {
+		return err
+	}
+	if len(shelf.Books) >= shelf.Capacity {
+		return errors.New("shelf fully choose another shelf")
+	}
+
+	return i.inserterEngine.InsertBook(ctx, book)
+}

books/booksinserter/booksinserter_test.go

@@ -0,0 +1,118 @@
+package booksinserter_test
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/rafaelhl/library-rel-lib/books"
+	"github.com/rafaelhl/library-rel-lib/books/booksinserter"
+	"github.com/rafaelhl/library-rel-lib/books/booksinserter/mocks"
+)
+
+var (
+	book = books.Book{
+		Title:       "Livro de Teste",
+		Description: "Esse livro é de teste",
+		Author:      "Rafael Holanda",
+		Edition:     1,
+		BookShelf: books.Shelf{
+			ID: 1,
+		},
+	}
+	shelf = books.Shelf{
+		ID:       1,
+		Capacity: 2,
+		Amount:   0,
+	}
+)
+
+type mocked struct {
+	inserter *mocks.InserterEngine
+	finder   *mocks.ShelfFinder
+}
+
+func (m mocked) assertExpectations(t *testing.T) {
+	m.inserter.AssertExpectations(t)
+	m.finder.AssertExpectations(t)
+}
+
+func doMock() (booksinserter.Inserter, mocked) {
+	m := mocked{
+		inserter: new(mocks.InserterEngine),
+		finder:   new(mocks.ShelfFinder),
+	}
+	return booksinserter.New(m.inserter, m.finder), m
+}
+
+func TestInserter_InsertBook(t *testing.T) {
+	ctx := context.Background()
+	inserter, m := doMock()
+	m.finder.On("FindShelf", ctx, book.BookShelf.ID).Return(shelf, nil)
+	m.inserter.On("InsertBook", ctx, book).Return(nil)
+
+	err := inserter.InsertBook(ctx, book)
+
+	m.assertExpectations(t)
+	assert.NoError(t, err)
+}
+
+func TestInserter_InsertBook_Fail(t *testing.T) {
+	ctx := context.Background()
+	inserter, m := doMock()
+	m.finder.On("FindShelf", ctx, book.BookShelf.ID).Return(shelf, nil)
+	m.inserter.On("InsertBook", ctx, book).Return(errors.New("unexpected error!"))
+
+	err := inserter.InsertBook(ctx, book)
+
+	m.assertExpectations(t)
+	assert.Error(t, err)
+}
+
+func TestInserter_InsertBook_FindShelfFail(t *testing.T) {
+	ctx := context.Background()
+	inserter, m := doMock()
+	m.finder.On("FindShelf", ctx, book.BookShelf.ID).Return(books.Shelf{}, errors.New("unexpected error!"))
+
+	err := inserter.InsertBook(ctx, book)
+
+	m.assertExpectations(t)
+	assert.Error(t, err)
+}
+
+func TestInserter_InsertBook_ShelfFully(t *testing.T) {
+	ctx := context.Background()
+	inserter, m := doMock()
+	s := books.Shelf{
+		ID:       shelf.ID,
+		Capacity: shelf.Capacity,
+		Amount:   shelf.Amount,
+		Books: []books.Book{
+			{
+				ID:          1,
+				Title:       "Teste 1",
+				Description: "Teste 1",
+				Author:      "Teste 1",
+				Edition:     rand.Int(),
+				ShelfID:     shelf.ID,
+			},
+			{
+				ID:          2,
+				Title:       "Teste 2",
+				Description: "Teste 2",
+				Author:      "Teste 2",
+				Edition:     rand.Int(),
+				ShelfID:     shelf.ID,
+			},
+		},
+	}
+	m.finder.On("FindShelf", ctx, book.BookShelf.ID).Return(s, nil)
+
+	err := inserter.InsertBook(ctx, book)
+
+	m.assertExpectations(t)
+	assert.Error(t, err)
+}

books/booksinserter/mocks/InserterEngine.go

@@ -0,0 +1,34 @@
+package books
+
+import (
+	"time"
+)
+
+type (
+	Book struct {
+		ID          int       `json:"id"`
+		Title       string    `json:"title"`
+		Description string    `json:"description"`
+		Author      string    `json:"author"`
+		Edition     int       `json:"edition"`
+		ShelfID     int       `db:"shelf_id"`
+		CreatedAt   time.Time `json:"-"`
+		UpdatedAt   time.Time `json:"-"`
+		BookShelf   Shelf     `json:"shelf" ref:"shelf_id" fk:"id"`
+	}
+
+	Shelf struct {
+		ID       int    `json:"id"`
+		Capacity int    `json:"-"`
+		Amount   int    `json:"-"`
+		Books    []Book `json:"-" ref:"id" fk:"shelf_id"`
+	}
+)
+
+func (Book) Table() string {
+	return "book"
+}
+
+func (Shelf) Table() string {
+	return "shelf"
+}

books/booksinserter/mocks/ShelfFinder.go

@@ -0,0 +1,42 @@
+//go:generate mockery -name=BookInserter
+
+package bookinsert
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"github.com/rafaelhl/library-rel-lib/books"
+)
+
+type (
+	BookInserter interface {
+		InsertBook(ctx context.Context, book books.Book) error
+	}
+
+	handler struct {
+		inserter BookInserter
+	}
+)
+
+func NewHandler(inserter BookInserter) handler {
+	return handler{
+		inserter: inserter,
+	}
+}
+
+func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	var book books.Book
+	err := json.NewDecoder(r.Body).Decode(&book)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	err = h.inserter.InsertBook(r.Context(), book)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+}

books/entities.go

@@ -0,0 +1,76 @@
+package bookinsert_test
+
+import (
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/go-chi/chi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/rafaelhl/library-rel-lib/books"
+	"github.com/rafaelhl/library-rel-lib/books/handler/bookinsert"
+	"github.com/rafaelhl/library-rel-lib/books/handler/bookinsert/mocks"
+)
+
+var (
+	body, _ = ioutil.ReadFile("mocks/book.json")
+	book    = books.Book{
+		Title:       "Livro de Teste",
+		Description: "Esse livro é de teste",
+		Author:      "Rafael Holanda",
+		Edition:     1,
+		BookShelf: books.Shelf{
+			ID: 1,
+		},
+	}
+)
+
+func TestHandler_ServeHTTP(t *testing.T) {
+	inserter := new(mocks.BookInserter)
+	inserter.On("InsertBook", mock.Anything, book).Return(nil)
+
+	recorder := sendRequest(inserter, strings.NewReader(string(body)))
+
+	inserter.AssertExpectations(t)
+
+	assert.Equal(t, http.StatusOK, recorder.Code)
+	inserter.AssertExpectations(t)
+}
+
+func TestHandler_ServeHTTP_InvalidPayload(t *testing.T) {
+	inserter := new(mocks.BookInserter)
+	recorder := sendRequest(inserter, strings.NewReader("{"))
+
+	inserter.AssertExpectations(t)
+
+	assert.Equal(t, http.StatusInternalServerError, recorder.Code)
+	inserter.AssertExpectations(t)
+}
+
+func TestHandler_ServeHTTP_InsertFail(t *testing.T) {
+	inserter := new(mocks.BookInserter)
+	inserter.On("InsertBook", mock.Anything, book).Return(errors.New("unexpected error!"))
+
+	recorder := sendRequest(inserter, strings.NewReader(string(body)))
+
+	inserter.AssertExpectations(t)
+
+	assert.Equal(t, http.StatusInternalServerError, recorder.Code)
+	inserter.AssertExpectations(t)
+}
+
+func sendRequest(inserter *mocks.BookInserter, body io.Reader) *httptest.ResponseRecorder {
+	mux := chi.NewMux()
+	handler := bookinsert.NewHandler(inserter)
+	mux.Method(http.MethodPost, "/books", handler)
+
+	recorder := httptest.NewRecorder()
+	mux.ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/books", body))
+	return recorder
+}