public void ChangeAssessorTests_ChangeTypeChanged_NoChangesShouldBePresentedAsThisFieldIsIgnored()
{
//Note I am using sub properties to ensure the name is ignored in both levels of different types
var source = MockDataHelper.BuildMultiLevelA("1");
source.B = MockDataHelper.BuildMultiLevelB("23145");
var destination = Mapper.Map <MultiLevelA>(source);
destination.B = Mapper.Map <MultiLevelB>(source.B);
//Ensure statuses are different
source.ChangeType = ChangeType.Updated;
destination.ChangeType = ChangeType.Added;
source.B.ChangeType = ChangeType.None;
destination.B.ChangeType = ChangeType.Deleted;
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 0, "No changes should be found as the changed fields should be ignored");
}
public void ChangeAssessorTests_SubPropertyValuesIdDifferent_SubPropertySetWithAnAddAndARemove()
{
var source = MockDataHelper.BuildMultiLevelA("123");
var destination = Mapper.Map <MultiLevelA>(source);
//Different ids
source.B = MockDataHelper.BuildMultiLevelB("1");
destination.B = Mapper.Map <MultiLevelB>(source.B);
destination.B.Id = "SOmething different";
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(0, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(2, assessment.Relationships.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
var relationshipDeleted = assessment.Relationships.FirstOrDefault(f => f.Value == destination.B);
Assert.IsNotNull(relationshipDeleted, "Destination should be in the list of changed relationships");
Assert.AreEqual(relationshipDeleted.Parent, source, "Proper parent should be assigned in the relationship ");
Assert.AreEqual(relationshipDeleted.ChangeType, ChangeType.Deleted, "Change Type is set to Added ");
var relationshipAdded = assessment.Relationships.FirstOrDefault(f => f.Value == source.B);
Assert.IsNotNull(relationshipAdded, "Destination should be in the list of changed relationships");
Assert.AreEqual(relationshipAdded.Parent, source, "Proper parent should be assigned in the relationship ");
Assert.AreEqual(relationshipAdded.ChangeType, ChangeType.Added, "Change Type is set to Added ");
}
public void ChangeAssessorTests_IgnoreFieldNameSet_ChangesAreNotDetectedForFieldsSet()
{
//Note I am using sub properties to ensure the name is ignored in both levels of different types
var source = MockDataHelper.BuildMultiLevelA("1");
source.B = MockDataHelper.BuildMultiLevelB("23145");
var destination = Mapper.Map <MultiLevelA>(source);
destination.B = Mapper.Map <MultiLevelB>(source.B);
//Change StringField, and Int32
source.StringField = Guid.NewGuid().ToString();
source.Int32Field += 2000;
source.B.StringField = Guid.NewGuid().ToString();
source.B.Int32Field += 1000;
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Ignoring both fields
.IgnoreFields("StringField", "Int32Field");
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 0, "No changes should be found as the changed fields should be ignored");
}
public void ChangeAssessorTests_SubPropertyRemoved_IsOwner_SubPropertySetAsRemoved()
{
var source = MockDataHelper.BuildMultiLevelA("1");
var destination = Mapper.Map <MultiLevelA>(source);
//Note source will now have a sub single property
//This is removed and not in the source
destination.B = MockDataHelper.BuildMultiLevelB("23145");
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note ownership assignment
.AddOwnerMapping <MultiLevelA>(a => a.B);
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 1, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(destination.B, assessment.OwnedEntities[0], "Destination record returned as Deleted");
Assert.AreEqual(ChangeType.Deleted, destination.B.ChangeType, "Change Type is set to Deleted");
//Relationships
Assert.AreEqual(assessment.Relationships.Count, 1, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities.Count));
var relationship = assessment.Relationships.FirstOrDefault(r => r.Value == destination.B);
Assert.IsNotNull(relationship, "Record {0} should be in the list of changed relationships");
Assert.AreEqual(relationship.Parent, source, "Proper parent should be assigned in the relationship");
Assert.AreEqual(relationship.ChangeType, ChangeType.Deleted, "Change Type is set to Deleted");
}
public void CreateModuloTest()
{
var modulo = MockDataHelper.Modulos.FirstOrDefault();
var plantilla = MockDataHelper.Plantillas.FirstOrDefault();
var categoria = MockDataHelper.Categorias.FirstOrDefault();
var empresas = iSeguridadService.GetProfesionales("nico", 10);
modulo.Codigo = 0;
plantilla.Codigo = 0;
categoria.Codigo = 0;
categoria.IdEmpresa = 9;
var idcategoria = this.iCategoriaService.CreateOrUpdateCategoria(1884, categoria);
plantilla.IdCategoria = idcategoria;
plantilla.Ambitos = MockDataHelper.GetListAmbito();
var idPlantilla = this.iPlantillaService.CreateOrUpdatePlantilla(1884, plantilla);
modulo.IdPlantilla = idPlantilla;
var idModulo = this.iModuloService.CreateOrUpdateModulo(1884, modulo);
Assert.IsTrue(idModulo > 0);
}
public void ChangeAssessorTests_List_RootValuesAdded_RootSetAsAdded()
{
var source = new List <OneLevel>()
{
MockDataHelper.BuildOneLevel("-2124"), MockDataHelper.BuildOneLevel("1"), MockDataHelper.BuildOneLevel("5212"), MockDataHelper.BuildOneLevel("561223")
};
//Note out of order to ensure test covers other scenarios
var destination = new List <OneLevel>()
{
source[2]
};
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatusList(source, destination);
var expectedIndices = new[] { 0, 1, 3 };
Assert.AreEqual(expectedIndices.Length, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
foreach (var expectedIndex in expectedIndices)
{
Assert.IsTrue(assessment.OwnedEntities.Contains(source[expectedIndex]), string.Format("Record {0} should be in the list of changes", expectedIndex));
Assert.AreEqual(ChangeType.Added, source[expectedIndex].ChangeType, string.Format("Record {0} should have the added change type", expectedIndex));
}
}
public void ChangeAssessorTests_SubListPropertyValuesChanged_IsOwner_SubListPropertySetAsUpdated()
{
var source = MockDataHelper.BuildMultiLevelA("1");
source.Cs = new System.Collections.Generic.List <MultiLevelC>()
{
MockDataHelper.BuildMultiLevelC("11"),
MockDataHelper.BuildMultiLevelC("22")
};
var destination = Mapper.Map <MultiLevelA>(source);
destination.Cs = source.Cs.Select(c => Mapper.Map <MultiLevelC>(c)).ToList();
destination.Cs[0].StringField = "I am different1";
destination.Cs[1].StringField = "I am different2";
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note ownership
.AddOwnerMapping <MultiLevelA>(a => a.Cs);
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 2, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities.Count));
Assert.IsTrue(assessment.OwnedEntities.Contains(source.Cs[0]), "Cs 0 returned as changed");
Assert.IsTrue(assessment.OwnedEntities.Contains(source.Cs[1]), "Cs 1 returned as changed");
Assert.AreEqual(source.Cs[0].ChangeType, ChangeType.Updated, "Change Type is set to updated for C 0");
Assert.AreEqual(source.Cs[1].ChangeType, ChangeType.Updated, "Change Type is set to updated for C 1");
}
public void ChangeAssessorTests_SubPropertyAdded_IsOwner_SubPropertySetAsAdded()
{
var source = MockDataHelper.BuildMultiLevelA("1");
var destination = Mapper.Map <MultiLevelA>(source);
//Note source will now have a sub single property
//This is new and not in the destiation
source.B = MockDataHelper.BuildMultiLevelB("23145");
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note owner addition
.AddOwnerMapping <MultiLevelA>(a => a.B)
;
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 1, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(source.B, assessment.OwnedEntities[0], "Source record returned as Added");
Assert.AreEqual(source.B.ChangeType, ChangeType.Added, "Change Type is set to Added");
//relationships
Assert.AreEqual(assessment.Relationships.Count, 1, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(source.B, assessment.Relationships[0].Value, "Source record returned as in relationship changes");
Assert.AreEqual(assessment.Relationships[0].Parent, source, "Proper parent should be assigned in the relationship");
Assert.AreEqual(assessment.Relationships[0].ChangeType, ChangeType.Added, "Change Type is set to Added");
}
public async Task GetMovie_200(string movieId, MovieEntity expectedMovie)
{
// Arrange
var expectedResult = Mapper.Map <MovieEntity, GetMovieResponse>(expectedMovie);
var mockMovieService = new Mock <IMovieService>();
mockMovieService.Setup(x => x.GetOne(It.IsAny <string>()))
.Returns((string mId) => Task.FromResult(MockDataHelper.GetMovie(mId)));
// Act
var movieController = new MovieController(Mapper, mockMovieService.Object);
var response = await movieController.GetMovieMetaInfo(movieId);
// Assert
var okResponse = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsAssignableFrom <GetMovieResponse>(okResponse.Value);
Assert.Equal(expectedResult.Id, result.Id);
Assert.Equal(expectedResult.Title, result.Title);
Assert.Equal(expectedResult.PlotSummary, result.PlotSummary);
Assert.Equal(expectedResult.Director, result.Director);
Assert.Equal(expectedResult.Tags, result.Tags);
Assert.Equal(expectedResult.ReleaseDate, result.ReleaseDate);
Assert.Equal(expectedResult.Language, result.Language);
Assert.Equal(expectedResult.CountReviews, result.CountReviews);
Assert.Equal(expectedResult.Rating, result.Rating);
}
public void ChangeAssessorTests_List_RootValuesNoChangeAndOutOfOrder_RootSetAsAdded()
{
var source = new List <OneLevel>()
{
MockDataHelper.BuildOneLevel("-2124"), MockDataHelper.BuildOneLevel("1"), MockDataHelper.BuildOneLevel("5212"), MockDataHelper.BuildOneLevel("561223")
};
//Note out of order to ensure test covers other scenarios
var destination = new List <OneLevel>()
{
Mapper.Map <OneLevel>(source[2]),
Mapper.Map <OneLevel>(source[1]),
Mapper.Map <OneLevel>(source[0]),
Mapper.Map <OneLevel>(source[3])
};
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatusList(source, destination);
Assert.AreEqual(0, assessment.OwnedEntities.Count, string.Format("No changes expected, received {0}", assessment.OwnedEntities.Count));
foreach (var sourceItem in source)
{
Assert.AreEqual(ChangeType.None, sourceItem.ChangeType, string.Format("Record {0} should have the none change type", sourceItem.Id));
}
}
public void ChangeAssessorTests_SubListPropertyValuesAddDeletedAndUpdated_IsOwner_SubListPropertySetAsMixedStatuses()
{
var source = MockDataHelper.BuildMultiLevelA("123");
var destination = Mapper.Map <MultiLevelA>(source);
source.B = MockDataHelper.BuildMultiLevelB("5523");
destination.B = MockDataHelper.BuildMultiLevelB("5523");
//The root is changed as well
destination.StringField = Guid.NewGuid().ToString();
//Note out of order to ensure test covers other scenarios
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note ownership
.AddOwnerMapping <MultiLevelA>(a => a.B);
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(2, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
Assert.IsTrue(assessment.OwnedEntities.Contains(source), "Root record should be in the list of changes");
Assert.AreEqual(ChangeType.Updated, source.ChangeType, string.Format("Record {0} should have the update change type", 2));
Assert.IsTrue(assessment.OwnedEntities.Contains(source.B), "Sub record should be in the list of changes");
Assert.AreEqual(ChangeType.Updated, source.B.ChangeType, string.Format("Record {0} should have the update change type", 2));
}
public void ChangeAssessorTests_ListDestinationNull_RootValuesAdded_RootSetAsAdded()
{
var source = new List <OneLevel>()
{
MockDataHelper.BuildOneLevel("-2124"), MockDataHelper.BuildOneLevel("1"), MockDataHelper.BuildOneLevel("5212"), MockDataHelper.BuildOneLevel("561223")
};
//note null
List <OneLevel> destination = null;
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatusList(source, destination);
var expectedIndices = Enumerable.Range(0, source.Count);
Assert.AreEqual(expectedIndices.Count(), assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
foreach (var expectedIndex in expectedIndices)
{
Assert.IsTrue(assessment.OwnedEntities.Contains(source[expectedIndex]), string.Format("Record {0} should be in the list of changes", expectedIndex));
Assert.AreEqual(ChangeType.Added, source[expectedIndex].ChangeType, string.Format("Record {0} should have the added change type", expectedIndex));
}
}
public void Test2()
{
var mockData = MockDataHelper.GetInvoiceData();
InvoiceDataStore.Add(mockData);
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
Assert.That(_invoiceStore[mockData.InvoiceNo].TotalAmount == mockData.TotalAmount);
}
public void ChangeAssessorTests_List_SubPropertyValuesAddDeletedAndUpdatedAndRootUpdated_SubPropertySetAsMixedStatuses()
{
var source = MockDataHelper.BuildMultiLevelA("123");
var destination = Mapper.Map <MultiLevelA>(source);
source.Cs = new List <MultiLevelC>()
{
MockDataHelper.BuildMultiLevelC("-2124"), MockDataHelper.BuildMultiLevelC("1"), MockDataHelper.BuildMultiLevelC("5212")
};
destination.Cs = new List <MultiLevelC>()
{
//Existing, unchanged
Mapper.Map <MultiLevelC>(source.Cs[0]),
//To Be updated
MockDataHelper.BuildMultiLevelC("1"),
//Note index 2 is not here and therefore added
//Does not exist in source and therefore will be deleted
MockDataHelper.BuildMultiLevelC("14wdwedqweqe")
};
//The root is changed as well
destination.StringField = Guid.NewGuid().ToString();
//Note out of order to ensure test covers other scenarios
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(1, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(2, assessment.Relationships.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
Assert.IsTrue(assessment.OwnedEntities.Contains(source), "Root record should be in the list of changes");
Assert.AreEqual(ChangeType.Updated, source.ChangeType, string.Format("Record {0} should have the update change type", 2));
Assert.AreEqual(ChangeType.None, source.Cs[0].ChangeType, string.Format("Record {0} should have the none change type", 0));
Assert.AreEqual(ChangeType.None, source.Cs[1].ChangeType, string.Format("Record {0} should have the none change type as it is not owned", 1));
var relationshipS2 = assessment.Relationships.FirstOrDefault(r => r.Value == source.Cs[2]);
Assert.IsNotNull(relationshipS2, "Record 2 should be in the list of changed relationships S2");
Assert.AreEqual(relationshipS2.Parent, source, "Proper parent should be assigned in the relationship S2");
Assert.AreEqual(relationshipS2.ChangeType, ChangeType.Added, "Change Type is set to Added S2");
Assert.AreEqual(source.Cs[2].ChangeType, ChangeType.None, "Actual Entity type not changed due to lack of ownership S2");
var relationshipD2 = assessment.Relationships.FirstOrDefault(r => r.Value == destination.Cs[2]);
Assert.IsNotNull(relationshipD2, "Record 2 should be in the list of changed relationships D2");
Assert.AreEqual(relationshipD2.Parent, source, "Proper parent should be assigned in the relationship D2");
Assert.AreEqual(relationshipD2.ChangeType, ChangeType.Deleted, "Change Type is set to Deleted D2");
Assert.AreEqual(destination.Cs[2].ChangeType, ChangeType.None, "Actual Entity type not changed due to lack of ownership D2");
}
public async Task GetRecentReviews_200(string userName, int maxItems, MovieReviewDto expectedReviews)
{
// Arrange
// Arrange
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userName),
}, "mock"));
var expectedResult = Mapper.Map <MovieReviewDto, GetRecentReviewsResponse>(expectedReviews);
var mockReviewService = new Mock <IReviewService>();
mockReviewService.Setup(x => x.GetRecentReviewsFromFollowedAsync(It.IsAny <string>(), It.IsAny <int>()))
.Returns((string mId, int maxItems) => {
var reviews = MockDataHelper.GetReviews(mId);
return(Task.FromResult(new MovieReviewDto
{
Reviews = reviews.Reviews.Take(maxItems)
}));
});
// Act
var reviewController = new ReviewController(Mapper, mockReviewService.Object);
var request = new GetRecentReviewsRequest
{
NumberOfItems = 10
};
reviewController.ControllerContext.HttpContext = new DefaultHttpContext {
User = user
};
MockModelState(request, reviewController);
var response = await reviewController.GetRecentReviews(request);
// Assert
var okResponse = Assert.IsType <OkObjectResult>(response.Result);
var result = Assert.IsAssignableFrom <GetRecentReviewsResponse>(okResponse.Value);
Assert.True(maxItems >= result.Reviews.Count());
foreach (var(actualReview, expectedReview) in result.Reviews.Zip(expectedResult.Reviews))
{
Assert.Equal(expectedReview.Author.DisplayName, actualReview.Author.DisplayName);
Assert.Equal(expectedReview.Author.UserName, actualReview.Author.UserName);
Assert.Equal(expectedReview.Author.Followers, actualReview.Author.Followers);
Assert.Equal(expectedReview.Author.Id, actualReview.Author.Id);
Assert.Equal(expectedReview.Description, actualReview.Description);
Assert.Equal(expectedReview.Rating, actualReview.Rating);
Assert.Equal(expectedReview.Title, actualReview.Title);
Assert.Equal(expectedReview.Movie.Id, actualReview.Movie.Id);
Assert.Equal(expectedReview.Movie.Title, actualReview.Movie.Title);
}
}
public void Test5()
{
var mockData = MockDataHelper.GetInvoiceData();
InvoiceDataStore.Update(mockData.InvoiceNo, mockData);
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
Assert.That(_invoiceStore[mockData.InvoiceNo].Status == Status.NotProcessed);
InvoiceDataStore.UpdateStatus(mockData.InvoiceNo, Status.Digitized);
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
Assert.That(_invoiceStore[mockData.InvoiceNo].Status == Status.Digitized);
}
public ActionResult News()
{
NewsModel news = new NewsModel();
int day = DateTime.Now.Day;
if (day == 15 || day == 30)
{
MockDataHelper.UpdateNewsMockData();
}
news = GetDataHelper.GetNews();
return(View(news));
}
public void ChangeAssessorTests_RootValuesChanged_RootSetAsNoChange()
{
//Note both should be randomly generated but have the same ID
var source = MockDataHelper.BuildOneLevel("1");
var destination = Mapper.Map <OneLevel>(source);
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 0, string.Format("No changes expected, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(source.ChangeType, ChangeType.None, "Change Type is set to NoChange");
}
public void Test1()
{
var mockData = MockDataHelper.GetInvoiceData();
Assert.That(!string.IsNullOrEmpty(mockData.InvoiceNo));
Assert.That(mockData.InvoiceDate != null);
Assert.That(mockData.Seller != null && !string.IsNullOrEmpty(mockData.Seller.Name));
Assert.That(mockData.BillTo != null && !string.IsNullOrEmpty(mockData.BillTo.Name));
Assert.That(mockData.ShipTo != null && !string.IsNullOrEmpty(mockData.ShipTo.Name));
Assert.That(mockData.Items != null && mockData.Items.Count() > 0);
Assert.That(mockData.SubTotal != 0);
Assert.That(mockData.TotalAmount != 0);
}
public void Test3()
{
var mockData = MockDataHelper.GetInvoiceData();
InvoiceDataStore.Add(mockData);
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
mockData.Seller.Name = "Zomato";
mockData.ShipTo.ZipCode = "234323";
InvoiceDataStore.Update(mockData.InvoiceNo, mockData);
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
Assert.That(_invoiceStore[mockData.InvoiceNo].Seller.Name.Equals("Zomato"));
Assert.That(_invoiceStore[mockData.InvoiceNo].ShipTo.ZipCode.Equals("234323"));
}
public async Task GetMovie_400(string movieId)
{
// Arrange
var mockMovieService = new Mock <IMovieService>();
mockMovieService.Setup(x => x.GetOne(It.IsAny <string>()))
.Returns((string mId) => Task.FromResult(MockDataHelper.GetMovie(mId)));
// Act
var movieController = new MovieController(Mapper, mockMovieService.Object);
var response = await movieController.GetMovieMetaInfo(movieId);
// Assert
var badRequest = Assert.IsType <BadRequestObjectResult>(response.Result);
}
public void ChangeAssessorTests_RootValuesChanged_RootSetAsUpdated()
{
//Note both should be randomly generated but have the same ID
var source = MockDataHelper.BuildOneLevel("1");
var destination = MockDataHelper.BuildOneLevel("1");
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 1, string.Format("One and only one change is expected, received {0}", assessment.OwnedEntities));
Assert.AreEqual(source, assessment.OwnedEntities[0], "Source record returned as changed");
Assert.AreEqual(source.ChangeType, ChangeType.Updated, "Change Type is set to updated");
}
public void ChangeAssessorTests_List_SubPropertyValuesAddDeletedAndUpdatedAndRootUpdated_IsOwner_SubPropertySetAsMixedStatuses()
{
var source = MockDataHelper.BuildMultiLevelA("123");
var destination = Mapper.Map <MultiLevelA>(source);
source.Cs = new List <MultiLevelC>()
{
MockDataHelper.BuildMultiLevelC("-2124"), MockDataHelper.BuildMultiLevelC("1"), MockDataHelper.BuildMultiLevelC("5212")
};
destination.Cs = new List <MultiLevelC>()
{
//Existing, unchanged
Mapper.Map <MultiLevelC>(source.Cs[0]),
//To Be updated
MockDataHelper.BuildMultiLevelC("1"),
//Note index 2 is not here and therefore added
//Does not exist in source and therefore will be deleted
MockDataHelper.BuildMultiLevelC("14wdwedqweqe")
};
//The root is changed as well
destination.StringField = Guid.NewGuid().ToString();
//Note out of order to ensure test covers other scenarios
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Adding Ownershio
.AddOwnerMapping <MultiLevelA>(c => c.Cs);
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(4, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
Assert.IsTrue(assessment.OwnedEntities.Contains(source), "Root record should be in the list of changes");
Assert.AreEqual(ChangeType.Updated, source.ChangeType, string.Format("Record {0} should have the update change type", 2));
Assert.AreEqual(ChangeType.None, source.Cs[0].ChangeType, string.Format("Record {0} should have the none change type", 0));
Assert.IsTrue(assessment.OwnedEntities.Contains(source.Cs[1]), string.Format("Record {0} should be in the list of changes", 1));
Assert.AreEqual(ChangeType.Updated, source.Cs[1].ChangeType, string.Format("Record {0} should have the updated change type", 1));
Assert.IsTrue(assessment.OwnedEntities.Contains(source.Cs[2]), string.Format("Record {0} should be in the list of changes", 2));
Assert.AreEqual(ChangeType.Added, source.Cs[2].ChangeType, string.Format("Record {0} should have the added change type", 2));
Assert.IsTrue(assessment.OwnedEntities.Contains(destination.Cs[2]), string.Format("Record {0} should be in the list of changes", 2));
Assert.AreEqual(ChangeType.Deleted, destination.Cs[2].ChangeType, string.Format("Record {0} should have the removed change type", 2));
}
/// <summary>
/// Parsing the invoice file and extract and stores the data
/// Actual Parsing Need to be implemented
/// </summary>
/// <param name="filePath"> Invoice file path</param>
/// <returns></returns>
public bool ProcessInvoice(IEnumerable <string> invoiceFiles)
{
try {
foreach (var file in invoiceFiles)
{
var data = MockDataHelper.GetInvoiceData();
data.Status = Status.Digitized;
InvoiceDataStore.Add(data);
}
return(true);
}
catch (Exception) {
return(false);
}
}
public void ChangeAssessorTests_SubListPropertyValuessAdded_IsOwner_SubListPropertySetAsAdded()
{
var source = MockDataHelper.BuildMultiLevelA("1");
source.Cs = new System.Collections.Generic.List <MultiLevelC>()
{
MockDataHelper.BuildMultiLevelC("00"),
MockDataHelper.BuildMultiLevelC("11"),
MockDataHelper.BuildMultiLevelC("22")
};
var destination = Mapper.Map <MultiLevelA>(source);
//Note only one exists therefore 2 should be added
destination.Cs = new List <MultiLevelC>()
{
Mapper.Map <MultiLevelC>(source.Cs[1])
};
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note ownership
.AddOwnerMapping <MultiLevelA>(a => a.Cs);
var assessment = changeAssessor.SetChangeStatus(source, destination);
var expectedIndices = new[] { 0, 2 };
Assert.AreEqual(expectedIndices.Length, assessment.OwnedEntities.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
foreach (var expectedIndex in expectedIndices)
{
Assert.IsTrue(assessment.OwnedEntities.Contains(source.Cs[expectedIndex]), string.Format("Record {0} should be in the list of changes", expectedIndex));
Assert.AreEqual(ChangeType.Added, source.Cs[expectedIndex].ChangeType, string.Format("Record {0} should have the added change type", expectedIndex));
}
//Relationships
Assert.AreEqual(expectedIndices.Length, assessment.Relationships.Count, string.Format("Invalid change count, received {0}", assessment.OwnedEntities.Count));
foreach (var expectedIndex in expectedIndices)
{
var relationship = assessment.Relationships.FirstOrDefault(r => r.Value == source.Cs[expectedIndex]);
Assert.IsNotNull(relationship, string.Format("Record {0} should be in the list of changed relationships", expectedIndex));
Assert.AreEqual(relationship.Parent, source, "Proper parent should be assigned in the relationship " + expectedIndex);
Assert.AreEqual(relationship.ChangeType, ChangeType.Added, "Change Type is set to Added " + expectedIndex);
}
}
public void GetAgrupadorUnitTest()
{
var agrupador1 = MockDataHelper.Agrupadores.FirstOrDefault();
var modulo = MockDataHelper.Modulos.FirstOrDefault();
var plantilla = MockDataHelper.Plantillas.FirstOrDefault();
var categoria = MockDataHelper.Categorias.FirstOrDefault();
categoria.Codigo = 0;
categoria.IdEmpresa = 11;
categoria.Vigencia = Vigencia.NoVigente;
plantilla.Codigo = 0;
plantilla.Vigencia = Vigencia.NoVigente;
modulo.Codigo = 0;
modulo.Vigencia = Vigencia.NoVigente;
var idcategoria = this.iCategoriaService.CreateOrUpdateCategoria(11, categoria);
plantilla.IdCategoria = idcategoria;
plantilla.Ambitos = MockDataHelper.GetListAmbito();
var idPlantilla = this.iPlantillaService.CreateOrUpdatePlantilla(11, plantilla);
modulo.IdPlantilla = idPlantilla;
var idModulo = this.iModuloService.CreateOrUpdateModulo(11, modulo);
agrupador1.Codigo = 0;
agrupador1.IdModulo = idModulo;
var id = this.iAgrupadorService.CreateOrUpdateAgrupador(11, agrupador1);
Assert.IsTrue(id > 0);
var agrupador2 = this.iAgrupadorService.GetAgrupador(id);
Assert.IsTrue(agrupador1.AlineacionAyuda == agrupador2.AlineacionAyuda);
Assert.IsTrue(agrupador1.IdModulo == agrupador2.IdModulo);
Assert.IsTrue(agrupador1.Nombre == agrupador2.Nombre);
Assert.IsTrue(agrupador1.IsNombreVisible == agrupador2.IsNombreVisible);
Assert.IsTrue(agrupador1.Orden == agrupador2.Orden);
Assert.IsTrue(agrupador1.TextoAyuda == agrupador2.TextoAyuda);
Assert.IsTrue(agrupador1.Vigencia == agrupador2.Vigencia);
}
public void AutoMapper_ConvertFrom_AcceptedRequest_IsValid()
{
var entity = MockDataHelper.GetAcceptedRequestMock();
var acceptedRequest = new AcceptedRequestMappingProfile();
var mapperConfig = new MapperConfiguration(m =>
{
m.AddProfile(acceptedRequest);
});
mapperConfig.AssertConfigurationIsValid();
var mapper = new Mapper(mapperConfig);
var dto = mapper.Map <AcceptedRequestDto>(entity);
Assert.IsNotNull(dto);
Assert.IsInstanceOf <AcceptedRequestDto>(dto);
Assert.IsTrue(dto.RequestId == entity.RequestId);
}
public void ChangeAssessorTests_IgnoreBaseClassSet_ChangesAreNotDetectedForBaseClassFields()
{
var source = MockDataHelper.BuildMultiLevelC("1");
var destination = Mapper.Map <MultiLevelC>(source);
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>()
//Note ignoring the whole class
.IgnoreFields <BaseClassToIgnore>()
;
//Only change fields from ignored class cast for test safety
var sourceCastToBaseClass = (BaseClassToIgnore)source;
sourceCastToBaseClass.StringField = Guid.NewGuid().ToString();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 0, "No changes should be found as the changed fields should be ignored");
}
public void Test4()
{
var mockData = MockDataHelper.GetInvoiceData();
InvoiceDataStore.Add(mockData);
var oldInvoiceNo = mockData.InvoiceNo;
var newInvoiceNo = Guid.NewGuid().ToString();
Assert.That(_invoiceStore.ContainsKey(mockData.InvoiceNo));
mockData.InvoiceNo = newInvoiceNo;
mockData.Seller.Name = "Zomato";
mockData.ShipTo.ZipCode = "234323";
InvoiceDataStore.Update(mockData.InvoiceNo, mockData);
Assert.That(_invoiceStore.ContainsKey(newInvoiceNo));
Assert.That(_invoiceStore[newInvoiceNo].Seller.Name.Equals("Zomato"));
Assert.That(_invoiceStore[newInvoiceNo].ShipTo.ZipCode.Equals("234323"));
Assert.That(_invoiceStore.ContainsKey(oldInvoiceNo));
}
public void ChangeAssessorTests_SubPropertyValuesChanged_SubPropertySetAsNoChange()
{
var source = MockDataHelper.BuildMultiLevelA("1");
source.B = MockDataHelper.BuildMultiLevelB("2");
var destination = Mapper.Map <MultiLevelA>(source);
destination.B = Mapper.Map <MultiLevelB>(source.B);
ChangeAssessor <string> changeAssessor = new ChangeAssessor <string>();
var assessment = changeAssessor.SetChangeStatus(source, destination);
Assert.AreEqual(assessment.OwnedEntities.Count, 0, string.Format("No changes expected, received {0}", assessment.OwnedEntities.Count));
Assert.AreEqual(source.B.ChangeType, ChangeType.None, "Change Type is set to None");
}
