t1 OK

go.mod

@@ -1,3 +1,5 @@
 module git.mtux.eu/darkgopher/session
 
 go 1.23.4
+
+require golang.org/x/net v0.40.0

go.sum

@@ -0,0 +1,2 @@
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=

session.go

@@ -132,13 +132,13 @@ func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (se
 func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) (err error) {
 	var cookie *http.Cookie
 	if cookie, err = r.Cookie(manager.cookieName); err != nil || cookie.Value == "" {
-		return
+		return fmt.Errorf("Get cookie from request failed: %v", err)
 	}
 
 	manager.provider.Destroy(cookie.Value)
 	rmcookie := http.Cookie{
 		Name: manager.cookieName, Path: "/", HttpOnly: true,
-		Expires: time.Now(), MaxAge: -1,
+		Expires: time.Now(), MaxAge: -1, Secure: manager.secure,
 	}
 	http.SetCookie(w, &rmcookie)
 	return nil

tests/t_test.go

@@ -13,10 +13,12 @@ import (
 	"io"
 	"net/http"
 	"net/http/cookiejar"
+	"net/http/httptest"
 	"testing"
 	"time"
 
 	"git.mtux.eu/darkgopher/session"
+	"golang.org/x/net/publicsuffix"
 
 	//all impls imports here ...
 	_ "git.mtux.eu/darkgopher/session/storage/memory"
@@ -24,30 +26,28 @@ import (
 
 const sid = "sid"
 const lifet = 180
-const testsrvaddr = ":8888"
 
 var sm *session.Manager         //current session impl.
-var tc *TestClient      //current test client
+var testserver *httptest.Server //httptest server h2
+var testclient *http.Client
 
-type TestServer struct {
-	addr string
-}
-
-func NewTestServer(addr string) (ts *TestServer) {
-	return &TestServer{addr}
-}
+type TestServer struct{}
 
 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)
+	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("/validateupdatedvalue", ts.validateUpdatedValue)
+	mux.HandleFunc("/deletesessionvalue", ts.deleteSessionValue)
+	mux.HandleFunc("/validatedeletedvalue", 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) {
@@ -178,45 +178,23 @@ func (ts *TestServer) sessionGC(w http.ResponseWriter, r *http.Request) {
 	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) {
+func MkRequest(method, path string) (body []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)
+	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 rs *http.Response
-	if rs, err = tc.cl.Do(req); err != nil {
-		return nil, fmt.Errorf("Request failed err: %v", err)
+	var res *http.Response
+	if res, err = testclient.Do(req); err != nil {
+		return nil, fmt.Errorf("Request to: %s failed: %v", uri, err)
 	}
-
-	defer rs.Body.Close()
-	var body []byte
-	if body, err = io.ReadAll(rs.Body); err != nil {
-		return nil, err
-	}
-	return body, nil
+	return io.ReadAll(res.Body)
 }
 
 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)
+	if res, err = MkRequest("GET", "/startsession"); err != nil {
 		t.Error(err)
 	}
 	if string(res) != "OK" {
@@ -233,11 +211,14 @@ func t7(t *testing.T) {}
 
 // iterate all session storage impls. and run t1 - t7
 func TestRunAll(t *testing.T) {
-	ts := NewTestServer("localhost:8080")
+
+	ts := &TestServer{}
 	ts.Serve()
+	//all impls. subtests
 	for _, pn := range session.ProviderNames() {
 		var err error
-		tc, err = NewTestClient()
+		jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+		testclient.Jar = jar
 		if sm, err = session.NewManager(pn, sid, lifet, true); err != nil {
 			t.Errorf("Session provider %s failed initialize err: %v", pn, err)
 		}