public void client_should_be_able_to_call_server_over_http_with_as()
{
var store = new PecanDocumentStore(
"PecanDBTest",
new DatabaseOptions(true)
{
RunAsServerWithAddress = "http://localhost:8018/",
UseRemoteServerAdrressForClientRequests = "http://localhost:8018/"
});
string orderId;
using (ISession session = store.OpenSession())
{
orderId = session.Save(
new Order
{
Id = "yo be",
Name = "wooo"
});
}
using (ISession session = store.OpenSession())
{
var order = session.LoadAs <Order>(orderId);
Assert.AreEqual(order.Id, "yo be");
}
using (ISession session = store.OpenSession())
{
var order = session.LoadAs <OrderIsh>(orderId);
Assert.AreEqual(order.Id, "yo be");
}
}
public void it_should_perform_basic_operations2()
{
int total = 1000;
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(true));
ISession session = store.OpenSession();
Task task = Task.Run(
() =>
{
foreach (int i1 in Enumerable.Range(0, total))
{
List <Order> result = session.Query <Order>(all => from every in all select every).ToList();
}
});
foreach (int i1 in Enumerable.Range(0, total))
{
string orderId = session.Save(
new Order
{
Name = "wooo"
});
var order = session.Load <Order>(orderId);
session.SaveChanges(true);
}
// task.Wait();
}
private static void CleanDB <T>(PecanDocumentStore store, string DocumentName)
{
using (ISession session = store.OpenSession())
{
foreach (PecanDocument <T> x in session.QueryDocument <T>(x => x, DocumentName))
{
try
{
session.DeleteForever <T>(x.Id, DocumentName);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
foreach (PecanDocument <T> x in session.QueryDocument <T>(x => x))
{
try
{
session.DeleteForever <T>(x.Id);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
public void buggy_using_single_file()
{
var store = new PecanDocumentStore(
"PecanDBTest",
new DatabaseOptions(true)
{
//no ready yet
//UseSingleFile = true
});
ISession session = store.OpenSession();
foreach (int i1 in Enumerable.Range(0, 100))
{
string orderId = session.Save(
new Order
{
Id = "yo be",
Name = "wooo"
});
var order = session.Load <Order>(orderId);
Assert.AreEqual(order.Name, "wooo");
order.Name = "sam";
session.SaveChanges(true);
var order2 = session.Load <Order>(orderId);
Assert.AreEqual(order2.Name, "sam");
order2.Name = "sowhat";
Assert.AreEqual(order2.Name, order.Name);
List <Order> result = session.Query <Order>(all => from every in all select every).ToList();
}
}
public void TestMethod1()
{
var store = new PecanDocumentStore(
"PecanDB",
false,
new DatabaseOptions
{
PrettifyDocuments = true,
EnableCaching = true
});
ISession session = store.OpenSession();
/*
* var total = 10000;
* foreach (int i in Enumerable.Range(0, total))
* {
* string id = session.StoreAndSave(new Order()
* {
* Id = "orders/1000",
* Name = "who" + i
* });
* }
* Parallel.For(1, total, i=> session.StoreAndSave(new Order()
* {
* Id = "orders/1000",
* Name = "who" + i
* }));
*/
session.Save(
new Order
{
Id = "orders/1000",
Name = "who"
});
Parallel.For(
1,
10,
i =>
{
List <Order> ordsw3 = session.Query <Order>(orders => from order in orders select order).Take(2).ToList();
List <Order> ordsw = session.Query <Order>(orders => from order in orders select order).ToList();
IEnumerable <Order> ords = session.Query <Order>(orders => from order in orders select order);
List <Order> ord2 = session.Search <Order>(s => s.Contains("was10000")).ToList();
List <Order> ord3 = session.Search <Order>(s => s.Contains("was100")).ToList();
List <Order> ord4 = session.Search <Order>(s => s.Contains("w")).ToList();
});
Parallel.For(
1,
100,
i =>
{
List <Order> ordsw = session.Query <Order>(orders => from order in orders select order).ToList();
});
}
private static void CheckThatPecanCanSaveAndRetrieveSimpleData <T>(T data, T updateData)
{
CheckThatPecanCanSaveAndRetrieveSimpleDataWithPredefinedId(data, updateData);
string DocumentName = Guid.NewGuid().ToString();
using (var store = new PecanDocumentStore(
"TestDB2",
new DatabaseOptions
//using (var store = new DocumentStoreInMemory(new DatabaseOptions()
{
MaxResponseTime = TimeSpan.FromMinutes(10)
}))
{
CleanDB <T>(store, DocumentName);
string id;
string id2;
using (ISession session = store.OpenSession())
{
id = session.Save(DocumentName, data);
id2 = session.Save(data);
}
T savedData;
T savedData2;
using (ISession session = store.OpenSession())
{
try
{
savedData = session.Load <T>(id);
Assert.Fail();
}
catch (Exception e)
{
}
savedData2 = session.Load <T>(id2);
}
AssertAreExactlyEqualByValue(data, savedData2);
using (ISession session = store.OpenSession())
{
try
{
savedData = session.Load <T>(id2);
Assert.Fail();
}
catch (Exception e)
{
}
savedData = session.Load <T>(id, DocumentName);
}
AssertAreExactlyEqualByValue(data, savedData);
//todo fix why save changes doesnt work when load document and doc is replaced
}
}
// [TestMethod]
public void delete()
{
using (var store = new PecanDocumentStore("tester", null))
{
string lastId = "";
using (ISession session = store.OpenSession())
{
List <FilesStorage> t = session.SearchFiles(s => s.Contains("me")).ToList();
string m = session.SaveFile(@"C:\Users\Sa\Desktop\discard\www.saptarang.org\premium\html\onevent\img\icons\me.jpg");
}
}
}
public void dynamic_test()
{
new List <bool>
{
true,
false
}.ForEach(
cache =>
{
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(cache));
ISession session = store.OpenSession();
foreach (int i1 in Enumerable.Range(0, 10))
{
string orderId = session.Save(
new
{
Id = "yo be",
Name = i1
});
string orderId2 = session.Save(
new object());
dynamic order = null;
TestHelperMethods.AssertAwait(
() =>
{
order = session.Load <dynamic>(orderId);
Assert.AreEqual(order.Name.ToString(), i1.ToString());
Order oo = session.LoadAs <dynamic, Order>(orderId);
Assert.AreEqual(oo.Name, i1.ToString());
Order oo2 = session.LoadAs <dynamic, Order>(orderId2);
var oo3 = session.LoadAs <Order>(orderId2);
dynamic oo4 = session.Load(orderId2);
});
order.Name = "sam";
session.SaveChanges(true);
var o = session.Load <object>(orderId);
dynamic order2 = o;
Assert.AreEqual(order2.Name.ToString(), "sam");
order2.Name = "sowhat";
Assert.AreEqual(order2.Name.ToString(), order.Name.ToString());
List <dynamic> result = session.Query <object>(all => from every in all select every).ToList();
}
});
}
public void load_type_as_another_type()
{
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(true));
ISession session = store.OpenSession();
foreach (int i1 in Enumerable.Range(0, 100))
{
string orderId = session.Save(
new Order
{
Id = "yo be",
Name = "wooo"
});
var order = session.Load <Order>(orderId);
OrderNew order2 = session.LoadAs <Order, OrderNew>(orderId);
Assert.AreEqual(order.Name, order2.Name);
}
}
public void savechanges()
{
var store = new PecanDocumentStore(
"PecanDB",
false,
new DatabaseOptions
{
PrettifyDocuments = true,
EnableCaching = true,
MaxResponseTime = TimeSpan.FromMinutes(1)
});
ISession session = store.OpenSession();
foreach (PecanDocument <Order> order in session.QueryDocument <Order>(orders => from order in orders select order))
{
session.DeleteForever <Order>(order.Id);
}
string t = session.Save(
new Order
{
Id = "yo be",
Name = "wooo"
});
var m = session.Load <Order>(t);
m.Name = "sam";
session.SaveChanges(true);
var m1 = store.OpenSession().Load <Order>(t);
Assert.AreEqual("sam", m1.Name);
m.Name = "sa";
session.SaveChanges();
var m2 = session.Load <Order>(t);
Assert.AreEqual("sa", m2.Name);
foreach (PecanDocument <Order> order in session.QueryDocument <Order>(orders => from order in orders select order))
{
session.DeleteForever <Order>(order.Id);
}
}
public PecanDbWebApiService()
{
ServicePointManager.MaxServicePointIdleTime = Timeout.Infinite;
var path = "PecanDBRemoteServer";
try
{
this.store = new PecanDocumentStore(path,
false,
new DatabaseOptions
{
DontWaitForWritesOnCreate = true
});
}
catch (Exception e)
{
throw new Exception(path, e);
}
}
public void it_should_save_dynamic_and_load_json2()
{
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(true));
ISession session = store.OpenSession();
foreach (int i1 in Enumerable.Range(0, 100))
{
string orderId = session.Save(
new Order
{
Id = "yo be",
Name = "wooo"
});
var order = session.Load <Order>(orderId);
Assert.AreEqual(order.Name, "wooo");
string orderJson = JsonConvert.SerializeObject(JsonConvert.DeserializeObject <PecanDocument <Order> >(session.LoadRawDocument <Order>(orderId)).DocumentEntity);
string orderJsonExisting = JsonConvert.SerializeObject(order);
Assert.AreEqual(orderJsonExisting, orderJson);
}
}
public void canUseNewStorageName()
{
var st = new PecanDocumentStore("tester", new DatabaseOptions()
{
StorageName = "tsn_" + Guid.NewGuid().ToString()
});
using (var store = st)
{
string lastId = "";
using (ISession session = store.OpenSession())
{
session.Save(new Order(), "tsn");
}
}
using (var store = st)
{
string lastId = "";
using (ISession session = store.OpenSession())
{
session.Load <Order>("tsn");
}
}
using (var store = st)
{
string lastId = "";
using (ISession session = store.OpenSession())
{
try
{
session.Load <Order>("tsn");
Assert.Fail();
}
catch (Exception e)
{
}
}
}
}
public void performance1()
{
var store = new PecanDocumentStore(
"PecanDB",
false,
new DatabaseOptions
{
PrettifyDocuments = true,
EnableCaching = true
});
ISession session = store.OpenSession();
foreach (PecanDocument <Order> order in session.QueryDocument <Order>(orders => from order in orders select order))
{
session.DeleteForever <Order>(order.Id);
}
Parallel.For(
1,
100,
i => session.Save(
new Order
{
Id = "orders/1000",
Name = "who"
}));
Parallel.For(
1,
100,
i =>
{
List <Order> ordsw = session.Query <Order>(orders => from order in orders select order).ToList();
});
foreach (PecanDocument <Order> order in session.QueryDocument <Order>(orders => from order in orders select order))
{
session.DeleteForever <Order>(order.Id);
}
}
public void create_multiple_ids()
{
var logger = new DefaultPecanLogger(false); // new DefaultPecanLogger( true,"D:\\!MUST_TRASH.txt",null, TimeSpan.FromSeconds(30));
new List <bool>
{
true,
false
}.ForEach(
cache =>
{
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(cache)
{
Logger = logger
});
ISession session = store.OpenSession();
foreach (int i1 in Enumerable.Range(0, 10))
{
logger.Trace($"Test {i1}", $"ON {i1} ord1");
string orderId1 = session.Save(
"doc1",
new
{
Id = "yo be",
Name = "doc1"
});
logger.Trace($"Test {i1}", $"ON {i1} ord2");
string orderId2 = session.Save(
"doc2",
new
{
Id = "yo be",
Name = "doc2"
});
logger.Trace($"Test {i1}", $"ON {i1} DONE");
}
});
}
public void dynamic_document_test()
{
var store = new PecanDocumentStore("PecanDBTest", new DatabaseOptions(true));
ISession session = store.OpenSession();
string orderId1 = session.Save(
"doc1",
new
{
Id = "yo be",
Name = "doc1"
});
string orderId2 = session.Save(
"doc2",
new
{
Id = "yo be",
Name = "doc2"
});
TestHelperMethods.AssertAwait(
() =>
{
var order1 = session.Load <dynamic>(orderId1, "doc1");
Assert.AreEqual(order1.Name.ToString(), "doc1");
var order2 = session.Load <dynamic>(orderId2, "doc2");
Assert.AreEqual(order2.Name.ToString(), "doc2");
dynamic order11 = session.Load(orderId1, "doc1");
Assert.AreEqual(order11.Name.ToString(), "doc1");
dynamic order22 = session.Load(orderId2, "doc2");
Assert.AreEqual(order22.Name.ToString(), "doc2");
try
{
var order5 = session.Load <dynamic>(orderId1);
Assert.Fail();
}
catch (Exception e)
{
}
try
{
var order6 = session.Load <dynamic>(orderId2);
Assert.Fail();
}
catch (Exception e)
{
}
try
{
dynamic order7 = session.Load(orderId1);
Assert.Fail();
}
catch (Exception e)
{
}
try
{
dynamic order8 = session.Load(orderId2);
Assert.Fail();
}
catch (Exception e)
{
}
try
{
var order3 = session.Load <dynamic>(orderId1, "doc2");
Assert.Fail();
}
catch (Exception e)
{
}
try
{
var order4 = session.Load <dynamic>(orderId2, "doc1");
Assert.Fail();
}
catch (Exception e)
{
}
}
);
}
public void RunPerformanceTest <T>(bool isParallel, string description, Func <int, ISession, Action> opearation)
{
new List <bool>
{
true,
false
}.ForEach(
dontWaitForWritesOnCreate =>
{
for (int j = 0; j < this.numberOfSamples; j++)
{
var store = new PecanDocumentStore(
"PecanDB",
false,
new DatabaseOptions
{
EnableCaching = false,
DontWaitForWritesOnCreate = dontWaitForWritesOnCreate
});
ISession session = store.OpenSession();
try
{
foreach (PecanDocument <T> order in session.QueryDocument <T>(orders => from order in orders select order))
{
session.DeleteForever <T>(order.Id);
}
}
catch (Exception e)
{
}
// Create new stopwatch
var stopwatch = new Stopwatch();
var validationOperations = new ConcurrentQueue <Action>();
// Begin timing
stopwatch.Start();
if (isParallel)
{
Parallel.For(1, this.total, i => validationOperations.Enqueue(opearation(i, session)));
}
else
{
foreach (int i in Enumerable.Range(0, this.total))
{
validationOperations.Enqueue(opearation(i, session));
}
}
// Stop timing
stopwatch.Stop();
Console.Write($"{j} {(dontWaitForWritesOnCreate ? "" : "DONT WAIT FOR CREATE")} - Time elapsed: {stopwatch.Elapsed.TotalMilliseconds}ms : {description} with {this.total} iteration - RATE {this.total / (stopwatch.Elapsed.TotalMilliseconds / 1000)} op/sec");
var validationStopwatch = new Stopwatch();
validationStopwatch.Start();
Action validationOperation;
while (validationOperations.TryDequeue(out validationOperation))
{
if (validationOperation != null)
{
TestHelperMethods.AssertAwait(validationOperation);
}
}
validationStopwatch.Stop();
Console.WriteLine($"VALIDATION TIMING elapsed: {validationStopwatch.Elapsed.TotalMilliseconds}ms ");
try
{
foreach (PecanDocument <T> order in session.QueryDocument <T>(orders => from order in orders select order))
{
session.DeleteForever <T>(order.Id);
}
}
catch (Exception)
{
}
}
});
}
private static void RunTest(bool enableCaching, Order data, bool useInMemoryStorage)
{
if (data == null)
{
return;
}
var store = new PecanDocumentStore(
Guid.NewGuid().ToString(),
useInMemoryStorage,
new DatabaseOptions(enableCaching)
);
Order loadedData;
Order queriedData;
Order searchedData;
Order queriedDocumentData;
Order deletedData;
string id;
using (ISession session = store.OpenSession())
{
id = session.Save(data);
Thread.Sleep(1000);
}
using (ISession session = store.OpenSession())
{
loadedData = session.Load <Order>(id);
}
using (ISession session = store.OpenSession())
{
queriedData = session.Query <Order>(orders => from order in orders where order.Name == data.Name select order).First();
}
using (ISession session = store.OpenSession())
{
searchedData = session.Search <Order>(search => search == data.Name).First();
}
using (ISession session = store.OpenSession())
{
queriedDocumentData = session.QueryDocument <Order>(documents => from document in documents where document.Id == id select document).First().DocumentEntity;
}
Order modifiedData;
using (ISession session = store.OpenSession())
{
modifiedData = session.Load <Order>(id);
//modify order id
modifiedData.Id = Guid.NewGuid().ToString();
session.SaveChanges();
}
using (ISession session = store.OpenSession())
{
Order result = session.Query <Order>(orders => from order in orders where order.Id == modifiedData.Id select order).First();
Assert.AreEqual(modifiedData.Id, result.Id, "Unable to modify order id");
var ord = session.Load <Order>(id);
//swithc id back
ord.Id = data.Id;
session.SaveChanges();
loadedData = session.Load <Order>(id);
}
string jsonData = JsonConvert.SerializeObject(data);
string jsonLoadedData = JsonConvert.SerializeObject(loadedData);
string jsonQueriedData = JsonConvert.SerializeObject(queriedData);
string jsonSearchedData = JsonConvert.SerializeObject(searchedData);
string jsonQueriedDocumentData = JsonConvert.SerializeObject(queriedDocumentData);
using (ISession session = store.OpenSession())
{
session.Delete <Order>(id);
}
using (ISession session = store.OpenSession())
{
try
{
session.Load <Order>(id);
Assert.Fail("tried to load a deleted data");
}
catch (Exception e)
{
}
}
//System.Threading.Thread.Sleep(500);
using (ISession session = store.OpenSession())
{
deletedData = session.Load <Order>(id, null, true);
}
string jsonDeletedData = JsonConvert.SerializeObject(deletedData);
using (ISession session = store.OpenSession())
{
session.DeleteForever <Order>(id);
}
using (ISession session = store.OpenSession())
{
try
{
session.Load <Order>(id, null, true);
Assert.Fail("tried to load data already deleted forever");
}
catch (Exception e)
{
}
}
int count = 0;
while (true)
{
try
{
Assert.AreEqual(jsonData, jsonLoadedData, "original data");
Assert.AreEqual(jsonData, jsonQueriedData, "query data");
Assert.AreEqual(jsonData, jsonSearchedData, "search");
Assert.AreEqual(jsonData, jsonQueriedDocumentData, "query document");
//Assert.AreEqual(jsonData, jsonDeletedData,"deleted");
break;
}
catch (Exception e)
{
count++;
Thread.Sleep(300);
if (count > 10)
{
throw e;
}
}
}
}