public void Should_replace_function()
{
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
var registerResult = db.Function.Register(
"myfunctions::temperature::celsiustofahrenheit",
"function (celsius) { return celsius * 1.8 + 40; }"
);
Assert.AreEqual(201, registerResult.StatusCode);
Assert.IsTrue(registerResult.Success);
Assert.IsTrue(registerResult.HasValue);
Assert.IsTrue(registerResult.Value);
var replaceResult = db.Function.Register(
"myfunctions::temperature::celsiustofahrenheit",
"function (celsius) { return celsius * 1.8 + 32; }"
);
Assert.AreEqual(200, replaceResult.StatusCode);
Assert.IsTrue(replaceResult.Success);
Assert.IsTrue(replaceResult.HasValue);
Assert.IsTrue(replaceResult.Value);
const int celsius = 30;
const float fahrenheit = celsius * 1.8f + 32;
var queryResult = db.Query
.BindVar("celsius", celsius)
.Aql("return myfunctions::temperature::celsiustofahrenheit(@celsius)")
.ToList();
Assert.AreEqual(fahrenheit, Convert.ToSingle(queryResult.Value.First()));
}
public void Should_update_document_with_generic_object()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var dummy = new Dummy();
dummy.Foo = "some other new string";
dummy.Bar = 54321;
dummy.Baz = 12345;
var updateResult = db.Document
.Update(documents[0].String("_id"), dummy);
Assert.AreEqual(202, updateResult.StatusCode);
Assert.IsTrue(updateResult.Success);
Assert.IsTrue(updateResult.HasValue);
Assert.AreEqual(updateResult.Value.String("_id"), documents[0].String("_id"));
Assert.AreEqual(updateResult.Value.String("_key"), documents[0].String("_key"));
Assert.AreNotEqual(updateResult.Value.String("_rev"), documents[0].String("_rev"));
var getResult = db.Document
.Get(updateResult.Value.String("_id"));
Assert.AreEqual(getResult.Value.String("_id"), updateResult.Value.String("_id"));
Assert.AreEqual(getResult.Value.String("_key"), updateResult.Value.String("_key"));
Assert.AreEqual(getResult.Value.String("_rev"), updateResult.Value.String("_rev"));
Assert.AreNotEqual(getResult.Value.String("foo"), documents[0].String("foo"));
Assert.AreEqual(getResult.Value.String("foo"), dummy.Foo);
Assert.AreNotEqual(getResult.Value.Int("bar"), documents[0].Int("bar"));
Assert.AreEqual(getResult.Value.Int("bar"), dummy.Bar);
Assert.AreEqual(getResult.Value.Int("baz"), dummy.Baz);
}
public void Should_list_functions()
{
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
const string name1 = "myfunctions::temperature::celsiustofahrenheit1";
const string code1 = "function (celsius) { return celsius * 1.8 + 40; }";
var registerResult1 = db.Function.Register(name1, code1);
Assert.AreEqual(true, registerResult1.Success);
const string name2 = "myfunctions::temperature::celsiustofahrenheit2";
const string code2 = "function (celsius) { return celsius * 1.8 + 32; }";
var registerResult2 = db.Function.Register(name2, code2);
Assert.AreEqual(true, registerResult2.Success);
var listResult = db.Function.List();
Assert.AreEqual(200, listResult.StatusCode);
Assert.IsTrue(listResult.Success);
Assert.IsTrue(listResult.HasValue);
Assert.AreEqual(2, listResult.Value.Count);
Assert.AreEqual(name1, listResult.Value[0].String("name"));
Assert.AreEqual(code1, listResult.Value[0].String("code"));
Assert.AreEqual(name2, listResult.Value[1].String("name"));
Assert.AreEqual(code2, listResult.Value[1].String("code"));
}
public void Should_create_hash_index()
{
Database.CreateTestCollection(Database.TestDocumentCollectionName, ACollectionType.Document);
var db = new ADatabase(Database.Alias);
var createResult = db.Index
.Type(AIndexType.Hash)
.Unique(true)
.Fields("foo", "bar")
.Create(Database.TestDocumentCollectionName);
Assert.AreEqual(201, createResult.StatusCode);
Assert.IsTrue(createResult.Success);
Assert.IsTrue(createResult.HasValue);
Assert.IsTrue(createResult.Value.IsID("id"));
Assert.AreEqual(AIndexType.Hash, createResult.Value.Enum <AIndexType>("type"));
Assert.IsTrue(createResult.Value.Bool("unique"));
Assert.IsFalse(createResult.Value.Bool("sparse"));
Assert.AreEqual(1, createResult.Value.Int("selectivityEstimate"));
Assert.AreEqual(2, createResult.Value.Size("fields"));
new List <string> {
"foo", "bar"
}.ForEach(field => Assert.IsTrue(createResult.Value.List <string>("fields").Contains(field)));
Assert.IsTrue(createResult.Value.Bool("isNewlyCreated"));
}
public void Should_update_document_with_ifMatch_and_lastUpdatePolicy()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var document = new Dictionary <string, object>()
.String("foo", "some other new string")
.Int("bar", 54321)
.Int("baz", 12345);
var updateResult = db.Document
.IfMatch("123456789", AUpdatePolicy.Last)
.Update(documents[0].String("_id"), document);
Assert.AreEqual(202, updateResult.StatusCode);
Assert.IsTrue(updateResult.Success);
Assert.IsTrue(updateResult.HasValue);
Assert.AreEqual(updateResult.Value.String("_id"), documents[0].String("_id"));
Assert.AreEqual(updateResult.Value.String("_key"), documents[0].String("_key"));
Assert.AreNotEqual(updateResult.Value.String("_rev"), documents[0].String("_rev"));
var getResult = db.Document
.Get(updateResult.Value.String("_id"));
Assert.AreEqual(getResult.Value.String("_id"), updateResult.Value.String("_id"));
Assert.AreEqual(getResult.Value.String("_key"), updateResult.Value.String("_key"));
Assert.AreEqual(getResult.Value.String("_rev"), updateResult.Value.String("_rev"));
Assert.AreNotEqual(getResult.Value.String("foo"), documents[0].String("foo"));
Assert.AreEqual(getResult.Value.String("foo"), document.String("foo"));
Assert.AreNotEqual(getResult.Value.Int("bar"), documents[0].Int("bar"));
Assert.AreEqual(getResult.Value.Int("bar"), document.Int("bar"));
Assert.AreEqual(getResult.Value.Int("baz"), document.Int("baz"));
}
public void Should_execute_AQL_query_fluent()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var useCount = true;
var useBatchSize = true;
var queryOperation = db.Query
.Aql(string.Format(@"
FOR item IN {0}
RETURN item
", Database.TestDocumentCollectionName));
if (useCount)
{
queryOperation.Count(true);
}
if (useBatchSize)
{
queryOperation.BatchSize(1);
}
var queryResult = queryOperation.ToList <object>();
Assert.AreEqual(200, queryResult.StatusCode);
Assert.IsTrue(queryResult.Success);
Assert.IsTrue(queryResult.HasValue);
Assert.AreEqual(queryResult.Value.Count, 2);
Assert.AreEqual(queryResult.Extra.Long("count"), 2);
}
public void Should_execute_AQL_query_with_batchSize()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var doc3 = new Dictionary <string, object>()
.String("foo", "foo string 3");
db.Document
.Create(Database.TestDocumentCollectionName, doc3);
var doc4 = new Dictionary <string, object>()
.String("foo", "foo string 4");
db.Document
.Create(Database.TestDocumentCollectionName, doc4);
var queryResult = db.Query
.BatchSize(1)
.Aql(string.Format(@"
FOR item IN {0}
RETURN item
", Database.TestDocumentCollectionName))
.ToList <object>();
Assert.AreEqual(200, queryResult.StatusCode);
Assert.IsTrue(queryResult.Success);
Assert.IsTrue(queryResult.HasValue);
Assert.AreEqual(queryResult.Value.Count, 4);
}
public void Should_execute_transaction_with_single_value_parameter_and_return_document_ID()
{
Database.ClearTestCollection(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var transactionResult = db.Transaction
.WriteCollection(Database.TestDocumentCollectionName)
.Param("data", "some string value")
.Execute <string>(@"
function (params) {
var db = require('internal').db;
return db." + Database.TestDocumentCollectionName + @".save({ foo: params.data })._id;
}
");
Assert.AreEqual(200, transactionResult.StatusCode);
Assert.IsTrue(transactionResult.Success);
Assert.IsTrue(transactionResult.HasValue);
Assert.IsFalse(string.IsNullOrEmpty(transactionResult.Value));
var docId = transactionResult.Value;
var getResult = db.Document
.Get(docId);
Assert.AreEqual(200, getResult.StatusCode);
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
Assert.AreEqual(getResult.Value.ID(), docId);
}
protected async Task <List <Dictionary <string, object> > > InsertTestData(ADatabase db)
{
var collection = db.GetCollection <Dictionary <string, object> >(TestDocumentCollectionName);
var documents = new List <Dictionary <string, object> >();
var document1 = new Dictionary <string, object>();
document1.Add("Foo", "string value one");
document1.Add("Bar", 1);
var document2 = new Dictionary <string, object>();
document2.Add("Foo", "string value two");
document2.Add("Bar", 2);
var createResult1 = await collection.Insert().ReturnNew().Document(document1);
var createResult2 = await collection.Insert().ReturnNew().Document(document2);
documents.Add(createResult1.Value);
documents.Add(createResult2.Value);
return(documents);
}
public void Should_change_collection_properties()
{
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Create(Database.TestDocumentCollectionName);
const long journalSize = 199999999;
var operationResult = db.Collection
.WaitForSync(true)
.JournalSize(journalSize)
.ChangeProperties(createResult.Value.String("name"));
Assert.AreEqual(200, operationResult.StatusCode);
Assert.IsTrue(operationResult.Success);
Assert.IsTrue(operationResult.HasValue);
Assert.AreEqual(createResult.Value.String("id"), operationResult.Value.String("id"));
Assert.AreEqual(createResult.Value.String("name"), operationResult.Value.String("name"));
Assert.AreEqual(createResult.Value.Bool("isSystem"), operationResult.Value.Bool("isSystem"));
Assert.AreEqual(createResult.Value.Int("status"), operationResult.Value.Int("status"));
Assert.AreEqual(createResult.Value.Int("type"), operationResult.Value.Int("type"));
Assert.IsFalse(operationResult.Value.Bool("isVolatile"));
Assert.IsTrue(operationResult.Value.Bool("doCompact"));
Assert.AreEqual(AKeyGeneratorType.Traditional, operationResult.Value.Enum <AKeyGeneratorType>("keyOptions.type"));
Assert.IsTrue(operationResult.Value.Bool("keyOptions.allowUserKeys"));
Assert.IsTrue(operationResult.Value.Bool("waitForSync"));
Assert.IsTrue(operationResult.Value.Long("journalSize") == journalSize);
}
public void TestSimpleSequentialHttpPostRequests(int iterationCount)
{
Console.WriteLine("Operation start: TestSimpleSequentialHttpPostRequests\n");
var db = new ADatabase(Database.Alias);
//ServicePointManager.DefaultConnectionLimit = 40;
//ServicePointManager.Expect100Continue = false;
//ServicePointManager.UseNagleAlgorithm = false;
ExecuteTimedTest(iterationCount, () => {
var entity = new PerformanceEntity();
entity.Id = "1234567890123456789012345678901234";
entity.Key = "1234567";
entity.Revision = "1234567";
entity.Name = "Mohamad Abu Bakar";
entity.IcNumber = "1234567-12-3444";
entity.Department = "IT Department";
entity.Height = 1234;
entity.DateOfBirth = new DateTime(2015, 1, 27, 3, 33, 3);
entity.Salary = 3333;
var jsonEntity = JSON.ToJSON(entity);
var response = SimpleHttpPostCreateDocument(
"http://localhost:8529/_db/" + Database.TestDatabaseGeneral + "/_api/document?collection=" + Database.TestDocumentCollectionName,
jsonEntity
);
var deserializedResponse = JSON.ToObject <Dictionary <string, object> >(response);
});
Console.WriteLine("\nOperation end: TestSimpleSequentialHttpPostRequests");
}
public void Should_replace_document_with_ifMatch()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var document = new Dictionary <string, object>()
.String("foo", "some other new string")
.Int("baz", 54321);
var replaceResult = db.Document
.IfMatch(documents[0].Rev())
.Replace(documents[0].ID(), document);
Assert.AreEqual(202, replaceResult.StatusCode);
Assert.IsTrue(replaceResult.Success);
Assert.IsTrue(replaceResult.HasValue);
Assert.AreEqual(replaceResult.Value.ID(), documents[0].ID());
Assert.AreEqual(replaceResult.Value.Key(), documents[0].Key());
Assert.AreNotEqual(replaceResult.Value.Rev(), documents[0].Rev());
var getResult = db.Document
.Get(replaceResult.Value.ID());
Assert.AreEqual(getResult.Value.ID(), replaceResult.Value.ID());
Assert.AreEqual(getResult.Value.Key(), replaceResult.Value.Key());
Assert.AreEqual(getResult.Value.Rev(), replaceResult.Value.Rev());
Assert.AreNotEqual(getResult.Value.String("foo"), documents[0].String("foo"));
Assert.AreEqual(getResult.Value.String("foo"), document.String("foo"));
Assert.AreEqual(getResult.Value.Int("baz"), document.Int("baz"));
Assert.IsFalse(getResult.Value.Has("bar"));
}
public void Should_create_document_from_generic_object()
{
Database.ClearTestCollection(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var dummy = new Dummy();
dummy.Foo = "foo string value";
dummy.Bar = 12345;
var createResult = db.Document
.Create(Database.TestDocumentCollectionName, dummy);
Assert.AreEqual(202, createResult.StatusCode);
Assert.IsTrue(createResult.Success);
Assert.IsTrue(createResult.HasValue);
Assert.IsTrue(createResult.Value.IsString("_id"));
Assert.IsTrue(createResult.Value.IsString("_key"));
Assert.IsTrue(createResult.Value.IsString("_rev"));
var getResult = db.Document
.Get(createResult.Value.ID());
Assert.AreEqual(getResult.Value.ID(), createResult.Value.ID());
Assert.AreEqual(getResult.Value.Key(), createResult.Value.Key());
Assert.AreEqual(getResult.Value.Rev(), createResult.Value.Rev());
Assert.AreEqual(getResult.Value.String("foo"), dummy.Foo);
Assert.AreEqual(getResult.Value.Int("bar"), dummy.Bar);
Assert.AreEqual(0, dummy.Baz);
}
public void Should_create_document_with_returnNew_parameter()
{
Database.ClearTestCollection(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var document = new Dictionary <string, object>()
.String("foo", "foo string value")
.Int("bar", 12345);
var createResult = db.Document
.ReturnNew()
.Create(Database.TestDocumentCollectionName, document);
Assert.AreEqual(202, createResult.StatusCode);
Assert.IsTrue(createResult.Success);
Assert.IsTrue(createResult.HasValue);
Assert.IsTrue(createResult.Value.IsString("_id"));
Assert.IsTrue(createResult.Value.IsString("_key"));
Assert.IsTrue(createResult.Value.IsString("_rev"));
Assert.IsTrue(createResult.Value.Has("new"));
Assert.AreEqual(createResult.Value.ID(), createResult.Value.String("new._id"));
Assert.AreEqual(createResult.Value.Key(), createResult.Value.String("new._key"));
Assert.AreEqual(createResult.Value.Rev(), createResult.Value.String("new._rev"));
Assert.AreEqual(document.String("foo"), createResult.Value.String("new.foo"));
Assert.AreEqual(document.Int("bar"), createResult.Value.Int("new.bar"));
}
public void Should_update_document_with_waitForSync()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var document = new Dictionary <string, object>()
.String("foo", "some other new string")
.Int("bar", 54321)
.Int("baz", 12345);
var updateResult = db.Document
.WaitForSync(true)
.Update(documents[0].ID(), document);
Assert.AreEqual(201, updateResult.StatusCode);
Assert.IsTrue(updateResult.Success);
Assert.IsTrue(updateResult.HasValue);
Assert.AreEqual(updateResult.Value.ID(), documents[0].ID());
Assert.AreEqual(updateResult.Value.Key(), documents[0].Key());
Assert.AreNotEqual(updateResult.Value.Rev(), documents[0].Rev());
var getResult = db.Document
.Get(updateResult.Value.ID());
Assert.AreEqual(getResult.Value.ID(), updateResult.Value.ID());
Assert.AreEqual(getResult.Value.Key(), updateResult.Value.Key());
Assert.AreEqual(getResult.Value.Rev(), updateResult.Value.Rev());
Assert.AreNotEqual(getResult.Value.String("foo"), documents[0].String("foo"));
Assert.AreEqual(getResult.Value.String("foo"), document.String("foo"));
Assert.AreNotEqual(getResult.Value.Int("bar"), documents[0].Int("bar"));
Assert.AreEqual(getResult.Value.Int("bar"), document.Int("bar"));
Assert.AreEqual(getResult.Value.Int("baz"), document.Int("baz"));
}
public static void ClearTestCollection(string collectionName)
{
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Truncate(collectionName);
}
public void Should_get_collection_figures()
{
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Create(Database.TestDocumentCollectionName);
var getResult = db.Collection
.GetFigures(createResult.Value.String("name"));
Assert.AreEqual(200, getResult.StatusCode);
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
Assert.AreEqual(createResult.Value.String("id"), getResult.Value.String("id"));
Assert.AreEqual(createResult.Value.String("name"), getResult.Value.String("name"));
Assert.AreEqual(createResult.Value.Bool("isSystem"), getResult.Value.Bool("isSystem"));
Assert.AreEqual(createResult.Value.Bool("isVolatile"), getResult.Value.Bool("isVolatile"));
Assert.AreEqual(createResult.Value.Int("status"), getResult.Value.Int("status"));
Assert.AreEqual(createResult.Value.Int("type"), getResult.Value.Int("type"));
Assert.AreEqual(createResult.Value.Bool("waitForSync"), getResult.Value.Bool("waitForSync"));
Assert.IsTrue(getResult.Value.Bool("doCompact"));
Assert.IsTrue(getResult.Value.Long("journalSize") > 0);
Assert.AreEqual(AKeyGeneratorType.Traditional, getResult.Value.Enum <AKeyGeneratorType>("keyOptions.type"));
Assert.AreEqual(true, getResult.Value.Bool("keyOptions.allowUserKeys"));
Assert.AreEqual(0, getResult.Value.Long("count"));
Assert.IsTrue(getResult.Value.Document("figures").Count > 0);
}
private void Run()
{
Database = XNP.Create();
if (Database == null)
{
return;
}
while (true)
{
try
{
// fetch all type 1 binary events (1 = public match)
var collection = ADatabase.GetCollection <BinaryEvent>("blobEvents");
var query = Query.EQ("type", 1);
var events = collection.Find(query);
foreach (var bevent in events)
{
ProcessEvent(bevent.data);
collection.Remove(Query.EQ("_id", bevent.id));
break;
}
}
catch (Exception e)
{
Log.Error(e.ToString());
}
Thread.Sleep(5 * 60);
}
}
public void Issue_No16_SortedList()
{
Database.CreateTestCollection(Database.TestDocumentCollectionName, ACollectionType.Document);
var db = new ADatabase(Database.Alias);
var entity = new IssueNo16Entity();
entity.SortedList = new SortedList <int, bool>();
entity.SortedList.Add(1, true);
entity.SortedList.Add(2, false);
entity.SortedList.Add(3, false);
entity.SortedList.Add(4, false);
var createResult = db.Document.Create <IssueNo16Entity>(Database.TestDocumentCollectionName, entity);
Assert.IsTrue(createResult.Success);
var getResult = db.Document.Get <IssueNo16Entity>(createResult.Value.ID());
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
for (int i = 0; i < getResult.Value.SortedList.Count; i++)
{
Assert.AreEqual(entity.SortedList.ElementAt(i).Key, getResult.Value.SortedList.ElementAt(i).Key);
Assert.AreEqual(entity.SortedList.ElementAt(i).Value, getResult.Value.SortedList.ElementAt(i).Value);
}
}
public void Should_get_database_collections()
{
Database.CleanupTestDatabases();
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Create(Database.TestDocumentCollectionName);
var getResult = db
.ExcludeSystem(true)
.GetAllCollections();
Assert.AreEqual(200, getResult.StatusCode);
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
var foundCreatedCollection = getResult.Value.FirstOrDefault(col => col.String("name") == createResult.Value.String("name"));
Assert.IsNotNull(foundCreatedCollection);
var foundSystemCollection = getResult.Value.FirstOrDefault(col => col.String("name") == "_system");
Assert.IsNull(foundSystemCollection);
}
public void Should_get_collection_cehcksum()
{
Database.CreateTestDatabase(Database.TestDatabaseGeneral);
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Create(Database.TestDocumentCollectionName);
var getResult = db.Collection
.WithData(true)
.WithRevisions(true)
.GetChecksum(createResult.Value.String("name"));
Assert.AreEqual(200, getResult.StatusCode);
Assert.IsTrue(getResult.Success);
Assert.IsTrue(getResult.HasValue);
Assert.AreEqual(createResult.Value.String("id"), getResult.Value.String("id"));
Assert.AreEqual(createResult.Value.String("name"), getResult.Value.String("name"));
Assert.AreEqual(createResult.Value.Bool("isSystem"), getResult.Value.Bool("isSystem"));
Assert.AreEqual(createResult.Value.Int("status"), getResult.Value.Int("status"));
Assert.AreEqual(createResult.Value.Int("type"), getResult.Value.Int("type"));
Assert.IsTrue(getResult.Value.IsString("revision"));
Assert.IsTrue(getResult.Value.IsString("checksum"));
}
public static List <Dictionary <string, object> > ClearCollectionAndFetchTestDocumentData(string collectionName)
{
ClearTestCollection(collectionName);
var documents = new List <Dictionary <string, object> >();
var db = new ADatabase(Alias);
var document1 = new Dictionary <string, object>()
.String("foo", "string value one")
.Int("bar", 1);
var document2 = new Dictionary <string, object>()
.String("foo", "string value two")
.Int("bar", 2);
var createResult1 = db.Document.Create(TestDocumentCollectionName, document1);
document1.Merge(createResult1.Value);
var createResult2 = db.Document.Create(TestDocumentCollectionName, document2);
document2.Merge(createResult2.Value);
documents.Add(document1);
documents.Add(document2);
return(documents);
}
public void Should_replace_document_with_generic_object()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var dummy = new Dummy();
dummy.Foo = "some other new string";
dummy.Baz = 54321;
var replaceResult = db.Document
.Replace(documents[0].ID(), dummy);
Assert.AreEqual(202, replaceResult.StatusCode);
Assert.IsTrue(replaceResult.Success);
Assert.IsTrue(replaceResult.HasValue);
Assert.AreEqual(replaceResult.Value.ID(), documents[0].ID());
Assert.AreEqual(replaceResult.Value.Key(), documents[0].Key());
Assert.AreNotEqual(replaceResult.Value.Rev(), documents[0].Rev());
var getResult = db.Document
.Get(replaceResult.Value.ID());
Assert.AreEqual(getResult.Value.ID(), replaceResult.Value.ID());
Assert.AreEqual(getResult.Value.Key(), replaceResult.Value.Key());
Assert.AreEqual(getResult.Value.Rev(), replaceResult.Value.Rev());
Assert.AreNotEqual(getResult.Value.String("foo"), documents[0].String("foo"));
Assert.AreEqual(getResult.Value.String("foo"), dummy.Foo);
Assert.AreEqual(getResult.Value.Int("baz"), dummy.Baz);
Assert.AreEqual(0, dummy.Bar);
}
public void Issue_No15_List_save_and_retrieve()
{
Database.CreateTestCollection(Database.TestDocumentCollectionName, ACollectionType.Document);
var db = new ADatabase(Database.Alias);
var entity = new IssueNo15Entity();
entity.ListNumbers = new List <int> {
1, 2, 3
};
entity.ArrayNumbers = new int[] { 4, 5, 6 };
var createResult = db.Document.Create <IssueNo15Entity>(Database.TestDocumentCollectionName, entity);
Assert.IsTrue(createResult.Success);
var getresult = db.Document.Get <IssueNo15Entity>(createResult.Value.ID());
Assert.IsTrue(getresult.Success);
Assert.IsTrue(getresult.HasValue);
for (int i = 0; i < getresult.Value.ListNumbers.Count; i++)
{
Assert.AreEqual(entity.ListNumbers[i], getresult.Value.ListNumbers[i]);
}
for (int i = 0; i < getresult.Value.ArrayNumbers.Length; i++)
{
Assert.AreEqual(entity.ArrayNumbers[i], getresult.Value.ArrayNumbers[i]);
}
}
public void Should_execute_get_foxx_request()
{
var db = new ADatabase(Database.SystemAlias);
var getResult = db.Foxx.Get <Dictionary <string, object> >("/getting-started/hello-world");
Assert.AreEqual(200, getResult.StatusCode);
Assert.AreEqual("bar", getResult.Value.String("foo"));
}
public async Task Setup()
{
await Connection.CreateDatabase(TestDatabaseGeneral);
_db = Connection.GetDatabase(TestDatabaseGeneral);
await _db.CreateCollection(TestDocumentCollectionName)
.Type(ACollectionType.Document)
.Create();
}
public static void CreateTestCollection(string collectionName, ACollectionType collectionType)
{
DeleteTestCollection(collectionName);
var db = new ADatabase(Database.Alias);
var createResult = db.Collection
.Type(collectionType)
.Create(collectionName);
}
public static void DeleteTestCollection(string collectionName)
{
var db = new ADatabase(Database.Alias);
var resultGet = db.Collection.Get(collectionName);
if (resultGet.Success && (resultGet.Value.String("name") == collectionName))
{
db.Collection.Delete(collectionName);
}
}
public static void DeleteTestDatabase(string databaseName)
{
var db = new ADatabase(Database.SystemAlias);
var resultList = db.GetAccessibleDatabases();
if (resultList.Success && resultList.Value.Contains(databaseName))
{
db.Drop(databaseName);
}
}
public void Should_get_document_with_ifNoneMatch_and_return_304()
{
var documents = Database.ClearCollectionAndFetchTestDocumentData(Database.TestDocumentCollectionName);
var db = new ADatabase(Database.Alias);
var getResult = db.Document
.IfNoneMatch(documents[0].Rev())
.Get(documents[0].ID());
Assert.AreEqual(304, getResult.StatusCode);
Assert.IsFalse(getResult.Success);
Assert.IsFalse(getResult.HasValue);
}
