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_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); }