public void InheritedMap() { var definitions = new MapDefinitionCollection(new IMapDefinition[] { new MapperDefinition1(), }); var mapper = new UmbracoMapper(definitions); var thing3 = new Thing3 { Value = "value" }; var thing2 = mapper.Map <Thing3, Thing2>(thing3); Assert.IsNotNull(thing2); Assert.AreEqual("value", thing2.Value); thing2 = mapper.Map <Thing2>(thing3); Assert.IsNotNull(thing2); Assert.AreEqual("value", thing2.Value); thing2 = new Thing2(); mapper.Map(thing3, thing2); Assert.AreEqual("value", thing2.Value); }
public void EnumerableMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition1() }); var mapper = new UmbracoMapper(definitions, _scopeProvider); var thing1A = new Thing1 { Value = "valueA" }; var thing1B = new Thing1 { Value = "valueB" }; Thing1[] thing1 = { thing1A, thing1B }; var thing2 = mapper.Map <IEnumerable <Thing1>, IEnumerable <Thing2> >(thing1).ToList(); Assert.IsNotNull(thing2); Assert.AreEqual(2, thing2.Count); Assert.AreEqual("valueA", thing2[0].Value); Assert.AreEqual("valueB", thing2[1].Value); thing2 = mapper.Map <IEnumerable <Thing2> >(thing1).ToList(); Assert.IsNotNull(thing2); Assert.AreEqual(2, thing2.Count); Assert.AreEqual("valueA", thing2[0].Value); Assert.AreEqual("valueB", thing2[1].Value); thing2 = mapper.MapEnumerable <Thing1, Thing2>(thing1).ToList(); Assert.IsNotNull(thing2); Assert.AreEqual(2, thing2.Count); Assert.AreEqual("valueA", thing2[0].Value); Assert.AreEqual("valueB", thing2[1].Value); }
public void SimpleMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition1(), }); var mapper = new UmbracoMapper(definitions, _scopeProvider); var thing1 = new Thing1 { Value = "value" }; Thing2 thing2 = mapper.Map <Thing1, Thing2>(thing1); Assert.IsNotNull(thing2); Assert.AreEqual("value", thing2.Value); thing2 = mapper.Map <Thing2>(thing1); Assert.IsNotNull(thing2); Assert.AreEqual("value", thing2.Value); thing2 = new Thing2(); mapper.Map(thing1, thing2); Assert.AreEqual("value", thing2.Value); }
public void OrderCustomerWithDefinition() { using (var context = new TestEntities()) { var query = context.Orders.Include(o => o.Customer); var mapDefinitions = new MapDefinitionCollection(); mapDefinitions.Register(typeof(Order), typeof(OrderDto), new MapDefinition( new Dictionary <string, string> { { "CustomerId", "Id" } // set OrderNo with Id } )); mapDefinitions.Register(typeof(Customer), typeof(CustomerDto), new MapDefinition( new Dictionary <string, string> { { "Id", "Id" } // get only Id field }, true )); var dtoQuery = query.ProjectTo <OrderDto>(mapDefinitions); var orders = dtoQuery.ToList(); Assert.AreEqual(2, orders.Count); Assert.IsTrue(orders.All(o => o.CustomerId == o.Id)); Assert.IsTrue(orders.All(o => o.Customer != null && o.Customer.Name == null)); Assert.IsTrue(orders.All(o => !o.OrderDetails.Any())); } }
public void CollectionsMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition2() }); var mapper = new UmbracoMapper(definitions, _scopeProvider); // can map a PropertyCollection var source = new PropertyCollection(); var target = mapper.Map <IEnumerable <ContentPropertyDto> >(source); }
public void NullPropertyMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition5() }); var mapper = new UmbracoMapper(definitions, _scopeProvider); var thing7 = new Thing7(); var thing8 = mapper.Map <Thing7, Thing8>(thing7); Assert.IsNotNull(thing8); Assert.IsNull(thing8.Things); }
public void ManyToOneTypeMismatchCheck() { using (var context = new TestEntities()) { var query = context.Set <OrderDetail>().Include(od => od.Supplier); var mapDefinitions = new MapDefinitionCollection(); mapDefinitions.Register(typeof(OrderDetail), typeof(OrderDto), new MapDefinition( new Dictionary <string, string> { { "OrderDetails", "Supplier" } // set single to collection }, true )); query.ProjectTo <OrderDto>(mapDefinitions); } }
public void OneToManyTypeMismatchCheck() { using (var context = new TestEntities()) { var query = context.Orders.Include(o => o.OrderDetails); var mapDefinitions = new MapDefinitionCollection(); mapDefinitions.Register(typeof(Order), typeof(OrderDetailDto), new MapDefinition( new Dictionary <string, string> { { "Supplier", "OrderDetails" } // set collection to single }, true )); query.ProjectTo <OrderDetailDto>(mapDefinitions); } }
public void EnumMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition4() }); var mapper = new UmbracoMapper(definitions, _scopeProvider); var thing5 = new Thing5 { Fruit1 = Thing5Enum.Apple, Fruit2 = Thing5Enum.Banana, Fruit3 = Thing5Enum.Cherry }; var thing6 = mapper.Map <Thing5, Thing6>(thing5); Assert.IsNotNull(thing6); Assert.AreEqual(Thing6Enum.Apple, thing6.Fruit1); Assert.AreEqual(Thing6Enum.Banana, thing6.Fruit2); Assert.AreEqual(Thing6Enum.Cherry, thing6.Fruit3); }
public void OrderDetailsWithDefinition() { using (var context = new TestEntities()) { var query = context.Orders.Include(o => o.OrderDetails.Select(od => od.Supplier)); var mapDefinitions = new MapDefinitionCollection(); mapDefinitions.Register(typeof(OrderDetail), typeof(OrderDetailDto), new MapDefinition( new Dictionary <string, string> { { "Id", "OrderId" } // write OrderId into Id field }, true )); var dtoQuery = query.ProjectTo <OrderDto>(mapDefinitions); var orders = dtoQuery.ToList(); Assert.AreEqual(2, orders.Count); Assert.IsTrue(orders.All(o => o.OrderDetails.All(od => od.Id == o.Id))); // suppliers should be null even if it is included, because we wanted only explicit properties. Assert.IsTrue(orders.All(o => o.OrderDetails.All(od => od.Supplier == null))); } }
/// <summary> /// Create member controller to test /// </summary> /// <param name="memberService">Member service</param> /// <param name="memberTypeService">Member type service</param> /// <param name="memberGroupService">Member group service</param> /// <param name="membersUserManager">Members user manager</param> /// <param name="dataTypeService">Data type service</param> /// <param name="backOfficeSecurityAccessor">Back office security accessor</param> /// <param name="mockPasswordChanger">Password changer class</param> /// <returns>A member controller for the tests</returns> private MemberController CreateSut( IMemberService memberService, IMemberTypeService memberTypeService, IMemberGroupService memberGroupService, IUmbracoUserManager <MemberIdentityUser> membersUserManager, IDataTypeService dataTypeService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor, IPasswordChanger <MemberIdentityUser> passwordChanger, IOptions <GlobalSettings> globalSettings, IUser user) { var httpContextAccessor = new HttpContextAccessor(); var mockShortStringHelper = new MockShortStringHelper(); var textService = new Mock <ILocalizedTextService>(); var contentTypeBaseServiceProvider = new Mock <IContentTypeBaseServiceProvider>(); contentTypeBaseServiceProvider.Setup(x => x.GetContentTypeOf(It.IsAny <IContentBase>())).Returns(new ContentType(mockShortStringHelper, 123)); var contentAppFactories = new Mock <List <IContentAppFactory> >(); var mockContentAppFactoryCollection = new Mock <ILogger <ContentAppFactoryCollection> >(); var hybridBackOfficeSecurityAccessor = new BackOfficeSecurityAccessor(httpContextAccessor); var contentAppFactoryCollection = new ContentAppFactoryCollection( () => contentAppFactories.Object, mockContentAppFactoryCollection.Object, hybridBackOfficeSecurityAccessor); var mockUserService = new Mock <IUserService>(); var commonMapper = new CommonMapper( mockUserService.Object, contentTypeBaseServiceProvider.Object, contentAppFactoryCollection, textService.Object); var mockCultureDictionary = new Mock <ICultureDictionary>(); var mockPasswordConfig = new Mock <IOptions <MemberPasswordConfigurationSettings> >(); mockPasswordConfig.Setup(x => x.Value).Returns(() => new MemberPasswordConfigurationSettings()); IDataEditor dataEditor = Mock.Of <IDataEditor>( x => x.Type == EditorType.PropertyValue && x.Alias == Constants.PropertyEditors.Aliases.Label); Mock.Get(dataEditor).Setup(x => x.GetValueEditor()).Returns(new TextOnlyValueEditor(new DataEditorAttribute(Constants.PropertyEditors.Aliases.TextBox, "Test Textbox", "textbox"), textService.Object, Mock.Of <IShortStringHelper>(), Mock.Of <IJsonSerializer>(), Mock.Of <IIOHelper>())); var propertyEditorCollection = new PropertyEditorCollection(new DataEditorCollection(() => new[] { dataEditor })); IMapDefinition memberMapDefinition = new MemberMapDefinition( commonMapper, new CommonTreeNodeMapper(Mock.Of <LinkGenerator>()), new MemberTabsAndPropertiesMapper( mockCultureDictionary.Object, backOfficeSecurityAccessor, textService.Object, memberTypeService, memberService, memberGroupService, mockPasswordConfig.Object, contentTypeBaseServiceProvider.Object, propertyEditorCollection)); var map = new MapDefinitionCollection(() => new List <IMapDefinition>() { new global::Umbraco.Cms.Core.Models.Mapping.MemberMapDefinition(), memberMapDefinition, new ContentTypeMapDefinition( commonMapper, propertyEditorCollection, dataTypeService, new Mock <IFileService>().Object, new Mock <IContentTypeService>().Object, new Mock <IMediaTypeService>().Object, memberTypeService, new Mock <ILoggerFactory>().Object, mockShortStringHelper, globalSettings, new Mock <IHostingEnvironment>().Object) }); var scopeProvider = Mock.Of <IScopeProvider>(x => x.CreateScope( It.IsAny <IsolationLevel>(), It.IsAny <RepositoryCacheMode>(), It.IsAny <IEventDispatcher>(), It.IsAny <IScopedNotificationPublisher>(), It.IsAny <bool?>(), It.IsAny <bool>(), It.IsAny <bool>()) == Mock.Of <IScope>()); _mapper = new UmbracoMapper(map, scopeProvider); return(new MemberController( new DefaultCultureDictionary( new Mock <ILocalizationService>().Object, NoAppCache.Instance), new LoggerFactory(), mockShortStringHelper, new DefaultEventMessagesFactory( new Mock <IEventMessagesAccessor>().Object), textService.Object, propertyEditorCollection, _mapper, memberService, memberTypeService, (IMemberManager)membersUserManager, dataTypeService, backOfficeSecurityAccessor, new ConfigurationEditorJsonSerializer(), passwordChanger, scopeProvider )); }
public void ConcurrentMap() { var definitions = new MapDefinitionCollection(() => new IMapDefinition[] { new MapperDefinition1(), new MapperDefinition3(), }); var mapper = new UmbracoMapper(definitions, _scopeProvider); // the mapper currently has a map from Thing1 to Thing2 // because Thing3 inherits from Thing1, it will map a Thing3 instance, // and register a new map from Thing3 to Thing2, // thus modifying its internal dictionaries // if timing is good, and mapper does have non-concurrent dictionaries, it fails // practically, to reproduce, one needs to add a 1s sleep in the mapper's loop // hence, this test is explicit var thing3 = new Thing3 { Value = "value" }; var thing4 = new Thing4(); Exception caught = null; void ThreadLoop() { // keep failing at mapping - and looping through the maps for (var i = 0; i < 10; i++) { try { mapper.Map <Thing2>(thing4); } catch (Exception e) { caught = e; Console.WriteLine($"{e.GetType().Name} {e.Message}"); } } Console.WriteLine("done"); } var thread = new Thread(ThreadLoop); thread.Start(); Thread.Sleep(1000); try { Console.WriteLine($"{DateTime.Now:O} mapping"); var thing2 = mapper.Map <Thing2>(thing3); Console.WriteLine($"{DateTime.Now:O} mapped"); Assert.IsNotNull(thing2); Assert.AreEqual("value", thing2.Value); } finally { thread.Join(); } }