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