303 lines
7.6 KiB
Go
303 lines
7.6 KiB
Go
package tests
|
|
|
|
// Package tests --
|
|
// 1) StartSession -----
|
|
// 2) DestroySessioon -----
|
|
// 3) Set session variable--|
|
|
// 4) Get session variable--|
|
|
// 5) Update -- // --
|
|
// 6) Delete -- // --
|
|
// 7) GC session after lifetime
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/http/cookiejar"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.mtux.eu/darkgopher/session"
|
|
"golang.org/x/net/publicsuffix"
|
|
|
|
//all impls imports here ...
|
|
_ "git.mtux.eu/darkgopher/session/storage/memory"
|
|
)
|
|
|
|
const sid = "sid"
|
|
const lifet = 180
|
|
|
|
var sm *session.Manager //current session impl.
|
|
var testserver *httptest.Server //httptest server h2
|
|
var testclient *http.Client //httptest client h2
|
|
//var cursid string
|
|
|
|
type TestServer struct{}
|
|
|
|
func (ts *TestServer) Serve() {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/startsession", ts.startSession) //ck
|
|
mux.HandleFunc("/destroysession", ts.destroySession) //ck
|
|
mux.HandleFunc("/setsessionvar", ts.setSessionVar)
|
|
mux.HandleFunc("/getsessionvar", ts.getSessionVar)
|
|
mux.HandleFunc("/updatesessionvar", ts.updateSessionVar)
|
|
mux.HandleFunc("/validateupdatedvar", ts.validateUpdatedValue)
|
|
mux.HandleFunc("/deletesessionvar", ts.deleteSessionValue)
|
|
mux.HandleFunc("/validatedeletedvar", ts.validateDeletedValue)
|
|
mux.HandleFunc("/sessionGC", ts.sessionGC) //ck
|
|
testserver = httptest.NewUnstartedServer(mux)
|
|
testserver.EnableHTTP2 = true
|
|
testserver.StartTLS()
|
|
testclient = testserver.Client()
|
|
}
|
|
|
|
func (ts *TestServer) startSession(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
if _, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) destroySession(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
if _, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if err = sm.SessionDestroy(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) setSessionVar(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if err = sess.Set("Pes", "Minule"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if err = sess.Set("Vek", 16); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) getSessionVar(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
|
|
var (
|
|
v any
|
|
n any
|
|
)
|
|
|
|
if v, err = sess.Get("Pes"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
return
|
|
}
|
|
if n, err = sess.Get("Vek"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
return
|
|
}
|
|
if v != nil && v.(string) != "Minule" {
|
|
fmt.Fprintf(w, "Value of session key: 'Pes' must be 'Minule', not: %s", v)
|
|
return
|
|
}
|
|
if n != nil && n.(int) != 16 {
|
|
fmt.Fprintf(w, "Value of session key: 'Vek' must be '16', not: %d", n)
|
|
return
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) updateSessionVar(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
|
|
if err = sess.Set("Vek", 3); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) validateUpdatedValue(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
var n any
|
|
if n, err = sess.Get("Vek"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if n.(int) != 3 {
|
|
io.WriteString(w, fmt.Sprintf("Value vek ater update must be: '3', not: '%d'", n.(int)))
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) deleteSessionValue(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if sess.Delete("Vek"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) validateDeletedValue(w http.ResponseWriter, r *http.Request) {
|
|
var err error
|
|
var sess session.Session
|
|
if sess, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
var v any
|
|
if v, err = sess.Get("Vek"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if v != nil {
|
|
io.WriteString(w, fmt.Sprintf("Session value 'Vek' must be nil after delete, not: %v", v))
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func (ts *TestServer) sessionGC(w http.ResponseWriter, r *http.Request) {
|
|
var ses session.Session
|
|
var err error
|
|
if ses, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
return
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
if sm.Exists(ses.SessionID()) {
|
|
io.WriteString(w, fmt.Sprintf("Session id: %s must not exists in storage after GC",
|
|
ses.SessionID()))
|
|
return
|
|
}
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
func MkRequest(method, path string) (body []byte, err error) {
|
|
var req *http.Request
|
|
uri := fmt.Sprintf("%s%s", testserver.URL, path)
|
|
if req, err = http.NewRequest(method, uri, nil); err != nil {
|
|
return nil, fmt.Errorf("Create request to: %s failed: %v", uri, err)
|
|
}
|
|
var res *http.Response
|
|
if res, err = testclient.Do(req); err != nil {
|
|
return nil, fmt.Errorf("Request to: %s failed: %v", uri, err)
|
|
}
|
|
return io.ReadAll(res.Body)
|
|
}
|
|
|
|
func CheckRequestOK(path string) (err error) {
|
|
var res []byte
|
|
if res, err = MkRequest("GET", path); err != nil {
|
|
return fmt.Errorf("Make request: %s failed: %v", path, err)
|
|
}
|
|
if string(res) != "OK" {
|
|
return fmt.Errorf("Response from test request not OK, but: %s", res)
|
|
}
|
|
return
|
|
}
|
|
|
|
func t1(t *testing.T) {
|
|
if err := CheckRequestOK("/startsession"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
uri, _ := url.Parse(testserver.URL + "/startsession")
|
|
cks := testclient.Jar.Cookies(uri)
|
|
if len(cks) != 1 && cks[0].Name != sid {
|
|
t.Errorf("After session start must be set 1 cookie named: '%s'", sid)
|
|
}
|
|
}
|
|
|
|
func t2(t *testing.T) {
|
|
if err := CheckRequestOK("/destroysession"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
uri, _ := url.Parse(testserver.URL + "/destroysession")
|
|
cks := testclient.Jar.Cookies(uri)
|
|
if len(cks) != 0 && cks[0].Name != sid {
|
|
t.Errorf("After session destroy musoyt be 0 cookies in jar")
|
|
}
|
|
}
|
|
|
|
func t3(t *testing.T) {
|
|
if err := CheckRequestOK("/setsessionvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t4(t *testing.T) {
|
|
if err := CheckRequestOK("/getsessionvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t5(t *testing.T) {
|
|
if err := CheckRequestOK("/updatesessionvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t6(t *testing.T) {
|
|
if err := CheckRequestOK("/validateupdatedvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t7(t *testing.T) {
|
|
if err := CheckRequestOK("/deletesessionvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t8(t *testing.T) {
|
|
if err := CheckRequestOK("/validatedeletedvar"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func t9(t *testing.T) {
|
|
if err := CheckRequestOK("/sessionGC"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
// iterate all session storage impls. and run t1 - t7
|
|
func TestRunAll(t *testing.T) {
|
|
ts := &TestServer{}
|
|
ts.Serve()
|
|
//all impls. subtests
|
|
for _, pn := range session.ProviderNames() {
|
|
var err error
|
|
jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
|
|
testclient.Jar = jar
|
|
sessopts := session.SessOpts{
|
|
ProviderName: "memory", CookieName: sid,
|
|
MaxLifetime: 180, Ssl: true,
|
|
}
|
|
|
|
if sm, err = session.NewManager(sessopts, nil); err != nil {
|
|
t.Errorf("Session provider %s failed initialize err: %v", pn, err)
|
|
}
|
|
fns := []func(t *testing.T){t1, t2, t3, t4, t5, t6, t7, t8, t9}
|
|
for idx, fn := range fns {
|
|
t.Run(fmt.Sprintf("Test%d", idx+1), fn)
|
|
}
|
|
}
|
|
}
|