public void Verify_MapToEntity_AssignsPersonProperties()
{
// Arrange
var mapper = new PersonMapper();
var model = PeopleMockingSetup.DoMockingSetupForPersonModel();
// Act
var entity = mapper.MapToEntity(model.Object);
// Assert
Assert.Equal(model.Object.Hometown, entity.Hometown);
Assert.Equal(model.Object.Country, entity.Country);
Assert.Equal(model.Object.Email, entity.Email);
Assert.Equal(model.Object.Website, entity.Website);
Assert.Equal(model.Object.BirthDate, entity.BirthDate);
Assert.Equal(model.Object.DeathDate, entity.DeathDate);
// Related Objects
Assert.Equal(model.Object.PrimaryImageFileId, entity.PrimaryImageFileId);
Assert.Equal(model.Object.GenderId, entity.GenderId);
// Associated Objects
//Assert.Equal(model.Object.CharactersCreated?.Count, entity.CharactersCreated?.Count);
model.VerifyGet(x => x.CharactersCreated, Times.Once);
//Assert.Equal(model.Object.PersonAliases?.Count, entity.PersonAliases?.Count);
model.VerifyGet(x => x.PersonAliases, Times.Once);
//Assert.Equal(model.Object.IssuesWritten?.Count, entity.IssuesWritten?.Count);
model.VerifyGet(x => x.IssuesWritten, Times.Once);
//Assert.Equal(model.Object.MoviesProduced?.Count, entity.MoviesProduced?.Count);
model.VerifyGet(x => x.MoviesProduced, Times.Once);
//Assert.Equal(model.Object.MoviesWritten?.Count, entity.MoviesWritten?.Count);
model.VerifyGet(x => x.MoviesWritten, Times.Once);
//Assert.Equal(model.Object.PromosWritten?.Count, entity.PromosWritten?.Count);
model.VerifyGet(x => x.PromosWritten, Times.Once);
//Assert.Equal(model.Object.StoryArcsWritten?.Count, entity.StoryArcsWritten?.Count);
model.VerifyGet(x => x.StoryArcsWritten, Times.Once);
//Assert.Equal(model.Object.VolumesWritten?.Count, entity.VolumesWritten?.Count);
model.VerifyGet(x => x.VolumesWritten, Times.Once);
}
public void Map()
{
// Arrange
var start = new DateTime(2010, 1, 1);
var end = DateUtility.MaxDate;
var range = new DateRange(start, end);
var id = new EnergyTrading.Mdm.Contracts.MdmId { SystemName = "Test", Identifier = "A" };
var contractDetails = new EnergyTrading.MDM.Contracts.Sample.PersonDetails();
var contract = new EnergyTrading.MDM.Contracts.Sample.Person
{
Identifiers = new EnergyTrading.Mdm.Contracts.MdmIdList { id },
Details = contractDetails,
MdmSystemData = new EnergyTrading.Mdm.Contracts.SystemData { StartDate = start, EndDate = end }
};
// NB Don't assign validity here, want to prove SUT sets it
var personDetails = new PersonDetails();
var mapping = new PersonMapping();
var mappingEngine = new Mock<IMappingEngine>();
mappingEngine.Setup(x => x.Map<EnergyTrading.Mdm.Contracts.MdmId, PersonMapping>(id)).Returns(mapping);
mappingEngine.Setup(x => x.Map<EnergyTrading.MDM.Contracts.Sample.PersonDetails, PersonDetails>(contractDetails)).Returns(personDetails);
var mapper = new PersonMapper(mappingEngine.Object);
// Act
var candidate = mapper.Map(contract);
// Assert
Assert.AreEqual(1, candidate.Details.Count, "Detail count differs");
Assert.AreEqual(1, candidate.Mappings.Count, "Mapping count differs");
Check(range, personDetails.Validity, "Validity differs");
}
public void Arrange()
{
person = new Person
{
FirstName = "John",
LastName = "Test",
DateOfBirth = new DateTime(1980, 2, 24)
};
mapper = new PersonMapper();
}
public void GetById_SeededPerson()
{
var person2 = _personRepositorySUT.GetById(Seed.JohnTravolta.Id);
var person = PersonMapper.MapToDetailModel(Seed.JohnTravolta);
Assert.Equal(person, person2, PersonDetailModel.PersonDetailModelComparer);
Assert.Equal(person.ActedInFilms, person2.ActedInFilms,
ActedInFilmDetailModel.ActedInFilmDetailModelComparer);
Assert.Equal(person.DirectedFilms, person2.DirectedFilms,
DirectedFilmDetailModel.DirectedFilmDetailModelComparer);
}
public async Task <PersonDTO> CreatePerson(PersonDTO personModel)
{
Person person = PersonMapper.ConvertModelToEntity(personModel);
if (await _personRepo.CreatePerson(person))
{
return(PersonMapper.ConvertEntityToModel(person));
}
return(null);
}
public void Verify_AreEqual_WithEqualObjects_ReturnsTrue()
{
// Arrange
var mapper = new PersonMapper();
var model = PeopleMockingSetup.DoMockingSetupForPersonModel(1);
var entity = PeopleMockingSetup.DoMockingSetupForPerson(1);
// Act
var result = mapper.AreEqual(model.Object, entity.Object);
// Assert
Assert.True(result);
}
public void ReturnNull()
{
// Arrange
var sut = new PersonMapper(_mapperMock.Object);
// Act
var result = sut.Convert((Person)null);
// Assert
Assert.Null(result);
}
public Task <IEnumerable <Dto.PersonDto> > Get()
{
var service = new PersonService();
var data = service.GetManyByAsync();
var mapper = new PersonMapper();
var mappedData = mapper.MapManyAsync(data);
return(mappedData);
}
public async Task <PersonDTO> GetPerson(int personId)
{
var person = await _personRepo.GetPersonById(personId);
if (person != null)
{
return(PersonMapper.ConvertEntityToModel(person));
}
return(null);
}
public PersonListModel GetByIdListModel(Guid id)
{
using (var dbContext = _dbContextSqlFactory.CreateDbContext())
{
var entity = dbContext.People.FirstOrDefault(t => t.Id == id);
if (entity == null)
{
return(null);
}
return(PersonMapper.MapPersonEntityToListModel(entity));
}
}
public void Verify_AreEqual_WithDifferentObjects_ReturnsFalse()
{
// Arrange
var mapper = new PersonMapper();
var model = PeopleMockingSetup.DoMockingSetupForPersonModel(1);
var entity = PeopleMockingSetup.DoMockingSetupForPerson(2);
// Act
var result = mapper.AreEqual(model.Object, entity.Object);
// Assert
Assert.False(result);
}
public void Update_Name_FromSeeded_CheckUpdated()
{
//Arrange
var person = PersonMapper.MapToDetailModel(Seed.RandalKleiser);
person.FirstName = "Changed first name to joe";
//Act & Assert
person = _personRepositorySUT.InsertOrUpdate(person);
var person2 = _personRepositorySUT.GetById(person.Id);
Assert.Equal(person, person2, PersonDetailModel.PersonDetailModelComparer);
}
public void FindAll_WhenCalledCorrectly_Succeeds()
{
// Assemble
var personRepository = new Mock<IPersonRepository>();
personRepository.Setup(a => a.FindAll())
.Returns(new List<PersonEntity> {PersonMapper.ToEntity(SampleData.SamplePersonData.ValidSamplePerson1())});
// Act
var persons = personRepository.Object.FindAll();
// Assert
Assert.NotNull(persons);
}
public void MapToOData()
{
var pm = new PersonMapper();
var p = Person.Create();
var json = pm.MapToOData(p, Mapper.OperationTypes.Update);
Assert.IsNotNull(json);
Assert.AreEqual(Person.JsonData, System.Text.RegularExpressions.Regex.Replace(json.ToString(), @"\s+", " "));
json = pm.MapToOData(p, Mapper.OperationTypes.Create);
Assert.AreEqual(Person.JsonData.Replace("\"IdX\": 1, ", ""), System.Text.RegularExpressions.Regex.Replace(json.ToString(), @"\s+", " "));
}
public int SaveOrder(HttpContext context)
{
var order = _sessionContainer.GetOrderFromSession(context, "order");
var personId = _orderBroker.SavePerson(PersonMapper.PersonDTOToPerson(order.Person));
//var businessId = _broker.SaveBusiness(BusinessMapper.BusinessDTOToBusiness(order.Business));
var orderId = _orderBroker.SaveOrder(OrderMapper.OrderDTOToOrder(order, personId));
_orderBroker.SaveBusinessOrder(order.Business.Id, orderId);
_orderBroker.SaveOrderProduct(OrderMapper.OrderDTOToOrderProduct(orderId, order.Products));
return(orderId);
}
public PersonVM Get(int id)
{
if (id == 0)
{
id = 14; //14 is currently logged in user
}
var context = new Model.hackathon_shift_2016_testEntities();
var viewModel = PersonMapper.Map(context.Person.Single(person => person.Id == id));
context.Dispose();
return(viewModel);
}
public void GetPersonById_WhenCalledCorrectly_Succeeds()
{
// Assemble
var personRepository = new Mock<IPersonRepository>();
personRepository.Setup(a => a.FindById(It.IsAny<long>()))
.Returns(PersonMapper.ToEntity(SampleData.SamplePersonData.ValidSamplePerson1()));
// Act
var person = personRepository.Object.FindById(1);
// Assert
Assert.NotNull(person);
}
public override void PreInitialize()
{
Configuration.Authorization.Providers.Add <AbpStudyAuthorizationProvider>();
Configuration.Authorization.Providers.Add <PersonAuthorizationProvider>();
// 自定义类型映射
Configuration.Modules.AbpAutoMapper().Configurators.Add(configuration =>
{
// XXXMapper.CreateMappers(configuration);
PersonMapper.CreateMappings(configuration);
});
}
public List <OrderDTO> GetPersonsByOrderIds(List <int> orderIds)
{
List <OrderDTO> orders = new List <OrderDTO>();
foreach (var orderId in orderIds)
{
OrderDTO order = new OrderDTO();
order.Id = orderId;
order.Person = PersonMapper.PersonToPersonDTO(_orderBroker.GetPersonByOrderId(orderId));
orders.Add(order);
}
return(orders);
}
public ActionResult <PersonDto> Put([FromRoute] int id, [FromBody] PersonDto personDto)
{
try
{
var person = new PersonMapper().ToModel(personDto);
person.PersonId ??= id;
var result = _unitOfWork.Persons.Update(id, person);
_unitOfWork.Save();
return(Ok(new PersonMapper().ToDto(result)));
}
catch (Exception e)
{
throw new HttpRequestException(e.Message, e, HttpStatusCode.InternalServerError);
}
}
public void Update_Name_FromSeeded_CheckUpdated()
{
//Arrange
var detailModel = PersonMapper.MapPersonEntityToDetailModel(DAL.Seed.MarkHamill);
detailModel.Name = "Changed recipe name 1";
//Act
RepositorySUT.Update(detailModel);
//Assert
var returnedModel = RepositorySUT.GetById(detailModel.Id);
Assert.Equal(detailModel, returnedModel, PersonDetailModel.PersonDetailModelComparer);
}
public ESDATChemistryMapperFactory(ODM2DuplicateChecker duplicateChecker, IWQDefaultValueProvider WQDefaultValueProvider, WayToHandleNewData wayToHandleNewData, List<IResult> results)
{
this.WQDefaultValueProvider = WQDefaultValueProvider;
ActionMapper = new ChemistryActionMapper(duplicateChecker, this, WQDefaultValueProvider, wayToHandleNewData, results);
ActionByMapper = new ActionByMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
AffiliationMapper = new AffiliationMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
AffiliationMapper.BackingStore = new List<Affiliation>();
DatasetMapper = new DatasetMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
DatasetMapper.BackingStore = new List<Dataset>();
DatasetsResultMapper = new DatasetsResultMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
FeatureActionMapper = new ChemistryFeatureActionMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
MeasurementResultMapper = new ChemistryMeasurementResultMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
MeasurementResultValueMapper = new ChemistryMeasurementResultValueMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
MethodMapper = new ChemistryMethodMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
MethodMapper.BackingStore = new List<Method>();
OrganizationMapper = new ChemistryOrganizationMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
OrganizationMapper.BackingStore = new List<Organization>();
PersonMapper = new PersonMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
PersonMapper.BackingStore = new List<Person>();
ProcessingLevelMapper = new ProcessingLevelMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
ProcessingLevelMapper.BackingStore = new List<ProcessingLevel>();
RelatedActionMapper = new RelatedActionMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
ResultMapper = new ChemistryResultMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
SamplingFeatureMapper = new ChemistrySamplingFeatureMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
SamplingFeatureMapper.BackingStore = new List<SamplingFeature>();
UnitMapper = new ChemistryUnitMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
UnitMapper.BackingStore = new List<Unit>();
VariableMapper = new ChemistryVariableMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
VariableMapper.BackingStore = new List<Variable>();
ResultExtensionPropertyValueMapper = new ResultExtensionPropertyValueMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
ExtensionPropertyMapper = new ExtensionPropertyMapper(duplicateChecker, WQDefaultValueProvider, wayToHandleNewData, results);
ExtensionPropertyMapper.BackingStore = new List<ExtensionProperty>();
}
public void MapperBase_MergeWith_AllPropertiesMerged()
{
var persons = MockDataFactory.GetPersons();
var personMapper = new PersonMapper();
var dtos = persons.AsQueryable().Select(personMapper.SelectorExpression);
Assert.AreEqual(2, dtos.Count());
foreach (var person in persons)
{
var correspondingDto = dtos.Where(p => p.Id == person.Id).FirstOrDefault();
Assert.IsNotNull(correspondingDto);
Assert.AreEqual(person.Id, correspondingDto.Id);
Assert.AreEqual(person.FullName, correspondingDto.FullName);
}
}
public void t_Person_Select_All()
{
// Backdoor setup
List <Person_ado> list = DbTestHelper.LoadExtraneousPersons();
// Exercise the test
List <Person> PersonList = PersonMapper.SelectAll();
// Validate results
Assert.AreEqual(list.Count(), PersonList.Count, "Wrong number of objects in the result list");
foreach (Person_ado ado in list)
{
// just check to make sure the object is there; leave specific value check for the Select_ByGuid test
Assert.IsTrue(PersonList.Exists(x => x.Id.Equals(ado.PersonId)), "personAdo " + ado.PersonId.ToString() + " is not in the results");
}
}
public Person update(Person newPerson)
{
Person oldPerson = _repository.get(newPerson.IDPerson);
if (oldPerson == null)
{
return(null);
}
oldPerson = PersonMapper.mapModel(oldPerson, newPerson);
if (oldPerson == null)
{
return(null);
}
_repository.update(oldPerson);
return(oldPerson);
}
public ActionResult AddMother(ParentViewModel parent)
{
if (ModelState.IsValid)
{
PersonModel child = _dalModelRetriever.GetPersonById(parent.ChildId);
parent.Gender = "Female";
PersonModel parentModel = PersonMapper.ConvertToPersonModel(parent);
parent.Id = _dalModelModifier.Save(parentModel);
child.MomId = parent.Id;
_dalModelModifier.AddMother(child);
return(Redirect("~/Home/Index"));
}
else
{
return(PartialView("_AddParents", parent));
}
}
public void Update_RemovePerson_fromSeeded_CheckUpdated()
{
//Arrange
var person = PersonMapper.MapToDetailModel(Seed.JohnTravolta);
person.ActedInFilms.Clear();
//Act
person = _personRepositorySUT.InsertOrUpdate(person);
//Assert
var person2 = _personRepositorySUT.GetById(person.Id);
Assert.Equal(person, person2, PersonDetailModel.PersonDetailModelComparer);
Assert.Equal(person.ActedInFilms, person2.ActedInFilms,
ActedInFilmDetailModel.ActedInFilmDetailModelComparer);
Assert.Equal(person.DirectedFilms, person2.DirectedFilms,
DirectedFilmDetailModel.DirectedFilmDetailModelComparer);
}
public ActionResult Politician(int id = 0)
{
if (id == 0)
{
return(View(new PersonDto()));
}
var personRepo = new PersonRepository();
var person = personRepo.Get(id);
var personDto = PersonMapper.MapPerson(person);
var languageManager = new LanguageManager();
personDto = languageManager.GetTranslations(personDto);
return(View(personDto));
}
public ActionResult Edit(int id = 0)
{
PersonModel person = _dalModelRetriever.GetPersonById(id);
List <PersonModel> people = _dalModelRetriever.GetAllPeople();
int parentCount = _familyManager.FindParents(person, people).Count;
if (parentCount == 1)
{
PersonModel parent = _familyManager.FindParents(person, people)[0];
ViewData["parentGender"] = parent.Gender;
}
ViewData["name"] = person.Name;
EditViewModel editedPerson = PersonMapper.ConvertToEditViewModel(person);
editedPerson.ParentCount = parentCount;
return(View(editedPerson));
}
public PersonUpdateResponse Update(PersonUpdateRequest request)
{
var response = new PersonUpdateResponse();
if (request.IsNotValid())
{
response.Message = ConstHelper.REQUEST_NOT_VALID;
return(response);
}
try
{
var entity = _personRepository.SelectOne(request.UId);
if (entity == null)
{
response.Message = "There is no entity with this uid!";
return(response);
}
PersonMapper.MapEntityFromRequest(request, entity);
var result = _personRepository.Update(entity);
if (result.ModifiedCount != 1)
{
response.Message = "Update could not be done!";
return(response);
}
var model = PersonMapper.MapModelFromEntity(entity);
response.Model = model;
var cacheKey = "Person-" + request.UId;
CacheManager.AddOrUpdateItem(cacheKey, model);
}
catch (Exception ex)
{
response.Message = string.Format("Update entity failed on database process!{0}{1}", Environment.NewLine, ex.Message);
return(response);
}
response.Status = true;
response.Message = "Person updated.";
return(response);
}
public void Scaffold()
{
var esdatModel = new ESDATModel();
var mockDb = new Mock<IDbContext>();
var mockDbContext = mockDb.Object;
var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
var defaultValueProvider = new StaticWQDefaultValueProvider();
var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
var results = new List<IResult>();
var mapper = new PersonMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);
var affiliation = new Affiliation();
var person = mapper.Draft(esdatModel);
Assert.AreEqual(defaultValueProvider.DefaultPersonFirstName, person.PersonFirstName);
Assert.AreEqual(defaultValueProvider.DefaultPersonMiddleName, person.PersonMiddleName);
Assert.AreEqual(defaultValueProvider.DefaultPersonLastName, person.PersonLastName);
}
public void Verify_MapToModelLite_AssignsLiteOnlyPersonProperties()
{
// Arrange
var mapper = new PersonMapper();
var entity = PeopleMockingSetup.DoMockingSetupForPerson();
// Act
var model = mapper.MapToModelLite(entity.Object);
// Assert
Assert.Equal(entity.Object.Hometown, model.Hometown);
Assert.Equal(entity.Object.Country, model.Country);
Assert.Equal(entity.Object.Email, model.Email);
Assert.Equal(entity.Object.Website, model.Website);
Assert.Equal(entity.Object.BirthDate, model.BirthDate);
Assert.Equal(entity.Object.DeathDate, model.DeathDate);
// Related Objects
Assert.Equal(entity.Object.PrimaryImageFileId, model.PrimaryImageFileId);
Assert.Equal(entity.Object.GenderId, model.GenderId);
}
public void Scaffold()
{
var esdatModel = new ESDATModel();
var mockDb = new Mock <IDbContext>();
var mockDbContext = mockDb.Object;
var duplicateChecker = new ODM2DuplicateChecker(mockDbContext);
var defaultValueProvider = new StaticWQDefaultValueProvider();
var wayToHandleNewData = WayToHandleNewData.ThrowExceptionForNewData;
var results = new List <IResult>();
var mapper = new PersonMapper(duplicateChecker, defaultValueProvider, wayToHandleNewData, results);
var affiliation = new Affiliation();
var person = mapper.Draft(esdatModel);
Assert.AreEqual(defaultValueProvider.DefaultPersonFirstName, person.PersonFirstName);
Assert.AreEqual(defaultValueProvider.DefaultPersonMiddleName, person.PersonMiddleName);
Assert.AreEqual(defaultValueProvider.DefaultPersonLastName, person.PersonLastName);
}
public ActionResult <PersonDto> Post([FromBody] PersonDto personDto)
{
try
{
if (personDto is null)
{
return(BadRequest("Person can't be null"));
}
var person = new PersonMapper().ToModel(personDto);
var send = _unitOfWork.Persons.Add(person);
_unitOfWork.Save();
var dto = new PersonMapper().ToDto(send);
return(CreatedAtAction(nameof(GetInvestigationPerson), new { id = dto.PersonId }, dto));
}
catch (Exception e)
{
throw new HttpRequestException(e.Message, e, HttpStatusCode.InternalServerError);
}
}
public ActionResult Detail(string uid)
{
var request = new PersonSelectRequest(uid);
if (request.IsNotValid())
{
return(RedirectToNotFound());
}
var response = _personService.Select(request);
if (response.Status)
{
var model = PersonMapper.MapViewModelFromModel(response.Model);
return(View(model));
}
return(RedirectToNotFound());
}
public void SetUp()
{
var dbFactory = new DatabaseFactory();
var personColumnProvider = new PersonColumnProvider();
var columnProvider = new PostColumnProvider();
var personMapper = new PersonMapper(personColumnProvider);
var mapper = new PostMapper(columnProvider, personMapper);
var helper = new DataParamHelper();
var paramRepository = new PostParamRepository(columnProvider, helper);
var collectionRepository = new PostParamCollectionRepository(paramRepository);
var personParamRepository = new PersonParamRepository(personColumnProvider, helper);
var personCollectionRepository = new PersonParamCollectionRepository(personParamRepository);
_repository = new PostRepository(dbFactory, mapper, collectionRepository);
_personRepository = new PersonRepository(dbFactory, personMapper, personCollectionRepository);
}
public void Verify_MapToModelLite_AssignsLiteOnlyPersonProperties()
{
// Arrange
var mapper = new PersonMapper();
var entity = PeopleMockingSetup.DoMockingSetupForPerson();
// Act
var model = mapper.MapToModelLite(entity.Object);
// Assert
Assert.Equal(entity.Object.Hometown, model.Hometown);
Assert.Equal(entity.Object.Country, model.Country);
Assert.Equal(entity.Object.Email, model.Email);
Assert.Equal(entity.Object.Website, model.Website);
Assert.Equal(entity.Object.BirthDate, model.BirthDate);
Assert.Equal(entity.Object.DeathDate, model.DeathDate);
// Related Objects
Assert.Equal(entity.Object.PrimaryImageFileId, model.PrimaryImageFileId);
Assert.Equal(entity.Object.GenderId, model.GenderId);
}
public void Verify_MapToModel_AssignsPersonProperties()
{
// Arrange
var mapper = new PersonMapper();
var entity = PeopleMockingSetup.DoMockingSetupForPerson();
// Act
var model = mapper.MapToModel(entity.Object);
// Assert
Assert.Equal(entity.Object.Hometown, model.Hometown);
Assert.Equal(entity.Object.Country, model.Country);
Assert.Equal(entity.Object.Email, model.Email);
Assert.Equal(entity.Object.Website, model.Website);
Assert.Equal(entity.Object.BirthDate, model.BirthDate);
Assert.Equal(entity.Object.DeathDate, model.DeathDate);
// Related Objects
Assert.Equal(entity.Object.PrimaryImageFileId, model.PrimaryImageFileId);
Assert.Equal(entity.Object.GenderId, model.GenderId);
// Associated Objects
Assert.Equal(entity.Object.CharactersCreated?.Count, model.CharactersCreated?.Count);
Assert.Equal(entity.Object.PersonAliases?.Count, model.PersonAliases?.Count);
Assert.Equal(entity.Object.IssuesWritten?.Count, model.IssuesWritten?.Count);
Assert.Equal(entity.Object.MoviesProduced?.Count, model.MoviesProduced?.Count);
Assert.Equal(entity.Object.MoviesWritten?.Count, model.MoviesWritten?.Count);
Assert.Equal(entity.Object.PromosWritten?.Count, model.PromosWritten?.Count);
Assert.Equal(entity.Object.StoryArcsWritten?.Count, model.StoryArcsWritten?.Count);
Assert.Equal(entity.Object.VolumesWritten?.Count, model.VolumesWritten?.Count);
}
public void Verify_MapToSearchModel_AssignsPersonSearchProperties()
{
// Arrange
var mapper = new PersonMapper();
var model = PeopleMockingSetup.DoMockingSetupForPersonModel();
// Act
var searchModel = mapper.MapToSearchModel(model.Object);
// Assert
Assert.Equal(model.Object.PrimaryImageFileId, searchModel.PrimaryImageFileId);
Assert.Equal(model.Object.PrimaryImageFile?.CustomKey, searchModel.PrimaryImageFileCustomKey);
Assert.Equal(model.Object.PrimaryImageFile?.ApiDetailUrl, searchModel.PrimaryImageFileApiDetailUrl);
Assert.Equal(model.Object.PrimaryImageFile?.SiteDetailUrl, searchModel.PrimaryImageFileSiteDetailUrl);
Assert.Equal(model.Object.PrimaryImageFile?.Name, searchModel.PrimaryImageFileName);
Assert.Equal(model.Object.PrimaryImageFile?.ShortDescription, searchModel.PrimaryImageFileShortDescription);
Assert.Equal(model.Object.PrimaryImageFile?.Description, searchModel.PrimaryImageFileDescription);
Assert.Equal(model.Object.GenderId, searchModel.GenderId);
Assert.Equal(model.Object.Gender?.CustomKey, searchModel.GenderCustomKey);
Assert.Equal(model.Object.Gender?.ApiDetailUrl, searchModel.GenderApiDetailUrl);
Assert.Equal(model.Object.Gender?.SiteDetailUrl, searchModel.GenderSiteDetailUrl);
Assert.Equal(model.Object.Gender?.Name, searchModel.GenderName);
Assert.Equal(model.Object.Gender?.ShortDescription, searchModel.GenderShortDescription);
Assert.Equal(model.Object.Gender?.Description, searchModel.GenderDescription);
}