Welcome to mirror list, hosted at ThFree Co, Russian Federation.

gitlab.com/gitlab-org/gitlab-pages.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile.build.mk1
-rw-r--r--internal/domain/domain.go6
-rw-r--r--internal/domain/domain_test.go112
-rw-r--r--internal/mocks/resolver.go51
4 files changed, 117 insertions, 53 deletions
diff --git a/Makefile.build.mk b/Makefile.build.mk
index 562c9b86..2474ccbb 100644
--- a/Makefile.build.mk
+++ b/Makefile.build.mk
@@ -18,6 +18,7 @@ generate-mocks: .GOPATH/.ok
$Q bin/mockgen -source=internal/interface.go -destination=internal/mocks/mocks.go -package=mocks
$Q bin/mockgen -source=internal/source/source.go -destination=internal/mocks/source.go -package=mocks
$Q bin/mockgen -source=internal/mocks/api/client_stub.go -destination=internal/mocks/client.go -package=mocks
+ $Q bin/mockgen -source=internal/domain/resolver.go -destination=internal/mocks/resolver.go -package=mocks
build: .GOPATH/.ok
$Q GOBIN=$(CURDIR)/bin go install $(if $V,-v) $(VERSION_FLAGS) -tags "${GO_BUILD_TAGS}" -buildmode exe $(IMPORT_PATH)
diff --git a/internal/domain/domain.go b/internal/domain/domain.go
index 695bc166..bf202cd3 100644
--- a/internal/domain/domain.go
+++ b/internal/domain/domain.go
@@ -157,10 +157,10 @@ func (d *Domain) ServeNotFoundHTTP(w http.ResponseWriter, r *http.Request) {
request.ServeNotFoundHTTP(w, r)
}
-// serveNamespaceNotFound will try to find a parent namespace domain for a request
+// ServeNamespaceNotFound will try to find a parent namespace domain for a request
// that failed authentication so that we serve the custom namespace error page for
// public namespace domains
-func (d *Domain) serveNamespaceNotFound(w http.ResponseWriter, r *http.Request) {
+func (d *Domain) ServeNamespaceNotFound(w http.ResponseWriter, r *http.Request) {
// clone r and override the path and try to resolve the domain name
clonedReq := r.Clone(context.Background())
clonedReq.URL.Path = "/"
@@ -201,5 +201,5 @@ func (d *Domain) ServeNotFoundAuthFailed(w http.ResponseWriter, r *http.Request)
return
}
- d.serveNamespaceNotFound(w, r)
+ d.ServeNamespaceNotFound(w, r)
}
diff --git a/internal/domain/domain_test.go b/internal/domain/domain_test.go
index 57b8f185..408ddf38 100644
--- a/internal/domain/domain_test.go
+++ b/internal/domain/domain_test.go
@@ -1,33 +1,22 @@
-package domain
+package domain_test
import (
"fmt"
"net/http"
"testing"
+ "github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
+ "gitlab.com/gitlab-org/gitlab-pages/internal/domain"
"gitlab.com/gitlab-org/gitlab-pages/internal/fixture"
+ "gitlab.com/gitlab-org/gitlab-pages/internal/mocks"
"gitlab.com/gitlab-org/gitlab-pages/internal/serving"
"gitlab.com/gitlab-org/gitlab-pages/internal/serving/disk/local"
"gitlab.com/gitlab-org/gitlab-pages/internal/testhelpers"
)
-type stubbedResolver struct {
- project *serving.LookupPath
- subpath string
- err error
-}
-
-func (resolver *stubbedResolver) Resolve(*http.Request) (*serving.Request, error) {
- return &serving.Request{
- Serving: local.Instance(),
- LookupPath: resolver.project,
- SubPath: resolver.subpath,
- }, resolver.err
-}
-
-func serveFileOrNotFound(domain *Domain) http.HandlerFunc {
+func serveFileOrNotFound(domain *domain.Domain) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if !domain.ServeFileHTTP(w, r) {
domain.ServeNotFoundHTTP(w, r)
@@ -38,39 +27,41 @@ func serveFileOrNotFound(domain *Domain) http.HandlerFunc {
func TestIsHTTPSOnly(t *testing.T) {
tests := []struct {
name string
- domain *Domain
+ domain *domain.Domain
url string
expected bool
}{
{
name: "Custom domain with HTTPS-only enabled",
- domain: New("custom-domain", "", "",
- &stubbedResolver{
- project: &serving.LookupPath{
+ domain: domain.New("custom-domain", "", "",
+ mockResolver(t,
+ &serving.LookupPath{
Path: "group/project/public",
SHA256: "foo",
IsHTTPSOnly: true,
},
- }),
+ "",
+ nil)),
url: "http://custom-domain",
expected: true,
},
{
name: "Custom domain with HTTPS-only disabled",
- domain: New("custom-domain", "", "",
- &stubbedResolver{
- project: &serving.LookupPath{
+ domain: domain.New("custom-domain", "", "",
+ mockResolver(t,
+ &serving.LookupPath{
Path: "group/project/public",
SHA256: "foo",
IsHTTPSOnly: false,
},
- }),
+ "",
+ nil)),
url: "http://custom-domain",
expected: false,
},
{
name: "Unknown project",
- domain: New("", "", "", &stubbedResolver{err: ErrDomainDoesNotExist}),
+ domain: domain.New("", "", "", mockResolver(t, nil, "", domain.ErrDomainDoesNotExist)),
url: "http://test-domain/project",
expected: false,
},
@@ -88,14 +79,14 @@ func TestPredefined404ServeHTTP(t *testing.T) {
cleanup := setUpTests(t)
defer cleanup()
- testDomain := New("", "", "", &stubbedResolver{err: ErrDomainDoesNotExist})
+ testDomain := domain.New("", "", "", mockResolver(t, nil, "", domain.ErrDomainDoesNotExist))
require.HTTPStatusCode(t, serveFileOrNotFound(testDomain), http.MethodGet, "http://group.test.io/not-existing-file", nil, http.StatusNotFound)
require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), http.MethodGet, "http://group.test.io/not-existing-file", nil, "The page you're looking for could not be found")
}
func TestGroupCertificate(t *testing.T) {
- testGroup := &Domain{}
+ testGroup := &domain.Domain{}
tls, err := testGroup.EnsureCertificate()
require.Nil(t, tls)
@@ -103,7 +94,7 @@ func TestGroupCertificate(t *testing.T) {
}
func TestDomainNoCertificate(t *testing.T) {
- testDomain := &Domain{
+ testDomain := &domain.Domain{
Name: "test.domain.com",
}
@@ -118,7 +109,7 @@ func TestDomainNoCertificate(t *testing.T) {
func BenchmarkEnsureCertificate(b *testing.B) {
for i := 0; i < b.N; i++ {
- testDomain := &Domain{
+ testDomain := &domain.Domain{
Name: "test.domain.com",
CertificateCert: fixture.Certificate,
CertificateKey: fixture.Key,
@@ -142,70 +133,91 @@ func TestServeNamespaceNotFound(t *testing.T) {
name string
domain string
path string
- resolver *stubbedResolver
+ resolver domain.Resolver
expectedResponse string
}{
{
name: "public_namespace_domain",
domain: "group.404.gitlab-example.com",
path: "/unknown",
- resolver: &stubbedResolver{
- project: &serving.LookupPath{
+ resolver: mockResolver(t,
+ &serving.LookupPath{
Path: "group.404/group.404.gitlab-example.com/public",
IsNamespaceProject: true,
},
- subpath: "/unknown",
- },
+ "/unknown",
+ nil,
+ ),
expectedResponse: "Custom 404 group page",
},
{
name: "private_project_under_public_namespace_domain",
domain: "group.404.gitlab-example.com",
path: "/private_project/unknown",
- resolver: &stubbedResolver{
- project: &serving.LookupPath{
+ resolver: mockResolver(t,
+ &serving.LookupPath{
Path: "group.404/group.404.gitlab-example.com/public",
IsNamespaceProject: true,
HasAccessControl: false,
},
- subpath: "/",
- },
+ "/",
+ nil,
+ ),
expectedResponse: "Custom 404 group page",
},
{
name: "private_namespace_domain",
domain: "group.404.gitlab-example.com",
path: "/unknown",
- resolver: &stubbedResolver{
- project: &serving.LookupPath{
+ resolver: mockResolver(t,
+ &serving.LookupPath{
Path: "group.404/group.404.gitlab-example.com/public",
IsNamespaceProject: true,
HasAccessControl: true,
},
- subpath: "/",
- },
+ "/",
+ nil,
+ ),
expectedResponse: "The page you're looking for could not be found.",
},
{
name: "no_parent_namespace_domain",
domain: "group.404.gitlab-example.com",
path: "/unknown",
- resolver: &stubbedResolver{
- err: ErrDomainDoesNotExist,
- subpath: "/",
- },
+ resolver: mockResolver(t,
+ nil,
+ "/",
+ domain.ErrDomainDoesNotExist,
+ ),
expectedResponse: "The page you're looking for could not be found.",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- d := &Domain{
+ d := &domain.Domain{
Name: tt.domain,
Resolver: tt.resolver,
}
- require.HTTPStatusCode(t, d.serveNamespaceNotFound, http.MethodGet, fmt.Sprintf("http://%s%s", tt.domain, tt.path), nil, http.StatusNotFound)
- require.HTTPBodyContains(t, d.serveNamespaceNotFound, http.MethodGet, fmt.Sprintf("http://%s%s", tt.domain, tt.path), nil, tt.expectedResponse)
+ require.HTTPStatusCode(t, d.ServeNamespaceNotFound, http.MethodGet, fmt.Sprintf("http://%s%s", tt.domain, tt.path), nil, http.StatusNotFound)
+ require.HTTPBodyContains(t, d.ServeNamespaceNotFound, http.MethodGet, fmt.Sprintf("http://%s%s", tt.domain, tt.path), nil, tt.expectedResponse)
})
}
}
+
+func mockResolver(t *testing.T, project *serving.LookupPath, subpath string, err error) domain.Resolver {
+ mockCtrl := gomock.NewController(t)
+
+ mockResolver := mocks.NewMockResolver(mockCtrl)
+
+ mockResolver.EXPECT().
+ Resolve(gomock.Any()).
+ AnyTimes().
+ Return(&serving.Request{
+ Serving: local.Instance(),
+ LookupPath: project,
+ SubPath: subpath,
+ }, err)
+
+ return mockResolver
+}
diff --git a/internal/mocks/resolver.go b/internal/mocks/resolver.go
new file mode 100644
index 00000000..14b86a9c
--- /dev/null
+++ b/internal/mocks/resolver.go
@@ -0,0 +1,51 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: internal/domain/resolver.go
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+ http "net/http"
+ reflect "reflect"
+
+ gomock "github.com/golang/mock/gomock"
+ serving "gitlab.com/gitlab-org/gitlab-pages/internal/serving"
+)
+
+// MockResolver is a mock of Resolver interface.
+type MockResolver struct {
+ ctrl *gomock.Controller
+ recorder *MockResolverMockRecorder
+}
+
+// MockResolverMockRecorder is the mock recorder for MockResolver.
+type MockResolverMockRecorder struct {
+ mock *MockResolver
+}
+
+// NewMockResolver creates a new mock instance.
+func NewMockResolver(ctrl *gomock.Controller) *MockResolver {
+ mock := &MockResolver{ctrl: ctrl}
+ mock.recorder = &MockResolverMockRecorder{mock}
+ return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockResolver) EXPECT() *MockResolverMockRecorder {
+ return m.recorder
+}
+
+// Resolve mocks base method.
+func (m *MockResolver) Resolve(arg0 *http.Request) (*serving.Request, error) {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "Resolve", arg0)
+ ret0, _ := ret[0].(*serving.Request)
+ ret1, _ := ret[1].(error)
+ return ret0, ret1
+}
+
+// Resolve indicates an expected call of Resolve.
+func (mr *MockResolverMockRecorder) Resolve(arg0 interface{}) *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockResolver)(nil).Resolve), arg0)
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-02 09:17:20 +0300