Merge branch 'main' of github.com:thenativeweb/temp--techlounge

Author: goloroden

.github/workflows/lint-pr-title.yml

@@ -18,7 +18,7 @@ jobs:
 
     steps:
       - name: Lint PR Title
-        uses: amannn/action-semantic-pull-request@v5
+        uses: amannn/action-semantic-pull-request@v6
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:

.github/workflows/qa.yml

@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: Clone repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Install Go
         uses: actions/setup-go@v5
         with:

.github/workflows/release.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Clone repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: "0"
       - name: Install Go

api/alltodos/handle_test.go

@@ -0,0 +1,45 @@
+package alltodos_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/techlounge-to-do/api/alltodos"
+)
+
+func TestHandle(t *testing.T) {
+	payload := &alltodos.ResponseBody{
+		ToDos: []alltodos.ResponseBodyToDo{
+			{ID: "1", Intention: "Buy milk", IsCompleted: false},
+			{ID: "2", Intention: "Read book", IsCompleted: true},
+		},
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/todos", nil)
+	rr := httptest.NewRecorder()
+
+	handler := alltodos.Handle(payload)
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+	assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
+
+	var responseBody alltodos.ResponseBody
+	err := json.NewDecoder(rr.Body).Decode(&responseBody)
+	assert.NoError(t, err)
+
+	assert.Len(t, responseBody.ToDos, 2)
+	assert.Equal(
+		t,
+		alltodos.ResponseBodyToDo{ID: "1", Intention: "Buy milk", IsCompleted: false},
+		responseBody.ToDos[0],
+	)
+	assert.Equal(
+		t,
+		alltodos.ResponseBodyToDo{ID: "2", Intention: "Read book", IsCompleted: true},
+		responseBody.ToDos[1],
+	)
+}

api/completetodo/handle.go

@@ -36,7 +36,7 @@ func Handle(client *eventsourcingdb.Client) http.HandlerFunc {
 		// taking events back, and writing them to the database
 		// should happen there. This is a bit of a mess right now.
 
-		todo := domain.NewTodo(id)
+		todo := domain.NewToDo(id)
 
 		latestEventID := ""
 		for event, err := range client.ReadEvents(

api/memorizetodo/handle.go

@@ -41,7 +41,7 @@ func Handle(client *eventsourcingdb.Client) http.HandlerFunc {
 		// taking events back, and writing them to the database
 		// should happen there. This is a bit of a mess right now.
 
-		todo := domain.NewTodo(id)
+		todo := domain.NewToDo(id)
 		toDoMemorized, err := todo.Memorize(intention, details)
 		if err != nil {
 			logging.Error("failed to memorize todo", "error", err)

api/memorizetodo/handle_test.go

@@ -0,0 +1,65 @@
+package memorizetodo_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/eventsourcingdb-client-golang/eventsourcingdb"
+	"github.com/thenativeweb/techlounge-to-do/api/memorizetodo"
+	"github.com/thenativeweb/techlounge-to-do/domain"
+)
+
+func TestHandle(t *testing.T) {
+	container := eventsourcingdb.NewContainer().
+		WithImageTag("1.1.0").
+		WithAPIToken("secret")
+
+	err := container.Start(t.Context())
+	assert.NoError(t, err)
+	defer container.Stop(t.Context())
+
+	client, err := container.GetClient(t.Context())
+	assert.NoError(t, err)
+
+	requestBody := `{"intention":"Buy milk","details":"Remember to buy milk on the way home."}`
+	req := httptest.NewRequest(http.MethodPost, "/memorize-to-do", strings.NewReader(requestBody))
+	rr := httptest.NewRecorder()
+
+	handler := memorizetodo.Handle(client)
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+	assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
+
+	var responseBody memorizetodo.ResponseBody
+	err = json.NewDecoder(rr.Body).Decode(&responseBody)
+	assert.NoError(t, err)
+	assert.NotEqual(t, uuid.Nil, responseBody.ID)
+
+	var events []eventsourcingdb.Event
+	for event, err := range client.ReadEvents(
+		t.Context(),
+		"/",
+		eventsourcingdb.ReadEventsOptions{Recursive: true},
+	) {
+		assert.NoError(t, err)
+		events = append(events, event)
+	}
+
+	assert.Len(t, events, 1)
+
+	event := events[0]
+	assert.Equal(t, domain.ToDoMemorizedEventType, event.Type)
+
+	var memorizedEvent domain.ToDoMemorized
+	err = json.Unmarshal(event.Data, &memorizedEvent)
+	assert.NoError(t, err)
+
+	assert.Equal(t, "Buy milk", memorizedEvent.Intention)
+	assert.Equal(t, "Remember to buy milk on the way home.", memorizedEvent.Details)
+}

api/ping/handle_test.go

@@ -0,0 +1,27 @@
+package ping_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/techlounge-to-do/api/ping"
+)
+
+func TestHandle(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/ping", nil)
+	rr := httptest.NewRecorder()
+
+	handler := ping.Handle()
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+	assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
+
+	var responseBody ping.ResponseBody
+	err := json.NewDecoder(rr.Body).Decode(&responseBody)
+	assert.NoError(t, err)
+	assert.Equal(t, "pong", responseBody.Ping)
+}

domain/to_do.go

@@ -12,7 +12,7 @@ type ToDo struct {
 	IsCompleted bool
 }
 
-func NewTodo(id uuid.UUID) *ToDo {
+func NewToDo(id uuid.UUID) *ToDo {
 	return &ToDo{
 		ID:          id,
 		IsCompleted: false,

domain/to_do_test.go

@@ -0,0 +1,38 @@
+package domain_test
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/techlounge-to-do/domain"
+)
+
+func TestNewToDo(t *testing.T) {
+	id := uuid.New()
+	toDo := domain.NewToDo(id)
+
+	assert.Equal(t, id, toDo.ID)
+	assert.False(t, toDo.IsCompleted)
+}
+
+func TestMemorize(t *testing.T) {
+	t.Run("returns a memorized event", func(t *testing.T) {
+		id := uuid.New()
+		toDo := domain.NewToDo(id)
+
+		event, err := toDo.Memorize("Buy milk", "Remember to buy milk on the way home.")
+		assert.NoError(t, err)
+		assert.Equal(t, id, event.ToDoID)
+		assert.Equal(t, "Buy milk", event.Intention)
+		assert.Equal(t, "Remember to buy milk on the way home.", event.Details)
+	})
+
+	t.Run("returns an error if intention is empty", func(t *testing.T) {
+		id := uuid.New()
+		toDo := domain.NewToDo(id)
+
+		_, err := toDo.Memorize("", "Some details")
+		assert.Error(t, err)
+	})
+}