public async Task Mapping_Should_Work_With_Manual_Addon_for_automapper_Elements()
{
//Arrange
MappingHandler.AddMapping <string, WrappedValue>((source) => new WrappedValue()
{
Value = source
});
MappingHandler.AddMapping(MappingHandler.AutoConverter <ExtendedFromObject, ExtendedToObject>(async(from, to) =>
{
await Task.Delay(100);
to.WrappedValue.OtherValue = from.OtherWrappedValue;
return(to);
}, MappingPropertySource.Target));
var fromObject = new ExtendedFromObject()
{
Name = "Testsson",
WrappedValue = "inner value",
OtherWrappedValue = "second value",
Age = 22
};
//Act
var toObject = await fromObject.ConvertAsync <ExtendedToObject>();
//Assert
using (new FluentAssertions.Execution.AssertionScope())
{
fromObject.WrappedValue.Should().Be(toObject.WrappedValue.Value);
fromObject.OtherWrappedValue.Should().Be(toObject.WrappedValue.OtherValue);
}
}
public async Task Can_add_optional_additional_async_conversion_after_convert()
{
// Arrange
MappingHandler.AddMapping <int, int>(source => source + 2);
// Act
var result = await MappingHandler.ConvertAsync <int>(1, withTwoAdded => Task.FromResult(withTwoAdded * 3));
//Assert
result.Should().Be(9);
}
public async Task Can_convert_primitive_type()
{
// Arrange
MappingHandler.AddMapping <int, bool>(source => source > 0);
// Act
var result = await MappingHandler.ConvertAsync <bool>(1);
//Assert
result.Should().Be(true);
}
public void Throws_if_no_mapping_for_the_value_exists()
{
// Arrange
MappingHandler.AddMapping <string, string>(source => "a string mapper");
// Act
Func <Task <bool> > convertAction = async() => await MappingHandler.ConvertAsync <bool>("a string value to a bool converter");
//Assert
convertAction.Should().Throw <Exception>("because bool has no mapping");
}
public async Task Returns_null_given_null_despite_mapping_producing_value()
{
// Arrange
MappingHandler.AddMapping <string, string>(source => "not null");
// Act
var result = await MappingHandler.ConvertAsync <string>(null);
//Assert
result.Should().Be(null);
}
public Model.Keyboard GetKeyboard(KeyboardType type)
{
using (var ctx = new CableProviderConnection())
{
string keyboardType = type.ToString();
DvrKeyboard keyboard = _dataExecutor.ExecuteQuery(new GetKeyboard(ctx, keyboardType));
IMapper mapHandler = MappingHandler.BuildMapper();
return(mapHandler.Map <Model.Keyboard>(keyboard));
}
}
public static void Can_add_converters()
{
// Arrange
var converter = new {
Name = "Foo"
};
// Act
MappingHandler.AddConverters(converter);
//Assert
}
/// <summary>
/// Creates code that maps the given parameter specification to
/// a compatible representation.
/// </summary>
/// <param name="entryPoint">The entry point.</param>
public void Map(EntryPoint entryPoint)
{
Debug.Assert(entryPoint != null, "Invalid entry point");
// Map all arguments
var mappingHandler = new MappingHandler();
MapArguments(
emitter,
mappingHandler,
entryPoint.Parameters);
}
public void SetMappingForType <T>(Func <T, MappingResultTypedWrapper <T> > mapHandler)
{
var handler = new MappingHandler(obj => mapHandler((T)obj));
var typeHash = typeof(T).GetHashCode();
if (!_handlers.ContainsKey(typeHash))
{
_handlers.TryAdd(typeHash, handler);
}
_handlers[typeHash] = handler;
}
public async Task Automapping_should_work_with_enumerable()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
var fromObject = new FromObject()
{
Numbers = new [] { 1, 2, 3 }
};
//Act
var toObject = await fromObject.ConvertAsync <ToObject>();
//Assert
toObject.Numbers.Should().Equal(new [] { 1, 2, 3 });
}
public async Task Mapping_Should_Work_Reversed()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
var fromObject = new FromObject()
{
Name = "Testsson",
Age = 22
};
//Act
var toObject = await fromObject.ConvertAsync <ToObject>();
//Assert
fromObject.Name.Should().Be(toObject.Name);
}
public void Mapping_should_throw_if_fields_are_missing()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, FailingToObject>(MappingPropertySource.Source));
var fromObject = new FromObject()
{
Name = "Testsson",
Age = 22
};
//Act
Func <Task> tryToConvert = async() => await fromObject.ConvertAsync <FailingToObject>();
//Assert
tryToConvert.Should().Throw <KeyNotFoundException>();
}
public async Task Automapping_should_work_with_enums_tostring()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <ToObject, FromObject>(MappingPropertySource.Target, requireAllProperties: true));
var fromObject = new ToObject()
{
Name = "Testsson",
TestValue = TestEnum.No,
Age = 22
};
//Act
var toObject = await fromObject.ConvertAsync <FromObject>();
//Assert
toObject.EnumValue.Should().Be("No");
}
public async Task Mapping_Should_Work_With_Wrapped_Elements()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
MappingHandler.AddMapping <string, WrappedValue>((source) => new WrappedValue()
{
Value = source
});
var fromObject = new FromObject()
{
Name = "Testsson",
WrappedValue = "inner value",
Age = 22
};
//Act
var toObject = await fromObject.ConvertAsync <ToObject>();
//Assert
fromObject.WrappedValue.Should().Be(toObject.WrappedValue.Value);
}
public async Task Allow_mapperoverwrite()
{
// Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
MappingHandler.OnMappingOverwrite += (form, to) =>
{
return(true);
};
// Act
//Action shouldAddExisitingMapping = () =>
MappingHandler.AddMapping <FromObject, ToObject>(async(source) => new ToObject()
{
Name = "NewMapper!"
});
//); ;
var result = await new FromObject().ConvertAsync <ToObject>();
//Assert
Assert.Equal("NewMapper!", result.Name);
}
public async Task Automapping_should_work_with_dictionaries()
{
//Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
var fromObject = new FromObject()
{
Table = new Dictionary <int, string> {
{ 1, "1" },
{ 2, "2" },
{ 3, "3" }
}
};
//Act
var toObject = await fromObject.ConvertAsync <ToObject>();
//Assert
toObject.Table.Should().Equal(new Dictionary <int, string> {
{ 1, "1" },
{ 2, "2" },
{ 3, "3" }
});
}
public async Task Disallow_mapperoverwrite()
{
// Arrange
MappingHandler.AddMapping(MappingHandler.AutoConverter <FromObject, ToObject>(MappingPropertySource.Target, requireAllProperties: true));
MappingHandler.OnMappingOverwrite += (form, to) =>
{
return(false);
};
// Act
Action shouldAddExisitingMapping = () =>
{
MappingHandler.AddMapping <FromObject, ToObject>(async(source) => new ToObject()
{
Name = "NewMapper!"
});
};
var result = await new FromObject().ConvertAsync <ToObject>();
//Assert
shouldAddExisitingMapping.Should().Throw <MapperAlreadyDefinedException>();
}
public static Task <TTo> ConvertAsync <TTo>(this object instance, Func <TTo, Task <TTo> > afterMapping = null) => MappingHandler.ConvertAsync(instance, afterMapping);
public void Dispose() => MappingHandler.Reset();
public void SetGlobalMapping(Func <object, MappingResult> mapHandler)
{
GlobalMappingHandler = new MappingHandler(obj => mapHandler(obj));
}
public static Task <IEnumerable <TTo> > ConvertListAsync <TTo>(this object instance) => MappingHandler.ConvertListAsync <TTo>(instance);
