github.com/ravendb/ravendb-go-client@v0.0.0-20240229102137-4474ee7aa0fa/tests/cluster_transaction_test.go (about)

     1  package tests
     2  
     3  import (
     4  	"github.com/ravendb/ravendb-go-client"
     5  	"github.com/stretchr/testify/assert"
     6  	"reflect"
     7  	"strings"
     8  	"testing"
     9  )
    10  
    11  func throwOnInvalidTransactionMode(t *testing.T, driver *RavenTestDriver) {
    12  	store := driver.getDocumentStoreMust(t)
    13  	defer store.Close()
    14  
    15  	user := &User{}
    16  	user.setName("Karmel")
    17  
    18  	var session *ravendb.DocumentSession
    19  	{
    20  		session = openSessionMust(t, store)
    21  
    22  		ct := session.Advanced().ClusterTransaction()
    23  		assert.Nil(t, ct)
    24  
    25  		session.Close()
    26  		session = nil
    27  	}
    28  
    29  	disableAtomicDocumentWritesInClusterWideTransaction := true
    30  	{
    31  		session = openSessionMustWithOptions(t, store, &ravendb.SessionOptions{
    32  			Database:        "",
    33  			RequestExecutor: nil,
    34  			TransactionMode: ravendb.TransactionMode_ClusterWide,
    35  			DisableAtomicDocumentWritesInClusterWideTransaction: &disableAtomicDocumentWritesInClusterWideTransaction,
    36  		})
    37  
    38  		clusterTransaction := session.Advanced().ClusterTransaction()
    39  		assert.NotNil(t, clusterTransaction)
    40  
    41  		session.Advanced().ClusterTransaction().CreateCompareExchangeValue("usernames/ayende", user)
    42  		session.Advanced().SetTransactionMode(ravendb.TransactionMode_SingleNode)
    43  
    44  		err := session.SaveChanges()
    45  		assert.Error(t, err)
    46  		assert.True(t, strings.Contains(err.Error(), "Performing cluster transaction operation require the TransactionMode to be set to TransactionMode_ClusterWide"))
    47  
    48  		session.Advanced().SetTransactionMode(ravendb.TransactionMode_ClusterWide)
    49  
    50  		err = session.SaveChanges()
    51  		assert.NoError(t, err)
    52  		session.Close()
    53  	}
    54  }
    55  
    56  func testSessionSequance(t *testing.T, driver *RavenTestDriver) {
    57  	store := driver.getDocumentStoreMust(t)
    58  	defer store.Close()
    59  
    60  	user1 := &User{}
    61  	user2 := &User{}
    62  
    63  	user1.setName("Karmel")
    64  	user2.setName("Indych")
    65  	dat := true
    66  	{
    67  		session := openSessionMustWithOptions(t, store, &ravendb.SessionOptions{
    68  			Database:        "",
    69  			RequestExecutor: nil,
    70  			TransactionMode: ravendb.TransactionMode_ClusterWide,
    71  			DisableAtomicDocumentWritesInClusterWideTransaction: &dat,
    72  		})
    73  
    74  		var err error
    75  		session.Advanced().ClusterTransaction().CreateCompareExchangeValue("usernames/ayende", user1)
    76  		err = session.StoreWithID(user1, "users/1")
    77  		assert.NoError(t, err)
    78  
    79  		err = session.SaveChanges()
    80  		assert.NoError(t, err)
    81  
    82  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/ayende")
    83  		value.Value = user2
    84  
    85  		session.StoreWithID(user2, "users/2")
    86  		user1.setAge(10)
    87  		session.StoreWithID(user1, "users/1")
    88  		err = session.SaveChanges()
    89  		assert.NoError(t, err)
    90  		session.Close()
    91  	}
    92  }
    93  
    94  func testSessionOnPrimitiveType(t *testing.T, driver *RavenTestDriver) {
    95  	store := driver.getDocumentStoreMust(t)
    96  	defer store.Close()
    97  	dat := true
    98  	options := &ravendb.SessionOptions{
    99  		Database:        "",
   100  		RequestExecutor: nil,
   101  		TransactionMode: ravendb.TransactionMode_ClusterWide,
   102  		DisableAtomicDocumentWritesInClusterWideTransaction: &dat,
   103  	}
   104  
   105  	{
   106  		session := openSessionMustWithOptions(t, store, options)
   107  		defer session.Close()
   108  
   109  		var err error
   110  		_, err = session.Advanced().ClusterTransaction().CreateCompareExchangeValue("int/Key", 1)
   111  		assert.NoError(t, err)
   112  
   113  		_, err = session.Advanced().ClusterTransaction().CreateCompareExchangeValue("string/Key", "hello")
   114  		assert.NoError(t, err)
   115  
   116  		err = session.SaveChanges()
   117  		assert.NoError(t, err)
   118  
   119  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   120  		assert.NoError(t, err)
   121  		assert.Equal(t, 1, value.Value)
   122  
   123  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   124  		assert.NoError(t, err)
   125  		assert.Equal(t, "hello", value.Value)
   126  	}
   127  
   128  	{
   129  		session := openSessionMustWithOptions(t, store, options)
   130  		defer session.Close()
   131  
   132  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   133  		assert.NoError(t, err)
   134  		assert.Equal(t, 1, value.Value)
   135  		value.Value = 2
   136  
   137  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   138  		assert.NoError(t, err)
   139  		assert.Equal(t, 2, value.Value)
   140  
   141  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   142  		assert.NoError(t, err)
   143  		assert.Equal(t, "hello", value.Value)
   144  		value.Value = "world"
   145  
   146  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   147  		assert.NoError(t, err)
   148  		assert.Equal(t, "world", value.Value)
   149  
   150  		err = session.SaveChanges()
   151  		assert.NoError(t, err)
   152  	}
   153  
   154  	{
   155  		session := openSessionMustWithOptions(t, store, options)
   156  		defer session.Close()
   157  
   158  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   159  		assert.NoError(t, err)
   160  		assert.Equal(t, 2, value.Value)
   161  
   162  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   163  		assert.NoError(t, err)
   164  		assert.Equal(t, "world", value.Value)
   165  	}
   166  
   167  	{
   168  		session := openSessionMustWithOptions(t, store, options)
   169  		defer session.Close()
   170  
   171  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   172  		assert.NoError(t, err)
   173  		err = session.Advanced().ClusterTransaction().DeleteCompareExchangeValueByKey("int/Key", value.GetIndex())
   174  
   175  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   176  		assert.NoError(t, err)
   177  		err = session.Advanced().ClusterTransaction().DeleteCompareExchangeValue(value)
   178  		assert.NoError(t, err)
   179  
   180  		err = session.SaveChanges()
   181  		assert.NoError(t, err)
   182  	}
   183  
   184  	{
   185  		session := openSessionMustWithOptions(t, store, options)
   186  		defer session.Close()
   187  
   188  		value, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(int(0)), "int/Key")
   189  		assert.NoError(t, err)
   190  		assert.Nil(t, value)
   191  
   192  		value, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(string("")), "string/Key")
   193  		assert.NoError(t, err)
   194  		assert.Nil(t, value)
   195  	}
   196  }
   197  
   198  func canCreateClusterTransactionRequest(t *testing.T, driver *RavenTestDriver) {
   199  	store := driver.getDocumentStoreMust(t)
   200  	defer store.Close()
   201  
   202  	user1 := &User{}
   203  	user3 := &User{}
   204  
   205  	user1.setName("Karmel")
   206  	user3.setName("Indych")
   207  	dat := true
   208  	{
   209  		session := openSessionMustWithOptions(t, store, &ravendb.SessionOptions{
   210  			Database:        "",
   211  			RequestExecutor: nil,
   212  			TransactionMode: ravendb.TransactionMode_ClusterWide,
   213  			DisableAtomicDocumentWritesInClusterWideTransaction: &dat,
   214  		})
   215  
   216  		var err error
   217  		_, err = session.Advanced().ClusterTransaction().CreateCompareExchangeValue("usernames/ayende", user1)
   218  		assert.NoError(t, err)
   219  
   220  		err = session.StoreWithID(user3, "foo/bar")
   221  		assert.NoError(t, err)
   222  
   223  		err = session.SaveChanges()
   224  		assert.NoError(t, err)
   225  
   226  		cev, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/ayende")
   227  		assert.NoError(t, err)
   228  
   229  		userFromCEV, ok := cev.Value.(*User)
   230  		assert.True(t, ok)
   231  
   232  		user := &User{}
   233  		err = session.Load(&user, "foo/bar")
   234  		assert.NoError(t, err)
   235  
   236  		assert.Equal(t, user1.Name, userFromCEV.Name)
   237  		assert.Equal(t, user.Name, user3.Name)
   238  		session.Close()
   239  	}
   240  }
   241  
   242  func canDeleteCompareExchangeValue(t *testing.T, driver *RavenTestDriver) {
   243  	store := driver.getDocumentStoreMust(t)
   244  	defer store.Close()
   245  
   246  	user1 := &User{}
   247  	user3 := &User{}
   248  
   249  	user1.setName("Karmel")
   250  	user3.setName("Indych")
   251  
   252  	opt := true
   253  	options := &ravendb.SessionOptions{
   254  		Database:        "",
   255  		RequestExecutor: nil,
   256  		TransactionMode: ravendb.TransactionMode_ClusterWide,
   257  		DisableAtomicDocumentWritesInClusterWideTransaction: &opt,
   258  	}
   259  
   260  	{
   261  		session := openSessionMustWithOptions(t, store, options)
   262  		defer session.Close()
   263  		session.Advanced().ClusterTransaction().CreateCompareExchangeValue("usernames/ayende", user1)
   264  		session.Advanced().ClusterTransaction().CreateCompareExchangeValue("usernames/marcin", user3)
   265  		session.SaveChanges()
   266  	}
   267  
   268  	{
   269  		session := openSessionMustWithOptions(t, store, options)
   270  		defer session.Close()
   271  
   272  		compareExchangeValue, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/ayende")
   273  		assert.NoError(t, err)
   274  		assert.NotNil(t, compareExchangeValue)
   275  
   276  		err = session.Advanced().ClusterTransaction().DeleteCompareExchangeValue(compareExchangeValue)
   277  		assert.NoError(t, err)
   278  
   279  		compareExchangeValue2, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/marcin")
   280  		assert.NoError(t, err)
   281  		assert.NotNil(t, compareExchangeValue2)
   282  		err = session.Advanced().ClusterTransaction().DeleteCompareExchangeValueByKey(compareExchangeValue2.GetKey(), compareExchangeValue2.GetIndex())
   283  		assert.NoError(t, err)
   284  		session.SaveChanges()
   285  	}
   286  
   287  	{
   288  		session := openSessionMustWithOptions(t, store, options)
   289  		defer session.Close()
   290  
   291  		compareExchangeValue, err := session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/ayende")
   292  		assert.NoError(t, err)
   293  		assert.Nil(t, compareExchangeValue)
   294  
   295  		compareExchangeValue, err = session.Advanced().ClusterTransaction().GetCompareExchangeValue(reflect.TypeOf(&User{}), "usernames/marcin")
   296  		assert.NoError(t, err)
   297  		assert.Nil(t, compareExchangeValue)
   298  	}
   299  
   300  }
   301  
   302  func TestClusterTransaction(t *testing.T) {
   303  	driver := createTestDriver(t)
   304  	destroy := func() { destroyDriver(t, driver) }
   305  	defer recoverTest(t, destroy)
   306  	throwOnInvalidTransactionMode(t, driver)
   307  	testSessionSequance(t, driver)
   308  	canCreateClusterTransactionRequest(t, driver)
   309  	canDeleteCompareExchangeValue(t, driver)
   310  	testSessionOnPrimitiveType(t, driver)
   311  }