store_test.go

package tests

import (
	"testing"

	ravendb "github.com/ravendb/ravendb-go-client"
	"github.com/stretchr/testify/assert"
)

func storeTestRefreshTest(t *testing.T, driver *RavenTestDriver) {
	var err error
	store := driver.getDocumentStoreMust(t)
	defer store.Close()

	{
		session := openSessionMust(t, store)
		user := &User{}
		user.setName("RavenDB")
		err = session.StoreWithID(user, "users/1")
		assert.NoError(t, err)
		err = session.SaveChanges()
		assert.NoError(t, err)

		{
			innerSession := openSessionMust(t, store)
			var innerUser *User
			err = innerSession.Load(&innerUser, "users/1")
			assert.NoError(t, err)

			innerUser.setName("RavenDB 4.0")
			err = innerSession.SaveChanges()
			assert.NoError(t, err)
		}

		err = session.Advanced().Refresh(user)
		assert.NoError(t, err)

		name := *user.Name
		assert.Equal(t, name, "RavenDB 4.0")
		session.Close()
	}
}

func storeTestStoreDocument(t *testing.T, driver *RavenTestDriver) {
	var err error
	store := driver.getDocumentStoreMust(t)
	defer store.Close()

	{
		session := openSessionMust(t, store)

		user := &User{}
		user.setName("RavenDB")
		err = session.StoreWithID(user, "users/1")
		assert.NoError(t, err)
		err = session.SaveChanges()
		assert.NoError(t, err)

		user = nil
		err = session.Load(&user, "users/1")
		assert.NoError(t, err)
		assert.NotNil(t, user)
		name := *user.Name
		assert.Equal(t, name, "RavenDB")
		session.Close()
	}
}

func storeTestStoreDocuments(t *testing.T, driver *RavenTestDriver) {
	var err error
	store := driver.getDocumentStoreMust(t)
	defer store.Close()

	{
		session := openSessionMust(t, store)
		user1 := &User{}
		user1.setName("RavenDB")
		err = session.StoreWithID(user1, "users/1")
		assert.NoError(t, err)

		user2 := &User{}
		user2.setName("Hibernating Rhinos")
		err = session.StoreWithID(user2, "users/2")
		assert.NoError(t, err)

		err = session.SaveChanges()
		assert.NoError(t, err)

		users := map[string]*User{}
		err = session.LoadMulti(users, []string{"users/1", "users/2"})
		assert.NoError(t, err)
		assert.Equal(t, len(users), 2)
		session.Close()
	}
}

func storeTestNotifyAfterStore(t *testing.T, driver *RavenTestDriver) {
	var err error
	store := driver.getDocumentStoreMust(t)
	defer store.Close()

	storeLevelCallBack := []*ravendb.MetadataAsDictionary{nil}
	sessionLevelCallback := []*ravendb.MetadataAsDictionary{nil}

	fn := func(event *ravendb.AfterSaveChangesEventArgs) {
		storeLevelCallBack[0] = event.GetDocumentMetadata()
	}
	store.AddAfterSaveChangesListener(fn)

	{
		session := openSessionMust(t, store)
		fn := func(event *ravendb.AfterSaveChangesEventArgs) {
			sessionLevelCallback[0] = event.GetDocumentMetadata()
		}
		session.Advanced().AddAfterSaveChangesListener(fn)

		user1 := &User{}
		user1.setName("RavenDB")
		err = session.StoreWithID(user1, "users/1")
		assert.NoError(t, err)
		err = session.SaveChanges()
		assert.NoError(t, err)

		isLoaded := session.Advanced().IsLoaded("users/1")
		assert.True(t, isLoaded)

		changeVector, err := session.Advanced().GetChangeVectorFor(user1)
		assert.NoError(t, err)
		assert.NotNil(t, changeVector)

		lastModified, err := session.Advanced().GetLastModifiedFor(user1)
		assert.NoError(t, err)
		assert.NotNil(t, lastModified)

		session.Close()
	}

	assert.NotNil(t, storeLevelCallBack[0])
	assert.Equal(t, storeLevelCallBack[0], sessionLevelCallback[0])
	assert.NotNil(t, sessionLevelCallback[0])

	iMetadataDictionary := sessionLevelCallback[0]
	entrySet := iMetadataDictionary.EntrySet()
	for key, value := range entrySet {
		assert.NotEqual(t, key, "")
		assert.NotNil(t, value)
	}
}

func TestStore(t *testing.T) {
	driver := createTestDriver(t)
	destroy := func() { destroyDriver(t, driver) }
	defer recoverTest(t, destroy)

	// matches order of java tests
	storeTestRefreshTest(t, driver)
	storeTestStoreDocument(t, driver)
	storeTestStoreDocuments(t, driver)
	storeTestNotifyAfterStore(t, driver)
}