From f8a9396f6ef693941519321259bb9f8819a1eca9 Mon Sep 17 00:00:00 2001
From: Amir Raminfar <findamir@gmail.com>
Date: Sat, 11 Nov 2023 13:22:06 -0800
Subject: [PATCH] chore(test): adds test for proxy mode (#2490)

---
 assets/components/Links.vue       |  2 +-
 internal/web/auth.go              |  2 +-
 internal/web/index.go             |  6 ++--
 internal/web/routes.go            | 46 +++++++++++++++-----------
 internal/web/routes_auth_test.go  | 24 +++++++-------
 internal/web/routes_proxy_test.go | 54 +++++++++++++++++++++++++++++++
 internal/web/routes_test.go       |  2 +-
 main.go                           | 22 +++++++------
 8 files changed, 111 insertions(+), 47 deletions(-)
 create mode 100644 internal/web/routes_proxy_test.go

diff --git a/assets/components/Links.vue b/assets/components/Links.vue
index 963bf565..90ba64c6 100644
--- a/assets/components/Links.vue
+++ b/assets/components/Links.vue
@@ -29,7 +29,7 @@
 
     <dropdown class="dropdown-end" v-if="config.user">
       <template #trigger>
-        <img class="h-8 w-8 max-w-none rounded-full p-1 ring-2 ring-base-content/50" :src="config.user.avatar" />
+        <img class="h-6 w-6 max-w-none rounded-full" :src="config.user.avatar" />
       </template>
       <template #content>
         <div class="p-2">
diff --git a/internal/web/auth.go b/internal/web/auth.go
index b10a5cc8..b25e8405 100644
--- a/internal/web/auth.go
+++ b/internal/web/auth.go
@@ -105,7 +105,7 @@ func (h *handler) createToken(w http.ResponseWriter, r *http.Request) {
 	user := r.PostFormValue("username")
 	pass := r.PostFormValue("password")
 
-	if token, err := h.config.Authorizer.CreateToken(user, pass); err == nil {
+	if token, err := h.config.Authorization.Authorizer.CreateToken(user, pass); err == nil {
 		http.SetCookie(w, &http.Cookie{
 			Name:     "jwt",
 			Value:    token,
diff --git a/internal/web/index.go b/internal/web/index.go
index 29da7db1..47066a2b 100644
--- a/internal/web/index.go
+++ b/internal/web/index.go
@@ -50,7 +50,7 @@ func (h *handler) executeTemplate(w http.ResponseWriter, req *http.Request) {
 		"secured":             secured,
 		"hostname":            h.config.Hostname,
 		"hosts":               hosts,
-		"authProvider":        h.config.AuthProvider,
+		"authProvider":        h.config.Authorization.Provider,
 	}
 
 	pages, err := content.ReadAll()
@@ -71,7 +71,7 @@ func (h *handler) executeTemplate(w http.ResponseWriter, req *http.Request) {
 			config["serverSettings"] = struct{}{}
 		}
 		config["user"] = user
-	} else if h.config.AuthProvider == FORWARD_PROXY {
+	} else if h.config.Authorization.Provider == FORWARD_PROXY {
 		log.Error("Unable to find remote user. Please check your proxy configuration. Expecting headers Remote-Email, Remote-User, Remote-Name.")
 		log.Debugf("Dumping all headers for url /%s", req.URL.String())
 		for k, v := range req.Header {
@@ -79,7 +79,7 @@ func (h *handler) executeTemplate(w http.ResponseWriter, req *http.Request) {
 		}
 		http.Error(w, "Unauthorized user", http.StatusUnauthorized)
 		return
-	} else if h.config.AuthProvider == SIMPLE && req.URL.Path != "login" {
+	} else if h.config.Authorization.Provider == SIMPLE && req.URL.Path != "login" {
 		log.Debugf("Redirecting to login page for url /%s", req.URL.String())
 		http.Redirect(w, req, path.Clean(h.config.Base+"/login"), http.StatusTemporaryRedirect)
 		return
diff --git a/internal/web/routes.go b/internal/web/routes.go
index 4647dd55..19406fe7 100644
--- a/internal/web/routes.go
+++ b/internal/web/routes.go
@@ -26,16 +26,25 @@ const (
 
 // Config is a struct for configuring the web service
 type Config struct {
-	Base         string
-	Addr         string
-	Version      string
-	Username     string
-	Password     string
-	Hostname     string
-	NoAnalytics  bool
-	Dev          bool
-	AuthProvider AuthProvider
-	Authorizer   Authorizer
+	Base          string
+	Addr          string
+	Version       string
+	Username      string
+	Password      string
+	Hostname      string
+	NoAnalytics   bool
+	Dev           bool
+	Authorization Authorization
+}
+
+type Authorization struct {
+	Provider   AuthProvider
+	Authorizer Authorizer
+}
+
+type Authorizer interface {
+	AuthMiddleware(http.Handler) http.Handler
+	CreateToken(string, string) (string, error)
 }
 
 type handler struct {
@@ -56,11 +65,6 @@ type DockerClient interface {
 	Host() *docker.Host
 }
 
-type Authorizer interface {
-	AuthMiddleware(http.Handler) http.Handler
-	CreateToken(string, string) (string, error)
-}
-
 func CreateServer(clients map[string]DockerClient, content fs.FS, config Config) *http.Server {
 	handler := &handler{
 		clients: clients,
@@ -82,13 +86,17 @@ func createRouter(h *handler) *chi.Mux {
 		r.Use(cspHeaders)
 	}
 
+	if h.config.Authorization.Provider != NONE && h.config.Authorization.Authorizer == nil {
+		log.Panic("Authorization provider is set but no authorizer is provided")
+	}
+
 	r.Route(base, func(r chi.Router) {
-		if h.config.Authorizer != nil {
-			r.Use(h.config.Authorizer.AuthMiddleware)
+		if h.config.Authorization.Provider != NONE {
+			r.Use(h.config.Authorization.Authorizer.AuthMiddleware)
 		}
 		r.Group(func(r chi.Router) {
 			r.Group(func(r chi.Router) {
-				if h.config.AuthProvider != NONE {
+				if h.config.Authorization.Provider != NONE {
 					r.Use(auth.RequireAuthentication)
 				}
 				r.Use(authorizationRequired) // TODO remove this
@@ -109,7 +117,7 @@ func createRouter(h *handler) *chi.Mux {
 			})
 		})
 
-		if h.config.AuthProvider == SIMPLE {
+		if h.config.Authorization.Provider == SIMPLE {
 			r.Post("/api/token", h.createToken)
 			r.Delete("/api/token", h.deleteToken)
 		}
diff --git a/internal/web/routes_auth_test.go b/internal/web/routes_auth_test.go
index 6c0470a7..a5facb51 100644
--- a/internal/web/routes_auth_test.go
+++ b/internal/web/routes_auth_test.go
@@ -27,7 +27,7 @@ func Test_createRoutes_index(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
 
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/"})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -40,7 +40,7 @@ func Test_createRoutes_redirect(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
 
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar"})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/foobar", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -53,7 +53,7 @@ func Test_createRoutes_redirect_with_auth(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
 
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar", Username: "amir", Password: "password"})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/foobar/", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -66,7 +66,7 @@ func Test_createRoutes_foobar(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("foo page"), 0644), "WriteFile should have no error.")
 
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar"})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/foobar/", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -80,7 +80,7 @@ func Test_createRoutes_foobar_file(t *testing.T) {
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
 	require.NoError(t, afero.WriteFile(fs, "test", []byte("test page"), 0644), "WriteFile should have no error.")
 
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar"})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/foobar", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/foobar/test", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -92,7 +92,7 @@ func Test_createRoutes_foobar_file(t *testing.T) {
 func Test_createRoutes_version(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
-	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/", Version: "dev", AuthProvider: NONE})
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/", Version: "dev", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/version", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -103,7 +103,7 @@ func Test_createRoutes_version(t *testing.T) {
 
 func Test_createRoutes_username_password(t *testing.T) {
 
-	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password"})
+	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -112,7 +112,7 @@ func Test_createRoutes_username_password(t *testing.T) {
 }
 
 func Test_createRoutes_username_password_invalid(t *testing.T) {
-	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password"})
+	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/api/logs/stream/localhost/123?stdout=1&stderr=1", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	rr := httptest.NewRecorder()
@@ -121,7 +121,7 @@ func Test_createRoutes_username_password_invalid(t *testing.T) {
 }
 
 func Test_createRoutes_username_password_login_happy(t *testing.T) {
-	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password"})
+	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
@@ -151,7 +151,7 @@ func Test_createRoutes_username_password_login_happy(t *testing.T) {
 }
 
 func Test_createRoutes_username_password_login_failed(t *testing.T) {
-	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password"})
+	handler := createHandler(nil, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
@@ -181,7 +181,7 @@ func Test_createRoutes_username_password_valid_session(t *testing.T) {
 	mockedClient := new(MockedClient)
 	mockedClient.On("FindContainer", "123").Return(docker.Container{ID: "123"}, nil)
 	mockedClient.On("ContainerLogs", mock.Anything, "123", "", docker.STDALL).Return(io.NopCloser(strings.NewReader("test data")), io.EOF)
-	handler := createHandler(mockedClient, nil, Config{Base: "/", Username: "amir", Password: "password", AuthProvider: NONE})
+	handler := createHandler(mockedClient, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 
 	// Get cookie first
 	req, err := http.NewRequest("GET", "/api/logs/stream/localhost/123?stdout=1&stderr=1", nil)
@@ -205,7 +205,7 @@ func Test_createRoutes_username_password_invalid_session(t *testing.T) {
 	mockedClient := new(MockedClient)
 	mockedClient.On("FindContainer", "123").Return(docker.Container{ID: "123"}, nil)
 	mockedClient.On("ContainerLogs", mock.Anything, "since", docker.STDALL).Return(io.NopCloser(strings.NewReader("test data")), io.EOF)
-	handler := createHandler(mockedClient, nil, Config{Base: "/", Username: "amir", Password: "password"})
+	handler := createHandler(mockedClient, nil, Config{Base: "/", Username: "amir", Password: "password", Authorization: Authorization{Provider: NONE}})
 	req, err := http.NewRequest("GET", "/api/logs/stream/localhost/123?stdout=1&stderr=1", nil)
 	require.NoError(t, err, "NewRequest should not return an error.")
 	req.AddCookie(&http.Cookie{Name: "session", Value: "baddata"})
diff --git a/internal/web/routes_proxy_test.go b/internal/web/routes_proxy_test.go
new file mode 100644
index 00000000..8ffd7d98
--- /dev/null
+++ b/internal/web/routes_proxy_test.go
@@ -0,0 +1,54 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+
+	"testing"
+
+	"github.com/amir20/dozzle/internal/auth"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/spf13/afero"
+)
+
+func Test_createRoutes_proxy_missing_headers(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
+
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/",
+		Authorization: Authorization{
+			Provider:   FORWARD_PROXY,
+			Authorizer: auth.NewForwardProxyAuth(),
+		},
+	})
+	req, err := http.NewRequest("GET", "/", nil)
+	require.NoError(t, err, "NewRequest should not return an error.")
+	rr := httptest.NewRecorder()
+
+	handler.ServeHTTP(rr, req)
+
+	assert.Equal(t, 401, rr.Code, "Response code should be 401.")
+}
+
+func Test_createRoutes_proxy_happy(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	require.NoError(t, afero.WriteFile(fs, "index.html", []byte("index page"), 0644), "WriteFile should have no error.")
+
+	handler := createHandler(nil, afero.NewIOFS(fs), Config{Base: "/",
+		Authorization: Authorization{
+			Provider:   FORWARD_PROXY,
+			Authorizer: auth.NewForwardProxyAuth(),
+		},
+	})
+	req, err := http.NewRequest("GET", "/", nil)
+	req.Header.Set("Remote-Email", "amir@test.com")
+	req.Header.Set("Remote-Name", "Amir")
+	req.Header.Set("Remote-User", "amir")
+	require.NoError(t, err, "NewRequest should not return an error.")
+	rr := httptest.NewRecorder()
+
+	handler.ServeHTTP(rr, req)
+	assert.Equal(t, 200, rr.Code, "Response code should be 200.")
+}
diff --git a/internal/web/routes_test.go b/internal/web/routes_test.go
index 711a66b5..24d5b1e1 100644
--- a/internal/web/routes_test.go
+++ b/internal/web/routes_test.go
@@ -80,5 +80,5 @@ func createHandler(client DockerClient, content fs.FS, config Config) *chi.Mux {
 }
 
 func createDefaultHandler(client DockerClient) *chi.Mux {
-	return createHandler(client, nil, Config{Base: "/", AuthProvider: NONE})
+	return createHandler(client, nil, Config{Base: "/", Authorization: Authorization{Provider: NONE}})
 }
diff --git a/main.go b/main.go
index 76f2dcc8..e8ccc0df 100644
--- a/main.go
+++ b/main.go
@@ -199,16 +199,18 @@ func createServer(args args, clients map[string]web.DockerClient) *http.Server {
 	}
 
 	config := web.Config{
-		Addr:         args.Addr,
-		Base:         args.Base,
-		Version:      version,
-		Username:     args.Username,
-		Password:     args.Password,
-		Hostname:     args.Hostname,
-		NoAnalytics:  args.NoAnalytics,
-		Dev:          dev,
-		AuthProvider: provider,
-		Authorizer:   authorizer,
+		Addr:        args.Addr,
+		Base:        args.Base,
+		Version:     version,
+		Username:    args.Username,
+		Password:    args.Password,
+		Hostname:    args.Hostname,
+		NoAnalytics: args.NoAnalytics,
+		Dev:         dev,
+		Authorization: web.Authorization{
+			Provider:   provider,
+			Authorizer: authorizer,
+		},
 	}
 
 	assets, err := fs.Sub(content, "dist")