268 lines
5.1 KiB
Go
268 lines
5.1 KiB
Go
package store
|
|
|
|
import (
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/boltdb/bolt"
|
|
"github.com/gorilla/securecookie"
|
|
"github.com/gorilla/sessions"
|
|
)
|
|
|
|
func TestStore_Get(t *testing.T) {
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
defer db.Close()
|
|
|
|
req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
str, err := New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session, err := str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
if session.IsNew != true {
|
|
t.Errorf("session.IsNew should be true (actual: %+v)", session.IsNew)
|
|
}
|
|
}
|
|
|
|
func TestStore_New(t *testing.T) {
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
defer db.Close()
|
|
|
|
str, err := New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
encoded, err := securecookie.EncodeMulti("test", "1", str.codecs...)
|
|
|
|
req.AddCookie(sessions.NewCookie("test", encoded, &sessions.Options{
|
|
MaxAge: 1024,
|
|
}))
|
|
|
|
session, err := str.New(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
if session.IsNew != true {
|
|
t.Errorf("session.IsNew should be true (actual: %+v)", session.IsNew)
|
|
}
|
|
}
|
|
|
|
func TestStore_Save(t *testing.T) {
|
|
// When session.Options.MaxAge < 0
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
defer db.Close()
|
|
|
|
str, err := New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session, err := str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session.Options.MaxAge = -1
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
str.Save(req, w, session)
|
|
|
|
// When session.Options.MaxAge >= 0
|
|
session, err = str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session.Options.MaxAge = 1
|
|
|
|
w = httptest.NewRecorder()
|
|
|
|
str.Save(req, w, session)
|
|
|
|
// When session.Options.MaxAge >= 0 and
|
|
// s.save returns an error
|
|
session.Values = make(map[interface{}]interface{})
|
|
session.Values[make(chan int)] = make(chan int)
|
|
str.Save(req, w, session)
|
|
|
|
// When session.Options.MaxAge >= 0 and
|
|
// securecookie.EncodeMulti returns an error
|
|
session.Values = make(map[interface{}]interface{})
|
|
str.codecs = nil
|
|
str.Save(req, w, session)
|
|
}
|
|
|
|
func TestStore_load(t *testing.T) {
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
defer db.Close()
|
|
|
|
str, err := New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session, err := str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
str.Save(req, w, session)
|
|
|
|
exists, err := str.load(session)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
if exists != true {
|
|
t.Error("Store.load should return true (actual: false)")
|
|
}
|
|
|
|
// When the target session data is nil
|
|
session.ID = "x"
|
|
exists, err = str.load(session)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
if exists != false {
|
|
t.Error("Store.load should return false (actual: true)")
|
|
}
|
|
|
|
// When shared.Session returns an error
|
|
err = db.Update(func(tx *bolt.Tx) error {
|
|
return tx.Bucket(str.config.DBOptions.BucketName).Put([]byte("x"), []byte("test"))
|
|
})
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
_, err = str.load(session)
|
|
if err == nil || err.Error() != "proto: field/encoding mismatch: wrong type for field" {
|
|
t.Error(`str.load should return an error "%s" (actual: %s)`, "proto: field/encoding mismatch: wrong type for field", err)
|
|
}
|
|
|
|
// When the target session data is expired
|
|
session, err = str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
session.Options.MaxAge = 0
|
|
str.Save(req, w, session)
|
|
time.Sleep(time.Second)
|
|
_, err = str.load(session)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
}
|
|
|
|
func TestSession_delete(t *testing.T) {
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
defer db.Close()
|
|
|
|
str, err := New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
session, err := str.Get(req, "test")
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
|
|
db.Close()
|
|
|
|
err = str.delete(session)
|
|
|
|
if err.Error() != "database not open" {
|
|
t.Error(`str.delete should return an error "%s" (actual: %s)`, "database not open", err)
|
|
}
|
|
}
|
|
|
|
func TestNew(t *testing.T) {
|
|
// When db.Update returns an error
|
|
db, err := bolt.Open("./sessions.db", 0666)
|
|
if err != nil {
|
|
t.Error(err.Error())
|
|
}
|
|
db.Close()
|
|
|
|
_, err = New(
|
|
db,
|
|
Config{},
|
|
[]byte("secret-key"),
|
|
)
|
|
if err.Error() != "database not open" {
|
|
t.Error(`str.delete should return an error "%s" (actual: %s)`, "database not open", err)
|
|
}
|
|
}
|