Add more tests (#6)

Author: lcd1232

.github/workflows/test.yml

@@ -10,14 +10,18 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: ["1.21", "1.22", "1.23"]
+        go-version: ["1.21", "1.22", "1.23", "1.24", "1.25"]
         include:
-          - go-version: "1.23"
-            upload-coverage: true
           - go-version: "1.21"
             upload-coverage: false
           - go-version: "1.22"
             upload-coverage: false
+          - go-version: "1.23"
+            upload-coverage: false
+          - go-version: "1.24"
+            upload-coverage: false
+          - go-version: "1.25"
+            upload-coverage: true
     steps:
       - uses: actions/checkout@v4
 

.mockery.yaml

@@ -8,3 +8,9 @@ packages:
           dir: .
           mockname: mockDoer
           inpackage: true
+      readCloser:
+        config:
+          filename: mock_read_closer.go
+          dir: .
+          mockname: mockReadCloser
+          inpackage: true

client.go

@@ -12,6 +12,13 @@ type doer interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
+// readCloser is just an interface to generate mocks.
+//
+//nolint:unused
+type readCloser interface {
+	io.ReadCloser
+}
+
 // Client is a client for the Temp Mail API.
 type Client struct {
 	// doer is an HTTP client.

client_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -56,6 +57,15 @@ func TestNewRequest(t *testing.T) {
 		require.NoError(t, err)
 		assert.JSONEq(t, `{"domain":"example.com"}`, string(b))
 	})
+
+	t.Run("JSON marshal error", func(t *testing.T) {
+		c := newClient()
+		// Create a value that cannot be marshaled to JSON
+		invalidData := make(chan int)
+		req, err := c.newRequest(context.Background(), http.MethodPost, "/v1/emails", invalidData)
+		assert.Error(t, err)
+		assert.Nil(t, req)
+	})
 }
 
 // readFile reads the file from the given path.
@@ -72,3 +82,124 @@ func newTestResponse(statusCode int, body []byte) *http.Response {
 		Body:       io.NopCloser(bytes.NewReader(body)),
 	}
 }
+
+func TestClient_do(t *testing.T) {
+	t.Run("success with nil v", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusOK, []byte{}), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		resp, err := c.do(req, nil)
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+	})
+
+	t.Run("error from rawDo", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(nil, assert.AnError)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		_, err = c.do(req, nil)
+		assert.EqualError(t, err, assert.AnError.Error())
+	})
+
+	t.Run("error from checkResponse", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusBadRequest, readFile(t, "testdata/error_response.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		_, err = c.do(req, nil)
+		require.Error(t, err)
+		var httpErr *HTTPError
+		assert.ErrorAs(t, err, &httpErr)
+		assert.NotNil(t, httpErr.Response)
+		assert.Equal(t, HTTPErrorError{
+			Type:   "request_error",
+			Code:   "not_found",
+			Detail: "Attachment not found",
+		}, httpErr.ErrorDetails)
+		assert.Equal(t, HTTPErrorMeta{
+			RequestID: "req_123456789",
+		}, httpErr.Meta)
+	})
+
+	t.Run("JSON decode error", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(200, []byte("invalid json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		var result map[string]interface{}
+		_, err = c.do(req, &result)
+		require.Error(t, err)
+		assert.EqualError(t, err, "invalid character 'i' looking for beginning of value")
+	})
+}
+
+func TestClient_checkResponse(t *testing.T) {
+	t.Run("success response", func(t *testing.T) {
+		c := newClient()
+		resp := newResponse(newTestResponse(http.StatusOK, []byte{}))
+		err := c.checkResponse(resp)
+		require.NoError(t, err)
+	})
+
+	t.Run("error response", func(t *testing.T) {
+		c := newClient()
+		resp := newResponse(newTestResponse(http.StatusBadRequest, readFile(t, "testdata/error_response.json")))
+		err := c.checkResponse(resp)
+		require.Error(t, err)
+		var httpErr *HTTPError
+		require.ErrorAs(t, err, &httpErr)
+		assert.Equal(t, 400, httpErr.Response.StatusCode)
+		assert.Equal(t, "request_error", httpErr.ErrorDetails.Type)
+		assert.Equal(t, "not_found", httpErr.ErrorDetails.Code)
+	})
+
+	t.Run("error response with invalid JSON", func(t *testing.T) {
+		c := newClient()
+		resp := newResponse(newTestResponse(http.StatusBadGateway, []byte("invalid json")))
+		err := c.checkResponse(resp)
+		require.Error(t, err)
+		assert.Errorf(t, err, "invalid character 'i' looking for beginning of value")
+	})
+}
+
+func TestClient_rawDo(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		expectedResp := newTestResponse(http.StatusOK, []byte("test"))
+		mDoer.EXPECT().Do(mock.Anything).Return(expectedResp, nil)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		resp, err := c.rawDo(req)
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+	})
+
+	t.Run("error from doer", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(nil, assert.AnError)
+
+		c := newClient()
+		c.doer = mDoer
+		req, err := c.newRequest(context.Background(), http.MethodGet, "/test", nil)
+		require.NoError(t, err)
+		_, err = c.rawDo(req)
+		assert.EqualError(t, err, assert.AnError.Error())
+	})
+}

create_email_test.go

@@ -2,11 +2,14 @@ package tempmail
 
 import (
 	"context"
+	"net/http"
 	"os"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -60,3 +63,59 @@ func testRateLimit(t *testing.T, resp *Response) {
 	assert.NotZero(t, resp.Rate.Used)
 	assert.True(t, resp.Rate.Reset.After(time.Now()), "reset time should be in the future")
 }
+
+func TestClient_CreateEmail(t *testing.T) {
+	t.Run("success with empty options", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusOK, readFile(t, "testdata/create_email.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		result, resp, err := c.CreateEmail(context.Background(), CreateEmailOptions{})
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+
+		expected := CreateEmailResponse{
+			Email: "[email protected]",
+			TTL:   3600 * time.Second,
+		}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("success with custom options", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusOK, readFile(t, "testdata/create_email.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		result, resp, err := c.CreateEmail(context.Background(), CreateEmailOptions{
+			Email:      "[email protected]",
+			DomainType: DomainTypePublic,
+			Domain:     "example.com",
+		})
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+		assert.NotEmpty(t, result.Email)
+		assert.NotZero(t, result.TTL)
+	})
+
+	t.Run("error from newRequest", func(t *testing.T) {
+		c := newClient()
+		_, _, err := c.CreateEmail(nil, CreateEmailOptions{})
+		assert.EqualError(t, err, "net/http: nil Context")
+	})
+
+	t.Run("error from do", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusBadRequest, readFile(t, "testdata/error_response.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		_, _, err := c.CreateEmail(context.Background(), CreateEmailOptions{Email: "invalid"})
+		require.Error(t, err)
+		var httpErr *HTTPError
+		require.ErrorAs(t, err, &httpErr)
+		assert.Equal(t, "request_error", httpErr.ErrorDetails.Type)
+		assert.Equal(t, "not_found", httpErr.ErrorDetails.Code)
+	})
+}

delete_email_test.go

@@ -0,0 +1,44 @@
+package tempmail
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_DeleteEmail(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusOK, []byte("{}")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		resp, err := c.DeleteEmail(context.Background(), "[email protected]")
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+	})
+
+	t.Run("error from newRequest", func(t *testing.T) {
+		c := newClient()
+		_, err := c.DeleteEmail(nil, "[email protected]")
+		assert.EqualError(t, err, "net/http: nil Context")
+	})
+
+	t.Run("error from do", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusBadRequest, readFile(t, "testdata/error_response.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		_, err := c.DeleteEmail(context.Background(), "[email protected]")
+		require.Error(t, err)
+		var httpErr *HTTPError
+		require.ErrorAs(t, err, &httpErr)
+		assert.Equal(t, "request_error", httpErr.ErrorDetails.Type)
+		assert.Equal(t, "not_found", httpErr.ErrorDetails.Code)
+	})
+}

delete_message_test.go

@@ -0,0 +1,44 @@
+package tempmail
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_DeleteMessage(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusOK, []byte("{}")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		resp, err := c.DeleteMessage(context.Background(), "01JE97FT950QRPDYGDXJ4R43QR")
+		require.NoError(t, err)
+		assert.Equal(t, 200, resp.StatusCode)
+	})
+
+	t.Run("error from newRequest", func(t *testing.T) {
+		c := newClient()
+		_, err := c.DeleteMessage(nil, "01JE97FT950QRPDYGDXJ4R43QR")
+		assert.EqualError(t, err, "net/http: nil Context")
+	})
+
+	t.Run("error from do", func(t *testing.T) {
+		mDoer := newMockDoer(t)
+		mDoer.EXPECT().Do(mock.Anything).Return(newTestResponse(http.StatusBadRequest, readFile(t, "testdata/error_response.json")), nil)
+
+		c := newClient()
+		c.doer = mDoer
+		_, err := c.DeleteMessage(context.Background(), "nonexistent_id")
+		require.Error(t, err)
+		var httpErr *HTTPError
+		require.ErrorAs(t, err, &httpErr)
+		assert.Equal(t, "request_error", httpErr.ErrorDetails.Type)
+		assert.Equal(t, "not_found", httpErr.ErrorDetails.Code)
+	})
+}