public void Parsing_GenerationReport_Success()
        {
            // Arrange
            var    facade  = new FileParserFacade();
            var    factory = new ParserFactory();
            string referenceDatafullFileName    = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDataFile", "ReferenceData.xml");
            string generationOutputfullFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDataFile", "GenerationReport.xml");

            // Act
            // Initializes reference data first
            var type   = facade.GetExtention(referenceDatafullFileName);
            var parser = factory.GetObject(type.ToString());

            parser.IsReferenceData = true;
            parser.FileName        = referenceDatafullFileName;
            parser.Read();

            // read generation data
            parser.IsReferenceData = false;
            parser.FileName        = generationOutputfullFileName;
            parser.Read();

            // Assert
            Assert.IsInstanceOfType(Constants.ReferenceData.ValueFactor, typeof(BaseFactor));
            Assert.IsNotNull(Constants.ReferenceData);
            Assert.AreEqual(Constants.ReferenceData.ValueFactor.High, 0.946);
            Assert.AreEqual(Constants.ReferenceData.EmissionsFactor.Low, 0.312);

            Assert.IsInstanceOfType(parser.Generators.FirstOrDefault(), typeof(BaseGenerator));
            Assert.IsNotNull(parser.Generators);
            Assert.AreEqual(parser.Generators.Count, 4);
            Assert.AreEqual(parser.Generators.Where(s => s.GeneratorType == Constants.GeneratorType.OnshoreWind).ToList().Count, 1);
            Assert.IsNotNull(parser.Generators.Where(s => s.Name == "Wind[Onshore]").FirstOrDefault());

            var windOnshoreTotalEmission = parser.Generators.Where(s => s.Name == "Wind[Onshore]").FirstOrDefault().TotalGeneratorGenerationByName.Value;

            Assert.AreEqual(windOnshoreTotalEmission, 4869.4539173939993);

            var maxEmission = (from dailyEmission in parser.Generators.Where(s => s.IsFossilFuel).SelectMany(s => ((FossilFuelGenerator)s).GeneratorDailyEmissions)
                               group dailyEmission by dailyEmission.Date into dateWiseGroup
                               select new DailyEmission
            {
                Date = dateWiseGroup.Key,
                DailyEmissionValue = dateWiseGroup.Max(s => s.DailyEmissionValue),
                GenerationTypeName = dateWiseGroup.Where(s => s.DailyEmissionValue == dateWiseGroup.Max(p => p.DailyEmissionValue)).First().GenerationTypeName,
                GeneratorType = dateWiseGroup.Where(s => s.DailyEmissionValue == dateWiseGroup.Max(p => p.DailyEmissionValue)).First().GeneratorType
            }).OrderByDescending(s => s.DailyEmissionValue).FirstOrDefault().DailyEmissionValue;

            Assert.AreEqual(maxEmission, 137.175004008);

            var firstCoalHeatRate = parser.Generators.Where(s => s.GeneratorType == GeneratorType.Coal).Select(s => ((CoalGenerator)s).ActualHeatRate).FirstOrDefault();

            Assert.AreEqual(firstCoalHeatRate.HeatRate, 12.849293200);
        }
        public void GetRecordListTest_Success_ValidData()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\ExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);

            // Act
            IList <Record> faultyRecords = _fileParserFacade.GetRecordList().Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();

            // Assert
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(0, faultyRecords.Count);
        }
Пример #3
0
        public void XmlParserFactory_Should_Be_User_For_Xml_File_Parsing()
        {
            //Arrange
            var facade  = new FileParserFacade();
            var factory = new ParserFactory();

            //Act
            var type   = facade.GetExtention("a.xml");
            var parser = factory.GetObject(type.ToString());

            // Assert
            Assert.IsNotNull(type);
            Assert.IsNotNull(parser);
            Assert.IsInstanceOfType(type, typeof(ParserType));
            Assert.IsInstanceOfType(parser, typeof(EnergyXmlParser));
            Assert.AreEqual(type, ParserType.Xml);
        }
        public void GetRecordListTest_Success_SortByStartDate()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\ExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);
            string expectedStartDate = "2009-06-01 00:00:00.000";

            // Act
            IList <Record> records   = _fileParserFacade.GetRecordList().OrderBy(s => s.StartDate).ToList();
            string         startDate = DateTime.Parse(records.FirstOrDefault()?.StartDate.ToString() ?? string.Empty).ToString(Constants.FileDateTimeFormat);

            // Assert
            Assert.IsNotNull(records);
            Assert.AreEqual(expectedStartDate, startDate);
        }
        public void GetRecordListByProjectTest_Success_ValidData()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\ExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);
            int project             = 5;
            int expectedRecordCount = 1;

            // Act
            IList <Record> records = _fileParserFacade.GetRecordListByProject(project).ToList();

            // Assert
            Assert.IsNotNull(records);
            Assert.AreEqual(expectedRecordCount, records.Count);
        }
        public void GetRecordListTest_Error_InvalidLines()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\InvalidLinesExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);

            // Act
            IList <Record> faultyRecords = _fileParserFacade.GetRecordList().Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();
            string         errorMessage  = faultyRecords.Select(s => s.Error).FirstOrDefault();
            bool           isContainExpectedErrorMessage = errorMessage.Contains("The conversion cannot be performed.\r\n    Text: 'hkdhgkhgs'");

            // Assert
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(1, faultyRecords.Count);
            Assert.AreEqual(isContainExpectedErrorMessage, true);
        }
        public void GetRecordListTest_Error_InvalidComplexity()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\InvalidComplexityExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);

            // Act
            IList <Record> faultyRecords = _fileParserFacade.GetRecordList().Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();
            string         errorMessage  = faultyRecords.Select(s => s.Error).FirstOrDefault();
            bool           isContainExpectedErrorMessage = errorMessage.Contains("Complexity value: 'VeryHigh' is different than the allowed values");

            // Assert
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(1, faultyRecords.Count);
            Assert.AreEqual(isContainExpectedErrorMessage, true);
        }
        public void Parsing_BadFormatFile_Resultant_ParseValue_Null()
        {
            // Arrange
            var    facade       = new FileParserFacade();
            var    factory      = new ParserFactory();
            string fullFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDataFile", "BadFomratGenerationOutput.xml");

            // Act
            var type   = facade.GetExtention(fullFileName);
            var parser = factory.GetObject(type.ToString());

            parser.IsReferenceData = true;
            parser.FileName        = fullFileName;
            parser.Read();

            // Assert
            Assert.IsNull(Constants.ReferenceData.ValueFactor);
            Assert.IsNull(Constants.ReferenceData.EmissionsFactor);
        }
        public void GetRecordListTest_Success_ColumnsOrderChanged()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\ColumnsOrderChangeExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);
            int expectedProject = 2;

            // Act
            IList <Record> records       = _fileParserFacade.GetRecordList().ToList();
            IList <Record> faultyRecords = records.Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();
            Record         record        = records.FirstOrDefault();

            // Assert
            Assert.AreEqual(2, records.Count);
            Assert.AreEqual(expectedProject, record?.Project);
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(0, faultyRecords.Count);
        }
        public void Parsing_ReferenceData_Success()
        {
            // Arrange
            var    facade       = new FileParserFacade();
            var    factory      = new ParserFactory();
            string fullFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDataFile", "ReferenceData.xml");

            // Act
            var type   = facade.GetExtention(fullFileName);
            var parser = factory.GetObject(type.ToString());

            parser.IsReferenceData = true;
            parser.FileName        = fullFileName;
            parser.Read();

            // Assert
            Assert.IsInstanceOfType(Constants.ReferenceData.ValueFactor, typeof(Domain.Entities.ReferenceDataEntities.BaseFactor));
            Assert.IsNotNull(Constants.ReferenceData);
            Assert.AreEqual(Constants.ReferenceData.ValueFactor.High, 0.946);
            Assert.AreEqual(Constants.ReferenceData.EmissionsFactor.Low, 0.312);
        }
        public void GetRecordListByProjectWithSort_IntegrationTest_Error_MixedValidInValidRecords()
        {
            // Arrange
            int project = 6;

            string           fileFullPath     = Path.Join(_applicationBase, @"TestData\MixedExampleData.tsv");
            FileParserClient fileParserClient = new FileParserClient();
            IFileParser      iFileParser      = fileParserClient.GetFileParserFromFileExtension(fileFullPath);
            FileParserFacade fileParserFacade = new FileParserFacade(iFileParser);

            // Act
            List <Record> records = fileParserFacade.GetRecordListByProject(project).OrderBy(s => s.StartDate).ToList();

            List <Record> faultyRecords = records.Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();

            // Assert
            Assert.IsNotNull(records);
            Assert.AreEqual(3, records.Count);
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(1, faultyRecords.Count);
        }
        public void GetRecordListTest_Error_InvalidDateFormat()
        {
            // Arrange
            string fileFullPath = Path.Join(_applicationBase, @"TestData\InvalidDateExampleData.tsv");

            _iFileParser      = new TsvFileParser(fileFullPath);
            _fileParserFacade = new FileParserFacade(_iFileParser);

            // Act
            IList <Record> faultyRecords = _fileParserFacade.GetRecordList().Where(s => !string.IsNullOrWhiteSpace(s.Error)).ToList();
            string         errorMessage1 = faultyRecords.Select(s => s.Error).FirstOrDefault();
            string         errorMessage2 = faultyRecords.Select(s => s.Error).LastOrDefault();
            bool           isContainExpectedErrorMessage1 = errorMessage1.Contains("The string '2014hghdkdk-01-01 00:00:00.000' was not recognized as a valid DateTime. There is an unknown word starting at index '4'.");
            bool           isContainExpectedErrorMessage2 = errorMessage2.Contains("Start date value: '2013/01/01 00:00:00.000' is different than the allowed format i.e. yyyy-MM-dd HH:mm:ss.fff");

            // Assert
            Assert.IsNotNull(faultyRecords);
            Assert.AreEqual(2, faultyRecords.Count);
            Assert.AreEqual(isContainExpectedErrorMessage1, true);
            Assert.AreEqual(isContainExpectedErrorMessage2, true);
        }