| // Copyright 2016 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fuchsia/modular/testing/cpp/fidl.h> |
| #include <fuchsia/testing/modular/cpp/fidl.h> |
| #include <lib/fidl/cpp/optional.h> |
| #include <lib/modular/testing/cpp/fake_agent.h> |
| |
| #include <gmock/gmock.h> |
| #include <src/modular/lib/modular_config/modular_config_constants.h> |
| |
| #include "src/lib/fsl/vmo/strings.h" |
| #include "src/modular/bin/sessionmgr/testing/annotations_matchers.h" |
| #include "src/modular/lib/modular_test_harness/cpp/fake_module.h" |
| #include "src/modular/lib/modular_test_harness/cpp/fake_session_shell.h" |
| #include "src/modular/lib/modular_test_harness/cpp/test_harness_fixture.h" |
| |
| #define TEST_NAME(SUFFIX) \ |
| std::string(::testing::UnitTest::GetInstance()->current_test_info()->name()) + "_" #SUFFIX; |
| |
| using fuchsia::modular::StoryInfo2; |
| using fuchsia::modular::StoryState; |
| using fuchsia::modular::StoryVisibilityState; |
| using fuchsia::modular::ViewIdentifier; |
| using testing::ByRef; |
| using testing::Pointee; |
| using testing::UnorderedElementsAre; |
| |
| namespace { |
| |
| class SessionShellTest : public modular_testing::TestHarnessFixture { |
| protected: |
| SessionShellTest() |
| : fake_session_shell_(modular_testing::FakeSessionShell::CreateWithDefaultOptions()), |
| fake_module_(modular_testing::FakeModule::CreateWithDefaultOptions()) {} |
| // Shared boilerplate for configuring the test harness to intercept the |
| // session shell, setting up the session shell mock object, running the test |
| // harness, and waiting for the session shell to be successfully intercepted. |
| // Note that this method blocks the thread until the session shell has started |
| // up. |
| // |
| // Not done in SetUp() or the constructor to let the test reader know that |
| // this is happening. Also, certain tests may want to change this flow. |
| void RunHarnessAndInterceptSessionShell() { |
| modular_testing::TestHarnessBuilder builder; |
| builder.InterceptSessionShell(fake_session_shell_->BuildInterceptOptions()); |
| builder.InterceptComponent(fake_module_->BuildInterceptOptions()); |
| builder.BuildAndRun(test_harness()); |
| |
| // Wait for our session shell to start. |
| RunLoopUntil([&] { return fake_session_shell_->is_running(); }); |
| } |
| |
| void RunFakeModule(const std::string& story_name) { |
| // Connect to PuppetMaster. |
| fuchsia::modular::testing::ModularService svc; |
| fuchsia::modular::PuppetMasterPtr puppet_master; |
| svc.set_puppet_master(puppet_master.NewRequest()); |
| test_harness()->ConnectToModularService(std::move(svc)); |
| |
| // Add the module to the story. |
| fuchsia::modular::Intent intent; |
| intent.handler = fake_module_->url(); |
| intent.action = "action"; |
| |
| modular_testing::AddModToStory(test_harness(), story_name, "modname", std::move(intent)); |
| |
| // Wait for the story and mod to start. |
| RunLoopUntil([&] { return fake_module_->is_running(); }); |
| } |
| |
| std::unique_ptr<modular_testing::FakeSessionShell> fake_session_shell_; |
| std::unique_ptr<modular_testing::FakeModule> fake_module_; |
| }; |
| |
| class TestComponent : public modular_testing::FakeComponent { |
| public: |
| // |on_created| is called when the component is launched. |on_destroyed| is called when the |
| // component is terminated. |
| TestComponent(fit::function<void()> on_created, fit::function<void()> on_destroyed) |
| : FakeComponent({.url = modular_testing::TestHarnessBuilder::GenerateFakeUrl(), |
| .sandbox_services = {"fuchsia.modular.SessionShellContext"}}), |
| on_created_(std::move(on_created)), |
| on_destroyed_(std::move(on_destroyed)) {} |
| |
| protected: |
| void OnCreate(fuchsia::sys::StartupInfo startup_info) override { on_created_(); } |
| |
| void OnDestroy() override { on_destroyed_(); } |
| |
| fit::function<void()> on_created_; |
| fit::function<void()> on_destroyed_; |
| }; |
| |
| TEST_F(SessionShellTest, RestartShell) { |
| modular_testing::TestHarnessBuilder builder; |
| |
| // Overriding OnDestroy() and OnCreate() to ensure that there isn't a race condition when |
| // verifying that the session_shell restarts properly. |
| bool stopped = false; |
| bool started = false; |
| |
| TestComponent session_shell([&] { started = true; }, [&] { stopped = true; }); |
| builder.InterceptSessionShell(session_shell.BuildInterceptOptions()); |
| builder.BuildAndRun(test_harness()); |
| |
| EXPECT_FALSE(session_shell.is_running()); |
| RunLoopUntil([&] { return session_shell.is_running(); }); |
| |
| started = false; |
| |
| fuchsia::modular::SessionShellContextPtr session_shell_context; |
| session_shell.component_context()->svc()->Connect(session_shell_context.NewRequest()); |
| session_shell_context->Restart(); |
| |
| RunLoopUntil([&] { return stopped; }); |
| |
| // Tests that the session shell is restarted after a call to SessionShellContext::Restart. |
| RunLoopUntil([&] { return started; }); |
| } |
| |
| TEST_F(SessionShellTest, GetStoryInfoNonexistentStory) { |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| bool tried_get_story_info = false; |
| story_provider->GetStoryInfo2("X", |
| [&tried_get_story_info](fuchsia::modular::StoryInfo2 story_info) { |
| EXPECT_TRUE(story_info.IsEmpty()); |
| tried_get_story_info = true; |
| }); |
| |
| RunLoopUntil([&] { return tried_get_story_info; }); |
| } |
| |
| TEST_F(SessionShellTest, GetStoriesEmpty) { |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| bool called_get_stories = false; |
| story_provider->GetStories2( |
| nullptr, [&called_get_stories](const std::vector<fuchsia::modular::StoryInfo2>& stories) { |
| EXPECT_THAT(stories, testing::IsEmpty()); |
| called_get_stories = true; |
| }); |
| |
| RunLoopUntil([&] { return called_get_stories; }); |
| } |
| |
| TEST_F(SessionShellTest, StartAndStopStoryWithExtraInfoMod) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Have the mock session_shell record the sequence of story states it sees, |
| // and confirm that it only sees the correct story id. |
| std::vector<StoryState> sequence_of_story_states; |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| watcher.set_on_change_2([&sequence_of_story_states](StoryInfo2 story_info, StoryState story_state, |
| StoryVisibilityState _) { |
| ASSERT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| sequence_of_story_states.push_back(story_state); |
| }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| // Start the story. |
| RunFakeModule(kStoryId); |
| |
| // Stop the story. Check that the story went through the correct sequence |
| // of states (see StoryState FIDL file for valid state transitions). Since we |
| // started it, ran it, and stopped it, the sequence is STOPPED -> RUNNING -> |
| // STOPPING -> STOPPED. |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(kStoryId, story_controller.NewRequest()); |
| |
| bool stop_called = false; |
| story_controller->Stop([&stop_called] { stop_called = true; }); |
| RunLoopUntil([&] { return stop_called; }); |
| |
| // Run the loop until there are the expected number of state changes; |
| // having called Stop() is not enough to guarantee seeing all updates. |
| RunLoopUntil([&] { return sequence_of_story_states.size() == 4; }); |
| EXPECT_THAT(sequence_of_story_states, |
| testing::ElementsAre(StoryState::STOPPED, StoryState::RUNNING, StoryState::STOPPING, |
| StoryState::STOPPED)); |
| } |
| |
| TEST_F(SessionShellTest, StoryInfoBeforeAndAfterDelete) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| // Connect to PuppetMaster. |
| fuchsia::modular::PuppetMasterPtr puppet_master; |
| fuchsia::modular::testing::ModularService svc; |
| svc.set_puppet_master(puppet_master.NewRequest()); |
| test_harness()->ConnectToModularService(std::move(svc)); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Start the story. |
| RunFakeModule(kStoryId); |
| |
| // Verify that the newly created story returns something for |
| // GetStoryInfo(). |
| bool get_story_info_called = false; |
| story_provider->GetStoryInfo2(kStoryId, |
| [&get_story_info_called](fuchsia::modular::StoryInfo2 story_info) { |
| ASSERT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| get_story_info_called = true; |
| }); |
| RunLoopUntil([&] { return get_story_info_called; }); |
| |
| // Delete the story and confirm that the story info is null now. |
| bool delete_called = false; |
| puppet_master->DeleteStory(kStoryId, [&delete_called, story_provider] { |
| story_provider->GetStoryInfo2(kStoryId, [](fuchsia::modular::StoryInfo2 story_info) { |
| EXPECT_TRUE(story_info.IsEmpty()); |
| }); |
| delete_called = true; |
| }); |
| RunLoopUntil([&] { return delete_called; }); |
| } |
| |
| TEST_F(SessionShellTest, DISABLED_AttachesAndDetachesView) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Have the mock session_shell record the sequence of story states it sees, |
| // and confirm that it only sees the correct story id. |
| std::vector<StoryState> sequence_of_story_states; |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| watcher.set_on_change_2([&sequence_of_story_states](StoryInfo2 story_info, StoryState story_state, |
| StoryVisibilityState _) { |
| EXPECT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| sequence_of_story_states.push_back(story_state); |
| }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| bool called_attach_view = false; |
| fake_session_shell_->set_on_attach_view( |
| [&called_attach_view](const ViewIdentifier& /*unused*/) { called_attach_view = true; }); |
| |
| bool called_detach_view = false; |
| fake_session_shell_->set_on_detach_view( |
| [&called_detach_view](const ViewIdentifier& /*unused*/) { called_detach_view = true; }); |
| |
| // Start the story and confirm that AttachView() was called. |
| RunFakeModule(kStoryId); |
| |
| RunLoopUntil([&] { return called_attach_view; }); |
| |
| // Stop the story. Confirm that: |
| // a. DetachView() was called. |
| // b. The story went through the correct sequence |
| // of states (see StoryState FIDL file for valid state transitions). Since we |
| // started it, ran it, and stopped it, the sequence is STOPPED -> RUNNING -> |
| // STOPPING -> STOPPED. |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(kStoryId, story_controller.NewRequest()); |
| |
| bool stop_called = false; |
| story_controller->Stop([&stop_called] { stop_called = true; }); |
| RunLoopUntil([&] { return stop_called; }); |
| |
| // Run the loop until there are the expected number of state changes; |
| // having called Stop() is not enough to guarantee seeing all updates. |
| RunLoopUntil([&] { return sequence_of_story_states.size() == 4; }); |
| EXPECT_TRUE(called_detach_view); |
| EXPECT_THAT(sequence_of_story_states, |
| testing::ElementsAre(StoryState::STOPPED, StoryState::RUNNING, StoryState::STOPPING, |
| StoryState::STOPPED)); |
| } |
| |
| TEST_F(SessionShellTest, DISABLED_StoryStopDoesntWaitOnDetachView) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Have the mock session_shell record the sequence of story states it sees, |
| // and confirm that it only sees the correct story id. |
| std::vector<StoryState> sequence_of_story_states; |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| watcher.set_on_change_2([&sequence_of_story_states](StoryInfo2 story_info, StoryState story_state, |
| StoryVisibilityState _) { |
| EXPECT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| sequence_of_story_states.push_back(story_state); |
| }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| bool called_attach_view = false; |
| fake_session_shell_->set_on_attach_view( |
| [&called_attach_view](const ViewIdentifier& /*unused*/) { called_attach_view = true; }); |
| |
| // Start the story and confirm that AttachView() was called. |
| RunFakeModule(kStoryId); |
| |
| RunLoopUntil([&] { return called_attach_view; }); |
| |
| // Stop the story. Confirm that: |
| // a. The story stopped, even though it didn't see the DetachView() response |
| // (it was artificially delayed for 1hr). |
| // b. The story went through the correct sequence of states (see StoryState |
| // FIDL file for valid state transitions). Since we started it, ran it, and |
| // stopped it, the sequence is STOPPED -> RUNNING -> STOPPING -> STOPPED. |
| fake_session_shell_->set_detach_delay(zx::sec(60 * 60)); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(kStoryId, story_controller.NewRequest()); |
| |
| bool stop_called = false; |
| story_controller->Stop([&stop_called] { stop_called = true; }); |
| RunLoopUntil([&] { return stop_called; }); |
| |
| // Run the loop until there are the expected number of state changes; |
| // having called Stop() is not enough to guarantee seeing all updates. |
| RunLoopUntil([&] { return sequence_of_story_states.size() == 4; }); |
| EXPECT_THAT(sequence_of_story_states, |
| testing::ElementsAre(StoryState::STOPPED, StoryState::RUNNING, StoryState::STOPPING, |
| StoryState::STOPPED)); |
| } |
| |
| TEST_F(SessionShellTest, GetStoryInfo2HasId) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Start the story. |
| RunFakeModule(kStoryId); |
| |
| // Verify that the newly created story returns something for |
| // GetStoryInfo2(). |
| bool get_story_info_called = false; |
| story_provider->GetStoryInfo2(kStoryId, |
| [&get_story_info_called](fuchsia::modular::StoryInfo2 story_info) { |
| ASSERT_FALSE(story_info.IsEmpty()); |
| EXPECT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| get_story_info_called = true; |
| }); |
| RunLoopUntil([&] { return get_story_info_called; }); |
| } |
| |
| TEST_F(SessionShellTest, GetStories2ReturnsStoryInfo) { |
| static constexpr char kStoryId[] = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_TRUE(story_provider != nullptr); |
| |
| // Start the story. |
| RunFakeModule(kStoryId); |
| |
| // Verify that GetStories2 returns the StoryInfo2 for the newly created story |
| bool get_stories_called = false; |
| story_provider->GetStories2( |
| /*watcher=*/nullptr, |
| [&get_stories_called](std::vector<fuchsia::modular::StoryInfo2> story_infos) { |
| ASSERT_FALSE(story_infos.empty()); |
| const auto& story_info = story_infos.at(0); |
| ASSERT_FALSE(story_info.IsEmpty()); |
| EXPECT_TRUE(story_info.has_id()); |
| EXPECT_EQ(story_info.id(), kStoryId); |
| get_stories_called = true; |
| }); |
| RunLoopUntil([&] { return get_stories_called; }); |
| } |
| |
| TEST_F(SessionShellTest, StoryProviderWatcher) { |
| static constexpr auto kStoryId = "my_story"; |
| |
| RunHarnessAndInterceptSessionShell(); |
| |
| // Connect to PuppetMaster. |
| fuchsia::modular::PuppetMasterPtr puppet_master; |
| fuchsia::modular::testing::ModularService svc; |
| svc.set_puppet_master(puppet_master.NewRequest()); |
| test_harness()->ConnectToModularService(std::move(svc)); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| ASSERT_NE(nullptr, story_provider); |
| |
| // Once the story is created, OnChange2 should be called with a StoryInfo2 that has the story ID. |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| std::vector<StoryInfo2> on_change_calls; |
| watcher.set_on_change_2( |
| [&](StoryInfo2 story_info, StoryState /* unused */, StoryVisibilityState /* unused */) { |
| on_change_calls.push_back(std::move(story_info)); |
| }); |
| std::vector<std::string> on_delete_calls; |
| watcher.set_on_delete([&](const std::string& story_id) { on_delete_calls.push_back(story_id); }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| // Start the story. |
| RunFakeModule(kStoryId); |
| |
| RunLoopUntil([&] { return !on_change_calls.empty(); }); |
| EXPECT_TRUE(on_change_calls.at(0).has_id()); |
| EXPECT_EQ(kStoryId, on_change_calls.at(0).id()); |
| |
| // Delete the story twice. Expect that we are notified only once. |
| EXPECT_TRUE(on_delete_calls.empty()); |
| int delete_story_count = 0; |
| puppet_master->DeleteStory(kStoryId, [&delete_story_count] { delete_story_count++; }); |
| puppet_master->DeleteStory(kStoryId, [&delete_story_count] { delete_story_count++; }); |
| RunLoopUntil([&] { return delete_story_count == 2; }); |
| EXPECT_EQ(2, delete_story_count); |
| |
| // In order to ensure that both DeleteStory() operations have completed, |
| // perform another operation that is enqueued after them and wait for it |
| // to return. |
| bool get_stories_done = false; |
| story_provider->GetStories2(nullptr, [&](auto /*ignored*/) { get_stories_done = true; }); |
| RunLoopUntil([&] { return get_stories_done; }); |
| |
| RunLoopUntil([&] { return !on_delete_calls.empty(); }); |
| EXPECT_EQ(1u, on_delete_calls.size()); |
| } |
| |
| TEST_F(SessionShellTest, StoryControllerAnnotate) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(story_name, story_controller.NewRequest()); |
| |
| // Create some annotations, one for each variant of AnnotationValue. |
| auto text_annotation_value = fuchsia::modular::AnnotationValue{}; |
| text_annotation_value.set_text("text_value"); |
| auto text_annotation = fuchsia::modular::Annotation{ |
| .key = "text_key", .value = fidl::MakeOptional(fidl::Clone(text_annotation_value))}; |
| |
| auto bytes_annotation_value = fuchsia::modular::AnnotationValue{}; |
| bytes_annotation_value.set_bytes({0x01, 0x02, 0x03, 0x04}); |
| auto bytes_annotation = fuchsia::modular::Annotation{ |
| .key = "bytes_key", .value = fidl::MakeOptional(fidl::Clone(bytes_annotation_value))}; |
| |
| fuchsia::mem::Buffer buffer{}; |
| std::string buffer_value = "buffer_value"; |
| ASSERT_TRUE(fsl::VmoFromString(buffer_value, &buffer)); |
| auto buffer_annotation_value = fuchsia::modular::AnnotationValue{}; |
| buffer_annotation_value.set_buffer(std::move(buffer)); |
| auto buffer_annotation = fuchsia::modular::Annotation{ |
| .key = "buffer_key", .value = fidl::MakeOptional(fidl::Clone(buffer_annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(fidl::Clone(text_annotation)); |
| annotations.push_back(fidl::Clone(bytes_annotation)); |
| annotations.push_back(fidl::Clone(buffer_annotation)); |
| |
| // Annotate the story. |
| bool done_annotating{false}; |
| story_controller->Annotate(std::move(annotations), |
| [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()); |
| done_annotating = true; |
| }); |
| RunLoopUntil([&] { return done_annotating; }); |
| |
| // GetStoryInfo should contain the annotations. |
| fuchsia::modular::StoryInfo2 story_info; |
| bool done_getting_story_info = false; |
| |
| story_provider->GetStoryInfo2(story_name, [&](fuchsia::modular::StoryInfo2 data) { |
| done_getting_story_info = true; |
| story_info = std::move(data); |
| }); |
| RunLoopUntil([&] { return done_getting_story_info; }); |
| |
| EXPECT_FALSE(story_info.IsEmpty()); |
| EXPECT_TRUE(story_info.has_annotations()); |
| |
| EXPECT_EQ(3u, story_info.annotations().size()); |
| |
| EXPECT_THAT( |
| story_info.mutable_annotations(), |
| Pointee(UnorderedElementsAre(modular::annotations::AnnotationEq(ByRef(text_annotation)), |
| modular::annotations::AnnotationEq(ByRef(bytes_annotation)), |
| modular::annotations::AnnotationEq(ByRef(buffer_annotation))))); |
| } |
| |
| // Verifies that Annotate merges new annotations, preserving existing ones. |
| TEST_F(SessionShellTest, StoryControllerAnnotateMerge) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(story_name, story_controller.NewRequest()); |
| |
| // Create the initial set of annotations. |
| auto first_annotation_value = fuchsia::modular::AnnotationValue{}; |
| first_annotation_value.set_text("first_value"); |
| auto first_annotation = fuchsia::modular::Annotation{ |
| .key = "first_key", .value = fidl::MakeOptional(fidl::Clone(first_annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(fidl::Clone(first_annotation)); |
| |
| // Annotate the story. |
| bool done{false}; |
| story_controller->Annotate(std::move(annotations), |
| [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| |
| // GetStoryData should contain the first annotation. |
| done = false; |
| story_provider->GetStoryInfo2(story_name, [&](fuchsia::modular::StoryInfo2 story_info) { |
| EXPECT_FALSE(story_info.IsEmpty()); |
| EXPECT_TRUE(story_info.has_annotations()); |
| |
| EXPECT_EQ(1u, story_info.annotations().size()); |
| |
| EXPECT_EQ(story_info.annotations().at(0).key, first_annotation.key); |
| EXPECT_EQ(story_info.annotations().at(0).value->text(), first_annotation_value.text()); |
| |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| |
| // Create another set of annotations that should be merged into the initial one. |
| auto second_annotation_value = fuchsia::modular::AnnotationValue{}; |
| second_annotation_value.set_text("second_value"); |
| auto second_annotation = fuchsia::modular::Annotation{ |
| .key = "second_key", .value = fidl::MakeOptional(fidl::Clone(second_annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations_2; |
| annotations_2.push_back(fidl::Clone(second_annotation)); |
| |
| // Annotate the story with the second set of annotations. |
| done = false; |
| story_controller->Annotate(std::move(annotations_2), |
| [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| |
| // GetStoryData should now return annotations from both the first and second set. |
| done = false; |
| story_provider->GetStoryInfo2(story_name, [&](fuchsia::modular::StoryInfo2 story_info) { |
| EXPECT_FALSE(story_info.IsEmpty()); |
| |
| EXPECT_EQ(2u, story_info.annotations().size()); |
| |
| EXPECT_THAT(story_info.mutable_annotations(), |
| Pointee(UnorderedElementsAre( |
| modular::annotations::AnnotationEq(ByRef(first_annotation)), |
| modular::annotations::AnnotationEq(ByRef(second_annotation))))); |
| |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| } |
| |
| // Verifies that StoryController.Annotate returns an error when one of the annotations |
| // has a buffer value that exceeds MAX_ANNOTATION_VALUE_BUFFER_LENGTH_BYTES. |
| TEST_F(SessionShellTest, StoryControllerAnnotateBufferValueTooBig) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(story_name, story_controller.NewRequest()); |
| |
| // Create an annotation with a large buffer value. |
| fuchsia::mem::Buffer buffer{}; |
| std::string buffer_value(fuchsia::modular::MAX_ANNOTATION_VALUE_BUFFER_LENGTH_BYTES + 1, 'x'); |
| ASSERT_TRUE(fsl::VmoFromString(buffer_value, &buffer)); |
| |
| auto annotation_value = fuchsia::modular::AnnotationValue{}; |
| annotation_value.set_buffer(std::move(buffer)); |
| auto annotation = fuchsia::modular::Annotation{ |
| .key = "buffer_key", .value = fidl::MakeOptional(std::move(annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(std::move(annotation)); |
| |
| // Annotate the story. |
| bool done{false}; |
| story_controller->Annotate( |
| std::move(annotations), [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_TRUE(result.is_err()); |
| EXPECT_EQ(fuchsia::modular::AnnotationError::VALUE_TOO_BIG, result.err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| } |
| |
| // Verifies that StoryPuppetMaster.Annotate returns an error when one of the annotations |
| // has a buffer value that exceeds MAX_ANNOTATION_VALUE_BUFFER_LENGTH_BYTES. |
| TEST_F(SessionShellTest, StoryPuppetMasterAnnotateBufferValueTooBig) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| // Connect to StoryPuppetMaster. |
| fuchsia::modular::testing::ModularService svc; |
| fuchsia::modular::PuppetMasterPtr puppet_master; |
| svc.set_puppet_master(puppet_master.NewRequest()); |
| test_harness()->ConnectToModularService(std::move(svc)); |
| |
| fuchsia::modular::StoryPuppetMasterPtr story_puppet_master; |
| puppet_master->ControlStory(story_name, story_puppet_master.NewRequest()); |
| |
| // Create an annotation with a large buffer value. |
| fuchsia::mem::Buffer buffer{}; |
| std::string buffer_value(fuchsia::modular::MAX_ANNOTATION_VALUE_BUFFER_LENGTH_BYTES + 1, 'x'); |
| ASSERT_TRUE(fsl::VmoFromString(buffer_value, &buffer)); |
| |
| auto annotation_value = fuchsia::modular::AnnotationValue{}; |
| annotation_value.set_buffer(std::move(buffer)); |
| auto annotation = fuchsia::modular::Annotation{ |
| .key = "buffer_key", .value = fidl::MakeOptional(std::move(annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(std::move(annotation)); |
| |
| // Annotate the story. |
| bool done{false}; |
| story_puppet_master->Annotate( |
| std::move(annotations), [&](fuchsia::modular::StoryPuppetMaster_Annotate_Result result) { |
| EXPECT_TRUE(result.is_err()); |
| EXPECT_EQ(fuchsia::modular::AnnotationError::VALUE_TOO_BIG, result.err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| } |
| |
| // Verifies that Annotate returns an error when adding new annotations to exceeds |
| // MAX_ANNOTATIONS_PER_STORY. |
| TEST_F(SessionShellTest, StoryControllerAnnotateTooMany) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(story_name, story_controller.NewRequest()); |
| |
| // A single Annotate call should not accept more annotations than allowed on a single story. |
| ASSERT_GE(fuchsia::modular::MAX_ANNOTATIONS_PER_STORY, |
| fuchsia::modular::MAX_ANNOTATIONS_PER_UPDATE); |
| |
| // Annotate the story repeatedly, in batches of MAX_ANNOTATIONS_PER_UPDATE items, in order |
| // to reach, but not exceed the MAX_ANNOTATIONS_PER_STORY limit. |
| for (unsigned int num_annotate_calls = 0; |
| num_annotate_calls < |
| fuchsia::modular::MAX_ANNOTATIONS_PER_STORY / fuchsia::modular::MAX_ANNOTATIONS_PER_UPDATE; |
| ++num_annotate_calls) { |
| std::vector<fuchsia::modular::Annotation> annotations; |
| |
| // Create MAX_ANNOTATIONS_PER_UPDATE annotations for each call to Annotate. |
| for (unsigned int num_annotations = 0; |
| num_annotations < fuchsia::modular::MAX_ANNOTATIONS_PER_UPDATE; ++num_annotations) { |
| auto annotation_value = fuchsia::modular::AnnotationValue{}; |
| annotation_value.set_text("test_annotation_value"); |
| auto annotation = |
| fuchsia::modular::Annotation{.key = "annotation_" + std::to_string(num_annotate_calls) + |
| "_" + std::to_string(num_annotations), |
| .value = fidl::MakeOptional(std::move(annotation_value))}; |
| annotations.push_back(std::move(annotation)); |
| } |
| |
| // Annotate the story. |
| bool done{false}; |
| story_controller->Annotate( |
| std::move(annotations), [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()) |
| << "Annotate call #" << num_annotate_calls << " returned an error when trying to add " |
| << std::to_string(fuchsia::modular::MAX_ANNOTATIONS_PER_UPDATE) |
| << " annotations to the story."; |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| } |
| |
| // Create some more annotations for a total of (MAX_ANNOTATIONS_PER_STORY + 1) on the story. |
| std::vector<fuchsia::modular::Annotation> annotations; |
| |
| for (unsigned int num_annotations = 0; |
| num_annotations < (fuchsia::modular::MAX_ANNOTATIONS_PER_STORY % |
| fuchsia::modular::MAX_ANNOTATIONS_PER_UPDATE) + |
| 1; |
| ++num_annotations) { |
| auto annotation_value = fuchsia::modular::AnnotationValue{}; |
| annotation_value.set_text("test_annotation_value"); |
| auto annotation = |
| fuchsia::modular::Annotation{.key = "excess_annotation_" + std::to_string(num_annotations), |
| .value = fidl::MakeOptional(std::move(annotation_value))}; |
| annotations.push_back(std::move(annotation)); |
| } |
| |
| // Annotate the story. |
| bool done{false}; |
| story_controller->Annotate( |
| std::move(annotations), [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_TRUE(result.is_err()); |
| EXPECT_EQ(fuchsia::modular::AnnotationError::TOO_MANY_ANNOTATIONS, result.err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| } |
| |
| // Verifies that a call to StoryController.Annotate results in a StoryProviderWatcher.OnChange2 |
| // being called with the updated annotations. |
| TEST_F(SessionShellTest, StoryControllerAnnotateNotifiesWatcher) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| fuchsia::modular::StoryControllerPtr story_controller; |
| story_provider->GetController(story_name, story_controller.NewRequest()); |
| |
| // Watch the story for new annotations. |
| auto num_on_change_2_calls = 0; |
| auto num_annotations = 0; |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| watcher.set_on_change_2( |
| [&num_on_change_2_calls, &num_annotations](StoryInfo2 story_info, StoryState /*unused*/, |
| StoryVisibilityState /*unused*/) { |
| num_on_change_2_calls++; |
| num_annotations = story_info.mutable_annotations()->size(); |
| }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| // Create a set of annotations, containing a single annotation. |
| auto first_annotation_value = fuchsia::modular::AnnotationValue{}; |
| first_annotation_value.set_text("first_value"); |
| auto first_annotation = fuchsia::modular::Annotation{ |
| .key = "first_key", .value = fidl::MakeOptional(fidl::Clone(first_annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(fidl::Clone(first_annotation)); |
| |
| // Annotate the story. |
| bool done{false}; |
| story_controller->Annotate(std::move(annotations), |
| [&](fuchsia::modular::StoryController_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| |
| RunLoopUntil([&] { return num_on_change_2_calls > 0; }); |
| EXPECT_EQ(1, num_annotations); |
| } |
| |
| // Verifies that a call to StoryPuppetMaster.Annotate results in a StoryProviderWatcher.OnChange2 |
| // being called with the updated annotations. |
| TEST_F(SessionShellTest, StoryPuppetMasterAnnotateNotifiesWatcher) { |
| const auto story_name = TEST_NAME(story); |
| |
| RunHarnessAndInterceptSessionShell(); |
| RunFakeModule(story_name); |
| |
| fuchsia::modular::StoryProvider* story_provider = fake_session_shell_->story_provider(); |
| |
| // Connect to StoryPuppetMaster. |
| fuchsia::modular::testing::ModularService svc; |
| fuchsia::modular::PuppetMasterPtr puppet_master; |
| svc.set_puppet_master(puppet_master.NewRequest()); |
| test_harness()->ConnectToModularService(std::move(svc)); |
| |
| fuchsia::modular::StoryPuppetMasterPtr story_puppet_master; |
| puppet_master->ControlStory(story_name, story_puppet_master.NewRequest()); |
| |
| // Watch the story for new annotations. |
| auto num_on_change_2_calls = 0; |
| auto num_annotations = 0; |
| modular_testing::SimpleStoryProviderWatcher watcher; |
| watcher.set_on_change_2( |
| [&num_on_change_2_calls, &num_annotations](StoryInfo2 story_info, StoryState /*unused*/, |
| StoryVisibilityState /*unused*/) { |
| num_on_change_2_calls++; |
| num_annotations = story_info.mutable_annotations()->size(); |
| }); |
| watcher.Watch(story_provider, /*on_get_stories=*/nullptr); |
| |
| // Create a set of annotations, containing a single annotation. |
| auto first_annotation_value = fuchsia::modular::AnnotationValue{}; |
| first_annotation_value.set_text("first_value"); |
| auto first_annotation = fuchsia::modular::Annotation{ |
| .key = "first_key", .value = fidl::MakeOptional(fidl::Clone(first_annotation_value))}; |
| |
| std::vector<fuchsia::modular::Annotation> annotations; |
| annotations.push_back(fidl::Clone(first_annotation)); |
| |
| // Annotate the story. |
| bool done{false}; |
| story_puppet_master->Annotate(std::move(annotations), |
| [&](fuchsia::modular::StoryPuppetMaster_Annotate_Result result) { |
| EXPECT_FALSE(result.is_err()); |
| done = true; |
| }); |
| RunLoopUntil([&] { return done; }); |
| |
| RunLoopUntil([&] { return num_on_change_2_calls > 0; }); |
| EXPECT_EQ(1, num_annotations); |
| } |
| |
| class ServicePublishingSessionShell : public modular_testing::FakeSessionShell { |
| public: |
| explicit ServicePublishingSessionShell(modular_testing::FakeComponent::Args args) |
| : FakeSessionShell(std::move(args)) {} |
| |
| static std::unique_ptr<ServicePublishingSessionShell> CreateWithDefaultOptions() { |
| return std::make_unique<ServicePublishingSessionShell>(modular_testing::FakeComponent::Args{ |
| .url = modular_testing::TestHarnessBuilder::GenerateFakeUrl(), |
| .sandbox_services = FakeSessionShell::GetDefaultSandboxServices()}); |
| } |
| |
| int fake_service_connect_count() const { return fake_service_connect_count_; } |
| |
| protected: |
| void OnCreate(fuchsia::sys::StartupInfo startup_info) override { |
| FakeSessionShell::OnCreate(std::move(startup_info)); |
| component_context()->outgoing()->AddPublicService( |
| fit::function<void(fidl::InterfaceRequest<fuchsia::testing::modular::TestProtocol>)>( |
| [this](fidl::InterfaceRequest<fuchsia::testing::modular::TestProtocol> request) { |
| ++fake_service_connect_count_; |
| service_channels_.push_back(request.TakeChannel()); |
| })); |
| } |
| |
| std::vector<zx::channel> service_channels_; |
| int fake_service_connect_count_ = 0; |
| }; |
| |
| // Show that the session shell can publish a service that is accessible to agents |
| // via the agent_service_index. |
| TEST_F(SessionShellTest, SessionShellCanPublishServicesToAgents) { |
| auto session_shell = ServicePublishingSessionShell::CreateWithDefaultOptions(); |
| auto agent = modular_testing::FakeAgent::CreateWithDefaultOptions(); |
| |
| fuchsia::modular::testing::TestHarnessSpec spec; |
| std::vector<fuchsia::modular::session::AgentServiceIndexEntry> agent_service_index; |
| fuchsia::modular::session::AgentServiceIndexEntry agent_service; |
| agent_service.set_service_name(fuchsia::testing::modular::TestProtocol::Name_); |
| agent_service.set_agent_url(session_shell->url()); |
| agent_service_index.emplace_back(std::move(agent_service)); |
| |
| spec.mutable_sessionmgr_config()->set_agent_service_index(std::move(agent_service_index)); |
| spec.mutable_sessionmgr_config()->set_session_agents({agent->url()}); |
| |
| modular_testing::TestHarnessBuilder builder(std::move(spec)); |
| builder.InterceptSessionShell(session_shell->BuildInterceptOptions()); |
| auto agent_intercept_options = agent->BuildInterceptOptions(); |
| agent_intercept_options.sandbox_services.push_back( |
| fuchsia::testing::modular::TestProtocol::Name_); |
| builder.InterceptComponent(std::move(agent_intercept_options)); |
| builder.BuildAndRun(test_harness()); |
| |
| RunLoopUntil([&] { return session_shell->is_running() && agent->is_running(); }); |
| |
| auto service_ptr = |
| agent->component_context()->svc()->Connect<fuchsia::testing::modular::TestProtocol>(); |
| service_ptr.set_error_handler( |
| [](zx_status_t status) { FX_PLOGS(FATAL, status) << "channel should not have closed"; }); |
| |
| RunLoopUntil([&] { return session_shell->fake_service_connect_count() > 0; }); |
| EXPECT_EQ(1, session_shell->fake_service_connect_count()); |
| service_ptr.set_error_handler(nullptr); |
| } |
| |
| } // namespace |
