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

     1  package tests
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  
     8  	ravendb "github.com/altipla-consulting/ravendb-go-client"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func patchTestcanPatchSingleDocument(t *testing.T, driver *RavenTestDriver) {
    13  	var err error
    14  	store := driver.getDocumentStoreMust(t)
    15  	defer store.Close()
    16  
    17  	{
    18  		session := openSessionMust(t, store)
    19  		user := &User{}
    20  		user.setName("RavenDB")
    21  
    22  		err = session.StoreWithID(user, "users/1")
    23  		assert.NoError(t, err)
    24  		err = session.SaveChanges()
    25  		assert.NoError(t, err)
    26  		session.Close()
    27  	}
    28  
    29  	patchRequest := &ravendb.PatchRequest{
    30  		Script: `this.name = "Patched"`,
    31  	}
    32  	patchOperation, err := ravendb.NewPatchOperation("users/1", nil, patchRequest, nil, false)
    33  	assert.NoError(t, err)
    34  	patchResult, err := store.Operations().SendPatchOperation(patchOperation, nil)
    35  	assert.NoError(t, err)
    36  	assert.Equal(t, patchResult.Status, ravendb.PatchStatusPatched)
    37  
    38  	{
    39  		session := openSessionMust(t, store)
    40  		var loadedUser *User
    41  		err = session.Load(&loadedUser, "users/1")
    42  		assert.NoError(t, err)
    43  		assert.Equal(t, *loadedUser.Name, "Patched")
    44  		session.Close()
    45  	}
    46  }
    47  
    48  func patchTestCanWaitForIndexAfterPatch(t *testing.T, driver *RavenTestDriver) {
    49  	var err error
    50  	store := driver.getDocumentStoreMust(t)
    51  	defer store.Close()
    52  
    53  	usersByName := NewUsers_ByName()
    54  	err = usersByName.Execute(store, nil, "")
    55  	assert.NoError(t, err)
    56  
    57  	{
    58  		session := openSessionMust(t, store)
    59  		user := &User{}
    60  		user.setName("RavenDB")
    61  
    62  		err = session.StoreWithID(user, "users/1")
    63  		assert.NoError(t, err)
    64  		err = session.SaveChanges()
    65  		assert.NoError(t, err)
    66  
    67  		session.Close()
    68  	}
    69  
    70  	{
    71  		session := openSessionMust(t, store)
    72  
    73  		builder := func(x *ravendb.IndexesWaitOptsBuilder) {
    74  			x.WaitForIndexes("Users/ByName")
    75  		}
    76  		session.Advanced().WaitForIndexesAfterSaveChanges(builder)
    77  
    78  		var user *User
    79  		err = session.Load(&user, "users/1")
    80  		assert.NoError(t, err)
    81  
    82  		err = session.Advanced().Patch(user, "name", "New Name")
    83  		assert.NoError(t, err)
    84  
    85  		err = session.SaveChanges()
    86  		assert.NoError(t, err)
    87  
    88  		session.Close()
    89  	}
    90  }
    91  
    92  func patchTestcanPatchManyDocuments(t *testing.T, driver *RavenTestDriver) {
    93  	var err error
    94  	store := driver.getDocumentStoreMust(t)
    95  	defer store.Close()
    96  
    97  	{
    98  		session := openSessionMust(t, store)
    99  		user := &User{}
   100  		user.setName("RavenDB")
   101  
   102  		err = session.StoreWithID(user, "users/1")
   103  		assert.NoError(t, err)
   104  		err = session.SaveChanges()
   105  		assert.NoError(t, err)
   106  
   107  		// TODO: we crash if it's Query() and not QueryType()
   108  		// (need to validate and not crash)
   109  		clazz := reflect.TypeOf(&User{})
   110  		q := session.QueryCollectionForType(clazz)
   111  		lazy, err := q.CountLazily()
   112  		assert.NoError(t, err)
   113  		var n int
   114  		err = lazy.GetValue(&n)
   115  		assert.NoError(t, err)
   116  		assert.Equal(t, n, 1)
   117  
   118  		session.Close()
   119  	}
   120  
   121  	operation := ravendb.NewPatchByQueryOperation("from Users update {  this.name= \"Patched\"  }")
   122  	op, err := store.Operations().SendAsync(operation, nil)
   123  	assert.NoError(t, err)
   124  	err = op.WaitForCompletion()
   125  	assert.NoError(t, err)
   126  
   127  	{
   128  		session := openSessionMust(t, store)
   129  		var loadedUser *User
   130  		err = session.Load(&loadedUser, "users/1")
   131  		assert.NoError(t, err)
   132  		assert.Equal(t, *loadedUser.Name, "Patched")
   133  		session.Close()
   134  	}
   135  }
   136  
   137  func patchTestthrowsOnInvalidScript(t *testing.T, driver *RavenTestDriver) {
   138  	var err error
   139  	store := driver.getDocumentStoreMust(t)
   140  	defer store.Close()
   141  
   142  	{
   143  		session := openSessionMust(t, store)
   144  		user := &User{}
   145  		user.setName("RavenDB")
   146  
   147  		err = session.StoreWithID(user, "users/1")
   148  		assert.NoError(t, err)
   149  		err = session.SaveChanges()
   150  		assert.NoError(t, err)
   151  		session.Close()
   152  	}
   153  
   154  	operation := ravendb.NewPatchByQueryOperation("from Users update {  throw 5 }")
   155  
   156  	op, err := store.Operations().SendAsync(operation, nil)
   157  	assert.NoError(t, err)
   158  
   159  	err = op.WaitForCompletion()
   160  	assert.Error(t, err)
   161  	// TODO: make sure it's an instance of JavaScriptException ? Currently is RavenError
   162  	assert.True(t, strings.Contains(err.Error(), "Raven.Client.Exceptions.Documents.Patching.JavaScriptException"))
   163  
   164  }
   165  
   166  func TestPatch(t *testing.T) {
   167  	driver := createTestDriver(t)
   168  	destroy := func() { destroyDriver(t, driver) }
   169  	defer recoverTest(t, destroy)
   170  
   171  	// order matches Java tests
   172  	patchTestcanPatchManyDocuments(t, driver)
   173  	patchTestthrowsOnInvalidScript(t, driver)
   174  	patchTestcanPatchSingleDocument(t, driver)
   175  
   176  	// TODO: not in order of Java
   177  	patchTestCanWaitForIndexAfterPatch(t, driver)
   178  }