public void TestThatGetDataThrowsArgumentNullExceptionIfOnHandleOracleDataIsNull()
        {
            var fixture = new Fixture();

            fixture.Customize <ITable>(e => e.FromFactory(() => MockRepository.GenerateMock <ITable>()));

            var tableMock = fixture.CreateAnonymous <ITable>();

            using (var oracleClient = new OracleClient())
            {
                Assert.Throws <ArgumentNullException>(() => oracleClient.GetData(tableMock, null));

                oracleClient.Dispose();
            }

            tableMock.AssertWasNotCalled(m => m.Fields);
            tableMock.AssertWasNotCalled(m => m.RecordFilters);
            tableMock.AssertWasNotCalled(m => m.PrimaryKey);
            tableMock.AssertWasNotCalled(m => m.NameSource);
        }
        public void TestThatGetDataThrowsArgumentNullExceptionIfTableIsNull()
        {
            var fixture = new Fixture();

            fixture.Customize <IHandleDataEventArgs>(e => e.FromFactory(() => MockRepository.GenerateMock <IHandleDataEventArgs>()));
            DeliveryEngineEventHandler <IHandleDataEventArgs> onHandleOracleData = (s, e) =>
            {
                Assert.That(s, Is.Not.Null);
                Assert.That(e, Is.Not.Null);
            };

            onHandleOracleData.Invoke(fixture.CreateAnonymous <object>(), fixture.CreateAnonymous <IHandleDataEventArgs>());

            using (var oracleClient = new OracleClient())
            {
                Assert.Throws <ArgumentNullException>(() => oracleClient.GetData(null, onHandleOracleData));

                oracleClient.Dispose();
            }
        }
        public void TestThatGetDataGetDataWithRecordFilters()
        {
            var fieldCollectionMock = new List <IField>(7)
            {
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>(),
                MockRepository.GenerateMock <IField>()
            };

            fieldCollectionMock.ElementAt(0).Expect(m => m.NameSource)
            .Return("SYSTEM_NR")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfSource)
            .Return(typeof(int?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(int?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(0).Expect(m => m.Nullable)
            .Return(false)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(1).Expect(m => m.NameSource)
            .Return("TABEL")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(1).Expect(m => m.DatatypeOfSource)
            .Return(typeof(int?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(1).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(int?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(1).Expect(m => m.Nullable)
            .Return(false)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(2).Expect(m => m.NameSource)
            .Return("NR")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(2).Expect(m => m.DatatypeOfSource)
            .Return(typeof(string))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(2).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(string))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(2).Expect(m => m.Nullable)
            .Return(false)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(3).Expect(m => m.NameSource)
            .Return("TEKST")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(3).Expect(m => m.DatatypeOfSource)
            .Return(typeof(string))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(3).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(string))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(3).Expect(m => m.Nullable)
            .Return(true)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(4).Expect(m => m.NameSource)
            .Return("FORDELPCT")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(4).Expect(m => m.DatatypeOfSource)
            .Return(typeof(decimal?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(4).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(decimal?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(4).Expect(m => m.Nullable)
            .Return(true)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(5).Expect(m => m.NameSource)
            .Return("O_DATO")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(5).Expect(m => m.DatatypeOfSource)
            .Return(typeof(DateTime?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(5).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(DateTime?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(5).Expect(m => m.Nullable)
            .Return(true)
            .Repeat.Any();
            fieldCollectionMock.ElementAt(6).Expect(m => m.NameSource)
            .Return("O_TID")
            .Repeat.Any();
            fieldCollectionMock.ElementAt(6).Expect(m => m.DatatypeOfSource)
            .Return(typeof(TimeSpan?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(6).Expect(m => m.DatatypeOfTarget)
            .Return(typeof(TimeSpan?))
            .Repeat.Any();
            fieldCollectionMock.ElementAt(6).Expect(m => m.Nullable)
            .Return(true)
            .Repeat.Any();
            var primaryKeyMock = MockRepository.GenerateMock <ICandidateKey>();

            primaryKeyMock.Expect(m => m.Fields)
            .Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(fieldCollectionMock.GetRange(0, 3).Select(field => new KeyValuePair <IField, IMap>(field, null)))))
            .Repeat.Any();
            var recordFilterCollectionMock = new List <IFilter>(2)
            {
                MockRepository.GenerateMock <IFilter>(),
                MockRepository.GenerateMock <IFilter>()
            };

            recordFilterCollectionMock.ElementAt(0).Expect(m => m.AsSql())
            .Return("TABEL=0")
            .Repeat.Any();
            recordFilterCollectionMock.ElementAt(1).Expect(m => m.AsSql())
            .Return("TABEL=1")
            .Repeat.Any();
            var tableMock = MockRepository.GenerateMock <ITable>();

            tableMock.Expect(m => m.NameSource)
            .Return("TABEL")
            .Repeat.Any();
            tableMock.Expect(m => m.PrimaryKey)
            .Return(primaryKeyMock)
            .Repeat.Any();
            tableMock.Expect(m => m.RecordFilters)
            .Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(recordFilterCollectionMock)))
            .Repeat.Any();
            tableMock.Expect(m => m.Fields)
            .Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollectionMock)))
            .Repeat.Any();

            using (var oracleClient = new OracleClient())
            {
                var data = new List <IEnumerable <IDataObjectBase> >();
                oracleClient.GetData(tableMock, (s, e) =>
                {
                    data.AddRange(e.Data);
                    Assert.That(data.Any(row =>
                    {
                        var dataRow = row.ToList();
                        return(dataRow.ElementAt(1).GetSourceValue <int?>() == 0 &&
                               dataRow.ElementAt(1).GetSourceValue <int?>() == 1);
                    }), Is.False);
                });
                Assert.That(data, Is.Not.Null);

                var dataAsList = data.ToList();
                Assert.That(dataAsList, Is.Not.Null);
                Assert.That(dataAsList.Count(), Is.GreaterThan(0));

                oracleClient.Dispose();
            }

            tableMock.AssertWasCalled(m => m.Fields);
            tableMock.AssertWasCalled(m => m.RecordFilters);
            tableMock.AssertWasCalled(m => m.PrimaryKey);
            tableMock.AssertWasCalled(m => m.NameSource);
            recordFilterCollectionMock.ElementAt(0).AssertWasCalled(m => m.AsSql());
            recordFilterCollectionMock.ElementAt(1).AssertWasCalled(m => m.AsSql());
            primaryKeyMock.AssertWasCalled(m => m.Fields);
        }