public async Task create_or_update_lex_intent()
        {
            // Arrange
            var parseYaml   = ReadLocalFile.Run(_localFilePath);
            var lexYamlData = parseYaml.Run();
            Mock <ILexBotGeneratorDependencyProvider> provider = new Mock <ILexBotGeneratorDependencyProvider>(MockBehavior.Strict);

            // DeployA get intent
            provider.Setup(x => x.GetIntentAsync(It.Is <GetIntentRequest>(y =>
                                                                          y.Name == _deployGetIntent.Name &&
                                                                          y.Version == _deployGetIntent.Version
                                                                          ))).Returns(Task.FromResult(new GetIntentResponse {
                Name     = "DeployA",
                Checksum = "zyxwvu"
            }));
            provider.Setup(x => x.PutIntentAsync(It.Is <PutIntentRequest>(y =>
                                                                          y.Name == _deployPutIntent.Name &&
                                                                          y.Checksum == _deployPutIntent.Checksum &&
                                                                          y.SampleUtterances[0] == _deployPutIntent.SampleUtterances[0] &&
                                                                          y.SampleUtterances[1] == _deployPutIntent.SampleUtterances[1] &&
                                                                          y.ConclusionStatement.Messages[0].Content == _deployPutIntent.ConclusionStatement.Messages[0].Content &&
                                                                          y.FulfillmentActivity.Type.Value == _deployPutIntent.FulfillmentActivity.Type.Value &&
                                                                          y.Slots[0].Name == _deployPutIntent.Slots[0].Name &&
                                                                          y.Slots[1].Name == _deployPutIntent.Slots[1].Name &&
                                                                          y.Slots[0].SlotType == _deployPutIntent.Slots[0].SlotType
                                                                          ))).Returns(Task.FromResult(new PutIntentResponse {
                Name     = "DeployA",
                Checksum = "qwert"
            }));
            var manageIntents = new ManageIntents(provider.Object, lexYamlData);

            // Act
            // Assert
            await manageIntents.RunUpdate();
        }
        public void parse_lex_yaml()
        {
            // Arrange
            var parseYaml = ReadLocalFile.Run(_localFilePath);

            // Act
            var lexYamlData = parseYaml.Run();

            // Assert
            Assert.Equal("SampleTestCreateBot", lexYamlData.BotName);
            Assert.Equal("Good Bye", lexYamlData.AbortStatement.Messages[0].Content);
            Assert.Equal("PlainText", lexYamlData.AbortStatement.Messages[0].ContentType.ToString());
            Assert.Equal(3, lexYamlData.ClarificationPrompt.MaxAttempts);
            Assert.Equal("I didn't understand, please try again", lexYamlData.ClarificationPrompt.Messages[0].Content);
            Assert.Equal("PlainText", lexYamlData.ClarificationPrompt.Messages[0].ContentType.ToString());
            Assert.Equal("DeployA", lexYamlData.Intents[0].Name);
            Assert.Equal("Branch", lexYamlData.Intents[0].Slots[0].Name);
            Assert.Equal("EnvironmentA", lexYamlData.Slots[0].Name);
            Assert.Equal("smyleeface", lexYamlData.Slots[0].EnumerationValues[0].Value);
        }
        public async Task create_or_update_lex_slot()
        {
            // Arrange
            var parseYaml   = ReadLocalFile.Run(_localFilePath);
            var lexYamlData = parseYaml.Run();
            Mock <ILexBotGeneratorDependencyProvider> provider = new Mock <ILexBotGeneratorDependencyProvider>(MockBehavior.Strict);

            // EnvironmentA get slot
            provider.Setup(x => x.GetSlotTypeAsync(It.Is <GetSlotTypeRequest>(y =>
                                                                              y.Name == _environmentGetSlotRequest.Name && y.Version == "$LATEST"
                                                                              ))).Returns(Task.FromException <GetSlotTypeResponse>(new Exception("error")));

            // Branch get slot
            provider.Setup(x => x.GetSlotTypeAsync(It.Is <GetSlotTypeRequest>(y =>
                                                                              y.Name == _branchGetSlotRequest.Name && y.Version == "$LATEST"
                                                                              ))).Returns(Task.FromResult(new GetSlotTypeResponse {
                Name     = "BranchA",
                Checksum = "fghijk"
            }));

            // EnvironmentA put slot
            provider.Setup(x => x.PutSlotTypeAsync(It.Is <PutSlotTypeRequest>(y =>
                                                                              y.Name == _environmentPutSlotRequest.Name && y.Checksum == _environmentPutSlotRequest.Checksum
                                                                              ))).Returns(Task.FromResult(new PutSlotTypeResponse {
                Name     = "EnvironmentA",
                Checksum = "abcde"
            }));

            // Branch put slot
            provider.Setup(x => x.PutSlotTypeAsync(It.Is <PutSlotTypeRequest>(y =>
                                                                              y.Name == _branchPutSlotRequest.Name && y.Checksum == _branchPutSlotRequest.Checksum
                                                                              ))).Returns(Task.FromResult(new PutSlotTypeResponse {
                Name     = "BranchA",
                Checksum = "lmnob"
            }));
            var manageSlots = new ManageSlots(provider.Object, lexYamlData);

            // Act
            // Assert
            await manageSlots.RunUpdate();
        }
        public async Task create_or_update_lex_bot()
        {
            // Arrange
            var parseYaml   = ReadLocalFile.Run(_localFilePath);
            var lexYamlData = parseYaml.Run();
            Mock <ILexBotGeneratorDependencyProvider> provider = new Mock <ILexBotGeneratorDependencyProvider>(MockBehavior.Strict);

            provider.Setup(x => x.PutBotAsync(It.Is <PutBotRequest>(y =>
                                                                    y.Name == _putBotRequest.Name &&
                                                                    y.Intents[0].IntentName == _putBotRequest.Intents[0].IntentName &&
                                                                    y.ClarificationPrompt.MaxAttempts == _putBotRequest.ClarificationPrompt.MaxAttempts &&
                                                                    y.ClarificationPrompt.Messages[0].Content == _putBotRequest.ClarificationPrompt.Messages[0].Content &&
                                                                    y.AbortStatement.Messages[0].Content == _putBotRequest.AbortStatement.Messages[0].Content
                                                                    ))).Returns(Task.FromResult(new PutBotResponse {
                Name     = "DeployA",
                Checksum = "qwert"
            }));
            var manageBots = new ManageBots(provider.Object, lexYamlData);

            // Act
            // Assert
            await manageBots.RunUpdate();
        }