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

     1  package tests
     2  
     3  import (
     4  	"testing"
     5  
     6  	ravendb "github.com/altipla-consulting/ravendb-go-client"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func NewUsersInvalidIndex() *ravendb.IndexCreationTask {
    11  	res := ravendb.NewIndexCreationTask("UsersInvalidIndex")
    12  	res.Map = "from u in docs.Users select new { a = 5 / u.Age }"
    13  	return res
    14  }
    15  
    16  func NewUsers_Index() *ravendb.IndexCreationTask {
    17  	res := ravendb.NewIndexCreationTask("Users_Index")
    18  	res.Map = "from u in docs.Users select new { u.name }"
    19  	return res
    20  }
    21  
    22  func testIndexCanDeleteIndex(t *testing.T, driver *RavenTestDriver) {
    23  	var err error
    24  	store := driver.getDocumentStoreMust(t)
    25  	defer store.Close()
    26  
    27  	index := NewUsersIndex()
    28  	err = index.Execute(store, nil, "")
    29  	assert.NoError(t, err)
    30  
    31  	op := ravendb.NewGetIndexNamesOperation(0, 10)
    32  	err = store.Maintenance().Send(op)
    33  	assert.NoError(t, err)
    34  	indexNames := op.Command.Result
    35  	assert.True(t, stringArrayContains(indexNames, "UsersIndex"))
    36  
    37  	op2 := ravendb.NewDeleteIndexOperation("UsersIndex")
    38  	err = store.Maintenance().Send(op2)
    39  	assert.NoError(t, err)
    40  
    41  	op3 := ravendb.NewGetIndexNamesOperation(0, 10)
    42  	err = store.Maintenance().Send(op3)
    43  	assert.NoError(t, err)
    44  	indexNames = op3.Command.Result
    45  	assert.Equal(t, len(indexNames), 0)
    46  }
    47  
    48  func testIndexCanDisableAndEnableIndex(t *testing.T, driver *RavenTestDriver) {
    49  	var err error
    50  	store := driver.getDocumentStoreMust(t)
    51  	defer store.Close()
    52  
    53  	index := NewUsersIndex()
    54  	err = index.Execute(store, nil, "")
    55  	assert.NoError(t, err)
    56  
    57  	{
    58  		op, err := ravendb.NewDisableIndexOperation("UsersIndex")
    59  		assert.NoError(t, err)
    60  		err = store.Maintenance().Send(op)
    61  		assert.NoError(t, err)
    62  	}
    63  
    64  	{
    65  		op := ravendb.NewGetIndexingStatusOperation()
    66  		err = store.Maintenance().Send(op)
    67  		assert.NoError(t, err)
    68  		indexingStatus := op.Command.Result
    69  		indexStatus := indexingStatus.Indexes[0]
    70  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusDisabled)
    71  	}
    72  
    73  	{
    74  		op, err := ravendb.NewEnableIndexOperation("UsersIndex")
    75  		assert.NoError(t, err)
    76  		err = store.Maintenance().Send(op)
    77  		assert.NoError(t, err)
    78  	}
    79  
    80  	{
    81  		op := ravendb.NewGetIndexingStatusOperation()
    82  		err = store.Maintenance().Send(op)
    83  		assert.NoError(t, err)
    84  		indexingStatus := op.Command.Result
    85  		indexStatus := indexingStatus.Indexes[0]
    86  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusRunning)
    87  	}
    88  }
    89  
    90  func testIndexGetCanIndexes(t *testing.T, driver *RavenTestDriver) {
    91  	var err error
    92  	store := driver.getDocumentStoreMust(t)
    93  	defer store.Close()
    94  
    95  	index := NewUsersIndex()
    96  	err = index.Execute(store, nil, "")
    97  	assert.NoError(t, err)
    98  
    99  	{
   100  		op := ravendb.NewGetIndexesOperation(0, 10)
   101  		err = store.Maintenance().Send(op)
   102  		assert.NoError(t, err)
   103  		indexDefinitions := op.Command.Result
   104  		assert.Equal(t, len(indexDefinitions), 1)
   105  	}
   106  }
   107  
   108  func testIndexGetCanIndexesStats(t *testing.T, driver *RavenTestDriver) {
   109  	var err error
   110  	store := driver.getDocumentStoreMust(t)
   111  	index := NewUsersIndex()
   112  	err = index.Execute(store, nil, "")
   113  	assert.NoError(t, err)
   114  
   115  	{
   116  		op := ravendb.NewGetIndexesStatisticsOperation()
   117  		err = store.Maintenance().Send(op)
   118  		assert.NoError(t, err)
   119  		indexStats := op.Command.Result
   120  		assert.Equal(t, len(indexStats), 1)
   121  	}
   122  }
   123  
   124  func testIndexGetTerms(t *testing.T, driver *RavenTestDriver) {
   125  	var err error
   126  	store := driver.getDocumentStoreMust(t)
   127  	defer store.Close()
   128  
   129  	index := NewUsersIndex()
   130  	err = index.Execute(store, nil, "")
   131  	assert.NoError(t, err)
   132  
   133  	{
   134  		session := openSessionMust(t, store)
   135  		user := &User{}
   136  		user.setName("Marcin")
   137  		err = session.Store(user)
   138  		assert.NoError(t, err)
   139  		err = session.SaveChanges()
   140  		assert.NoError(t, err)
   141  		session.Close()
   142  	}
   143  
   144  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   145  	assert.NoError(t, err)
   146  
   147  	{
   148  		op, err := ravendb.NewGetTermsOperation("UsersIndex", "name", "", 0)
   149  		assert.NoError(t, err)
   150  		err = store.Maintenance().Send(op)
   151  		assert.NoError(t, err)
   152  		terms := op.Command.Result
   153  		assert.Equal(t, len(terms), 1)
   154  		assert.Equal(t, terms[0], "marcin")
   155  	}
   156  }
   157  
   158  func testIndexHasIndexChanged(t *testing.T, driver *RavenTestDriver) {
   159  	var err error
   160  	store := driver.getDocumentStoreMust(t)
   161  	defer store.Close()
   162  
   163  	index := NewUsersIndex()
   164  	indexDef := index.CreateIndexDefinition()
   165  	op := ravendb.NewPutIndexesOperation(indexDef)
   166  	err = store.Maintenance().Send(op)
   167  	assert.NoError(t, err)
   168  	op2 := ravendb.NewIndexHasChangedOperation(indexDef)
   169  	err = store.Maintenance().Send(op2)
   170  	assert.NoError(t, err)
   171  	{
   172  		cmd := op2.Command
   173  		assert.False(t, cmd.Result)
   174  	}
   175  	indexDef.Maps = []string{"from users"}
   176  
   177  	op3 := ravendb.NewIndexHasChangedOperation(indexDef)
   178  	err = store.Maintenance().Send(op3)
   179  	assert.NoError(t, err)
   180  	{
   181  		cmd := op3.Command
   182  		assert.True(t, cmd.Result)
   183  	}
   184  }
   185  
   186  func testIndexCanStopStartIndexing(t *testing.T, driver *RavenTestDriver) {
   187  	var err error
   188  	store := driver.getDocumentStoreMust(t)
   189  	defer store.Close()
   190  
   191  	index := NewUsersIndex()
   192  	indexDef := index.CreateIndexDefinition()
   193  	{
   194  		op := ravendb.NewPutIndexesOperation(indexDef)
   195  		err = store.Maintenance().Send(op)
   196  		assert.NoError(t, err)
   197  	}
   198  
   199  	{
   200  		op := ravendb.NewStopIndexingOperation()
   201  		err = store.Maintenance().Send(op)
   202  		assert.NoError(t, err)
   203  	}
   204  
   205  	{
   206  		op := ravendb.NewGetIndexingStatusOperation()
   207  		err = store.Maintenance().Send(op)
   208  		assert.NoError(t, err)
   209  		indexingStatus := op.Command.Result
   210  		indexStatus := indexingStatus.Indexes[0]
   211  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusPaused)
   212  	}
   213  
   214  	{
   215  		op := ravendb.NewStartIndexingOperation()
   216  		err = store.Maintenance().Send(op)
   217  		assert.NoError(t, err)
   218  	}
   219  
   220  	{
   221  		op := ravendb.NewGetIndexingStatusOperation()
   222  		err = store.Maintenance().Send(op)
   223  		assert.NoError(t, err)
   224  		indexingStatus := op.Command.Result
   225  		indexStatus := indexingStatus.Indexes[0]
   226  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusRunning)
   227  	}
   228  }
   229  
   230  func testIndexCanStopStartIndex(t *testing.T, driver *RavenTestDriver) {
   231  	var err error
   232  	store := driver.getDocumentStoreMust(t)
   233  	defer store.Close()
   234  
   235  	index := NewUsersIndex()
   236  	indexDef := index.CreateIndexDefinition()
   237  	{
   238  		op := ravendb.NewPutIndexesOperation(indexDef)
   239  		err = store.Maintenance().Send(op)
   240  		assert.NoError(t, err)
   241  	}
   242  
   243  	{
   244  		op, err := ravendb.NewStopIndexOperation(indexDef.Name)
   245  		assert.NoError(t, err)
   246  		err = store.Maintenance().Send(op)
   247  		assert.NoError(t, err)
   248  	}
   249  
   250  	{
   251  		op := ravendb.NewGetIndexingStatusOperation()
   252  		err = store.Maintenance().Send(op)
   253  		assert.NoError(t, err)
   254  		indexingStatus := op.Command.Result
   255  		assert.Equal(t, indexingStatus.Status, ravendb.IndexRunningStatusRunning)
   256  		indexStatus := indexingStatus.Indexes[0]
   257  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusPaused)
   258  	}
   259  
   260  	{
   261  		op, err := ravendb.NewStartIndexOperation(indexDef.Name)
   262  		assert.NoError(t, err)
   263  		err = store.Maintenance().Send(op)
   264  		assert.NoError(t, err)
   265  	}
   266  
   267  	{
   268  		op := ravendb.NewGetIndexingStatusOperation()
   269  		err = store.Maintenance().Send(op)
   270  		assert.NoError(t, err)
   271  		indexingStatus := op.Command.Result
   272  		assert.Equal(t, indexingStatus.Status, ravendb.IndexRunningStatusRunning)
   273  		indexStatus := indexingStatus.Indexes[0]
   274  		assert.Equal(t, indexStatus.Status, ravendb.IndexRunningStatusRunning)
   275  	}
   276  }
   277  
   278  func testIndexCanSetIndexLockMode(t *testing.T, driver *RavenTestDriver) {
   279  	var err error
   280  	store := driver.getDocumentStoreMust(t)
   281  	defer store.Close()
   282  
   283  	index := NewUsersIndex()
   284  	indexDef := index.CreateIndexDefinition()
   285  	{
   286  		op := ravendb.NewPutIndexesOperation(indexDef)
   287  		err = store.Maintenance().Send(op)
   288  		assert.NoError(t, err)
   289  	}
   290  
   291  	{
   292  		op, err := ravendb.NewSetIndexesLockOperation(indexDef.Name, ravendb.IndexLockModeLockedError)
   293  		assert.NoError(t, err)
   294  		err = store.Maintenance().Send(op)
   295  		assert.NoError(t, err)
   296  	}
   297  
   298  	{
   299  		op := ravendb.NewGetIndexOperation(indexDef.Name)
   300  		err = store.Maintenance().Send(op)
   301  		assert.NoError(t, err)
   302  		newIndexDef := op.Command.Result
   303  		assert.Equal(t, newIndexDef.LockMode, ravendb.IndexLockModeLockedError)
   304  	}
   305  }
   306  
   307  func testIndexCanSetIndexPriority(t *testing.T, driver *RavenTestDriver) {
   308  	var err error
   309  	store := driver.getDocumentStoreMust(t)
   310  	defer store.Close()
   311  
   312  	index := NewUsersIndex()
   313  	indexDef := index.CreateIndexDefinition()
   314  	op := ravendb.NewPutIndexesOperation(indexDef)
   315  	err = store.Maintenance().Send(op)
   316  	assert.NoError(t, err)
   317  
   318  	op2, err := ravendb.NewSetIndexesPriorityOperation(indexDef.Name, ravendb.IndexPriorityHigh)
   319  	assert.NoError(t, err)
   320  	err = store.Maintenance().Send(op2)
   321  	assert.NoError(t, err)
   322  
   323  	op3 := ravendb.NewGetIndexOperation(indexDef.Name)
   324  	err = store.Maintenance().Send(op3)
   325  	assert.NoError(t, err)
   326  	newIndexDef := op3.Command.Result
   327  	assert.Equal(t, newIndexDef.Priority, ravendb.IndexPriorityHigh)
   328  }
   329  
   330  func testIndexCanListErrors(t *testing.T, driver *RavenTestDriver) {
   331  	var err error
   332  	store := driver.getDocumentStoreMust(t)
   333  	defer store.Close()
   334  
   335  	index := NewUsersInvalidIndex()
   336  	indexDef := index.CreateIndexDefinition()
   337  	op := ravendb.NewPutIndexesOperation(indexDef)
   338  	err = store.Maintenance().Send(op)
   339  	assert.NoError(t, err)
   340  
   341  	{
   342  		session := openSessionMust(t, store)
   343  		user := &User{}
   344  		//user.setName(null)
   345  		user.Age = 0
   346  		err = session.Store(user)
   347  		assert.NoError(t, err)
   348  		err = session.SaveChanges()
   349  		assert.NoError(t, err)
   350  		session.Close()
   351  	}
   352  
   353  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   354  	assert.NoError(t, err)
   355  
   356  	op2 := ravendb.NewGetIndexErrorsOperation(nil)
   357  	err = store.Maintenance().Send(op2)
   358  	assert.NoError(t, err)
   359  	indexErrors := op2.Command.Result
   360  	assert.Equal(t, len(indexErrors), 1)
   361  
   362  	op3 := ravendb.NewGetIndexErrorsOperation([]string{indexDef.Name})
   363  	err = store.Maintenance().Send(op3)
   364  	assert.NoError(t, err)
   365  	perIndexErrors := op3.Command.Result
   366  	assert.Equal(t, len(perIndexErrors), 1)
   367  }
   368  
   369  func testIndexCanGetIndexStatistics(t *testing.T, driver *RavenTestDriver) {
   370  
   371  	var err error
   372  	store := driver.getDocumentStoreMust(t)
   373  	defer store.Close()
   374  
   375  	userIndex := NewUsers_Index()
   376  	err = userIndex.Execute(store, nil, "")
   377  	assert.NoError(t, err)
   378  
   379  	op := ravendb.NewGetIndexesStatisticsOperation()
   380  	err = store.Maintenance().Send(op)
   381  	assert.NoError(t, err)
   382  
   383  	indexStats := op.Command.Result
   384  	assert.Equal(t, len(indexStats), 1)
   385  }
   386  
   387  func TestIndexOperations(t *testing.T) {
   388  	driver := createTestDriver(t)
   389  	destroy := func() { destroyDriver(t, driver) }
   390  	defer recoverTest(t, destroy)
   391  
   392  	// order matches Java tests
   393  	testIndexHasIndexChanged(t, driver)
   394  	testIndexCanListErrors(t, driver)
   395  	testIndexCanGetIndexStatistics(t, driver)
   396  	testIndexCanSetIndexPriority(t, driver)
   397  	testIndexCanDisableAndEnableIndex(t, driver)
   398  	testIndexGetCanIndexes(t, driver)
   399  	testIndexCanDeleteIndex(t, driver)
   400  	testIndexCanStopStartIndexing(t, driver)
   401  	testIndexCanGetIndexStatistics(t, driver)
   402  	testIndexCanStopStartIndex(t, driver)
   403  	testIndexCanSetIndexLockMode(t, driver)
   404  	testIndexGetTerms(t, driver)
   405  }