def test_create_intent_with_amazon_slot(put_intent_response, codehook_uri,
                                        mock_context, lex, aws_lambda,
                                        monkeypatch_account):

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as lex_stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)

        intent_builder = IntentBuilder(Mock(),
                                       mock_context,
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)

        plaintext = {
            "confirmation": 'some confirmation message',
            'rejection': 'rejection message',
            'conclusion': 'concluded'
        }
        stub_not_found_get_request(lex_stubber)
        slot = Slot('person', 'AMAZON.Person', 'yo', ['one', 'two'])
        intent = Intent(BOT_NAME,
                        INTENT_NAME,
                        codehook_uri,
                        UTTERANCES, [slot],
                        plaintext=plaintext,
                        max_attempts=3)

        put_request = put_intent_slot_request(intent)
        put_request.update(put_request_conclusion(plaintext))

        stub_intent_creation(lex_stubber, put_intent_response, put_request)

        intent_builder.put_intent(intent)

        lex_stubber.assert_no_pending_responses()
        lambda_stubber.assert_no_pending_responses()
def test_create_intent_old_missing_rejection_plaintext(put_intent_response,
                                                       codehook_uri,
                                                       mock_context, lex,
                                                       aws_lambda,
                                                       monkeypatch_account):

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as lex_stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)
        stub_not_found_get_request(lex_stubber)

        intent_builder = IntentBuilder(Mock(),
                                       mock_context,
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)
        plaintext = {"confirmation": 'some confirmation message'}
        intent = Intent(BOT_NAME,
                        INTENT_NAME,
                        codehook_uri,
                        UTTERANCES, [],
                        plaintext=plaintext)
        with pytest.raises(Exception) as excinfo:
            intent_builder.put_intent(intent)

        assert "Must have both rejection and confirmation or neither" in str(
            excinfo.value)
def test_delete_deleted_intent(lex, mock_context, aws_lambda):
    delete_intent_response, delete_request_1 = {}, {'name': INTENT_NAME}
    delete_intent_response, delete_request_2 = {}, {'name': INTENT_NAME_2}

    intent_builder = IntentBuilder(Mock(),
                                   mock_context,
                                   lex_sdk=lex,
                                   lambda_sdk=aws_lambda)

    with Stubber(lex) as stubber:
        stub_not_found_get_request(stubber)
        stub_intent_deletion(stubber, delete_intent_response, delete_request_1)
        stub_not_found_get_request(stubber)
        stub_intent_deletion(stubber, delete_intent_response, delete_request_2)

        intent_builder.delete_intents([INTENT_NAME, INTENT_NAME_2])

        stubber.assert_no_pending_responses()
def test_update_intent_plaintext_followUp(put_intent_response, codehook_uri,
                                          mock_context, lex, aws_lambda,
                                          monkeypatch_account):

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)

        intent_builder = IntentBuilder(Mock(),
                                       mock_context,
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)

        plaintext = {
            "confirmation": 'some confirmation message',
            'rejection': 'rejection message',
            'followUpPrompt': 'follow on',
            'followUpRejection': 'failed follow on'
        }
        put_request = put_intent_request(BOT_NAME,
                                         INTENT_NAME,
                                         UTTERANCES,
                                         plaintext=plaintext)

        put_request.update(put_request_followUp(plaintext))
        put_request.update({'checksum': 'chksum'})
        stub_intent_get(stubber, INTENT_NAME)

        stub_intent_creation(stubber, put_intent_response, put_request)

        intent = Intent(BOT_NAME,
                        INTENT_NAME,
                        codehook_uri,
                        UTTERANCES,
                        None,
                        plaintext=plaintext,
                        max_attempts=3)
        response = intent_builder.put_intent(intent)

        stubber.assert_no_pending_responses()
        lambda_stubber.assert_no_pending_responses()

        assert response['intentName'] == 'greeting'
        assert response['intentVersion'] == '1'
def test_create_intent_conclusion_and_followUp_errors(put_intent_response,
                                                      codehook_uri,
                                                      mock_context, lex,
                                                      aws_lambda,
                                                      monkeypatch_account):

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)
        intent_builder = IntentBuilder(Mock(),
                                       mock_context,
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)

        plaintext = {
            "confirmation": 'some confirmation message',
            'rejection': 'rejection message',
            'conclusion': 'the conclusion',
            'followUpPrompt': 'follow up'
        }

        stub_not_found_get_request(stubber)
        put_request = put_intent_request(BOT_NAME,
                                         INTENT_NAME,
                                         UTTERANCES,
                                         plaintext=plaintext)
        put_request.update(put_request_conclusion(plaintext))

        stub_intent_creation(stubber, put_intent_response, put_request)

        with pytest.raises(Exception) as excinfo:
            intent = Intent(BOT_NAME,
                            INTENT_NAME,
                            codehook_uri,
                            UTTERANCES,
                            None,
                            plaintext=plaintext,
                            max_attempts=3)
            intent_builder.put_intent(intent)

        assert "Can not have conclusion and followUpPrompt" in str(
            excinfo.value)
def test_create_intent_response(put_intent_response, codehook_uri,
                                mock_context, lex, aws_lambda,
                                monkeypatch_account):
    """ test the response from create intent """

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)
        intent_builder = IntentBuilder(Mock(),
                                       mock_context(mocker),
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)

        plaintext = {
            "confirmation": 'some confirmation message',
            'rejection': 'rejection message',
            'conclusion': 'concluded'
        }

        stub_not_found_get_request(stubber)
        put_request = put_intent_request(BOT_NAME,
                                         INTENT_NAME,
                                         UTTERANCES,
                                         plaintext=plaintext)
        put_request.update(put_request_conclusion(plaintext))

        stub_intent_creation(stubber, put_intent_response, put_request)

        intent = Intent(BOT_NAME,
                        INTENT_NAME,
                        codehook_uri,
                        UTTERANCES,
                        None,
                        plaintext=plaintext,
                        max_attempts=3)
        response = intent_builder.put_intent(intent)

        stubber.assert_no_pending_responses()
        lambda_stubber.assert_no_pending_responses()

        assert response['intentName'] == 'greeting'
        assert response['intentVersion'] == '1'
def test_create_intent_missing_followUp_plaintext(put_intent_response,
                                                  codehook_uri, mock_context,
                                                  lex, aws_lambda,
                                                  monkeypatch_account):

    with Stubber(aws_lambda) as lambda_stubber, Stubber(lex) as stubber:
        stub_lambda_request(lambda_stubber, codehook_uri)
        intent_builder = IntentBuilder(Mock(),
                                       mock_context,
                                       lex_sdk=lex,
                                       lambda_sdk=aws_lambda)

        plaintext = {
            "confirmation": 'some confirmation message',
            'rejection': 'rejection message',
            'conclusion': 'the conclusion'
        }

        stub_not_found_get_request(stubber)
        put_request = put_intent_request(BOT_NAME,
                                         INTENT_NAME,
                                         UTTERANCES,
                                         plaintext=plaintext)
        put_request.update(put_request_conclusion(plaintext))

        stub_intent_creation(stubber, put_intent_response, put_request)

        intent = Intent(BOT_NAME,
                        INTENT_NAME,
                        codehook_uri,
                        UTTERANCES,
                        None,
                        plaintext=plaintext,
                        max_attempts=3)
        intent_builder.put_intent(intent)

        stubber.assert_no_pending_responses()
        lambda_stubber.assert_no_pending_responses()