Beispiel #1
0
        private void DoTransform(string sourceFile, string transformFile, string destFile)
        {
            if (!File.Exists(sourceFile))
            {
                Log.Warn(string.Format("No config file found in directory {0}, transformation ignored.",
                                       ProjectDirectory.FullName));
                return;
            }

            if (!File.Exists(transformFile))
            {
                Log.Info(
                    string.Format(
                        "No target config file found for target {0} in directory {1}, transformation ignored.", Target,
                        ProjectDirectory.FullName));
                return;
            }

            Log.Info(string.Format("Transforming file {0} and {1} ==> {2}", sourceFile, transformFile, destFile));
            var task = new TransformXml
            {
                Source      = sourceFile,
                Destination = destFile,
                Transform   = transformFile,
                BuildEngine = new FakeBuildEngine()
            };

            task.Execute();
        }
        public void Execute_Updates_WebConfig_Correctly(string envVariables, int expected)
        {
            string envTemplatePath = Path.GetTempFileName();
            string webConfigPath   = Path.GetTempFileName();
            string tempDir         = Path.GetDirectoryName(envTemplatePath);

            try
            {
                // Arrange
                List <XDocument> locationWebConfigTemplateList = new List <XDocument>()
                {
                    WebConfigTransformTemplates.WebConfigTemplate
                };
                foreach (var locationWebConfigTemplate in locationWebConfigTemplateList)
                {
                    _environmentTransformWithLocationTemplate.Save(envTemplatePath, SaveOptions.None);
                    XDocument webConfigTemplate = locationWebConfigTemplate;
                    webConfigTemplate.Save(webConfigPath);

                    GenerateEnvTransform env = new GenerateEnvTransform()
                    {
                        WebConfigEnvironmentVariables = envVariables,
                        EnvTransformTemplatePaths     = new List <string>()
                        {
                            envTemplatePath
                        }.ToArray(),
                                         PublishTempDirectory = tempDir
                    };


                    // Act
                    bool isSuccess = env.Execute();
                    Assert.True(isSuccess);
                    foreach (var generatedPath in env.GeneratedTransformFullPaths)
                    {
                        Assert.True(File.Exists(generatedPath));

                        TransformXml transformTask = new TransformXml()
                        {
                            Source            = webConfigPath,
                            Destination       = webConfigPath,
                            Transform         = generatedPath,
                            SourceRootPath    = Path.GetTempPath(),
                            TransformRootPath = Path.GetTempPath(),
                            StackTrace        = true
                        };

                        bool success = transformTask.RunXmlTransform(isLoggingEnabled: false);

                        // Assert
                        Assert.Equal(expected, XDocument.Parse(File.ReadAllText(webConfigPath)).Root.Descendants("environmentVariable").Count());
                    }
                }
            }
            finally
            {
                File.Delete(envTemplatePath);
                File.Delete(webConfigPath);
            }
        }
Beispiel #3
0
        public void TransformXml()
        {
            TransformXml t = new TransformXml();

            string sourcePath      = Path.Combine(Directory.GetCurrentDirectory(), "sample");
            string destinationPath = Path.Combine(Directory.GetCurrentDirectory(), "xmlencrypt");

            this.CopyDirectory(sourcePath, destinationPath);
            t.Execute(@"xmlencrypt\config\appSettings\sample.config.securetext", false);
            t.Execute(@"xmlencrypt\config\connectionStrings\sample.config.securetext", false);
            sourcePath      = Path.Combine(Directory.GetCurrentDirectory(), "xmlencrypt");
            destinationPath = Path.Combine(Directory.GetCurrentDirectory(), "xmldecrypt");
            this.CopyDirectory(sourcePath, destinationPath);
            t.Execute(@"xmldecrypt\config\appSettings\sample.config.securetext", true);
            t.Execute(@"xmldecrypt\config\connectionStrings\sample.config.securetext", true);

            FileInfo encrypt = new FileInfo(@"xmlencrypt\sample.config");
            FileInfo decrypt = new FileInfo(@"xmldecrypt\sample.config");

            Assert.IsTrue(encrypt.Length == decrypt.Length);
            encrypt = new FileInfo(@"xmlencrypt\config\appSettings\sample.config");
            decrypt = new FileInfo(@"xmldecrypt\config\appSettings\sample.config");
            Assert.IsTrue(encrypt.Length > decrypt.Length);
            encrypt = new FileInfo(@"xmlencrypt\config\connectionStrings\sample.config");
            decrypt = new FileInfo(@"xmldecrypt\config\connectionStrings\sample.config");
            Assert.IsTrue(encrypt.Length > decrypt.Length);
        }
Beispiel #4
0
        static void Main(string[] args)
        {
            Options options            = new Options();
            var     optionParseResults = CommandLine.Parser.Default.ParseArguments(args, options);

            if (!optionParseResults)
            {
                return;
            }

            var baseFileInfo      = new FileInfo(options.BaseConfig);
            var transformFileInfo = new FileInfo(options.TransformConfig);

            var myBasePath      = new FileInfo($".\\workspace\\{baseFileInfo.Name}");
            var myTransformPath = new FileInfo($".\\workspace\\{transformFileInfo.Name}");
            var myResultPath    = new FileInfo($".\\workspace\\{baseFileInfo.Name.Replace(baseFileInfo.Extension, "")}_Result{baseFileInfo.Extension}");


            CopyFile(baseFileInfo, myBasePath);
            CopyFile(transformFileInfo, myTransformPath);

            var diffCommand     = ConfigurationManager.AppSettings["diffCommand"];
            var diffCommandArgs = ConfigurationManager.AppSettings["diffCommand:Args"];
            var diffCommandWait = bool.Parse(ConfigurationManager.AppSettings["diffCommand:Wait"]);

            var transformer = new TransformXml
            {
                BuildEngine    = new TransformBuildEngine(),
                SourceRootPath = @"./workspace/",
                Source         = myBasePath.Name,
                Transform      = myTransformPath.Name,
                Destination    = myResultPath.FullName
            };

            var transformationSucceeded = transformer.Execute();

            if (transformationSucceeded)
            {
                var processInfo = new ProcessStartInfo(diffCommand);
                processInfo.Arguments = diffCommandArgs.Replace("${Source}", myBasePath.FullName)
                                        .Replace("${Result}", myResultPath.FullName);

                Console.WriteLine($"\"{processInfo.FileName}\" {processInfo.Arguments}");

                var process = Process.Start(processInfo);

                if (diffCommandWait)
                {
                    process?.WaitForExit();
                }
            }

            if (Debugger.IsAttached)
            {
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
Beispiel #5
0
        static void Main(string[] args)
        {
            var soapFile = @"C:\Temp\soap-req1.xml";
            var doc      = XDocument.Load(soapFile);

            var output = TransformXml.RemoveNameSpace(doc.ToString());

            StreamWriter sw = new StreamWriter(@"c:\temp\1.xml");

            sw.Write(output);
            sw.Close();

            Console.Read();
        }
Beispiel #6
0
        public void XmlTransform_AppliesRemoveAllTransform()
        {
            // Arrange
            string sourceFile    = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
            string transformFile = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
            string outputFile    = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());

            try
            {
                _webConfigTemplate.Save(sourceFile);
                _webConfigTransformRemoveAll.Save(transformFile);

                // Act
                TransformXml transformTask = new TransformXml()
                {
                    Source            = sourceFile,
                    Destination       = outputFile,
                    Transform         = transformFile,
                    SourceRootPath    = Path.GetTempPath(),
                    TransformRootPath = Path.GetTempPath(),
                    StackTrace        = true
                };

                bool success = transformTask.RunXmlTransform(isLoggingEnabled: false);


                // Assert
                Assert.True(success);
                Assert.True(XDocument.Parse(File.ReadAllText(sourceFile)).Descendants("handlers").Count() == 1);
                Assert.True(XDocument.Parse(File.ReadAllText(sourceFile)).Descendants("aspNetCore").Count() == 1);

                Assert.True(XDocument.Parse(File.ReadAllText(outputFile)).Descendants("handlers").Count() == 0);
                Assert.True(XDocument.Parse(File.ReadAllText(outputFile)).Descendants("aspNetCore").Count() == 0);
            }
            finally
            {
                File.Delete(sourceFile);
                File.Delete(transformFile);
                File.Delete(outputFile);
            }
        }
        static void Main(string[] args)
        {
            var optionSet = LoadCommandLineArguments(args);

            if(UserNeedsHelp())
            {
                WriteHelpToConsole(optionSet);
                return;
            }

            EnsureDestinationIsCreated(_destinationPathAndFilename);

            var task = new TransformXml
                           {
                               Source = new TaskItem(_sourcePathAndFilename),
                               Destination = new TaskItem(_destinationPathAndFilename),
                               Transform = new TaskItem(_transformPathAndFilename),
                               StackTrace = false,
                               BuildEngine = new CommandLineBuildEngine(),
                           };

            task.Execute();
        }
        private static bool ProcessTransform(TransformArgs args)
        {
            if (string.Equals(args.SourceFile, args.DestinationFile))
            {
                var tempFileName = Path.GetTempFileName();
                File.Delete(tempFileName);
                File.Copy(args.SourceFile, tempFileName);
                args.SourceFile = tempFileName;
            }

            var engine = new TransformOnlyBuildEngine();

            var transformer = new TransformXml
            {
                BuildEngine = engine,
                Source = args.SourceFile,
                Destination = args.DestinationFile,
                Transform = args.TransformFile
            };

            return transformer.Execute();
        }