public void Close_with_Mode_Read_closes_CsvReader()
        {
            //arrange
            _csvReaderWriter.Open(FileName, Mode.Read);

            //act
            _csvReaderWriter.Close();

            //assert
            _csvStreamReader.Verify(c => c.Close());
        }
        public void Should_ReadThrowException_WhenReaderWriterIsClosed()
        {
            // Arrange
            _subject.Open("TestFileName.csv", CSVReaderWriter.Mode.Read);
            _subject.Close();

            // Act

            // Assert
            var ex = Assert.Throws <ApplicationException>(() => _subject.Read(out var column1, out var column2));

            Assert.That(ex.Message, Is.EqualTo("File is closed or hasn't been opened in read mode."));
        }
        public void Open_For_Write_When_WriterStream_Initialized_Write_Data()
        {
            var csvReadWriter = new CSVReaderWriter();

            csvReadWriter.Open(@"test_data\test.txt", CSVReaderWriter.Mode.Write);
            csvReadWriter.Write("test line 1 Column 1", "test line 1 Column 2");// The functionality forces to create the file with two columns which is quite rigid.
            csvReadWriter.Close();
            string column1 = null;
            string column2 = null;

            csvReadWriter.Open(@"test_data\test.txt", CSVReaderWriter.Mode.Read);
            csvReadWriter.Read(out column1, out column2);
            csvReadWriter.Close();
            Assert.AreEqual("test line 1 Column 1", column1);
            Assert.AreEqual("test line 1 Column 2", column2);
        }
        private Tuple <int, Exception> CountLines(string filename, bool withOutValues)
        {
            var       csvReader = new CSVReaderWriter();
            string    string1   = null;
            string    string2   = null;
            Exception ex        = null;

            csvReader.Open(filename, CSVReaderWriter.Mode.Read);
            int lineCount = 0;

            try
            {
                while (withOutValues ? csvReader.Read(out string1, out string2) : csvReader.Read(string1, string2))
                {
                    lineCount++;
                }
            }
            catch (Exception e)
            {
                ex = e;
            }

            csvReader.Close();

            return(new Tuple <int, Exception>(lineCount, ex));
        }
        public void Should_close_the_state()
        {
            _CSVReaderWriter.Open(TestInputFile, CSVReaderWriter.Mode.Write);
            _CSVReaderWriter.Close();

            Assert.That(_stream.CanRead, Is.EqualTo(false));
        }
        public void canOpenAndCloseFile()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            rw.Open(TestInputFile, Mode.Read);
            rw.Close();
        }
        public void WriteCsvFile()
        {
            //Write test file
            using (var writer = new CSVReaderWriter())
            {
                writer.Open(_testWriteDataFile, CSVReaderWriter.Mode.Write);


                foreach (var testAddress in _mailAddressTests)
                {
                    writer.Write(testAddress.Name, testAddress.Address);
                }
                writer.Close();
            }

            //Read test file
            var contacts = new List <Contact>();

            using (var reader = new CSVReaderWriter())
            {
                reader.Open(_testWriteDataFile, CSVReaderWriter.Mode.Read);
                string column1, column2;
                while (reader.Read(out column1, out column2))
                {
                    contacts.Add(new Contact(column1, column2));
                }

                reader.Close();
            }

            CollectionAssert.AreEqual(_mailAddressTests, contacts);
        }
示例#8
0
        public void Open_Method_to_write_Should_not_throw_Exception()
        {
            var csvReaderWriter = new CSVReaderWriter();

            Assert.DoesNotThrow(() => csvReaderWriter.Open(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, TestOutputFile), CSVReaderWriter.Mode.Write));

            csvReaderWriter.Close();
        }
示例#9
0
        public void Write_Method_Should_not_throw_Exception_when_empty_string_array_is_passed()
        {
            var csvReaderWriter = new CSVReaderWriter();

            Assert.DoesNotThrow(() => csvReaderWriter.Write(new string[] {}));

            csvReaderWriter.Close();
        }
        public void Write_WriterIsDisposed_ThrowException()
        {
            var csv = new CSVReaderWriter(It.IsAny <ICSVReader>(), null);

            csv.Close();

            var ex = Assert.Throws <NullReferenceException>(() => csv.Write(It.IsAny <string[]>()));

            Assert.AreEqual("The file writer is closed. Please reopen it.", ex.Message);
        }
        public void CloseCleansReader()
        {
            var readerMock = new Mock <ICsvFileReader>();

            readerMock.Setup(x => x.Close());

            var sut = new CSVReaderWriter(readerMock.Object, null);

            sut.Close();
            readerMock.Verify(x => x.Close(), Times.Once);
        }
        public void CloseCleansWriter()
        {
            var writerMock = new Mock <ICsvFileWriter>();

            writerMock.Setup(x => x.Close());

            var sut = new CSVReaderWriter(null, writerMock.Object);

            sut.Close();
            writerMock.Verify(x => x.Close(), Times.Once);
        }
        public void canWriteToFile()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            //write  could generate a random string to compare with the read but keeping it simple for now
            rw.Open(TestInputFileForEditing, Mode.Write);
            rw.Write(new string[] { "some data col1 asdfasdfasdf", "some more data for col2" });
            rw.Close();

            //read what was written
            rw.Open(TestInputFileForEditing, Mode.Read);

            string col1 = "", col2 = "";
            bool   result = rw.Read(out col1, out col2);

            rw.Close();

            Assert.That(col1, Is.EquivalentTo("some data col1 asdfasdfasdf"));
            Assert.That(col2, Is.EquivalentTo("some more data for col2"));
            Assert.That(result, Is.True);
        }
        public void Read_ReaderIsDisposed_ThrowException()
        {
            var mockReader = new Mock <ICSVReader>();
            var csv        = new CSVReaderWriter(mockReader.Object, It.IsAny <ICSVWriter>());

            csv.Close();

            string c1;
            string c2;
            var    ex = Assert.Throws <NullReferenceException>(() => csv.Read(out c1, out c2));

            Assert.AreEqual("The file reader is closed. Please reopen it.", ex.Message);
        }
示例#15
0
        public void Write_Method_Should_write_to_the_file()
        {
            var csvReaderWriter = new CSVReaderWriter();

            csvReaderWriter.Open(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, TestOutputFile), CSVReaderWriter.Mode.Write);

            csvReaderWriter.Write(new string[] { "This", "should", "be", "written", "to", "the", "file" });

            csvReaderWriter.Close();

            Assert.True(File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, TestOutputFile)));
            File.Delete(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, TestOutputFile));
        }
        public void canReadFileDisgardingOutput()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            rw.Open(TestInputFile, Mode.Read);

            string col1 = "", col2 = "";
            bool   result = rw.Read(col1, col2);

            rw.Close();

            Assert.That(result, Is.True);
        }
        public void Process(string inputFile)
        {
            _reader.Open(inputFile, CSVReaderWriter.Mode.Read);

            string column1, column2;

            while (_reader.Read(out column1, out column2))
            {
                _mailShot.SendMailShot(column1, column2);
            }

            _reader.Close();
        }
        public void canNotWriteToFileIfInReadMode()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            try
            {
                rw.Open(TestInputFileForEditing, Mode.Read);
                rw.Write(new string[] { "some data col1", "some more data for col2" });
            } finally
            {
                rw.Close();
            }
        }
示例#19
0
        public void ShouldOpenCSVReader()
        {
            _csvReaderWriter.Open(Filename, CSVReaderWriter.Mode.Read);

            _csvReader.Verify(x => x.Open(Filename));

            _csvReaderWriter.Close();
        }
示例#20
0
        public void Should_write_columns_faster_with_updates()
        {
            CSVReaderWriter csvReaderWriter = new CSVReaderWriter();

            string fileName = GetTempFilePath();

            csvReaderWriter.Open(fileName, CSVReaderWriter.Mode.Write);

            DateTime startTime = DateTime.Now;

            for (int i = 0; i < 10000; i++)
            {
                csvReaderWriter.Write("COL 1", "column 2", "Test");
            }
            DateTime endTime = DateTime.Now;

            csvReaderWriter.Close();


            TimeSpan updatedDuration = endTime.Subtract(startTime);



            CSVReaderWriterForAnnotation oldCsvReaderWriter = new CSVReaderWriterForAnnotation();

            fileName = GetTempFilePath();

            oldCsvReaderWriter.Open(fileName, CSVReaderWriterForAnnotation.Mode.Write);

            startTime = DateTime.Now;
            for (int i = 0; i < 100000; i++)
            {
                oldCsvReaderWriter.Write("COL 1", "column 2", "Test");
            }
            endTime = DateTime.Now;

            oldCsvReaderWriter.Close();


            TimeSpan oldDuration = endTime.Subtract(startTime);


            string newTime = updatedDuration.ToString("c");
            string oldTime = oldDuration.ToString("c");

            System.Diagnostics.Debug.Write(newTime);
            System.Diagnostics.Debug.Write(oldTime);

            Assert.Less(updatedDuration.Ticks, oldDuration.Ticks);
        }
        public void Read_When_Only_First_Column_Exists_Throws_Exception()
        {
            var csvReadWriter = new CSVReaderWriter();

            csvReadWriter.Open(@"test_data\test.txt", CSVReaderWriter.Mode.Write);
            csvReadWriter.Write("test line 1 Column 1");// The Read functionality forces to create the file with two columns which is quite rigid.
            csvReadWriter.Close();
            string column1 = null;
            string column2 = null;

            csvReadWriter.Open(@"test_data\test.txt", CSVReaderWriter.Mode.Read);

            Assert.Throws <IndexOutOfRangeException>(() => csvReadWriter.Read(out column1, out column2));
        }
示例#22
0
        public void Close_when_open_with_read_should_set_read_stream_to_null()
        {
            //arrange
            var sut = new CSVReaderWriter();


            //act
            sut.Open(TestInputFile, CSVReaderWriter.Mode.Read);
            sut.Close();


            //assert
            Assert.That(sut.ReadStreamValid, Is.False);
        }
示例#23
0
        public void Open_when_mode_is_read_and_file_is_valid_will_return_ReadStreamValid()
        {
            //arrange
            var sut = new CSVReaderWriter();

            //act
            sut.Open(TestInputFile, CSVReaderWriter.Mode.Read);

            //assert
            Assert.That(sut.ReadStreamValid, "Unable to open text file");

            //clean up
            sut.Close();
        }
        public void Read_WithOut_Split()
        {
            var    csvReader = new CSVReaderWriter();
            string string1   = null;
            string string2   = null;

            csvReader.Open(TestInputFileBlank, CSVReaderWriter.Mode.Read);

            var output = csvReader.Read(out string1, out string2);

            csvReader.Close();
            Assert.That(output, Is.True);
            Assert.That(string1, Is.EqualTo("Shelby Macias"));
            Assert.That(string2, Is.EqualTo("3027 Lorem St.|Kokomo|Hertfordshire|L9T 3D5|England"));
        }
        public void canReadFileKeepOutput()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            rw.Open(TestInputFile, Mode.Read);

            string col1 = "", col2 = "";
            bool   result = rw.Read(out col1, out col2);

            rw.Close();

            Assert.That(col1, Is.Not.Empty);
            Assert.That(col2, Is.Not.Empty);
            Assert.That(result, Is.True);
        }
示例#26
0
        public void Process(string inputFile)
        {
            var reader = new CSVReaderWriter();

            reader.Open(inputFile, CSVReaderWriter.Mode.Read);

            string column1, column2;

            while (reader.Read(out column1, out column2))
            {
                emailProvider.Send(column1, column2);
            }

            reader.Close();
        }
示例#27
0
        public void Read_Method_Should_read_first_line_of_file()
        {
            var csvReaderWriter = new CSVReaderWriter();

            csvReaderWriter.Open(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, TestInputFile), CSVReaderWriter.Mode.Read);

            string column1, column2;

            csvReaderWriter.Read(out column1, out column2);

            csvReaderWriter.Close();

            Assert.IsTrue(string.Equals(column1, "Shelby Macias"));
            Assert.IsTrue(string.Equals(column2, "3027 Lorem St.|Kokomo|Hertfordshire|L9T 3D5|England"));
        }
示例#28
0
        public void Process(string inputFile)
        {
            var reader = new CSVReaderWriter(new CSVReader(), new CSVWriter());

            reader.Open(inputFile, CSVReaderWriter.Mode.Read);

            string column1, column2;

            while (reader.Read(out column1, out column2))
            {
                _mailShot.SendMailShot(column1, column2);
            }

            reader.Close();
        }
示例#29
0
        public void Read_EdgeCase_Open_read_no_tabs_file()
        {
            //arrange
            var    sut     = new CSVReaderWriter();
            string column1 = "";
            string column2 = "";

            //act
            sut.Open(TestOtherFile, CSVReaderWriter.Mode.Read);
            sut.Read(out column1, out column2);
            sut.Close();

            //assert
            Assert.That(sut.ReadStreamValid, Is.False);
        }
        public void canNotReadFromFileIfInWriteMode()
        {
            CSVReaderWriter rw = new CSVReaderWriter();

            try
            {
                rw.Open(TestInputFileForEditing, Mode.Write);
                string col1 = "", col2 = "";
                bool   result = rw.Read(col1, col2);
            }
            finally
            {
                rw.Close();
            }
        }