diff --git a/manager.go b/manager.go
index e46cd51..93c9e73 100644
--- a/manager.go
+++ b/manager.go
@@ -32,8 +32,8 @@ type Manager struct {
 
 // Options are available options to configure Manager.
 type Options struct {
-	// DisableAutoSet skips creation of session cookie in frontend and new session in store if session is not already set.
-	DisableAutoSet bool
+	// If enabled, Acquire() will always create and return a new session if one doesn't already exist.
+	EnableAutoCreate bool
 
 	// CookieName sets http cookie name. This is also sent as cookie name in `GetCookie` callback.
 	CookieName string
@@ -94,6 +94,36 @@ func (m *Manager) RegisterSetCookie(cb func(*http.Cookie, interface{}) error) {
 	m.setCookieCb = cb
 }
 
+// NewSession creates a new session. Reads cookie info from `GetCookie“ callback
+// and validate the session with current store. If cookie not set then it creates
+// new session and calls `SetCookie“ callback. If `DisableAutoSet` is set then it
+// skips new session creation and should be manually done using `Create` method.
+// If a cookie is found but its invalid in store then `ErrInvalidSession` error is returned.
+func (m *Manager) NewSession(r, w interface{}) (*Session, error) {
+	var (
+		sess = &Session{
+			manager: m,
+			reader:  r,
+			writer:  w,
+			values:  make(map[string]interface{}),
+		}
+	)
+
+	// Create new cookie in store and write to front.
+	// Store also calls `WriteCookie`` to write to http interface.
+	id, err := m.store.Create()
+	if err != nil {
+		return nil, errAs(err)
+	}
+
+	// Write cookie.
+	if err := sess.WriteCookie(id); err != nil {
+		return nil, err
+	}
+
+	return sess, nil
+}
+
 // Acquire gets a `Session` for current session cookie from store.
 // If `Session` is not found on store then it creates a new session and sets on store.
 // If 'DisableAutoSet` is set in options then session has to be explicitly created before
@@ -124,5 +154,24 @@ func (m *Manager) Acquire(r, w interface{}, c context.Context) (*Session, error)
 		}
 	}
 
-	return NewSession(m, r, w)
+	// Get existing HTTP session cookie.
+	// If there's no error and there's a session ID (unvalidated at this point),
+	// return a session object.
+	ck, err := m.getCookieCb(m.opts.CookieName, r)
+	if err == nil && ck != nil && ck.Value != "" {
+		return &Session{
+			manager: m,
+			reader:  r,
+			writer:  w,
+			id:      ck.Value,
+			values:  make(map[string]interface{}),
+		}, nil
+	}
+
+	// If auto-creation is disabled, return an error.
+	if !m.opts.EnableAutoCreate {
+		return nil, ErrInvalidSession
+	}
+
+	return m.NewSession(r, w)
 }
diff --git a/manager_test.go b/manager_test.go
index 2ba4d7b..b949aa3 100644
--- a/manager_test.go
+++ b/manager_test.go
@@ -21,7 +21,7 @@ func TestNewManagerWithDefaultOptions(t *testing.T) {
 
 func TestManagerNewManagerWithOptions(t *testing.T) {
 	opts := Options{
-		DisableAutoSet:   true,
+		EnableAutoCreate: true,
 		CookieName:       "testcookiename",
 		CookieDomain:     "somedomain",
 		CookiePath:       "/abc/123",
@@ -36,7 +36,7 @@ func TestManagerNewManagerWithOptions(t *testing.T) {
 	assert := assert.New(t)
 
 	// Default cookie path is set to root
-	assert.Equal(m.opts.DisableAutoSet, opts.DisableAutoSet)
+	assert.Equal(m.opts.EnableAutoCreate, opts.EnableAutoCreate)
 	assert.Equal(m.opts.CookieName, opts.CookieName)
 	assert.Equal(m.opts.CookieDomain, opts.CookieDomain)
 	assert.Equal(m.opts.CookiePath, opts.CookiePath)
@@ -60,12 +60,12 @@ func TestManagerRegisterGetCookie(t *testing.T) {
 	assert := assert.New(t)
 	m := New(Options{})
 
-	testCookie := &http.Cookie{
+	ck := &http.Cookie{
 		Name: "testcookie",
 	}
 
 	cb := func(string, interface{}) (*http.Cookie, error) {
-		return testCookie, http.ErrNoCookie
+		return ck, http.ErrNoCookie
 	}
 
 	m.RegisterGetCookie(cb)
@@ -81,7 +81,7 @@ func TestManagerRegisterSetCookie(t *testing.T) {
 	assert := assert.New(t)
 	m := New(Options{})
 
-	testCookie := &http.Cookie{
+	ck := &http.Cookie{
 		Name: "testcookie",
 	}
 
@@ -91,15 +91,15 @@ func TestManagerRegisterSetCookie(t *testing.T) {
 
 	m.RegisterSetCookie(cb)
 
-	expectCbErr := cb(testCookie, nil)
-	actualCbErr := m.setCookieCb(testCookie, nil)
+	expectCbErr := cb(ck, nil)
+	actualCbErr := m.setCookieCb(ck, nil)
 
 	assert.Equal(expectCbErr, actualCbErr)
 }
 
 func TestManagerAcquireFails(t *testing.T) {
 	assert := assert.New(t)
-	m := New(Options{})
+	m := New(Options{EnableAutoCreate: false})
 
 	_, err := m.Acquire(nil, nil, nil)
 	assert.Error(err, "session store is not set")
@@ -108,32 +108,60 @@ func TestManagerAcquireFails(t *testing.T) {
 	_, err = m.Acquire(nil, nil, nil)
 	assert.Error(err, "callback `GetCookie` not set")
 
-	getCb := func(string, interface{}) (*http.Cookie, error) {
+	m.RegisterGetCookie(func(string, interface{}) (*http.Cookie, error) {
 		return nil, nil
-	}
-	m.RegisterGetCookie(getCb)
+	})
+
 	_, err = m.Acquire(nil, nil, nil)
 	assert.Error(err, "callback `SetCookie` not set")
+
+	m.RegisterSetCookie(func(*http.Cookie, interface{}) error {
+		return nil
+	})
+	_, err = m.Acquire(nil, nil, nil)
+	assert.ErrorIs(err, ErrInvalidSession)
 }
 
-func TestManagerAcquireSucceeds(t *testing.T) {
-	m := New(Options{})
+func TestManagerAcquireNoAutocreate(t *testing.T) {
+	m := New(Options{EnableAutoCreate: false})
 	m.UseStore(&MockStore{
 		isValid: true,
+		id:      "somerandomid",
 	})
 
-	getCb := func(string, interface{}) (*http.Cookie, error) {
+	m.RegisterGetCookie(func(string, interface{}) (*http.Cookie, error) {
+		return &http.Cookie{
+			Name:  "testcookie",
+			Value: "somerandomid",
+		}, nil
+	})
+
+	m.RegisterSetCookie(func(*http.Cookie, interface{}) error {
+		return nil
+	})
+
+	_, err := m.Acquire(nil, nil, nil)
+	assert := assert.New(t)
+	assert.NoError(err)
+}
+
+func TestManagerAcquireAutocreate(t *testing.T) {
+	m := New(Options{EnableAutoCreate: true})
+	m.UseStore(&MockStore{
+		isValid: true,
+		id:      "somerandomid",
+	})
+
+	m.RegisterGetCookie(func(string, interface{}) (*http.Cookie, error) {
 		return &http.Cookie{
 			Name:  "testcookie",
 			Value: "",
 		}, nil
-	}
-	m.RegisterGetCookie(getCb)
+	})
 
-	setCb := func(*http.Cookie, interface{}) error {
-		return http.ErrNoCookie
-	}
-	m.RegisterSetCookie(setCb)
+	m.RegisterSetCookie(func(*http.Cookie, interface{}) error {
+		return nil
+	})
 
 	_, err := m.Acquire(nil, nil, nil)
 	assert := assert.New(t)
@@ -142,9 +170,10 @@ func TestManagerAcquireSucceeds(t *testing.T) {
 
 func TestManagerAcquireFromContext(t *testing.T) {
 	assert := assert.New(t)
-	m := New(Options{})
+	m := New(Options{EnableAutoCreate: true})
 	m.UseStore(&MockStore{
 		isValid: true,
+		id:      "somerandomid",
 	})
 
 	getCb := func(string, interface{}) (*http.Cookie, error) {
@@ -156,20 +185,20 @@ func TestManagerAcquireFromContext(t *testing.T) {
 	m.RegisterGetCookie(getCb)
 
 	setCb := func(*http.Cookie, interface{}) error {
-		return http.ErrNoCookie
+		return nil
 	}
 	m.RegisterSetCookie(setCb)
 
 	sess, err := m.Acquire(nil, nil, nil)
 	assert.NoError(err)
-	sess.cookie.Value = "updated"
+	sess.id = "updated"
 
 	sessNew, err := m.Acquire(nil, nil, nil)
 	assert.NoError(err)
-	assert.NotEqual(sessNew.cookie.Value, sess.cookie.Value)
+	assert.NotEqual(sessNew.id, sess.id)
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, ContextName, sess)
 	sessNext, err := m.Acquire(nil, nil, ctx)
-	assert.Equal(sessNext.cookie.Value, sess.cookie.Value)
+	assert.Equal(sessNext.id, sess.id)
 }
diff --git a/session.go b/session.go
index e34d742..efb5b24 100644
--- a/session.go
+++ b/session.go
@@ -15,18 +15,13 @@ type Session struct {
 	// Session manager.
 	manager *Manager
 
-	// Current http cookie. This is passed down to `SetCookie` callback.
-	cookie *http.Cookie
+	// Session ID.
+	id string
 
 	// HTTP reader and writer interfaces which are passed on to
 	// `GetCookie`` and `SetCookie`` callback respectively.
 	reader interface{}
 	writer interface{}
-
-	// Track if session is set in store or not
-	// used to throw and error is autoSet is not enabled and user
-	// explicitly didn't create new session in store.
-	isSet bool
 }
 
 var (
@@ -52,60 +47,10 @@ type errCode interface {
 	Code() int
 }
 
-// NewSession creates a new session. Reads cookie info from `GetCookie“ callback
-// and validate the session with current store. If cookie not set then it creates
-// new session and calls `SetCookie“ callback. If `DisableAutoSet` is set then it
-// skips new session creation and should be manually done using `Create` method.
-// If a cookie is found but its invalid in store then `ErrInvalidSession` error is returned.
-func NewSession(m *Manager, r, w interface{}) (*Session, error) {
-	var (
-		err  error
-		sess = &Session{
-			manager: m,
-			reader:  r,
-			writer:  w,
-			values:  make(map[string]interface{}),
-		}
-	)
-
-	// Get existing http session cookie
-	sess.cookie, err = m.getCookieCb(m.opts.CookieName, r)
-
-	// Create new session
-	if err == http.ErrNoCookie {
-		// Skip creating new cookie in store. User has to manually create before doing Get or Set.
-		if m.opts.DisableAutoSet {
-			return sess, nil
-		}
-
-		// Create new cookie in store and write to front
-		// Store also calls `WriteCookie`` to write to http interface
-		cv, err := m.store.Create()
-		if err != nil {
-			return nil, errAs(err)
-		}
-
-		// Write cookie
-		if err := sess.WriteCookie(cv); err != nil {
-			return nil, err
-		}
-
-		// Set isSet flag
-		sess.isSet = true
-	} else if err != nil {
-		return nil, err
-	}
-
-	// Set isSet flag
-	sess.isSet = true
-
-	return sess, nil
-}
-
 // WriteCookie updates the cookie and calls `SetCookie` callback.
 // This method can also be used by store to update cookie whenever the cookie value changes.
 func (s *Session) WriteCookie(cv string) error {
-	s.cookie = &http.Cookie{
+	ck := &http.Cookie{
 		Value:    cv,
 		Name:     s.manager.opts.CookieName,
 		Domain:   s.manager.opts.CookieDomain,
@@ -115,18 +60,13 @@ func (s *Session) WriteCookie(cv string) error {
 		SameSite: s.manager.opts.SameSite,
 	}
 
-	// Set cookie expiry
-	if s.manager.opts.CookieLifetime != 0 {
-		s.cookie.Expires = time.Now().Add(s.manager.opts.CookieLifetime)
-	}
-
 	// Call `SetCookie` callback to write cookie to response
-	return s.manager.setCookieCb(s.cookie, s.writer)
+	return s.manager.setCookieCb(ck, s.writer)
 }
 
 // clearCookie sets expiry of the cookie to one day before to clear it.
 func (s *Session) clearCookie() error {
-	s.cookie = &http.Cookie{
+	ck := &http.Cookie{
 		Name:  s.manager.opts.CookieName,
 		Value: "",
 		// Set expiry to previous date to clear it from browser
@@ -134,7 +74,7 @@ func (s *Session) clearCookie() error {
 	}
 
 	// Call `SetCookie` callback to write cookie to response
-	return s.manager.setCookieCb(s.cookie, s.writer)
+	return s.manager.setCookieCb(ck, s.writer)
 }
 
 // Create a new session. This is implicit when option `DisableAutoSet` is false
@@ -151,18 +91,12 @@ func (s *Session) Create() error {
 		return err
 	}
 
-	// Set isSet flag
-	s.isSet = true
-
 	return nil
 }
 
 // ID returns the acquired session ID. If cookie is not set then empty string is returned.
 func (s *Session) ID() string {
-	if s.cookie != nil {
-		return s.cookie.Value
-	}
-	return ""
+	return s.id
 }
 
 // LoadValues loads the session values in memory.
@@ -181,27 +115,17 @@ func (s *Session) ResetValues() {
 
 // GetAll gets all the fields in the session.
 func (s *Session) GetAll() (map[string]interface{}, error) {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return nil, ErrInvalidSession
-	}
-
 	// Load value from map if its already loaded
 	if len(s.values) > 0 {
 		return s.values, nil
 	}
 
-	out, err := s.manager.store.GetAll(s.cookie.Value)
+	out, err := s.manager.store.GetAll(s.id)
 	return out, errAs(err)
 }
 
 // GetMulti gets a map of values for multiple session keys.
 func (s *Session) GetMulti(keys ...string) (map[string]interface{}, error) {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return nil, ErrInvalidSession
-	}
-
 	// Load values from map if its already loaded
 	if len(s.values) > 0 {
 		vals := make(map[string]interface{})
@@ -214,7 +138,7 @@ func (s *Session) GetMulti(keys ...string) (map[string]interface{}, error) {
 		return vals, nil
 	}
 
-	out, err := s.manager.store.GetMulti(s.cookie.Value, keys...)
+	out, err := s.manager.store.GetMulti(s.id, keys...)
 	return out, errAs(err)
 }
 
@@ -222,11 +146,6 @@ func (s *Session) GetMulti(keys ...string) (map[string]interface{}, error) {
 // If session is already loaded using `Load` then returns values from
 // existing map instead of getting it from store.
 func (s *Session) Get(key string) (interface{}, error) {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return nil, ErrInvalidSession
-	}
-
 	// Load value from map if its already loaded
 	if len(s.values) > 0 {
 		if val, ok := s.values[key]; ok {
@@ -235,19 +154,14 @@ func (s *Session) Get(key string) (interface{}, error) {
 	}
 
 	// Get from backend if not found in previous step
-	out, err := s.manager.store.Get(s.cookie.Value, key)
+	out, err := s.manager.store.Get(s.id, key)
 	return out, errAs(err)
 }
 
 // Set sets a value for given key in session. Its up to store to commit
 // all previously set values at once or store it on each set.
 func (s *Session) Set(key string, val interface{}) error {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return ErrInvalidSession
-	}
-
-	err := s.manager.store.Set(s.cookie.Value, key, val)
+	err := s.manager.store.Set(s.id, key, val)
 	return errAs(err)
 }
 
@@ -255,13 +169,8 @@ func (s *Session) Set(key string, val interface{}) error {
 // Its up to store to commit all previously
 // set values at once or store it on each set.
 func (s *Session) SetMulti(values map[string]interface{}) error {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return ErrInvalidSession
-	}
-
 	for k, v := range values {
-		if err := s.manager.store.Set(s.cookie.Value, k, v); err != nil {
+		if err := s.manager.store.Set(s.id, k, v); err != nil {
 			return errAs(err)
 		}
 	}
@@ -272,12 +181,7 @@ func (s *Session) SetMulti(values map[string]interface{}) error {
 // Commit commits all set to store. Its up to store to commit
 // all previously set values at once or store it on each set.
 func (s *Session) Commit() error {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return ErrInvalidSession
-	}
-
-	if err := s.manager.store.Commit(s.cookie.Value); err != nil {
+	if err := s.manager.store.Commit(s.id); err != nil {
 		return errAs(err)
 	}
 
@@ -286,12 +190,7 @@ func (s *Session) Commit() error {
 
 // Delete deletes a field from session.
 func (s *Session) Delete(key string) error {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return ErrInvalidSession
-	}
-
-	if err := s.manager.store.Delete(s.cookie.Value, key); err != nil {
+	if err := s.manager.store.Delete(s.id, key); err != nil {
 		return errAs(err)
 	}
 
@@ -300,12 +199,7 @@ func (s *Session) Delete(key string) error {
 
 // Clear clears session data from store and clears the cookie
 func (s *Session) Clear() error {
-	// Check if session is set before accessing it
-	if !s.isSet {
-		return ErrInvalidSession
-	}
-
-	if err := s.manager.store.Clear(s.cookie.Value); err != nil {
+	if err := s.manager.store.Clear(s.id); err != nil {
 		return errAs(err)
 	}
 
diff --git a/session_test.go b/session_test.go
index 6a130f1..ccd13ea 100644
--- a/session_test.go
+++ b/session_test.go
@@ -90,16 +90,13 @@ func TestSessionNewSession(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, reader, writer)
+	sess, err := mockManager.NewSession(reader, writer)
 	assert.NoError(err)
 	assert.Equal(sess.manager, mockManager)
 	assert.Equal(sess.reader, reader)
 	assert.Equal(sess.writer, writer)
 	assert.NotNil(sess.values)
-	assert.NotNil(sess.cookie)
-	assert.Equal(sess.cookie.Name, defaultCookieName)
-	assert.Equal(sess.cookie.Value, testCookieValue)
-	assert.True(sess.isSet)
+	assert.Equal(sess.id, testCookieValue)
 }
 
 func TestSessionNewSessionErrorStoreCreate(t *testing.T) {
@@ -109,14 +106,14 @@ func TestSessionNewSessionErrorStoreCreate(t *testing.T) {
 
 	testError := errors.New("this is test error")
 	newCookieVal := "somerandomid"
-	mockStore.val = newCookieVal
+	mockStore.id = newCookieVal
 	mockStore.err = testError
 	mockManager := newMockManager(mockStore)
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.Error(err, testError.Error())
 	assert.Nil(sess)
 }
@@ -128,7 +125,7 @@ func TestSessionNewSessionErrorWriteCookie(t *testing.T) {
 
 	testError := errors.New("this is test error")
 	newCookieVal := "somerandomid"
-	mockStore.val = newCookieVal
+	mockStore.id = newCookieVal
 	mockManager := newMockManager(mockStore)
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
@@ -137,7 +134,7 @@ func TestSessionNewSessionErrorWriteCookie(t *testing.T) {
 		return testError
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.Error(err, testError.Error())
 	assert.Nil(sess)
 }
@@ -151,7 +148,7 @@ func TestSessionNewSessionInvalidGetCookie(t *testing.T) {
 		return nil, testError
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.Error(err, testError.Error())
 	assert.Nil(sess)
 }
@@ -161,32 +158,31 @@ func TestSessionNewSessionCreateNewCookie(t *testing.T) {
 	mockStore := newMockStore()
 
 	newCookieVal := "somerandomid"
-	mockStore.val = newCookieVal
+	mockStore.id = newCookieVal
 	mockStore.isValid = true
 	mockManager := newMockManager(mockStore)
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
-	assert.True(sess.isSet)
-	assert.Equal(sess.cookie.Value, newCookieVal)
+
+	assert.Equal(sess.id, newCookieVal)
 }
 
-func TestSessionNewSessionWithDisableAutoSet(t *testing.T) {
+func TestSessionNewSessionWithDisableAuto(t *testing.T) {
 	assert := assert.New(t)
 	mockStore := newMockStore()
 
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	_, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
-	assert.False(sess.isSet)
 }
 
 func TestSessionNewSessionGetCookieCb(t *testing.T) {
@@ -195,7 +191,7 @@ func TestSessionNewSessionGetCookieCb(t *testing.T) {
 
 	// Calls write cookie callback if cookie is not set already
 	newCookieVal := "somerandomid"
-	mockStore.val = newCookieVal
+	mockStore.id = newCookieVal
 	mockStore.isValid = true
 	mockManager := newMockManager(mockStore)
 
@@ -210,9 +206,9 @@ func TestSessionNewSessionGetCookieCb(t *testing.T) {
 	})
 
 	var reader = "this is reader interface"
-	sess, err := NewSession(mockManager, reader, nil)
+	_, err := mockManager.NewSession(reader, nil)
 	assert.NoError(err)
-	assert.True(sess.isSet)
+
 	assert.True(isCallbackTriggered)
 	assert.Equal(receivedName, mockManager.opts.CookieName)
 	assert.Equal(receivedReader, reader)
@@ -224,7 +220,7 @@ func TestSessionNewSessionSetCookieCb(t *testing.T) {
 
 	// Calls write cookie callback if cookie is not set already
 	newCookieVal := "somerandomid"
-	mockStore.val = newCookieVal
+	mockStore.id = newCookieVal
 	mockStore.isValid = true
 	mockManager := newMockManager(mockStore)
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
@@ -242,9 +238,9 @@ func TestSessionNewSessionSetCookieCb(t *testing.T) {
 	})
 
 	var writer = "this is writer interface"
-	sess, err := NewSession(mockManager, nil, writer)
+	_, err := mockManager.NewSession(nil, writer)
 	assert.NoError(err)
-	assert.True(sess.isSet)
+
 	assert.True(isCallbackTriggered)
 	assert.Equal(receivedCookie.Value, newCookieVal)
 	assert.Equal(receivedWriter, writer)
@@ -261,27 +257,20 @@ func TestSessionWriteCookie(t *testing.T) {
 		CookieLifetime:   time.Second * 1000,
 		IsHTTPOnlyCookie: true,
 		IsSecureCookie:   true,
-		DisableAutoSet:   true,
+		EnableAutoCreate: false,
 		SameSite:         http.SameSiteDefaultMode,
 	}
 	mockStore.isValid = true
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
-	sess.WriteCookie("testvalue")
-	assert.Equal(sess.cookie.Name, mockManager.opts.CookieName)
-	assert.Equal(sess.cookie.Value, "testvalue")
-	assert.Equal(sess.cookie.Domain, mockManager.opts.CookieDomain)
-	assert.Equal(sess.cookie.Path, mockManager.opts.CookiePath)
-	assert.Equal(sess.cookie.Secure, mockManager.opts.IsSecureCookie)
-	assert.Equal(sess.cookie.SameSite, mockManager.opts.SameSite)
-	assert.Equal(sess.cookie.HttpOnly, mockManager.opts.IsHTTPOnlyCookie)
+	assert.NoError(sess.WriteCookie("testvalue"))
 
 	// Ignore seconds
-	expiry := time.Now().Add(mockManager.opts.CookieLifetime)
-	assert.Equal(sess.cookie.Expires.Format("2006-01-02 15:04:05"), expiry.Format("2006-01-02 15:04:05"))
-	assert.WithinDuration(expiry, sess.cookie.Expires, time.Millisecond*1000)
+	// expiry := time.Now().Add(mockManager.opts.CookieLifetime)
+	// assert.Equal(sess.id.Expires.Format("2006-01-02 15:04:05"), expiry.Format("2006-01-02 15:04:05"))
+	// assert.WithinDuration(expiry, sess.id.Expires, time.Millisecond*1000)
 }
 
 func TestSessionClearCookie(t *testing.T) {
@@ -298,7 +287,7 @@ func TestSessionClearCookie(t *testing.T) {
 		return nil
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.clearCookie()
@@ -315,7 +304,7 @@ func TestSessionCreate(t *testing.T) {
 	mockStore.isValid = true
 	mockStore.val = "test"
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
@@ -326,15 +315,14 @@ func TestSessionCreate(t *testing.T) {
 		return nil
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
-	assert.False(sess.isSet)
 	assert.False(isCallbackTriggered)
 
 	err = sess.Create()
 	assert.NoError(err)
 	assert.True(isCallbackTriggered)
-	assert.True(sess.isSet)
+
 }
 
 func TestSessionLoadValues(t *testing.T) {
@@ -344,7 +332,7 @@ func TestSessionLoadValues(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.LoadValues()
@@ -360,7 +348,7 @@ func TestSessionResetValues(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.LoadValues()
@@ -379,7 +367,7 @@ func TestSessionGetAllFromStore(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	vals, err := sess.GetAll()
@@ -394,7 +382,7 @@ func TestSessionGetAllLoadedValues(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	setVals := make(map[string]interface{})
@@ -410,13 +398,13 @@ func TestSessionGetAllLoadedValues(t *testing.T) {
 func TestSessionGetAllInvalidSession(t *testing.T) {
 	mockStore := newMockStore()
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	vals, err := sess.GetAll()
@@ -431,7 +419,7 @@ func TestSessionGetMultiFromStore(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	vals, err := sess.GetMulti("val")
@@ -446,7 +434,7 @@ func TestSessionGetMultiLoadedValues(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	setVals := make(map[string]interface{})
@@ -464,13 +452,13 @@ func TestSessionGetMultiLoadedValues(t *testing.T) {
 func TestSessionGetMultiInvalidSession(t *testing.T) {
 	mockStore := newMockStore()
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	vals, err := sess.GetMulti("val")
@@ -485,7 +473,7 @@ func TestSessionGetFromStore(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	val, err := sess.Get("val")
@@ -499,7 +487,7 @@ func TestSessionGetLoadedValues(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	setVals := make(map[string]interface{})
@@ -515,13 +503,13 @@ func TestSessionGetLoadedValues(t *testing.T) {
 func TestSessionGetInvalidSession(t *testing.T) {
 	mockStore := newMockStore()
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	vals, err := sess.Get("val")
@@ -535,7 +523,7 @@ func TestSessionSet(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.Set("key", 100)
@@ -546,13 +534,13 @@ func TestSessionSet(t *testing.T) {
 func TestSessionSetInvalidSession(t *testing.T) {
 	mockStore := newMockStore()
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.Set("key", 100)
@@ -565,7 +553,7 @@ func TestSessionCommit(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.Set("key", 100)
@@ -580,13 +568,13 @@ func TestSessionCommit(t *testing.T) {
 func TestSessionCommitInvalidSession(t *testing.T) {
 	mockStore := newMockStore()
 	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
+	mockManager.opts.EnableAutoCreate = true
 	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
 		return nil, http.ErrNoCookie
 	})
 
 	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	err = sess.Commit()
@@ -600,7 +588,7 @@ func TestSessionDelete(t *testing.T) {
 	mockStore.isValid = true
 	mockStore.val = 100
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 	assert.Equal(mockStore.val, 100)
 
@@ -627,7 +615,7 @@ func TestSessionClear(t *testing.T) {
 		return nil
 	})
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 	assert.Equal(mockStore.val, 100)
 
@@ -644,7 +632,7 @@ func TestSessionClearError(t *testing.T) {
 	mockManager := newMockManager(mockStore)
 	mockStore.isValid = true
 
-	sess, err := NewSession(mockManager, nil, nil)
+	sess, err := mockManager.NewSession(nil, nil)
 	assert.NoError(err)
 
 	testError := errors.New("this is test error")
@@ -653,22 +641,6 @@ func TestSessionClearError(t *testing.T) {
 	assert.Error(err, testError.Error())
 }
 
-func TestSessionClearInvalidSession(t *testing.T) {
-	mockStore := newMockStore()
-	mockManager := newMockManager(mockStore)
-	mockManager.opts.DisableAutoSet = true
-	mockManager.RegisterGetCookie(func(name string, r interface{}) (*http.Cookie, error) {
-		return nil, http.ErrNoCookie
-	})
-
-	assert := assert.New(t)
-	sess, err := NewSession(mockManager, nil, nil)
-	assert.NoError(err)
-
-	err = sess.Clear()
-	assert.Error(err, ErrInvalidSession.Error())
-}
-
 type Err struct {
 	code int
 	msg  string
diff --git a/store_test.go b/store_test.go
index 4eba6fe..99ec0ee 100644
--- a/store_test.go
+++ b/store_test.go
@@ -5,6 +5,7 @@ type MockStore struct {
 	isValid     bool
 	cookieValue string
 	err         error
+	id          string
 	val         interface{}
 	isCommited  bool
 }
@@ -18,7 +19,7 @@ func (s *MockStore) reset() {
 }
 
 func (s *MockStore) Create() (cv string, err error) {
-	return s.val.(string), s.err
+	return s.id, s.err
 }
 
 func (s *MockStore) Get(cv, key string) (value interface{}, err error) {