Merge branch 'remove-testify-assert' into 'master'

Remove github.com/stretchr/testify/assert

See merge request gitlab-org/gitlab-pages!180

14 files changed, 293 insertions, 304 deletions

diff --git a/acceptance_test.go b/acceptance_test.go
index b2f0c747..85884a99 100644
--- a/acceptance_test.go
+++ b/acceptance_test.go
@@ -16,7 +16,6 @@ import (
 	"time"
 
 	"github.com/namsral/flag"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -75,7 +74,7 @@ func TestUnknownHostReturnsNotFound(t *testing.T) {
 
 		require.NoError(t, err)
 		rsp.Body.Close()
-		assert.Equal(t, http.StatusNotFound, rsp.StatusCode)
+		require.Equal(t, http.StatusNotFound, rsp.StatusCode)
 	}
 }
 
@@ -87,7 +86,7 @@ func TestUnknownProjectReturnsNotFound(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.gitlab-example.com", "/nonexistent/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusNotFound, rsp.StatusCode)
+	require.Equal(t, http.StatusNotFound, rsp.StatusCode)
 }
 
 func TestGroupDomainReturns200(t *testing.T) {
@@ -98,7 +97,7 @@ func TestGroupDomainReturns200(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.gitlab-example.com", "/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestKnownHostReturns200(t *testing.T) {
@@ -145,7 +144,7 @@ func TestKnownHostReturns200(t *testing.T) {
 
 				require.NoError(t, err)
 				rsp.Body.Close()
-				assert.Equal(t, http.StatusOK, rsp.StatusCode)
+				require.Equal(t, http.StatusOK, rsp.StatusCode)
 			}
 		})
 	}
@@ -205,9 +204,9 @@ func TestCORSWhenDisabled(t *testing.T) {
 		for _, method := range []string{"GET", "OPTIONS"} {
 			rsp := doCrossOriginRequest(t, method, method, spec.URL("project/"))
 
-			assert.Equal(t, http.StatusOK, rsp.StatusCode)
-			assert.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Origin"))
-			assert.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
+			require.Equal(t, http.StatusOK, rsp.StatusCode)
+			require.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Origin"))
+			require.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
 		}
 	}
 }
@@ -221,9 +220,9 @@ func TestCORSAllowsGET(t *testing.T) {
 		for _, method := range []string{"GET", "OPTIONS"} {
 			rsp := doCrossOriginRequest(t, method, method, spec.URL("project/"))
 
-			assert.Equal(t, http.StatusOK, rsp.StatusCode)
-			assert.Equal(t, "*", rsp.Header.Get("Access-Control-Allow-Origin"))
-			assert.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
+			require.Equal(t, http.StatusOK, rsp.StatusCode)
+			require.Equal(t, "*", rsp.Header.Get("Access-Control-Allow-Origin"))
+			require.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
 		}
 	}
 }
@@ -236,9 +235,9 @@ func TestCORSForbidsPOST(t *testing.T) {
 	for _, spec := range listeners {
 		rsp := doCrossOriginRequest(t, "OPTIONS", "POST", spec.URL("project/"))
 
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
-		assert.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Origin"))
-		assert.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Origin"))
+		require.Equal(t, "", rsp.Header.Get("Access-Control-Allow-Credentials"))
 	}
 }
 
@@ -249,9 +248,9 @@ func TestCustomHeaders(t *testing.T) {
 	for _, spec := range listeners {
 		rsp, err := GetPageFromListener(t, spec, "group.gitlab-example.com:", "project/")
 		require.NoError(t, err)
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
-		assert.Equal(t, "Testing1", rsp.Header.Get("X-Test1"))
-		assert.Equal(t, "Testing2", rsp.Header.Get("X-Test2"))
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, "Testing1", rsp.Header.Get("X-Test1"))
+		require.Equal(t, "Testing2", rsp.Header.Get("X-Test2"))
 	}
 }
 
@@ -288,7 +287,7 @@ func TestKnownHostWithPortReturns200(t *testing.T) {
 
 		require.NoError(t, err)
 		rsp.Body.Close()
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
 	}
 
 }
@@ -301,12 +300,12 @@ func TestHttpToHttpsRedirectDisabled(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "group.gitlab-example.com", "project/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 
 	rsp, err = GetPageFromListener(t, httpsListener, "group.gitlab-example.com", "project/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestHttpToHttpsRedirectEnabled(t *testing.T) {
@@ -317,14 +316,14 @@ func TestHttpToHttpsRedirectEnabled(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "group.gitlab-example.com", "project/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusTemporaryRedirect, rsp.StatusCode)
-	assert.Equal(t, 1, len(rsp.Header["Location"]))
-	assert.Equal(t, "https://group.gitlab-example.com/project/", rsp.Header.Get("Location"))
+	require.Equal(t, http.StatusTemporaryRedirect, rsp.StatusCode)
+	require.Equal(t, 1, len(rsp.Header["Location"]))
+	require.Equal(t, "https://group.gitlab-example.com/project/", rsp.Header.Get("Location"))
 
 	rsp, err = GetPageFromListener(t, httpsListener, "group.gitlab-example.com", "project/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestHttpsOnlyGroupEnabled(t *testing.T) {
@@ -335,7 +334,7 @@ func TestHttpsOnlyGroupEnabled(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "group.https-only.gitlab-example.com", "project1/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusMovedPermanently, rsp.StatusCode)
+	require.Equal(t, http.StatusMovedPermanently, rsp.StatusCode)
 }
 
 func TestHttpsOnlyGroupDisabled(t *testing.T) {
@@ -346,7 +345,7 @@ func TestHttpsOnlyGroupDisabled(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.https-only.gitlab-example.com", "project2/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestHttpsOnlyProjectEnabled(t *testing.T) {
@@ -357,7 +356,7 @@ func TestHttpsOnlyProjectEnabled(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "test.my-domain.com", "/index.html")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusMovedPermanently, rsp.StatusCode)
+	require.Equal(t, http.StatusMovedPermanently, rsp.StatusCode)
 }
 
 func TestHttpsOnlyProjectDisabled(t *testing.T) {
@@ -368,7 +367,7 @@ func TestHttpsOnlyProjectDisabled(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "test2.my-domain.com", "/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestHttpsOnlyDomainDisabled(t *testing.T) {
@@ -379,7 +378,7 @@ func TestHttpsOnlyDomainDisabled(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "no.cert.com", "/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestPrometheusMetricsCanBeScraped(t *testing.T) {
@@ -389,14 +388,13 @@ func TestPrometheusMetricsCanBeScraped(t *testing.T) {
 	defer teardown()
 
 	resp, err := http.Get("http://localhost:42345/metrics")
+	require.NoError(t, err)
 
-	if assert.NoError(t, err) {
-		defer resp.Body.Close()
-		body, _ := ioutil.ReadAll(resp.Body)
+	defer resp.Body.Close()
+	body, _ := ioutil.ReadAll(resp.Body)
 
-		assert.Contains(t, string(body), "gitlab_pages_http_in_flight_requests 0")
-		assert.Contains(t, string(body), "gitlab_pages_served_domains 16")
-	}
+	require.Contains(t, string(body), "gitlab_pages_http_in_flight_requests 0")
+	require.Contains(t, string(body), "gitlab_pages_served_domains 16")
 }
 
 func TestStatusPage(t *testing.T) {
@@ -407,7 +405,7 @@ func TestStatusPage(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.gitlab-example.com", "@statuscheck")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestStatusNotYetReady(t *testing.T) {
@@ -419,7 +417,7 @@ func TestStatusNotYetReady(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.gitlab-example.com", "@statuscheck")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusServiceUnavailable, rsp.StatusCode)
+	require.Equal(t, http.StatusServiceUnavailable, rsp.StatusCode)
 }
 
 func TestPageNotAvailableIfNotLoaded(t *testing.T) {
@@ -431,7 +429,7 @@ func TestPageNotAvailableIfNotLoaded(t *testing.T) {
 	rsp, err := GetPageFromListener(t, httpListener, "group.gitlab-example.com", "index.html")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusServiceUnavailable, rsp.StatusCode)
+	require.Equal(t, http.StatusServiceUnavailable, rsp.StatusCode)
 }
 
 func TestObscureMIMEType(t *testing.T) {
@@ -448,7 +446,7 @@ func TestObscureMIMEType(t *testing.T) {
 	require.Equal(t, http.StatusOK, rsp.StatusCode)
 	mt, _, err := mime.ParseMediaType(rsp.Header.Get("Content-Type"))
 	require.NoError(t, err)
-	assert.Equal(t, "application/manifest+json", mt)
+	require.Equal(t, "application/manifest+json", mt)
 }
 
 func TestArtifactProxyRequest(t *testing.T) {
@@ -584,15 +582,15 @@ func TestArtifactProxyRequest(t *testing.T) {
 			require.NoError(t, err)
 			defer resp.Body.Close()
 
-			assert.Equal(t, c.Status, resp.StatusCode)
-			assert.Equal(t, c.ContentType, resp.Header.Get("Content-Type"))
+			require.Equal(t, c.Status, resp.StatusCode)
+			require.Equal(t, c.ContentType, resp.Header.Get("Content-Type"))
 
 			if !((c.Status == http.StatusBadGateway) || (c.Status == http.StatusNotFound) || (c.Status == http.StatusInternalServerError)) {
 				body, err := ioutil.ReadAll(resp.Body)
 				require.NoError(t, err)
-				assert.Equal(t, c.Content, string(body))
-				assert.Equal(t, c.Length, resp.ContentLength)
-				assert.Equal(t, c.CacheControl, resp.Header.Get("Cache-Control"))
+				require.Equal(t, c.Content, string(body))
+				require.Equal(t, c.Length, resp.ContentLength)
+				require.Equal(t, c.CacheControl, resp.Header.Get("Cache-Control"))
 			}
 		})
 	}
@@ -611,7 +609,7 @@ func TestEnvironmentVariablesConfig(t *testing.T) {
 
 	require.NoError(t, err)
 	rsp.Body.Close()
-	assert.Equal(t, http.StatusOK, rsp.StatusCode)
+	require.Equal(t, http.StatusOK, rsp.StatusCode)
 }
 
 func TestMixedConfigSources(t *testing.T) {
@@ -628,7 +626,7 @@ func TestMixedConfigSources(t *testing.T) {
 		require.NoError(t, err)
 		rsp.Body.Close()
 
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
 	}
 }
 
@@ -649,7 +647,7 @@ func TestMultiFlagEnvironmentVariables(t *testing.T) {
 
 		require.NoError(t, err)
 		rsp.Body.Close()
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
 	}
 }
 
@@ -669,7 +667,7 @@ func TestKnownHostInReverseProxySetupReturns200(t *testing.T) {
 
 		require.NoError(t, err)
 		rsp.Body.Close()
-		assert.Equal(t, http.StatusOK, rsp.StatusCode)
+		require.Equal(t, http.StatusOK, rsp.StatusCode)
 	}
 }
 
@@ -682,7 +680,7 @@ func TestWhenAuthIsDisabledPrivateIsNotAccessible(t *testing.T) {
 
 	require.NoError(t, err)
 	rsp.Body.Close()
-	assert.Equal(t, http.StatusInternalServerError, rsp.StatusCode)
+	require.Equal(t, http.StatusInternalServerError, rsp.StatusCode)
 }
 
 func TestWhenAuthIsEnabledPrivateWillRedirectToAuthorize(t *testing.T) {
@@ -695,24 +693,24 @@ func TestWhenAuthIsEnabledPrivateWillRedirectToAuthorize(t *testing.T) {
 	require.NoError(t, err)
 	defer rsp.Body.Close()
 
-	assert.Equal(t, http.StatusFound, rsp.StatusCode)
-	assert.Equal(t, 1, len(rsp.Header["Location"]))
+	require.Equal(t, http.StatusFound, rsp.StatusCode)
+	require.Equal(t, 1, len(rsp.Header["Location"]))
 	url, err := url.Parse(rsp.Header.Get("Location"))
 	require.NoError(t, err)
 	rsp, err = GetRedirectPage(t, httpsListener, url.Host, url.Path+"?"+url.RawQuery)
 
-	assert.Equal(t, http.StatusFound, rsp.StatusCode)
-	assert.Equal(t, 1, len(rsp.Header["Location"]))
+	require.Equal(t, http.StatusFound, rsp.StatusCode)
+	require.Equal(t, 1, len(rsp.Header["Location"]))
 
 	url, err = url.Parse(rsp.Header.Get("Location"))
 	require.NoError(t, err)
 
-	assert.Equal(t, "https", url.Scheme)
-	assert.Equal(t, "gitlab-auth.com", url.Host)
-	assert.Equal(t, "/oauth/authorize", url.Path)
-	assert.Equal(t, "1", url.Query().Get("client_id"))
-	assert.Equal(t, "https://projects.gitlab-example.com/auth", url.Query().Get("redirect_uri"))
-	assert.NotEqual(t, "", url.Query().Get("state"))
+	require.Equal(t, "https", url.Scheme)
+	require.Equal(t, "gitlab-auth.com", url.Host)
+	require.Equal(t, "/oauth/authorize", url.Path)
+	require.Equal(t, "1", url.Query().Get("client_id"))
+	require.Equal(t, "https://projects.gitlab-example.com/auth", url.Query().Get("redirect_uri"))
+	require.NotEqual(t, "", url.Query().Get("state"))
 }
 
 func TestWhenAuthDeniedWillCauseUnauthorized(t *testing.T) {
@@ -725,7 +723,7 @@ func TestWhenAuthDeniedWillCauseUnauthorized(t *testing.T) {
 	require.NoError(t, err)
 	defer rsp.Body.Close()
 
-	assert.Equal(t, http.StatusUnauthorized, rsp.StatusCode)
+	require.Equal(t, http.StatusUnauthorized, rsp.StatusCode)
 }
 func TestWhenLoginCallbackWithWrongStateShouldFail(t *testing.T) {
 	skipUnlessEnabled(t)
@@ -743,7 +741,7 @@ func TestWhenLoginCallbackWithWrongStateShouldFail(t *testing.T) {
 	require.NoError(t, err)
 	defer authrsp.Body.Close()
 
-	assert.Equal(t, http.StatusUnauthorized, authrsp.StatusCode)
+	require.Equal(t, http.StatusUnauthorized, authrsp.StatusCode)
 }
 
 func TestWhenLoginCallbackWithCorrectStateWithoutEndpoint(t *testing.T) {
@@ -769,7 +767,7 @@ func TestWhenLoginCallbackWithCorrectStateWithoutEndpoint(t *testing.T) {
 	defer authrsp.Body.Close()
 
 	// Will cause 503 because token endpoint is not available
-	assert.Equal(t, http.StatusServiceUnavailable, authrsp.StatusCode)
+	require.Equal(t, http.StatusServiceUnavailable, authrsp.StatusCode)
 }
 
 // makeGitLabPagesAccessStub provides a stub *httptest.Server to check pages_access API call.
@@ -787,22 +785,22 @@ func makeGitLabPagesAccessStub(t *testing.T) *httptest.Server {
 	return httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/oauth/token":
-			assert.Equal(t, "POST", r.Method)
+			require.Equal(t, "POST", r.Method)
 			w.WriteHeader(http.StatusOK)
 			fmt.Fprint(w, "{\"access_token\":\"abc\"}")
 		case "/api/v4/user":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusOK)
 		default:
 			switch {
 			case allowedProjects.MatchString(r.URL.Path):
-				assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+				require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 				w.WriteHeader(http.StatusOK)
 			case deniedProjects.MatchString(r.URL.Path):
-				assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+				require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 				w.WriteHeader(http.StatusUnauthorized)
 			case invalidTokenProjects.MatchString(r.URL.Path):
-				assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+				require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 				w.WriteHeader(http.StatusUnauthorized)
 				fmt.Fprint(w, "{\"error\":\"invalid_token\"}")
 			default:
@@ -900,7 +898,7 @@ func TestAccessControlUnderCustomDomain(t *testing.T) {
 	require.NoError(t, err)
 
 	state := url.Query().Get("state")
-	assert.Equal(t, url.Query().Get("domain"), "http://private.domain.com")
+	require.Equal(t, url.Query().Get("domain"), "http://private.domain.com")
 
 	pagesrsp, err := GetRedirectPage(t, httpListener, url.Host, url.Path+"?"+url.RawQuery)
 	require.NoError(t, err)
@@ -919,9 +917,9 @@ func TestAccessControlUnderCustomDomain(t *testing.T) {
 	require.NoError(t, err)
 
 	// Will redirect to custom domain
-	assert.Equal(t, "private.domain.com", url.Host)
-	assert.Equal(t, "1", url.Query().Get("code"))
-	assert.Equal(t, state, url.Query().Get("state"))
+	require.Equal(t, "private.domain.com", url.Host)
+	require.Equal(t, "1", url.Query().Get("code"))
+	require.Equal(t, state, url.Query().Get("state"))
 
 	// Run auth callback in custom domain
 	authrsp, err = GetRedirectPageWithCookie(t, httpListener, "private.domain.com", "/auth?code=1&state="+
@@ -932,17 +930,17 @@ func TestAccessControlUnderCustomDomain(t *testing.T) {
 
 	// Will redirect to the page
 	cookie = authrsp.Header.Get("Set-Cookie")
-	assert.Equal(t, http.StatusFound, authrsp.StatusCode)
+	require.Equal(t, http.StatusFound, authrsp.StatusCode)
 
 	url, err = url.Parse(authrsp.Header.Get("Location"))
 	require.NoError(t, err)
 
 	// Will redirect to custom domain
-	assert.Equal(t, "http://private.domain.com/", url.String())
+	require.Equal(t, "http://private.domain.com/", url.String())
 
 	// Fetch page in custom domain
 	authrsp, err = GetRedirectPageWithCookie(t, httpListener, "private.domain.com", "/", cookie)
-	assert.Equal(t, http.StatusOK, authrsp.StatusCode)
+	require.Equal(t, http.StatusOK, authrsp.StatusCode)
 }
 
 func TestAccessControlUnderCustomDomainWithHTTPSProxy(t *testing.T) {
@@ -1018,12 +1016,12 @@ func TestAccessControlGroupDomain404RedirectsAuth(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "group.gitlab-example.com", "/nonexistent/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusFound, rsp.StatusCode)
+	require.Equal(t, http.StatusFound, rsp.StatusCode)
 	// Redirects to the projects under gitlab pages domain for authentication flow
 	url, err := url.Parse(rsp.Header.Get("Location"))
 	require.NoError(t, err)
-	assert.Equal(t, "projects.gitlab-example.com", url.Host)
-	assert.Equal(t, "/auth", url.Path)
+	require.Equal(t, "projects.gitlab-example.com", url.Host)
+	require.Equal(t, "/auth", url.Path)
 }
 func TestAccessControlProject404DoesNotRedirect(t *testing.T) {
 	skipUnlessEnabled(t)
@@ -1033,7 +1031,7 @@ func TestAccessControlProject404DoesNotRedirect(t *testing.T) {
 	rsp, err := GetRedirectPage(t, httpListener, "group.gitlab-example.com", "/project/nonexistent/")
 	require.NoError(t, err)
 	defer rsp.Body.Close()
-	assert.Equal(t, http.StatusNotFound, rsp.StatusCode)
+	require.Equal(t, http.StatusNotFound, rsp.StatusCode)
 }
 
 func TestAccessControl(t *testing.T) {
@@ -1146,14 +1144,14 @@ func TestAccessControl(t *testing.T) {
 			require.NoError(t, err)
 			defer rsp.Body.Close()
 
-			assert.Equal(t, http.StatusFound, rsp.StatusCode)
+			require.Equal(t, http.StatusFound, rsp.StatusCode)
 			cookie := rsp.Header.Get("Set-Cookie")
 
 			// Redirects to the projects under gitlab pages domain for authentication flow
 			url, err := url.Parse(rsp.Header.Get("Location"))
 			require.NoError(t, err)
-			assert.Equal(t, "projects.gitlab-example.com", url.Host)
-			assert.Equal(t, "/auth", url.Path)
+			require.Equal(t, "projects.gitlab-example.com", url.Host)
+			require.Equal(t, "/auth", url.Path)
 			state := url.Query().Get("state")
 
 			rsp, err = GetRedirectPage(t, httpsListener, url.Host, url.Path+"?"+url.RawQuery)
@@ -1161,7 +1159,7 @@ func TestAccessControl(t *testing.T) {
 			require.NoError(t, err)
 			defer rsp.Body.Close()
 
-			assert.Equal(t, http.StatusFound, rsp.StatusCode)
+			require.Equal(t, http.StatusFound, rsp.StatusCode)
 			pagesDomainCookie := rsp.Header.Get("Set-Cookie")
 
 			// Go to auth page with correct state will cause fetching the token
@@ -1174,30 +1172,30 @@ func TestAccessControl(t *testing.T) {
 			// Will redirect auth callback to correct host
 			url, err = url.Parse(authrsp.Header.Get("Location"))
 			require.NoError(t, err)
-			assert.Equal(t, c.Host, url.Host)
-			assert.Equal(t, "/auth", url.Path)
+			require.Equal(t, c.Host, url.Host)
+			require.Equal(t, "/auth", url.Path)
 
 			// Request auth callback in project domain
 			authrsp, err = GetRedirectPageWithCookie(t, httpsListener, url.Host, url.Path+"?"+url.RawQuery, cookie)
 
 			// server returns the ticket, user will be redirected to the project page
-			assert.Equal(t, http.StatusFound, authrsp.StatusCode)
+			require.Equal(t, http.StatusFound, authrsp.StatusCode)
 			cookie = authrsp.Header.Get("Set-Cookie")
 			rsp, err = GetRedirectPageWithCookie(t, httpsListener, c.Host, c.Path, cookie)
 
 			require.NoError(t, err)
 			defer rsp.Body.Close()
 
-			assert.Equal(t, c.Status, rsp.StatusCode)
-			assert.Equal(t, "", rsp.Header.Get("Cache-Control"))
+			require.Equal(t, c.Status, rsp.StatusCode)
+			require.Equal(t, "", rsp.Header.Get("Cache-Control"))
 
 			if c.RedirectBack {
 				url, err = url.Parse(rsp.Header.Get("Location"))
 				require.NoError(t, err)
 
-				assert.Equal(t, "https", url.Scheme)
-				assert.Equal(t, c.Host, url.Host)
-				assert.Equal(t, c.Path, url.Path)
+				require.Equal(t, "https", url.Scheme)
+				require.Equal(t, c.Host, url.Host)
+				require.Equal(t, c.Path, url.Path)
 			}
 		})
 	}
diff --git a/config_test.go b/config_test.go
index 3ec51c56..a13f1188 100644
--- a/config_test.go
+++ b/config_test.go
@@ -3,7 +3,7 @@ package main
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGitLabServerFromFlags(t *testing.T) {
@@ -48,7 +48,7 @@ func TestGitLabServerFromFlags(t *testing.T) {
 			gitLabServer = &test.gitLabServer
 			gitLabAuthServer = &test.gitLabAuthServer
 			artifactsServer = &test.artifactsServer
-			assert.Equal(t, test.expected, gitlabServerFromFlags())
+			require.Equal(t, test.expected, gitlabServerFromFlags())
 		})
 	}
 }
diff --git a/internal/artifact/artifact_test.go b/internal/artifact/artifact_test.go
index 73dd4bdc..ef37384e 100644
--- a/internal/artifact/artifact_test.go
+++ b/internal/artifact/artifact_test.go
@@ -7,7 +7,6 @@ import (
 	"net/url"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"gitlab.com/gitlab-org/gitlab-pages/internal/artifact"
@@ -83,12 +82,12 @@ func TestTryMakeRequest(t *testing.T) {
 			r := &http.Request{URL: reqURL}
 			art := artifact.New(testServer.URL, 1, "gitlab-example.io")
 
-			assert.True(t, art.TryMakeRequest("group.gitlab-example.io", result, r))
-			assert.Equal(t, c.Status, result.Code)
-			assert.Equal(t, c.ContentType, result.Header().Get("Content-Type"))
-			assert.Equal(t, c.Length, result.Header().Get("Content-Length"))
-			assert.Equal(t, c.CacheControl, result.Header().Get("Cache-Control"))
-			assert.Equal(t, c.Content, string(result.Body.Bytes()))
+			require.True(t, art.TryMakeRequest("group.gitlab-example.io", result, r))
+			require.Equal(t, c.Status, result.Code)
+			require.Equal(t, c.ContentType, result.Header().Get("Content-Type"))
+			require.Equal(t, c.Length, result.Header().Get("Content-Length"))
+			require.Equal(t, c.CacheControl, result.Header().Get("Cache-Control"))
+			require.Equal(t, c.Content, string(result.Body.Bytes()))
 
 		})
 	}
@@ -242,9 +241,9 @@ func TestBuildURL(t *testing.T) {
 				msg = msg + u.String()
 			}
 
-			assertOk := assert.Equal(t, c.Ok, ok, msg)
-			if assertOk && c.Ok {
-				assert.Equal(t, c.Expected, u.String(), c.Description)
+			require.Equal(t, c.Ok, ok, msg)
+			if c.Ok {
+				require.Equal(t, c.Expected, u.String(), c.Description)
 			}
 		})
 	}
diff --git a/internal/auth/auth_test.go b/internal/auth/auth_test.go
index 1aa3bfae..8be5e835 100644
--- a/internal/auth/auth_test.go
+++ b/internal/auth/auth_test.go
@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/gorilla/sessions"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"gitlab.com/gitlab-org/gitlab-pages/internal/domain"
@@ -56,7 +55,7 @@ func TestTryAuthenticate(t *testing.T) {
 	require.NoError(t, err)
 	r := request.WithHTTPSFlag(&http.Request{URL: reqURL}, true)
 
-	assert.Equal(t, false, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
+	require.Equal(t, false, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
 }
 
 func TestTryAuthenticateWithError(t *testing.T) {
@@ -67,8 +66,8 @@ func TestTryAuthenticateWithError(t *testing.T) {
 	require.NoError(t, err)
 	r := request.WithHTTPSFlag(&http.Request{URL: reqURL}, true)
 
-	assert.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
-	assert.Equal(t, 401, result.Code)
+	require.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
+	require.Equal(t, 401, result.Code)
 }
 
 func TestTryAuthenticateWithCodeButInvalidState(t *testing.T) {
@@ -84,19 +83,19 @@ func TestTryAuthenticateWithCodeButInvalidState(t *testing.T) {
 	session.Values["state"] = "state"
 	session.Save(r, result)
 
-	assert.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
-	assert.Equal(t, 401, result.Code)
+	require.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
+	require.Equal(t, 401, result.Code)
 }
 
 func testTryAuthenticateWithCodeAndState(t *testing.T, https bool) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/oauth/token":
-			assert.Equal(t, "POST", r.Method)
+			require.Equal(t, "POST", r.Method)
 			w.WriteHeader(http.StatusOK)
 			fmt.Fprint(w, "{\"access_token\":\"abc\"}")
 		case "/api/v4/projects/1000/pages_access":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusOK)
 		default:
 			t.Logf("Unexpected r.URL.RawPath: %q", r.URL.Path)
@@ -124,11 +123,11 @@ func testTryAuthenticateWithCodeAndState(t *testing.T, https bool) {
 	})
 
 	result := httptest.NewRecorder()
-	assert.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
-	assert.Equal(t, 302, result.Code)
-	assert.Equal(t, "https://pages.gitlab-example.com/project/", result.Header().Get("Location"))
-	assert.Equal(t, 600, result.Result().Cookies()[0].MaxAge)
-	assert.Equal(t, https, result.Result().Cookies()[0].Secure)
+	require.Equal(t, true, auth.TryAuthenticate(result, r, make(domain.Map), &sync.RWMutex{}))
+	require.Equal(t, 302, result.Code)
+	require.Equal(t, "https://pages.gitlab-example.com/project/", result.Header().Get("Location"))
+	require.Equal(t, 600, result.Result().Cookies()[0].MaxAge)
+	require.Equal(t, https, result.Result().Cookies()[0].Secure)
 }
 
 func TestTryAuthenticateWithCodeAndStateOverHTTP(t *testing.T) {
@@ -143,7 +142,7 @@ func TestCheckAuthenticationWhenAccess(t *testing.T) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/v4/projects/1000/pages_access":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusOK)
 		default:
 			t.Logf("Unexpected r.URL.RawPath: %q", r.URL.Path)
@@ -172,15 +171,15 @@ func TestCheckAuthenticationWhenAccess(t *testing.T) {
 	session.Values["access_token"] = "abc"
 	session.Save(r, result)
 
-	assert.Equal(t, false, auth.CheckAuthentication(result, r, 1000))
-	assert.Equal(t, 200, result.Code)
+	require.Equal(t, false, auth.CheckAuthentication(result, r, 1000))
+	require.Equal(t, 200, result.Code)
 }
 
 func TestCheckAuthenticationWhenNoAccess(t *testing.T) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/v4/projects/1000/pages_access":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusUnauthorized)
 		default:
 			t.Logf("Unexpected r.URL.RawPath: %q", r.URL.Path)
@@ -209,15 +208,15 @@ func TestCheckAuthenticationWhenNoAccess(t *testing.T) {
 	session.Values["access_token"] = "abc"
 	session.Save(r, result)
 
-	assert.Equal(t, true, auth.CheckAuthentication(result, r, 1000))
-	assert.Equal(t, 404, result.Code)
+	require.Equal(t, true, auth.CheckAuthentication(result, r, 1000))
+	require.Equal(t, 404, result.Code)
 }
 
 func TestCheckAuthenticationWhenInvalidToken(t *testing.T) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/v4/projects/1000/pages_access":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusUnauthorized)
 			fmt.Fprint(w, "{\"error\":\"invalid_token\"}")
 		default:
@@ -248,15 +247,15 @@ func TestCheckAuthenticationWhenInvalidToken(t *testing.T) {
 	session.Values["access_token"] = "abc"
 	session.Save(r, result)
 
-	assert.Equal(t, true, auth.CheckAuthentication(result, r, 1000))
-	assert.Equal(t, 302, result.Code)
+	require.Equal(t, true, auth.CheckAuthentication(result, r, 1000))
+	require.Equal(t, 302, result.Code)
 }
 
 func TestCheckAuthenticationWithoutProject(t *testing.T) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/v4/user":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusOK)
 		default:
 			t.Logf("Unexpected r.URL.RawPath: %q", r.URL.Path)
@@ -285,15 +284,15 @@ func TestCheckAuthenticationWithoutProject(t *testing.T) {
 	session.Values["access_token"] = "abc"
 	session.Save(r, result)
 
-	assert.Equal(t, false, auth.CheckAuthenticationWithoutProject(result, r))
-	assert.Equal(t, 200, result.Code)
+	require.Equal(t, false, auth.CheckAuthenticationWithoutProject(result, r))
+	require.Equal(t, 200, result.Code)
 }
 
 func TestCheckAuthenticationWithoutProjectWhenInvalidToken(t *testing.T) {
 	apiServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/api/v4/user":
-			assert.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
+			require.Equal(t, "Bearer abc", r.Header.Get("Authorization"))
 			w.WriteHeader(http.StatusUnauthorized)
 			fmt.Fprint(w, "{\"error\":\"invalid_token\"}")
 		default:
@@ -324,13 +323,13 @@ func TestCheckAuthenticationWithoutProjectWhenInvalidToken(t *testing.T) {
 	session.Values["access_token"] = "abc"
 	session.Save(r, result)
 
-	assert.Equal(t, true, auth.CheckAuthenticationWithoutProject(result, r))
-	assert.Equal(t, 302, result.Code)
+	require.Equal(t, true, auth.CheckAuthenticationWithoutProject(result, r))
+	require.Equal(t, 302, result.Code)
 }
 
 func TestGenerateKeyPair(t *testing.T) {
 	signingSecret, encryptionSecret := generateKeyPair("something-very-secret")
-	assert.NotEqual(t, fmt.Sprint(signingSecret), fmt.Sprint(encryptionSecret))
-	assert.Equal(t, len(signingSecret), 32)
-	assert.Equal(t, len(encryptionSecret), 32)
+	require.NotEqual(t, fmt.Sprint(signingSecret), fmt.Sprint(encryptionSecret))
+	require.Equal(t, len(signingSecret), 32)
+	require.Equal(t, len(encryptionSecret), 32)
 }
diff --git a/internal/domain/domain_config_test.go b/internal/domain/domain_config_test.go
index a89ead35..8cdcdeaa 100644
--- a/internal/domain/domain_config_test.go
+++ b/internal/domain/domain_config_test.go
@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -16,25 +15,25 @@ const validConfig = `{"Domains":[{"Domain":"test"}]}`
 
 func TestDomainConfigValidness(t *testing.T) {
 	d := domainConfig{}
-	assert.False(t, d.Valid("gitlab.io"))
+	require.False(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test"}
-	assert.True(t, d.Valid("gitlab.io"))
+	require.True(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test"}
-	assert.True(t, d.Valid("gitlab.io"))
+	require.True(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test.gitlab.io"}
-	assert.False(t, d.Valid("gitlab.io"))
+	require.False(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test.test.gitlab.io"}
-	assert.False(t, d.Valid("gitlab.io"))
+	require.False(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test.testgitlab.io"}
-	assert.True(t, d.Valid("gitlab.io"))
+	require.True(t, d.Valid("gitlab.io"))
 
 	d = domainConfig{Domain: "test.GitLab.Io"}
-	assert.False(t, d.Valid("gitlab.io"))
+	require.False(t, d.Valid("gitlab.io"))
 }
 
 func TestDomainConfigRead(t *testing.T) {
@@ -43,20 +42,20 @@ func TestDomainConfigRead(t *testing.T) {
 
 	d := domainsConfig{}
 	err := d.Read("test-group", "test-project")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	os.MkdirAll(filepath.Dir(configFile), 0700)
 	defer os.RemoveAll("test-group")
 
 	d = domainsConfig{}
 	err = d.Read("test-group", "test-project")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = ioutil.WriteFile(configFile, []byte(invalidConfig), 0600)
 	require.NoError(t, err)
 	d = domainsConfig{}
 	err = d.Read("test-group", "test-project")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	err = ioutil.WriteFile(configFile, []byte(validConfig), 0600)
 	require.NoError(t, err)
diff --git a/internal/domain/domain_test.go b/internal/domain/domain_test.go
index 8b2dae1c..499510a8 100644
--- a/internal/domain/domain_test.go
+++ b/internal/domain/domain_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"gitlab.com/gitlab-org/gitlab-pages/internal/fixture"
@@ -45,27 +44,27 @@ func testGroupServeHTTPHost(t *testing.T, host string) {
 
 	serve := serveFileOrNotFound(testGroup)
 
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/"), nil, "main-dir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/index"), nil, "main-dir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/index.html"), nil, "main-dir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/"), nil, "main-dir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/index"), nil, "main-dir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/index.html"), nil, "main-dir")
 	testhelpers.AssertRedirectTo(t, serve, "GET", makeURL("/project"), nil, "//"+host+"/project/")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project/"), nil, "project-subdir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project/index"), nil, "project-subdir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project/index/"), nil, "project-subdir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project/index.html"), nil, "project-subdir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project/"), nil, "project-subdir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project/index"), nil, "project-subdir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project/index/"), nil, "project-subdir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project/index.html"), nil, "project-subdir")
 	testhelpers.AssertRedirectTo(t, serve, "GET", makeURL("/project/subdir"), nil, "//"+host+"/project/subdir/")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project/subdir/"), nil, "project-subsubdir")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project2/"), nil, "project2-main")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project2/index"), nil, "project2-main")
-	assert.HTTPBodyContains(t, serve, "GET", makeURL("/project2/index.html"), nil, "project2-main")
-	assert.HTTPError(t, serve, "GET", makeURL("/private.project/"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("//about.gitlab.com/%2e%2e"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("/symlink"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("/symlink/index.html"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("/symlink/subdir/"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("/project/fifo"), nil)
-	assert.HTTPError(t, serve, "GET", makeURL("/not-existing-file"), nil)
-	assert.HTTPRedirect(t, serve, "GET", makeURL("/project//about.gitlab.com/%2e%2e"), nil)
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project/subdir/"), nil, "project-subsubdir")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project2/"), nil, "project2-main")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project2/index"), nil, "project2-main")
+	require.HTTPBodyContains(t, serve, "GET", makeURL("/project2/index.html"), nil, "project2-main")
+	require.HTTPError(t, serve, "GET", makeURL("/private.project/"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("//about.gitlab.com/%2e%2e"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("/symlink"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("/symlink/index.html"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("/symlink/subdir/"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("/project/fifo"), nil)
+	require.HTTPError(t, serve, "GET", makeURL("/not-existing-file"), nil)
+	require.HTTPRedirect(t, serve, "GET", makeURL("/project//about.gitlab.com/%2e%2e"), nil)
 }
 
 func TestGroupServeHTTP(t *testing.T) {
@@ -88,15 +87,15 @@ func TestDomainServeHTTP(t *testing.T) {
 		},
 	}
 
-	assert.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/", nil, "project2-main")
-	assert.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/index.html", nil, "project2-main")
-	assert.HTTPRedirect(t, serveFileOrNotFound(testDomain), "GET", "/subdir", nil)
-	assert.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir", nil,
+	require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/", nil, "project2-main")
+	require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/index.html", nil, "project2-main")
+	require.HTTPRedirect(t, serveFileOrNotFound(testDomain), "GET", "/subdir", nil)
+	require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir", nil,
 		`<a href="/subdir/">Found</a>`)
-	assert.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir/", nil, "project2-subdir")
-	assert.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir/index.html", nil, "project2-subdir")
-	assert.HTTPError(t, serveFileOrNotFound(testDomain), "GET", "//about.gitlab.com/%2e%2e", nil)
-	assert.HTTPError(t, serveFileOrNotFound(testDomain), "GET", "/not-existing-file", nil)
+	require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir/", nil, "project2-subdir")
+	require.HTTPBodyContains(t, serveFileOrNotFound(testDomain), "GET", "/subdir/index.html", nil, "project2-subdir")
+	require.HTTPError(t, serveFileOrNotFound(testDomain), "GET", "//about.gitlab.com/%2e%2e", nil)
+	require.HTTPError(t, serveFileOrNotFound(testDomain), "GET", "/not-existing-file", nil)
 }
 
 func TestIsHTTPSOnly(t *testing.T) {
@@ -200,7 +199,7 @@ func TestIsHTTPSOnly(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			req, _ := http.NewRequest(http.MethodGet, test.url, nil)
-			assert.Equal(t, test.expected, test.domain.IsHTTPSOnly(req))
+			require.Equal(t, test.expected, test.domain.IsHTTPSOnly(req))
 		})
 	}
 }
@@ -264,7 +263,7 @@ func TestHasAcmeChallenge(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.expected, test.domain.HasAcmeChallenge(test.token))
+			require.Equal(t, test.expected, test.domain.HasAcmeChallenge(test.token))
 		})
 	}
 }
@@ -284,16 +283,16 @@ func testHTTPGzip(t *testing.T, handler http.HandlerFunc, mode, url string, valu
 		defer reader.Close()
 
 		contentEncoding := w.Header().Get("Content-Encoding")
-		assert.Equal(t, "gzip", contentEncoding, "Content-Encoding")
+		require.Equal(t, "gzip", contentEncoding, "Content-Encoding")
 
 		bytes, err := ioutil.ReadAll(reader)
 		require.NoError(t, err)
-		assert.Contains(t, string(bytes), str)
+		require.Contains(t, string(bytes), str)
 	} else {
-		assert.Contains(t, w.Body.String(), str)
+		require.Contains(t, w.Body.String(), str)
 	}
 
-	assert.Equal(t, contentType, w.Header().Get("Content-Type"))
+	require.Equal(t, contentType, w.Header().Get("Content-Type"))
 }
 
 func TestGroupServeHTTPGzip(t *testing.T) {
@@ -386,7 +385,7 @@ func TestGroup404ServeHTTP(t *testing.T) {
 	testhelpers.AssertHTTP404(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/not/existing-file", nil, "Custom 404 group page")
 	testhelpers.AssertHTTP404(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/not-existing-file", nil, "Custom 404 group page")
 	testhelpers.AssertHTTP404(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/", nil, "Custom 404 group page")
-	assert.HTTPBodyNotContains(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/project.404.symlink/not/existing-file", nil, "Custom 404 project page")
+	require.HTTPBodyNotContains(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/project.404.symlink/not/existing-file", nil, "Custom 404 project page")
 
 	// Ensure the namespace project's custom 404.html is not used by projects
 	testhelpers.AssertHTTP404(t, serveFileOrNotFound(testGroup), "GET", "http://group.404.test.io/project.no.404/not/existing-file", nil, "The page you're looking for could not be found.")
@@ -426,8 +425,8 @@ func TestGroupCertificate(t *testing.T) {
 	}
 
 	tls, err := testGroup.EnsureCertificate()
-	assert.Nil(t, tls)
-	assert.Error(t, err)
+	require.Nil(t, tls)
+	require.Error(t, err)
 }
 
 func TestDomainNoCertificate(t *testing.T) {
@@ -440,12 +439,12 @@ func TestDomainNoCertificate(t *testing.T) {
 	}
 
 	tls, err := testDomain.EnsureCertificate()
-	assert.Nil(t, tls)
-	assert.Error(t, err)
+	require.Nil(t, tls)
+	require.Error(t, err)
 
 	_, err2 := testDomain.EnsureCertificate()
-	assert.Error(t, err)
-	assert.Equal(t, err, err2)
+	require.Error(t, err)
+	require.Equal(t, err, err2)
 }
 
 func TestDomainCertificate(t *testing.T) {
@@ -460,7 +459,7 @@ func TestDomainCertificate(t *testing.T) {
 	}
 
 	tls, err := testDomain.EnsureCertificate()
-	assert.NotNil(t, tls)
+	require.NotNil(t, tls)
 	require.NoError(t, err)
 }
 
@@ -483,8 +482,8 @@ func TestCacheControlHeaders(t *testing.T) {
 	now := time.Now()
 	serveFileOrNotFound(testGroup)(w, req)
 
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "max-age=600", w.Header().Get("Cache-Control"))
+	require.Equal(t, http.StatusOK, w.Code)
+	require.Equal(t, "max-age=600", w.Header().Get("Cache-Control"))
 
 	expires := w.Header().Get("Expires")
 	require.NotEmpty(t, expires)
@@ -492,7 +491,7 @@ func TestCacheControlHeaders(t *testing.T) {
 	expiresTime, err := time.Parse(time.RFC1123, expires)
 	require.NoError(t, err)
 
-	assert.WithinDuration(t, now.UTC().Add(10*time.Minute), expiresTime.UTC(), time.Minute)
+	require.WithinDuration(t, now.UTC().Add(10*time.Minute), expiresTime.UTC(), time.Minute)
 }
 
 func TestOpenNoFollow(t *testing.T) {
diff --git a/internal/domain/group_test.go b/internal/domain/group_test.go
index 2e41ef53..8f75fe96 100644
--- a/internal/domain/group_test.go
+++ b/internal/domain/group_test.go
@@ -4,7 +4,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGroupDig(t *testing.T) {
@@ -89,9 +89,9 @@ func TestGroupDig(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			project, projectPath, urlPath := test.g.digProjectWithSubpath("", strings.Split(test.path, "/"))
 
-			assert.Equal(t, test.expectedProject, project)
-			assert.Equal(t, test.expectedProjectPath, projectPath)
-			assert.Equal(t, test.expectedPath, urlPath)
+			require.Equal(t, test.expectedProject, project)
+			require.Equal(t, test.expectedProjectPath, projectPath)
+			require.Equal(t, test.expectedPath, urlPath)
 		})
 	}
 }
diff --git a/internal/domain/map_test.go b/internal/domain/map_test.go
index 156b039f..de5e4955 100644
--- a/internal/domain/map_test.go
+++ b/internal/domain/map_test.go
@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/karrick/godirwalk"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -61,19 +60,19 @@ func TestReadProjects(t *testing.T) {
 	}
 
 	for _, expected := range domains {
-		assert.Contains(t, domains, expected)
+		require.Contains(t, domains, expected)
 	}
 
 	for _, actual := range domains {
-		assert.Contains(t, expectedDomains, actual)
+		require.Contains(t, expectedDomains, actual)
 	}
 
 	// Check that multiple domains in the same project are recorded faithfully
 	exp1 := &domainConfig{Domain: "test.domain.com"}
-	assert.Equal(t, exp1, dm["test.domain.com"].config)
+	require.Equal(t, exp1, dm["test.domain.com"].config)
 
 	exp2 := &domainConfig{Domain: "other.domain.com", Certificate: "test", Key: "key"}
-	assert.Equal(t, exp2, dm["other.domain.com"].config)
+	require.Equal(t, exp2, dm["other.domain.com"].config)
 
 	// check subgroups
 	domain, ok := dm["group.test.io"]
@@ -105,7 +104,7 @@ func TestReadProjectsMaxDepth(t *testing.T) {
 	}
 
 	for _, expected := range domains {
-		assert.Contains(t, domains, expected)
+		require.Contains(t, domains, expected)
 	}
 
 	for _, actual := range domains {
@@ -113,7 +112,7 @@ func TestReadProjectsMaxDepth(t *testing.T) {
 		if !strings.HasSuffix(actual, defaultDomain) {
 			continue
 		}
-		assert.Contains(t, expectedDomains, actual)
+		require.Contains(t, expectedDomains, actual)
 	}
 
 	// check subgroups
@@ -165,15 +164,15 @@ func TestWatch(t *testing.T) {
 	defer os.Remove(updateFile)
 
 	domains := recvTimeout(t, update)
-	assert.NotNil(t, domains, "if the domains are fetched on start")
+	require.NotNil(t, domains, "if the domains are fetched on start")
 
 	writeRandomTimestamp(t)
 	domains = recvTimeout(t, update)
-	assert.NotNil(t, domains, "if the domains are updated after the creation")
+	require.NotNil(t, domains, "if the domains are updated after the creation")
 
 	writeRandomTimestamp(t)
 	domains = recvTimeout(t, update)
-	assert.NotNil(t, domains, "if the domains are updated after the timestamp change")
+	require.NotNil(t, domains, "if the domains are updated after the timestamp change")
 }
 
 func recvTimeout(t *testing.T, ch <-chan Map) Map {
diff --git a/internal/host/host_test.go b/internal/host/host_test.go
index 8395d3fc..7168eb1b 100644
--- a/internal/host/host_test.go
+++ b/internal/host/host_test.go
@@ -4,15 +4,15 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFromString(t *testing.T) {
-	assert.Equal(t, "example.com", FromString("example.com"))
-	assert.Equal(t, "example.com", FromString("eXAmpLe.com"))
-	assert.Equal(t, "example.com", FromString("example.com:8080"))
+	require.Equal(t, "example.com", FromString("example.com"))
+	require.Equal(t, "example.com", FromString("eXAmpLe.com"))
+	require.Equal(t, "example.com", FromString("example.com:8080"))
 }
 
 func TestFromRequest(t *testing.T) {
-	assert.Equal(t, "example.com", FromRequest(httptest.NewRequest("GET", "example.com:8080/123", nil)))
+	require.Equal(t, "example.com", FromRequest(httptest.NewRequest("GET", "example.com:8080/123", nil)))
 }
diff --git a/internal/httperrors/httperrors_test.go b/internal/httperrors/httperrors_test.go
index be532dfe..b003ce6f 100644
--- a/internal/httperrors/httperrors_test.go
+++ b/internal/httperrors/httperrors_test.go
@@ -5,7 +5,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // creates a new implementation of http.ResponseWriter that allows the
@@ -54,64 +54,64 @@ var (
 
 func TestGenerateemailHTML(t *testing.T) {
 	actual := generateErrorHTML(testingContent)
-	assert.Contains(t, actual, testingContent.title)
-	assert.Contains(t, actual, testingContent.statusString)
-	assert.Contains(t, actual, testingContent.header)
-	assert.Contains(t, actual, testingContent.subHeader)
+	require.Contains(t, actual, testingContent.title)
+	require.Contains(t, actual, testingContent.statusString)
+	require.Contains(t, actual, testingContent.header)
+	require.Contains(t, actual, testingContent.subHeader)
 }
 
 func TestServeErrorPage(t *testing.T) {
 	w := newTestResponseWriter(httptest.NewRecorder())
 	serveErrorPage(w, testingContent)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
-	assert.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
-	assert.Equal(t, w.Status(), testingContent.status)
+	require.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	require.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
+	require.Equal(t, w.Status(), testingContent.status)
 }
 
 func TestServe401(t *testing.T) {
 	w := newTestResponseWriter(httptest.NewRecorder())
 	Serve401(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
-	assert.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
-	assert.Equal(t, w.Status(), content401.status)
-	assert.Contains(t, w.Content(), content401.title)
-	assert.Contains(t, w.Content(), content401.statusString)
-	assert.Contains(t, w.Content(), content401.header)
-	assert.Contains(t, w.Content(), content401.subHeader)
+	require.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	require.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
+	require.Equal(t, w.Status(), content401.status)
+	require.Contains(t, w.Content(), content401.title)
+	require.Contains(t, w.Content(), content401.statusString)
+	require.Contains(t, w.Content(), content401.header)
+	require.Contains(t, w.Content(), content401.subHeader)
 }
 
 func TestServe404(t *testing.T) {
 	w := newTestResponseWriter(httptest.NewRecorder())
 	Serve404(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
-	assert.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
-	assert.Equal(t, w.Status(), content404.status)
-	assert.Contains(t, w.Content(), content404.title)
-	assert.Contains(t, w.Content(), content404.statusString)
-	assert.Contains(t, w.Content(), content404.header)
-	assert.Contains(t, w.Content(), content404.subHeader)
+	require.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	require.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
+	require.Equal(t, w.Status(), content404.status)
+	require.Contains(t, w.Content(), content404.title)
+	require.Contains(t, w.Content(), content404.statusString)
+	require.Contains(t, w.Content(), content404.header)
+	require.Contains(t, w.Content(), content404.subHeader)
 }
 
 func TestServe500(t *testing.T) {
 	w := newTestResponseWriter(httptest.NewRecorder())
 	Serve500(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
-	assert.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
-	assert.Equal(t, w.Status(), content500.status)
-	assert.Contains(t, w.Content(), content500.title)
-	assert.Contains(t, w.Content(), content500.statusString)
-	assert.Contains(t, w.Content(), content500.header)
-	assert.Contains(t, w.Content(), content500.subHeader)
+	require.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	require.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
+	require.Equal(t, w.Status(), content500.status)
+	require.Contains(t, w.Content(), content500.title)
+	require.Contains(t, w.Content(), content500.statusString)
+	require.Contains(t, w.Content(), content500.header)
+	require.Contains(t, w.Content(), content500.subHeader)
 }
 
 func TestServe502(t *testing.T) {
 	w := newTestResponseWriter(httptest.NewRecorder())
 	Serve502(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
-	assert.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
-	assert.Equal(t, w.Status(), content502.status)
-	assert.Contains(t, w.Content(), content502.title)
-	assert.Contains(t, w.Content(), content502.statusString)
-	assert.Contains(t, w.Content(), content502.header)
-	assert.Contains(t, w.Content(), content502.subHeader)
+	require.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	require.Equal(t, w.Header().Get("X-Content-Type-Options"), "nosniff")
+	require.Equal(t, w.Status(), content502.status)
+	require.Contains(t, w.Content(), content502.title)
+	require.Contains(t, w.Content(), content502.statusString)
+	require.Contains(t, w.Content(), content502.header)
+	require.Contains(t, w.Content(), content502.subHeader)
 }
diff --git a/internal/jail/jail_test.go b/internal/jail/jail_test.go
index 9a192d9c..27282cae 100644
--- a/internal/jail/jail_test.go
+++ b/internal/jail/jail_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"gitlab.com/gitlab-org/gitlab-pages/internal/jail"
@@ -21,7 +20,7 @@ func tmpJailPath() string {
 }
 
 func TestTimestampedJails(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	prefix := "jail"
 	var mode os.FileMode = 0755
@@ -29,33 +28,33 @@ func TestTimestampedJails(t *testing.T) {
 	j1 := jail.CreateTimestamped(prefix, mode)
 	j2 := jail.CreateTimestamped(prefix, mode)
 
-	assert.NotEqual(j1.Path(), j2.Path())
+	require.NotEqual(j1.Path(), j2.Path())
 }
 
 func TestJailPath(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	jailPath := tmpJailPath()
 	cage := jail.Create(jailPath, 0755)
 
-	assert.Equal(jailPath, cage.Path())
+	require.Equal(jailPath, cage.Path())
 }
 
 func TestJailBuild(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	jailPath := tmpJailPath()
 	cage := jail.Create(jailPath, 0755)
 
 	_, err := os.Stat(cage.Path())
-	assert.Error(err, "Jail path should not exist before Jail.Build()")
+	require.Error(err, "Jail path should not exist before Jail.Build()")
 
 	err = cage.Build()
-	require.NoError(t, err)
+	require.NoError(err)
 	defer cage.Dispose()
 
 	_, err = os.Stat(cage.Path())
-	require.NoError(t, err, "Jail path should exist after Jail.Build()")
+	require.NoError(err, "Jail path should exist after Jail.Build()")
 }
 
 func TestJailOnlySupportsOneBindMount(t *testing.T) {
@@ -86,32 +85,32 @@ func TestJailBuildCleansUpWhenMountFails(t *testing.T) {
 }
 
 func TestJailDispose(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	jailPath := tmpJailPath()
 	cage := jail.Create(jailPath, 0755)
 
 	err := cage.Build()
-	require.NoError(t, err)
+	require.NoError(err)
 
 	err = cage.Dispose()
-	require.NoError(t, err)
+	require.NoError(err)
 
 	_, err = os.Stat(cage.Path())
-	assert.Error(err, "Jail path should not exist after Jail.Dispose()")
+	require.Error(err, "Jail path should not exist after Jail.Dispose()")
 }
 
 func TestJailDisposeDoNotFailOnMissingPath(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	jailPath := tmpJailPath()
 	cage := jail.Create(jailPath, 0755)
 
 	_, err := os.Stat(cage.Path())
-	assert.Error(err, "Jail path should not exist")
+	require.Error(err, "Jail path should not exist")
 
 	err = cage.Dispose()
-	require.NoError(t, err)
+	require.NoError(err)
 }
 
 func TestJailWithCharacterDevice(t *testing.T) {
@@ -143,11 +142,11 @@ func TestJailWithCharacterDevice(t *testing.T) {
 	require.NoError(t, err)
 
 	isCharDev := fi.Mode()&os.ModeCharDevice == os.ModeCharDevice
-	assert.True(t, isCharDev, "Created file was not a character device")
+	require.True(t, isCharDev, "Created file was not a character device")
 
 	sys, ok = fi.Sys().(*syscall.Stat_t)
 	require.True(t, ok, "Couldn't determine rdev of created character device")
-	assert.Equal(t, expectedRdev, sys.Rdev, "Incorrect rdev for /dev/urandom")
+	require.Equal(t, expectedRdev, sys.Rdev, "Incorrect rdev for /dev/urandom")
 }
 
 func TestJailWithFiles(t *testing.T) {
@@ -180,7 +179,7 @@ func TestJailWithFiles(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			assert := assert.New(t)
+			require := require.New(t)
 
 			cage := jail.CreateTimestamped("jail-mkdir", 0755)
 			for _, dir := range test.directories {
@@ -196,18 +195,18 @@ func TestJailWithFiles(t *testing.T) {
 			defer cage.Dispose()
 
 			if test.error {
-				assert.Error(err)
+				require.Error(err)
 			} else {
-				require.NoError(t, err)
+				require.NoError(err)
 
 				for _, dir := range test.directories {
 					_, err := os.Stat(path.Join(cage.Path(), dir))
-					require.NoError(t, err, "jailed dir should exist")
+					require.NoError(err, "jailed dir should exist")
 				}
 
 				for _, file := range test.files {
 					_, err := os.Stat(path.Join(cage.Path(), file))
-					require.NoError(t, err, "Jailed file should exist")
+					require.NoError(err, "Jailed file should exist")
 				}
 			}
 		})
@@ -215,7 +214,7 @@ func TestJailWithFiles(t *testing.T) {
 }
 
 func TestJailCopyTo(t *testing.T) {
-	assert := assert.New(t)
+	require := require.New(t)
 
 	content := "hello"
 
@@ -232,24 +231,24 @@ func TestJailCopyTo(t *testing.T) {
 	jailedFilePath := cage.ExternalPath(path.Base(filePath))
 
 	err = cage.CopyTo(path.Base(filePath), filePath)
-	require.NoError(t, err)
+	require.NoError(err)
 
 	err = cage.Build()
 	defer cage.Dispose()
-	require.NoError(t, err)
+	require.NoError(err)
 
 	jailedFI, err := os.Stat(jailedFilePath)
-	require.NoError(t, err)
+	require.NoError(err)
 
 	fi, err := os.Stat(filePath)
-	require.NoError(t, err)
+	require.NoError(err)
 
-	assert.Equal(fi.Mode(), jailedFI.Mode(), "jailed file should preserve file mode")
-	assert.Equal(fi.Size(), jailedFI.Size(), "jailed file should have same size of original file")
+	require.Equal(fi.Mode(), jailedFI.Mode(), "jailed file should preserve file mode")
+	require.Equal(fi.Size(), jailedFI.Size(), "jailed file should have same size of original file")
 
 	jailedContent, err := ioutil.ReadFile(jailedFilePath)
-	require.NoError(t, err)
-	assert.Equal(content, string(jailedContent), "jailed file should preserve file content")
+	require.NoError(err)
+	require.Equal(content, string(jailedContent), "jailed file should preserve file content")
 }
 
 func TestJailLazyUnbind(t *testing.T) {
@@ -257,15 +256,15 @@ func TestJailLazyUnbind(t *testing.T) {
 		t.Skip("chroot binding requires linux and root permissions")
 	}
 
-	assert := assert.New(t)
+	require := require.New(t)
 
 	toBind, err := ioutil.TempDir("", "to-bind")
-	require.NoError(t, err)
+	require.NoError(err)
 	defer os.RemoveAll(toBind)
 
 	tmpFilePath := path.Join(toBind, "a-file")
 	tmpFile, err := os.OpenFile(tmpFilePath, os.O_CREATE, 0644)
-	require.NoError(t, err)
+	require.NoError(err)
 	tmpFile.Close()
 
 	jailPath := tmpJailPath()
@@ -275,28 +274,28 @@ func TestJailLazyUnbind(t *testing.T) {
 	cage.Bind("/my-bind", toBind)
 
 	err = cage.Build()
-	require.NoError(t, err, "jail build failed")
+	require.NoError(err, "jail build failed")
 
 	bindedTmpFilePath := cage.ExternalPath("/my-bind/a-file")
 	f, err := os.Open(bindedTmpFilePath)
-	require.NoError(t, err, "temporary file not binded")
-	require.NotNil(t, f)
+	require.NoError(err, "temporary file not binded")
+	require.NotNil(f)
 
 	err = cage.LazyUnbind()
-	require.NoError(t, err, "lazy unbind failed")
+	require.NoError(err, "lazy unbind failed")
 
 	f.Close()
 	_, err = os.Stat(bindedTmpFilePath)
-	assert.Error(err, "lazy unbind should remove mount-point after file close")
+	require.Error(err, "lazy unbind should remove mount-point after file close")
 
 	err = cage.Dispose()
-	require.NoError(t, err, "dispose failed")
+	require.NoError(err, "dispose failed")
 
 	_, err = os.Stat(cage.Path())
-	assert.Error(err, "Jail path should not exist after Jail.Dispose()")
+	require.Error(err, "Jail path should not exist after Jail.Dispose()")
 
 	_, err = os.Stat(tmpFilePath)
-	require.NoError(t, err, "disposing a jail should not delete files under binded directories")
+	require.NoError(err, "disposing a jail should not delete files under binded directories")
 }
 
 func TestJailIntoOnlyCleansSubpaths(t *testing.T) {
diff --git a/internal/request/request_test.go b/internal/request/request_test.go
index 97e40ee4..afb40142 100644
--- a/internal/request/request_test.go
+++ b/internal/request/request_test.go
@@ -4,7 +4,6 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"gitlab.com/gitlab-org/gitlab-pages/internal/domain"
@@ -15,25 +14,25 @@ func TestWithHTTPSFlag(t *testing.T) {
 	require.NoError(t, err)
 
 	httpsRequest := WithHTTPSFlag(r, true)
-	assert.True(t, IsHTTPS(httpsRequest))
+	require.True(t, IsHTTPS(httpsRequest))
 
 	httpRequest := WithHTTPSFlag(r, false)
-	assert.False(t, IsHTTPS(httpRequest))
+	require.False(t, IsHTTPS(httpRequest))
 }
 
 func TestPanics(t *testing.T) {
 	r, err := http.NewRequest("GET", "/", nil)
 	require.NoError(t, err)
 
-	assert.Panics(t, func() {
+	require.Panics(t, func() {
 		IsHTTPS(r)
 	})
 
-	assert.Panics(t, func() {
+	require.Panics(t, func() {
 		GetHost(r)
 	})
 
-	assert.Panics(t, func() {
+	require.Panics(t, func() {
 		GetDomain(r)
 	})
 }
@@ -61,8 +60,8 @@ func TestWithHostAndDomain(t *testing.T) {
 			require.NoError(t, err)
 
 			r = WithHostAndDomain(r, tt.host, tt.domain)
-			assert.Exactly(t, tt.domain, GetDomain(r))
-			assert.Equal(t, tt.host, GetHost(r))
+			require.Exactly(t, tt.domain, GetDomain(r))
+			require.Equal(t, tt.host, GetHost(r))
 		})
 	}
 }
diff --git a/internal/testhelpers/testhelpers.go b/internal/testhelpers/testhelpers.go
index 1c3a1eba..c0b87d93 100644
--- a/internal/testhelpers/testhelpers.go
+++ b/internal/testhelpers/testhelpers.go
@@ -7,7 +7,6 @@ import (
 	"net/url"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -18,12 +17,12 @@ func AssertHTTP404(t *testing.T, handler http.HandlerFunc, mode, url string, val
 	require.NoError(t, err)
 	handler(w, req)
 
-	assert.Equal(t, http.StatusNotFound, w.Code, "HTTP status")
+	require.Equal(t, http.StatusNotFound, w.Code, "HTTP status")
 
 	if str != nil {
 		contentType, _, _ := mime.ParseMediaType(w.Header().Get("Content-Type"))
-		assert.Equal(t, "text/html", contentType, "Content-Type")
-		assert.Contains(t, w.Body.String(), str)
+		require.Equal(t, "text/html", contentType, "Content-Type")
+		require.Contains(t, w.Body.String(), str)
 	}
 }
 
@@ -31,7 +30,7 @@ func AssertHTTP404(t *testing.T, handler http.HandlerFunc, mode, url string, val
 func AssertRedirectTo(t *testing.T, handler http.HandlerFunc, method string,
 	url string, values url.Values, expectedURL string) {
 
-	assert.HTTPRedirect(t, handler, method, url, values)
+	require.HTTPRedirect(t, handler, method, url, values)
 
 	recorder := httptest.NewRecorder()
 
@@ -40,5 +39,5 @@ func AssertRedirectTo(t *testing.T, handler http.HandlerFunc, method string,
 
 	handler(recorder, req)
 
-	assert.Equal(t, expectedURL, recorder.Header().Get("Location"))
+	require.Equal(t, expectedURL, recorder.Header().Get("Location"))
 }
diff --git a/internal/tlsconfig/tlsconfig_go1_12_test.go b/internal/tlsconfig/tlsconfig_go1_12_test.go
index 56b58c9d..09d18284 100644
--- a/internal/tlsconfig/tlsconfig_go1_12_test.go
+++ b/internal/tlsconfig/tlsconfig_go1_12_test.go
@@ -6,7 +6,6 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -30,9 +29,9 @@ func TestEnableTLS13(t *testing.T) {
 			require.NoError(t, err)
 
 			if tc.enableTLS13 {
-				assert.Regexp(t, "tls13=1", os.Getenv("GODEBUG"))
+				require.Regexp(t, "tls13=1", os.Getenv("GODEBUG"))
 			} else {
-				assert.NotRegexp(t, "tls13=1", godebug)
+				require.NotRegexp(t, "tls13=1", godebug)
 			}
 		})