public void should_be_able_to_find_pawns_if_sort_parameter_is_supplied()
{
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn",
Properties = new List <BlContainerProp>()
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider => provider.FindInContainer <BasicPawn>(It.IsAny <string>(), null, "Name", "Asc", 200))
.Returns(cursor).Verifiable();
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var resultCursor = bls.Find <BasicPawn>(filter: null, sortProperty: p => p.Name);
// Assert
Assert.NotNull(resultCursor);
storageProviderMock.Verify();
}
public void should_find_related_pawns_in_bls_buffer_with_filter_no_soft_delete()
{
// Setup
var cursor = new StorageCursor <Lawyer>();
var storedFirm = new LawFirm {
Name = "LLP"
};
storedFirm.SetId("firm_id");
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock.Setup(pr => pr.GetById <LawFirm>(
"law_firm_id",
"LawFirm"))
.Returns(storedFirm);
storageProviderMock
.Setup(pr => pr.GetByRelation <Lawyer>(It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <BlBinaryExpression>(), null, Sort.Asc, 200))
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object);
bls.RegisterBlPawns(new LawFirm(), new Lawyer(), new Assistant(), new Matter(), new Client());
// Act
LawFirm firm = bls.GetById <LawFirm>("law_firm_id");
Lawyer lawyer = bls.SpawnNew <Lawyer>();
lawyer.FirstName = "George";
firm.Lawyers.Connect(lawyer);
Lawyer lawyer2 = bls.SpawnNew <Lawyer>();
lawyer2.FirstName = "Mark";
cursor.BlsInMemoryCursorBuffer.Add(lawyer2);
firm.Lawyers.Connect(lawyer2);
Lawyer lawyer3 = bls.SpawnNew <Lawyer>();
lawyer2.FirstName = "Robert";
cursor.BlsInMemoryCursorBuffer.Add(lawyer3);
firm.Lawyers.Connect(lawyer3);
StorageCursor <Lawyer> cr = firm.Lawyers.Find(l => l.FirstName == "George");
List <Lawyer> pawns = cr.GetAll();
// Assert
Assert.NotEmpty(pawns);
Assert.Equal("George", pawns[0].FirstName);
}
public void should_fail_on_find_if_single_filter_property_is_incorrectly_formatted()
{
// There is some strange lambda syntax here which people would probably never use but it's
// still a good idea to guard against these types of error
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn", StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider =>
provider.FindInContainer <BasicPawn>(It.IsAny <string>(), It.IsAny <BlBinaryExpression>(), null,
"Asc", 200))
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act & Assert
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
// ReSharper disable once EqualExpressionComparison
bls.Find <BasicPawn>(filter: (pawn => "" == ""));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => "" == pawn.Name));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => string.Empty == ""));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => true));
});
}
public void should_be_able_to_find_pawns_based_on_single_literal_filter()
{
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn",
Properties = new List <BlContainerProp>()
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
BlBinaryExpression filterExpression = null;
storageProviderMock
.Setup(provider =>
provider.FindInContainer <BasicPawn>(It.IsAny <string>(), It.IsAny <BlBinaryExpression>(), null,
"Asc", 200))
.Callback <string, BlBinaryExpression, string, string, int>((container, exp, sort, order, batchSize) =>
filterExpression = exp)
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var resultCursor = bls.Find <BasicPawn>(filter: (bp) => bp.Name == "some name");
// Assert
Assert.NotNull(resultCursor);
Assert.NotNull(filterExpression);
Assert.Equal("Name", filterExpression.PropName);
Assert.Equal(BlOperator.Eq, filterExpression.Operator);
Assert.Equal("some name", filterExpression.Value);
Assert.Null(filterExpression.Left);
Assert.Null(filterExpression.Right);
Assert.True(filterExpression.IsLeaf);
}
public void should_not_find_pawn_in_bls_buffer_if_it_has_been_disconnected()
{
// Setup
var cursor = new StorageCursor <Lawyer>();
var storedFirm = new LawFirm {
Name = "LLP"
};
storedFirm.SetId("firm_id");
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock.Setup(pr => pr.GetById <LawFirm>(
"law_firm_id",
"LawFirm"))
.Returns(storedFirm);
storageProviderMock
.Setup(pr => pr.GetByRelation <Lawyer>(It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <string>(), null, null, Sort.Asc, 200))
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object);
bls.RegisterBlPawns(new LawFirm(), new Lawyer(), new Assistant(), new Matter(), new Client());
// Act
LawFirm firm = bls.GetById <LawFirm>("law_firm_id");
Lawyer lawyer = bls.SpawnNew <Lawyer>();
lawyer.FirstName = "George";
firm.Lawyers.Connect(lawyer);
firm.Lawyers.Disconnect(lawyer);
StorageCursor <Lawyer> cr = firm.Lawyers.Find();
List <Lawyer> pawns = cr.GetAll();
// Assert
Assert.Empty(pawns);
}
public void should_find_related_pawns_in_storage_no_filter_no_soft_delete()
{
// Setup
var cursor = new StorageCursor <Lawyer>();
var storedFirm = new LawFirm {
Name = "LLP"
};
// setting the ID so it looks like the object is coming from storage
storedFirm.SetId("law_firm_id");
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock.Setup(pr => pr.GetByRelation <Lawyer>(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
null,
null,
Sort.Asc,
200))
.Returns(cursor)
.Verifiable();
storageProviderMock.Setup(pr => pr.GetById <LawFirm>(
"law_firm_id",
"LawFirm"))
.Returns(storedFirm);
var bls = new Bls(storageProviderMock.Object);
bls.RegisterBlPawns(new LawFirm(), new Lawyer(), new Assistant(), new Matter(), new Client());
// Act
LawFirm firm = bls.GetById <LawFirm>("law_firm_id");
Lawyer lawyer = bls.SpawnNew <Lawyer>();
lawyer.FirstName = "George";
firm.Lawyers.Connect(lawyer);
var existingLawyerInStorage = new Lawyer();
existingLawyerInStorage.SetId("lawyer_id");
existingLawyerInStorage.FirstName = "Peter";
var traceableLawyer = existingLawyerInStorage.AsTrackable();
cursor.StorageObjectBuffer.Add(traceableLawyer);
bls.ToUpdate.Add(traceableLawyer);
StorageCursor <Lawyer> cr = firm.Lawyers.Find();
storageProviderMock.Verify();
List <Lawyer> pawns = cr.GetAll();
// Assert
Assert.NotEmpty(pawns);
Assert.Equal("George", pawns[0].FirstName);
Assert.Equal("Peter", pawns[1].FirstName);
}
