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

     1  package tests
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  type User5 struct {
    10  	ID        string
    11  	Name      string
    12  	PartnerID string
    13  	Email     string
    14  	Tags      []string
    15  	Age       int
    16  	Active    bool
    17  }
    18  
    19  func cofiCanCacheDocumentWithIncludes(t *testing.T, driver *RavenTestDriver) {
    20  	var err error
    21  	store := driver.getDocumentStoreMust(t)
    22  	defer store.Close()
    23  
    24  	{
    25  		session := openSessionMust(t, store)
    26  
    27  		user := User5{
    28  			Name: "Ayende",
    29  		}
    30  		err = session.Store(&user)
    31  		assert.NoError(t, err)
    32  
    33  		partner := User5{
    34  			PartnerID: "user5s/1-A",
    35  		}
    36  		err = session.Store(&partner)
    37  		assert.NoError(t, err)
    38  
    39  		err = session.SaveChanges()
    40  		assert.NoError(t, err)
    41  
    42  		session.Close()
    43  	}
    44  
    45  	{
    46  		session := openSessionMust(t, store)
    47  		var u *User5
    48  		err = session.Include("PartnerID").Load(&u, "user5s/2-A")
    49  		assert.NoError(t, err)
    50  		assert.NotNil(t, u)
    51  
    52  		// TODO: why SaveChanges() ?
    53  		err = session.SaveChanges()
    54  		assert.NoError(t, err)
    55  
    56  		session.Close()
    57  	}
    58  
    59  	{
    60  		session := openSessionMust(t, store)
    61  
    62  		var u *User5
    63  		err = session.Include("PartnerID").Load(&u, "user5s/2-A")
    64  		assert.NoError(t, err)
    65  		assert.NotNil(t, u)
    66  
    67  		// TODO: make it GetRequestExecutor().GetNumberOfCacheItems()
    68  		// and only available with fortests build tag
    69  		// then hide HttpCache
    70  		cache := session.Advanced().GetRequestExecutor().Cache
    71  		cacheSize := cache.GetNumberOfItems()
    72  		assert.Equal(t, 1, cacheSize)
    73  
    74  		session.Close()
    75  	}
    76  }
    77  
    78  func cofiCanvAoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCacheAsync(t *testing.T, driver *RavenTestDriver) {
    79  	var err error
    80  	store := driver.getDocumentStoreMust(t)
    81  	defer store.Close()
    82  
    83  	{
    84  		session := openSessionMust(t, store)
    85  
    86  		user := User5{
    87  			Name: "Ayende",
    88  		}
    89  		err = session.Store(&user)
    90  		assert.NoError(t, err)
    91  
    92  		partner := User5{
    93  			PartnerID: "user5s/1-A",
    94  		}
    95  		err = session.Store(&partner)
    96  		assert.NoError(t, err)
    97  
    98  		err = session.SaveChanges()
    99  		assert.NoError(t, err)
   100  
   101  		session.Close()
   102  	}
   103  
   104  	{
   105  		session := openSessionMust(t, store)
   106  		var user *User5
   107  		err = session.Load(&user, "user5s/2-A")
   108  		assert.NoError(t, err)
   109  		assert.NotNil(t, user)
   110  
   111  		err = session.Load(&user, user.PartnerID)
   112  		assert.NoError(t, err)
   113  		oldCount := session.Advanced().GetNumberOfRequests()
   114  		assert.NotNil(t, user)
   115  
   116  		var newUser *User5
   117  		err = session.Include("PartnerID").Load(&newUser, "user5s/2-A")
   118  		assert.NoError(t, err)
   119  		assert.NotNil(t, newUser)
   120  
   121  		newCount := session.Advanced().GetNumberOfRequests()
   122  		assert.Equal(t, newCount, oldCount)
   123  
   124  		session.Close()
   125  	}
   126  
   127  }
   128  
   129  func cofiCanAvoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCacheLazy(t *testing.T, driver *RavenTestDriver) {
   130  	var err error
   131  	store := driver.getDocumentStoreMust(t)
   132  	defer store.Close()
   133  
   134  	{
   135  		session := openSessionMust(t, store)
   136  
   137  		user := User5{
   138  			Name: "Ayende",
   139  		}
   140  		err = session.Store(&user)
   141  		assert.NoError(t, err)
   142  
   143  		partner := User5{
   144  			PartnerID: "user5s/1-A",
   145  		}
   146  		err = session.Store(&partner)
   147  		assert.NoError(t, err)
   148  
   149  		err = session.SaveChanges()
   150  		assert.NoError(t, err)
   151  
   152  		session.Close()
   153  	}
   154  
   155  	{
   156  		session := openSessionMust(t, store)
   157  
   158  		advanced := session.Advanced()
   159  		_, err = advanced.Lazily().Load("user5s/2-A")
   160  		assert.NoError(t, err)
   161  		_, err = advanced.Lazily().Load("user5s/1-A")
   162  		assert.NoError(t, err)
   163  
   164  		_, err = advanced.Eagerly().ExecuteAllPendingLazyOperations()
   165  		assert.NoError(t, err)
   166  
   167  		oldCount := advanced.GetNumberOfRequests()
   168  
   169  		resultLazy, err := advanced.Lazily().Include("PartnerId").Load("user5s/2-A")
   170  		assert.NoError(t, err)
   171  		var user *User
   172  		err = resultLazy.GetValue(&user)
   173  		assert.NoError(t, err)
   174  		assert.NotNil(t, user)
   175  		assert.Equal(t, user.ID, "user5s/2-A")
   176  
   177  		newCount := advanced.GetNumberOfRequests()
   178  		assert.Equal(t, newCount, oldCount)
   179  
   180  		session.Close()
   181  	}
   182  }
   183  
   184  func cofiCanAvoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCache(t *testing.T, driver *RavenTestDriver) {
   185  	var err error
   186  	store := driver.getDocumentStoreMust(t)
   187  	defer store.Close()
   188  
   189  	{
   190  		session := openSessionMust(t, store)
   191  
   192  		user := User5{
   193  			Name: "Ayende",
   194  		}
   195  		err = session.Store(&user)
   196  		assert.NoError(t, err)
   197  
   198  		partner := User5{
   199  			PartnerID: "user5s/1-A",
   200  		}
   201  		err = session.Store(&partner)
   202  		assert.NoError(t, err)
   203  
   204  		err = session.SaveChanges()
   205  		assert.NoError(t, err)
   206  
   207  		session.Close()
   208  	}
   209  
   210  	{
   211  		session := openSessionMust(t, store)
   212  
   213  		var user *User5
   214  		err = session.Load(&user, "user5s/2-A")
   215  		assert.NoError(t, err)
   216  
   217  		var partner *User5
   218  		err = session.Load(&partner, user.PartnerID)
   219  		assert.NoError(t, err)
   220  
   221  		oldCount := session.Advanced().GetNumberOfRequests()
   222  
   223  		var res *User5
   224  		err = session.Include("PartnerID").Load(&res, "user5s/2-A")
   225  		assert.NoError(t, err)
   226  
   227  		newCount := session.Advanced().GetNumberOfRequests()
   228  		assert.Equal(t, oldCount, newCount)
   229  
   230  		session.Close()
   231  	}
   232  }
   233  
   234  func cofiCanAvoidUsingServerForMultiloadWithIncludeIfEverythingIsInSessionCache(t *testing.T, driver *RavenTestDriver) {
   235  	var err error
   236  	store := driver.getDocumentStoreMust(t)
   237  	defer store.Close()
   238  
   239  	{
   240  		session := openSessionMust(t, store)
   241  
   242  		names := []string{"Additional", "Ayende", "Michael", "Fitzchak", "Maxim"}
   243  		for _, name := range names {
   244  			user := &User5{
   245  				Name: name,
   246  			}
   247  			err = session.Store(user)
   248  			assert.NoError(t, err)
   249  		}
   250  
   251  		withPartner := &User5{
   252  			PartnerID: "user5s/1-A",
   253  		}
   254  		err = session.Store(withPartner)
   255  		assert.NoError(t, err)
   256  
   257  		err = session.SaveChanges()
   258  		assert.NoError(t, err)
   259  
   260  		session.Close()
   261  	}
   262  
   263  	{
   264  		session := openSessionMust(t, store)
   265  
   266  		var u2, u6 *User5
   267  		err = session.Load(&u2, "user5s/2-A")
   268  		assert.NoError(t, err)
   269  		err = session.Load(&u6, "user5s/6-A")
   270  		assert.NoError(t, err)
   271  
   272  		inp := []string{"user5s/1-A", "user5s/2-A", "user5s/3-A", "user5s/4-A", "user5s/5-A", "user5s/6-A"}
   273  		u4 := make(map[string]*User5)
   274  		err = session.LoadMulti(u4, inp)
   275  		assert.NoError(t, err)
   276  
   277  		var u *User5
   278  		err = session.Load(&u, u6.PartnerID)
   279  		assert.NoError(t, err)
   280  
   281  		oldCount := session.Advanced().GetNumberOfRequests()
   282  
   283  		res := make(map[string]*User5)
   284  		ids := []string{"user5s/2-A", "user5s/3-A", "user5s/6-A"}
   285  		err = session.Include("PartnerID").LoadMulti(res, ids)
   286  		assert.NoError(t, err)
   287  
   288  		newCount := session.Advanced().GetNumberOfRequests()
   289  		assert.Equal(t, oldCount, newCount)
   290  
   291  		session.Close()
   292  	}
   293  }
   294  
   295  func TestCachingOfDocumentInclude(t *testing.T) {
   296  	driver := createTestDriver(t)
   297  	destroy := func() { destroyDriver(t, driver) }
   298  	defer recoverTest(t, destroy)
   299  
   300  	// matches order of Java tests
   301  	cofiCanAvoidUsingServerForMultiloadWithIncludeIfEverythingIsInSessionCache(t, driver)
   302  	cofiCanAvoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCacheLazy(t, driver)
   303  	cofiCanCacheDocumentWithIncludes(t, driver)
   304  	cofiCanvAoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCacheAsync(t, driver)
   305  	cofiCanAvoidUsingServerForLoadWithIncludeIfEverythingIsInSessionCache(t, driver)
   306  }