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_not_be_able_to_get_pawn_by_id_if_its_not_registered()
{
// Setup
var basicPawn = new BasicPawn {
Name = "Name"
};
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn", StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider => provider.GetById <BasicPawn>(It.IsAny <string>(), null))
.Returns(basicPawn);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
// Act & Assert
Assert.Throws <PawnNotRegisteredError>(() =>
{
bls.GetById <BasicPawn>("123");
});
}
public void should_spawn_new_pawn()
{
// Setup
var graphContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
graphContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
// Act
Bls bls = new Bls(null, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
BasicPawn basicPawn = bls.SpawnNew <BasicPawn>();
// Assert
Assert.NotNull(basicPawn);
Assert.Single(bls.ToAddBuffer);
}
public void should_remove_in_memory_connection()
{
// Setup
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);
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);
// Assert
Assert.Empty(firm.SystemRef.ToConnect);
}
public async Task <Bls> DeleteBl(int blId)
{
try
{
if (blId == 0)
{
throw new KeyNotFoundException("Bl");
}
Bls bls = await this.FindBlByBlId(blId);
using (var context = this._context)
{
context.Bls.Remove(bls);
context.SaveChanges();
return(bls);
}
}
catch (KeyNotFoundException key)
{
throw new Exception("Um campo necessário para essa ação não foi informado: " + key.Message);
}
catch (Exception ex)
{
throw new Exception("Houve um erro ao tentar deletar o registro: " + ex.Message);
}
}//DELETAR
public void should_fail_to_persist_if_no_storage_provider_is_set()
{
// Setup
var bls = new Bls(null, null);
// Act & Assert
Assert.Throws <NoStorageProviderRegisteredError>(() => { bls.PersistChanges(); });
}
public void should_fail_spawning_new_pawn_if_no_pawns_are_registered()
{
// Setup
Bls bls = new Bls(null);
// Act & Assert
Assert.Throws <PawnNotRegisteredError>(() =>
{
bls.SpawnNew <BasicPawn>();
});
}
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 async Task <Bls> InsertBl(Bls bls)
{
try
{
using (var context = this._context)
{
context.Bls.Add(bls);
context.SaveChanges();
return(bls);
}
}
catch (Exception ex)
{
throw new Exception("Houve um erro ao incluir Bl: " + ex.Message);
}
}
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 async Task <Bls> UpdateBl(Bls bl)
{
try
{
if (bl.BlId == 0)
{
throw new KeyNotFoundException("BlId");
}
this._context.Update(bl);
this._context.SaveChanges();
return(bl);
}
catch (KeyNotFoundException key)
{
throw new Exception("Um campo necessário para essa ação não foi informado: " + key.Message);
}
catch (Exception ex)
{
throw new Exception("Houve um erro ao tentar editar o registro: " + ex.Message);
}
}
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_be_able_to_get_pawn_by_id()
{
// Setup
var basicPawn = new BasicPawn {
Name = "Name"
};
basicPawn.SetId("123_id");
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 storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock.Setup(provider
=> provider.GetById <BasicPawn>(It.IsAny <string>(), It.IsAny <string>())).Returns(basicPawn);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var found = bls.GetById <BasicPawn>("123");
// Assert
Assert.NotNull(found);
storageProviderMock.Verify(provider => provider.GetById <BasicPawn>("123", "BasicPawn"), Times.Once());
}
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);
}
public async Task <ActionResult <Bls> > UpdateBl([FromServices] BlServico blServico, Bls Bl)
{
try
{
return(Ok(await blServico.UpdateBl(Bl)));
}
catch (Exception ex)
{
return(UnprocessableEntity(ex.Message));
}
}
