sessiongate_test.go

package sessiongate

import (
	"crypto/rand"
	"errors"
	"reflect"
	"regexp"
	"testing"
	"time"
)

var signKey []byte

func init() {
	signKey = make([]byte, 16)
	rand.Read(signKey)
}

// TestInitializer tests the Sessiongate initializer.
func TestInitializer(t *testing.T) {
	t.Run("Should fail with missing SignKey", func(t *testing.T) {
		config := &Config{}

		_, err := NewSessiongate(config)
		if err == nil {
			t.Fail()
		}
	})
}

// TestStart tests the START command for the SessionGate module.
func TestStart(t *testing.T) {
	t.Run("Should fail with negative TTL", func(t *testing.T) {
		config := &Config{
			SignKey: signKey,
		}

		sessiongate, err := NewSessiongate(config)
		if err != nil {
			t.Error(err)
		}

		_, err = sessiongate.Start(-1)
		if err == nil {
			t.Error(errors.New("Negative TTL should produce an error"))
		}
	})

	// checkStart checks if the START command does not produce an error and if
	// token is in the expected format
	checkStart := func(config *Config) {
		sessiongate, err := NewSessiongate(config)
		if err != nil {
			t.Error(err)
		}

		token, err := sessiongate.Start(300)
		if err != nil {
			t.Error(err)
		}

		regex := "^v[0-9]\\.[a-zA-Z0-9]+\\.[a-zA-Z0-9]+$"
		match, err := regexp.MatchString(regex, string(token))
		if err != nil {
			t.Error(err)
		}

		if match == false {
			err = errors.New("The response token does not match the expected format")
			t.Error(err)
		}
	}

	t.Run("Should succeed with default configuration", func(t *testing.T) {
		checkStart(&Config{
			SignKey: signKey,
		})
	})

	t.Run("Should succeed with explicit Addr", func(t *testing.T) {
		checkStart(&Config{
			SignKey: signKey,
			Addr:    "localhost:6379",
		})
	})

	t.Run("Should succeed with explicit MaxIdle", func(t *testing.T) {
		checkStart(&Config{
			SignKey: signKey,
			MaxIdle: 15,
		})
	})

	t.Run("Should succeed with explicit IdleTimeout", func(t *testing.T) {
		checkStart(&Config{
			SignKey:     signKey,
			IdleTimeout: 90 * time.Second,
		})
	})
}

func createSession() (*Sessiongate, []byte, error) {
	config := &Config{
		SignKey: signKey,
	}

	sessiongate, err := NewSessiongate(config)
	if err != nil {
		return nil, nil, err
	}

	token, err := sessiongate.Start(300)
	if err != nil {
		return nil, nil, err
	}

	return sessiongate, token, nil
}

// TestExpire tests the EXPIRE command for the SessionGate module.
func TestExpire(t *testing.T) {
	sessiongate, token, err := createSession()
	if err != nil {
		t.Error(err)
	}

	t.Run("Should fail with negative TTL", func(t *testing.T) {
		err := sessiongate.Expire(token, -5)
		if err == nil {
			t.Error(errors.New("Negative TTL should produce an error"))
		}
	})

	t.Run("Should succeed with positive TTL", func(t *testing.T) {
		err := sessiongate.Expire(token, 500)
		if err != nil {
			t.Error(err)
		}
	})
}

// TestPSet tests the PSET command for the SessionGate module.
func TestPSet(t *testing.T) {
	sessiongate, token, err := createSession()
	if err != nil {
		t.Error(err)
	}

	t.Run("Should fail with an empty name", func(t *testing.T) {
		name := []byte("")
		payload := []byte("{}")
		err := sessiongate.PSet(token, name, payload)
		if err == nil {
			t.Error(errors.New("Empty name should produce an error"))
		}
	})

	t.Run("Should fail with an empty payload", func(t *testing.T) {
		name := []byte("user")
		payload := []byte("")
		err := sessiongate.PSet(token, name, payload)
		if err == nil {
			t.Error(errors.New("Empty payload should produce an error"))
		}
	})

	t.Run("Should succeed with a JSON string as a payload", func(t *testing.T) {
		name := []byte("user")
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}
	})

	t.Run("Should succeed with arbitrary bytes in the name", func(t *testing.T) {
		name := make([]byte, 8)
		rand.Read(name)
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}
	})

	t.Run("Should succeed with arbitrary bytes in the payload", func(t *testing.T) {
		name := []byte("user")
		payload := make([]byte, 128)
		rand.Read(payload)
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}
	})
}

// TestPGet tests the PGET command for the SessionGate module.
func TestPGet(t *testing.T) {
	sessiongate, token, err := createSession()
	if err != nil {
		t.Error(err)
	}

	t.Run("Should fail with an empty name", func(t *testing.T) {
		name := []byte("")
		_, err := sessiongate.PGet(token, name)
		if err == nil {
			t.Error(errors.New("Empty name should produce an error"))
		}
	})

	t.Run("Should fail for a name not set", func(t *testing.T) {
		name := []byte("user")
		_, err := sessiongate.PGet(token, name)
		if err == nil {
			t.Error(errors.New("Name not set should produce an error"))
		}
	})

	t.Run("Should fail for expired sessions", func(t *testing.T) {
		sessiongate2, token2, err := createSession()
		if err != nil {
			t.Error(err)
		}

		name := []byte("user")
		payload := []byte("{\"name\":\"John Doe\"}")
		err = sessiongate2.PSet(token2, name, payload)
		if err != nil {
			t.Error(err)
		}

		_, err = sessiongate2.PGet(token2, name)
		if err != nil {
			t.Error(err)
		}

		err = sessiongate2.Expire(token2, 1)
		if err != nil {
			t.Error(err)
		}

		time.Sleep(time.Millisecond * 1050)

		_, err = sessiongate2.PGet(token2, name)
		if err == nil {
			t.Error(errors.New("Expired session should produce an error"))
		}
	})

	t.Run("Should succeed with a JSON string as a payload", func(t *testing.T) {
		name := []byte("user")
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}

		payloadPGet, err := sessiongate.PGet(token, name)
		if err != nil {
			t.Error(err)
		}

		if reflect.DeepEqual(payload, payloadPGet) == false {
			t.Error(errors.New("The payloads should be equal"))
		}
	})

	t.Run("Should succeed with arbitrary bytes in the payload", func(t *testing.T) {
		name := []byte("user")
		payload := make([]byte, 128)
		rand.Read(payload)
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}

		payloadPGet, err := sessiongate.PGet(token, name)
		if err != nil {
			t.Error(err)
		}

		if reflect.DeepEqual(payload, payloadPGet) == false {
			t.Error(errors.New("The payloads should be equal"))
		}
	})

	t.Run("Should succeed with arbitrary bytes in the name", func(t *testing.T) {
		name := make([]byte, 8)
		rand.Read(name)
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}

		payloadPGet, err := sessiongate.PGet(token, name)
		if err != nil {
			t.Error(err)
		}

		if reflect.DeepEqual(payload, payloadPGet) == false {
			t.Error(errors.New("The payloads should be equal"))
		}
	})
}

// TestPDel tests the PDEL command for the SessionGate module.
func TestPDel(t *testing.T) {
	sessiongate, token, err := createSession()
	if err != nil {
		t.Error(err)
	}

	t.Run("Should fail with an empty name", func(t *testing.T) {
		name := []byte("")
		err := sessiongate.PDel(token, name)
		if err == nil {
			t.Error(errors.New("Empty name should produce an error"))
		}
	})

	t.Run("Should fail for a name not set", func(t *testing.T) {
		name := []byte("user")
		err := sessiongate.PDel(token, name)
		if err == nil {
			t.Error(errors.New("Name not set should produce an error"))
		}
	})

	t.Run("Should fail for expired sessions", func(t *testing.T) {
		sessiongate2, token2, err := createSession()
		if err != nil {
			t.Error(err)
		}

		name := []byte("user")
		payload := []byte("{\"name\":\"John Doe\"}")
		err = sessiongate2.PSet(token2, name, payload)
		if err != nil {
			t.Error(err)
		}

		_, err = sessiongate2.PGet(token2, name)
		if err != nil {
			t.Error(err)
		}

		err = sessiongate2.Expire(token2, 1)
		if err != nil {
			t.Error(err)
		}

		time.Sleep(time.Millisecond * 1050)

		err = sessiongate2.PDel(token2, name)
		if err == nil {
			t.Error(errors.New("Expired session should produce an error"))
		}
	})

	t.Run("Should succeed with a UTF-8 name", func(t *testing.T) {
		name := []byte("user")
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}

		err = sessiongate.PDel(token, name)
		if err != nil {
			t.Error(err)
		}
	})

	t.Run("Should succeed with arbitrary bytes in the name", func(t *testing.T) {
		name := make([]byte, 8)
		rand.Read(name)
		payload := []byte("{\"name\":\"John Doe\"}")
		err := sessiongate.PSet(token, name, payload)
		if err != nil {
			t.Error(err)
		}

		err = sessiongate.PDel(token, name)
		if err != nil {
			t.Error(err)
		}
	})
}

// TestEnd tests the END command for the SessionGate module.
func TestEnd(t *testing.T) {
	sessiongate, token, err := createSession()
	if err != nil {
		t.Error(err)
	}

	t.Run("Should fail with an empty token", func(t *testing.T) {
		err := sessiongate.End([]byte(""))
		if err == nil {
			t.Error(errors.New("Empty token should produce an error"))
		}
	})

	t.Run("Should fail for expired sessions", func(t *testing.T) {
		sessiongate2, token2, err := createSession()
		if err != nil {
			t.Error(err)
		}

		err = sessiongate2.Expire(token2, 1)
		if err != nil {
			t.Error(err)
		}

		time.Sleep(time.Millisecond * 1050)

		err = sessiongate2.End(token2)
		if err == nil {
			t.Error(errors.New("Expired session should produce an error"))
		}
	})

	t.Run("Should succeed", func(t *testing.T) {
		err := sessiongate.End(token)
		if err != nil {
			t.Error(err)
		}

		err = sessiongate.Expire(token, 1)
		if err == nil {
			t.Error(errors.New("Expired session should produce an error"))
		}
	})
}