public void ThrowsForUnmatchedSource()
{
var mapperSpec = FluentMapper
.ThatMaps <SimpleTarget>().From <SourceWithExtraDoubleC>();
Assert.That(() => mapperSpec.Create(), Throws.Exception);
try
{
mapperSpec.Create();
}
catch (Exception ex)
{
Assert.AreEqual(ex.Message, "Source Double SourceWithExtraDoubleC.C is unmatched.");
}
}
public void ThrowsForMismatchedType()
{
var mapperSpec = FluentMapper
.ThatMaps <TargetWithExtraStringC>().From <SourceWithExtraDoubleC>();
Assert.That(() => mapperSpec.Create(), Throws.Exception);
try
{
mapperSpec.Create();
}
catch (Exception ex)
{
Assert.AreEqual(ex.Message, "Cannot map [String TargetWithExtraStringC.C] from [Double SourceWithExtraDoubleC.C].");
}
}
public void ThrowsForUnmatchedTarget()
{
var mapperSpec = FluentMapper
.ThatMaps <TargetWithExtraStringC>().From <SimpleSource>();
Assert.That(() => mapperSpec.Create(), Throws.Exception);
try
{
mapperSpec.Create();
}
catch (Exception ex)
{
Assert.AreEqual(ex.Message, "Target String TargetWithExtraStringC.C is unmatched.");
}
}
public void TestTypeMapTypeLevelResolverWithAttributes()
{
// Setup
var resolver = new TypeMapTypeLevelResolver();
FluentMapper
.Type <Guid>()
.DbType(DbType.AnsiStringFixedLength);
// Act
var result = resolver.Resolve(typeof(Guid));
var expected = DbType.AnsiStringFixedLength;
// Assert
Assert.AreEqual(expected, result);
}
public void FluentMapper_GetColumnInfo_Maps_ColumnName_To_Value_Provided()
{
// Arrange
var mapper = new FluentMapper <Dog>(Constants.TABLENAME_Prefix);
mapper.Property(d => d.Name, Constants.COLUMNNAME_Name);
var personType = typeof(Dog);
var personProperty = personType.GetProperty(Constants.COLUMNNAME_Name);
// Act
var ci = mapper.GetColumnInfo(personProperty);
// Assert
Assert.AreEqual(Constants.COLUMNNAME_Name, ci.ColumnName);
}
public void ContextualConstructor()
{
var ctor = new Mock <Func <StringifyContext, TargetWithExtraStringC> >(MockBehavior.Strict);
ctor.Setup(x => x(It.IsAny <StringifyContext>())).Returns(() => new TargetWithExtraStringC());
var mapper = FluentMapper
.ThatMaps <SimpleTarget>().From <SimpleSource>()
.UsingContext <StringifyContext>()
.WithConstructor(ctx => ctor.Object(ctx))
.Create();
mapper.Map(new SimpleSource(), new StringifyContext());
ctor.Verify(x => x(It.IsAny <StringifyContext>()));
}
public static void Carregar()
{
if (_carregado)
{
return;
}
FluentMapper.Initialize(config =>
{
config.AddMap(new ClienteMap());
config.AddMap(new IngredienteMap());
config.ForDommel();
});
_carregado = true;
}
public void TestIdentityResolverWithKeyAttributeAndMappings()
{
// Setup
var resolver = new IdentityResolver();
FluentMapper
.Entity <EntityModelWithKeyAttribute>()
.Primary(e => e.SecondaryId);
// Act
var result = resolver.Resolve(typeof(EntityModelWithKeyAttribute)).GetMappedName();
var expected = "PrimaryId";
// Assert
Assert.AreEqual(expected, result);
}
public void EntityMapsCustomIdAsKey()
{
PreTest();
FluentMapper.Initialize(c => c.AddMap(new MapWithCustomIdPropertyMap()));
var type = typeof(CustomIdEntity);
var keyResolver = new Dommel.Resolvers.DommelKeyPropertyResolver();
var columnResolver = new Dommel.Resolvers.DommelColumnNameResolver();
var keys = keyResolver.ResolveKeyProperties(type);
var columnName = columnResolver.ResolveColumnName(keys.Single().Property);
Assert.Single(keys);
Assert.Equal("customid", columnName);
}
public static void Register()
{
FluentMapper.Initialize(config =>
{
config.AddMap(new UsuarioMap());
config.AddMap(new EnderecoMap());
config.AddMap(new FinanceiroMap());
config.AddMap(new ClienteMap());
config.AddMap(new EventoMap());
config.AddMap(new ContratoMap());
config.AddMap(new ParcelaMap());
config.AddMap(new FuncionarioMap());
config.AddMap(new CrmMap());
config.ForDommel();
});
}
public void TestPropertyHandlerTypeLevelResolverWithAttributes()
{
// Setup
var resolver = new PropertyHandlerTypeLevelResolver();
FluentMapper
.Type <int>()
.PropertyHandler <IntPropertyHandler>();
// Act
var result = resolver.Resolve(typeof(int))?.GetType();
var expected = typeof(IntPropertyHandler);
// Assert
Assert.AreEqual(expected, result);
}
public void WithConstructor()
{
var mockCtor = new Mock <Func <SimpleTarget> >(MockBehavior.Strict);
var target = new SimpleTarget();
mockCtor.Setup(x => x()).Returns(target);
var mapper = FluentMapper
.ThatMaps <SimpleTarget>().From <SimpleSource>()
.WithConstructor(mockCtor.Object)
.Create();
var result = mapper.Map(new SimpleSource());
mockCtor.Verify(x => x(), Times.Once());
}
public void TestPropertyMappedNameResolverWithColumnAttributeAndMappings()
{
// Setup
var resolver = new PropertyMappedNameResolver();
FluentMapper
.Entity <EntityModelWithColumnAttribute>()
.Column(e => e.Id, "[ColumnId]");
// Act
var result = resolver.Resolve(typeof(EntityModelWithColumnAttribute).GetProperty("Id"), null);
var expected = "[PrimaryId]";
// Assert
Assert.AreEqual(expected, result);
}
public void FluentMapper_GetColumnInfo_Does_Not_Map_ColumnName_To_Attribute()
{
//Arrange
var mapper = new FluentMapper <Person>(Constants.TABLENAME_Prefix);
mapper.Property(d => d.Name, Constants.COLUMNNAME_Name);
var personType = typeof(Person);
var personProperty = personType.GetProperty(Constants.COLUMNNAME_Name);
//Act
var ci = mapper.GetColumnInfo(personProperty);
//Assert
Assert.AreNotEqual(Constants.COLUMNNAME_PersonName, ci.ColumnName);
}
public void DerivedProperties()
{
// Arrange
FluentMapper.Initialize(c => c.AddConvention <DerivedConvention>().ForEntity <DerivedTestEntity>());
var typeMap = SqlMapper.GetTypeMap(typeof(DerivedTestEntity));
// Act
var colName = typeMap.GetMember("colName");
var colId = typeMap.GetMember("colId");
//Assert
Assert.NotNull(colName);
Assert.NotNull(colId);
Assert.Equal(typeof(DerivedTestEntity).GetProperty(nameof(DerivedTestEntity.Name)), colName.Property);
Assert.Equal(typeof(DerivedTestEntity).GetProperty(nameof(TestEntity.Id)), colId.Property);
}
public void NullableProperties()
{
// Arrange
FluentMapper.Initialize(c => c.AddConvention <NullableConvention>().ForEntity <TestEntity>());
var typeMap = SqlMapper.GetTypeMap(typeof(TestEntity));
// Act
var colValue = typeMap.GetMember("intId");
var colValueNotNull = typeMap.GetMember("intOtherId");
//Assert
Assert.NotNull(colValue);
Assert.NotNull(colValueNotNull);
Assert.Equal(typeof(TestEntity).GetProperty(nameof(TestEntity.Id)), colValue.Property);
Assert.Equal(typeof(TestEntity).GetProperty(nameof(TestEntity.OtherId)), colValueNotNull.Property);
}
public static void Map()
{
if (mapped)
{
return;
}
FluentMapper.Initialize(config =>
{
mapped = true;
config.AddMap(new ProjectMapper());
config.AddMap(new BuyerMapper());
config.AddMap(new ShopMapper());
config.AddMap(new SupplierMapper());
config.AddMap(new ConnectionMapper());
});
}
public static IServiceCollection AddInfrastructure(this IServiceCollection collection)
{
FluentMapper.Initialize(
config =>
{
config.AddMap(new DataWithVersionMap());
config.AddMap(new OrderComponentMap());
});
SqlMapper.AddTypeHandler(new JObjectTypeHandler());
NpgsqlConnection.GlobalTypeMapper.UseJsonNet(jsonbClrTypes: new Type[] { typeof(JObject) });
collection.AddScoped <IEventDataLayer, EventDataLayer>();
collection.AddSingleton <IDatabaseConnectionFactory, DatabaseConnectionFactory>();
return(collection);
}
public static void RegisterDapperMapper()
{
FluentMapper.Initialize(config =>
{
config.AddMap(new SegmentMap());
config.AddMap(new CountryMap());
config.ForDommel();
});
SqlMapperExtensions.TableNameMapper = (type) =>
{
// do something here to pluralize the name of the type
return(type.Name);
};
}
public void ContextRetainedAfterIgnore()
{
var mapper = FluentMapper
.ThatMaps <TargetWithExtraStringC>().From <SourceWithExtraDoubleC>()
.UsingContext <StringifyContext>()
.ThatSets(x => x.C).From((src, ctx) => ctx.ArbitraryMethod(src.C))
.IgnoringSourceProperty(x => x.A)
.IgnoringTargetProperty(x => x.A)
.Create();
var source = new SourceWithExtraDoubleC();
var result = mapper.Map(source, new StringifyContext());
Assert.That(result.A, Is.Null);
Assert.That(result.C, Is.EqualTo("4.2"));
}
/// <summary>
/// Configers Dapper to use your conventions when handling the database
/// </summary>
private static void ConfigureDapper()
{
FluentMapper.Initialize(config =>
{
config
.AddConvention <PropertyTransformConvention>()
.ForEntity <PeriodEntry>()
.ForEntity <PropertyValuePair>()
.ForEntity <Profile>();
});
SqlMapper.RemoveTypeMap(typeof(DateTime));
SqlMapper.RemoveTypeMap(typeof(TimeSpan));
SqlMapper.AddTypeHandler(new DateTimeHandler());
SqlMapper.AddTypeHandler(new TimeSpanHandler());
}
public DapperRepositoryBase(IConfiguration configuration)
{
_configuration = configuration;
if (FluentMapper.EntityMaps.IsEmpty)
{
FluentMapper.Initialize(c =>
{
c.AddMap(new BookDapperMap());
c.AddMap(new AuthorDapperMap());
c.ForDommel();
});
}
conn = new SqlConnection(_configuration.GetConnectionString("DefaultConnection"));
}
public void ArquivoComMapeamentoCorreto()
{
FluentMapper.Initialize(folderPath, fileName, c =>
{
c.AddMap(new ArquivoModeloMap());
c.AddFromDataAnnotations <HeaderDoArquivo>(typeof(HeaderDoArquivo));
});
var arquivo = Builder <HeaderDoArquivo> .CreateNew().Build();
FluentMapper.Write(arquivo);
var path = Path.Combine(folderPath, fileName);
Assert.IsTrue(Directory.Exists(folderPath) && File.Exists(path));
}
public void FluentMapper_GetColumnInfo_Returns_ColumnInfo()
{
// Arrange
var mapper = new FluentMapper <Dog>(Constants.TABLENAME_Prefix);
mapper.Property(d => d.Name, Constants.COLUMNNAME_Name);
var dogType = typeof(Dog);
var dogProperty = dogType.GetProperty(Constants.COLUMNNAME_Name);
// Act
var ci = mapper.GetColumnInfo(dogProperty);
// Assert
Assert.IsInstanceOf <ColumnInfo>(ci);
}
public void ShouldMapEntitiesInAssembly()
{
PreTest();
// Arrange & Act
FluentMapper.Initialize(c => c.AddConvention <TestConvention>().ForEntitiesInAssembly(typeof(ConventionTests).GetTypeInfo().Assembly));
// Assert
var conventions = FluentMapper.TypeConventions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
Assert.NotEmpty(conventions);
Assert.True(conventions.ContainsKey(typeof(TestEntity)));
var map = conventions[typeof(TestEntity)];
Assert.True(map[0] is TestConvention);
}
public static void Register()
{
FluentMapper.Initialize(config =>
{
config.AddMap(new LoginDapperMap());
config.AddMap(new AddressDapperMap());
config.AddMap(new ContactDapperMap());
config.AddMap(new DoctorDapperMap());
config.AddMap(new SecretaryDapperMap());
config.AddMap(new PatientDapperMap());
config.AddMap(new ConvenioDapperMap());
config.AddMap(new ConsultaDapperMap());
config.AddMap(new MaterialDapperMap());
config.ForDommel();
});
}
private static void DatabaseColumnsMapping()
{
FluentMapper.Initialize(config =>
{
config.AddMap(new MatchMap());
config.AddMap(new TeamMap());
config.AddMap(new PlayerMap());
config.AddMap(new ScrapingInformationMap());
config.AddMap(new MetricMap());
config.AddMap(new PlayerHeadToHeadMap());
config.AddMap(new PlayerOverUnderMap());
config.AddMap(new SportMap());
config.AddMap(new ProviderMap());
config.AddMap(new TempTableToTestMap());
});
}
public void ListOfEmployeesWithTeritories() //2.2
{
FluentMapper.Initialize(config =>
{
config.AddMap(new EmployeeMap());
});
List <Employee> employees;
using (var db = new SqlConnection(this.connectionString))
{
employees = db.Query <Employee>("SELECT * FROM Employees").ToList();
foreach (var employee in employees)
{
var emplTerritories =
db.Query <EmployeeTerritory>(
"SELECT * FROM EmployeeTerritories WHERE EmployeeID = employeeId", new { employeeId = employee.Id });
employee.Territories = new List <Territory>();
foreach (var id in emplTerritories)
{
var t =
db.Query <Territory>("SELECT * FROM Territories WHERE TerritoryID = territoryId", new { territoryId = id.TerritoryID }).FirstOrDefault();
employee.Territories.Add(t);
}
}
}
var actual = employees.FirstOrDefault(e => e.Id == 3);
var expected = new Employee()
{
Id = 3,
LastName = "Leverling",
FirstName = "Janet",
Territories = new List <Territory>()
{
new Territory()
}
};
Assert.IsNotNull(actual);
Assert.IsNotNull(actual.Territories);
Assert.AreEqual(49, actual.Territories.Count);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.FirstName, actual.FirstName);
Assert.AreEqual(expected.LastName, actual.LastName);
}
public void Map_DataTableReaderToDictionary_ShouldReturnEntity()
{
var sut = new FluentMapper(new DefaultMappingConfiguration());
var reader = DefaultData.DataTable.CreateDataReader();
reader.Read();
var bag = sut.Map <DataTableReader, Dictionary <string, object> >(reader);
Assert.IsTrue((Guid)bag["PropertyGuid"] == DefaultData.Guid);
Assert.IsTrue((int)bag["PropertyInt"] == 10);
Assert.IsTrue((string)bag["PropertyString"] == "PropertyString");
Assert.IsTrue((string)bag["Property With Space"] == "PropertyWithSpace");
Assert.IsTrue((DummyEnum)bag["PropertyWithDummyEnum"] == DummyEnum.Hundred);
Assert.IsTrue((DummyEnum)bag["PropertyWithDummyEnum1"] == DummyEnum.Max);
}
public void Map_DataTableReaderToEntity_ShouldReturnEntity()
{
var sut = new FluentMapper(new DefaultMappingConfiguration());
var reader = DefaultData.DataTable.CreateDataReader();
reader.Read();
var entity = sut.Map <DataTableReader, EntityWithPlainNames>(reader);
Assert.IsTrue(entity.PropertyGuid == DefaultData.Guid);
Assert.IsTrue(entity.PropertyInt == 10);
Assert.IsTrue(entity.PropertyString == "PropertyString");
Assert.IsTrue(entity.PropertyWithSpace == "PropertyWithSpace");
Assert.IsTrue(entity.PropertyWithDummyEnum == DummyEnum.Hundred);
Assert.IsTrue(entity.PropertyWithDummyEnum1 == DummyEnum.Max);
}
