Simple test for alexedwards/scs using only the public api

This question is a follow-up question to this one. I would like a simple test for https://pkg.go.dev/github.com/alexedwards/scs/v2@v2.5.1 to verify the functions I would like to use. Basically, I just want to put some data into the session, pull it out, and verify it is the same. Something like:

func TestScs_SetGetIsSame1(t *testing.T) {
	sessionManager := scs.New()
	req := httptest.NewRequest("GET", "/", nil)
	key := "boolean"
	expected := false
	sessionManager.Put(req.Context(), key, expected)
	actual := sessionManager.GetBool(req.Context(), key)
	assert.Equal(t, expected, actual)
}

This gives panic: scs: no session data in context.

I tried copying the example from the httptest package, but httptest.Server does not implement http.Handler (missing method ServeHTTP).

func TestScs_SetGetIsSame2(t *testing.T) {
	sessionManager := scs.New()

	ts := httptest.NewServer((http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, client")
		expected := true
		sessionManager.Put(r.Context(), "key", expected)
		actual := sessionManager.GetBool(r.Context(), "key")
		assert.Equal(t, expected, actual)
	})))
	defer ts.Close()

	res, err := http.Get(ts.URL)
	if err != nil {
		log.Fatal(err)
	}

	greeting, err := io.ReadAll(res.Body)
	res.Body.Close()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%s", greeting)

	sessionManager.LoadAndSave(ts)
}

I also looked at the tests in the alexedwards/scs repository, but they use a private function addSessionDataToContext.

What is the best, most simple way to test sessions in go?

I see in your code

ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // ...
}))

sessionManager.LoadAndSave(ts) // this line is incorrect

You are trying to pass the test server (ts) to sessionManager.LoadAndSave. This will not work because sessionManager.LoadAndSave expects an http.Handler, and ts is of type *httptest.Server, not http.Handler.

Instead, you should pass the actual handler to sessionManager.LoadAndSave before creating the test server.

For that, you would wrap the actual handler function with sessionManager.LoadAndSave (which does return a http.Handler) before passing it to httptest.NewServer.

handler := sessionManager.LoadAndSave(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // ... logic here ...
}))

ts := httptest.NewServer(handler)

That creates a new handler by wrapping your actual handler function with the sessionManager.LoadAndSave middleware. This wrapped handler is then passed to httptest.NewServer.

If you bring it all together:

package main

import (
    "fmt"
    "github.com/alexedwards/scs/v2"
    "github.com/stretchr/testify/assert"
    "io"
    "log"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestScs_SetGetIsSame2(t *testing.T) {
    sessionManager := scs.New()

    // Create a handler and wrap it using sessionManager.LoadAndSave
    handler := sessionManager.LoadAndSave(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, client")
        expected := true
        sessionManager.Put(r.Context(), "key", expected)
        actual := sessionManager.GetBool(r.Context(), "key")
        assert.Equal(t, expected, actual)
    }))

    // Create a test server with the handler
    ts := httptest.NewServer(handler)
    defer ts.Close()

    // Make a request to the server
    res, err := http.Get(ts.URL)
    if err != nil {
        log.Fatal(err)
    }

    // Read the response body
    greeting, err := io.ReadAll(res.Body)
    res.Body.Close()
    if err != nil {
        log.Fatal(err)
    }

    // Print the response body
    fmt.Printf("%s", greeting)
}