github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/api/auth/check_authentication_handler_test.go

package auth_test

import (
	"bytes"
	"io"
	"io/ioutil"
	"net/http"
	"net/http/httptest"

	"github.com/pf-qiu/concourse/v6/atc/api/accessor"
	"github.com/pf-qiu/concourse/v6/atc/api/accessor/accessorfakes"
	"github.com/pf-qiu/concourse/v6/atc/api/auth"
	"github.com/pf-qiu/concourse/v6/atc/api/auth/authfakes"
	"github.com/pf-qiu/concourse/v6/atc/auditor/auditorfakes"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("AuthenticationHandler", func() {

	var (
		fakeAccess   *accessorfakes.FakeAccess
		fakeAccessor *accessorfakes.FakeAccessFactory
		fakeRejector *authfakes.FakeRejector

		server *httptest.Server
		client *http.Client

		err      error
		request  *http.Request
		response *http.Response
	)

	simpleHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		buffer := bytes.NewBufferString("simple hello")

		_, err := io.Copy(w, buffer)
		Expect(err).ToNot(HaveOccurred())
	})

	BeforeEach(func() {
		fakeAccess = new(accessorfakes.FakeAccess)
		fakeAccessor = new(accessorfakes.FakeAccessFactory)
		fakeRejector = new(authfakes.FakeRejector)

		fakeAccessor.CreateReturns(fakeAccess, nil)

		fakeRejector.UnauthorizedStub = func(w http.ResponseWriter, r *http.Request) {
			http.Error(w, "nope", http.StatusUnauthorized)
		}

		client = http.DefaultClient
	})

	JustBeforeEach(func() {
		response, err = client.Do(request)
		Expect(err).NotTo(HaveOccurred())
	})

	Describe("CheckAuthenticationHandler", func() {

		BeforeEach(func() {
			innerHandler := auth.CheckAuthenticationHandler(
				simpleHandler,
				fakeRejector,
			)

			server = httptest.NewServer(accessor.NewHandler(
				logger,
				"some-action",
				innerHandler,
				fakeAccessor,
				new(auditorfakes.FakeAuditor),
				map[string]string{},
			))
		})

		Context("when a request is made", func() {
			BeforeEach(func() {
				request, err = http.NewRequest("GET", server.URL, nil)
				Expect(err).NotTo(HaveOccurred())
			})

			Context("when the user is authenticated ", func() {
				BeforeEach(func() {
					fakeAccess.IsAuthenticatedReturns(true)
				})

				It("returns 200", func() {
					Expect(response.StatusCode).To(Equal(http.StatusOK))
				})

				It("proxies to the handler", func() {
					responseBody, err := ioutil.ReadAll(response.Body)
					Expect(err).NotTo(HaveOccurred())
					Expect(string(responseBody)).To(Equal("simple hello"))
				})
			})

			Context("when the user is not authenticated", func() {
				BeforeEach(func() {
					fakeAccess.IsAuthenticatedReturns(false)
				})

				It("returns 401", func() {
					Expect(response.StatusCode).To(Equal(http.StatusUnauthorized))
				})

				It("rejects the request", func() {
					responseBody, err := ioutil.ReadAll(response.Body)
					Expect(err).NotTo(HaveOccurred())
					Expect(string(responseBody)).To(Equal("nope\n"))
				})
			})
		})
	})

	Describe("CheckAuthenticationIfProvidedHandler", func() {

		BeforeEach(func() {
			innerHandler := auth.CheckAuthenticationIfProvidedHandler(
				simpleHandler,
				fakeRejector,
			)

			server = httptest.NewServer(accessor.NewHandler(
				logger,
				"some-action",
				innerHandler,
				fakeAccessor,
				new(auditorfakes.FakeAuditor),
				map[string]string{},
			))
		})

		Context("when a request is made", func() {
			BeforeEach(func() {
				request, err = http.NewRequest("GET", server.URL, nil)
				Expect(err).NotTo(HaveOccurred())
			})

			Context("when a token is provided", func() {
				BeforeEach(func() {
					fakeAccess.HasTokenReturns(true)
				})

				Context("when the user is not authenticated", func() {
					BeforeEach(func() {
						fakeAccess.IsAuthenticatedReturns(false)
					})

					It("returns 401", func() {
						Expect(response.StatusCode).To(Equal(http.StatusUnauthorized))
					})

					It("rejects the request", func() {
						responseBody, err := ioutil.ReadAll(response.Body)
						Expect(err).NotTo(HaveOccurred())
						Expect(string(responseBody)).To(Equal("nope\n"))
					})
				})

				Context("when the user is authenticated ", func() {
					BeforeEach(func() {
						fakeAccess.IsAuthenticatedReturns(true)
					})

					It("returns 200", func() {
						Expect(response.StatusCode).To(Equal(http.StatusOK))
					})

					It("proxies to the handler", func() {
						responseBody, err := ioutil.ReadAll(response.Body)
						Expect(err).NotTo(HaveOccurred())
						Expect(string(responseBody)).To(Equal("simple hello"))
					})
				})
			})

			Context("when a token is NOT provided", func() {
				BeforeEach(func() {
					fakeAccess.HasTokenReturns(false)
				})

				It("returns 200", func() {
					Expect(response.StatusCode).To(Equal(http.StatusOK))
				})

				It("proxies to the handler", func() {
					responseBody, err := ioutil.ReadAll(response.Body)
					Expect(err).NotTo(HaveOccurred())
					Expect(string(responseBody)).To(Equal("simple hello"))
				})
			})
		})
	})
})