コード例 #1
0
        public void Rename_Construct_Object_Must_Be_OfType_IDestinationUsernamePassword()
        {
            var pathRename = new DsfPathRename();
            IDestinationUsernamePassword password = pathRename;

            Assert.IsNotNull(password);
        }
コード例 #2
0
ファイル: RenameSteps.cs プロジェクト: Warewolf-ESB/Warewolf
        public void WhenValidatingTheRenameTool()
        {
            scenarioContext.TryGetValue(CommonSteps.SourcePrivatePublicKeyFile, out string privateKeyFile);
            scenarioContext.TryGetValue(CommonSteps.DestinationPrivateKeyFile, out string destPrivateKeyFile);

            var dsfRename = new DsfPathRename
            {
                InputPath           = scenarioContext.Get <string>(CommonSteps.SourceHolder),
                Username            = scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder),
                Password            = scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
                OutputPath          = scenarioContext.Get <string>(CommonSteps.DestinationHolder),
                DestinationUsername = scenarioContext.Get <string>(CommonSteps.DestinationUsernameHolder),
                DestinationPassword = scenarioContext.Get <string>(CommonSteps.DestinationPasswordHolder),
                Overwrite           = scenarioContext.Get <bool>(CommonSteps.OverwriteHolder),
                Result                    = scenarioContext.Get <string>(CommonSteps.ResultVariableHolder),
                PrivateKeyFile            = privateKeyFile,
                DestinationPrivateKeyFile = destPrivateKeyFile
            };

            if (!scenarioContext.ContainsKey("activity"))
            {
                scenarioContext.Add("activity", dsfRename);
            }

            dsfRename.PerformValidation();

            var viewModel = new RenameDesignerViewModel(ModelItemUtils.CreateModelItem(dsfRename));

            if (!scenarioContext.ContainsKey("viewModel"))
            {
                scenarioContext.Add("viewModel", viewModel);
            }
        }
コード例 #3
0
ファイル: RenameSteps.cs プロジェクト: Warewolf-ESB/Warewolf
        protected override void BuildDataList()
        {
            BuildShapeAndTestData();
            scenarioContext.TryGetValue(CommonSteps.SourcePrivatePublicKeyFile, out string privateKeyFile);
            scenarioContext.TryGetValue(CommonSteps.DestinationPrivateKeyFile, out string destPrivateKeyFile);
            var rename = new DsfPathRename
            {
                InputPath           = scenarioContext.Get <string>(CommonSteps.SourceHolder),
                Username            = scenarioContext.Get <string>(CommonSteps.SourceUsernameHolder),
                Password            = scenarioContext.Get <string>(CommonSteps.SourcePasswordHolder),
                OutputPath          = scenarioContext.Get <string>(CommonSteps.DestinationHolder),
                DestinationUsername = scenarioContext.Get <string>(CommonSteps.DestinationUsernameHolder),
                DestinationPassword = scenarioContext.Get <string>(CommonSteps.DestinationPasswordHolder),
                Overwrite           = scenarioContext.Get <bool>(CommonSteps.OverwriteHolder),
                Result                    = scenarioContext.Get <string>(CommonSteps.ResultVariableHolder),
                PrivateKeyFile            = privateKeyFile,
                DestinationPrivateKeyFile = destPrivateKeyFile
            };

            TestStartNode = new FlowStep
            {
                Action = rename
            };
            if (!scenarioContext.ContainsKey("activity"))
            {
                scenarioContext.Add("activity", rename);
            }
        }
コード例 #4
0
        public void PathRenameActivity_GetOutputs_Expected_One_Output()
        {
            DsfPathRename testAct = new DsfPathRename();

            IBinaryDataList outputs = testAct.GetOutputs();

            var res = outputs.FetchAllEntries().Count;

            // remove test datalist ;)

            Assert.AreEqual(1, res);
        }
コード例 #5
0
        public void PathRenameActivity_GetInputs_Expected_Six_Input()

        {
            DsfPathRename testAct = new DsfPathRename();

            IBinaryDataList inputs = testAct.GetInputs();

            var res = inputs.FetchAllEntries().Count;

            // remove test datalist ;)
            DataListRemoval(inputs.UID);

            Assert.AreEqual(8, res);
        }
コード例 #6
0
        public void DsfPathRename_UpdateForEachOutputs_NullUpdates_DoesNothing()
        {
            //------------Setup for test--------------------------
            var          newGuid = Guid.NewGuid();
            const string result  = "[[CompanyName]]";
            var          act     = new DsfPathRename
            {
                InputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"),
                OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"),
                Result     = result
            };

            act.UpdateForEachOutputs(null);
            //------------Assert Results-------------------------
            Assert.AreEqual(result, act.Result);
        }
コード例 #7
0
        public void DsfPathRename_UpdateForEachInputs_NullUpdates_DoesNothing()
        {
            //------------Setup for test--------------------------
            var newGuid    = Guid.NewGuid();
            var inputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
            var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
            var act        = new DsfPathRename {
                InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
            };

            //------------Execute Test---------------------------
            act.UpdateForEachInputs(null);
            //------------Assert Results-------------------------
            Assert.AreEqual(inputPath, act.InputPath);
            Assert.AreEqual(outputPath, act.OutputPath);
        }
コード例 #8
0
        public void Rename_Execute_Workflow_SourceFile_And_DestinationFile_Has_Separate_Passwords_Both_Passwords_Are_Sent_To_OperationBroker()
        {
            var fileNames = new List <string>
            {
                Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid() + ".txt"),
                Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid() + ".txt")
            };

            foreach (string fileName in fileNames)
            {
                File.WriteAllText(fileName, @"TestData");
            }

            string dataListWithData;
            string dataListShape;

            CreateDataListWithRecsetAndCreateShape(fileNames, "FileNames", "Name", out dataListShape,
                                                   out dataListWithData);

            var activityOperationBrokerMock = new ActivityOperationBrokerMock();

            var act = new DsfPathRename
            {
                InputPath           = @"c:\OldFile.txt",
                OutputPath          = Path.Combine(TestContext.TestRunDirectory, "NewName.txt"),
                Result              = "[[res]]",
                DestinationUsername = "******",
                DestinationPassword = "******",
                Username            = "******",
                Password            = "******",
                GetOperationBroker  = () => activityOperationBrokerMock
            };

            List <DebugItem> inRes;
            List <DebugItem> outRes;

            CheckPathOperationActivityDebugInputOutput(act, dataListShape,
                                                       dataListWithData, out inRes, out outRes);

            Assert.AreEqual(activityOperationBrokerMock.Destination.IOPath.Password, "destPWord");
            Assert.AreEqual(activityOperationBrokerMock.Destination.IOPath.Username, "destUName");
            Assert.AreEqual(activityOperationBrokerMock.Source.IOPath.Password, "pWord");
            Assert.AreEqual(activityOperationBrokerMock.Source.IOPath.Username, "uName");
        }
コード例 #9
0
        public void DsfPathRename_UpdateForEachOutputs_1Updates_UpdateResult()
        {
            //------------Setup for test--------------------------
            var newGuid    = Guid.NewGuid();
            var inputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
            var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
            var act        = new DsfPathRename {
                InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
            };

            var tuple1 = new Tuple <string, string>("[[CompanyName]]", "Test");

            //------------Execute Test---------------------------
            act.UpdateForEachOutputs(new List <Tuple <string, string> > {
                tuple1
            });
            //------------Assert Results-------------------------
            Assert.AreEqual("Test", act.Result);
        }
コード例 #10
0
        public void DsfPathRename_GetForEachOutputs_WhenHasResult_ReturnsOutputList()
        {
            //------------Setup for test--------------------------
            var          newGuid = Guid.NewGuid();
            const string result  = "[[CompanyName]]";
            var          act     = new DsfPathRename
            {
                InputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"),
                OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"),
                Result     = result
            };

            //------------Execute Test---------------------------
            var dsfForEachItems = act.GetForEachOutputs();

            //------------Assert Results-------------------------
            Assert.AreEqual(1, dsfForEachItems.Count);
            Assert.AreEqual(result, dsfForEachItems[0].Name);
            Assert.AreEqual(result, dsfForEachItems[0].Value);
        }
コード例 #11
0
        public void DsfPathRename_GetForEachInputs_WhenHasExpression_ReturnsInputList()
        {
            //------------Setup for test--------------------------
            var newGuid    = Guid.NewGuid();
            var inputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt");
            var outputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt");
            var act        = new DsfPathRename {
                InputPath = inputPath, OutputPath = outputPath, Result = "[[CompanyName]]"
            };

            //------------Execute Test---------------------------
            var dsfForEachItems = act.GetForEachInputs();

            //------------Assert Results-------------------------
            Assert.AreEqual(2, dsfForEachItems.Count);
            Assert.AreEqual(inputPath, dsfForEachItems[0].Name);
            Assert.AreEqual(inputPath, dsfForEachItems[0].Value);
            Assert.AreEqual(outputPath, dsfForEachItems[1].Name);
            Assert.AreEqual(outputPath, dsfForEachItems[1].Value);
        }
コード例 #12
0
        public void GetActivityFieldsOffDsfPathRenameActivityExpectedAllFindMissingFieldsToBeReturned()
        {
            DsfPathRename activity = new DsfPathRename();

            activity.InputPath           = "[[InputPath]]";
            activity.OutputPath          = "[[OutputPath]]";
            activity.Password            = "******";
            activity.Username            = "******";
            activity.DestinationPassword = "******";
            activity.DestinationUsername = "******";
            activity.Result = "[[Result]]";
            Dev2FindMissingStrategyFactory fac      = new Dev2FindMissingStrategyFactory();
            IFindMissingStrategy           strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
            List <string> actual   = strategy.GetActivityFields(activity);
            List <string> expected = new List <string> {
                "[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[Result]]"
            };

            CollectionAssert.AreEqual(expected, actual);
        }
コード例 #13
0
        public void DsfPathRename_UpdateForEachOutputs_MoreThan1Updates_DoesNothing()
        {
            //------------Setup for test--------------------------
            var          newGuid = Guid.NewGuid();
            const string result  = "[[CompanyName]]";
            var          act     = new DsfPathRename
            {
                InputPath  = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]].txt"),
                OutputPath = string.Concat(TestContext.TestRunDirectory, "\\", newGuid + "[[CompanyName]]2.txt"),
                Result     = result
            };

            var tuple1 = new Tuple <string, string>("Test", "Test");
            var tuple2 = new Tuple <string, string>("Test2", "Test2");

            //------------Execute Test---------------------------
            act.UpdateForEachOutputs(new List <Tuple <string, string> > {
                tuple1, tuple2
            });
            //------------Assert Results-------------------------
            Assert.AreEqual(result, act.Result);
        }
コード例 #14
0
        protected override void BuildDataList()
        {
            BuildShapeAndTestData();

            var rename = new DsfPathRename
            {
                InputPath           = ScenarioContext.Current.Get <string>(CommonSteps.SourceHolder),
                Username            = ScenarioContext.Current.Get <string>(CommonSteps.SourceUsernameHolder),
                Password            = ScenarioContext.Current.Get <string>(CommonSteps.SourcePasswordHolder),
                OutputPath          = ScenarioContext.Current.Get <string>(CommonSteps.DestinationHolder),
                DestinationUsername = ScenarioContext.Current.Get <string>(CommonSteps.DestinationUsernameHolder),
                DestinationPassword = ScenarioContext.Current.Get <string>(CommonSteps.DestinationPasswordHolder),
                Overwrite           = ScenarioContext.Current.Get <bool>(CommonSteps.OverwriteHolder),
                Result = ScenarioContext.Current.Get <string>(CommonSteps.ResultVariableHolder)
            };

            TestStartNode = new FlowStep
            {
                Action = rename
            };
            ScenarioContext.Current.Add("activity", rename);
        }
コード例 #15
0
        public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfPathRename_Activity_ExpectAllFindMissingFieldsToBeReturned()
        {
            var activity = new DsfPathRename
            {
                InputPath                 = "[[InputPath]]",
                OutputPath                = "[[OutputPath]]",
                Password                  = "******",
                Username                  = "******",
                PrivateKeyFile            = "[[KeyFile]]",
                DestinationPassword       = "******",
                DestinationUsername       = "******",
                DestinationPrivateKeyFile = "[[DestKeyFile]]",
                Result = "[[Result]]"
            };
            var fac      = new Dev2FindMissingStrategyFactory();
            var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
            var actual   = strategy.GetActivityFields(activity);
            var expected = new List <string> {
                "[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
            };

            CollectionAssert.AreEqual(expected, actual);
        }
コード例 #16
0
        public void DsfPathRename_GetState()
        {
            var fileNames = new List <string>
            {
                Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid() + ".txt"),
                Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid() + ".txt")
            };

            foreach (string fileName in fileNames)
            {
                File.WriteAllText(fileName, @"TestData");
            }

            CreateDataListWithRecsetAndCreateShape(fileNames, "FileNames", "Name", out string dataListShape,
                                                   out string dataListWithData);

            var activityOperationBrokerMock = new ActivityOperationBrokerMock();
            var inputPath                 = @"c:\OldFile.txt";
            var outputPath                = Path.Combine(TestContext.TestRunDirectory, "NewName.txt");
            var result                    = "[[res]]";
            var destinationUsername       = "******";
            var destinationPassword       = "******";
            var username                  = "******";
            var password                  = "******";
            var overwrite                 = false;
            var privateKeyFile            = "[[KeyFile]]";
            var destinationPrivateKeyFile = "[[DestKeyFile]]";
            var act = new DsfPathRename
            {
                InputPath                 = inputPath,
                OutputPath                = outputPath,
                Result                    = result,
                Overwrite                 = overwrite,
                DestinationUsername       = destinationUsername,
                DestinationPassword       = destinationPassword,
                Username                  = username,
                Password                  = password,
                PrivateKeyFile            = privateKeyFile,
                DestinationPrivateKeyFile = destinationPrivateKeyFile,
                GetOperationBroker        = () => activityOperationBrokerMock
            };

            CheckPathOperationActivityDebugInputOutput(act, dataListShape,
                                                       dataListWithData, out List <DebugItem> inRes, out List <DebugItem> outRes);

            //------------Execute Test---------------------------
            var stateItems = act.GetState();

            Assert.AreEqual(8, stateItems.Count());

            var expectedResults = new[]
            {
                new StateVariable
                {
                    Name  = "InputPath",
                    Type  = StateVariable.StateType.Input,
                    Value = inputPath
                },
                new StateVariable
                {
                    Name  = "OutputPath",
                    Type  = StateVariable.StateType.Output,
                    Value = outputPath
                },
                new StateVariable
                {
                    Name  = "DestinationUsername",
                    Type  = StateVariable.StateType.Input,
                    Value = destinationUsername
                },
                new StateVariable
                {
                    Name  = "Username",
                    Type  = StateVariable.StateType.Input,
                    Value = username
                },
                new StateVariable
                {
                    Name  = "Overwrite",
                    Type  = StateVariable.StateType.Input,
                    Value = overwrite.ToString()
                },
                new StateVariable
                {
                    Name  = "PrivateKeyFile",
                    Type  = StateVariable.StateType.Input,
                    Value = privateKeyFile
                },
                new StateVariable
                {
                    Name  = "DestinationPrivateKeyFile",
                    Type  = StateVariable.StateType.Input,
                    Value = destinationPrivateKeyFile
                },
                new StateVariable
                {
                    Name  = "Result",
                    Type  = StateVariable.StateType.Output,
                    Value = result
                }
            };

            var iter = act.GetState().Select(
                (item, index) => new
            {
                value       = item,
                expectValue = expectedResults[index]
            }
                );

            //------------Assert Results-------------------------
            foreach (var entry in iter)
            {
                Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
                Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
                Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
            }
        }