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 }