/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0/ * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ // @file DirectiveProcessorTest.cpp #include #include #include #include #include #include #include #include #include #include "ADSL/DirectiveProcessor.h" #include "MockDirectiveHandler.h" using namespace ::testing; namespace alexaClientSDK { namespace adsl { namespace test { using namespace avsCommon; using namespace avsCommon::avs; using namespace avsCommon::avs::attachment; /// Generic messageId used for tests. static const std::string MESSAGE_ID_0_0("Message_0_0"); /// Generic MessageId used for test. static const std::string MESSAGE_ID_0_1("Message_0_1"); /// Generic MessageId used for test. static const std::string MESSAGE_ID_0_2("Message_0_2"); /// Generic MessageId used for test. static const std::string MESSAGE_ID_0_3("Message_0_3"); /// Generic MessageId used for tests. static const std::string MESSAGE_ID_1_0("Message_1_0"); /// Generic DialogRequestId used for tests. static const std::string DIALOG_REQUEST_ID_0("DialogRequestId_0"); /// Generic DialogRequestId used for tests. static const std::string DIALOG_REQUEST_ID_1("DialogRequestId_1"); /// An unparsed directive for test. static const std::string UNPARSED_DIRECTIVE("unparsedDirectiveForTest"); /// A paylaod for test; static const std::string PAYLOAD_TEST("payloadForTest"); /// A generic namespace string for tests. static const std::string NAMESPACE_0("namespace_0"); /// A generic namespace string for tests. static const std::string NAMESPACE_1("namespace_1"); /// A generic name string for tests. static const std::string NAME_0("name_0"); /// A generic name string for tests. static const std::string NAME_1("name_1"); /// A generic name string for tests. static const std::string NAME_2("name_2"); /// A generic name string for tests. static const std::string NAME_3("name_3"); static const std::string TEST_ATTACHMENT_CONTEXT_ID("TEST_ATTACHMENT_CONTEXT_ID"); /// Namespace and name combination for tests. #define NAMESPACE_AND_NAME_0_0 NAMESPACE_0, NAME_0 /// Namespace and name combination (changing name this time) for tests. #define NAMESPACE_AND_NAME_0_1 NAMESPACE_0, NAME_1 /// Namespace and name combination (changing name this time) for tests. #define NAMESPACE_AND_NAME_0_2 NAMESPACE_0, NAME_2 /// Namespace and name combination (changing name this time) for tests. #define NAMESPACE_AND_NAME_0_3 NAMESPACE_0, NAME_3 /// Namespace and name combination (changing namespace this time) for tests. #define NAMESPACE_AND_NAME_1_0 NAMESPACE_1, NAME_0 /// An InteractionModel.NewDialogRequest v1.0 directive. The v1.0 directive has a dialogRequestID in the header and /// payload. // clang-format off static const std::string NEW_DIALOG_REQUEST_DIRECTIVE_V0 = R"delim( { "directive": { "header": { "namespace": "InteractionModel", "name": "NewDialogRequest", "messageId": "2120215c-d803-4800-8773-e9505d16354a", "dialogRequestId": ")delim" + DIALOG_REQUEST_ID_0 + R"delim(" }, "payload": { "dialogRequestId": ")delim" + DIALOG_REQUEST_ID_0 + R"delim(" } } })delim"; // clang-format on /// A null context ID string static const std::string NO_CONTEXT = ""; /// The NewDialogRequest directive signature. static const NamespaceAndName NEW_DIALOG_REQUEST_SIGNATURE{"InteractionModel", "NewDialogRequest"}; /** * DirectiveRouterTest */ class DirectiveProcessorTest : public ::testing::Test { public: void SetUp() override; /// A DirectiveRouter instance to test with. std::shared_ptr m_router; /// A DirectiveProcessor instance to test with. std::shared_ptr m_processor; /// AttachmentManager with which to create directives. std::shared_ptr m_attachmentManager; /// Generic @c AVSDirective for tests. std::shared_ptr m_directive_0_0; /// Generic @c AVSDirective for tests. std::shared_ptr m_directive_0_1; /// Generic @c AVSDirective for tests. std::shared_ptr m_directive_0_2; /// Generic @c AVSDirective for tests. std::shared_ptr m_directive_0_3; /// Generic @c AVSDirective for tests. std::shared_ptr m_directive_1_0; }; void DirectiveProcessorTest::SetUp() { m_router = std::make_shared(); m_processor = std::make_shared(m_router.get()); m_attachmentManager = std::make_shared(AttachmentManager::AttachmentType::IN_PROCESS); auto avsMessageHeader_0_0 = std::make_shared(NAMESPACE_AND_NAME_0_0, MESSAGE_ID_0_0, DIALOG_REQUEST_ID_0); m_directive_0_0 = AVSDirective::create( UNPARSED_DIRECTIVE, avsMessageHeader_0_0, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID); auto avsMessageHeader_0_1 = std::make_shared(NAMESPACE_AND_NAME_0_1, MESSAGE_ID_0_1, DIALOG_REQUEST_ID_0); m_directive_0_1 = AVSDirective::create( UNPARSED_DIRECTIVE, avsMessageHeader_0_1, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID); auto avsMessageHeader_0_2 = std::make_shared(NAMESPACE_AND_NAME_0_2, MESSAGE_ID_0_2, DIALOG_REQUEST_ID_0); m_directive_0_2 = AVSDirective::create( UNPARSED_DIRECTIVE, avsMessageHeader_0_2, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID); auto avsMessageHeader_0_3 = std::make_shared(NAMESPACE_AND_NAME_0_3, MESSAGE_ID_0_3, DIALOG_REQUEST_ID_0); m_directive_0_3 = AVSDirective::create( UNPARSED_DIRECTIVE, avsMessageHeader_0_3, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID); auto avsMessageHeader_1_0 = std::make_shared(NAMESPACE_AND_NAME_1_0, MESSAGE_ID_1_0, DIALOG_REQUEST_ID_1); m_directive_1_0 = AVSDirective::create( UNPARSED_DIRECTIVE, avsMessageHeader_1_0, PAYLOAD_TEST, m_attachmentManager, TEST_ATTACHMENT_CONTEXT_ID); } /** * Send a nullptr @c AVSDirective. Expect that it is ignored and a failure status (false) is returned. */ TEST_F(DirectiveProcessorTest, test_nullptrDirective) { ASSERT_FALSE(m_processor->onDirective(nullptr)); } /** * Register a @c DirectiveHandler and set the @c dialogRequestId. Send a @c AVSDirective that the handler * registered for, but with a @c dialogRequestId that does not match. Expect that @c onDirective() * returns true (because the handler was registered) but that none of the handler methods are called * (because directives with the wrong @c dialogRequestID are dropped). */ TEST_F(DirectiveProcessorTest, test_wrongDialogRequestId) { DirectiveHandlerConfiguration handler0Config; handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); std::shared_ptr handler0 = MockDirectiveHandler::create(handler0Config); ASSERT_TRUE(m_router->addDirectiveHandler(handler0)); EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler0.get()), preHandleDirective(m_directive_0_0, _)).Times(0); EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0_0)).Times(0); EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_1); ASSERT_TRUE(m_processor->onDirective(m_directive_0_0)); } /** * Register an @c AUDIO_NON_BLOCKING @c DirectiveHandler. Send an @c AVSDirective that matches the registered handler. * Expect that @c preHandleDirective() and @c handleDirective() are called. */ TEST_F(DirectiveProcessorTest, test_sendNonBlocking) { DirectiveHandlerConfiguration handler0Config; handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); std::shared_ptr handler0 = MockDirectiveHandler::create(handler0Config); ASSERT_TRUE(m_router->addDirectiveHandler(handler0)); EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler0.get()), preHandleDirective(m_directive_0_0, _)).Times(1); EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0_0)).Times(1); EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(m_directive_0_0)); ASSERT_TRUE(handler0->waitUntilCompleted(std::chrono::milliseconds(1500000))); } /** * Test sending a blocking and then a non-blocking directive. Expect that @c preHandleDirective() and * @c handleDirective() is called for each. */ TEST_F(DirectiveProcessorTest, test_sendBlockingThenNonBlocking) { DirectiveHandlerConfiguration handler0Config; handler0Config[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUMS_AUDIO_AND_VISUAL, true); std::shared_ptr handler0 = MockDirectiveHandler::create(handler0Config); DirectiveHandlerConfiguration handler1Config; handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); std::shared_ptr handler1 = MockDirectiveHandler::create(handler1Config); ASSERT_TRUE(m_router->addDirectiveHandler(handler0)); ASSERT_TRUE(m_router->addDirectiveHandler(handler1)); EXPECT_CALL(*(handler0.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler0.get()), preHandleDirective(m_directive_0_0, _)).Times(1); EXPECT_CALL(*(handler0.get()), handleDirective(MESSAGE_ID_0_0)).Times(1); EXPECT_CALL(*(handler0.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler1.get()), preHandleDirective(m_directive_0_1, _)).Times(1); EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_0_1)).Times(1); EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(m_directive_0_0)); ASSERT_TRUE(m_processor->onDirective(m_directive_0_1)); ASSERT_TRUE(handler1->waitUntilCompleted()); } /** * Register a handler for two @c AVSDirectives. Send an @c AVSDirective for which no handler is registered. * Then send an @c AVSDirective with the same @c dialogRequestId. Expect that the first @c AVSDirective will * be dropped (and @c onDirective() will return false) because there is no handler. Expect the second directive * to be handled, including @c preHandleDirective() and @c handleDirective() calls. After @c handleDirective() * has been called, set the @c dialogRequestId and send an @c AVSDirective for which the other handler was * registered. Expect that the last directive is handled as well. */ TEST_F(DirectiveProcessorTest, test_onUnregisteredDirective) { DirectiveHandlerConfiguration handler1Config; handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); std::shared_ptr handler1 = MockDirectiveHandler::create(handler1Config); DirectiveHandlerConfiguration handler2Config; handler2Config[NamespaceAndName{NAMESPACE_AND_NAME_1_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); std::shared_ptr handler2 = MockDirectiveHandler::create(handler2Config); ASSERT_TRUE(m_router->addDirectiveHandler(handler1)); ASSERT_TRUE(m_router->addDirectiveHandler(handler2)); EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler1.get()), preHandleDirective(m_directive_0_1, _)).Times(1); EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_0_1)).Times(1); EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler2.get()), preHandleDirective(m_directive_1_0, _)).Times(1); EXPECT_CALL(*(handler2.get()), handleDirective(MESSAGE_ID_1_0)).Times(1); EXPECT_CALL(*(handler2.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_FALSE(m_processor->onDirective(m_directive_0_0)); ASSERT_TRUE(m_processor->onDirective(m_directive_0_1)); ASSERT_TRUE(handler1->waitUntilCompleted()); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_1); ASSERT_TRUE(m_processor->onDirective(m_directive_1_0)); ASSERT_TRUE(handler2->waitUntilCompleted()); } /** * Register a long running and @c BLOCKING @c DirectiveHandler for one @c AVSDirective and a short * running @c DirectiveHandler for two more @c AVSDirectives. Send the long running @c AVSDirective * followed by a short running one. Wait until the long running @c AVSDirective has entered * handleDirective() and the short running @c AVSDirective has entered preHandleDirective(). * then change the @c dialogRequestId() and send a final @c AVSDirective with the new * @c dialogRequestId(). Expect the first two @c AVSDirectives to be cancelled and expect the * final @c AVSDirective to be processed normally. */ TEST_F(DirectiveProcessorTest, test_setDialogRequestIdCancelsOutstandingDirectives) { DirectiveHandlerConfiguration longRunningHandlerConfig; longRunningHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto longRunningHandler = MockDirectiveHandler::create(longRunningHandlerConfig, MockDirectiveHandler::DEFAULT_DONE_TIMEOUT_MS); DirectiveHandlerConfiguration handler1Config; auto audioNonBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); handler1Config[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = audioNonBlockingPolicy; auto handler1 = MockDirectiveHandler::create(handler1Config); DirectiveHandlerConfiguration handler2Config; handler2Config[NamespaceAndName{NAMESPACE_AND_NAME_1_0}] = audioNonBlockingPolicy; auto handler2 = MockDirectiveHandler::create(handler2Config); ASSERT_TRUE(m_router->addDirectiveHandler(longRunningHandler)); ASSERT_TRUE(m_router->addDirectiveHandler(handler1)); ASSERT_TRUE(m_router->addDirectiveHandler(handler2)); EXPECT_CALL(*(longRunningHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(longRunningHandler.get()), preHandleDirective(_, _)).Times(1); EXPECT_CALL(*(longRunningHandler.get()), handleDirective(_)).Times(1); EXPECT_CALL(*(longRunningHandler.get()), cancelDirective(_)).Times(1); EXPECT_CALL(*(handler1.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler1.get()), preHandleDirective(m_directive_0_1, _)).Times(1); EXPECT_CALL(*(handler1.get()), handleDirective(MESSAGE_ID_0_1)).Times(0); EXPECT_CALL(*(handler1.get()), cancelDirective(_)).Times(1); EXPECT_CALL(*(handler2.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(handler2.get()), preHandleDirective(m_directive_1_0, _)).Times(1); EXPECT_CALL(*(handler2.get()), handleDirective(MESSAGE_ID_1_0)).Times(1); EXPECT_CALL(*(handler2.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(m_directive_0_0)); ASSERT_TRUE(m_processor->onDirective(m_directive_0_1)); ASSERT_TRUE(longRunningHandler->waitUntilHandling()); ASSERT_TRUE(handler1->waitUntilPreHandling()); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_1); ASSERT_TRUE(m_processor->onDirective(m_directive_1_0)); ASSERT_TRUE(handler2->waitUntilCompleted()); } TEST_F(DirectiveProcessorTest, test_addDirectiveWhileDisabled) { m_processor->disable(); ASSERT_FALSE(m_processor->onDirective(m_directive_0_0)); } TEST_F(DirectiveProcessorTest, test_addDirectiveAfterReEnabled) { m_processor->disable(); ASSERT_FALSE(m_processor->onDirective(m_directive_0_0)); m_processor->enable(); ASSERT_TRUE(m_processor->onDirective(m_directive_0_0)); } /** * Verify that an @c AVSDirective using @c MEDIUMS_AUDIO_AND_VISUAL * is blocking @c MEDIUM_AUDIO but not blocking @c MEDIUMS_NONE. */ TEST_F(DirectiveProcessorTest, test_audioAndVisualIsBlockingAudio) { auto& audioAndVisualBlockingDirective = m_directive_0_0; DirectiveHandlerConfiguration audioAndVisualBlockingHandlerConfig; auto audioBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUMS_AUDIO_AND_VISUAL, true); audioAndVisualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = audioBlockingPolicy; auto audioAndVisualBlockingHandler = MockDirectiveHandler::create(audioAndVisualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioAndVisualBlockingHandler)); auto& audioNonBlockingDirective = m_directive_0_1; DirectiveHandlerConfiguration audioNonBlockingHandlerConfig; auto audioNonBlockingPolicy = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, false); audioNonBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = audioNonBlockingPolicy; auto audioNonBlockingHandler = MockDirectiveHandler::create(audioNonBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioNonBlockingHandler)); auto& noneMediumsNoBlockingDirective = m_directive_0_2; DirectiveHandlerConfiguration handler3Config; auto noneMediums = BlockingPolicy(BlockingPolicy::MEDIUMS_NONE, false); handler3Config[NamespaceAndName{NAMESPACE_AND_NAME_0_2}] = noneMediums; auto noneMediumsNonBlockingHandler = MockDirectiveHandler::create(handler3Config); ASSERT_TRUE(m_router->addDirectiveHandler(noneMediumsNonBlockingHandler)); // On audioAndVisualBlockingDirective, expect preHandle and handle. Then cancel, as it wasn't completed. EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), preHandleDirective(audioAndVisualBlockingDirective, _)) .Times(1); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_0)) .Times(1) .WillOnce(Return(true)); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), cancelDirective(_)).Times(1); // On audioNonBlockingDirective, expect only preHandle as it's blocked. EXPECT_CALL(*(audioNonBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioNonBlockingHandler.get()), preHandleDirective(audioNonBlockingDirective, _)).Times(1); EXPECT_CALL(*(audioNonBlockingHandler.get()), handleDirective(MESSAGE_ID_0_1)).Times(0); EXPECT_CALL(*(audioNonBlockingHandler.get()), cancelDirective(_)).Times(1); // On noneMediumsNoBlockingDirective, expect completion. EXPECT_CALL(*(noneMediumsNonBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(noneMediumsNonBlockingHandler.get()), preHandleDirective(noneMediumsNoBlockingDirective, _)).Times(1); EXPECT_CALL(*(noneMediumsNonBlockingHandler.get()), handleDirective(MESSAGE_ID_0_2)).Times(1); EXPECT_CALL(*(noneMediumsNonBlockingHandler.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(audioAndVisualBlockingDirective)); ASSERT_TRUE(m_processor->onDirective(audioNonBlockingDirective)); ASSERT_TRUE(m_processor->onDirective(noneMediumsNoBlockingDirective)); noneMediumsNonBlockingHandler->waitUntilCompleted(); } /** * Verify that a blocking @c AVSDirective is not blocking * a future @c AVSDirective on a different @c Medium. */ TEST_F(DirectiveProcessorTest, test_differentMediums) { auto& audioBlockingDirective = m_directive_0_0; DirectiveHandlerConfiguration audioBlockingHandlerConfig; audioBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto audioBlockingHandler = MockDirectiveHandler::create(audioBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioBlockingHandler)); auto& visualBlockingDirective = m_directive_0_1; DirectiveHandlerConfiguration visualBlockingHandlerConfig; visualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUM_VISUAL, true); auto visualBlockingHandler = MockDirectiveHandler::create(visualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(visualBlockingHandler)); // On audioBlockingDirective, expect preHandle and handle. Then cancel as it wasn't completed. EXPECT_CALL(*(audioBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioBlockingHandler.get()), preHandleDirective(audioBlockingDirective, _)).Times(1); EXPECT_CALL(*(audioBlockingHandler.get()), handleDirective(MESSAGE_ID_0_0)).Times(1).WillOnce(Return(true)); EXPECT_CALL(*(audioBlockingHandler.get()), cancelDirective(_)).Times(1); // On visualBlockingDirective, expect completion. EXPECT_CALL(*(visualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), preHandleDirective(visualBlockingDirective, _)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_1)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(audioBlockingDirective)); ASSERT_TRUE(m_processor->onDirective(visualBlockingDirective)); visualBlockingHandler->waitUntilCompleted(); } /** * Verify that when @c MEDIUM_AUDIO and @c MEDIUM_VISUAL * have been blocked by two different @c AVSDirectives, * When one of the blocking has been completed, only its @c Medium is * released. */ TEST_F(DirectiveProcessorTest, test_releaseOneMedium) { // 4 directives: blocking audio, blocking visual, using audio and using visual auto& audioBlockingDirective = m_directive_0_0; DirectiveHandlerConfiguration audioBlockingHandlerConfig; audioBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto audioBlockingHandler = MockDirectiveHandler::create(audioBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioBlockingHandler)); auto& visualBlockingDirective = m_directive_0_1; DirectiveHandlerConfiguration visualBlockingHandlerConfig; visualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUM_VISUAL, true); auto visualBlockingHandler = MockDirectiveHandler::create(visualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(visualBlockingHandler)); auto& audioBlockingDirective2 = m_directive_0_2; DirectiveHandlerConfiguration audioBlockingHandler2Config; audioBlockingHandler2Config[NamespaceAndName{NAMESPACE_AND_NAME_0_2}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto audioBlockingHandler2 = MockDirectiveHandler::create(audioBlockingHandler2Config); ASSERT_TRUE(m_router->addDirectiveHandler(audioBlockingHandler2)); auto& visualBlockingDirective2 = m_directive_0_3; DirectiveHandlerConfiguration visualBlockingHandler2Config; visualBlockingHandler2Config[NamespaceAndName{NAMESPACE_AND_NAME_0_3}] = BlockingPolicy(BlockingPolicy::MEDIUM_VISUAL, true); auto visualBlockingHandler2 = MockDirectiveHandler::create(visualBlockingHandler2Config); ASSERT_TRUE(m_router->addDirectiveHandler(visualBlockingHandler2)); // On audioBlockingDirective, expect preHandle and handle. Then cancel as it wasn't completed. EXPECT_CALL(*(audioBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioBlockingHandler.get()), preHandleDirective(audioBlockingDirective, _)).Times(1); EXPECT_CALL(*(audioBlockingHandler.get()), handleDirective(MESSAGE_ID_0_0)).Times(1).WillOnce(Return(true)); EXPECT_CALL(*(audioBlockingHandler.get()), cancelDirective(_)).Times(1); // On visualBlockingDirective, expect completion. EXPECT_CALL(*(visualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), preHandleDirective(visualBlockingDirective, _)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_1)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), cancelDirective(_)).Times(0); // On audioBlockingDirective2, expect preHandle and handle. Then cancel as it wasn't completed because it's blocked. EXPECT_CALL(*(audioBlockingHandler2.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioBlockingHandler2.get()), preHandleDirective(audioBlockingDirective2, _)).Times(1); EXPECT_CALL(*(audioBlockingHandler2.get()), handleDirective(MESSAGE_ID_0_2)).Times(0); EXPECT_CALL(*(audioBlockingHandler2.get()), cancelDirective(_)).Times(1); // On visualBlockingDirective2, expect completion. EXPECT_CALL(*(visualBlockingHandler2.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler2.get()), preHandleDirective(visualBlockingDirective2, _)).Times(1); EXPECT_CALL(*(visualBlockingHandler2.get()), handleDirective(MESSAGE_ID_0_3)).Times(1); EXPECT_CALL(*(visualBlockingHandler2.get()), cancelDirective(_)).Times(0); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(audioBlockingDirective)); ASSERT_TRUE(m_processor->onDirective(visualBlockingDirective)); ASSERT_TRUE(m_processor->onDirective(audioBlockingDirective2)); ASSERT_TRUE(m_processor->onDirective(visualBlockingDirective2)); visualBlockingHandler->waitUntilCompleted(); visualBlockingHandler2->waitUntilCompleted(); } /** * Verify that a blocked directive with isBlocking=true on the queue is blocking * subsequent directives using the same @c Medium. */ TEST_F(DirectiveProcessorTest, test_blockingQueuedDirectivIsBlocking) { auto& audioBlockingDirective = m_directive_0_0; DirectiveHandlerConfiguration audioBlockingHandlerConfig; audioBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto audioBlockingHandler = MockDirectiveHandler::create(audioBlockingHandlerConfig, MockDirectiveHandler::DEFAULT_DONE_TIMEOUT_MS); ASSERT_TRUE(m_router->addDirectiveHandler(audioBlockingHandler)); auto& audioAndVisualBlocking = m_directive_0_1; DirectiveHandlerConfiguration audioAndVisualBlockingHandlerConfig; audioAndVisualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUMS_AUDIO_AND_VISUAL, true); auto audioAndVisualBlockingHandler = MockDirectiveHandler::create(audioAndVisualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioAndVisualBlockingHandler)); auto& visualBlockingDirective = m_directive_0_2; DirectiveHandlerConfiguration visualBlockingHandlerConfig; visualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_2}] = BlockingPolicy(BlockingPolicy::MEDIUM_VISUAL, true); auto visualBlockingHandler = MockDirectiveHandler::create(visualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(visualBlockingHandler)); /* * create a none mediums directive to make sure visualBlockingDirective was waiting in the * queue after audioAndVisualBlocking */ auto& noneMediumsDirective = m_directive_0_3; DirectiveHandlerConfiguration noneMediumsHandlerConfig; noneMediumsHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_3}] = BlockingPolicy(BlockingPolicy::MEDIUMS_NONE, false); auto noneMediumsHandler = MockDirectiveHandler::create(noneMediumsHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(noneMediumsHandler)); EXPECT_CALL(*(audioBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioBlockingHandler.get()), preHandleDirective(audioBlockingDirective, _)).Times(1); EXPECT_CALL(*(audioBlockingHandler.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), preHandleDirective(audioAndVisualBlocking, _)).Times(1); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), preHandleDirective(visualBlockingDirective, _)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(noneMediumsHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(noneMediumsHandler.get()), preHandleDirective(noneMediumsDirective, _)).Times(1); EXPECT_CALL(*(noneMediumsHandler.get()), cancelDirective(_)).Times(0); /* * Expect the directives to be handles in the following order: * 1. audioBlockingDirective - arrived first * 2. noneMediumsHandler - not bloecked by any of the others. * 3. audioAndVisualBlocking - waiting for audioBlockingDirective to complete. * 4. visualBlockingHandler - waiting for audioAndVisualBlocking to complete */ ::testing::Sequence s1; EXPECT_CALL(*(audioBlockingHandler.get()), handleDirective(MESSAGE_ID_0_0)).Times(1).InSequence(s1); EXPECT_CALL(*(noneMediumsHandler.get()), handleDirective(MESSAGE_ID_0_3)).Times(1).InSequence(s1); EXPECT_CALL(*(audioAndVisualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_1)).Times(1).InSequence(s1); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_2)).Times(1).InSequence(s1); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(audioBlockingDirective)); audioBlockingHandler->waitUntilHandling(); ASSERT_TRUE(m_processor->onDirective(audioAndVisualBlocking)); audioAndVisualBlockingHandler->waitUntilPreHandling(); ASSERT_TRUE(m_processor->onDirective(visualBlockingDirective)); visualBlockingHandler->waitUntilPreHandling(); // wait until noneMediumsDirective is handled to make sure we have visited the procesingLoop with all of them ASSERT_TRUE(m_processor->onDirective(noneMediumsDirective)); noneMediumsHandler->waitUntilHandling(); // Now, audioBlockingDirective can be completed. audioBlockingHandler->doHandlingCompleted(); audioAndVisualBlockingHandler->waitUntilCompleted(); visualBlockingHandler->waitUntilCompleted(); } /** * Verify that a blocked directive with isBlocking=false on the queue is NOT blocking * subsequent directives using the same @c Medium. */ TEST_F(DirectiveProcessorTest, test_nonBlockingQueuedDirectivIsNotBlocking) { auto& audioBlockingDirective = m_directive_0_0; DirectiveHandlerConfiguration audioBlockingHandlerConfig; audioBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_0}] = BlockingPolicy(BlockingPolicy::MEDIUM_AUDIO, true); auto audioBlockingHandler = MockDirectiveHandler::create(audioBlockingHandlerConfig, MockDirectiveHandler::DEFAULT_DONE_TIMEOUT_MS); ASSERT_TRUE(m_router->addDirectiveHandler(audioBlockingHandler)); auto& audioAndVisualNonBlocking = m_directive_0_1; DirectiveHandlerConfiguration audioAndVisualNonBlockingHandlerConfig; audioAndVisualNonBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_1}] = BlockingPolicy(BlockingPolicy::MEDIUMS_AUDIO_AND_VISUAL, false); auto audioAndVisualNonBlockingHandler = MockDirectiveHandler::create(audioAndVisualNonBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(audioAndVisualNonBlockingHandler)); auto& visualBlockingDirective = m_directive_0_2; DirectiveHandlerConfiguration visualBlockingHandlerConfig; visualBlockingHandlerConfig[NamespaceAndName{NAMESPACE_AND_NAME_0_2}] = BlockingPolicy(BlockingPolicy::MEDIUM_VISUAL, true); auto visualBlockingHandler = MockDirectiveHandler::create(visualBlockingHandlerConfig); ASSERT_TRUE(m_router->addDirectiveHandler(visualBlockingHandler)); // Expect completion on all the directives. EXPECT_CALL(*(audioBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioBlockingHandler.get()), preHandleDirective(audioBlockingDirective, _)).Times(1); EXPECT_CALL(*(audioBlockingHandler.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(audioAndVisualNonBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(audioAndVisualNonBlockingHandler.get()), preHandleDirective(audioAndVisualNonBlocking, _)).Times(1); EXPECT_CALL(*(audioAndVisualNonBlockingHandler.get()), cancelDirective(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirectiveImmediately(_)).Times(0); EXPECT_CALL(*(visualBlockingHandler.get()), preHandleDirective(visualBlockingDirective, _)).Times(1); EXPECT_CALL(*(visualBlockingHandler.get()), cancelDirective(_)).Times(0); /* * Expect the third directive to be handled before the second, because it is neither blocked by the first one * - no common mediums. and nor by the second, queued directive, since the second is not a blocking directive. */ ::testing::Sequence s1; EXPECT_CALL(*(audioBlockingHandler.get()), handleDirective(MESSAGE_ID_0_0)).Times(1).InSequence(s1); EXPECT_CALL(*(visualBlockingHandler.get()), handleDirective(MESSAGE_ID_0_2)).Times(1).InSequence(s1); EXPECT_CALL(*(audioAndVisualNonBlockingHandler.get()), handleDirective(MESSAGE_ID_0_1)).Times(1).InSequence(s1); m_processor->setDialogRequestId(DIALOG_REQUEST_ID_0); ASSERT_TRUE(m_processor->onDirective(audioBlockingDirective)); audioBlockingHandler->waitUntilHandling(); ASSERT_TRUE(m_processor->onDirective(audioAndVisualNonBlocking)); ASSERT_TRUE(m_processor->onDirective(visualBlockingDirective)); // make sure audioAndVisualNonBlocking has been enqueued. audioAndVisualNonBlockingHandler->waitUntilPreHandling(); /* * visualBlockingDirective should be handled as it's not blocked by audioBlockingDirective and * audioAndVisualNonBlocking is not blocking. */ visualBlockingHandler->waitUntilHandling(); // Now, audioBlockingDirective can be completed. audioBlockingHandler->doHandlingCompleted(); audioAndVisualNonBlockingHandler->waitUntilCompleted(); visualBlockingHandler->waitUntilCompleted(); } } // namespace test } // namespace adsl } // namespace alexaClientSDK