public async Task TreeQuery_UnauthorizedUser_ThrowsException()
{
var treeId = await CreateTree();
await Assert.ThrowsAsync <UnauthorizedException>(async() =>
await QueriesExecutor.Execute(new GetTreeQuery(AuthId + "2", treeId)));
}
public async Task FileExportFileImport_TreeWithTwoPeople_PeoplePropertiesAreImported()
{
var tree = await PrepareTreeWithTwoPeople();
var export =
await QueriesExecutor.Execute(new GetTreeFileExportQuery(AuthId, new TreeId(tree.TreeId)));
const string createdTreeName = "Drzewko 🍑";
var document = new Document(export, "text/xml", "Drzewko");
var importTreeId = await CommandsExecutor.Execute(new CreateTreeFromFileCommand(AuthId, Mail, document, createdTreeName));
var importedTree = await QueriesExecutor.Execute(new GetTreeQuery(AuthId, importTreeId));
Assert.Equal(createdTreeName, importedTree.TreeName);
var princeExpected = tree.People.First(p => p.Gender == Gender.Male);
var queenExpected = tree.People.First(p => p.Gender != Gender.Male);
var prince = tree.People.First(p => p.Gender == Gender.Male);
var queen = tree.People.First(p => p.Gender != Gender.Male);
AssertPersonFieldsEqual(princeExpected, prince);
AssertPersonFieldsEqual(queenExpected, queen);
Assert.Equal(queen.Id, prince.Mother);
}
private async Task AddPersonsMainPhoto_HappyPath_FileIsReturnedInQuery()
{
_applicationFixture.FileSaver
.UploadFile(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Stream>(), Arg.Any <CancellationToken>())
.Returns(_uriExample);
var fileId = await CommandsExecutor.Execute(
new AddOrChangePersonsPhotoCommand(AuthId, _treeId, new Document(Stream.Null, "image/jpeg", "jeden"), _queenId));
Assert.NotNull(fileId);
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, _treeId));
var fileFromQueryId = tree.People.FirstOrDefault()?.MainPhoto;
Assert.Equal(fileId.Id.Value, fileFromQueryId?.Id);
Assert.Equal("jeden", fileFromQueryId?.Name);
var fileId2 = await CommandsExecutor.Execute(
new AddOrChangePersonsPhotoCommand(AuthId, _treeId, new Document(Stream.Null, "image/jpeg", "dwa"), _queenId));
var tree2 = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, _treeId));
var fileFromQueryId2 = tree2.People.FirstOrDefault()?.MainPhoto;
Assert.Equal(fileId2.Id.Value, fileFromQueryId2?.Id);
Assert.Equal("dwa", fileFromQueryId2?.Name);
}
private async Task ExportFile_HappyPath_FileIsExportetAndContainsProperData()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Filip",
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Spouse)
}));
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
var stream = await QueriesExecutor.Execute(
new GetTreeFileExportQuery(AuthId, treeId));
var serializer = new XmlSerializer(typeof(Gx.Gedcomx));
var gedcom = (Gx.Gedcomx)serializer.Deserialize(stream);
Assert.NotNull(gedcom);
Assert.Equal(2, gedcom.Persons.Count);
Assert.Single(gedcom.Persons,
p => p.Names.SelectMany(name => name.NameForm.Parts).Any(np => string.Equals(np.Value, "Elżbieta")));
Assert.NotNull(gedcom.Relationships);
Assert.Equal(RelationshipType.Couple, gedcom.Relationships.First().KnownType);
}
private async Task AddOrCreateTreePhoto_HappyPath_TreePhotoIsReturnedInTree()
{
var treeId = await CreateTree();
await AddExampleFile(treeId);
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
Assert.Equal(_uriExample, tree.PhotoUri);
}
private async Task AddOrCreateTreePhoto_HappyPath_TreePhotoIsReturnedInMyTreesList()
{
var treeId = await CreateTree();
await AddExampleFile(treeId);
var myTrees = await QueriesExecutor.Execute(
new GetMyTreesQuery(AuthId));
Assert.Equal(_uriExample, myTrees.Trees.FirstOrDefault()?.PhotoUri);
}
public async Task AddPersonToTree_HappyPath_PeopleAreAdded()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Filip",
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Spouse)
}));
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
Assert.Equal(2, tree.People.Count);
Assert.NotNull(tree.People.FirstOrDefault()?.Spouse);
Assert.Null(tree.People.FirstOrDefault()?.Mother);
Assert.Null(tree.People.FirstOrDefault()?.Father);
Assert.Equal(TreeName, tree.TreeName);
Assert.Equal(treeId.Value, tree.TreeId);
}
private async Task RemovePersonsFile_HappyPath_FileIsDeleted()
{
_applicationFixture.FileSaver
.UploadFile(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Stream>(), Arg.Any <CancellationToken>())
.Returns(_uriExample);
var file = await CommandsExecutor.Execute(
new AddPersonsFileCommand(AuthId, _treeId, new Document(Stream.Null, "image/jpeg", "file"), _queenId));
await CommandsExecutor.Execute(
new RemovePersonsFileCommand(AuthId, _treeId, file.Id, _queenId));
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, _treeId));
var files = tree.People.FirstOrDefault()?.Files;
Assert.NotNull(files);
Assert.Empty(files);
}
public async Task PlaceOrder_Test()
{
string customerEmail = "*****@*****.**";
CustomerDto customer =
await CommandsExecutor.Execute(new RegisterCustomerCommand(customerEmail, "Sample Customer"));
List <ProductDto> products = new List <ProductDto>();
Guid productId = Guid.Parse("9DB6E474-AE74-4CF5-A0DC-BA23A42E2566");
products.Add(new ProductDto(productId, 2));
Guid orderId = await CommandsExecutor.Execute(new PlaceCustomerOrderCommand(customer.Id, products, "EUR"));
OrderDetailsDto orderDetails = await QueriesExecutor.Execute(new GetCustomerOrderDetailsQuery(orderId));
Assert.That(orderDetails, Is.Not.Null);
Assert.That(orderDetails.Value, Is.EqualTo(70));
Assert.That(orderDetails.Products.Count, Is.EqualTo(1));
Assert.That(orderDetails.Products[0].Quantity, Is.EqualTo(2));
Assert.That(orderDetails.Products[0].Id, Is.EqualTo(productId));
SqlConnection connection = new SqlConnection(ConnectionString);
List <OutboxMessageDto> messagesList = await OutboxMessagesHelper.GetOutboxMessages(connection);
Assert.That(messagesList.Count, Is.EqualTo(3));
CustomerRegisteredNotification customerRegisteredNotification =
OutboxMessagesHelper.Deserialize <CustomerRegisteredNotification>(messagesList[0]);
Assert.That(customerRegisteredNotification.CustomerId, Is.EqualTo(new CustomerId(customer.Id)));
OrderPlacedNotification orderPlaced =
OutboxMessagesHelper.Deserialize <OrderPlacedNotification>(messagesList[1]);
Assert.That(orderPlaced.OrderId, Is.EqualTo(new OrderId(orderId)));
PaymentCreatedNotification paymentCreated =
OutboxMessagesHelper.Deserialize <PaymentCreatedNotification>(messagesList[2]);
Assert.That(paymentCreated, Is.Not.Null);
}
public async Task PlaceOrder_Test()
{
var customerEmail = "*****@*****.**";
var customer = await CommandsExecutor.Execute(new RegisterCustomerCommand(customerEmail, "soheil bijavar"));
List <ProductDto> products = new List <ProductDto>();
var productId = Guid.Parse("cdd19ddd-647a-4af7-9f95-cfef9e346c40");
products.Add(new ProductDto(productId, 2));
var orderId = await CommandsExecutor.Execute(new PlaceCustomerOrderCommand(customer.Id, products, "Rial"));
var orderDetails = await QueriesExecutor.Execute(new GetCustomerOrderDetailsQuery(orderId));
Assert.That(orderDetails, Is.Not.Null);
Assert.That(orderDetails.Value, Is.EqualTo(80));
Assert.That(orderDetails.Products.Count, Is.EqualTo(1));
Assert.That(orderDetails.Products[0].Quantity, Is.EqualTo(2));
Assert.That(orderDetails.Products[0].Id, Is.EqualTo(productId));
var connection = new SqlConnection(ConnectionString);
var messagesList = await OutboxMessagesHelper.GetOutboxMessages(connection);
Assert.That(messagesList.Count, Is.EqualTo(3));
var customerRegisteredNotification =
OutboxMessagesHelper.Deserialize <CustomerRegisteredNotification>(messagesList[0]);
Assert.That(customerRegisteredNotification.CustomerId, Is.EqualTo(new CustomerId(customer.Id)));
var orderPlaced =
OutboxMessagesHelper.Deserialize <OrderPlacedNotification>(messagesList[1]);
Assert.That(orderPlaced.OrderId, Is.EqualTo(new OrderId(orderId)));
var paymentCreated =
OutboxMessagesHelper.Deserialize <PaymentCreatedNotification>(messagesList[2]);
Assert.That(paymentCreated, Is.Not.Null);
}
public async Task RegisterCustomerTest()
{
const string email = "*****@*****.**";
const string name = "soheil bijavar company";
var customer = await CommandsExecutor.Execute(new RegisterCustomerCommand(email, name));
var customerDetails = await QueriesExecutor.Execute(new GetCustomerDetailsQuery(customer.Id));
Assert.That(customerDetails, Is.Not.Null);
Assert.That(customerDetails.Name, Is.EqualTo(name));
Assert.That(customerDetails.Email, Is.EqualTo(email));
var connection = new SqlConnection(ConnectionString);
var messagesList = await OutboxMessagesHelper.GetOutboxMessages(connection);
Assert.That(messagesList.Count, Is.EqualTo(1));
var customerRegisteredNotification =
OutboxMessagesHelper.Deserialize <CustomerRegisteredNotification>(messagesList[0]);
Assert.That(customerRegisteredNotification.CustomerId, Is.EqualTo(new CustomerId(customer.Id)));
}
private async Task <TreeDto> PrepareTreeWithTwoPeople()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Unknown,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Filip",
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Mother)
}));
return(await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId)));
}
public async Task CreateProfileAndTree_HappyPath_TreeIsCreated()
{
var userId = await CommandsExecutor.Execute(
new CreateOrUpdateUserProfileCommand(AuthId, Mail, Name, LastName, BirthDate));
var treeId = await CommandsExecutor.Execute(
new CreateTreeCommand(TreeName, AuthId, Mail));
var myTrees = await QueriesExecutor.Execute(
new GetMyTreesQuery(AuthId));
Assert.Single(myTrees.Trees);
var tree = myTrees.Trees[0];
Assert.Equal(tree.Id, treeId.Value);
Assert.Equal(TreeName, tree.TreeName);
var treeQuery = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
Assert.Equal(userId.Value, treeQuery.Owners.FirstOrDefault()?.Id);
}
public async Task AddRelation_TwoMothers_ThrowsException()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var queenId2 = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"III",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Queens child",
null,
Gender.Male,
new DateTime(1955, 5, 10),
null,
"Prince",
"Some biography of Filip",
null));
var princeId2 = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Queens child",
null,
Gender.Male,
new DateTime(1955, 5, 10),
null,
"Prince2",
"Some biography of Filip",
null));
await CommandsExecutor.Execute(
new AddRelationCommand(AuthId, treeId, princeId, queenId, RelationType.Mother));
await CommandsExecutor.Execute(
new AddRelationCommand(AuthId, treeId, princeId2, queenId, RelationType.Mother));
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
Assert.NotNull(tree.People.First(p => p.Id == princeId.Value).Mother);
Assert.Equal(2, tree.People.First(p => p.Id == queenId.Value).Children.Count);
await Assert.ThrowsAsync <BusinessRuleValidationException>(async() =>
await CommandsExecutor.Execute(
new AddRelationCommand(AuthId, treeId, princeId, queenId, RelationType.Mother)));
}
public async Task UpdatePerson_UpdateRelationAndName_UpdatesValues()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Filip",
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Spouse)
}));
const string newName = "If Filip was soo good why theres no Filip2";
await CommandsExecutor.Execute(
new UpdatePersonCommand(
AuthId,
treeId,
princeId,
newName,
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Mother)
}));
var tree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, treeId));
var queen = tree.People.First(p => p.Id == queenId.Value);
var prince = tree.People.First(p => p.Id == princeId.Value);
Assert.NotNull(prince.Mother);
Assert.Null(prince.Spouse);
Assert.Null(queen.Spouse);
Assert.Equal(newName, prince.Name);
}
public async Task MergeTrees_TreesWithOneOverlappingPerson_PeopleAndRelationsAreMerged()
{
var treeId = await CreateTree();
var queenId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var princeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
treeId,
"Filip",
null,
Gender.Male,
new DateTime(1921, 5, 10),
null,
"Prince",
"Some biography of Filip",
new List <Relation>
{
new Relation(queenId, RelationDirection.FromAddedPerson, RelationType.Spouse)
}));
var secondTreeId = await CreateTree();
var queenInSecondTreeId = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
secondTreeId,
"Elżbieta",
"II",
Gender.Female,
new DateTime(1926, 4, 21),
null,
"Queen",
"Some biography"));
var queenMotherInSecondTree = await CommandsExecutor.Execute(
new AddPersonCommand(
AuthId,
secondTreeId,
"Mother",
"Of Queen",
Gender.Female,
new DateTime(1896, 4, 21),
null,
"",
"Some biography",
new List <Relation>
{
new Relation(queenInSecondTreeId, RelationDirection.ToAddedPerson, RelationType.Mother)
}));
var mergedTreeId = await CommandsExecutor.Execute(
new MergeTreesCommand(treeId, secondTreeId, AuthId));
var mergedTree = await QueriesExecutor.Execute(
new GetTreeQuery(AuthId, mergedTreeId));
Assert.Equal(3, mergedTree.People.Count);
Assert.NotNull(mergedTree.People.FirstOrDefault(p => p.Name == "Elżbieta")?.Mother);
Assert.NotNull(mergedTree.People.FirstOrDefault(p => p.Name == "Elżbieta")?.Spouse);
}
