Add 'types/' from commit '38a6e18f9010e700a60c91db6bc276b9966cdff3'

git-subtree-dir: types
git-subtree-mainline: b8dc2db
git-subtree-split: 38a6e18

Author: Jamie Tanna

types/date.go

@@ -0,0 +1,43 @@
+package types
+
+import (
+	"encoding/json"
+	"time"
+)
+
+const DateFormat = "2006-01-02"
+
+type Date struct {
+	time.Time
+}
+
+func (d Date) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.Time.Format(DateFormat))
+}
+
+func (d *Date) UnmarshalJSON(data []byte) error {
+	var dateStr string
+	err := json.Unmarshal(data, &dateStr)
+	if err != nil {
+		return err
+	}
+	parsed, err := time.Parse(DateFormat, dateStr)
+	if err != nil {
+		return err
+	}
+	d.Time = parsed
+	return nil
+}
+
+func (d Date) String() string {
+	return d.Time.Format(DateFormat)
+}
+
+func (d *Date) UnmarshalText(data []byte) error {
+	parsed, err := time.Parse(DateFormat, string(data))
+	if err != nil {
+		return err
+	}
+	d.Time = parsed
+	return nil
+}

types/date_test.go

@@ -0,0 +1,65 @@
+package types
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDate_MarshalJSON(t *testing.T) {
+	testDate := time.Date(2019, 4, 1, 0, 0, 0, 0, time.UTC)
+	b := struct {
+		DateField Date `json:"date"`
+	}{
+		DateField: Date{testDate},
+	}
+	jsonBytes, err := json.Marshal(b)
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{"date":"2019-04-01"}`, string(jsonBytes))
+}
+
+func TestDate_UnmarshalJSON(t *testing.T) {
+	testDate := time.Date(2019, 4, 1, 0, 0, 0, 0, time.UTC)
+	jsonStr := `{"date":"2019-04-01"}`
+	b := struct {
+		DateField Date `json:"date"`
+	}{}
+	err := json.Unmarshal([]byte(jsonStr), &b)
+	assert.NoError(t, err)
+	assert.Equal(t, testDate, b.DateField.Time)
+}
+
+func TestDate_Stringer(t *testing.T) {
+	t.Run("nil date", func(t *testing.T) {
+		var d *Date
+		assert.Equal(t, "<nil>", fmt.Sprintf("%v", d))
+	})
+
+	t.Run("ptr date", func(t *testing.T) {
+		d := &Date{
+			Time: time.Date(2019, 4, 1, 0, 0, 0, 0, time.UTC),
+		}
+		assert.Equal(t, "2019-04-01", fmt.Sprintf("%v", d))
+	})
+
+	t.Run("value date", func(t *testing.T) {
+		d := Date{
+			Time: time.Date(2019, 4, 1, 0, 0, 0, 0, time.UTC),
+		}
+		assert.Equal(t, "2019-04-01", fmt.Sprintf("%v", d))
+	})
+}
+
+func TestDate_UnmarshalText(t *testing.T) {
+	testDate := time.Date(2022, 6, 14, 0, 0, 0, 0, time.UTC)
+	value := []byte("2022-06-14")
+
+	date := Date{}
+	err := date.UnmarshalText(value)
+
+	assert.NoError(t, err)
+	assert.Equal(t, testDate, date.Time)
+}

types/email.go

@@ -0,0 +1,40 @@
+package types
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+// ErrValidationEmail is the sentinel error returned when an email fails validation
+var ErrValidationEmail = errors.New("email: failed to pass regex validation")
+
+// Email represents an email address.
+// It is a string type that must pass regex validation before being marshalled
+// to JSON or unmarshalled from JSON.
+type Email string
+
+func (e Email) MarshalJSON() ([]byte, error) {
+	if !emailRegex.MatchString(string(e)) {
+		return nil, ErrValidationEmail
+	}
+
+	return json.Marshal(string(e))
+}
+
+func (e *Email) UnmarshalJSON(data []byte) error {
+	if e == nil {
+		return nil
+	}
+
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+
+	*e = Email(s)
+	if !emailRegex.MatchString(s) {
+		return ErrValidationEmail
+	}
+
+	return nil
+}

types/email_test.go

@@ -0,0 +1,176 @@
+package types
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEmail_MarshalJSON_Validation(t *testing.T) {
+	type requiredEmail struct {
+		EmailField Email `json:"email"`
+	}
+
+	testCases := map[string]struct {
+		email         Email
+		expectedJSON  []byte
+		expectedError error
+	}{
+		"it should succeed marshalling a valid email and return valid JSON populated with the email": {
+			email:         Email("validemail@openapicodegen.com"),
+			expectedJSON:  []byte(`{"email":"validemail@openapicodegen.com"}`),
+			expectedError: nil,
+		},
+		"it should fail marshalling an invalid email and return a validation error": {
+			email:         Email("invalidemail"),
+			expectedJSON:  nil,
+			expectedError: ErrValidationEmail,
+		},
+		"it should fail marshalling an empty email and return a validation error": {
+			email:         Email(""),
+			expectedJSON:  nil,
+			expectedError: ErrValidationEmail,
+		},
+	}
+
+	for name, tc := range testCases {
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			jsonBytes, err := json.Marshal(requiredEmail{EmailField: tc.email})
+
+			if tc.expectedError != nil {
+				assert.ErrorIs(t, err, tc.expectedError)
+			} else {
+				assert.JSONEq(t, string(tc.expectedJSON), string(jsonBytes))
+			}
+		})
+	}
+}
+
+func TestEmail_UnmarshalJSON_RequiredEmail_Validation(t *testing.T) {
+	type requiredEmail struct {
+		EmailField Email `json:"email"`
+	}
+
+	requiredEmailTestCases := map[string]struct {
+		jsonStr       string
+		expectedEmail Email
+		expectedError error
+	}{
+		"it should succeed validating a valid email during the unmarshal process": {
+			jsonStr:       `{"email":"gaben@valvesoftware.com"}`,
+			expectedError: nil,
+			expectedEmail: func() Email {
+				e := Email("gaben@valvesoftware.com")
+				return e
+			}(),
+		},
+		"it should fail validating an invalid email": {
+			jsonStr:       `{"email":"not-an-email"}`,
+			expectedError: ErrValidationEmail,
+			expectedEmail: func() Email {
+				e := Email("not-an-email")
+				return e
+			}(),
+		},
+		"it should fail validating an empty email": {
+			jsonStr: `{"email":""}`,
+			expectedEmail: func() Email {
+				e := Email("")
+				return e
+			}(),
+			expectedError: ErrValidationEmail,
+		},
+		"it should fail validating a null email": {
+			jsonStr: `{"email":null}`,
+			expectedEmail: func() Email {
+				e := Email("")
+				return e
+			}(),
+			expectedError: ErrValidationEmail,
+		},
+	}
+
+	for name, tc := range requiredEmailTestCases {
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			b := requiredEmail{}
+			err := json.Unmarshal([]byte(tc.jsonStr), &b)
+			assert.Equal(t, tc.expectedEmail, b.EmailField)
+			assert.ErrorIs(t, err, tc.expectedError)
+		})
+	}
+
+}
+
+func TestEmail_UnmarshalJSON_NullableEmail_Validation(t *testing.T) {
+
+	type nullableEmail struct {
+		EmailField *Email `json:"email,omitempty"`
+	}
+
+	nullableEmailTestCases := map[string]struct {
+		body          nullableEmail
+		jsonStr       string
+		expectedEmail *Email
+		expectedError error
+	}{
+		"it should succeed validating a valid email during the unmarshal process": {
+			body:          nullableEmail{},
+			jsonStr:       `{"email":"gaben@valvesoftware.com"}`,
+			expectedError: nil,
+			expectedEmail: func() *Email {
+				e := Email("gaben@valvesoftware.com")
+				return &e
+			}(),
+		},
+		"it should fail validating an invalid email": {
+			body:          nullableEmail{},
+			jsonStr:       `{"email":"not-an-email"}`,
+			expectedError: ErrValidationEmail,
+			expectedEmail: func() *Email {
+				e := Email("not-an-email")
+				return &e
+			}(),
+		},
+		"it should fail validating an empty email": {
+			body:          nullableEmail{},
+			jsonStr:       `{"email":""}`,
+			expectedError: ErrValidationEmail,
+			expectedEmail: func() *Email {
+				e := Email("")
+				return &e
+			}(),
+		},
+		"it should succeed validating a null email": {
+			body:          nullableEmail{},
+			jsonStr:       `{"email":null}`,
+			expectedEmail: nil,
+			expectedError: nil,
+		},
+		"it should succeed validating a missing email": {
+			body:          nullableEmail{},
+			jsonStr:       `{}`,
+			expectedEmail: nil,
+			expectedError: nil,
+		},
+	}
+
+	for name, tc := range nullableEmailTestCases {
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			err := json.Unmarshal([]byte(tc.jsonStr), &tc.body)
+			assert.Equal(t, tc.expectedEmail, tc.body.EmailField)
+			if tc.expectedError != nil {
+				assert.ErrorIs(t, err, tc.expectedError)
+			}
+		})
+	}
+}

types/file.go

@@ -0,0 +1,71 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"mime/multipart"
+)
+
+type File struct {
+	multipart *multipart.FileHeader
+	data      []byte
+	filename  string
+}
+
+func (file *File) InitFromMultipart(header *multipart.FileHeader) {
+	file.multipart = header
+	file.data = nil
+	file.filename = ""
+}
+
+func (file *File) InitFromBytes(data []byte, filename string) {
+	file.data = data
+	file.filename = filename
+	file.multipart = nil
+}
+
+func (file File) MarshalJSON() ([]byte, error) {
+	b, err := file.Bytes()
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(b)
+}
+
+func (file *File) UnmarshalJSON(data []byte) error {
+	return json.Unmarshal(data, &file.data)
+}
+
+func (file File) Bytes() ([]byte, error) {
+	if file.multipart != nil {
+		f, err := file.multipart.Open()
+		if err != nil {
+			return nil, err
+		}
+		defer func() { _ = f.Close() }()
+		return io.ReadAll(f)
+	}
+	return file.data, nil
+}
+
+func (file File) Reader() (io.ReadCloser, error) {
+	if file.multipart != nil {
+		return file.multipart.Open()
+	}
+	return io.NopCloser(bytes.NewReader(file.data)), nil
+}
+
+func (file File) Filename() string {
+	if file.multipart != nil {
+		return file.multipart.Filename
+	}
+	return file.filename
+}
+
+func (file File) FileSize() int64 {
+	if file.multipart != nil {
+		return file.multipart.Size
+	}
+	return int64(len(file.data))
+}