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

     1  package tests
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/ravendb/ravendb-go-client"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func whatChangedWhatChangedNewField(t *testing.T, driver *RavenTestDriver) {
    12  	var err error
    13  	store := driver.getDocumentStoreMust(t)
    14  	defer store.Close()
    15  
    16  	{
    17  		newSession := openSessionMust(t, store)
    18  		basicName := &BasicName{}
    19  		basicName.Name = "Toli"
    20  		err = newSession.StoreWithID(basicName, "users/1")
    21  		assert.NoError(t, err)
    22  
    23  		changes, _ := newSession.Advanced().WhatChanged()
    24  		assert.Equal(t, len(changes), 1)
    25  		err = newSession.SaveChanges()
    26  		assert.NoError(t, err)
    27  		newSession.Close()
    28  	}
    29  
    30  	{
    31  		var user *NameAndAge
    32  		newSession := openSessionMust(t, store)
    33  		err = newSession.Load(&user, "users/1")
    34  		assert.NoError(t, err)
    35  		user.Age = 5
    36  
    37  		changesMap, _ := newSession.Advanced().WhatChanged()
    38  		changes := changesMap["users/1"]
    39  		assert.Equal(t, len(changes), 1)
    40  
    41  		{
    42  			change := changes[0]
    43  			assert.Equal(t, change.Change, ravendb.DocumentChangeNewField)
    44  			err = newSession.SaveChanges()
    45  			assert.NoError(t, err)
    46  		}
    47  		newSession.Close()
    48  	}
    49  }
    50  
    51  func whatChangedWhatChangedRemovedField(t *testing.T, driver *RavenTestDriver) {
    52  	var err error
    53  	store := driver.getDocumentStoreMust(t)
    54  	defer store.Close()
    55  
    56  	{
    57  		newSession := openSessionMust(t, store)
    58  		nameAndAge := &NameAndAge{}
    59  		nameAndAge.Age = 5
    60  		nameAndAge.Name = "Toli"
    61  
    62  		err = newSession.StoreWithID(nameAndAge, "users/1")
    63  		assert.NoError(t, err)
    64  
    65  		changes, _ := newSession.Advanced().WhatChanged()
    66  		assert.Equal(t, len(changes), 1)
    67  
    68  		err = newSession.SaveChanges()
    69  		assert.NoError(t, err)
    70  		newSession.Close()
    71  	}
    72  
    73  	{
    74  		newSession := openSessionMust(t, store)
    75  		var unused *BasicAge
    76  		err = newSession.Load(&unused, "users/1")
    77  		assert.NoError(t, err)
    78  
    79  		changesMap, _ := newSession.Advanced().WhatChanged()
    80  		changes := changesMap["users/1"]
    81  		assert.Equal(t, len(changes), 1)
    82  
    83  		{
    84  			change := changes[0]
    85  			assert.Equal(t, change.Change, ravendb.DocumentChangeRemovedField)
    86  		}
    87  
    88  		err = newSession.SaveChanges()
    89  		assert.NoError(t, err)
    90  		newSession.Close()
    91  	}
    92  }
    93  
    94  func whatChangedWhatChangedChangeField(t *testing.T, driver *RavenTestDriver) {
    95  	var err error
    96  	store := driver.getDocumentStoreMust(t)
    97  	defer store.Close()
    98  
    99  	{
   100  		newSession := openSessionMust(t, store)
   101  		basicAge := &BasicAge{}
   102  		basicAge.Age = 5
   103  		err = newSession.StoreWithID(basicAge, "users/1")
   104  		assert.NoError(t, err)
   105  
   106  		changes, _ := newSession.Advanced().WhatChanged()
   107  		assert.Equal(t, len(changes), 1)
   108  
   109  		err = newSession.SaveChanges()
   110  		assert.NoError(t, err)
   111  		newSession.Close()
   112  	}
   113  
   114  	{
   115  		newSession := openSessionMust(t, store)
   116  		var unused *Int
   117  		err = newSession.Load(&unused, "users/1")
   118  		assert.NoError(t, err)
   119  		changesMap, _ := newSession.Advanced().WhatChanged()
   120  		changes := changesMap["users/1"]
   121  		assert.Equal(t, len(changes), 2)
   122  
   123  		{
   124  			change := changes[0]
   125  			assert.Equal(t, change.Change, ravendb.DocumentChangeRemovedField)
   126  		}
   127  
   128  		{
   129  			change := changes[1]
   130  			assert.Equal(t, change.Change, ravendb.DocumentChangeNewField)
   131  		}
   132  
   133  		err = newSession.SaveChanges()
   134  		assert.NoError(t, err)
   135  		newSession.Close()
   136  	}
   137  }
   138  
   139  func whatChangedWhatChangedArrayValueChanged(t *testing.T, driver *RavenTestDriver) {
   140  	var err error
   141  	store := driver.getDocumentStoreMust(t)
   142  	defer store.Close()
   143  
   144  	{
   145  		session := openSessionMust(t, store)
   146  		arr := &Arr{}
   147  		arr.Array = []interface{}{"a", 1, "b"}
   148  
   149  		err = session.StoreWithID(arr, "users/1")
   150  		assert.NoError(t, err)
   151  		changesMap, _ := session.Advanced().WhatChanged()
   152  		assert.Equal(t, len(changesMap), 1)
   153  
   154  		changes := changesMap["users/1"]
   155  		assert.Equal(t, len(changes), 1)
   156  
   157  		{
   158  			change := changes[0]
   159  			assert.Equal(t, change.Change, ravendb.DocumentChangeDocumentAdded)
   160  			err = session.SaveChanges()
   161  			assert.NoError(t, err)
   162  		}
   163  
   164  		{
   165  			newSession := openSessionMust(t, store)
   166  			var arr *Arr
   167  			err = newSession.Load(&arr, "users/1")
   168  			assert.NoError(t, err)
   169  
   170  			arr.Array = []interface{}{"a", 2, "c"}
   171  
   172  			changesMap, _ := newSession.Advanced().WhatChanged()
   173  			assert.Equal(t, len(changesMap), 1)
   174  
   175  			changes := changesMap["users/1"]
   176  			assert.Equal(t, len(changes), 2)
   177  
   178  			{
   179  				change := changes[0]
   180  				assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueChanged)
   181  				oldValue := change.FieldOldValue
   182  				assert.Equal(t, oldValue, 1.0)
   183  				newValue := change.FieldNewValue
   184  				assert.Equal(t, newValue, 2.0)
   185  			}
   186  
   187  			{
   188  				change := changes[1]
   189  				assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueChanged)
   190  				oldValueStr := fmt.Sprintf("%#v", change.FieldOldValue)
   191  				assert.Equal(t, oldValueStr, "\"b\"")
   192  				newValueStr := fmt.Sprintf("%#v", change.FieldNewValue)
   193  				assert.Equal(t, newValueStr, "\"c\"")
   194  			}
   195  			newSession.Close()
   196  		}
   197  		session.Close()
   198  	}
   199  }
   200  
   201  func whatChangedWhatChangedArrayValueAdded(t *testing.T, driver *RavenTestDriver) {
   202  	var err error
   203  	store := driver.getDocumentStoreMust(t)
   204  	defer store.Close()
   205  
   206  	{
   207  		newSession := openSessionMust(t, store)
   208  		arr := &Arr{}
   209  		arr.Array = []interface{}{"a", 1, "b"}
   210  		err = newSession.StoreWithID(arr, "arr/1")
   211  		assert.NoError(t, err)
   212  		err = newSession.SaveChanges()
   213  		assert.NoError(t, err)
   214  		newSession.Close()
   215  	}
   216  
   217  	{
   218  		newSession := openSessionMust(t, store)
   219  		var arr *Arr
   220  		err = newSession.Load(&arr, "arr/1")
   221  		assert.NoError(t, err)
   222  
   223  		arr.Array = []interface{}{"a", 1, "b", "c", 2}
   224  
   225  		changesMap, _ := newSession.Advanced().WhatChanged()
   226  		assert.Equal(t, len(changesMap), 1)
   227  		changes := changesMap["arr/1"]
   228  		assert.Equal(t, len(changes), 2)
   229  
   230  		{
   231  			change := changes[0]
   232  			assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueAdded)
   233  			newValStr := fmt.Sprintf("%#v", change.FieldNewValue)
   234  			assert.Equal(t, newValStr, "\"c\"")
   235  			assert.Nil(t, change.FieldOldValue)
   236  		}
   237  		{
   238  			change := changes[1]
   239  			assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueAdded)
   240  			assert.Equal(t, change.FieldNewValue, float64(2))
   241  			assert.Nil(t, change.FieldOldValue)
   242  		}
   243  		newSession.Close()
   244  	}
   245  }
   246  
   247  func whatChangedWhatChangedArrayValueRemoved(t *testing.T, driver *RavenTestDriver) {
   248  	var err error
   249  	store := driver.getDocumentStoreMust(t)
   250  	defer store.Close()
   251  
   252  	{
   253  		newSession := openSessionMust(t, store)
   254  		arr := &Arr{}
   255  		arr.Array = []interface{}{"a", 1, "b"}
   256  		err = newSession.StoreWithID(arr, "arr/1")
   257  		assert.NoError(t, err)
   258  		err = newSession.SaveChanges()
   259  		assert.NoError(t, err)
   260  		newSession.Close()
   261  	}
   262  
   263  	{
   264  		newSession := openSessionMust(t, store)
   265  		var arr *Arr
   266  		err = newSession.Load(&arr, "arr/1")
   267  		assert.NoError(t, err)
   268  		assert.Equal(t, 3, len(arr.Array))
   269  
   270  		arr.Array = []interface{}{"a"}
   271  
   272  		changesMap, _ := newSession.Advanced().WhatChanged()
   273  		assert.Equal(t, len(changesMap), 1)
   274  		changes := changesMap["arr/1"]
   275  		assert.Equal(t, len(changes), 2)
   276  
   277  		{
   278  			change := changes[0]
   279  			assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueRemoved)
   280  			assert.Equal(t, change.FieldOldValue, float64(1))
   281  			assert.Nil(t, change.FieldNewValue)
   282  		}
   283  
   284  		{
   285  			change := changes[1]
   286  			assert.Equal(t, change.Change, ravendb.DocumentChangeArrayValueRemoved)
   287  
   288  			oldValStr := fmt.Sprintf("%#v", change.FieldOldValue)
   289  			assert.Equal(t, oldValStr, "\"b\"")
   290  			assert.Nil(t, change.FieldNewValue)
   291  		}
   292  		newSession.Close()
   293  	}
   294  }
   295  
   296  func whatChangedRavenDB8169(t *testing.T, driver *RavenTestDriver) {
   297  	//Test that when old and new values are of different type
   298  	//but have the same value, we consider them unchanged
   299  
   300  	var err error
   301  	store := driver.getDocumentStoreMust(t)
   302  	defer store.Close()
   303  
   304  	{
   305  		newSession := openSessionMust(t, store)
   306  
   307  		anInt := &Int{}
   308  		anInt.Number = 1
   309  
   310  		err = newSession.StoreWithID(anInt, "num/1")
   311  		assert.NoError(t, err)
   312  
   313  		aDouble := &Double{}
   314  		aDouble.Number = 2.0
   315  		err = newSession.StoreWithID(aDouble, "num/2")
   316  		assert.NoError(t, err)
   317  
   318  		err = newSession.SaveChanges()
   319  		assert.NoError(t, err)
   320  		newSession.Close()
   321  	}
   322  
   323  	{
   324  		newSession := openSessionMust(t, store)
   325  		var unused *Double
   326  		err = newSession.Load(&unused, "num/1")
   327  		assert.NoError(t, err)
   328  
   329  		changes, _ := newSession.Advanced().WhatChanged()
   330  		assert.Equal(t, len(changes), 0)
   331  		newSession.Close()
   332  	}
   333  
   334  	{
   335  		newSession := openSessionMust(t, store)
   336  		var unused *Int
   337  		err = newSession.Load(&unused, "num/2")
   338  		assert.NoError(t, err)
   339  
   340  		changes, _ := newSession.Advanced().WhatChanged()
   341  		assert.Equal(t, len(changes), 0)
   342  		newSession.Close()
   343  	}
   344  }
   345  
   346  func whatChangedWhatChangedShouldBeIdempotentOperation(t *testing.T, driver *RavenTestDriver) {
   347  	//RavenDB-9150
   348  	var err error
   349  	store := driver.getDocumentStoreMust(t)
   350  	defer store.Close()
   351  
   352  	{
   353  		session := openSessionMust(t, store)
   354  
   355  		user1 := &User{}
   356  		user1.setName("user1")
   357  
   358  		user2 := &User{}
   359  		user2.setName("user2")
   360  		user2.Age = 1
   361  
   362  		user3 := &User{}
   363  		user3.setName("user3")
   364  		user3.Age = 1
   365  
   366  		err = session.StoreWithID(user1, "users/1")
   367  		assert.NoError(t, err)
   368  		err = session.StoreWithID(user2, "users/2")
   369  		assert.NoError(t, err)
   370  		err = session.StoreWithID(user3, "users/3")
   371  		assert.NoError(t, err)
   372  
   373  		changes, _ := session.Advanced().WhatChanged()
   374  		assert.Equal(t, len(changes), 3)
   375  
   376  		err = session.SaveChanges()
   377  		assert.NoError(t, err)
   378  
   379  		user1 = nil
   380  		err = session.Load(&user1, "users/1")
   381  		assert.NoError(t, err)
   382  
   383  		user2 = nil
   384  		err = session.Load(&user2, "users/2")
   385  		assert.NoError(t, err)
   386  
   387  		user1.Age = 10
   388  		err = session.Delete(user2)
   389  		assert.NoError(t, err)
   390  
   391  		changes, _ = session.Advanced().WhatChanged()
   392  		assert.Equal(t, len(changes), 2)
   393  		changes, _ = session.Advanced().WhatChanged()
   394  		assert.Equal(t, len(changes), 2)
   395  		session.Close()
   396  	}
   397  }
   398  
   399  func whatChangedWhatChangedBooleanItem(t *testing.T, driver *RavenTestDriver) {
   400  	var err error
   401  	store := driver.getDocumentStoreMust(t)
   402  	defer store.Close()
   403  	{
   404  		session := openSessionMust(t, store)
   405  		hasChanges := session.Advanced().HasChanges()
   406  		assert.False(t, hasChanges)
   407  
   408  		logicValue := &Boolean{}
   409  		logicValue.LogicValue = true
   410  		err = session.StoreWithID(logicValue, "logic/1")
   411  		assert.NoError(t, err)
   412  		err = session.SaveChanges()
   413  		assert.NoError(t, err)
   414  
   415  		hasChanges, err = session.Advanced().HasChanged(logicValue)
   416  		assert.NoError(t, err)
   417  		assert.False(t, hasChanges)
   418  
   419  		logicValue.LogicValue = false
   420  
   421  		hasChanges, err = session.Advanced().HasChanged(logicValue)
   422  		assert.NoError(t, err)
   423  		assert.True(t, hasChanges)
   424  
   425  		err = session.SaveChanges()
   426  		assert.NoError(t, err)
   427  		session.Close()
   428  	}
   429  
   430  	{
   431  		session := openSessionMust(t, store)
   432  		hasChanges := session.Advanced().HasChanges()
   433  		assert.False(t, hasChanges)
   434  
   435  		var b1 *Boolean
   436  		err = session.Load(&b1, "logic/1")
   437  		assert.NoError(t, err)
   438  		assert.False(t, b1.LogicValue)
   439  		session.Close()
   440  
   441  	}
   442  }
   443  
   444  func whatChangedHasChanges(t *testing.T, driver *RavenTestDriver) {
   445  	var err error
   446  	store := driver.getDocumentStoreMust(t)
   447  	defer store.Close()
   448  
   449  	{
   450  		session := openSessionMust(t, store)
   451  
   452  		user1 := &User{}
   453  		user1.setName("user1")
   454  
   455  		user2 := &User{}
   456  		user2.setName("user2")
   457  		user2.Age = 1
   458  
   459  		err = session.StoreWithID(user1, "users/1")
   460  		assert.NoError(t, err)
   461  		err = session.StoreWithID(user2, "users/2")
   462  		assert.NoError(t, err)
   463  
   464  		err = session.SaveChanges()
   465  		assert.NoError(t, err)
   466  
   467  		session.Close()
   468  	}
   469  
   470  	{
   471  		session := openSessionMust(t, store)
   472  
   473  		hasChanges := session.Advanced().HasChanges()
   474  		assert.False(t, hasChanges)
   475  
   476  		var u1, u2 *User
   477  
   478  		err = session.Load(&u1, "users/1")
   479  		assert.NoError(t, err)
   480  		err = session.Load(&u2, "users/2")
   481  		assert.NoError(t, err)
   482  
   483  		hasChanged, err := session.Advanced().HasChanged(u1)
   484  		assert.NoError(t, err)
   485  		assert.False(t, hasChanged)
   486  
   487  		hasChanged, err = session.Advanced().HasChanged(u2)
   488  		assert.NoError(t, err)
   489  		assert.False(t, hasChanged)
   490  
   491  		u1.setName("new name")
   492  
   493  		hasChanged, err = session.Advanced().HasChanged(u1)
   494  		assert.NoError(t, err)
   495  		assert.True(t, hasChanged)
   496  
   497  		hasChanged, err = session.Advanced().HasChanged(u2)
   498  		assert.NoError(t, err)
   499  		assert.False(t, hasChanged)
   500  
   501  		hasChanges = session.Advanced().HasChanges()
   502  		assert.True(t, hasChanges)
   503  
   504  		session.Close()
   505  	}
   506  }
   507  
   508  type BasicName struct {
   509  	Name string
   510  }
   511  
   512  type NameAndAge struct {
   513  	Name string
   514  	Age  int
   515  }
   516  
   517  type BasicAge struct {
   518  	Age int
   519  }
   520  
   521  type Int struct {
   522  	Number int
   523  }
   524  
   525  type Double struct {
   526  	Number float64
   527  }
   528  
   529  type Arr struct {
   530  	Array []interface{}
   531  }
   532  
   533  type Boolean struct {
   534  	LogicValue bool
   535  }
   536  
   537  func TestWhatChanged(t *testing.T) {
   538  	driver := createTestDriver(t)
   539  	destroy := func() { destroyDriver(t, driver) }
   540  	defer recoverTest(t, destroy)
   541  
   542  	// matches order of Java tests
   543  	whatChangedWhatChangedArrayValueRemoved(t, driver)
   544  	whatChangedWhatChangedNewField(t, driver)
   545  	whatChangedWhatChangedArrayValueAdded(t, driver)
   546  	whatChangedWhatChangedChangeField(t, driver)
   547  	whatChangedWhatChangedArrayValueChanged(t, driver)
   548  	whatChangedRavenDB8169(t, driver)
   549  	whatChangedWhatChangedRemovedField(t, driver)
   550  	whatChangedWhatChangedShouldBeIdempotentOperation(t, driver)
   551  	whatChangedWhatChangedBooleanItem(t, driver)
   552  	// TODO: order doesn't match Java
   553  	whatChangedHasChanges(t, driver)
   554  }