상속: IDataReader
예제 #1
0
        public void ContainsMappingCache_WhenDoesNotContainCache_ReturnsFalse()
        {
            var dataReader = new MockDataReader();
            dataReader.AddTable();

            Assert.IsFalse( CacheManager.ContainsMappingCache<TestClass1>( dataReader, null ) );
        }
예제 #2
0
        public void ContainsMappingCache_WhenContainsCache_ReturnsFalse()
        {
            var dataReader = new MockDataReader();
            dataReader.AddTable();

            CacheManager.StoreMappingCache( () => new MappingCache<TestClass1>( null, null ), dataReader, null );

            Assert.IsTrue( CacheManager.ContainsMappingCache<TestClass1>( dataReader, null ) );
        }
        public void DataReaderToList_WhenPropertyHasCorrosponingColmunButHasPropertyMap_OnlyUsesPropertyMap()
        {
            var dataReader = new MockDataReader();
            var rootTable = dataReader.AddTable( "IdVal", "Id" );
            dataReader.AddRow( rootTable, 1, 2 );
            dataReader.AddRow( rootTable, 1, DBNull.Value );

            var result = dataReader.DataReaderToList<PropertyMapTest>( typeof( PropertyMapTestConfiguration ) );
        }
        public void DataReaderToList_WithMappingThatSetsVirtualStringProperty_ReturnsList()
        {
            var dataReader = new MockDataReader();
            var table = dataReader.AddTable( "Id" );
            dataReader.AddRow( table, 1 );

            var result = dataReader.DataReaderToList<TestObject>( typeof ( TestObjectConfiguration ) );

            Assert.AreEqual( "Hello World", result[ 0 ].Name );
        }
예제 #5
0
        public void GetMappingCache_WhenContainsCacheSameDataReaderButDifferentConfiguration_ReturnsFalse()
        {
            var dataReader = new MockDataReader();
            var table1 = dataReader.AddTable( "Name" );
            dataReader.AddRow( table1, "" );

            var mappingCache = new MappingCache<TestClass1>( null, null );
            CacheManager.StoreMappingCache( () => mappingCache, dataReader, typeof( Configuration1 ) );

            Assert.AreEqual( mappingCache, CacheManager.GetMappingCache<TestClass1>( dataReader, typeof( Configuration1 ) ) );
        }
예제 #6
0
        public void ContainsMappingCache_WhenContainsCacheButDataReaderDoesNotMatch_ReturnsFalse()
        {
            var dataReader1 = new MockDataReader();
            var table1 = dataReader1.AddTable( "Name" );
            dataReader1.AddRow( table1, "" );
            var dataReader2 = new MockDataReader();
            var table2 = dataReader2.AddTable( "Age" );
            dataReader1.AddRow( table2, 1 );

            CacheManager.StoreMappingCache( () => new MappingCache<TestClass1>( null, null ), dataReader1, null );

            Assert.IsTrue( CacheManager.ContainsMappingCache<TestClass1>( dataReader1, null ) );
            Assert.IsFalse( CacheManager.ContainsMappingCache<TestClass1>( dataReader2, null ) );
        }
        public void DataReaderToList_WhenMultipleDictionaryJoins_DoesNotUseSameExpandoObjectMap()
        {
            var dataReader = new MockDataReader();
            var rootTable = dataReader.AddTable( "Id" );
            var users = dataReader.AddTable( "Key", "Value" );
            var places = dataReader.AddTable( "Key", "Value" );

            dataReader.AddRow( rootTable, 1 );

            dataReader.AddRow( users, 1, "User 1" );

            dataReader.AddRow( places, "Place 1", "Location" );

            var result = dataReader.DataReaderToList<WhenMultipleDictionaryJoins>( typeof( WhenMultipleDictionaryJoinsConfiguration ) );
        }
        public void GenerateToObject_WhenCalledWithMultipeTablesUsingJoinIsJoinedCorrectly_SetsPropertiesCorrectly()
        {
            IMapping mapping = new Mapping();
            Action<TestClass, List<TestContent>> listSet = ( x, y ) => x.TestContents = y;
            mapping.Join( listSet );

            mapping.Table<TestClass>( 0 );
            mapping.Table<TestContent>( 1 );

            var classMapResult = new ClassMapResult
            {
                Mappings = (Mapping)mapping
            };

            var mockDataReader = new MockDataReader();
            var table = mockDataReader.AddTable( "Length2" );
            var contentTable = mockDataReader.AddTable( "Id", "Name" );
            mockDataReader.AddRow( table, 1 );

            mockDataReader.AddRow( contentTable, 1, "Name1" );
            mockDataReader.AddRow( contentTable, 2, "Name2" );

            var func = MappingGenerator.Generate<TestClass>( new MockDataReader(), classMapResult );

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>
            {
                {
                    MappingEnum.Join, new List<object>
                    {
                        listSet
                    }
                }
            }, new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>() );

            Assert.AreEqual( 2, result.TestContents.Count );
            Assert.AreEqual( "Name1", result.TestContents[ 0 ].Name );
            Assert.AreEqual( "Name2", result.TestContents[ 1 ].Name );
        }
        public void DataReaderToList_WhenUsingConfiguration_ReturnsCorrectResult()
        {
            var dataReader = new MockDataReader();
            var rootTable = dataReader.AddTable( "Name", "Size", "DueDate" );
            var products = dataReader.AddTable( "Id", "Name", "Price", "Available" );
            var stock = dataReader.AddTable( "ProductId", "Id", "Quantity" );
            var ratings = dataReader.AddTable( "ProductId", "Rating" );

            dataReader.AddRow( rootTable, "The Shop", 12, DateTime.Now );
            dataReader.AddRow( products, 1, "Drink", 1.99m, true );
            dataReader.AddRow( products, 2, "Snack", 0.78m, false );
            dataReader.AddRow( stock, 1, 1, 20 );
            dataReader.AddRow( stock, 1, 2, 5 );
            dataReader.AddRow( stock, 2, 3, 0 );
            dataReader.AddRow( ratings, 2, (double)2 );

            var result = dataReader.DataReaderToList<RootTable>( typeof( ShopConfiguration ) );

            Assert.AreEqual( "The Shop", result[ 0 ].Name );
            Assert.AreEqual( 24, result[ 0 ].Size );
            Assert.AreEqual( 2, result[ 0 ].Products.Count );
            Assert.AreEqual( 1, result[ 0 ].Products[ 0 ].Id );
            Assert.AreEqual( "Drink", result[ 0 ].Products[ 0 ].Name );
            Assert.AreEqual( 1.99M, result[ 0 ].Products[ 0 ].Price );
            Assert.AreEqual( true, result[ 0 ].Products[ 0 ].Available );
            Assert.AreEqual( 2, result[ 0 ].Products[ 1 ].Id );
            Assert.AreEqual( "Snack", result[ 0 ].Products[ 1 ].Name );
            Assert.AreEqual( 0.78M, result[ 0 ].Products[ 1 ].Price );
            Assert.AreEqual( false, result[ 0 ].Products[ 1 ].Available );
            Assert.AreEqual( 2, result[ 0 ].Products[ 0 ].Stock.Count );
            Assert.AreEqual( 20, result[ 0 ].Products[ 0 ].Stock[ 1 ] );
            Assert.AreEqual( 5, result[ 0 ].Products[ 0 ].Stock[ 2 ] );
            Assert.AreEqual( 1, result[ 0 ].Products[ 1 ].Stock.Count );
            Assert.AreEqual( 0, result[ 0 ].Products[ 1 ].Stock[ 3 ] );
            Assert.AreEqual( 0, result[ 0 ].Products[ 0 ].ProductRatings.Count );
            Assert.AreEqual( 1, result[ 0 ].Products[ 1 ].ProductRatings.Count );
            Assert.AreEqual( 2, result[ 0 ].Products[ 1 ].ProductRatings[ 0 ].Rating );
        }
        public void Generate_WhenInputTypeIsList_ReturnsListOfData()
        {
            var classMapResult = new ClassMapResult
            {
                Mappings = new Mapping
                {
                    TableMaps = new Dictionary<int, Type>
                    {
                        { 0, typeof( TestClass ) }
                    }
                }
            };

            var mockDataReader = new MockDataReader();
            var table = mockDataReader.AddTable( "Name1", "Name 2", "Length1" );
            mockDataReader.AddRow( table, "Name 1", DBNull.Value, 1 );

            var func = MappingGenerator.Generate<List<TestClass>>( new MockDataReader(), classMapResult );

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>(), new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>() );

            Assert.AreEqual( "Name 1", result[ 0 ].Name1 );
            Assert.AreEqual( null, result[ 0 ].Name2 );
            Assert.AreEqual( 1, result[ 0 ].Length1 );
        }
        public void GenerateToObject_WhenCalled_DoesNotThrowExeception()
        {
            var classMapResult = new ClassMapResult
            {
                Mappings = new Mapping
                {
                    TableMaps = new Dictionary<int, Type>
                    {
                        { 0, typeof( TestClass ) }
                    }
                }
            };
            var mockDataReader = new MockDataReader();
            var table = mockDataReader.AddTable();
            mockDataReader.AddRow( table );

            var result = MappingGenerator.Generate<TestClass>( new MockDataReader(), classMapResult );

            result( mockDataReader, new Dictionary<MappingEnum, object>(), new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>() );
        }
        public void DataReaderToList_WithTwoTableJoinsForSameTable_JoinsTables()
        {
            var dataReader = new MockDataReader();
            var rootTable = dataReader.AddTable( "HomeTeamId", "HomeTeamId1", "AwayTeamId" );
            dataReader.AddRow( rootTable, DBNull.Value, 2, 1 );

            var teamTable = dataReader.AddTable( "Id", "Name" );
            dataReader.AddRow( teamTable, 1, "Team A" );
            dataReader.AddRow( teamTable, 2, "Team B" );

            var result = dataReader.DataReaderToList<Score>( typeof( ScoreConfiguration ) );

            Assert.AreEqual( "Team A", result[ 0 ].AwayTeam.Name );
            Assert.AreEqual( "Team B", result[ 0 ].HomeTeam.Name );
        }
        public void GenerateToObject_WhenCalledWithVariableTableTypeAndPropertyMap_UsesPropertyMap()
        {
            IMapping mapping = new Mapping();

            Func<IDataRecord, Type> variableTableType = dataRecord => typeof( StringScore );

            mapping.VariableTableType<BaseScore>( variableTableType );
            Func<IDataRecord, string> action = dataRecord => "The Score Is: " + dataRecord.GetString( 2 );
            mapping.PropertyMap<StringScore, String>( x => x.ValueString, action );

            mapping.Table<BaseScore>( 0 );

            var classMapResult = new ClassMapResult
            {
                Mappings = (Mapping)mapping
            };

            var mockDataReader = new MockDataReader();

            var scores = mockDataReader.AddTable( "Id", "ResultId", "ValueString", "ResultType" );

            mockDataReader.AddRow( scores, 1, 1, "10", 2 );

            var func = MappingGenerator.Generate<List<BaseScore>>( new MockDataReader(), classMapResult );

            var dictionary = new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>();

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>
            {
                {
                    MappingEnum.VariableTableType, new Dictionary<Type, object>
                    {
                        { typeof( BaseScore ), variableTableType }
                    }
                },
                {
                    MappingEnum.PropertyMap, new Dictionary<PropertyInfo, PropertyMap>
                    {
                        {
                            typeof( StringScore ).GetProperty( "ValueString" ), new PropertyMap( action )
                        }
                    }
                }
            }, dictionary );

            Assert.AreEqual( 1, result[ 0 ].Id );

            Assert.IsInstanceOf<StringScore>( result[ 0 ] );

            Assert.AreEqual( "The Score Is: 10", ( result[ 0 ] as StringScore ).ValueString );
        }
        public void GenerateToObject_WhenCalledWithSingleTable_SetsPropertiesCorrectly()
        {
            var classMapResult = new ClassMapResult
            {
                Mappings = new Mapping
                {
                    TableMaps = new Dictionary<int, Type>
                    {
                        { 0, typeof( TestClass ) }
                    }
                }
            };

            var mockDataReader = new MockDataReader();
            var table = mockDataReader.AddTable( "Name1", "Name 2", "Length1" );
            mockDataReader.AddRow( table, "Name 1", DBNull.Value, 1 );

            var func = MappingGenerator.Generate<TestClass>( new MockDataReader(), classMapResult );

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>(), new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>() );

            Assert.AreEqual( "Name 1", result.Name1 );
            Assert.AreEqual( null, result.Name2 );
            Assert.AreEqual( 1, result.Length1 );
        }
        public void GenerateToObject_WhenCalledWithPropertyMapColumnName_ReturnsCorrectData()
        {
            IMapping mapping = new Mapping();

            mapping.Table<TestClass>( 0 );
            mapping.PropertyMap<TestClass,string>( x => x.Name1, "Name" );

            var classMapResult = new ClassMapResult
            {
                Mappings = (Mapping)mapping
            };

            var mockDataReader = new MockDataReader();

            var scores = mockDataReader.AddTable( "Name" );

            string expectedName = "The name";
            mockDataReader.AddRow( scores, expectedName );

            var func = MappingGenerator.Generate<List<TestClass>>( new MockDataReader(), classMapResult );

            var dictionary = new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>();

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>
            {
                {
                    MappingEnum.PropertyMap, new Dictionary<PropertyInfo, PropertyMap>
                    {
                        {
                            typeof( TestClass ).GetProperty( "Name1" ), new PropertyMap( "Name" )
                        }
                    }
                }
            }, dictionary );

            Assert.AreEqual( expectedName, result[ 0 ].Name1 );
        }
        public void GenerateToObject_WhenCalledWithMultipeTablesWithResultingDictionary_FillsDictionaryCorrectly()
        {
            IMapping mapping = new Mapping();
            Func<TestClass, dynamic, bool> condition = ( @class, o ) => true;
            Action<TestClass, Dictionary<int, string>> destination = ( @class, values ) => @class.TestContentDictionary = values;
            mapping.AddJoin( x =>
                x.DictionaryTableJoin<TestClass>()
                    .Condition( condition )
                    .KeyColumn( "Id" )
                    .ValueColumn( "Name" )
                    .SetDestinationProperty( destination )
                    .ChildTable( 1 ) );

            mapping.Table<TestClass>( 0 );

            var classMapResult = new ClassMapResult
            {
                Mappings = (Mapping)mapping
            };

            var mockDataReader = new MockDataReader();
            var table = mockDataReader.AddTable( "Length2", "TestContentId" );
            var contentTable = mockDataReader.AddTable( "Id", "Name" );

            mockDataReader.AddRow( table, 1, 1 );

            mockDataReader.AddRow( contentTable, 1, "Name1" );
            mockDataReader.AddRow( contentTable, 2, "Name2" );

            var func = MappingGenerator.Generate<TestClass>( new MockDataReader(), classMapResult );

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>
            {
                {
                    MappingEnum.DictionaryJoin, new List<KeyValuePair<object, object>>
                    {
                        new KeyValuePair<object, object>( condition, destination )
                    }
                }
            }, new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>() );

            Assert.AreEqual( 2, result.TestContentDictionary.Count );
            Assert.AreEqual( "Name1", result.TestContentDictionary[ 1 ] );
            Assert.AreEqual( "Name2", result.TestContentDictionary[ 2 ] );
        }
        public void GenerateToObject_WhenCalledWithVariableTableType_UsesCorrectType()
        {
            IMapping mapping = new Mapping();

            Func<Result, BaseScore, bool> canJoin = ( r, b ) => r.Id == b.ResultId;
            Action<Result, List<BaseScore>> listSet = ( r, b ) => r.Scores = b;
            Func<IDataRecord, Type> variableTableType = dataRecord =>
            {
                switch ( dataRecord.GetInt32( 4 ) )
                {
                    case 1:
                        return typeof( IntScore );
                    default:
                        return typeof( StringScore );
                }
            };

            mapping.TableJoin<Result, BaseScore>( canJoin, listSet );
            mapping.VariableTableType<BaseScore>( variableTableType );

            mapping.Table<Result>( 0 );
            mapping.Table<BaseScore>( 1 );

            var classMapResult = new ClassMapResult
            {
                Mappings = (Mapping)mapping
            };

            var mockDataReader = new MockDataReader();

            var results = mockDataReader.AddTable( "Id", "Name" );
            var scores = mockDataReader.AddTable( "Id", "ResultId", "Value", "ValueString", "ResultType" );

            mockDataReader.AddRow( results, 1, "Result 1" );
            mockDataReader.AddRow( results, 2, "Result 2" );

            mockDataReader.AddRow( scores, 1, 1, 10, "", 1 );
            mockDataReader.AddRow( scores, 1, 2, DBNull.Value, "10", 2 );

            var func = MappingGenerator.Generate<List<Result>>( new MockDataReader(), classMapResult );

            var dictionary = new Dictionary<Tuple<int, Type>, Func<IDataRecord, Dictionary<MappingEnum, object>, object>>();

            var result = func( mockDataReader, new Dictionary<MappingEnum, object>
            {
                {
                    MappingEnum.TableJoin, new List<TableJoinMap>
                    {
                        new TableJoinMap
                        {
                            CanJoin = canJoin,
                            ListSet = listSet
                        }
                    }
                },
                {
                    MappingEnum.VariableTableType, new Dictionary<Type, object>
                    {
                        { typeof( BaseScore ), variableTableType }
                    }
                }
            }, dictionary );

            Assert.AreEqual( 1, result[ 0 ].Id );
            Assert.AreEqual( 2, result[ 1 ].Id );

            Assert.AreEqual( 1, result[ 0 ].Scores.Count );
            Assert.AreEqual( 1, result[ 1 ].Scores.Count );

            Assert.IsInstanceOf<IntScore>( result[ 0 ].Scores[ 0 ] );
            Assert.IsInstanceOf<StringScore>( result[ 1 ].Scores[ 0 ] );

            Assert.AreEqual( 10, ( result[ 0 ].Scores[ 0 ] as IntScore ).Value );
            Assert.AreEqual( "10", ( result[ 1 ].Scores[ 0 ] as StringScore ).ValueString );
        }
        public void DataReaderToList_WithNullablePropertyThatHasAValueOnTheFirstRowAndNullOnTheSecondRow_SetsTheSecondObjectsPropertyToNull()
        {
            var dataReader = new MockDataReader();
            var rootTable = dataReader.AddTable( "Name", "Score" );

            dataReader.AddRow( rootTable, "Team A", (int?)12 );
            dataReader.AddRow( rootTable, "Team B", DBNull.Value );

            var result = dataReader.DataReaderToList<NullableTest>();

            Assert.AreEqual( 12, result[ 0 ].Score );
            Assert.IsNull( result[ 1 ].Score );
        }