| // Copyright 2020 The Cobalt Authors. 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. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License 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. |
| |
| #include "starboard/loader_app/slot_management.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include "gmock/gmock.h" |
| #include "starboard/configuration_constants.h" |
| #include "starboard/elf_loader/sabi_string.h" |
| #include "starboard/event.h" |
| #include "starboard/loader_app/app_key_files.h" |
| #include "starboard/loader_app/drain_file.h" |
| #include "starboard/loader_app/installation_manager.h" |
| #include "starboard/loader_app/installation_store.pb.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| #if SB_IS(EVERGREEN_COMPATIBLE) |
| |
| namespace starboard { |
| namespace loader_app { |
| namespace { |
| |
| const char kTestAppKey[] = "1234"; |
| const char kTestApp2Key[] = "ABCD"; |
| |
| void SbEventFake(const SbEvent*) {} |
| |
| const char* GetEvergreenSabiStringFake() { |
| return "bad"; |
| } |
| |
| const char* GetCobaltUserAgentStringFake() { |
| return ""; |
| } |
| |
| class MockLibraryLoader : public LibraryLoader { |
| public: |
| MOCK_METHOD4(Load, |
| bool(const std::string& library_path, |
| const std::string& content_path, |
| bool use_compression, |
| bool use_memory_mapped_file)); |
| MOCK_METHOD1(Resolve, void*(const std::string& symbol)); |
| }; |
| |
| class SlotManagementTest : public testing::TestWithParam<bool> { |
| protected: |
| virtual void SetUp() { |
| slot_0_libcobalt_path_ = |
| CreatePath({"content", "app", "cobalt", "lib", "libcobalt"}); |
| slot_0_content_path_ = CreatePath({"content", "app", "cobalt", "content"}); |
| slot_1_libcobalt_path_ = CreatePath({"installation_1", "lib", "libcobalt"}); |
| slot_1_content_path_ = CreatePath({"installation_1", "content"}); |
| slot_2_libcobalt_path_ = CreatePath({"installation_2", "lib", "libcobalt"}); |
| slot_2_content_path_ = CreatePath({"installation_2", "content"}); |
| |
| std::vector<char> buf(kSbFileMaxPath); |
| storage_path_implemented_ = SbSystemGetPath(kSbSystemPathStorageDirectory, |
| buf.data(), kSbFileMaxPath); |
| } |
| |
| void AddFileExtension(std::string& path) { |
| if (GetParam()) { |
| path += ".lz4"; |
| } else { |
| path += ".so"; |
| } |
| } |
| |
| std::string CreatePath(std::initializer_list<std::string> path_elements) { |
| std::string result; |
| for (const std::string& path : path_elements) { |
| result += kSbFileSepString; |
| result += path; |
| } |
| return result; |
| } |
| |
| void CreateBadFile(int index, const std::string& app_key) { |
| std::vector<char> installation_path(kSbFileMaxPath); |
| ASSERT_EQ(IM_SUCCESS, ImGetInstallationPath(index, installation_path.data(), |
| kSbFileMaxPath)); |
| std::string bad_app_key_file_path = |
| starboard::loader_app::GetBadAppKeyFilePath(installation_path.data(), |
| app_key); |
| ASSERT_TRUE(!bad_app_key_file_path.empty()); |
| ASSERT_TRUE(starboard::loader_app::CreateAppKeyFile(bad_app_key_file_path)); |
| } |
| |
| void CreateGoodFile(int index, const std::string& app_key) { |
| std::vector<char> installation_path(kSbFileMaxPath); |
| ASSERT_EQ(IM_SUCCESS, ImGetInstallationPath(index, installation_path.data(), |
| kSbFileMaxPath)); |
| std::string good_app_key_file_path = |
| starboard::loader_app::GetGoodAppKeyFilePath(installation_path.data(), |
| app_key); |
| ASSERT_TRUE(!good_app_key_file_path.empty()); |
| ASSERT_TRUE( |
| starboard::loader_app::CreateAppKeyFile(good_app_key_file_path)); |
| } |
| |
| void VerifyGoodFile(int index, const std::string& app_key, bool exists) { |
| std::vector<char> installation_path(kSbFileMaxPath); |
| ImGetInstallationPath(index, installation_path.data(), kSbFileMaxPath); |
| std::string good_app_key_file_path = |
| starboard::loader_app::GetGoodAppKeyFilePath(installation_path.data(), |
| app_key); |
| ASSERT_TRUE(!good_app_key_file_path.empty()); |
| ASSERT_EQ(exists, SbFileExists(good_app_key_file_path.c_str())); |
| } |
| |
| void VerifyBadFile(int index, const std::string& app_key, bool exists) { |
| std::vector<char> installation_path(kSbFileMaxPath); |
| ImGetInstallationPath(index, installation_path.data(), kSbFileMaxPath); |
| std::string bad_app_key_file_path = |
| starboard::loader_app::GetBadAppKeyFilePath(installation_path.data(), |
| app_key); |
| ASSERT_TRUE(!bad_app_key_file_path.empty()); |
| SB_LOG(INFO) << "bad_app_key_file_path=" << bad_app_key_file_path; |
| ASSERT_EQ(exists, SbFileExists(bad_app_key_file_path.c_str())); |
| } |
| |
| void CreateDrainFile(int index, const std::string& app_key) { |
| std::vector<char> installation_path(kSbFileMaxPath); |
| ASSERT_EQ(IM_SUCCESS, ImGetInstallationPath(index, installation_path.data(), |
| kSbFileMaxPath)); |
| ASSERT_TRUE(DrainFileTryDrain(installation_path.data(), app_key.c_str())); |
| } |
| |
| void VerifyLoad(const std::string& lib, const std::string& content) { |
| bool use_compression = GetParam(); |
| MockLibraryLoader library_loader; |
| |
| std::string full_lib_path = lib; |
| AddFileExtension(full_lib_path); |
| EXPECT_CALL(library_loader, |
| Load(testing::EndsWith(full_lib_path), |
| testing::EndsWith(content), use_compression, false)) |
| .Times(1) |
| .WillOnce(testing::Return(true)); |
| EXPECT_CALL(library_loader, Resolve("GetEvergreenSabiString")) |
| .Times(1) |
| .WillOnce( |
| testing::Return(reinterpret_cast<void*>(&GetEvergreenSabiString))); |
| EXPECT_CALL(library_loader, Resolve("GetCobaltUserAgentString")) |
| .Times(1) |
| .WillOnce(testing::Return( |
| reinterpret_cast<void*>(&GetCobaltUserAgentStringFake))); |
| EXPECT_CALL(library_loader, Resolve("SbEventHandle")) |
| .Times(1) |
| .WillOnce(testing::Return(reinterpret_cast<void*>(&SbEventFake))); |
| ASSERT_EQ(&SbEventFake, |
| LoadSlotManagedLibrary(kTestAppKey, "", &library_loader, |
| use_compression, false)); |
| } |
| |
| protected: |
| std::string slot_0_libcobalt_path_; |
| std::string slot_0_content_path_; |
| std::string slot_1_libcobalt_path_; |
| std::string slot_1_content_path_; |
| std::string slot_2_libcobalt_path_; |
| std::string slot_2_content_path_; |
| bool storage_path_implemented_; |
| }; |
| |
| TEST_P(SlotManagementTest, SystemSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ImUninitialize(); |
| VerifyLoad(slot_0_libcobalt_path_, slot_0_content_path_); |
| VerifyGoodFile(0, kTestAppKey, false); |
| VerifyBadFile(0, kTestAppKey, false); |
| } |
| |
| TEST_P(SlotManagementTest, AdoptSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(1)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(1)); |
| ASSERT_EQ(1, ImGetCurrentInstallationIndex()); |
| |
| VerifyGoodFile(1, kTestAppKey, false); |
| CreateGoodFile(1, kTestApp2Key); |
| ImUninitialize(); |
| VerifyLoad(slot_1_libcobalt_path_, slot_1_content_path_); |
| VerifyGoodFile(1, kTestAppKey, true); |
| VerifyBadFile(1, kTestAppKey, false); |
| } |
| |
| TEST_P(SlotManagementTest, GoodSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(2)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(2)); |
| ASSERT_EQ(2, ImGetCurrentInstallationIndex()); |
| |
| CreateGoodFile(2, kTestAppKey); |
| ImUninitialize(); |
| VerifyLoad(slot_2_libcobalt_path_, slot_2_content_path_); |
| VerifyGoodFile(2, kTestAppKey, true); |
| VerifyBadFile(2, kTestAppKey, false); |
| } |
| |
| TEST_P(SlotManagementTest, NotAdoptSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(2)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(2)); |
| ASSERT_EQ(2, ImGetCurrentInstallationIndex()); |
| |
| VerifyGoodFile(2, kTestAppKey, false); |
| ImUninitialize(); |
| VerifyLoad(slot_0_libcobalt_path_, slot_0_content_path_); |
| VerifyGoodFile(2, kTestAppKey, false); |
| VerifyBadFile(2, kTestAppKey, true); |
| } |
| |
| TEST_P(SlotManagementTest, BadSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(1)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(1)); |
| ASSERT_EQ(1, ImGetCurrentInstallationIndex()); |
| CreateBadFile(1, kTestAppKey); |
| ImUninitialize(); |
| VerifyLoad(slot_0_libcobalt_path_, slot_0_content_path_); |
| VerifyGoodFile(1, kTestAppKey, false); |
| } |
| |
| TEST_P(SlotManagementTest, DrainingSlot) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(1)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(1)); |
| ASSERT_EQ(1, ImGetCurrentInstallationIndex()); |
| CreateDrainFile(1, kTestApp2Key); |
| ImUninitialize(); |
| VerifyLoad(slot_0_libcobalt_path_, slot_0_content_path_); |
| VerifyGoodFile(1, kTestAppKey, false); |
| VerifyBadFile(1, kTestAppKey, false); |
| } |
| |
| TEST_P(SlotManagementTest, AlternativeContent) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(1)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(1)); |
| ASSERT_EQ(1, ImGetCurrentInstallationIndex()); |
| ImUninitialize(); |
| |
| MockLibraryLoader library_loader; |
| |
| std::string full_lib_path = slot_0_libcobalt_path_; |
| AddFileExtension(full_lib_path); |
| EXPECT_CALL(library_loader, |
| Load(testing::EndsWith(full_lib_path), testing::EndsWith("/foo"), |
| GetParam(), false)) |
| .Times(1) |
| .WillOnce(testing::Return(true)); |
| EXPECT_CALL(library_loader, Resolve("GetEvergreenSabiString")) |
| .Times(1) |
| .WillOnce( |
| testing::Return(reinterpret_cast<void*>(&GetEvergreenSabiString))); |
| |
| EXPECT_CALL(library_loader, Resolve("GetCobaltUserAgentString")) |
| .Times(1) |
| .WillOnce(testing::Return( |
| reinterpret_cast<void*>(&GetCobaltUserAgentStringFake))); |
| EXPECT_CALL(library_loader, Resolve("SbEventHandle")) |
| .Times(1) |
| .WillOnce(testing::Return(reinterpret_cast<void*>(&SbEventFake))); |
| ASSERT_EQ(&SbEventFake, |
| LoadSlotManagedLibrary(kTestAppKey, "/foo", &library_loader, |
| GetParam(), false)); |
| } |
| |
| TEST_P(SlotManagementTest, BadSabi) { |
| if (!storage_path_implemented_) { |
| return; |
| } |
| ImInitialize(3, kTestAppKey); |
| ImReset(); |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(1)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(1)); |
| ASSERT_EQ(1, ImGetCurrentInstallationIndex()); |
| CreateGoodFile(1, kTestAppKey); |
| |
| ASSERT_EQ(IM_SUCCESS, ImRollForward(2)); |
| ASSERT_EQ(IM_SUCCESS, ImMarkInstallationSuccessful(2)); |
| ASSERT_EQ(2, ImGetCurrentInstallationIndex()); |
| CreateGoodFile(2, kTestAppKey); |
| |
| ImUninitialize(); |
| |
| MockLibraryLoader library_loader; |
| |
| std::string slot2_libcobalt_full = slot_2_libcobalt_path_; |
| AddFileExtension(slot2_libcobalt_full); |
| EXPECT_CALL(library_loader, |
| Load(testing::EndsWith(slot2_libcobalt_full), |
| testing::EndsWith(slot_2_content_path_), GetParam(), false)) |
| .Times(1) |
| .WillOnce(testing::Return(true)); |
| |
| EXPECT_CALL(library_loader, Resolve("GetEvergreenSabiString")) |
| .Times(2) |
| .WillOnce( |
| testing::Return(reinterpret_cast<void*>(&GetEvergreenSabiStringFake))) |
| .WillOnce( |
| testing::Return(reinterpret_cast<void*>(&GetEvergreenSabiString))); |
| |
| std::string slot1_libcobalt_full = slot_1_libcobalt_path_; |
| AddFileExtension(slot1_libcobalt_full); |
| EXPECT_CALL(library_loader, |
| Load(testing::EndsWith(slot1_libcobalt_full), |
| testing::EndsWith(slot_1_content_path_), GetParam(), false)) |
| .Times(1) |
| .WillOnce(testing::Return(true)); |
| |
| EXPECT_CALL(library_loader, Resolve("GetCobaltUserAgentString")) |
| .Times(1) |
| .WillOnce(testing::Return( |
| reinterpret_cast<void*>(&GetCobaltUserAgentStringFake))); |
| |
| EXPECT_CALL(library_loader, Resolve("SbEventHandle")) |
| .Times(1) |
| .WillOnce(testing::Return(reinterpret_cast<void*>(&SbEventFake))); |
| |
| ASSERT_EQ(&SbEventFake, |
| LoadSlotManagedLibrary(kTestAppKey, "", &library_loader, GetParam(), |
| false)); |
| } |
| |
| INSTANTIATE_TEST_CASE_P(SlotManagementTests, |
| SlotManagementTest, |
| ::testing::Bool()); |
| |
| } // namespace |
| } // namespace loader_app |
| } // namespace starboard |
| #endif // #if SB_IS(EVERGREEN_COMPATIBLE) |
