-
Notifications
You must be signed in to change notification settings - Fork 820
/
AsyncDocumentStoreServerTests.cs
195 lines (170 loc) · 6.21 KB
/
AsyncDocumentStoreServerTests.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
using Raven.Abstractions.Data;
using Raven.Abstractions.Indexing;
using Raven.Json.Linq;
namespace Raven.Tests.Silverlight
{
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Client.Document;
using Client.Extensions;
using Document;
using Microsoft.Silverlight.Testing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class AsyncDocumentStoreServerTests : RavenTestBase
{
[Asynchronous]
public IEnumerable<Task> Can_insert_async_and_multi_get_async()
{
var dbname = GenerateNewDatabaseName();
var documentStore = new DocumentStore {Url = Url + Port};
documentStore.Initialize();
yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);
var entity1 = new Company {Name = "Async Company #1"};
var entity2 = new Company {Name = "Async Company #2"};
using (var session_for_storing = documentStore.OpenAsyncSession(dbname))
{
session_for_storing.Store(entity1);
session_for_storing.Store(entity2);
yield return session_for_storing.SaveChangesAsync();
}
using (var session_for_loading = documentStore.OpenAsyncSession(dbname))
{
var task = session_for_loading.LoadAsync<Company>(new[] {entity1.Id, entity2.Id});
yield return task;
Assert.AreEqual(entity1.Name, task.Result[0].Name);
Assert.AreEqual(entity2.Name, task.Result[1].Name);
}
}
[Asynchronous]
public IEnumerable<Task> Can_insert_async_and_load_async()
{
var dbname = GenerateNewDatabaseName();
var documentStore = new DocumentStore {Url = Url + Port};
documentStore.Initialize();
yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);
var entity = new Company {Name = "Async Company #1"};
using (var session_for_storing = documentStore.OpenAsyncSession(dbname))
{
session_for_storing.Store(entity);
yield return session_for_storing.SaveChangesAsync();
}
using (var session_for_loading = documentStore.OpenAsyncSession(dbname))
{
var task = session_for_loading.LoadAsync<Company>(entity.Id);
yield return task;
Assert.AreEqual(entity.Name, task.Result.Name);
}
}
[Asynchronous]
public IEnumerable<Task> Can_insert_async_and_delete_async()
{
var dbname = GenerateNewDatabaseName();
var documentStore = new DocumentStore {Url = Url + Port};
documentStore.Initialize();
yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);
var entity = new Company {Name = "Async Company #1", Id = "companies/1"};
using (var session = documentStore.OpenAsyncSession(dbname))
{
session.Store(entity);
yield return session.SaveChangesAsync();
}
using (var for_loading = documentStore.OpenAsyncSession(dbname))
{
var loading = for_loading.LoadAsync<Company>(entity.Id);
yield return loading;
Assert.IsNotNull(loading.Result);
}
using (var for_deleting = documentStore.OpenAsyncSession(dbname))
{
var loading = for_deleting.LoadAsync<Company>(entity.Id);
yield return loading;
for_deleting.Delete(loading.Result);
yield return for_deleting.SaveChangesAsync();
}
using (var for_verifying = documentStore.OpenAsyncSession(dbname))
{
var verification = for_verifying.LoadAsync<Company>(entity.Id);
yield return verification;
Assert.IsNull(verification.Result);
}
}
[Asynchronous]
public IEnumerable<Task> Can_query_by_index()
{
var dbname = GenerateNewDatabaseName();
var documentStore = new DocumentStore {Url = Url + Port};
documentStore.Initialize();
yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);
var entity = new Company {Name = "Async Company #1", Id = "companies/1"};
using (var session = documentStore.OpenAsyncSession(dbname))
{
session.Store(entity);
yield return (session.SaveChangesAsync());
}
var task = documentStore.AsyncDatabaseCommands
.ForDatabase(dbname)
.PutIndexAsync("Test", new IndexDefinition
{
Map =
"from doc in docs.Companies select new { doc.Name }"
}, true);
yield return (task);
Task<QueryResult> query = null;
for (int i = 0; i < 50; i++)
{
query = documentStore.AsyncDatabaseCommands
.ForDatabase(dbname)
.QueryAsync("Test", new IndexQuery(), null);
yield return (query);
if (query.Result.IsStale)
{
yield return Delay(100);
continue;
}
Assert.AreNotEqual(0, query.Result.TotalResults);
yield break;
}
}
[Asynchronous]
public IEnumerable<Task> Can_project_value_from_collection()
{
var dbname = GenerateNewDatabaseName();
var documentStore = new DocumentStore {Url = Url + Port};
documentStore.Initialize();
yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);
using (var session = documentStore.OpenAsyncSession(dbname))
{
session.Store(new Company
{
Name = "Project Value Company",
Contacts = new List<Contact>
{
new Contact {Surname = "Abbot"},
new Contact {Surname = "Costello"}
}
});
yield return session.SaveChangesAsync();
Task<QueryResult> query;
do
{
query = documentStore.AsyncDatabaseCommands
.ForDatabase(dbname)
.QueryAsync("dynamic",
new IndexQuery
{
FieldsToFetch = new[] {"Contacts,Surname"}
},
new string[0]);
yield return query;
if (query.Result.IsStale)
yield return Delay(100);
} while (query.Result.IsStale);
var ravenJToken = (RavenJArray)query.Result.Results[0]["Contacts"];
Assert.AreEqual(2, ravenJToken.Count());
Assert.AreEqual("Abbot", ravenJToken[0].Value<string>("Surname"));
Assert.AreEqual("Costello", ravenJToken[1].Value<string>("Surname"));
}
}
}
}