go/authboss
1
0
Fork 0
mirror of https://github.com/volatiletech/authboss.git synced 2024-11-28 08:58:38 +02:00
Code Issues Releases Activity
931ccfba1f
authboss/client_state_test.go

199 lines
4.5 KiB
Go
Raw Normal View History

Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
package authboss
import (
"io"
"net/http/httptest"
"strings"
"testing"
)
func TestStateGet(t *testing.T) {
t.Parallel()
ab := New()
Get tests working after latest refactors - Change changelog format to use keepachangelog standard - Refactor the config to be made of substructs to help organize all the pieces - Add the new interfaces to the configuration - Clean up module loading (no unnecessary reflection to create new value) - Change User interface to have a Get/SetPID not E-mail/Username, this way we don't ever have to refer to one or the other, we just always assume pid. In the case of Confirm/Recover we'll have to make a GetEmail or there won't be a way for us to get the e-mail to send to. - Delete the xsrf nonsense in the core
2018-02-02 01:42:48 +02:00
ab.Storage.SessionState = newMockClientStateRW("one", "two")
ab.Storage.CookieState = newMockClientStateRW("three", "four")
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
r := httptest.NewRequest("GET", "/", nil)
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
var err error
r, err = ab.LoadClientState(w, r)
if err != nil {
t.Error(err)
}
if got, _ := GetSession(r, "one"); got != "two" {
t.Error("session value was wrong:", got)
}
if got, _ := GetCookie(r, "three"); got != "four" {
t.Error("cookie value was wrong:", got)
}
}
func TestStateResponseWriterDoubleWritePanic(t *testing.T) {
t.Parallel()
ab := New()
Get tests working after latest refactors - Change changelog format to use keepachangelog standard - Refactor the config to be made of substructs to help organize all the pieces - Add the new interfaces to the configuration - Clean up module loading (no unnecessary reflection to create new value) - Change User interface to have a Get/SetPID not E-mail/Username, this way we don't ever have to refer to one or the other, we just always assume pid. In the case of Confirm/Recover we'll have to make a GetEmail or there won't be a way for us to get the e-mail to send to. - Delete the xsrf nonsense in the core
2018-02-02 01:42:48 +02:00
ab.Storage.SessionState = newMockClientStateRW("one", "two")
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
w.WriteHeader(200)
// Check this doesn't panic
w.WriteHeader(200)
defer func() {
if recover() == nil {
t.Error("expected a panic")
}
}()
Fix several lint errors
2018-09-04 01:34:10 +02:00
_ = w.putClientState()
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
}
func TestStateResponseWriterLastSecondWriteHeader(t *testing.T) {
t.Parallel()
ab := New()
Get tests working after latest refactors - Change changelog format to use keepachangelog standard - Refactor the config to be made of substructs to help organize all the pieces - Add the new interfaces to the configuration - Clean up module loading (no unnecessary reflection to create new value) - Change User interface to have a Get/SetPID not E-mail/Username, this way we don't ever have to refer to one or the other, we just always assume pid. In the case of Confirm/Recover we'll have to make a GetEmail or there won't be a way for us to get the e-mail to send to. - Delete the xsrf nonsense in the core
2018-02-02 01:42:48 +02:00
ab.Storage.SessionState = newMockClientStateRW()
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
PutSession(w, "one", "two")
w.WriteHeader(200)
got := strings.TrimSpace(w.Header().Get("test_session"))
if got != `{"one":"two"}` {
t.Error("got:", got)
}
}
func TestStateResponseWriterLastSecondWriteWrite(t *testing.T) {
t.Parallel()
ab := New()
Get tests working after latest refactors - Change changelog format to use keepachangelog standard - Refactor the config to be made of substructs to help organize all the pieces - Add the new interfaces to the configuration - Clean up module loading (no unnecessary reflection to create new value) - Change User interface to have a Get/SetPID not E-mail/Username, this way we don't ever have to refer to one or the other, we just always assume pid. In the case of Confirm/Recover we'll have to make a GetEmail or there won't be a way for us to get the e-mail to send to. - Delete the xsrf nonsense in the core
2018-02-02 01:42:48 +02:00
ab.Storage.SessionState = newMockClientStateRW()
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
PutSession(w, "one", "two")
io.WriteString(w, "Hello world!")
got := strings.TrimSpace(w.Header().Get("test_session"))
if got != `{"one":"two"}` {
t.Error("got:", got)
}
}
func TestStateResponseWriterEvents(t *testing.T) {
t.Parallel()
ab := New()
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
PutSession(w, "one", "two")
DelSession(w, "one")
DelCookie(w, "one")
PutCookie(w, "two", "one")
want := ClientStateEvent{Kind: ClientStateEventPut, Key: "one", Value: "two"}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.sessionStateEvents[0]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
want = ClientStateEvent{Kind: ClientStateEventDel, Key: "one"}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.sessionStateEvents[1]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
want = ClientStateEvent{Kind: ClientStateEventDel, Key: "one"}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.cookieStateEvents[0]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
want = ClientStateEvent{Kind: ClientStateEventPut, Key: "two", Value: "one"}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.cookieStateEvents[1]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
}
func TestFlashClearer(t *testing.T) {
t.Parallel()
ab := New()
Get tests working after latest refactors - Change changelog format to use keepachangelog standard - Refactor the config to be made of substructs to help organize all the pieces - Add the new interfaces to the configuration - Clean up module loading (no unnecessary reflection to create new value) - Change User interface to have a Get/SetPID not E-mail/Username, this way we don't ever have to refer to one or the other, we just always assume pid. In the case of Confirm/Recover we'll have to make a GetEmail or there won't be a way for us to get the e-mail to send to. - Delete the xsrf nonsense in the core
2018-02-02 01:42:48 +02:00
ab.Storage.SessionState = newMockClientStateRW(FlashSuccessKey, "a", FlashErrorKey, "b")
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
r := httptest.NewRequest("GET", "/", nil)
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
w := ab.NewResponse(httptest.NewRecorder())
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
if msg := FlashSuccess(w, r); msg != "" {
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
t.Error("unexpected flash success:", msg)
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
}
if msg := FlashError(w, r); msg != "" {
Clean up context and client state - Remove extraneous http.ResponseWriter from all read-only queries against the request context (for the ClientState) - Instead of using a context.Context on the ClientStateResponseWriter just store variables for the things we'd like to store, it should be less expensive and it's much easier to work with and more clear. - Save the loaded client state into both the ResponseWriter itself and the Request context, the ResponseWriter will store them simply to send them into the WriteState() method later on, the Request will store them to be able to query data.
2018-03-08 02:21:37 +02:00
t.Error("unexpected flash error:", msg)
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
}
var err error
r, err = ab.LoadClientState(w, r)
if err != nil {
t.Error(err)
}
if msg := FlashSuccess(w, r); msg != "a" {
t.Error("Unexpected flash success:", msg)
}
if msg := FlashError(w, r); msg != "b" {
t.Error("Unexpected flash error:", msg)
}
want := ClientStateEvent{Kind: ClientStateEventDel, Key: FlashSuccessKey}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.sessionStateEvents[0]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
want = ClientStateEvent{Kind: ClientStateEventDel, Key: FlashErrorKey}
Fix authboss core tests - Delete callbacks tests - Remove some useless code (SendMail), as well as some extra arguments in certain functions that didn't require them. - Remove tests for more code that has been moved to default implementations
2018-02-01 21:51:43 +02:00
if got := w.sessionStateEvents[1]; got != want {
Introduce new type of client storage - This addresses the problem of having to update multiple times during one request. It's hard to have a nice interface especially with JWT because you always end up having to decode the request, encode new response, write header, then a second write to it comes, and where do you grab the value from? Often you don't have access to the response as a "read" structure. So we store it as events instead, and play those events against the original data right before the response is written to set the headers.
2017-02-25 02:45:47 +02:00
t.Error("event was wrong", got)
}
}
Increase testing coverage. - Missed some actual tests, added them. - Added a bunch of useless tests to increase coverage. Guilty as charged.
2018-05-14 23:27:33 +02:00
func TestDelKnown(t *testing.T) {
t.Parallel()
csrw := &ClientStateResponseWriter{}
DelKnownSession(csrw)
DelKnownCookie(csrw)
mustBeDel := func(ev ClientStateEvent) {
t.Helper()
if ev.Kind != ClientStateEventDel {
t.Error("events should all be deletes")
}
}
if len(csrw.sessionStateEvents) != 3 {
t.Error("should have deleted 3 session entries")
}
mustBeDel(csrw.sessionStateEvents[0])
mustBeDel(csrw.sessionStateEvents[1])
mustBeDel(csrw.sessionStateEvents[2])
for i, key := range []string{SessionKey, SessionHalfAuthKey, SessionLastAction} {
if sessionKey := csrw.sessionStateEvents[i].Key; key != sessionKey {
t.Errorf("%d) key was wrong, want: %s, got: %s", i, key, sessionKey)
}
}
if len(csrw.cookieStateEvents) != 1 {
t.Error("should have deleted 1 cookie")
}
mustBeDel(csrw.cookieStateEvents[0])
if key := csrw.cookieStateEvents[0].Key; key != CookieRemember {
t.Error("cookie key was wrong:", key)
}
}
Reference in New Issue Copy Permalink