github.com/ravendb/ravendb-go-client@v0.0.0-20240229102137-4474ee7aa0fa/tests/revisions_subscriptions_test.go (about) 1 package tests 2 3 import ( 4 "fmt" 5 "reflect" 6 "strconv" 7 "sync" 8 "testing" 9 "time" 10 11 ravendb "github.com/ravendb/ravendb-go-client" 12 "github.com/stretchr/testify/assert" 13 ) 14 15 func revisionsSubscriptions_plainRevisionsSubscriptions(t *testing.T, driver *RavenTestDriver) { 16 var err error 17 store := driver.getDocumentStoreMust(t) 18 defer store.Close() 19 20 subscriptionId, err := store.Subscriptions().CreateForRevisions(reflect.TypeOf(&User{}), nil, "") 21 assert.NoError(t, err) 22 23 defaultCollection := &ravendb.RevisionsCollectionConfiguration{ 24 MinimumRevisionsToKeep: 5, 25 } 26 27 usersConfig := &ravendb.RevisionsCollectionConfiguration{} 28 donsConfig := &ravendb.RevisionsCollectionConfiguration{} 29 30 configuration := &ravendb.RevisionsConfiguration{ 31 DefaultConfig: defaultCollection, 32 } 33 perCollectionConfig := map[string]*ravendb.RevisionsCollectionConfiguration{ 34 "Users": usersConfig, 35 "Dons": donsConfig, 36 } 37 38 configuration.Collections = perCollectionConfig 39 40 operation := ravendb.NewConfigureRevisionsOperation(configuration) 41 42 err = store.Maintenance().Send(operation) 43 assert.NoError(t, err) 44 45 for i := 0; i < 10; i++ { 46 for j := 0; j < 10; j++ { 47 { 48 session, err := store.OpenSession("") 49 assert.NoError(t, err) 50 51 user := &User{} 52 user.setName(fmt.Sprintf("users%d ver %d", i, j)) 53 err = session.StoreWithID(user, "users/"+strconv.Itoa(i)) 54 assert.NoError(t, err) 55 56 company := &Company{ 57 Name: fmt.Sprintf("dons%d ver %d", i, j), 58 } 59 err = session.StoreWithID(company, "dons/"+strconv.Itoa(i)) 60 assert.NoError(t, err) 61 62 err = session.SaveChanges() 63 assert.NoError(t, err) 64 65 session.Close() 66 } 67 } 68 } 69 70 { 71 opts := ravendb.NewSubscriptionWorkerOptions(subscriptionId) 72 clazz := reflect.TypeOf(&User{}) 73 sub, err := store.Subscriptions().GetSubscriptionWorkerForRevisions(clazz, opts, "") 74 assert.NoError(t, err) 75 76 mre := make(chan bool, 1) 77 names := map[string]struct{}{} 78 79 results := make(chan *ravendb.SubscriptionBatch, 16) 80 cb := func(batch *ravendb.SubscriptionBatch) error { 81 results <- batch 82 return nil 83 } 84 err = sub.Run(cb) 85 assert.NoError(t, err) 86 select { 87 case batch := <-results: 88 for _, item := range batch.Items { 89 // result is ravendb.Revision of type User 90 var result *ravendb.Revision 91 err := item.GetResult(&result) 92 assert.NoError(t, err) 93 var currName string 94 var prevName string 95 if result.Current != nil { 96 u := result.Current.(*User) 97 currName = *u.Name 98 } 99 if result.Previous != nil { 100 u := result.Previous.(*User) 101 prevName = *u.Name 102 } 103 name := currName + prevName 104 names[name] = struct{}{} 105 if len(names) == 100 { 106 mre <- true 107 } 108 } 109 case <-time.After(_reasonableWaitTime): 110 assert.Fail(t, "timed out waiting for batch") 111 } 112 113 err = sub.Close() 114 assert.NoError(t, err) 115 } 116 } 117 118 func revisionsSubscriptions_plainRevisionsSubscriptionsCompareDocs(t *testing.T, driver *RavenTestDriver) { 119 var err error 120 store := driver.getDocumentStoreMust(t) 121 defer store.Close() 122 123 subscriptionId, err := store.Subscriptions().CreateForRevisions(reflect.TypeOf(&User{}), nil, "") 124 assert.NoError(t, err) 125 126 defaultCollection := &ravendb.RevisionsCollectionConfiguration{ 127 MinimumRevisionsToKeep: 5, 128 } 129 130 usersConfig := &ravendb.RevisionsCollectionConfiguration{} 131 donsConfig := &ravendb.RevisionsCollectionConfiguration{} 132 133 configuration := &ravendb.RevisionsConfiguration{ 134 DefaultConfig: defaultCollection, 135 } 136 perCollectionConfig := map[string]*ravendb.RevisionsCollectionConfiguration{ 137 "Users": usersConfig, 138 "Dons": donsConfig, 139 } 140 141 configuration.Collections = perCollectionConfig 142 143 operation := ravendb.NewConfigureRevisionsOperation(configuration) 144 145 err = store.Maintenance().Send(operation) 146 assert.NoError(t, err) 147 148 for j := 0; j < 10; j++ { 149 { 150 session, err := store.OpenSession("") 151 assert.NoError(t, err) 152 153 user := &User{ 154 Age: j, 155 } 156 user.setName("users1 ver " + strconv.Itoa(j)) 157 err = session.StoreWithID(user, "users/1") 158 assert.NoError(t, err) 159 160 company := &Company{ 161 Name: "dons1 ver " + strconv.Itoa(j), 162 } 163 err = session.StoreWithID(company, "dons/1") 164 assert.NoError(t, err) 165 166 err = session.SaveChanges() 167 assert.NoError(t, err) 168 169 session.Close() 170 } 171 } 172 173 { 174 opts := ravendb.NewSubscriptionWorkerOptions(subscriptionId) 175 clazz := reflect.TypeOf(&User{}) 176 sub, err := store.Subscriptions().GetSubscriptionWorkerForRevisions(clazz, opts, "") 177 assert.NoError(t, err) 178 179 mre := make(chan bool, 1) 180 names := map[string]struct{}{} 181 182 var mu sync.Mutex 183 maxAge := -1 184 185 results := make(chan *ravendb.SubscriptionBatch, 16) 186 cb := func(batch *ravendb.SubscriptionBatch) error { 187 results <- batch 188 return nil 189 } 190 err = sub.Run(cb) 191 192 assert.NoError(t, err) 193 select { 194 case batch := <-results: 195 for _, item := range batch.Items { 196 // result is ravendb.Revision of type User 197 var result *ravendb.Revision 198 err := item.GetResult(&result) 199 assert.NoError(t, err) 200 201 var currName, prevName string 202 currAge := -1 203 prevAge := -1 204 if result.Current != nil { 205 u := result.Current.(*User) 206 currName = *u.Name 207 currAge = u.Age 208 } 209 if result.Previous != nil { 210 u := result.Previous.(*User) 211 prevName = *u.Name 212 prevAge = u.Age 213 } 214 215 mu.Lock() 216 217 if currAge > maxAge && currAge > prevAge { 218 name := currName + " " + prevName 219 names[name] = struct{}{} 220 maxAge = currAge 221 } 222 223 shouldRelease := len(names) == 10 224 mu.Unlock() 225 226 if shouldRelease { 227 mre <- true 228 } 229 } 230 231 case <-time.After(_reasonableWaitTime): 232 assert.Fail(t, "timed out waiting for batch") 233 } 234 235 timedOut := chanWaitTimedOut(mre, _reasonableWaitTime) 236 assert.False(t, timedOut) 237 238 err = sub.Close() 239 assert.NoError(t, err) 240 } 241 } 242 243 func TestRevisionsSubscriptions(t *testing.T) { 244 driver := createTestDriver(t) 245 destroy := func() { destroyDriver(t, driver) } 246 defer recoverTest(t, destroy) 247 248 // matches order of Java tests 249 revisionsSubscriptions_plainRevisionsSubscriptionsCompareDocs(t, driver) 250 revisionsSubscriptions_plainRevisionsSubscriptions(t, driver) 251 }