249 lines
6.3 KiB
Go
249 lines
6.3 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"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.mtux.eu/darkgopher/session"
|
|
|
|
//all impls imports here ...
|
|
_ "git.mtux.eu/darkgopher/session/storage/memory"
|
|
)
|
|
|
|
const sid = "sid"
|
|
const lifet = 180
|
|
const testsrvaddr = ":8888"
|
|
|
|
var sm *session.Manager //current session impl.
|
|
var tc *TestClient //current test client
|
|
|
|
type TestServer struct {
|
|
addr string
|
|
}
|
|
|
|
func NewTestServer(addr string) (ts *TestServer) {
|
|
return &TestServer{addr}
|
|
}
|
|
|
|
func (ts *TestServer) Serve() {
|
|
http.HandleFunc("/startsession", ts.startSession) //ck
|
|
http.HandleFunc("/destroysession", ts.destroySession) //ck
|
|
http.HandleFunc("/setsessionvar", ts.setSessionVar)
|
|
http.HandleFunc("/getsessionvar", ts.getSessionVar)
|
|
http.HandleFunc("/updatesessionvar", ts.updateSessionVar)
|
|
http.HandleFunc("/validateupdatedvalue", ts.validateUpdatedValue)
|
|
http.HandleFunc("/deletesessionvalue", ts.deleteSessionValue)
|
|
http.HandleFunc("/validatedeletedvalue", ts.validateDeletedValue)
|
|
http.HandleFunc("/sessionGC", ts.sessionGC) //ck
|
|
http.ListenAndServe(ts.addr, nil)
|
|
}
|
|
|
|
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())
|
|
}
|
|
if n, err = sess.Get("Vek"); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
if v.(string) != "Minule" {
|
|
fmt.Fprintf(w, "Value of session key: 'Pes' must be 'Minule', not: %s", v)
|
|
}
|
|
if n.(int) != 10 {
|
|
fmt.Fprintf(w, "Value of session key: 'Vek' must be '16', not: %d", n)
|
|
}
|
|
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())
|
|
}
|
|
fmt.Println(sess)
|
|
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 err error
|
|
if _, err = sm.SessionStart(w, r); err != nil {
|
|
io.WriteString(w, err.Error())
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
io.WriteString(w, "OK")
|
|
}
|
|
|
|
type TestClient struct {
|
|
cl *http.Client
|
|
ckstore *cookiejar.Jar
|
|
}
|
|
|
|
func NewTestClient() (tc *TestClient, err error) {
|
|
var ckstore *cookiejar.Jar
|
|
if ckstore, err = cookiejar.New(nil); err != nil {
|
|
return nil, err
|
|
}
|
|
httpclient := &http.Client{Jar: ckstore}
|
|
tc = &TestClient{httpclient, ckstore}
|
|
return
|
|
}
|
|
|
|
// Request send http request into test server and return ResponseResult or error
|
|
func (tc *TestClient) Request(meth, uri string) (resb []byte, err error) {
|
|
var req *http.Request
|
|
if req, err = http.NewRequest(meth, uri, nil); err != nil {
|
|
return nil, fmt.Errorf("Create request to: %s ailed err: %v", uri, err)
|
|
}
|
|
var rs *http.Response
|
|
if rs, err = tc.cl.Do(req); err != nil {
|
|
return nil, fmt.Errorf("Request failed err: %v", err)
|
|
}
|
|
|
|
defer rs.Body.Close()
|
|
var body []byte
|
|
if body, err = io.ReadAll(rs.Body); err != nil {
|
|
return nil, err
|
|
}
|
|
return body, nil
|
|
}
|
|
|
|
func t1(t *testing.T) {
|
|
var res []byte
|
|
var err error
|
|
if res, err = tc.Request("GET", "http://localhost:8080/startsession/"); err != nil {
|
|
t.Logf("err: %v", err)
|
|
t.Error(err)
|
|
}
|
|
if string(res) != "OK" {
|
|
t.Errorf("Response from test request not OK, but: %s", res)
|
|
}
|
|
}
|
|
|
|
func t2(t *testing.T) {}
|
|
func t3(t *testing.T) {}
|
|
func t4(t *testing.T) {}
|
|
func t5(t *testing.T) {}
|
|
func t6(t *testing.T) {}
|
|
func t7(t *testing.T) {}
|
|
|
|
// iterate all session storage impls. and run t1 - t7
|
|
func TestRunAll(t *testing.T) {
|
|
ts := NewTestServer("localhost:8080")
|
|
ts.Serve()
|
|
for _, pn := range session.ProviderNames() {
|
|
var err error
|
|
tc, err = NewTestClient()
|
|
if sm, err = session.NewManager(pn, sid, lifet, true); 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}
|
|
for idx, fn := range fns {
|
|
t.Run(fmt.Sprintf("Test%d", idx+1), fn)
|
|
}
|
|
}
|
|
}
|