public void A_class_should_be_able_to_create_a_clone_with_two_property_set_using_equal_equal(
Customer myClass, int newIntValue, string newStrValue)
{
var ret = myClass.With(m => m.Id == newIntValue && m.Name == newStrValue);
Assert.Equal(newIntValue, ret.Id);
Assert.Equal(newStrValue, ret.Name);
}
public void A_class_should_map_properties(Customer myClass, DateTime time)
{
var ret = myClass.As<CustomerFromSomeOtherDll>(c=>c.Since==time);
Assert.Equal(ret.Id, myClass.Id);
Assert.Equal(ret.Name, myClass.Name);
Assert.Equal(ret.Since, time);
}
public void A_class_should_be_able_to_create_a_clone_with_a_property_set_using_equal_equal_and_another_propertyvalue(
Customer anInstance, Customer anotherInstance)
{
var ret = anotherInstance.With(m => m.Id == anInstance.Id);
Assert.Equal(anInstance.Id, ret.Id);
Assert.Equal(anotherInstance.Name, ret.Name);
}
public void A_class_should_be_able_to_create_a_clone_with_a_property_set(
Customer myClass, int newValue)
{
var ret = myClass.With(m => m.Id, newValue);
Assert.Equal(newValue, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
}
public void A_class_using_const(
Customer myClass, DateTime time)
{
const string _time = "253654365";
var ret = myClass.As<VipCustomer>(m => m.Name == _time && m.Since == time);
Assert.Equal(ret.Name, _time);
}
public void Doit()
{
var c = new Customer
{
CustomerId = 3,
FirstName = "fn",
SecondName = "sn",
CustomerCountries =
new[] { new CustomerCountry { CountryId = 1 }, new CustomerCountry { CountryId = 2 } }
};
var countries = new[]
{
new Country {CountryId = 1, Name = "Moldova"},
new Country {CountryId = 2, Name = "Japan"}
};
var d = new CustomerDto();
d.InjectFrom(c);
Assert.AreEqual(c.CustomerId, d.CustomerId);
Assert.AreEqual(c.FirstName, d.FirstName);
Assert.AreEqual(c.SecondName, d.SecondName);
d.InjectFrom(new My(countries), c);
Assert.AreEqual(c.CustomerCountries.Count(), d.Countries.Count());
Assert.AreEqual(countries.First().Name, d.Countries.First().Name);
}
public void A_class_should_throw_a_decent_exception_when_changing_the_order(
Customer anInstance, Customer anotherInstance)
{
Assert.Throws<ShouldBeAnExpressionLeftToRightException>(() =>
{
anInstance.With(m => anotherInstance.Id == m.Id);
});
}
public void A_class_should_be_able_to_create_a_clone_with_a_property_set_using_eql(
Customer instance, int newInt)
{
Customer ret = instance.With()
.Eql(m => m.Id, newInt);
Assert.Equal(newInt, ret.Id);
Assert.Equal(instance.Name, ret.Name);
}
public void A_class_should_map_its_parents_properties_and_get_the_new_value(
Customer myClass, DateTime time)
{
VipCustomer ret = myClass.As<VipCustomer>()
.Eql(p => p.Since, time);
Assert.Equal(myClass.Id, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
Assert.Equal(time, ret.Since);
}
public void A_class_should_map_its_parents_properties(
Customer myClass, DateTime time)
{
var ret = myClass.As<VipCustomer>(c=>c.Since, time);
Assert.Equal(time, ret.Since);
Assert.Equal(myClass.Id, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
}
public void A_class_should_be_able_to_use_lambda(
Customer myClass, DateTime time)
{
var ret = myClass.As<VipCustomer>(m => m.Since == time);
Assert.Equal(ret.Since, time);
Assert.Equal(myClass.Id, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
}
public void A_class_with_different_order_of_constructor_parameters(
Customer myClass, DateTime time)
{
MyCustomerWithDifferentParameterOrder ret = myClass.As<MyCustomerWithDifferentParameterOrder>()
.Eql(p => p.Since, time);
Assert.Equal(time, ret.Since);
Assert.Equal(myClass.Id, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
}
public void A_class_using_cast(
Customer myClass, DateTime time)
{
Object _time = (Object)time;
var ret = myClass.As<VipCustomer>(m => m.Since == (DateTime)_time);
Assert.Equal(ret.Since, time);
Assert.Equal(myClass.Id, ret.Id);
Assert.Equal(myClass.Name, ret.Name);
}
