public void Inner_IList_Strings_From_Array()
{
using (var documentStore = GetDocumentStore())
{
using (var session = documentStore.OpenSession())
{
session.Store(new Foo1 {
Id = "foos/1", Strings = new[] { "A", "B", "C" }
});
session.SaveChanges();
}
using (var commands = documentStore.Commands())
{
var doc = GetJsonString(commands, "foos/1");
Assert.Equal(LinuxTestUtils.Dos2Unix(@"{
""Strings"": [
""A"",
""B"",
""C""
]
}"), doc);
}
}
}
public void ShouldNotGetErrors()
{
using (var store = GetDocumentStore())
{
store.Maintenance.Send(new PutIndexesOperation(new[] { new IndexDefinition
{
Name = "test",
Maps = { @"from brief in docs.TestCases
select new {
_tWarnings_AccessoryWarnings_Value = brief.Warnings.AccessoryWarnings.Select(y=>y.Value)
}" }
} }));
using (var commands = store.Commands())
{
var json = commands.ParseJson(LinuxTestUtils.Dos2Unix(@"{
""Warnings"": {
""AccessoryWarnings"": [
{
""Value"": ""whatever"",
""Id"": 123
},
{
""Value"": ""dsfsdfsd sfsd sd"",
""Id"": 1234
}
]
}
}"));
commands.Put("TestCases/TST00001", null, json, new Dictionary <string, object>
{
{ Constants.Documents.Metadata.Collection, "TestCases" }
});
json = commands.ParseJson(@"{
""Warnings"": {
""AccessoryWarnings"": []
}
}");
commands.Put("TestCases/TST00002", null,
json,
new Dictionary <string, object>
{
{ Constants.Documents.Metadata.Collection, "TestCases" }
});
}
Indexes.WaitForIndexing(store);
RavenTestHelper.AssertNoIndexErrors(store);
}
}
public void WillNotForgetCastToNullableDateTime()
{
var indexDefinition = new IndexDefinitionBuilder <Person>
{
Map = persons => from p in persons select new { DateTime = (DateTime?)null }
}.ToIndexDefinition(DocumentConventions.Default);
var expected = LinuxTestUtils.Dos2Unix(@"docs.People.Select(p => new {
DateTime = ((DateTime ? ) null)
})");
Assert.Equal(expected, indexDefinition.Maps.First());
}
public void CanSetPropertyOnArrayItem()
{
using (var store = GetDocumentStore())
{
using (var commands = store.Commands())
{
var json = commands.ParseJson(LinuxTestUtils.Dos2Unix(@"{
'Privilege':[
{
'Level':'Silver',
'Code':'12312',
'EndDate':'12/12/2012'
}
],
'Phones':[
{
'Cell':'123123',
'Home':'9783041284',
'Office':'1234123412'
}
],
'MiddleName':'asdfasdfasdf',
'FirstName':'asdfasdfasdf'
}"));
commands.Put("patrons/1", null, json, new Dictionary <string, object>
{
{ Constants.Documents.Metadata.Collection, "patrons" }
});
}
new Index1().Execute(store);
Indexes.WaitForIndexing(store);
store
.Operations
.Send(new PatchByQueryOperation(
new IndexQuery {
Query = $"FROM INDEX '{new Index1().IndexName}' UPDATE {{ this.Privilege[0].Level = 'Gold' }}"
}))
.WaitForCompletion(TimeSpan.FromSeconds(15));
using (var commands = store.Commands())
{
dynamic document = commands.Get("patrons/1");
var level = document.Privilege[0].Level.ToString();
Assert.Equal("Gold", level);
}
}
}
public void WillNotForgetCastToNullableDateTime()
{
var indexDefinition = new IndexDefinitionBuilder <Person>()
{
Map = persons => from p in persons select new { DateTime = (DateTime?)null }
#pragma warning disable CS0618 // Type or member is obsolete
}.ToIndexDefinition(new DocumentConventions {
PrettifyGeneratedLinqExpressions = false
});
#pragma warning restore CS0618 // Type or member is obsolete
var expected = LinuxTestUtils.Dos2Unix(@"docs.People.Select(p => new {
DateTime = ((DateTime ? ) null)
})");
Assert.Equal(expected, indexDefinition.Maps.First());
}
public void WillGenerateDecimalCast()
{
Expression <Func <IEnumerable <Coin>, IEnumerable <object> > > query = x => from y in x
group y by y.Denomination
into g
select new
{
Denomination = g.Key,
Cost = g.Sum(z => z.Cost)
};
var code = IndexDefinitionHelper.PruneToFailureLinqQueryAsStringToWorkableCode <Coin, Coin>(query, new DocumentConventions(), "docs", false);
Assert.Equal(LinuxTestUtils.Dos2Unix(@"docs.GroupBy(y => y.Denomination).Select(g => new {
Denomination = g.Key,
Cost = Enumerable.Sum(g, z => ((double) z.Cost))
})"), code);
}
public void CanCreateMultiMapIndex()
{
using (var store = GetDocumentStore(new Options
{
ModifyDocumentStore = s => s.Conventions.PrettifyGeneratedLinqExpressions = false
}))
{
new CatsAndDogs().Execute(store);
var indexDefinition = store.Maintenance.Send(new GetIndexOperation("CatsAndDogs"));
Assert.Equal(2, indexDefinition.Maps.Count);
Assert.Equal(LinuxTestUtils.Dos2Unix(@"docs.Cats.Select(cat => new {
Name = cat.Name
})"), indexDefinition.Maps.First());
Assert.Equal(LinuxTestUtils.Dos2Unix(@"docs.Dogs.Select(dog => new {
Name = dog.Name
})"), indexDefinition.Maps.Skip(1).First());
}
}
public void WillProperlyCompileWhenUsingToString()
{
Expression <Func <IEnumerable <Coin>, IEnumerable <object> > > query = x => from y in x
group y by y.Denomination
into g
select
new
{
Denomination = g.Key,
Cost = g.First().Cost.ToString()
};
var code = IndexDefinitionHelper.PruneToFailureLinqQueryAsStringToWorkableCode <Coin, Coin>(query, new DocumentConventions(), "docs", false);
Assert.Equal(LinuxTestUtils.Dos2Unix(@"docs.GroupBy(y => y.Denomination).Select(g => new {
Denomination = g.Key,
Cost = (DynamicEnumerable.FirstOrDefault(g)).Cost.ToString()
})"), code);
}
public unsafe void RavenDB_15975()
{
using (var options = StorageEnvironmentOptions.ForPath(DataDir))
{
options.Encryption.MasterKey = Sodium.GenerateRandomBuffer((int)Sodium.crypto_aead_xchacha20poly1305_ietf_keybytes());
using (var innerPager = LinuxTestUtils.GetNewPager(options, DataDir, "Raven.Voron"))
{
AbstractPager cryptoPager;
using (cryptoPager = new CryptoPager(innerPager))
{
using (var tx = new TempPagerTransaction(isWriteTransaction: true))
{
var overflowSize = 4 * Constants.Storage.PageSize + 100;
cryptoPager.EnsureContinuous(26, 5);
var pagePointer = cryptoPager.AcquirePagePointerForNewPage(tx, 26, 5);
var header = (PageHeader *)pagePointer;
header->PageNumber = 26;
header->Flags = PageFlags.Overflow;
header->OverflowSize = overflowSize;
Memory.Set(pagePointer + PageHeader.SizeOf, (byte)'X', overflowSize);
}
using (var tx = new TempPagerTransaction())
{
var pagePointer = cryptoPager.AcquirePagePointer(tx, 26);
// Making sure that the data was decrypted and still holds those 'X' chars
Assert.True(pagePointer[PageHeader.SizeOf] == 'X');
Assert.True(pagePointer[666] == 'X');
Assert.True(pagePointer[1039] == 'X');
}
}
}
}
}
public void Inner_List_Objects()
{
using (var documentStore = GetDocumentStore())
{
using (var session = documentStore.OpenSession())
{
session.Store(new Foo7 {
Id = "foos/1", Bars = new List <Bar> {
new Bar {
Baz = "A"
}, new Bar {
Baz = "B"
}, new Bar {
Baz = "C"
}
}
});
session.SaveChanges();
}
using (var commands = documentStore.Commands())
{
var doc = GetJsonString(commands, "foos/1");
Assert.Equal(LinuxTestUtils.Dos2Unix(@"{
""Bars"": [
{
""Baz"": ""A""
},
{
""Baz"": ""B""
},
{
""Baz"": ""C""
}
]
}"), doc);
}
}
}
public unsafe void WriteAndReadPageUsingCryptoPager()
{
using (var options = StorageEnvironmentOptions.ForPath(DataDir))
{
options.Encryption.MasterKey = Sodium.GenerateRandomBuffer((int)Sodium.crypto_aead_xchacha20poly1305_ietf_keybytes());
using (var innerPager = LinuxTestUtils.GetNewPager(options, DataDir, "Raven.Voron"))
{
AbstractPager cryptoPager;
using (cryptoPager = new CryptoPager(innerPager))
{
using (var tx = new TempPagerTransaction(isWriteTransaction: true))
{
cryptoPager.EnsureContinuous(17, 1); // We're gonna try to read and write to page 17
var pagePointer = cryptoPager.AcquirePagePointerForNewPage(tx, 17, 1);
var header = (PageHeader *)pagePointer;
header->PageNumber = 17;
header->Flags = PageFlags.Single | PageFlags.FixedSizeTreePage;
Memory.Set(pagePointer + PageHeader.SizeOf, (byte)'X', Constants.Storage.PageSize - PageHeader.SizeOf);
}
using (var tx = new TempPagerTransaction())
{
var pagePointer = cryptoPager.AcquirePagePointer(tx, 17);
// Making sure that the data was decrypted and still holds those 'X' chars
Assert.True(pagePointer[PageHeader.SizeOf] == 'X');
Assert.True(pagePointer[666] == 'X');
Assert.True(pagePointer[1039] == 'X');
}
}
}
}
}
public void CanIndexWithNoErrors_Datetime()
{
using (var store = GetDocumentStore())
{
using (var commands = store.Commands())
{
var json = commands.ParseJson(LinuxTestUtils.Dos2Unix(@"{
'$type': 'Domain.Model.Clicks.ClickAllocation, Domain',
'AccountId': 'accounts/4',
'Quantity': 90,
'Date': '2011-12-12T08:47:44.0706445',
'Key': null,
'OrderNumber': null,
'PurchaseOrderNumber': null,
'PurchaseDate': '0001-01-01T00:00:00.0000000-05:00',
'ReorderQuantity': 0,
'Type': 'Dealer',
'LastSavedDate': '2011-12-12T08:47:44.1643945-05:00',
'LastSavedUser': '******',
'SourceId': '00000000-0000-0000-0000-000000000000'
}"));
commands.Put("test/1", null, json, new Dictionary <string, object> {
{ Constants.Documents.Metadata.Collection, "ClickAllocations" }
});
json = commands.ParseJson(LinuxTestUtils.Dos2Unix(@"{
'$type': 'Domain.Model.Clicks.ClickAllocation, Domain',
'AccountId': 'accounts/4',
'Quantity': 20,
'Date': '2012-02-28T16:05:18.7359910',
'Key': null,
'OrderNumber': null,
'PurchaseOrderNumber': null,
'PurchaseDate': '0001-01-01T00:00:00.0000000',
'ReorderQuantity': 5,
'Type': 'Dealer',
'LastSavedDate': '2012-02-28T16:05:19.3609910',
'LastSavedUser': '******',
'SourceId': '00000000-0000-0000-0000-000000000000'
}"));
commands.Put("test/2", null, json, new Dictionary <string, object> {
{ Constants.Documents.Metadata.Collection, "ClickAllocations" }
});
}
store.Maintenance.Send(new PutIndexesOperation(new[] {
new IndexDefinition
{
Name = "test",
Maps =
{
LinuxTestUtils.Dos2Unix(@"docs.ClickAllocations
.Select(doc => new {AccountId = doc.AccountId, Date = doc.Date, Id = Id(doc), Key = doc.Key, LastSavedDate = doc.LastSavedDate, LastSavedUser = doc.LastSavedUser, OrderNumber = doc.OrderNumber, PurchaseDate = doc.PurchaseDate, PurchaseOrderNumber = doc.PurchaseOrderNumber, Quantity = doc.Quantity, ReorderQuantity = doc.ReorderQuantity, Type = doc.Type})
")
},
Reduce =
LinuxTestUtils.Dos2Unix(@"results
.GroupBy(result => result.AccountId)
.Select(a => new {a = a, clickAllocation = a.OrderByDescending(x => x.Date).FirstOrDefault()})
.Select(__h__TransparentIdentifier0 => new {AccountId = __h__TransparentIdentifier0.clickAllocation.AccountId, Date = __h__TransparentIdentifier0.clickAllocation.Date, Id = __h__TransparentIdentifier0.clickAllocation.Id, Key = __h__TransparentIdentifier0.clickAllocation.Key, LastSavedDate = __h__TransparentIdentifier0.clickAllocation.LastSavedDate, LastSavedUser = __h__TransparentIdentifier0.clickAllocation.LastSavedUser, OrderNumber = __h__TransparentIdentifier0.clickAllocation.OrderNumber, PurchaseDate = __h__TransparentIdentifier0.clickAllocation.PurchaseDate, PurchaseOrderNumber = __h__TransparentIdentifier0.clickAllocation.PurchaseOrderNumber, Quantity = __h__TransparentIdentifier0.clickAllocation.Quantity, ReorderQuantity = __h__TransparentIdentifier0.clickAllocation.ReorderQuantity, Type = __h__TransparentIdentifier0.clickAllocation.Type})")
}
}));
WaitForIndexing(store);
RavenTestHelper.AssertNoIndexErrors(store);
}
}
public unsafe void ValidatePageChecksumShouldDetectDataCorruption()
{
// Create some random data
var treeNames = new List <string>();
var random = new Random();
var value1 = new byte[random.Next(1024 * 1024 * 2)];
var value2 = new byte[random.Next(1024 * 1024 * 2)];
random.NextBytes(value1);
random.NextBytes(value2);
const int treeCount = 5;
const int recordCount = 6;
using (var env = new StorageEnvironment(StorageEnvironmentOptions.ForPath(DataDir)))
{
env.Options.ManualFlushing = true;
for (int i = 0; i < treeCount; i++)
{
using (var tx = env.WriteTransaction())
{
string name = "tree/" + i;
treeNames.Add(name);
var tree = tx.CreateTree(name);
for (int j = 0; j < recordCount; j++)
{
tree.Add(string.Format("{0}/items/{1}", name, j), j % 2 == 0 ? value1 : value2);
}
tx.Commit();
}
}
env.FlushLogToDataFile();
}
// Lets corrupt something
using (var options = StorageEnvironmentOptions.ForPath(DataDir))
using (var pager = LinuxTestUtils.GetNewPager(options, DataDir, "Raven.Voron"))
using (var tempTX = new TempPagerTransaction())
{
var writePtr = pager.AcquirePagePointer(tempTX, 2) + PageHeader.SizeOf + 43; // just some random place on page #2
for (byte i = 0; i < 8; i++)
{
writePtr[i] = i;
}
}
// Now lets try to read it all back and hope we get an exception
try
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.ForPath(DataDir)))
{
using (var tx = env.ReadTransaction())
{
foreach (var treeName in treeNames)
{
var tree = tx.CreateTree(treeName);
for (int i = 0; i < recordCount; i++)
{
var readResult = tree.Read(string.Format("{0}/items/{1}", treeName, i));
Assert.NotNull(readResult);
if (i % 2 == 0)
{
var readBytes = new byte[value1.Length];
readResult.Reader.Read(readBytes, 0, readBytes.Length);
}
else
{
var readBytes = new byte[value2.Length];
readResult.Reader.Read(readBytes, 0, readBytes.Length);
}
}
}
}
}
}
catch (Exception e)
{
Assert.True(e is InvalidOperationException || e is InvalidDataException);
}
}
