github.com/ijkbytes/memstore@v0.0.0-20190724172552-e67b6955e95a/memstore_test.go (about)

     1  package memstore
     2  
     3  import (
     4  	"github.com/gorilla/sessions"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"strings"
     8  	"sync"
     9  	"testing"
    10  )
    11  
    12  func TestMemStore_Get(t *testing.T) {
    13  	store := NewMemStore(
    14  		&GcOptions{ScanLimit: 2},
    15  		[]byte("authkey"),
    16  		[]byte("enckey1234567890"),
    17  	)
    18  
    19  	req := httptest.NewRequest("GET", "http://test.local", nil)
    20  	_, err := store.Get(req, "mycookiename")
    21  	if err != nil {
    22  		t.Errorf("failed to create session from empty request: %v", err)
    23  	}
    24  }
    25  
    26  func TestMemStore_Get_Bogus(t *testing.T) {
    27  	store := NewMemStore(
    28  		&GcOptions{ScanLimit: 2},
    29  		[]byte("authkey"),
    30  		[]byte("enckey1234567890"),
    31  	)
    32  
    33  	req := httptest.NewRequest("GET", "http://test.local", nil)
    34  	req.AddCookie(sessions.NewCookie("mycookiename", "SomeBogusValueThatIsActuallyNotEncrypted", store.Options))
    35  	_, err := store.Get(req, "mycookiename")
    36  	if err == nil {
    37  		t.Error(`store.Get(req, "mycookiename") should have returned error if cookie value is bogus`)
    38  	}
    39  }
    40  
    41  func TestMemStore_New(t *testing.T) {
    42  	store := NewMemStore(
    43  		&GcOptions{ScanLimit: 2},
    44  		[]byte("authkey"),
    45  		[]byte("enckey1234567890"),
    46  	)
    47  
    48  	req := httptest.NewRequest("GET", "http://test.local", nil)
    49  	_, err := store.New(req, "mycookiename")
    50  	if err != nil {
    51  		t.Errorf("failed to create session from empty request: %v", err)
    52  	}
    53  }
    54  
    55  func TestMemStore_Save(t *testing.T) {
    56  	store := NewMemStore(
    57  		&GcOptions{ScanLimit: 2},
    58  		[]byte("authkey"),
    59  		[]byte("enckey1234567890"),
    60  	)
    61  
    62  	want := "value123"
    63  	req := httptest.NewRequest("GET", "http://test.local", nil)
    64  	rec := httptest.NewRecorder()
    65  	session, err := store.Get(req, "mycookiename")
    66  	if err != nil {
    67  		t.Fatalf("failed to create session from empty request: %v", err)
    68  	}
    69  	session.Values["key"] = want
    70  	session.Save(req, rec)
    71  
    72  	cookie := rec.Header().Get("Set-Cookie")
    73  	if !strings.Contains(cookie, "mycookiename") {
    74  		t.Error("cookie was not stored in request")
    75  	}
    76  }
    77  
    78  func TestMemStore_Save_Multiple_Requests(t *testing.T) {
    79  	store := NewMemStore(
    80  		&GcOptions{ScanLimit: 2},
    81  		[]byte("authkey"),
    82  		[]byte("enckey1234567890"),
    83  	)
    84  
    85  	want := "value123"
    86  
    87  	req1 := httptest.NewRequest("GET", "http://test.local", nil)
    88  	rec1 := httptest.NewRecorder()
    89  	session1, err := store.Get(req1, "mycookiename")
    90  	if err != nil {
    91  		t.Fatalf("failed to create session from empty request: %v", err)
    92  	}
    93  	session1.Values["key"] = want
    94  	session1.Save(req1, rec1)
    95  
    96  	req2 := httptest.NewRequest("GET", "http://test.local", nil)
    97  	// Simulate retaining cookie from previous response
    98  	req2.AddCookie(rec1.Result().Cookies()[0])
    99  	session2, err := store.Get(req2, "mycookiename")
   100  	if err != nil {
   101  		t.Fatalf("failed to create session from second request: %v", err)
   102  	}
   103  	got := session2.Values["key"]
   104  	if got != want {
   105  		t.Errorf(`session2.Values["key"] got = %q, want %q`, got, want)
   106  	}
   107  }
   108  
   109  func TestMemStore_Delete(t *testing.T) {
   110  	store := NewMemStore(
   111  		&GcOptions{ScanLimit: 2},
   112  		[]byte("authkey"),
   113  		[]byte("enckey1234567890"),
   114  	)
   115  
   116  	req := httptest.NewRequest("GET", "http://test.local", nil)
   117  	rec := httptest.NewRecorder()
   118  	session, err := store.Get(req, "mycookiename")
   119  	if err != nil {
   120  		t.Fatalf("failed to create session from empty request: %v", err)
   121  	}
   122  
   123  	// Save some value
   124  	session.Values["key"] = "somevalue"
   125  	session.Save(req, rec)
   126  
   127  	// And immediately delete it
   128  	session.Options.MaxAge = -1
   129  	session.Save(req, rec)
   130  
   131  	if session.Values["key"] == "somevalue" {
   132  		t.Error("cookie was not deleted from session after setting session.Options.MaxAge = -1 and saving")
   133  	}
   134  }
   135  
   136  func BenchmarkRace(b *testing.B) {
   137  	store := NewMemStore(
   138  		&GcOptions{ScanLimit: 2},
   139  		[]byte("authkey"),
   140  		[]byte("enckey1234567890"),
   141  	)
   142  
   143  	var wg sync.WaitGroup
   144  
   145  	s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   146  		defer wg.Done()
   147  
   148  		session, err := store.Get(r, "mycookiename")
   149  		if err != nil {
   150  			b.Fatalf("failed to create session from empty request: %v", err)
   151  		}
   152  		session.Values["key"] = "somevalue"
   153  		session.Save(r, w)
   154  
   155  		// And immediately delete it
   156  		session.Options.MaxAge = -1
   157  		session.Save(r, w)
   158  
   159  		_ = session.Values["key"]
   160  	}))
   161  	defer s.Close()
   162  
   163  	loops := 100
   164  	wg.Add(loops)
   165  	for i := 1; i <= loops; i++ {
   166  		go http.Get(s.URL)
   167  	}
   168  	wg.Wait()
   169  }