permission_set_mojom_traits_unittest.cc 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "extensions/common/mojom/permission_set_mojom_traits.h"
  5. #include "extensions/common/manifest_handler.h"
  6. #include "extensions/common/mojom/permission_set.mojom.h"
  7. #include "extensions/common/permissions/api_permission_set.h"
  8. #include "extensions/common/permissions/mock_manifest_permission.h"
  9. #include "extensions/common/permissions/permissions_info.h"
  10. #include "extensions/common/scoped_testing_manifest_handler_registry.h"
  11. #include "mojo/public/cpp/test_support/test_utils.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace extensions {
  14. using mojo::test::SerializeAndDeserialize;
  15. class MockManifestHandler : public ManifestHandler {
  16. public:
  17. MockManifestHandler() {}
  18. MockManifestHandler(const MockManifestHandler&) = delete;
  19. MockManifestHandler& operator=(const MockManifestHandler&) = delete;
  20. ~MockManifestHandler() override {}
  21. bool Parse(Extension* extension, std::u16string* error) override {
  22. return true;
  23. }
  24. ManifestPermission* CreatePermission() override {
  25. return new MockManifestPermission("mock_keys::key");
  26. }
  27. base::span<const char* const> Keys() const override {
  28. static constexpr const char* kKeys[] = {"mock_keys::key"};
  29. return kKeys;
  30. }
  31. };
  32. TEST(PermissionSetMojomTraitsTest, BasicAPIPermission) {
  33. const APIPermissionInfo* permission_info =
  34. PermissionsInfo::GetInstance()->GetByID(mojom::APIPermissionID::kSocket);
  35. std::unique_ptr<APIPermission> input = permission_info->CreateAPIPermission();
  36. {
  37. base::Value value(base::Value::Type::LIST);
  38. value.Append("tcp-connect:*.example.com:80");
  39. value.Append("udp-bind::8080");
  40. value.Append("udp-send-to::8888");
  41. ASSERT_TRUE(
  42. input->FromValue(&base::Value::AsListValue(value), nullptr, nullptr));
  43. }
  44. std::unique_ptr<APIPermission> output = nullptr;
  45. EXPECT_TRUE(
  46. SerializeAndDeserialize<extensions::mojom::APIPermission>(input, output));
  47. EXPECT_TRUE(input->Equal(output.get()));
  48. }
  49. TEST(PermissionSetMojomTraitsTest, BasicAPIPermissionSet) {
  50. const APIPermissionInfo* permission_info =
  51. PermissionsInfo::GetInstance()->GetByID(mojom::APIPermissionID::kSocket);
  52. std::unique_ptr<APIPermission> permission =
  53. permission_info->CreateAPIPermission();
  54. {
  55. base::Value value(base::Value::Type::LIST);
  56. value.Append("tcp-connect:*.example.com:80");
  57. value.Append("udp-bind::8080");
  58. value.Append("udp-send-to::8888");
  59. ASSERT_TRUE(permission->FromValue(&base::Value::AsListValue(value), nullptr,
  60. nullptr));
  61. }
  62. APIPermissionSet input;
  63. input.insert(mojom::APIPermissionID::kAudioCapture);
  64. input.insert(mojom::APIPermissionID::kDns);
  65. input.insert(mojom::APIPermissionID::kHid);
  66. input.insert(mojom::APIPermissionID::kPower);
  67. input.insert(mojom::APIPermissionID::kSerial);
  68. input.insert(std::move(permission));
  69. APIPermissionSet output;
  70. EXPECT_TRUE(SerializeAndDeserialize<extensions::mojom::APIPermissionSet>(
  71. input, output));
  72. EXPECT_EQ(input, output);
  73. }
  74. TEST(PermissionSetMojomTraitsTest, BasicManifestPermission) {
  75. ScopedTestingManifestHandlerRegistry scoped_registry;
  76. ManifestHandlerRegistry::Get()->RegisterHandler(
  77. std::make_unique<MockManifestHandler>());
  78. ManifestHandler::FinalizeRegistration();
  79. std::unique_ptr<extensions::ManifestPermission> input(
  80. extensions::ManifestHandler::CreatePermission("mock_keys::key"));
  81. ASSERT_TRUE(input);
  82. base::Value value("value");
  83. input->FromValue(&value);
  84. std::unique_ptr<extensions::ManifestPermission> output = nullptr;
  85. EXPECT_TRUE(SerializeAndDeserialize<extensions::mojom::ManifestPermission>(
  86. input, output));
  87. EXPECT_EQ(input->id(), output->id());
  88. EXPECT_TRUE(input->Equal(output.get()));
  89. }
  90. TEST(PermissionSetMojomTraitsTest, BasicManifestPermissionSet) {
  91. ScopedTestingManifestHandlerRegistry scoped_registry;
  92. ManifestHandlerRegistry::Get()->RegisterHandler(
  93. std::make_unique<MockManifestHandler>());
  94. ManifestHandler::FinalizeRegistration();
  95. std::unique_ptr<extensions::ManifestPermission> permission1(
  96. extensions::ManifestHandler::CreatePermission("mock_keys::key"));
  97. std::unique_ptr<extensions::ManifestPermission> permission2(
  98. extensions::ManifestHandler::CreatePermission("mock_keys::key"));
  99. base::Value value("value");
  100. permission2->FromValue(&value);
  101. ManifestPermissionSet input;
  102. input.insert(std::move(permission1));
  103. input.insert(std::move(permission2));
  104. ManifestPermissionSet output;
  105. EXPECT_TRUE(SerializeAndDeserialize<extensions::mojom::ManifestPermissionSet>(
  106. input, output));
  107. EXPECT_EQ(input, output);
  108. }
  109. TEST(PermissionSetMojomTraitsTest, BasicPermissionSet) {
  110. const APIPermissionInfo* permission_info =
  111. PermissionsInfo::GetInstance()->GetByID(mojom::APIPermissionID::kSocket);
  112. std::unique_ptr<APIPermission> permission =
  113. permission_info->CreateAPIPermission();
  114. {
  115. base::Value value(base::Value::Type::LIST);
  116. value.Append("tcp-connect:*.example.com:80");
  117. value.Append("udp-bind::8080");
  118. value.Append("udp-send-to::8888");
  119. ASSERT_TRUE(permission->FromValue(&base::Value::AsListValue(value), nullptr,
  120. nullptr));
  121. }
  122. APIPermissionSet apis;
  123. apis.insert(mojom::APIPermissionID::kAudioCapture);
  124. apis.insert(mojom::APIPermissionID::kDns);
  125. apis.insert(std::move(permission));
  126. ScopedTestingManifestHandlerRegistry scoped_registry;
  127. ManifestHandlerRegistry::Get()->RegisterHandler(
  128. std::make_unique<MockManifestHandler>());
  129. ManifestHandler::FinalizeRegistration();
  130. std::unique_ptr<extensions::ManifestPermission> permission1(
  131. extensions::ManifestHandler::CreatePermission("mock_keys::key"));
  132. std::unique_ptr<extensions::ManifestPermission> permission2(
  133. extensions::ManifestHandler::CreatePermission("mock_keys::key"));
  134. {
  135. base::Value value("value");
  136. permission2->FromValue(&value);
  137. }
  138. ManifestPermissionSet manifest_permissions;
  139. manifest_permissions.insert(std::move(permission1));
  140. manifest_permissions.insert(std::move(permission2));
  141. URLPattern pattern1(URLPattern::SCHEME_ALL);
  142. EXPECT_EQ(URLPattern::ParseResult::kSuccess,
  143. pattern1.Parse("http://*.foo:1234/bar"))
  144. << "Got unexpected error in the URLPattern parsing";
  145. URLPattern pattern2(URLPattern::SCHEME_HTTPS);
  146. EXPECT_EQ(URLPattern::ParseResult::kSuccess,
  147. pattern2.Parse("https://www.google.com/foobar"))
  148. << "Got unexpected error in the URLPattern parsing";
  149. URLPatternSet hosts;
  150. hosts.AddPattern(pattern1);
  151. hosts.AddPattern(pattern2);
  152. URLPattern pattern3(URLPattern::SCHEME_HTTP);
  153. EXPECT_EQ(URLPattern::ParseResult::kSuccess,
  154. pattern3.Parse("http://127.0.0.1/*"))
  155. << "Got unexpected error in the URLPattern parsing";
  156. URLPatternSet user_script_hosts;
  157. user_script_hosts.AddPattern(pattern3);
  158. PermissionSet input(std::move(apis), std::move(manifest_permissions),
  159. std::move(hosts), std::move(user_script_hosts));
  160. PermissionSet output;
  161. EXPECT_TRUE(
  162. SerializeAndDeserialize<extensions::mojom::PermissionSet>(input, output));
  163. EXPECT_EQ(input, output);
  164. }
  165. } // namespace extensions