NuDeploy.CommandLine.Commands.Console.PublishingTargetConfigurationCommand.Execute C# (CSharp) Method

        public bool Execute()
        {
            // identify the action (required parameter)
            string suppliedActionName = this.Arguments.ContainsKey(ArgumentNameAction) ? this.Arguments[ArgumentNameAction] : string.Empty;
            var action = this.publishingTargetConfigurationCommandActionParser.ParseAction(suppliedActionName);

            switch (action)
            {
                case PublishingTargetConfigurationCommandAction.Add:
                {
                    if (!this.Arguments.ContainsKey(ArgumentNamePublishConfigurationName) || !this.Arguments.ContainsKey(ArgumentNamePublishLocation))
                    {
                        // abort
                        this.userInterface.WriteLine(
                            string.Format(string.Format(Resources.PublishingTargetConfigurationCommand.AddCommandInvalidArgumentCountMessageTemplate, PublishingTargetConfigurationCommandAction.Add, 2)));

                        return false;
                    }

                    string publishConfigurationName = this.Arguments[ArgumentNamePublishConfigurationName];
                    string publishLocation = this.Arguments[ArgumentNamePublishLocation];
                    string apiKey = this.Arguments.ContainsKey(ArgumentNameApiKey) ? this.Arguments[ArgumentNameApiKey] : null;

                    IServiceResult addResult = this.publishConfigurationAccessor.AddOrUpdatePublishConfiguration(
                        publishConfigurationName, publishLocation, apiKey);

                    if (addResult.Status == ServiceResultType.Failure)
                    {
                        // failure
                        this.userInterface.Display(addResult);

                        this.userInterface.WriteLine(
                            string.Format(
                                Resources.PublishingTargetConfigurationCommand.SavePublishingConfigurationFailedMessageTemplate,
                                publishConfigurationName,
                                publishLocation));

                        return false;
                    }

                    // success
                    this.userInterface.WriteLine(
                        string.Format(
                            Resources.PublishingTargetConfigurationCommand.SavePublishingConfigurationSucceededMessageTemplate,
                            publishConfigurationName,
                            publishLocation));

                    return true;
                }

                case PublishingTargetConfigurationCommandAction.Delete:
                {
                    if (!this.Arguments.ContainsKey(ArgumentNamePublishConfigurationName))
                    {
                        // abort
                        this.userInterface.WriteLine(
                            string.Format(Resources.PublishingTargetConfigurationCommand.DeletePublishingConfigurationNoNameSuppliedMessage));

                        return false;
                    }

                    string publishConfigurationName = this.Arguments[ArgumentNamePublishConfigurationName] ?? this.Arguments.Values.Skip(1).Take(1).FirstOrDefault();

                    IServiceResult deleteResult = this.publishConfigurationAccessor.DeletePublishConfiguration(publishConfigurationName);
                    if (deleteResult.Status == ServiceResultType.Failure)
                    {
                        // failure
                        this.userInterface.Display(deleteResult);

                        this.userInterface.WriteLine(
                            string.Format(
                                Resources.PublishingTargetConfigurationCommand.DeletePublishingConfigurationFailedMessageTemplate, publishConfigurationName));

                        return false;
                    }

                    // success
                    this.userInterface.WriteLine(
                        string.Format(
                            Resources.PublishingTargetConfigurationCommand.DeletePublishingConfigurationSucceededMessageTemplate, publishConfigurationName));

                    return true;
                }

                case PublishingTargetConfigurationCommandAction.List:
                {
                    var publishConfigurations = this.publishConfigurationAccessor.GetPublishConfigurations().ToList();
                    if (publishConfigurations.Count == 0)
                    {
                        this.userInterface.WriteLine(Resources.PublishingTargetConfigurationCommand.ListPublishingConfigurationsNoConfigsAvailableMessage);
                        return true;
                    }

                    var dataToDisplay = new Dictionary<string, string>
                    {
                        { Resources.PublishingTargetConfigurationCommand.PublishingConfigurationTableHeadlineColumn1, Resources.PublishingTargetConfigurationCommand.PublishingConfigurationTableHeadlineColumn2 },
                        { new string('-', Resources.PublishingTargetConfigurationCommand.PublishingConfigurationTableHeadlineColumn1.Length + 3), new string('-', Resources.PublishingTargetConfigurationCommand.PublishingConfigurationTableHeadlineColumn2.Length + 3) },
                        { string.Empty, string.Empty },
                    };

                    foreach (var publishConfiguration in publishConfigurations)
                    {
                        dataToDisplay.Add(publishConfiguration.Name, publishConfiguration.PublishLocation);
                    }

                    this.userInterface.ShowKeyValueStore(dataToDisplay, 4);
                    return true;
                }

                case PublishingTargetConfigurationCommandAction.Reset:
                {
                    IServiceResult resetResult = this.publishConfigurationAccessor.ResetPublishConfiguration();
                    if (resetResult.Status == ServiceResultType.Failure)
                    {
                        // failure
                        this.userInterface.Display(resetResult);
                        this.userInterface.WriteLine(Resources.PublishingTargetConfigurationCommand.ResetPublishingConfigurationFailedMessage);
                        return false;
                    }

                    this.userInterface.WriteLine(Resources.PublishingTargetConfigurationCommand.ResetPublishingConfigurationSuccessMessage);
                    return true;
                }
            }

            this.userInterface.WriteLine(
                string.Format(Resources.PublishingTargetConfigurationCommand.InvalidActionNameMessageTemplate, string.Join(", ", this.AllowedActions)));

            return false;
        }

        public void Execute_ActionArgumentIs_Reset_Succeeds_MessageIsWrittenToUserInterface()
        {
            // Arrange
            var commandAction = PublishingTargetConfigurationCommandAction.Reset;

            var publishingTargetConfigurationCommandParser = new Mock<IPublishingTargetConfigurationCommandActionParser>();
            publishingTargetConfigurationCommandParser.Setup(r => r.ParseAction(It.IsAny<string>())).Returns(commandAction);

            var publishConfigurationAccessor = new Mock<IPublishConfigurationAccessor>();
            publishConfigurationAccessor.Setup(s => s.ResetPublishConfiguration()).Returns(new SuccessResult());

            var publishingTargetConfigurationCommand = new PublishingTargetConfigurationCommand(
                this.loggingUserInterface.UserInterface, publishingTargetConfigurationCommandParser.Object, publishConfigurationAccessor.Object);

            // Act
            publishingTargetConfigurationCommand.Execute();

            // Assert
            Assert.IsTrue(this.loggingUserInterface.UserInterfaceOutput.Contains("success") || this.loggingUserInterface.UserInterfaceOutput.Contains("succeed"));
        }