Merge pull request #228 from microsoft/axsuarez/DialogPrompts

Zerryth · web-flow · commit 76ba2701816c · 2019-06-26T11:23:45.000-07:00
Tests for activity prompt.
diff --git a/libraries/botbuilder-core/botbuilder/core/adapters/test_adapter.py b/libraries/botbuilder-core/botbuilder/core/adapters/test_adapter.py
@@ -103,7 +103,7 @@ async def receive_activity(self, activity):
             if value is not None and key != 'additional_properties':
                 setattr(request, key, value)
 
-            request.type = ActivityTypes.message
+        request.type = request.type or ActivityTypes.message
         if not request.id:
             self._next_id += 1
             request.id = str(self._next_id)
diff --git a/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/activity_prompt.py b/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/activity_prompt.py
@@ -8,6 +8,7 @@
 from botbuilder.dialogs import Dialog, DialogContext, DialogInstance, DialogReason, DialogTurnResult
 from botbuilder.schema import Activity, ActivityTypes, InputHints
 
+from .prompt import Prompt
 from .prompt_options import PromptOptions
 from .prompt_recognizer_result import PromptRecognizerResult
 from .prompt_validator_context import PromptValidatorContext
@@ -36,6 +37,8 @@ def __init__(self, dialog_id: str, validator: Callable[[PromptValidatorContext],
         """
         Dialog.__init__(self, dialog_id)
         
+        if validator is None:
+            raise TypeError('validator was expected but received None')
         self._validator = validator
 
     async def begin_dialog(self, dc: DialogContext, options: PromptOptions) -> DialogTurnResult:
@@ -45,16 +48,18 @@ async def begin_dialog(self, dc: DialogContext, options: PromptOptions) -> Dialo
             raise TypeError('ActivityPrompt.begin_dialog(): Prompt options are required for ActivityPrompts.')
         
         # Ensure prompts have input hint set
-        if options.prompt != None and not options.prompt.input_hint:
+        if options.prompt is not None and not options.prompt.input_hint:
             options.prompt.input_hint = InputHints.expecting_input
 
-        if options.retry_prompt != None and not options.retry_prompt.input_hint:
+        if options.retry_prompt is not None and not options.retry_prompt.input_hint:
             options.retry_prompt.input_hint = InputHints.expecting_input
 
         # Initialize prompt state
         state: Dict[str, object] = dc.active_dialog.state
         state[self.persisted_options] = options
-        state[self.persisted_state] = Dict[str, object]
+        state[self.persisted_state] = {
+            Prompt.ATTEMPT_COUNT_KEY: 0
+        }
 
         # Send initial prompt
         await self.on_prompt(
@@ -76,9 +81,12 @@ async def continue_dialog(self, dc: DialogContext) -> DialogTurnResult:
         options: Dict[str, object] = instance.state[self.persisted_options]
         recognized: PromptRecognizerResult = await self.on_recognize(dc.context, state, options)
 
+        # Increment attempt count
+        state[Prompt.ATTEMPT_COUNT_KEY] += 1
+
         # Validate the return value
         is_valid = False
-        if self._validator != None:
+        if self._validator is not None:
             prompt_context = PromptValidatorContext(
                 dc.context,
                 recognized,
@@ -125,7 +133,7 @@ async def on_prompt(
         context: TurnContext, 
         state: Dict[str, dict], 
         options: PromptOptions,
-        isRetry: bool = False
+        is_retry: bool = False
     ):
         """
         Called anytime the derived class should send the user a prompt.
@@ -140,11 +148,11 @@ async def on_prompt(
 
         isRetry: If `true` the users response wasn't recognized and the re-prompt should be sent.
         """
-        if isRetry and options.retry_prompt:
+        if is_retry and options.retry_prompt:
             options.retry_prompt.input_hint = InputHints.expecting_input
             await context.send_activity(options.retry_prompt)
         elif options.prompt:
-            options.prompt = InputHints.expecting_input
+            options.prompt.input_hint = InputHints.expecting_input
             await context.send_activity(options.prompt)
     
     async def on_recognize(
diff --git a/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/prompt.py b/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/prompt.py
@@ -20,6 +20,7 @@
 """ Base class for all prompts.
 """
 class Prompt(Dialog):
+    ATTEMPT_COUNT_KEY = "AttemptCount"
     persisted_options = "options"
     persisted_state = "state"
     def __init__(self, dialog_id: str, validator: object = None):
@@ -52,7 +53,7 @@ async def begin_dialog(self, dc: DialogContext, options: object) -> DialogTurnRe
         # Initialize prompt state
         state = dc.active_dialog.state
         state[self.persisted_options] = options
-        state[self.persisted_state] = Dict[str, object]
+        state[self.persisted_state] = {}
 
         # Send initial prompt
         await self.on_prompt(dc.context, state[self.persisted_state], state[self.persisted_options], False)
diff --git a/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/prompt_validator_context.py b/libraries/botbuilder-dialogs/botbuilder/dialogs/prompts/prompt_validator_context.py
@@ -6,8 +6,6 @@
 from .prompt_recognizer_result import PromptRecognizerResult
 
 
-""" Contextual information passed to a custom `PromptValidator`.
-"""
 class PromptValidatorContext():
     def __init__(self, turn_context: TurnContext, recognized: PromptRecognizerResult, state: Dict[str, object], options: PromptOptions): 
         """Creates contextual information passed to a custom `PromptValidator`.
@@ -71,3 +69,11 @@ def options(self) -> PromptOptions:
         The validator can extend this interface to support additional prompt options.
         """
         return self._options
+
+    @property
+    def attempt_count(self) -> int:
+        """
+        Gets the number of times the prompt has been executed.
+        """
+        from botbuilder.dialogs.prompts import Prompt
+        return self._state.get(Prompt.ATTEMPT_COUNT_KEY, 0)
diff --git a/libraries/botbuilder-dialogs/tests/test_activity_prompt.py b/libraries/botbuilder-dialogs/tests/test_activity_prompt.py
@@ -2,35 +2,189 @@
 # Licensed under the MIT License.
 
 import aiounittest
-from botbuilder.dialogs.prompts import ActivityPrompt, NumberPrompt, PromptOptions, PromptRecognizerResult
-from botbuilder.schema import Activity, InputHints
+import unittest
 
-from botbuilder.core.turn_context import TurnContext
+from typing import Callable
+from botbuilder.dialogs.prompts import (ActivityPrompt, NumberPrompt, PromptOptions, PromptRecognizerResult,
+                                        PromptValidatorContext)
+from botbuilder.schema import Activity, InputHints, ActivityTypes
+
+from botbuilder.core import ConversationState, MemoryStorage, TurnContext, MessageFactory
 from botbuilder.core.adapters import TestAdapter
+from botbuilder.dialogs import DialogSet, DialogTurnStatus, DialogReason
+
+
+async def validator(prompt_context: PromptValidatorContext):
+    tester = unittest.TestCase()
+    tester.assertTrue(prompt_context.attempt_count > 0)
+
+    activity = prompt_context.recognized.value
+
+    if activity.type == ActivityTypes.event:
+        if int(activity.value) == 2:
+            prompt_context.recognized.value = MessageFactory.text(str(activity.value))
+            return True
+    else:
+        await prompt_context.context.send_activity("Please send an 'event'-type Activity with a value of 2.")
+
+    return False
+
 
 class SimpleActivityPrompt(ActivityPrompt):
-    pass
+    def __init__(self, dialog_id: str, validator: Callable[[PromptValidatorContext], bool]):
+        super().__init__(dialog_id, validator)
+
 
 class ActivityPromptTests(aiounittest.AsyncTestCase):
-    async def test_does_the_things(self):
-        my_activity = Activity(type='message', text='I am activity message!')
-        my_retry_prompt = Activity(type='message', id='ididretry', text='retry text hurrr')
-        options = PromptOptions(prompt=my_activity, retry_prompt=my_retry_prompt)
-        activity_promptyy = ActivityPrompt('myId', 'validator thing')
-
-        my_context = TurnContext(TestAdapter(), my_activity)
-        my_state = {'stringy': {'nestedkey': 'nestedvalue'} }
-        
-        await activity_promptyy.on_prompt(my_context, state=my_state, options=options, isRetry=True)
-
-        print('placeholder print')
-
-        pass
-
-    # def test_activity_prompt_with_empty_id_should_fail(self):
-    #     empty_id = ''
-    #     text_prompt = SimpleActivityPrompt(empty_id, self.validator)
-    
-    # async def validator(self):
-    #     return True
-        
+
+    def test_activity_prompt_with_empty_id_should_fail(self):
+        empty_id = ''
+        with self.assertRaises(TypeError):
+            SimpleActivityPrompt(empty_id, validator)
+
+    def test_activity_prompt_with_none_id_should_fail(self):
+        none_id = None
+        with self.assertRaises(TypeError):
+            SimpleActivityPrompt(none_id, validator)
+
+    def test_activity_prompt_with_none_validator_should_fail(self):
+        none_validator = None
+        with self.assertRaises(TypeError):
+            SimpleActivityPrompt('EventActivityPrompt', none_validator)
+
+    async def test_basic_activity_prompt(self):
+        async def exec_test(turn_context: TurnContext):
+            dc = await dialogs.create_context(turn_context)
+
+            results = await dc.continue_dialog()
+            if results.status == DialogTurnStatus.Empty:
+                options = PromptOptions(prompt=Activity(type=ActivityTypes.message, text='please send an event.'))
+                await dc.prompt('EventActivityPrompt', options)
+            elif results.status == DialogTurnStatus.Complete:
+                await turn_context.send_activity(results.result)
+
+            await convo_state.save_changes(turn_context)
+
+        # Initialize TestAdapter.
+        adapter = TestAdapter(exec_test)
+
+        # Create ConversationState with MemoryStorage and register the state as middleware.
+        convo_state = ConversationState(MemoryStorage())
+
+        # Create a DialogState property, DialogSet and AttachmentPrompt.
+        dialog_state = convo_state.create_property('dialog_state')
+        dialogs = DialogSet(dialog_state)
+        dialogs.add(SimpleActivityPrompt('EventActivityPrompt', validator))
+
+        event_activity = Activity(type=ActivityTypes.event, value=2)
+
+        step1 = await adapter.send('hello')
+        step2 = await step1.assert_reply('please send an event.')
+        step3 = await step2.send(event_activity)
+        await step3.assert_reply('2')
+
+    async def test_retry_activity_prompt(self):
+        async def exec_test(turn_context: TurnContext):
+            dc = await dialogs.create_context(turn_context)
+
+            results = await dc.continue_dialog()
+            if results.status == DialogTurnStatus.Empty:
+                options = PromptOptions(prompt=Activity(type=ActivityTypes.message, text='please send an event.'))
+                await dc.prompt('EventActivityPrompt', options)
+            elif results.status == DialogTurnStatus.Complete:
+                await turn_context.send_activity(results.result)
+
+            await convo_state.save_changes(turn_context)
+
+        # Initialize TestAdapter.
+        adapter = TestAdapter(exec_test)
+
+        # Create ConversationState with MemoryStorage and register the state as middleware.
+        convo_state = ConversationState(MemoryStorage())
+
+        # Create a DialogState property, DialogSet and AttachmentPrompt.
+        dialog_state = convo_state.create_property('dialog_state')
+        dialogs = DialogSet(dialog_state)
+        dialogs.add(SimpleActivityPrompt('EventActivityPrompt', validator))
+
+        event_activity = Activity(type=ActivityTypes.event, value=2)
+
+        step1 = await adapter.send('hello')
+        step2 = await step1.assert_reply('please send an event.')
+        step3 = await step2.send('hello again')
+        step4 = await step3.assert_reply("Please send an 'event'-type Activity with a value of 2.")
+        step5 = await step4.send(event_activity)
+        await step5.assert_reply('2')
+
+    async def test_activity_prompt_should_return_dialog_end_if_validation_failed(self):
+        async def exec_test(turn_context: TurnContext):
+            dc = await dialogs.create_context(turn_context)
+
+            results = await dc.continue_dialog()
+            if results.status == DialogTurnStatus.Empty:
+                options = PromptOptions(
+                    prompt=Activity(type=ActivityTypes.message, text='please send an event.'),
+                    retry_prompt=Activity(type=ActivityTypes.message, text='event not received.')
+                )
+                await dc.prompt('EventActivityPrompt', options)
+            elif results.status == DialogTurnStatus.Complete:
+                await turn_context.send_activity(results.result)
+
+            await convo_state.save_changes(turn_context)
+
+        async def aux_validator(prompt_context: PromptValidatorContext):
+            assert prompt_context, 'Validator missing prompt_context'
+            return False
+
+        # Initialize TestAdapter.
+        adapter = TestAdapter(exec_test)
+
+
+
+        # Create ConversationState with MemoryStorage and register the state as middleware.
+        convo_state = ConversationState(MemoryStorage())
+
+        # Create a DialogState property, DialogSet and AttachmentPrompt.
+        dialog_state = convo_state.create_property('dialog_state')
+        dialogs = DialogSet(dialog_state)
+        dialogs.add(SimpleActivityPrompt('EventActivityPrompt', aux_validator))
+
+        step1 = await adapter.send('hello')
+        step2 = await step1.assert_reply('please send an event.')
+        step3 = await step2.send('test')
+        await step3.assert_reply('event not received.')
+
+    async def test_activity_prompt_resume_dialog_should_return_dialog_end(self):
+        async def exec_test(turn_context: TurnContext):
+            dc = await dialogs.create_context(turn_context)
+
+            results = await dc.continue_dialog()
+            if results.status == DialogTurnStatus.Empty:
+                options = PromptOptions(prompt=Activity(type=ActivityTypes.message, text='please send an event.'))
+                await dc.prompt('EventActivityPrompt', options)
+
+            second_results = await event_prompt.resume_dialog(dc, DialogReason.NextCalled)
+
+            assert second_results.status == DialogTurnStatus.Waiting, 'resume_dialog did not returned Dialog.EndOfTurn'
+
+            await convo_state.save_changes(turn_context)
+
+        async def aux_validator(prompt_context: PromptValidatorContext):
+            assert prompt_context, 'Validator missing prompt_context'
+            return False
+
+        # Initialize TestAdapter.
+        adapter = TestAdapter(exec_test)
+
+        # Create ConversationState with MemoryStorage and register the state as middleware.
+        convo_state = ConversationState(MemoryStorage())
+
+        # Create a DialogState property, DialogSet and AttachmentPrompt.
+        dialog_state = convo_state.create_property('dialog_state')
+        dialogs = DialogSet(dialog_state)
+        event_prompt = SimpleActivityPrompt('EventActivityPrompt', aux_validator)
+        dialogs.add(event_prompt)
+
+        step1 = await adapter.send('hello')
+        step2 = await step1.assert_reply('please send an event.')
+        await step2.assert_reply('please send an event.')
