diff options
Diffstat (limited to 'chromium/extensions/common/permissions/permission_message_test_util.cc')
| -rw-r--r-- | chromium/extensions/common/permissions/permission_message_test_util.cc | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/chromium/extensions/common/permissions/permission_message_test_util.cc b/chromium/extensions/common/permissions/permission_message_test_util.cc new file mode 100644 index 00000000000..d4ff6395e34 --- /dev/null +++ b/chromium/extensions/common/permissions/permission_message_test_util.cc @@ -0,0 +1,322 @@ +// 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 |