Additional functionality to util package

CHANGELOG.md

@@ -10,6 +10,12 @@
 ## Unreleased
 
 ### Changed
+- Extend util package with additional helper functions.
+- Add MIME interface to use *mimtype.MIME or an already KnownMIME.
+- Add function to detach context to avoid context cancelation. Can be used to pass context information to go routines without a deadline or cancel.
+- Add oauth2 helper for PKCE extention to generate verifier and challenge.
+- **DEPRECATED** Add starttls support to mailer. If you were using the `SERVER_SMTP_USE_TLS` flag before to enable TLS you need to change it to the `SERVER_SMTP_ENCRYPTION` setting and set it to `tls`.
+- Extend mailer mock to support waiting for all expected mails to arrive to check asynchronously sent mails in tests.
 
 ## 2021-10-19
 

go.mod

@@ -31,6 +31,7 @@ require (
 	github.com/volatiletech/strmangle v0.0.1
 	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519
 	golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6
+	golang.org/x/text v0.3.7
 	google.golang.org/api v0.57.0
 )
 
@@ -101,7 +102,6 @@ require (
 	go.opencensus.io v0.23.0 // indirect
 	golang.org/x/net v0.0.0-20210913180222-943fd674d43e // indirect
 	golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f // indirect
-	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	google.golang.org/appengine v1.6.7 // indirect

internal/api/httperrors/common.go

@@ -0,0 +1,7 @@
+package httperrors
+
+import "net/http"
+
+var (
+	ErrBadRequestZeroFileSize = NewHTTPError(http.StatusBadRequest, "ZERO_FILE_SIZE", "File size of 0 is not supported.")
+)

internal/config/server_config.go

@@ -185,13 +185,14 @@ func DefaultServiceConfigFromEnv() Server {
 				Transporter:                 util.GetEnvEnum("SERVER_MAILER_TRANSPORTER", MailerTransporterMock.String(), []string{MailerTransporterSMTP.String(), MailerTransporterMock.String()}),
 			},
 			SMTP: transport.SMTPMailTransportConfig{
-				Host:      util.GetEnv("SERVER_SMTP_HOST", "mailhog"),
-				Port:      util.GetEnvAsInt("SERVER_SMTP_PORT", 1025),
-				Username:  util.GetEnv("SERVER_SMTP_USERNAME", ""),
-				Password:  util.GetEnv("SERVER_SMTP_PASSWORD", ""),
-				AuthType:  transport.SMTPAuthTypeFromString(util.GetEnv("SERVER_SMTP_AUTH_TYPE", transport.SMTPAuthTypeNone.String())),
-				UseTLS:    util.GetEnvAsBool("SERVER_SMTP_USE_TLS", false),
-				TLSConfig: nil,
+				Host:       util.GetEnv("SERVER_SMTP_HOST", "mailhog"),
+				Port:       util.GetEnvAsInt("SERVER_SMTP_PORT", 1025),
+				Username:   util.GetEnv("SERVER_SMTP_USERNAME", ""),
+				Password:   util.GetEnv("SERVER_SMTP_PASSWORD", ""),
+				AuthType:   transport.SMTPAuthTypeFromString(util.GetEnv("SERVER_SMTP_AUTH_TYPE", transport.SMTPAuthTypeNone.String())),
+				Encryption: transport.SMTPEncryption(util.GetEnvEnum("SERVER_SMTP_ENCRYPTION", transport.SMTPEncryptionNone.String(), []string{transport.SMTPEncryptionNone.String(), transport.SMTPEncryptionTLS.String(), transport.SMTPEncryptionStartTLS.String()})),
+				UseTLS:     util.GetEnvAsBool("SERVER_SMTP_USE_TLS", false),
+				TLSConfig:  nil,
 			},
 			Frontend: FrontendServer{
 				BaseURL:               util.GetEnv("SERVER_FRONTEND_BASE_URL", "http://localhost:3000"),

internal/mailer/transport/mock.go

@@ -2,19 +2,24 @@ package transport
 
 import (
 	"sync"
+	"time"
 
+	"allaboutapps.dev/aw/go-starter/internal/util"
 	"github.com/jordan-wright/email"
 )
 
 type MockMailTransport struct {
 	sync.RWMutex
-	mails []*email.Email
+	mails      []*email.Email
+	OnMailSent func(mail email.Email) // non pointer to prevent concurrent read errors
+	wg         sync.WaitGroup
 }
 
 func NewMock() *MockMailTransport {
 	return &MockMailTransport{
-		RWMutex: sync.RWMutex{},
-		mails:   make([]*email.Email, 0),
+		RWMutex:    sync.RWMutex{},
+		mails:      make([]*email.Email, 0),
+		OnMailSent: func(mail email.Email) {},
 	}
 }
 
@@ -23,6 +28,7 @@ func (m *MockMailTransport) Send(mail *email.Email) error {
 	defer m.Unlock()
 
 	m.mails = append(m.mails, mail)
+	m.OnMailSent(*mail)
 
 	return nil
 }
@@ -44,3 +50,17 @@ func (m *MockMailTransport) GetSentMails() []*email.Email {
 
 	return m.mails
 }
+
+// Expect adds the mailCnt to a waitgroup and sets the OnMailSent callback
+// to call wg.Done()
+func (m *MockMailTransport) Expect(mailCnt int) {
+	m.wg.Add(mailCnt)
+	m.OnMailSent = func(email.Email) {
+		m.wg.Done()
+	}
+}
+
+// Wait until all expected mails have arrived
+func (m *MockMailTransport) Wait() {
+	_ = util.WaitTimeout(&m.wg, time.Second*10)
+}

internal/mailer/transport/smtp.go

@@ -38,5 +38,14 @@ func (m *SMTPMailTransport) Send(mail *email.Email) error {
 		return mail.SendWithTLS(m.addr, m.auth, m.config.TLSConfig)
 	}
 
-	return mail.Send(m.addr, m.auth)
+	switch m.config.Encryption {
+	case SMTPEncryptionNone:
+		return mail.Send(m.addr, m.auth)
+	case SMTPEncryptionTLS:
+		return mail.SendWithTLS(m.addr, m.auth, m.config.TLSConfig)
+	case SMTPEncryptionStartTLS:
+		return mail.SendWithStartTLS(m.addr, m.auth, m.config.TLSConfig)
+	default:
+		return fmt.Errorf("invalid SMTP encryption %q", m.config.Encryption)
+	}
 }

internal/mailer/transport/smtp_config.go

@@ -47,12 +47,36 @@ func SMTPAuthTypeFromString(s string) SMTPAuthType {
 	}
 }
 
+type SMTPEncryption string
+
+const (
+	SMTPEncryptionNone     SMTPEncryption = "none"
+	SMTPEncryptionTLS      SMTPEncryption = "tls"
+	SMTPEncryptionStartTLS SMTPEncryption = "starttls"
+)
+
+func (e SMTPEncryption) String() string {
+	return string(e)
+}
+
+func SMTPEncryptionFromString(s string) SMTPEncryption {
+	switch strings.ToLower(s) {
+	case "tls":
+		return SMTPEncryptionTLS
+	case "starttls":
+		return SMTPEncryptionStartTLS
+	default:
+		return SMTPEncryptionNone
+	}
+}
+
 type SMTPMailTransportConfig struct {
-	Host      string
-	Port      int
-	AuthType  SMTPAuthType `json:"-"` // iota
-	Username  string
-	Password  string `json:"-"` // sensitive
-	UseTLS    bool
-	TLSConfig *tls.Config `json:"-"` // pointer
+	Host       string
+	Port       int
+	AuthType   SMTPAuthType `json:"-"` // iota
+	Username   string
+	Password   string         `json:"-"` // sensitive
+	Encryption SMTPEncryption `json:"-"` // iota
+	TLSConfig  *tls.Config    `json:"-"` // pointer
+	UseTLS     bool           // ! deprecated since 2021-10-25, use Encryption type 'SMTPEncryptionTLS' instead
 }

internal/util/bool.go

@@ -0,0 +1,10 @@
+package util
+
+// FalseIfNil returns false if the passed pointer is nil. Passing a pointer to a bool will return the value of the bool.
+func FalseIfNil(b *bool) bool {
+	if b == nil {
+		return false
+	}
+
+	return *b
+}

internal/util/bool_test.go

@@ -0,0 +1,16 @@
+package util_test
+
+import (
+	"testing"
+
+	"allaboutapps.dev/aw/go-starter/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFalseIfNil(t *testing.T) {
+	b := true
+	assert.True(t, util.FalseIfNil(&b))
+	b = false
+	assert.False(t, util.FalseIfNil(&b))
+	assert.False(t, util.FalseIfNil(nil))
+}

internal/util/context.go

@@ -3,18 +3,35 @@ package util
 import (
 	"context"
 	"errors"
+	"time"
 )
 
 type contextKey string
 
 const (
 	CTXKeyUser          contextKey = "user"
 	CTXKeyAccessToken   contextKey = "access_token"
+	CTXKeyCacheControl  contextKey = "cache_control"
 	CTXKeyRequestID     contextKey = "request_id"
 	CTXKeyDisableLogger contextKey = "disable_logger"
-	CTXKeyCacheControl  contextKey = "cache_control"
 )
 
+type detachedContext struct {
+	parent context.Context
+}
+
+func (c detachedContext) Deadline() (time.Time, bool)       { return time.Time{}, false }
+func (c detachedContext) Done() <-chan struct{}             { return nil }
+func (c detachedContext) Err() error                        { return nil }
+func (c detachedContext) Value(key interface{}) interface{} { return c.parent.Value(key) }
+
+// DetachContext detaches a context by returning a wrapped struct implementing the context interface, but omitting the deadline, done and error functionality.
+// Mainly used to pass context information to go routines that should not be cancelled by the context.
+// ! USE THIS DETACHED CONTEXT SPARINGLY, ONLY IF ABSOLUTELY NEEDED. DO *NOT* KEEP USING A DETACHED CONTEXT FOR A PROLONGED TIME OUT OF CHAIN
+func DetachContext(ctx context.Context) context.Context {
+	return detachedContext{ctx}
+}
+
 // RequestIDFromContext returns the ID of the (HTTP) request, returning an error if it is not present.
 func RequestIDFromContext(ctx context.Context) (string, error) {
 	val := ctx.Value(CTXKeyRequestID)

internal/util/context_test.go

@@ -0,0 +1,83 @@
+package util_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"allaboutapps.dev/aw/go-starter/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+type contextKey string
+
+func TestDetachContextWithCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	var key contextKey = "test"
+	val := 42
+	ctx2 := context.WithValue(ctx, key, val)
+	detachedContext := util.DetachContext(ctx2)
+
+	cancel()
+
+	select {
+	case <-ctx.Done():
+		t.Log("Context cancelled")
+	default:
+		t.Error("Context is not canceled")
+	}
+
+	select {
+	case <-ctx2.Done():
+		t.Log("Context with value cancelled")
+	default:
+		t.Error("Context with value is not canceled")
+	}
+
+	select {
+	case <-detachedContext.Done():
+		t.Error("Detached context is cancelled")
+	default:
+		t.Log("Detached context is not cancelled")
+	}
+
+	res := detachedContext.Value(key).(int)
+	assert.Equal(t, val, res)
+}
+
+func TestDetachContextWithDeadline(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*1)
+	defer cancel()
+
+	var key contextKey = "test"
+	val := 42
+	ctx2 := context.WithValue(ctx, key, val)
+	detachedContext := util.DetachContext(ctx2)
+
+	time.Sleep(time.Second * 2)
+
+	select {
+	case <-ctx.Done():
+		t.Log("Context cancelled")
+	default:
+		t.Error("Context is not canceled")
+	}
+
+	select {
+	case <-ctx2.Done():
+		t.Log("Context with value cancelled")
+	default:
+		t.Error("Context with value is not canceled")
+	}
+
+	select {
+	case <-detachedContext.Done():
+		t.Error("Detached context is cancelled")
+	default:
+		t.Log("Detached context is not cancelled")
+	}
+
+	res := detachedContext.Value(key).(int)
+	assert.Equal(t, val, res)
+}

internal/util/currency.go

@@ -38,6 +38,10 @@ func Float64PtrToInt64WithCents(f *float64) int64 {
 	return int64(swag.Float64Value(f) * 100)
 }
 
+func Float64ToInt64WithCents(f float64) int64 {
+	return int64(f * 100)
+}
+
 func Float64PtrToIntPtrWithCents(f *float64) *int {
 	if f == nil {
 		return nil

internal/util/currency_test.go

@@ -46,6 +46,8 @@ func TestCurrencyConversion(t *testing.T) {
 			res = util.IntPtrWithCentsToFloat64Ptr(&inInt)
 			outInt := util.Float64PtrToIntPtrWithCents(res)
 			assert.Equal(t, inInt, *outInt)
+			outInt2 := util.Float64ToInt64WithCents(*res)
+			assert.Equal(t, int64(inInt), outInt2)
 		})
 	}
 }

internal/util/db/db.go

@@ -63,3 +63,25 @@ func NullFloat32FromFloat64Ptr(f *float64) null.Float32 {
 	}
 	return null.NewFloat32(float32(*f), true)
 }
+
+func NullIntFromInt16Ptr(i *int16) null.Int {
+	if i == nil {
+		return null.NewInt(0, false)
+	}
+	return null.NewInt(int(*i), true)
+}
+
+func Int16PtrFromNullInt(i null.Int) *int16 {
+	if !i.Valid {
+		return nil
+	}
+
+	res := int16(i.Int)
+	return &res
+}
+
+func Int16PtrFromInt(i int) *int16 {
+	res := int16(i)
+
+	return &res
+}