public void GivenCalculationConfigurationReader_WhenReadingOutdatedVersion_ThenCalculationConfigurationCorrectlyMigratedMultipleVersions()
        {
            // Given
            string filePath = Path.Combine(testDirectoryPath, "validConfiguration_1.xml");
            string versionOneSchemaDefinition   = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationSchema_1.xsd"));
            string versionTwoSchemaDefinition   = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationSchema_2.xsd"));
            string versionThreeSchemaDefinition = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationSchema_3.xsd"));
            string migrationZeroOneDefinition   = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationMigration0To1.xslt"));
            string migrationOneTwoDefinition    = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationMigration1To2.xslt"));
            string migrationTwoThreeDefinition  = File.ReadAllText(Path.Combine(testDirectoryPath, "validConfigurationMigration2To3.xslt"));

            var calculationConfigurationReader = new CalculationConfigurationReader(filePath, new[]
            {
                new CalculationConfigurationSchemaDefinition(0, validMainSchemaDefinition, new Dictionary <string, string>(), string.Empty),
                new CalculationConfigurationSchemaDefinition(1, versionOneSchemaDefinition, new Dictionary <string, string>(), migrationZeroOneDefinition),
                new CalculationConfigurationSchemaDefinition(2, versionTwoSchemaDefinition, new Dictionary <string, string>(), migrationOneTwoDefinition),
                new CalculationConfigurationSchemaDefinition(3, versionThreeSchemaDefinition, new Dictionary <string, string>(), migrationTwoThreeDefinition)
            });

            // When
            IConfigurationItem[] readConfigurationItems = calculationConfigurationReader.Read().ToArray();

            // Then
            Assert.IsTrue(readConfigurationItems.OfType <ReadCalculation>()
                          .Select(calc => calc.VersionSpecificProperty)
                          .All(s => s == "test3"));
        }
        public void Read_ValidConfigurationWithEmptyFolder_ReturnExpectedReadCalculationGroup()
        {
            // Setup
            string filePath = Path.Combine(testDirectoryPath, "validConfigurationEmptyFolder.xml");
            var    calculationConfigurationReader = new CalculationConfigurationReader(filePath, new[]
            {
                new CalculationConfigurationSchemaDefinition(0, validMainSchemaDefinition, new Dictionary <string, string>(), string.Empty)
            });

            // Call
            IEnumerable <IConfigurationItem> readConfigurationItems = calculationConfigurationReader.Read().ToArray();

            // Assert
            var group = (CalculationGroupConfiguration)readConfigurationItems.Single();

            Assert.IsNotNull(group);
            Assert.AreEqual("Calculation group", group.Name);
            CollectionAssert.IsEmpty(group.Items);
        }
        public void Read_ValidConfigurationWithNesting_ReturnExpectedReadConfigurationItems()
        {
            // Setup
            string filePath = Path.Combine(testDirectoryPath, "validConfiguration.xml");
            var    calculationConfigurationReader = new CalculationConfigurationReader(filePath, new[]
            {
                new CalculationConfigurationSchemaDefinition(0, validMainSchemaDefinition, new Dictionary <string, string>(), string.Empty)
            });

            // Call
            IConfigurationItem[] readConfigurationItems = calculationConfigurationReader.Read().ToArray();

            // Assert
            Assert.AreEqual(5, readConfigurationItems.Length);

            var group1 = readConfigurationItems[0] as CalculationGroupConfiguration;

            Assert.IsNotNull(group1);
            Assert.AreEqual("Group 1", group1.Name);

            var calculation1 = readConfigurationItems[1] as ReadCalculation;

            Assert.IsNotNull(calculation1);
            Assert.AreEqual("Calculation 1", calculation1.Name);

            var group2 = readConfigurationItems[2] as CalculationGroupConfiguration;

            Assert.IsNotNull(group2);
            Assert.AreEqual("Group 2", group2.Name);

            var calculation2 = readConfigurationItems[3] as ReadCalculation;

            Assert.IsNotNull(calculation2);
            Assert.AreEqual("Calculation 2", calculation2.Name);

            var group3 = readConfigurationItems[4] as CalculationGroupConfiguration;

            Assert.IsNotNull(group3);
            Assert.AreEqual("Group 3", group3.Name);

            List <IConfigurationItem> group1Items = group1.Items.ToList();

            Assert.AreEqual(1, group1Items.Count);

            var calculation3 = group1Items[0] as ReadCalculation;

            Assert.IsNotNull(calculation3);
            Assert.AreEqual("Calculation 3", calculation3.Name);

            List <IConfigurationItem> group2Items = group2.Items.ToList();

            Assert.AreEqual(2, group2Items.Count);

            var group4 = group2Items[0] as CalculationGroupConfiguration;

            Assert.IsNotNull(group4);
            Assert.AreEqual("Group 4", group4.Name);

            var calculation4 = group2Items[1] as ReadCalculation;

            Assert.IsNotNull(calculation4);
            Assert.AreEqual("Calculation 4", calculation4.Name);

            List <IConfigurationItem> group3Items = group3.Items.ToList();

            Assert.AreEqual(0, group3Items.Count);

            List <IConfigurationItem> group4Items = group4.Items.ToList();

            Assert.AreEqual(1, group4Items.Count);

            var calculation5 = group4Items[0] as ReadCalculation;

            Assert.IsNotNull(calculation5);
            Assert.AreEqual("Calculation 5", calculation5.Name);
        }