public void ProcessOneSheetNullableFile_HasCorrectNullableSequence()
{
var source = TestSampleFiles.Sample_OneSheet_Nullable_WithErrors;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <OneSheetExcel>().WithTables(table =>
{
table.Bind("My Sheet 1", m => m.FirstSheetRows).WithColumns(column =>
{
column.Bind("Text Column", c => c.TextColumn);
column.Bind("Some Int", c => c.IntColumn);
column.Bind("Decimals", c => c.DecimalColumn);
column.Bind("Nullable ints", c => c.NullableIntColumn);
column.Bind("Nullable ints with err", c => c.NullableIntWithErrColumn);
});
});
var result = reader.AsClass <OneSheetExcel>(out List <string> errors, config);
var targetResult = new List <int?> {
1, null, 3, 4, 5, 6, 7
};
result.FirstSheetRows.Select(s => s.NullableIntWithErrColumn).ShouldBe(targetResult);
errors.Count.ShouldBe(1);
}
}
public void ProcessOneSheetNullableFile_HasCorrectNullableSequence()
{
var source = TestSampleFiles.Sample_OneSheet_Nullable;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <OneSheetExcel>().WithTables(table =>
{
table.Bind("My Sheet 1", m => m.FirstSheetRows).WithColumns(column =>
{
column.Bind("Text Column", c => c.TextColumn);
column.Bind("Some Int", c => c.IntColumn);
column.Bind("Decimals", c => c.DecimalColumn);
column.Bind("Nullable ints", c => c.NullableIntColumn);
column.Bind("Nullable Enums", c => c.NullableEnumColumn);
});
});
var result = reader.AsClass <OneSheetExcel>(config);
var targetResult = new List <int?> {
1, 2, null, 4, 5, null, 7
};
result.FirstSheetRows.Select(s => s.NullableIntColumn).ShouldBe(targetResult);
var targetEnumResult = new List <MyEnum?> {
MyEnum.Val1, MyEnum.Val2, MyEnum.Val2, null, MyEnum.Val1, MyEnum.Val1, MyEnum.Val1
};
result.FirstSheetRows.Select(s => s.NullableEnumColumn).ShouldBe(targetEnumResult);
}
}
public void ProcessOneSheetFile_HasCorrectData()
{
var source = TestSampleFiles.Sample_OneSheet;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <OneSheetExcel>().WithTables(table =>
{
table.Bind("My Sheet 1", m => m.FirstSheetRows).WithColumns(column =>
{
column.Bind("Text Column", c => c.TextColumn);
column.Bind("Some Int", c => c.IntColumn);
column.Bind("Decimals", c => c.DecimalColumn);
});
});
var result = reader.AsClass <OneSheetExcel>(config);
var targetText = new List <string> {
"Data 1", "Data 2", "Other Data"
};
result.FirstSheetRows.Select(s => s.TextColumn).ShouldBe(targetText);
var targetInts = new List <int> {
1, 2, 3
};
result.FirstSheetRows.Select(s => s.IntColumn).ShouldBe(targetInts);
var targetDecimals = new List <decimal> {
1.5m, 3m, 4.5m
};
result.FirstSheetRows.Select(s => s.DecimalColumn).ShouldBe(targetDecimals);
}
}
public static void ConfigureModel()
{
FluentConfig.Config()
.With <Violation>()
.Match(x => x.Type)
.Merge(x => x.Type)
.Merge(x => x.CreatedAt)
.MergeOnMatchOrCreate(p => p.Type)
.MergeOnMatchOrCreate(p => p.CreatedAt)
.Set();
FluentConfig.Config()
.With <Alert>()
.Match(x => x.AlertId)
.Merge(x => x.Type)
.Merge(x => x.CreatedAt)
.Merge(x => x.SeverityLevel)
.Merge(x => x.Status)
.Merge(x => x.Description)
.Merge(x => x.AlertId)
.MergeOnMatchOrCreate(p => p.Type)
.MergeOnMatchOrCreate(p => p.CreatedAt)
.MergeOnMatchOrCreate(p => p.SeverityLevel)
.MergeOnMatchOrCreate(p => p.Status)
.MergeOnMatchOrCreate(p => p.Description)
.MergeOnMatchOrCreate(p => p.Description)
.MergeOnMatchOrCreate(p => p.AlertId)
.Set();
}
public static void Setup(Type type)
{
try
{
var items = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(type.IsAssignableFrom).Select(t => t.Assembly);
var fluentConfig = FluentMappingConfiguration.Scan(s =>
{
foreach (var item in items)
{
s.Assembly(item);
s.WithSmartConventions();
s.TablesNamed(
t =>
t.GetCustomAttributes(true).OfType <TableNameAttribute>().FirstOrDefault()?.Value ??
Inflector.AddUnderscores(Inflector.MakePlural(t.Name)).ToLower());
s.Columns.Named(m => Inflector.AddUnderscores(m.Name).ToLower());
s.Columns.IgnoreWhere(x => x.GetCustomAttributes <IgnoreAttribute>().Any());
s.PrimaryKeysNamed(t => Inflector.AddUnderscores(t.Name).ToLower() + "_id");
s.PrimaryKeysAutoIncremented(t => true);
}
});
Config = fluentConfig;
}
catch (ReflectionTypeLoadException)
{
//Swallow
}
}
public static void ConfigureModel()
{
FluentConfig.Config()
.With <User>()
.Match(x => x.AzureId)
.Merge(x => x.AzureId)
.MergeOnCreate(p => p.AzureId)
.MergeOnCreate(p => p.CreatedAt)
.MergeOnCreate(p => p.Phone)
.MergeOnMatchOrCreate(p => p.Name)
.MergeOnMatchOrCreate(p => p.Surname)
.MergeOnMatchOrCreate(p => p.Email)
.Set();
FluentConfig.Config()
.With <Role>()
.Match(role => role.RoleType)
.Merge(role => role.RoleType)
.MergeOnMatchOrCreate(role => role.RoleType)
.Set();
FluentConfig.Config()
.With <UserRoleRelationship>()
.Set();
}
public void ProcessOneSheetFile_HasCorrectEnums()
{
var source = TestSampleFiles.Sample_OneSheet;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <OneSheetExcel>().WithTables(table =>
{
table.Bind("My Sheet 1", m => m.FirstSheetRows).WithColumns(column =>
{
column.Bind("Enums", c => c.EnumColumn);
column.Bind("Str Enums", c => c.StringEnumColumn);
});
});
var result = reader.AsClass <OneSheetExcel>(config);
var targetEnums = new List <MyEnum> {
MyEnum.Value1, MyEnum.Value1, MyEnum.OtherEnum
};
result.FirstSheetRows.Select(s => s.EnumColumn).ShouldBe(targetEnums);
var targetStringEnums = new List <MyEnum> {
MyEnum.Value1, MyEnum.OtherEnum, MyEnum.Value1
};
result.FirstSheetRows.Select(s => s.StringEnumColumn).ShouldBe(targetStringEnums);
}
}
public void ProcessMultipleTablesPerSheet_CanReadAllRows()
{
var source = TestSampleFiles.Sample_ComplexMultipleSheets;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <MultipleTablesExcel>().WithTables(table =>
{
table.Bind("MultipleTables", m => m.FirstTableRows).StartingFromCell("B4").WithColumns(column =>
{
column.Bind("Name", c => c.Name, isMandatory: true);
column.Bind("Value", c => c.Value);
});
table.Bind("MultipleTables", m => m.SecondTableRows).StartingFromCell("F6").WithColumns(column =>
{
column.Bind("Title", c => c.Title, isMandatory: true);
column.Bind("Amount", c => c.Amount);
column.Bind("Count", c => c.Count);
});
});
var result = reader.AsClass <MultipleTablesExcel>(config);
result.FirstTableRows.Count.ShouldBe(3);
result.SecondTableRows.Count.ShouldBe(4);
}
}
public void SheetWithSubRows_CanReadAllDataWithSubTables()
{
var source = TestSampleFiles.Sample_ComplexMultipleSheets;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <ComplexExcel>().WithTables(table =>
{
var columnCount = 0;
object[] columns = null;
table.Bind("SubData", m => m.SheetRows).WithColumns(column =>
{
column.Bind("Id", c => c.Id);
column.Bind("Name", c => c.Name);
}).OnHeaderRead((header) =>
{
columnCount = header.Length;
columns = header;
}).OnRowRead((myRow, data) =>
{
var staticColumnCount = 2;
myRow.YearlyData = new List <SubYearlyData>();
for (int i = staticColumnCount; i < columnCount; i++)
{
myRow.YearlyData.Add(new SubYearlyData
{
Year = Convert.ToInt32(columns[i]),
Value = Convert.ToInt32(data[i]),
});
}
});
});
var result = reader.AsClass <ComplexExcel>(config);
result.SheetRows.Select(s => s.Id)
.ShouldBe(new List <int> {
1, 2, 3
});
result.SheetRows.Select(s => s.Name)
.ShouldBe(new List <string> {
"Aaaa", "Bbbb", "Cccc"
});
result.SheetRows.First().YearlyData.Select(s => s.Year)
.ShouldBe(new List <int> {
2017, 2018, 2019
});
result.SheetRows.First().YearlyData.Select(s => s.Value)
.ShouldBe(new List <int> {
11, 22, 33
});
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
FluentConfig.Register();
}
/// <summary>
/// Creates a mocked instance from an internal class.
/// </summary>
/// <param name="fullName">Fully qualified name of the target type.</param>
/// <param name="settings">Settings for the mock</param>
/// <returns>Mock instance</returns>
public static object Create(string fullName, Action <IFluentConfig> settings)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var fluentConfig = new FluentConfig();
settings(fluentConfig);
return fluentConfig.CreateMock(MockingUtil.GetTypeFrom(fullName), MockingContext.CurrentRepository);
}));
}
/// <summary>
/// Creates a mocked instance from a given type.
/// </summary>
/// <param name="type">Target type to mock</param>
/// <param name="settings">Mock settings</param>
/// <returns>Mock instance</returns>
public static object Create(Type type, Action <IFluentConfig> settings)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var fluentConfig = new FluentConfig();
settings(fluentConfig);
return fluentConfig.CreateMock(type, MockingContext.CurrentRepository);
}));
}
/// <summary>
/// Configure a positional argument with a single value.
/// </summary>
/// <typeparam name="TArg">Argument type.</typeparam>
/// <param name="getExpr">
/// Getter expression describing where the value is stored.
/// </param>
/// <returns></returns>
public Positional <TConf, TArg> HasPositionalArgument <TArg>(
Expression <Func <TConf, TArg> > getExpr)
{
var positional = new Positional <TConf, TArg>(this,
GetDefinitionFromExpression(getExpr));
FluentConfig.Add(positional);
return(positional);
}
/// <summary>
/// Configure a named argument with multiple values.
/// </summary>
/// <typeparam name="TArg">Argument type.</typeparam>
/// <param name="getExpr">
/// Getter expression describing where the values are stored.
/// </param>
/// <returns></returns>
public NamedList <TConf, TArg> HasNamedArgumentList <TArg>(
Expression <Func <TConf, TArg> > getExpr)
{
var named = new NamedList <TConf, TArg>(this,
GetDefinitionFromExpression(getExpr));
FluentConfig.Add(named);
return(named);
}
/// <summary>
/// Creates a mocked instance from settings specified in the lambda.
/// </summary>
/// <typeparam name="T">Type of the mock</typeparam>
/// <param name="settings">Specifies mock settings</param>
/// <returns>Mock instance</returns>
public static T Create <T>(Action <IFluentConfig <T> > settings)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var fluentConfig = new FluentConfig <T>();
settings(fluentConfig);
return (T)fluentConfig.CreateMock(typeof(T), MockingContext.CurrentRepository);
}));
}
public void Init()
{
FluentConfig.Config()
.With <Gene>("Gene")
.MergeOnCreate(gene => gene.Name)
.MergeOnMatch(gene => gene.Name)
.MergeOnMatchOrCreate(gene => gene.Name)
.Set();
FluentConfig.Config()
.With <Variation>("Variation")
.MergeOnCreate(variation => variation.Location)
.MergeOnCreate(variation => variation.Description)
.MergeOnMatch(variation => variation.Location)
.MergeOnMatch(variation => variation.Description)
.MergeOnMatchOrCreate(variation => variation.Location)
.MergeOnMatchOrCreate(variation => variation.Description)
.Set();
FluentConfig.Config()
.With <Protein>("Protein")
.MergeOnCreate(protein => protein.Name)
.MergeOnCreate(protein => protein.FullName)
.MergeOnCreate(protein => protein.Code)
.MergeOnMatch(protein => protein.Name)
.MergeOnMatch(protein => protein.FullName)
.MergeOnMatch(protein => protein.Code)
.MergeOnMatchOrCreate(protein => protein.Name)
.MergeOnMatchOrCreate(protein => protein.FullName)
.MergeOnMatchOrCreate(protein => protein.Code)
.Set();
FluentConfig.Config()
.With <Comment>("Comment")
.MergeOnCreate(comment => comment.Text)
.MergeOnCreate(comment => comment.Type)
.MergeOnMatch(comment => comment.Text)
.MergeOnMatch(comment => comment.Type)
.MergeOnMatchOrCreate(comment => comment.Text)
.MergeOnMatchOrCreate(comment => comment.Type)
.Set();
FluentConfig.Config()
.With <Taxon>("Taxon")
.MergeOnCreate(taxon => taxon.Name)
.MergeOnMatch(taxon => taxon.Name)
.MergeOnMatchOrCreate(taxon => taxon.Name)
.Set();
FluentConfig.Config()
.With <Sequence>("Sequence")
.MergeOnCreate(sequence => sequence.Content)
.MergeOnMatch(sequence => sequence.Content)
.MergeOnMatchOrCreate(sequence => sequence.Content)
.Set();
}
public FluentConfig <T> DefaultConfig()
{
var defaultConfig = new FluentConfig <T>
{
ResultMapper = FluentMapper <T> .ReflectMap,
Key = "Id"
};
return(defaultConfig);
}
public void Apply(FluentConfig config)
{
config.AssertNotNull();
var from = _log.GetOrDefault(config, -1) + 1;
from.UpTo(_clauses.Count() - 1).ForEach(i =>
{
Clauses[i](config);
_log[config] = i;
});
}
public void ShouldConfigMapping()
{
ExtensionList extensions = new ExtensionList();
FluentConfig.Configure(extensions)
.MapingFromAssemblyOf <FluentConfigTest>();
Assert.IsTrue(extensions.ContainsKey(typeof(Dbo1).FullName), "Not mapping");
Assert.IsFalse(extensions.ContainsKey(typeof(Dbo2).FullName), "Fail mapping for abstract");
Assert.IsFalse(extensions.ContainsKey(typeof(Dbo3).FullName), "Fail mapping for generic");
}
/// <summary>
/// Configure NHibernate. This method returns an ISessionFactory instance that is
/// populated with mappings created by Fluent NHibernate.
///
/// Line 1: Begin configuration
/// 2+3: Configure the database being used (SQLite file db)
/// 4+5: Specify what mappings are going to be used (Automappings from the CreateAutomappings method)
/// 6: Expose the underlying configuration instance to the BuildSchema method,
/// this creates the database.
/// 7: Finally, build the session factory.
/// </summary>
/// <returns></returns>
private ISessionFactory CreateSessionFactory()
{
lock (SyncFactory)
{
if (_sessionFactory == null)
{
_sessionFactory = FluentConfig.BuildSessionFactory();
}
}
return(_sessionFactory);
}
public static void Setup()
{
FluentConfig fluentConfig = FluentMappingConfiguration.Configure(new EmployeeMapping());
DbFactory = DatabaseFactory.Config(x =>
{
x.UsingDatabase(() => new SqlServerDatabase(AppSettings.StringConnection));
x.WithFluentConfig(fluentConfig);
x.WithMapper(new Mapper());
});
}
public void Apply(FluentConfig config)
{
config.AssertNotNull();
var from = _log.GetOrDefault(config, -1) + 1;
from.UpTo(_clauses.Count() - 1).ForEach(i =>
{
Clauses[i](config);
_log[config] = i;
});
}
public T ReadAllWorksheets <T>(IExcelDataReader reader, FluentConfig config = null) where T : class, new()
{
var dataFromExcel = new T();
var sheetProcessors = new List <SheetProcessingData>();
List <TablePropertyData> tables = null;
if (config != null)
{
tables = config.Tables;
}
else
{
tables = GetTableProperties(typeof(T));
}
foreach (var table in tables)
{
sheetProcessors.Add(new SheetProcessingData(table, CreateSetPropertyAction(typeof(T), table.PropertyName))); //table.ExcelSheetName
}
var hasNextResult = false;
var readerWasReset = false;
do
{
readerWasReset = false;
var worksheetName = reader.Name;
var currentSheetTables = sheetProcessors.Where(m => m.TablePropertyData.ExcelSheetName.Equals(worksheetName, StringComparison.OrdinalIgnoreCase) && m.Processed == false).ToList();
if (currentSheetTables.Count > 0)
{
var processor = currentSheetTables.First();
var result = ProcessTable(reader, processor.TablePropertyData);
processor.PropertySetter(dataFromExcel, result);
processor.Processed = true;
// handling cases (experimental), where multiple tables (classes) are bound to one excel sheet
if (currentSheetTables.Count > 1)
{
reader.Reset(); // ToDo: this will kill performance on large files. Reading should be refactored to be able to read one sheet to different tables simultaneously...
readerWasReset = true;
}
}
if (!readerWasReset)
{
hasNextResult = reader.NextResult();
}
} while (hasNextResult);
return(dataFromExcel);
}
public void TestFluentNullValue()
{
var schema = new MappingSchema();
FluentConfig.Configure(schema).MapingFromType <TestObjectMap> ();
var om = schema.GetObjectMapper(typeof(TestObject));
var instance = new TestObject()
{
NullableString = "SOMEVALUE"
};
om.SetValue(instance, "NullableString", null);
Assert.AreEqual(null, instance.NullableString);
}
public void ProcessMultipleTablesPerSheet_HasCorrectData()
{
var source = TestSampleFiles.Sample_ComplexMultipleSheets;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <MultipleTablesExcel>().WithTables(table =>
{
table.Bind("MultipleTables", m => m.FirstTableRows).StartingFromCell("B4").WithColumns(column =>
{
column.Bind("Name", c => c.Name, isMandatory: true);
column.Bind("Value", c => c.Value);
});
table.Bind("MultipleTables", m => m.SecondTableRows).StartingFromCell("F6").WithColumns(column =>
{
column.Bind("Title", c => c.Title, isMandatory: true);
column.Bind("Amount", c => c.Amount);
column.Bind("Count", c => c.Count);
});
});
var result = reader.AsClass <MultipleTablesExcel>(config);
var targetFirstTableNames = new List <string> {
"Eee", "Fff", "Ggg"
};
result.FirstTableRows.Select(s => s.Name).ShouldBe(targetFirstTableNames);
var targetFirstTableValues = new List <int> {
13, 26, 75
};
result.FirstTableRows.Select(s => s.Value).ShouldBe(targetFirstTableValues);
var targetSecondTableTitles = new List <string> {
"Aaa", "Bbb", "Ccc", "Ddd"
};
result.SecondTableRows.Select(s => s.Title).ShouldBe(targetSecondTableTitles);
var targetSecondTableAmounts = new List <decimal> {
10.1m, 22.22m, 0.1m, 23m
};
result.SecondTableRows.Select(s => s.Amount).ShouldBe(targetSecondTableAmounts);
var targetSecondTableCounts = new List <int> {
4, 5, 6, 7
};
result.SecondTableRows.Select(s => s.Count).ShouldBe(targetSecondTableCounts);
}
}
public void FluentConfigShouldBePlacedOnDatabaseWhenInsertedIntoFactoryConfig()
{
var db = new Database(new SqlConnection());
var fluentConfig = new FluentConfig(x => y => new PocoData(y, new Mapper()));
var factory = DatabaseFactory.Config(x =>
{
x.UsingDatabase(() => db);
x.WithFluentConfig(fluentConfig);
});
var database = factory.GetDatabase();
Assert.AreEqual(fluentConfig.Config(null), database.PocoDataFactory);
}
public static FluentConfig DefaultEngine(this Configuration.TypeConfig generic_config)
{
return(generic_config.Hash.GetOrCreate(typeof(Gateway), () =>
{
var type = generic_config.Type;
var new_config = new TypeConfig(type);
var new_fluent_config = new FluentConfig(new_config);
var generic_rules = Repository.Rules.Where(rule => rule.Hash.ContainsKey(typeof(Gateway))).ToReadOnly();
var fluent_rules = generic_rules.Where(rule => rule.AppliesTo(type)).Select(rule => rule.DefaultEngine()).ToReadOnly();
var rules = fluent_rules.Select(rule => rule.Rule).ToReadOnly();
rules.ForEach(rule => rule.Apply(new_fluent_config));
return new_fluent_config;
}).AssertCast <FluentConfig>());
}
public void ShouldConfigMapping()
{
ExtensionList extensions = new ExtensionList();
FluentConfig.Configure(extensions).MapingFromAssemblyOf <FluentMapAttributesTest>();
var key = extensions[typeof(DboFluentMapAttributesTest).FullName];
var mem1 = key["Id"];
Assert.IsTrue(mem1.Attributes.ContainsKey("Identity"));
var mem2 = key["Test"];
Assert.IsTrue(mem2.Attributes.ContainsKey("MemberMapper"));
Assert.IsTrue(mem2.Attributes.ContainsKey("DbType"));
}
public static FluentConfig DefaultEngine(this Configuration.TypeConfig generic_config)
{
return generic_config.Hash.GetOrCreate(typeof(Gateway), () =>
{
var type = generic_config.Type;
var new_config = new TypeConfig(type);
var new_fluent_config = new FluentConfig(new_config);
var generic_rules = Repository.Rules.Where(rule => rule.Hash.ContainsKey(typeof(Gateway))).ToReadOnly();
var fluent_rules = generic_rules.Where(rule => rule.AppliesTo(type)).Select(rule => rule.DefaultEngine()).ToReadOnly();
var rules = fluent_rules.Select(rule => rule.Rule).ToReadOnly();
rules.ForEach(rule => rule.Apply(new_fluent_config));
return new_fluent_config;
}).AssertCast<FluentConfig>();
}
public void ProcessOneSheetFileWithNestedClasses_HasCorrectData()
{
var source = TestSampleFiles.Sample_OneSheet_Nullable;
using (var ms = new MemoryStream(source))
using (var reader = ExcelReaderFactory.CreateReader(ms))
{
var config = FluentConfig.ConfigureFor <OneSheetExcel>().WithTables(table =>
{
table.Bind("My Sheet 1", m => m.FirstSheetRows).WithColumns(column =>
{
column.Bind("Text Column", c => c.TextColumn);
column.Bind("Some Int", c => c.IntColumn);
column.Bind("Decimals", c => c.Nested.DecimalColumn);
column.Bind("Nullable ints", c => c.Nested.NullableIntColumn);
column.Bind("Nullable Enums", c => c.Nested.NullableEnumColumn);
});
});
var result = reader.AsClass <OneSheetExcel>(config);
var targetText = new List <string> {
"Data 1", "Data 2", "Other Data", "Lorem", "Ipsum", "Dolor", "Hodor"
};
result.FirstSheetRows.Select(s => s.TextColumn).ShouldBe(targetText);
var targetInts = new List <int> {
1, 2, 3, 4, 5, 6, 7
};
result.FirstSheetRows.Select(s => s.IntColumn).ShouldBe(targetInts);
var targetDecimals = new List <decimal> {
1.5m, 3m, 4.5m, 6m, 7.5m, 9m, 10.5m
};
result.FirstSheetRows.Select(s => s.Nested.DecimalColumn).ShouldBe(targetDecimals);
var targetResult = new List <int?> {
1, 2, null, 4, 5, null, 7
};
result.FirstSheetRows.Select(s => s.Nested.NullableIntColumn).ShouldBe(targetResult);
var targetEnumResult = new List <MyEnum?> {
MyEnum.Val1, MyEnum.Val2, MyEnum.Val2, null, MyEnum.Val1, MyEnum.Val1, MyEnum.Val1
};
result.FirstSheetRows.Select(s => s.Nested.NullableEnumColumn).ShouldBe(targetEnumResult);
}
}
public void FluentConfigShouldBePlacedOnDatabaseWhenInsertedIntoFactoryConfig()
{
var db = new Database(new SqlConnection());
var mapperCollection = new MapperCollection();
var pocoDataFactory = new FluentPocoDataFactory((y, f) => new PocoDataBuilder(y, mapperCollection).Init(), mapperCollection);
var fluentConfig = new FluentConfig(x => pocoDataFactory);
var factory = DatabaseFactory.Config(x =>
{
x.UsingDatabase(() => db);
x.WithFluentConfig(fluentConfig);
});
var database = factory.GetDatabase();
Assert.AreEqual(fluentConfig.Config(null), database.PocoDataFactory);
}
public static void ConfigureModel()
{
FluentConfig.Config()
.With <Transportation>()
.Match(x => x.TransportationId)
.Merge(x => x.TransportationId)
.Merge(x => x.IsActive)
.MergeOnCreate(p => p.TransportationId)
.MergeOnCreate(p => p.IsActive)
.MergeOnCreate(p => p.CreatedAt)
.Set();
FluentConfig.Config()
.With <CapturedLocation>()
.MergeOnMatchOrCreate(x => x.Altitude)
.MergeOnMatchOrCreate(x => x.Longitude)
.MergeOnMatchOrCreate(x => x.CapturedDateTimeUtc)
.Set();
}
