refactor server to support variable options

backend/app/api/main.go

@@ -119,7 +119,11 @@ func run(cfg *config.Config) error {
 
 	// =========================================================================
 	// Start Server
-	app.server = server.NewServer(app.conf.Web.Host, app.conf.Web.Port)
+	app.server = server.NewServer(
+		server.WithHost(app.conf.Web.Host),
+		server.WithPort(app.conf.Web.Port),
+	)
+
 	routes := app.newRouter(app.repos)
 
 	if app.conf.Mode != config.ModeDevelopment {

backend/pkgs/server/response.go

@@ -21,7 +21,7 @@ func Respond(w http.ResponseWriter, statusCode int, data interface{}) {
 	}
 
 	// Set the content type and headers once we know marshaling has succeeded.
-	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Type", ContentJSON)
 
 	// Write the status code to the response.
 	w.WriteHeader(statusCode)

backend/pkgs/server/server.go

@@ -12,29 +12,44 @@ import (
 	"time"
 )
 
-// TODO: #2 Implement Go routine pool/job queue
+var (
-
+	ErrServerNotStarted     = errors.New("server not started")
-var ErrServerNotStarted = errors.New("server not started")
+	ErrServerAlreadyStarted = errors.New("server already started")
-var ErrServerAlreadyStarted = errors.New("server already started")
+)
 
 type Server struct {
-	Host string
+	Host   string
-	Port string
+	Port   string
-
 	Worker Worker
-	wg     sync.WaitGroup
+
+	wg sync.WaitGroup
 
 	started      bool
 	activeServer *http.Server
+
+	idleTimeout  time.Duration
+	readTimeout  time.Duration
+	writeTimeout time.Duration
 }
 
-func NewServer(host, port string) *Server {
+func NewServer(opts ...Option) *Server {
-	return &Server{
+	s := &Server{
-		Host:   host,
+		Host:         "localhost",
-		Port:   port,
+		Port:         "8080",
-		wg:     sync.WaitGroup{},
+		Worker:       NewSimpleWorker(),
-		Worker: NewSimpleWorker(),
+		idleTimeout:  30 * time.Second,
+		readTimeout:  10 * time.Second,
+		writeTimeout: 10 * time.Second,
 	}
+
+	for _, opt := range opts {
+		err := opt(s)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	return s
 }
 
 func (s *Server) Shutdown(sig string) error {
@@ -68,9 +83,9 @@ func (s *Server) Start(router http.Handler) error {
 	s.activeServer = &http.Server{
 		Addr:         s.Host + ":" + s.Port,
 		Handler:      router,
-		IdleTimeout:  time.Minute,
+		IdleTimeout:  s.idleTimeout,
-		ReadTimeout:  10 * time.Second,
+		ReadTimeout:  s.readTimeout,
-		WriteTimeout: 10 * time.Second,
+		WriteTimeout: s.writeTimeout,
 	}
 
 	shutdownError := make(chan error)

backend/pkgs/server/server_options.go

@@ -0,0 +1,47 @@
+package server
+
+import "time"
+
+type Option = func(s *Server) error
+
+func WithWorker(w Worker) Option {
+	return func(s *Server) error {
+		s.Worker = w
+		return nil
+	}
+}
+
+func WithHost(host string) Option {
+	return func(s *Server) error {
+		s.Host = host
+		return nil
+	}
+}
+
+func WithPort(port string) Option {
+	return func(s *Server) error {
+		s.Port = port
+		return nil
+	}
+}
+
+func WithReadTimeout(seconds int) Option {
+	return func(s *Server) error {
+		s.readTimeout = time.Duration(seconds) * time.Second
+		return nil
+	}
+}
+
+func WithWriteTimeout(seconds int) Option {
+	return func(s *Server) error {
+		s.writeTimeout = time.Duration(seconds) * time.Second
+		return nil
+	}
+}
+
+func WithIdleTimeout(seconds int) Option {
+	return func(s *Server) error {
+		s.idleTimeout = time.Duration(seconds) * time.Second
+		return nil
+	}
+}

backend/pkgs/server/server_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func testServer(t *testing.T, r http.Handler) *Server {
-	svr := NewServer("127.0.0.1", "19245")
+	svr := NewServer(WithHost("127.0.0.1"), WithPort("19245"))
 
 	go func() {
 		err := svr.Start(r)
@@ -33,7 +33,7 @@ func testServer(t *testing.T, r http.Handler) *Server {
 }
 
 func Test_ServerShutdown_Error(t *testing.T) {
-	svr := NewServer("127.0.0.1", "19245")
+	svr := NewServer(WithHost("127.0.0.1"), WithPort("19245"))
 
 	err := svr.Shutdown("test")
 	assert.ErrorIs(t, err, ErrServerNotStarted)

backend/pkgs/server/worker.go

@@ -1,5 +1,7 @@
 package server
 
+// TODO: #2 Implement Go routine pool/job queue
+
 type Worker interface {
 	Add(func())
 }