public void EmptyArrayTest()
{
var str = "{\"Alias\":\"Jimmy\",\"Data\":[],\"Name\":\"Trolo\",\"SubData\":{\"SubArray\":[]}}";
using (var blittableContext = JsonOperationContext.ShortTermSingleUse())
using (var employee = blittableContext.Read(new MemoryStream(Encoding.UTF8.GetBytes(str)), "doc1"))
{
dynamic dynamicObject = new DynamicBlittableJson(employee);
Assert.Equal(dynamicObject.Alias, "Jimmy");
Assert.Equal(dynamicObject.Data.Length, 0);
Assert.Equal(dynamicObject.SubData.SubArray.Length, 0);
Assert.Equal(dynamicObject.Name, "Trolo");
Assert.Throws <ArgumentOutOfRangeException>(() => dynamicObject.Data[0]);
Assert.Throws <ArgumentOutOfRangeException>(() => dynamicObject.SubData.SubArray[0]);
}
}
public void Can_get_simple_values()
{
var now = SystemTime.UtcNow;
using (var lazyStringValue = _ctx.GetLazyString("22.0"))
{
var doc = create_doc(new DynamicJsonValue
{
["Name"] = "Arek",
["Address"] = new DynamicJsonValue
{
["City"] = "NYC"
},
["NullField"] = null,
["Age"] = new LazyDoubleValue(lazyStringValue),
["LazyName"] = _ctx.GetLazyString("Arek"),
["Friends"] = new DynamicJsonArray
{
new DynamicJsonValue
{
["Name"] = "Joe"
},
new DynamicJsonValue
{
["Name"] = "John"
}
},
[Constants.Metadata.Key] = new DynamicJsonValue
{
[Constants.Headers.RavenEntityName] = "Users",
[Constants.Headers.RavenLastModified] = now.GetDefaultRavenFormat(true)
}
}, "users/1");
dynamic user = new DynamicBlittableJson(doc);
Assert.Equal("Arek", user.Name);
Assert.Equal("NYC", user.Address.City);
Assert.Equal("users/1", user.Id);
Assert.Equal(DynamicNullObject.Null, user.NullField);
Assert.Equal(22.0, user.Age);
Assert.Equal("Arek", user.LazyName);
Assert.Equal(2, user.Friends.Length);
Assert.Equal("Users", user[Constants.Metadata.Key][Constants.Headers.RavenEntityName]);
Assert.Equal(now, user[Constants.Metadata.Key].Value <DateTime>(Constants.Headers.RavenLastModified));
}
}
public void FlatBoundarySizeFieldsAmount(int maxValue)
{
//var maxValue = short.MaxValue + 1000;
var str = GetJsonString(maxValue);
using (var blittableContext = JsonOperationContext.ShortTermSingleUse())
using (var employee = blittableContext.Read(new MemoryStream(Encoding.UTF8.GetBytes(str)), "doc1"))
{
dynamic dynamicBlittableJObject = new DynamicBlittableJson(employee);
for (var i = 0; i < maxValue; i++)
{
string key = "Field" + i;
long curVal = dynamicBlittableJObject[key];
Assert.Equal(curVal, i);
}
}
}
public async Task LongStringsTest(int repeatSize)
{
var originStr = string.Join("", Enumerable.Repeat(1, repeatSize).Select(x => "sample"));
var sampleObject = new
{
SomeProperty = "text",
SomeNumber = 1,
SomeArray = new[] { 1, 2, 3 },
SomeObject = new
{
SomeValue = 1,
SomeArray = new[] { "a", "b" }
},
Value = originStr,
AnotherNumber = 3
};
var str = sampleObject.ToJsonString();
using (var blittableContext = JsonOperationContext.ShortTermSingleUse())
using (var doc = await blittableContext.ReadForDiskAsync(new MemoryStream(Encoding.UTF8.GetBytes(str)), "doc1"))
{
dynamic dynamicObject = new DynamicBlittableJson(doc);
Assert.Equal(sampleObject.Value, dynamicObject.Value);
Assert.Equal(sampleObject.SomeNumber, dynamicObject.SomeNumber);
Assert.Equal(sampleObject.SomeArray.Length, dynamicObject.SomeArray.Length);
Assert.Equal(sampleObject.SomeArray[0], dynamicObject.SomeArray[0]);
Assert.Equal(sampleObject.AnotherNumber, dynamicObject.AnotherNumber);
Assert.Equal(sampleObject.SomeArray[1], dynamicObject.SomeArray[1]);
Assert.Equal(sampleObject.SomeArray[2], dynamicObject.SomeArray[2]);
Assert.Equal(sampleObject.SomeObject.SomeValue, dynamicObject.SomeObject.SomeValue);
Assert.Equal(sampleObject.SomeObject.SomeArray.Length, dynamicObject.SomeObject.SomeArray.Length);
Assert.Equal(sampleObject.SomeObject.SomeArray[0], dynamicObject.SomeObject.SomeArray[0]);
Assert.Equal(sampleObject.SomeObject.SomeArray[1], dynamicObject.SomeObject.SomeArray[1]);
var ms = new MemoryStream();
await blittableContext.WriteAsync(ms, doc);
Assert.Equal(str, Encoding.UTF8.GetString(ms.ToArray()));
}
}
public void FunctionalityTest()
{
var str = GenerateSimpleEntityForFunctionalityTest();
using (var blittableContext = JsonOperationContext.ShortTermSingleUse())
using (var employee = blittableContext.Read(new MemoryStream(Encoding.UTF8.GetBytes(str)), "doc1"))
{
dynamic dynamicRavenJObject = JsonConvert.DeserializeObject <ExpandoObject>(str, new ExpandoObjectConverter());
dynamic dynamicBlittableJObject = new DynamicBlittableJson(employee);
Assert.Equal(dynamicRavenJObject.Age, dynamicBlittableJObject.Age);
Assert.Equal(dynamicRavenJObject.Name, dynamicBlittableJObject.Name);
Assert.Equal(dynamicRavenJObject.Dogs.Count, dynamicBlittableJObject.Dogs.Count);
for (var i = 0; i < dynamicBlittableJObject.Dogs.Length; i++)
{
Assert.Equal(dynamicRavenJObject.Dogs[i], dynamicBlittableJObject.Dogs[i]);
}
Assert.Equal(dynamicRavenJObject.Office.Name, dynamicRavenJObject.Office.Name);
Assert.Equal(dynamicRavenJObject.Office.Street, dynamicRavenJObject.Office.Street);
Assert.Equal(dynamicRavenJObject.Office.City, dynamicRavenJObject.Office.City);
var ms = new MemoryStream();
blittableContext.Write(ms, employee);
Assert.Equal(str, Encoding.UTF8.GetString(ms.ToArray()));
}
}
public static string GetCollectionName(DynamicBlittableJson document)
{
return(GetCollectionName(document.BlittableJson));
}
public async Task CriteriaScriptWithTransformation(bool useSsl)
{
string dbName = GetDatabaseName();
X509Certificate2 clientCertificate = null;
X509Certificate2 adminCertificate = null;
if (useSsl)
{
var serverCertPath = SetupServerAuthentication();
adminCertificate = AskServerForClientCertificate(serverCertPath, new Dictionary <string, DatabaseAccess>(), SecurityClearance.ClusterAdmin);
clientCertificate = AskServerForClientCertificate(serverCertPath, new Dictionary <string, DatabaseAccess>
{
[dbName] = DatabaseAccess.ReadWrite,
});
}
using (var store = GetDocumentStore(new Options
{
AdminCertificate = adminCertificate,
ClientCertificate = clientCertificate,
ModifyDatabaseName = s => dbName
}))
{
using (var subscriptionManager = new DocumentSubscriptions(store))
{
await CreateDocuments(store, 1);
var lastChangeVector = (await store.Admin.SendAsync(new GetStatisticsOperation())).DatabaseChangeVector;
await CreateDocuments(store, 6);
var subscriptionCreationParams = new SubscriptionCreationOptions()
{
Query = @"
declare function project(d) {
var namSuffix = parseInt(d.Name.replace('ThingNo', ''));
if (namSuffix <= 2){
return false;
}
else if (namSuffix == 3){
return null;
}
else if (namSuffix == 4){
return d;
}
return {Name: 'foo', OtherDoc:load('things/6-A')}
}
from Things as d
select project(d)
",
ChangeVector = lastChangeVector
};
var subsId = subscriptionManager.Create(subscriptionCreationParams);
using (var subscription = subscriptionManager.Open <BlittableJsonReaderObject>(new SubscriptionConnectionOptions(subsId)))
{
using (store.GetRequestExecutor().ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
var list = new BlockingCollection <BlittableJsonReaderObject>();
GC.KeepAlive(subscription.Run(x =>
{
foreach (var item in x.Items)
{
list.Add(context.ReadObject(item.Result, "test"));
}
}));
BlittableJsonReaderObject thing;
Assert.True(list.TryTake(out thing, 5000));
dynamic dynamicThing = new DynamicBlittableJson(thing);
Assert.Equal("ThingNo4", dynamicThing.Name);
Assert.True(list.TryTake(out thing, 5000));
dynamicThing = new DynamicBlittableJson(thing);
Assert.Equal("foo", dynamicThing.Name);
Assert.Equal("ThingNo4", dynamicThing.OtherDoc.Name);
Assert.False(list.TryTake(out thing, 50));
}
}
}
}
}
