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

     1  package tests
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  	"time"
     7  
     8  	ravendb "github.com/altipla-consulting/ravendb-go-client"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func bulkInsertsTestSimpleBulkInsertShouldWork(t *testing.T, driver *RavenTestDriver) {
    13  	fooBar1 := &FooBar{}
    14  	fooBar1.Name = "John Doe"
    15  
    16  	fooBar2 := &FooBar{}
    17  	fooBar2.Name = "Jane Doe"
    18  
    19  	fooBar3 := &FooBar{}
    20  	fooBar3.Name = "Mega John"
    21  
    22  	fooBar4 := &FooBar{}
    23  	fooBar4.Name = "Mega Jane"
    24  
    25  	var err error
    26  	store := driver.getDocumentStoreMust(t)
    27  	defer store.Close()
    28  
    29  	{
    30  		bulkInsert := store.BulkInsert("")
    31  
    32  		_, err = bulkInsert.Store(fooBar1, nil)
    33  		assert.NoError(t, err)
    34  
    35  		_, err = bulkInsert.Store(fooBar2, nil)
    36  		assert.NoError(t, err)
    37  
    38  		_, err = bulkInsert.Store(fooBar3, nil)
    39  		assert.NoError(t, err)
    40  
    41  		_, err = bulkInsert.Store(fooBar4, nil)
    42  		assert.NoError(t, err)
    43  
    44  		err = bulkInsert.Close()
    45  		assert.NoError(t, err)
    46  	}
    47  
    48  	{
    49  		session := openSessionMust(t, store)
    50  		var doc1, doc2, doc3, doc4 *FooBar
    51  		err = session.Load(&doc1, "FooBars/1-A")
    52  		assert.NoError(t, err)
    53  		err = session.Load(&doc2, "FooBars/2-A")
    54  		assert.NoError(t, err)
    55  		err = session.Load(&doc3, "FooBars/3-A")
    56  		assert.NoError(t, err)
    57  		err = session.Load(&doc4, "FooBars/4-A")
    58  		assert.NoError(t, err)
    59  
    60  		assert.Equal(t, doc1.Name, "John Doe")
    61  		assert.Equal(t, doc2.Name, "Jane Doe")
    62  		assert.Equal(t, doc3.Name, "Mega John")
    63  		assert.Equal(t, doc4.Name, "Mega Jane")
    64  
    65  		session.Close()
    66  	}
    67  }
    68  
    69  func bulkInsertsTestKilledToEarly(t *testing.T, driver *RavenTestDriver) {
    70  	var err error
    71  	store := driver.getDocumentStoreMust(t)
    72  	defer store.Close()
    73  
    74  	{
    75  		bulkInsert := store.BulkInsert("")
    76  
    77  		_, err = bulkInsert.Store(&FooBar{}, nil)
    78  		assert.NoError(t, err)
    79  		err = bulkInsert.Abort()
    80  		if err == nil {
    81  			_, err = bulkInsert.Store(&FooBar{}, nil)
    82  		}
    83  		if err == nil {
    84  			err = bulkInsert.Close()
    85  		}
    86  
    87  		assert.Error(t, err)
    88  		_, ok := err.(*ravendb.BulkInsertAbortedError)
    89  		assert.True(t, ok, "expected error to be of type ravendb.BulkInsertAbortedError, got type '%T', value: '%s'", err, err)
    90  	}
    91  }
    92  
    93  func bulkInsertsTestShouldNotAcceptIdsEndingWithPipeLine(t *testing.T, driver *RavenTestDriver) {
    94  	var err error
    95  	store := driver.getDocumentStoreMust(t)
    96  	defer store.Close()
    97  
    98  	{
    99  		bulkInsert := store.BulkInsert("")
   100  		err = bulkInsert.StoreWithID(&FooBar{}, "foobars|", nil)
   101  		assert.Error(t, err)
   102  		_, ok := err.(*ravendb.UnsupportedOperationError)
   103  		assert.True(t, ok)
   104  		ok = strings.Contains(err.Error(), "Document ids cannot end with '|', but was called with foobars|")
   105  		assert.True(t, ok)
   106  
   107  		err = bulkInsert.Close()
   108  		assert.NoError(t, err)
   109  	}
   110  }
   111  
   112  func bulkInsertsTestCanModifyMetadataWithBulkInsert(t *testing.T, driver *RavenTestDriver) {
   113  	var err error
   114  	store := driver.getDocumentStoreMust(t)
   115  	defer store.Close()
   116  
   117  	et := time.Now().Add(time.Hour * 24 * 365)
   118  	expirationDate := ravendb.Time(et).Format()
   119  
   120  	{
   121  		bulkInsert := store.BulkInsert("")
   122  
   123  		fooBar := &FooBar{}
   124  		fooBar.Name = "Jon Show"
   125  		metadata := &ravendb.MetadataAsDictionary{}
   126  		metadata.Put(ravendb.MetadataExpires, expirationDate)
   127  
   128  		_, err = bulkInsert.Store(fooBar, metadata)
   129  		assert.NoError(t, err)
   130  
   131  		err = bulkInsert.Close()
   132  		assert.NoError(t, err)
   133  	}
   134  
   135  	{
   136  		session := openSessionMust(t, store)
   137  		var entity *FooBar
   138  		err = session.Load(&entity, "FooBars/1-A")
   139  		assert.NoError(t, err)
   140  
   141  		meta, err := session.Advanced().GetMetadataFor(entity)
   142  		assert.NoError(t, err)
   143  
   144  		metadataExpirationDate, ok := meta.Get(ravendb.MetadataExpires)
   145  		assert.True(t, ok)
   146  		assert.Equal(t, metadataExpirationDate, expirationDate)
   147  	}
   148  }
   149  
   150  type FooBar struct {
   151  	Name string
   152  }
   153  
   154  func TestBulkInserts(t *testing.T) {
   155  	driver := createTestDriver(t)
   156  	destroy := func() { destroyDriver(t, driver) }
   157  	defer recoverTest(t, destroy)
   158  
   159  	// matches order of Java tests
   160  	bulkInsertsTestSimpleBulkInsertShouldWork(t, driver)
   161  	bulkInsertsTestShouldNotAcceptIdsEndingWithPipeLine(t, driver)
   162  	bulkInsertsTestKilledToEarly(t, driver)
   163  	bulkInsertsTestCanModifyMetadataWithBulkInsert(t, driver)
   164  }