155 lines
4.3 KiB
Go
155 lines
4.3 KiB
Go
package mocks
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/authelia/authelia/internal/regulation"
|
|
"github.com/authelia/authelia/internal/storage"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/sirupsen/logrus/hooks/test"
|
|
"github.com/valyala/fasthttp"
|
|
|
|
"github.com/authelia/authelia/internal/authorization"
|
|
"github.com/authelia/authelia/internal/configuration/schema"
|
|
"github.com/authelia/authelia/internal/middlewares"
|
|
"github.com/authelia/authelia/internal/session"
|
|
)
|
|
|
|
// MockAutheliaCtx a mock of AutheliaCtx
|
|
type MockAutheliaCtx struct {
|
|
// Logger hook
|
|
Hook *test.Hook
|
|
Ctx *middlewares.AutheliaCtx
|
|
Ctrl *gomock.Controller
|
|
|
|
// Providers
|
|
UserProviderMock *MockUserProvider
|
|
StorageProviderMock *storage.MockProvider
|
|
NotifierMock *MockNotifier
|
|
|
|
UserSession *session.UserSession
|
|
|
|
Clock TestingClock
|
|
}
|
|
|
|
// TestingClock implementation of clock for tests
|
|
type TestingClock struct {
|
|
now time.Time
|
|
}
|
|
|
|
// Now return the stored clock
|
|
func (dc *TestingClock) Now() time.Time {
|
|
return dc.now
|
|
}
|
|
|
|
// After return a channel receiving the time after duration has elapsed
|
|
func (dc *TestingClock) After(d time.Duration) <-chan time.Time {
|
|
return time.After(d)
|
|
}
|
|
|
|
// Set set the time of the clock
|
|
func (dc *TestingClock) Set(now time.Time) {
|
|
dc.now = now
|
|
}
|
|
|
|
// NewMockAutheliaCtx create an instance of AutheliaCtx mock
|
|
func NewMockAutheliaCtx(t *testing.T) *MockAutheliaCtx {
|
|
mockAuthelia := new(MockAutheliaCtx)
|
|
mockAuthelia.Clock = TestingClock{}
|
|
|
|
datetime, _ := time.Parse("2006-Jan-02", "2013-Feb-03")
|
|
mockAuthelia.Clock.Set(datetime)
|
|
|
|
configuration := schema.Configuration{}
|
|
configuration.Session.RememberMeDuration = schema.DefaultSessionConfiguration.RememberMeDuration
|
|
configuration.Session.Name = "authelia_session"
|
|
configuration.AccessControl.DefaultPolicy = "deny"
|
|
configuration.AccessControl.Rules = []schema.ACLRule{{
|
|
Domain: "bypass.example.com",
|
|
Policy: "bypass",
|
|
}, {
|
|
Domain: "one-factor.example.com",
|
|
Policy: "one_factor",
|
|
}, {
|
|
Domain: "two-factor.example.com",
|
|
Policy: "two_factor",
|
|
}, {
|
|
Domain: "deny.example.com",
|
|
Policy: "deny",
|
|
}}
|
|
|
|
providers := middlewares.Providers{}
|
|
|
|
mockAuthelia.Ctrl = gomock.NewController(t)
|
|
mockAuthelia.UserProviderMock = NewMockUserProvider(mockAuthelia.Ctrl)
|
|
providers.UserProvider = mockAuthelia.UserProviderMock
|
|
|
|
mockAuthelia.StorageProviderMock = storage.NewMockProvider(mockAuthelia.Ctrl)
|
|
providers.StorageProvider = mockAuthelia.StorageProviderMock
|
|
|
|
mockAuthelia.NotifierMock = NewMockNotifier(mockAuthelia.Ctrl)
|
|
providers.Notifier = mockAuthelia.NotifierMock
|
|
|
|
providers.Authorizer = authorization.NewAuthorizer(
|
|
configuration.AccessControl)
|
|
|
|
providers.SessionProvider = session.NewProvider(
|
|
configuration.Session)
|
|
|
|
providers.Regulator = regulation.NewRegulator(configuration.Regulation, providers.StorageProvider, &mockAuthelia.Clock)
|
|
|
|
request := &fasthttp.RequestCtx{}
|
|
// Set a cookie to identify this client throughout the test
|
|
// request.Request.Header.SetCookie("authelia_session", "client_cookie")
|
|
|
|
autheliaCtx, _ := middlewares.NewAutheliaCtx(request, configuration, providers)
|
|
mockAuthelia.Ctx = autheliaCtx
|
|
|
|
logger, hook := test.NewNullLogger()
|
|
mockAuthelia.Hook = hook
|
|
|
|
mockAuthelia.Ctx.Logger = logrus.NewEntry(logger)
|
|
return mockAuthelia
|
|
}
|
|
|
|
// Close close the mock
|
|
func (m *MockAutheliaCtx) Close() {
|
|
m.Hook.Reset()
|
|
m.Ctrl.Finish()
|
|
}
|
|
|
|
// Assert200KO assert an error response from the service.
|
|
func (m *MockAutheliaCtx) Assert200KO(t *testing.T, message string) {
|
|
assert.Equal(t, 200, m.Ctx.Response.StatusCode())
|
|
assert.Equal(t, fmt.Sprintf("{\"status\":\"KO\",\"message\":\"%s\"}", message), string(m.Ctx.Response.Body()))
|
|
}
|
|
|
|
// Assert200OK assert a successful response from the service.
|
|
func (m *MockAutheliaCtx) Assert200OK(t *testing.T, data interface{}) {
|
|
assert.Equal(t, 200, m.Ctx.Response.StatusCode())
|
|
response := middlewares.OKResponse{
|
|
Status: "OK",
|
|
Data: data,
|
|
}
|
|
|
|
b, err := json.Marshal(response)
|
|
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, string(b), string(m.Ctx.Response.Body()))
|
|
}
|
|
|
|
func (m *MockAutheliaCtx) GetResponseData(t *testing.T, data interface{}) {
|
|
okResponse := middlewares.OKResponse{}
|
|
okResponse.Data = data
|
|
err := json.Unmarshal(m.Ctx.Response.Body(), &okResponse)
|
|
require.NoError(t, err)
|
|
}
|