public void Avoids_Hash_Collisions() { // Arrange var id2 = typeof(Employee).GetHashCode() - typeof(Contract).GetHashCode(); var source = new List <object>(); dynamic obj1 = new ExpandoObject(); obj1.Id = 1; obj1.Contracts_Id = id2; source.Add(obj1); dynamic obj2 = new ExpandoObject(); obj2.Id = 1; obj2.Contracts_Id = id2 + 1; source.Add(obj2); var mappy = new Mappy(); // Act/Assert var result = mappy.Map <Employee>(source).First(); }
public void Can_Map_Null_Values() { // Arrange const int id = 1; const string firstName = null; const string lastName = "Smith"; var dictionary = new Dictionary <string, object> { { "Id", id }, { "FirstName", null }, { "LastName", lastName } }; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithFields>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); }
public void Can_Map_Matching_Property_Names() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; var dictionary = new Dictionary <string, object> { { "Id", id }, { "FirstName", firstName }, { "LastName", lastName } }; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithProperties>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); }
public void Should_Map_Simple_Abbreviations_Correct() { var dictionary = new Dictionary <string, object> { { "Id", 1 }, { "FullName", "Bob Smith" }, { "Ph_Id", 1 }, { "Ph_PhoneNumber", "1234" } }; var data = new List <Dictionary <string, object> > { dictionary }; var mappy = new Mappy(); var customers = mappy.Map <Customer>(data, new Dictionary <string, string> { { "Phone_", "Ph_" } }); Assert.Single(customers); var customer = customers.Single(); Assert.Equal(dictionary["Id"], customer.Id); Assert.Equal(dictionary["FullName"], customer.FullName); Assert.NotNull(customer.Phone); Assert.Equal(dictionary["Ph_Id"], customer.Phone.Id); Assert.Equal(dictionary["Ph_PhoneNumber"], customer.Phone.PhoneNumber); }
public void Can_Map_To_Array() { // Arrange var dictionary = new Dictionary <string, object> { { "CustomerId", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_OrderId", 1 }, { "Orders_OrderTotal", 50.50m } }; var mappy = new Mappy(); // Act var customer = mappy.Map <CustomerArray>(dictionary); // Assert Assert.Equal(dictionary["CustomerId"], customer.CustomerId); Assert.Equal(dictionary["FirstName"], customer.FirstName); Assert.Equal(dictionary["LastName"], customer.LastName); Assert.Single(customer.Orders); Assert.Equal(dictionary["Orders_OrderId"], customer.Orders.Single().OrderId); Assert.Equal(dictionary["Orders_OrderTotal"], customer.Orders.Single().OrderTotal); }
public void Can_Handle_Mapping_Nested_Members_Using_Dynamic() { // Arrange var dynamicCustomers = new List <object>(); for (var i = 0; i < 5; i++) { dynamic customer = new ExpandoObject(); customer.Id = i; customer.FirstName = "FirstName" + i; customer.LastName = "LastName" + i; customer.Orders_Id = i; customer.Orders_OrderTotal = i + 0m; dynamicCustomers.Add(customer); } var mappy = new Mappy(); // Act var customers = mappy.Map <Customer>(dynamicCustomers) .ToList(); // Assert Assert.Equal(5, customers.Count()); Assert.Equal(1, customers.First().Orders.Count); }
public void Can_Map_DateTime_String_Values_To_Nullable_DateTime_Fields() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; DateTime startDate = DateTime.Now.AddDays(-2); DateTime? endDate = DateTime.Now; dynamic dynamicPerson = new ExpandoObject(); dynamicPerson.Id = id; dynamicPerson.FirstName = firstName; dynamicPerson.LastName = lastName; dynamicPerson.StartDate = startDate.ToString(); dynamicPerson.EndDate = endDate.ToString(); var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithFields>(dynamicPerson); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); Assert.Equal(customer.StartDate.ToString(), startDate.ToString()); Assert.Equal(customer.EndDate.ToString(), endDate.ToString()); }
public void Should_Map_Not_Exists_Primitive_Array_Values_To_Null_Array() { // Arrange var dictionary = new Dictionary <string, object> { { "Id", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" } }; var dictionary2 = new Dictionary <string, object> { { "Id", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" } }; var mappy = new Mappy(); var users = mappy.Map <UserWithPhones>( new List <Dictionary <string, object> > { dictionary, dictionary2 }) .ToList(); Assert.Single(users); var user = users.Single(); Assert.Equal(dictionary["Id"], user.Id); Assert.Equal(dictionary["FirstName"], user.FirstName); Assert.Equal(dictionary["LastName"], user.LastName); Assert.Null(user.Phones); }
public void Can_Map_DateTime_Values_To_Nullable_DateTime_Properties() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; var startDate = DateTime.Now.AddDays(-2); var endDate = DateTime.Now; // This is what we are testing dynamic dynamicPerson = new ExpandoObject(); dynamicPerson.Id = id; dynamicPerson.FirstName = firstName; dynamicPerson.LastName = lastName; dynamicPerson.StartDate = startDate; dynamicPerson.EndDate = endDate; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithProperties>(dynamicPerson); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); Assert.Equal(customer.StartDate, startDate); Assert.Equal(customer.EndDate, endDate); // This is what we are testing }
public void Can_Map_Null_Values_To_Nullable_Enum_Properties() { // Arrange const int id = 1; const string firstName = "Jimbo"; const string lastName = "Smith"; const Gender gender = Gender.Male; MaritalStatus?maritalStatus = null; dynamic person = new ExpandoObject(); person.Id = id; person.FirstName = firstName; person.LastName = lastName; person.Gender = gender; person.MaritalStatus = maritalStatus; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithProperties>(person); // Assert Assert.NotNull(customer); Assert.Equal(id, customer.Id); Assert.Equal(firstName, customer.FirstName); Assert.Equal(lastName, customer.LastName); Assert.Equal(gender, customer.Gender); Assert.Equal(maritalStatus, customer.MaritalStatus); }
public void Can_Map_Enum_Values_To_Enum_Properties() { // Arrange const int id = 1; const string firstName = "Jimbo"; const string lastName = "Smith"; const Gender gender = Gender.Male; var dictionary = new Dictionary <string, object> { { "Id", id }, { "FirstName", firstName }, { "LastName", lastName }, { "Gender", gender } }; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithProperties>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(id, customer.Id); Assert.Equal(firstName, customer.FirstName); Assert.Equal(lastName, customer.LastName); Assert.Equal(gender, customer.Gender); }
public void I_Can_Map_Value_SpecialStringTyped_Collection() { // Arrange var dictionary = new Dictionary <string, object> { { "CustomerNamesId", 1 }, { "Names_$", "Name 1" }, }; var dictionary2 = new Dictionary <string, object> { { "CustomerNamesId", 1 }, { "Names_$", "Name 2" } }; var list = new List <IDictionary <string, object> > { dictionary, dictionary2 }; var mappy = new Mappy(); // Act var customers = mappy.Map <CustomerNames>(list).ToList(); // Assert // There should only be a single customer Assert.Single(customers); // There should be two values in OrdersIds, with the correct values Assert.Equal(2, customers.Single().Names.Count); Assert.Equal("Name 1", customers.Single().Names[0]); Assert.Equal("Name 2", customers.Single().Names[1]); }
public void I_Can_Map_Value_PrimitiveTyped_Collection() { // Arrange var dictionary = new Dictionary <string, object> { { "CustomerId", 1 }, { "OrdersIds_$", 3 }, }; var dictionary2 = new Dictionary <string, object> { { "CustomerId", 1 }, { "OrdersIds_$", 5 } }; var list = new List <IDictionary <string, object> > { dictionary, dictionary2 }; var mappy = new Mappy(); // Act var customers = mappy.Map <Customer>(list) .ToList(); // Assert // There should only be a single customer Assert.Single(customers); // There should be two values in OrdersIds, with the correct values Assert.Equal(2, customers.Single().OrdersIds.Count); Assert.Equal(3, customers.Single().OrdersIds[0]); Assert.Equal(5, customers.Single().OrdersIds[1]); }
public void Can_Map_Array_Values_To_Arrays() { // Arrange const int id = 1; const string firstName = null; const string lastName = "Smith"; string[] favoriteFoods = new[] { "Ice Cream", "Jello" }; var dictionary = new Dictionary <string, object> { { "Id", id }, { "FirstName", null }, { "LastName", lastName }, { "FavoriteFoods", favoriteFoods } }; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithFields>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); Assert.Equal(customer.FavoriteFoods, favoriteFoods); }
public void Can_Map_Guid_String_Values_To_Guid_Fields() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; var uniqueId = Guid.NewGuid(); dynamic dynamicPerson = new ExpandoObject(); dynamicPerson.Id = id; dynamicPerson.FirstName = firstName; dynamicPerson.LastName = lastName; dynamicPerson.UniqueId = uniqueId.ToString(); // This is what we are testing var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithFields>(dynamicPerson); // Assert Assert.NotNull(customer); Assert.Equal(id, customer.Id); Assert.Equal(firstName, customer.FirstName); Assert.Equal(lastName, customer.LastName); Assert.Equal(uniqueId, customer.UniqueId); // This is what we are testing }
public void Can_Map_And_Ignore_Keys_Case() { // Arrange var dictionary = new Dictionary <string, object> { { "CUSTOMERID", 1 }, { "FIRSTNAME", "Bob" }, { "LASTNAME", "Smith" }, { "ORDERS_ORDERID", 1 }, { "ORDERS_ORDERTOTAL", 50.50m } }; var options = new MappyOptions( stringComparison: StringComparison.OrdinalIgnoreCase, useDefaultDictionaryComparer: false); var mappy = new Mappy(options); // Act var customer = mappy.Map <Customer>(dictionary); // Assert Assert.Equal(dictionary["CUSTOMERID"], customer.CustomerId); Assert.Equal(dictionary["FIRSTNAME"], customer.FirstName); Assert.Equal(dictionary["LASTNAME"], customer.LastName); Assert.Single(customer.Orders); Assert.Equal(dictionary["ORDERS_ORDERID"], customer.Orders.Single().OrderId); Assert.Equal(dictionary["ORDERS_ORDERTOTAL"], customer.Orders.Single().OrderTotal); }
public void Can_Map_Complex_Nested_Members() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; const int orderId = 1; const decimal orderTotal = 50.50m; var dictionary = new Dictionary <string, object> { { "Id", id }, { "FirstName", firstName }, { "LastName", lastName }, { "Orders_Id", orderId }, { "Orders_OrderTotal", orderTotal } }; var mappy = new Mappy(); // Act var customer = mappy.Map <MapTestModels.CustomerWithOrdersList>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); Assert.NotNull(customer.Orders); Assert.Single(customer.Orders); Assert.Equal(customer.Orders[0].Id, orderId); Assert.Equal(customer.Orders[0].OrderTotal, orderTotal); }
public void Can_Map_DifferentsRows_to_Same_object() { dynamic dynamicCustomer = new ExpandoObject(); dynamicCustomer.Id = 1; dynamicCustomer.Name = "Clark"; dynamicCustomer.Phones_Id = 1; dynamicCustomer.Phones_Name = "88888"; dynamicCustomer.Emails_Id = "1"; dynamicCustomer.Emails_Name = "*****@*****.**"; dynamic dynamicCustomer2 = new ExpandoObject(); dynamicCustomer2.Id = 1; dynamicCustomer2.Name = "Clark"; dynamicCustomer2.Phones_Id = 2; dynamicCustomer2.Phones_Name = "99999"; dynamicCustomer2.Emails_Id = "2"; dynamicCustomer2.Emails_Name = "*****@*****.**"; var list = new List <dynamic> { dynamicCustomer, dynamicCustomer2 }; var mappy = new Mappy(); var customer = mappy.Map <NameValue>(list) .FirstOrDefault(); Assert.NotNull(customer); Assert.NotEqual( customer.Emails.FirstOrDefault(e => e.Id == 1).Name, customer.Phones.FirstOrDefault(p => p.Id == 1).Name); }
public void Can_Map_To_Multiple_Objects() { // Arrange var dictionary = new Dictionary <string, object> { { "Id", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_Id", 1 }, { "Orders_OrderTotal", 50.50m } }; var dictionary2 = new Dictionary <string, object> { { "Id", 2 }, { "FirstName", "Jane" }, { "LastName", "Doe" }, { "Orders_Id", 2 }, { "Orders_OrderTotal", 23.40m } }; var listOfDictionaries = new List <Dictionary <string, object> > { dictionary, dictionary2 }; var mappy = new Mappy(); // Act var customers = mappy.Map <MapTestModels.CustomerWithAnIEnumerableOrdersCollection>(listOfDictionaries); // Assert Assert.Equal(2, customers.Count()); Assert.Equal("Bob", customers.ToList()[0].FirstName); Assert.Equal("Jane", customers.ToList()[1].FirstName); }
public void Can_Handle_Mapping_Deeply_Nested_Members() { // Arrange var dictionary = new Dictionary <string, object> { { "Id", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_Id", 1 }, { "Orders_OrderTotal", 50.50m }, { "Orders_OrderDetails_Id", 1 }, { "Orders_OrderDetails_OrderDetailTotal", 50.50m }, { "Orders_OrderDetails_Product_Id", 546 }, { "Orders_OrderDetails_Product_ProductName", "Black Bookshelf" } }; var mappy = new Mappy(); // Act var customer = mappy.Map <MapTestModels.CustomerWithAnIEnumerableOrdersCollection>(dictionary); // Assert Assert.Single(customer.Orders); Assert.Single(customer.Orders.First().OrderDetails); Assert.Equal("Black Bookshelf", customer.Orders.First().OrderDetails[0].Product.ProductName); }
public void Should_Map_Null_Identifier_Correctly() { var dictionary = new Dictionary <string, object> { { "CustomerId", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_OrderId", new int?() }, { "Orders_OrderTotal", 50.50m }, { "Orders_OrderDate", DateTime.Now } }; var mappy = new Mappy(); var customer = mappy.Map <Customer>(dictionary); Assert.Equal(dictionary["CustomerId"], customer.CustomerId); Assert.Equal(dictionary["FirstName"], customer.FirstName); Assert.Single(customer.Orders); var order = customer.Orders.Single(); Assert.Equal(0, order.OrderId); Assert.Equal(dictionary["Orders_OrderTotal"], order.OrderTotal); Assert.Equal(dictionary["Orders_OrderDate"], order.OrderDate); }
/// <summary> /// Krijgt alle mappen uit een hoofdonderwerp /// </summary> /// <param name="Hoofdonderwerp"></param> /// <returns></returns> public static List <Mappy> GetMappy(string Hoofdonderwerp) { List <Mappy> post = new List <Mappy>(); string str = "Select * From mappy where Hoofdonderwerp = :hoofd"; if (Openconnecion()) { //Alle mappies uit een bepaalde hoofdonderwerp OracleCommand command = new OracleCommand(str); command.Connection = Conn; command.Parameters.Add("hoofd", OracleDbType.Varchar2); command.Parameters["hoofd"].Value = Hoofdonderwerp; OracleDataReader Data = command.ExecuteReader(); while (Data.Read()) { Mappy m = new Mappy(); m.Id = Data.GetInt32(0); m.Naam = Data.GetString(1); m.Hoofdonderwerp = Data.GetString(2); post.Add(m); } } return(post); }
public void Can_Map_Matching_Property_Names_With_Different_Types() { // Arrange const int id = 1; const string firstName = "Bob"; const string lastName = "Smith"; var dictionary = new Dictionary <string, object> { { "Id", Double.Parse("1.245698", CultureInfo.InvariantCulture) }, { "FirstName", firstName }, { "LastName", lastName } }; var mappy = new Mappy(); // Act var customer = mappy.Map <PersonWithProperties>(dictionary); // Assert Assert.NotNull(customer); Assert.Equal(customer.Id, id); Assert.Equal(customer.FirstName, firstName); Assert.Equal(customer.LastName, lastName); }
public void GetConversationTest() { ForumController f = new ForumController(); Mappy m = new Mappy(); m.Id = 1; ViewResult result = f.GetConversation(m, "Games") as ViewResult; Assert.IsNotNull(result); }
public void IndexTest() { ForumController f = new ForumController(); Mappy m = new Mappy(); m.Id = 1; ViewResult result = f.Index() as ViewResult; Assert.IsNotNull(result); }
public void Will_Throw_An_Exception_If_The_Type_Is_Not_Dynamic() { // Arrange var someObject = new object(); var mappy = new Mappy(); // Assert Assert.Throws <ArgumentException>(() => mappy.Map <Person>(someObject as IDictionary <string, object>)); }
public void GetPostsTest() { ForumController f = new ForumController(); Mappy m = new Mappy(); m.Id = 1; ViewResult result = f.GetPosts(m) as ViewResult; Assert.IsNotNull(result); }
public ActionResult PostPost(Post P, int prepost, int Mappy) { //Reageren op een post waar een andere post voor zit P.Mappy = Mappy; P.PrePost = new Post(); P.PrePost.Id = prepost; P.ReactPosts(User.Identity.Name); Models.Mappy m = new Mappy(); m.Id = P.Id; return(RedirectToAction("Index")); }
public void Should_Map_Different_Sets_Correctly() { // Arrange var partialInfo = new Dictionary <string, object> { { "CustomerId", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_OrderId", 1 } }; var fullInfo = new Dictionary <string, object> { { "CustomerId", 1 }, { "FirstName", "Bob" }, { "LastName", "Smith" }, { "Orders_OrderId", 1 }, { "Orders_OrderTotal", 50.50m }, { "Orders_OrderDate", DateTime.Now } }; var mappy = new Mappy(); // Act var customerPartial = mappy.Map <Customer>(partialInfo); var customerFull = mappy.Map <Customer>(fullInfo); Assert.NotNull(customerPartial); Assert.Equal(partialInfo["CustomerId"], customerPartial.CustomerId); Assert.Equal(partialInfo["FirstName"], customerPartial.FirstName); Assert.Equal(partialInfo["LastName"], customerPartial.LastName); Assert.Single(customerPartial.Orders); var order = customerPartial.Orders.Single(); Assert.Equal(partialInfo["Orders_OrderId"], order.OrderId); Assert.Equal(default(decimal), order.OrderTotal); Assert.Null(order.OrderDate); Assert.Equal(fullInfo["CustomerId"], customerFull.CustomerId); Assert.Equal(fullInfo["FirstName"], customerFull.FirstName); Assert.Equal(fullInfo["LastName"], customerFull.LastName); Assert.Single(customerFull.Orders); order = customerFull.Orders.Single(); Assert.Equal(fullInfo["Orders_OrderId"], order.OrderId); Assert.Equal(fullInfo["Orders_OrderTotal"], order.OrderTotal); Assert.Equal(fullInfo["Orders_OrderDate"], order.OrderDate); }
public void Can_Handle_Mapping_Objects_With_Multiple_Identifiers() { // Arrange const int customerId = 1; const string customerType = "Commercial"; const string firstName = "Bob"; const string lastName = "Smith"; const int orderId = 1; const decimal orderTotal = 50.50m; var dictionary = new Dictionary <string, object> { { "Customer_Id", customerId }, { "Customer_Type", customerType }, { "FirstName", firstName }, { "LastName", lastName }, { "Orders_Id", orderId }, { "Orders_OrderTotal", orderTotal } }; var dictionary2 = new Dictionary <string, object> { { "Customer_Id", customerId }, { "Customer_Type", customerType }, { "FirstName", firstName }, { "LastName", lastName }, { "Orders_Id", orderId + 1 }, { "Orders_OrderTotal", orderTotal + 1 } }; var dictionary3 = new Dictionary <string, object> { { "Customer_Id", customerId + 1 }, { "Customer_Type", customerType }, { "FirstName", firstName }, { "LastName", lastName }, { "Orders_Id", orderId + 1 }, { "Orders_OrderTotal", orderTotal + 1 } }; var listOfDictionaries = new List <Dictionary <string, object> > { dictionary, dictionary2, dictionary3 }; var mappy = new Mappy(); // Act var customers = mappy.Map <MapTestModels.CustomerWithMultipleIdAttributes>(listOfDictionaries); // Assert Assert.Equal(2, customers.Count()); Assert.Equal(2, customers.First().Orders.Count); Assert.Equal(customers.ToList()[1].Orders[0].Id, orderId + 1); }