github.com/altipla-consulting/ravendb-go-client@v0.1.3/tests/what_changed_test.go (about)

     1  package tests
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/altipla-consulting/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 whatChangedHasChanges(t *testing.T, driver *RavenTestDriver) {
   400  	var err error
   401  	store := driver.getDocumentStoreMust(t)
   402  	defer store.Close()
   403  
   404  	{
   405  		session := openSessionMust(t, store)
   406  
   407  		user1 := &User{}
   408  		user1.setName("user1")
   409  
   410  		user2 := &User{}
   411  		user2.setName("user2")
   412  		user2.Age = 1
   413  
   414  		err = session.StoreWithID(user1, "users/1")
   415  		assert.NoError(t, err)
   416  		err = session.StoreWithID(user2, "users/2")
   417  		assert.NoError(t, err)
   418  
   419  		err = session.SaveChanges()
   420  		assert.NoError(t, err)
   421  
   422  		session.Close()
   423  	}
   424  
   425  	{
   426  		session := openSessionMust(t, store)
   427  
   428  		hasChanges := session.Advanced().HasChanges()
   429  		assert.False(t, hasChanges)
   430  
   431  		var u1, u2 *User
   432  
   433  		err = session.Load(&u1, "users/1")
   434  		assert.NoError(t, err)
   435  		err = session.Load(&u2, "users/2")
   436  		assert.NoError(t, err)
   437  
   438  		hasChanged, err := session.Advanced().HasChanged(u1)
   439  		assert.NoError(t, err)
   440  		assert.False(t, hasChanged)
   441  
   442  		hasChanged, err = session.Advanced().HasChanged(u2)
   443  		assert.NoError(t, err)
   444  		assert.False(t, hasChanged)
   445  
   446  		u1.setName("new name")
   447  
   448  		hasChanged, err = session.Advanced().HasChanged(u1)
   449  		assert.NoError(t, err)
   450  		assert.True(t, hasChanged)
   451  
   452  		hasChanged, err = session.Advanced().HasChanged(u2)
   453  		assert.NoError(t, err)
   454  		assert.False(t, hasChanged)
   455  
   456  		hasChanges = session.Advanced().HasChanges()
   457  		assert.True(t, hasChanges)
   458  
   459  		session.Close()
   460  	}
   461  }
   462  
   463  type BasicName struct {
   464  	Name string
   465  }
   466  
   467  type NameAndAge struct {
   468  	Name string
   469  	Age  int
   470  }
   471  
   472  type BasicAge struct {
   473  	Age int
   474  }
   475  
   476  type Int struct {
   477  	Number int
   478  }
   479  
   480  type Double struct {
   481  	Number float64
   482  }
   483  
   484  type Arr struct {
   485  	Array []interface{}
   486  }
   487  
   488  func TestWhatChanged(t *testing.T) {
   489  	driver := createTestDriver(t)
   490  	destroy := func() { destroyDriver(t, driver) }
   491  	defer recoverTest(t, destroy)
   492  
   493  	// matches order of Java tests
   494  	whatChangedWhatChangedArrayValueRemoved(t, driver)
   495  	whatChangedWhatChangedNewField(t, driver)
   496  	whatChangedWhatChangedArrayValueAdded(t, driver)
   497  	whatChangedWhatChangedChangeField(t, driver)
   498  	whatChangedWhatChangedArrayValueChanged(t, driver)
   499  	whatChangedRavenDB8169(t, driver)
   500  	whatChangedWhatChangedRemovedField(t, driver)
   501  	whatChangedWhatChangedShouldBeIdempotentOperation(t, driver)
   502  
   503  	// TODO: order doesn't match Java
   504  	whatChangedHasChanges(t, driver)
   505  }