| // Copyright 2015 The Chromium 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 "extensions/common/permissions/permission_message_test_util.h" |
| |
| #include <stddef.h> |
| |
| #include <algorithm> |
| #include <iterator> |
| |
| #include "base/strings/string_split.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "extensions/common/permissions/permission_message_provider.h" |
| #include "extensions/common/permissions/permissions_data.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| PermissionMessages GetMessages(const PermissionSet& permissions, |
| Manifest::Type extension_type) { |
| const PermissionMessageProvider* provider = PermissionMessageProvider::Get(); |
| return provider->GetPermissionMessages( |
| provider->GetAllPermissionIDs(permissions, extension_type)); |
| } |
| |
| std::vector<base::string16> MakeVectorString16(const base::string16& str) { |
| return std::vector<base::string16>(1, str); |
| } |
| |
| std::vector<base::string16> MakeVectorString16(const base::string16& str1, |
| const base::string16& str2) { |
| std::vector<base::string16> result; |
| result.push_back(str1); |
| result.push_back(str2); |
| return result; |
| } |
| |
| std::vector<base::string16> MakeVectorString16(const std::string& str1, |
| const std::string& str2) { |
| return MakeVectorString16(base::UTF8ToUTF16(str1), base::UTF8ToUTF16(str2)); |
| } |
| |
| std::vector<base::string16> MakeVectorString16( |
| const std::vector<std::string>& vec) { |
| std::vector<base::string16> result; |
| for (const std::string& msg : vec) |
| result.push_back(base::UTF8ToUTF16(msg)); |
| return result; |
| } |
| |
| std::vector<std::vector<base::string16>> MakeVectorVectorString16( |
| const std::vector<base::string16>& vec) { |
| return std::vector<std::vector<base::string16>>(1, vec); |
| } |
| |
| std::vector<std::vector<base::string16>> MakeVectorVectorString16( |
| const std::vector<std::vector<std::string>>& vecs) { |
| std::vector<std::vector<base::string16>> result; |
| for (const std::vector<std::string>& vec : vecs) |
| result.push_back(MakeVectorString16(vec)); |
| return result; |
| } |
| |
| // Returns the vector of messages concatenated into a single string, separated |
| // by newlines, e.g.: "Bar"\n"Baz"\n |
| base::string16 MessagesVectorToString( |
| const std::vector<base::string16>& messages) { |
| if (messages.empty()) |
| return base::ASCIIToUTF16("\n"); |
| return base::ASCIIToUTF16("\"") + |
| base::JoinString(messages, base::ASCIIToUTF16("\"\n\"")) + |
| base::ASCIIToUTF16("\"\n"); |
| } |
| |
| base::string16 MessagesToString(const PermissionMessages& messages) { |
| std::vector<base::string16> messages_vec; |
| for (const PermissionMessage& msg : messages) |
| messages_vec.push_back(msg.message()); |
| return MessagesVectorToString(messages_vec); |
| } |
| |
| bool CheckThatSubmessagesMatch( |
| const base::string16& message, |
| const std::vector<base::string16>& expected_submessages, |
| const std::vector<base::string16>& actual_submessages) { |
| bool result = true; |
| |
| std::vector<base::string16> expected_sorted(expected_submessages); |
| std::sort(expected_sorted.begin(), expected_sorted.end()); |
| |
| std::vector<base::string16> actual_sorted(actual_submessages); |
| std::sort(actual_sorted.begin(), actual_sorted.end()); |
| if (expected_sorted != actual_sorted) { |
| // This is always a failure, even within an EXPECT_FALSE. |
| // Message: Expected submessages for "Message" to be { "Foo" }, but got |
| // { "Bar", "Baz" } |
| ADD_FAILURE() << "Expected submessages for \"" << message << "\" to be:\n" |
| << MessagesVectorToString(expected_sorted) << "But got:\n" |
| << MessagesVectorToString(actual_sorted); |
| result = false; |
| } |
| |
| return result; |
| } |
| |
| testing::AssertionResult VerifyHasPermissionMessageImpl( |
| const base::string16& expected_message, |
| const std::vector<base::string16>& expected_submessages, |
| const PermissionMessages& actual_messages) { |
| auto message_it = |
| std::find_if(actual_messages.begin(), actual_messages.end(), |
| [&expected_message](const PermissionMessage& msg) { |
| return msg.message() == expected_message; |
| }); |
| bool found = message_it != actual_messages.end(); |
| if (!found) { |
| // Message: Expected messages to contain "Foo", but got { "Bar", "Baz" } |
| return testing::AssertionFailure() << "Expected messages to contain \"" |
| << expected_message << "\", but got " |
| << MessagesToString(actual_messages); |
| } |
| |
| if (!CheckThatSubmessagesMatch(expected_message, expected_submessages, |
| message_it->submessages())) { |
| return testing::AssertionFailure(); |
| } |
| |
| // Message: Expected messages NOT to contain "Foo", but got { "Bar", "Baz" } |
| return testing::AssertionSuccess() << "Expected messages NOT to contain \"" |
| << expected_message << "\", but got " |
| << MessagesToString(actual_messages); |
| } |
| |
| testing::AssertionResult VerifyPermissionMessagesWithSubmessagesImpl( |
| const std::vector<base::string16>& expected_messages, |
| const std::vector<std::vector<base::string16>>& expected_submessages, |
| const PermissionMessages& actual_messages, |
| bool check_order) { |
| CHECK_EQ(expected_messages.size(), expected_submessages.size()); |
| if (expected_messages.size() != actual_messages.size()) { |
| // Message: Expected 2 messages { "Bar", "Baz" }, but got 0 {} |
| return testing::AssertionFailure() |
| << "Expected " << expected_messages.size() << " messages:\n" |
| << MessagesVectorToString(expected_messages) << "But got " |
| << actual_messages.size() << " messages:\n" |
| << MessagesToString(actual_messages); |
| } |
| |
| if (check_order) { |
| auto it = actual_messages.begin(); |
| for (size_t i = 0; i < expected_messages.size(); i++, ++it) { |
| const PermissionMessage& actual_message = *it; |
| if (expected_messages[i] != actual_message.message()) { |
| // Message: Expected messages to be { "Foo" }, but got { "Bar", "Baz" } |
| return testing::AssertionFailure() |
| << "Expected messages to be:\n" |
| << MessagesVectorToString(expected_messages) << "But got:\n" |
| << MessagesToString(actual_messages); |
| } |
| |
| if (!CheckThatSubmessagesMatch(expected_messages[i], |
| expected_submessages[i], |
| actual_message.submessages())) { |
| return testing::AssertionFailure(); |
| } |
| } |
| } else { |
| for (size_t i = 0; i < expected_messages.size(); i++) { |
| testing::AssertionResult result = VerifyHasPermissionMessageImpl( |
| expected_messages[i], expected_submessages[i], actual_messages); |
| if (!result) |
| return result; |
| } |
| } |
| return testing::AssertionSuccess(); |
| } |
| |
| } // namespace |
| |
| testing::AssertionResult VerifyHasPermissionMessage( |
| const PermissionsData* permissions_data, |
| const std::string& expected_message) { |
| return VerifyHasPermissionMessage(permissions_data, |
| base::UTF8ToUTF16(expected_message)); |
| } |
| |
| testing::AssertionResult VerifyHasPermissionMessage( |
| const PermissionsData* permissions_data, |
| const base::string16& expected_message) { |
| return VerifyHasPermissionMessageImpl( |
| expected_message, std::vector<base::string16>(), |
| permissions_data->GetPermissionMessages()); |
| } |
| |
| testing::AssertionResult VerifyHasPermissionMessage( |
| const PermissionSet& permissions, |
| Manifest::Type extension_type, |
| const std::string& expected_message) { |
| return VerifyHasPermissionMessage(permissions, extension_type, |
| base::UTF8ToUTF16(expected_message)); |
| } |
| |
| testing::AssertionResult VerifyHasPermissionMessage( |
| const PermissionSet& permissions, |
| Manifest::Type extension_type, |
| const base::string16& expected_message) { |
| return VerifyHasPermissionMessageImpl( |
| expected_message, std::vector<base::string16>(), |
| GetMessages(permissions, extension_type)); |
| } |
| |
| testing::AssertionResult VerifyNoPermissionMessages( |
| const PermissionsData* permissions_data) { |
| return VerifyPermissionMessages(permissions_data, |
| std::vector<base::string16>(), true); |
| } |
| |
| testing::AssertionResult VerifyOnePermissionMessage( |
| const PermissionsData* permissions_data, |
| const std::string& expected_message) { |
| return VerifyOnePermissionMessage(permissions_data, |
| base::UTF8ToUTF16(expected_message)); |
| } |
| |
| testing::AssertionResult VerifyOnePermissionMessage( |
| const PermissionsData* permissions_data, |
| const base::string16& expected_message) { |
| return VerifyPermissionMessages(permissions_data, |
| MakeVectorString16(expected_message), true); |
| } |
| |
| testing::AssertionResult VerifyOnePermissionMessage( |
| const PermissionSet& permissions, |
| Manifest::Type extension_type, |
| const base::string16& expected_message) { |
| return VerifyPermissionMessagesWithSubmessagesImpl( |
| MakeVectorString16(expected_message), |
| std::vector<std::vector<base::string16>>(1), |
| GetMessages(permissions, extension_type), true); |
| } |
| |
| testing::AssertionResult VerifyOnePermissionMessageWithSubmessages( |
| const PermissionsData* permissions_data, |
| const std::string& expected_message, |
| const std::vector<std::string>& expected_submessages) { |
| return VerifyOnePermissionMessageWithSubmessages( |
| permissions_data, base::UTF8ToUTF16(expected_message), |
| MakeVectorString16(expected_submessages)); |
| } |
| |
| testing::AssertionResult VerifyOnePermissionMessageWithSubmessages( |
| const PermissionsData* permissions_data, |
| const base::string16& expected_message, |
| const std::vector<base::string16>& expected_submessages) { |
| return VerifyPermissionMessagesWithSubmessages( |
| permissions_data, MakeVectorString16(expected_message), |
| MakeVectorVectorString16(expected_submessages), true); |
| } |
| |
| testing::AssertionResult VerifyTwoPermissionMessages( |
| const PermissionsData* permissions_data, |
| const std::string& expected_message_1, |
| const std::string& expected_message_2, |
| bool check_order) { |
| return VerifyPermissionMessages( |
| permissions_data, |
| MakeVectorString16(expected_message_1, expected_message_2), check_order); |
| } |
| |
| testing::AssertionResult VerifyTwoPermissionMessages( |
| const PermissionsData* permissions_data, |
| const base::string16& expected_message_1, |
| const base::string16& expected_message_2, |
| bool check_order) { |
| return VerifyPermissionMessages( |
| permissions_data, |
| MakeVectorString16(expected_message_1, expected_message_2), check_order); |
| } |
| |
| testing::AssertionResult VerifyPermissionMessages( |
| const PermissionsData* permissions_data, |
| const std::vector<std::string>& expected_messages, |
| bool check_order) { |
| return VerifyPermissionMessages( |
| permissions_data, MakeVectorString16(expected_messages), check_order); |
| } |
| |
| testing::AssertionResult VerifyPermissionMessages( |
| const PermissionsData* permissions_data, |
| const std::vector<base::string16>& expected_messages, |
| bool check_order) { |
| return VerifyPermissionMessagesWithSubmessages( |
| permissions_data, expected_messages, |
| std::vector<std::vector<base::string16>>(expected_messages.size()), |
| check_order); |
| } |
| |
| testing::AssertionResult VerifyPermissionMessagesWithSubmessages( |
| const PermissionsData* permissions_data, |
| const std::vector<std::string>& expected_messages, |
| const std::vector<std::vector<std::string>>& expected_submessages, |
| bool check_order) { |
| return VerifyPermissionMessagesWithSubmessages( |
| permissions_data, MakeVectorString16(expected_messages), |
| MakeVectorVectorString16(expected_submessages), check_order); |
| } |
| |
| testing::AssertionResult VerifyPermissionMessagesWithSubmessages( |
| const PermissionsData* permissions_data, |
| const std::vector<base::string16>& expected_messages, |
| const std::vector<std::vector<base::string16>>& expected_submessages, |
| bool check_order) { |
| CHECK_EQ(expected_messages.size(), expected_submessages.size()); |
| return VerifyPermissionMessagesWithSubmessagesImpl( |
| expected_messages, expected_submessages, |
| permissions_data->GetPermissionMessages(), check_order); |
| } |
| |
| } // namespace extensions |