[Android] Implement GetRuleIterator for channels provider

chrome/browser/notifications/notification_channels_provider_android_unittest.cc

 // Copyright 2017 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 "chrome/browser/notifications/notification_channels_provider_android.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/content_settings/core/browser/content_settings_pref.h"
+#include "components/content_settings/core/browser/content_settings_rule.h"
+#include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using ::testing::Return;
 
 namespace {
 const char kTestOrigin[] = "https://example.com/";
 }  // namespace
 
 class MockNotificationChannelsBridge
     : public NotificationChannelsProviderAndroid::NotificationChannelsBridge {
  public:
   ~MockNotificationChannelsBridge() = default;
   MOCK_METHOD0(ShouldUseChannelSettings, bool());
   MOCK_METHOD2(CreateChannel, void(const std::string&, bool));
   MOCK_METHOD1(GetChannelStatus, NotificationChannelStatus(const std::string&));
   MOCK_METHOD1(DeleteChannel, void(const std::string&));
+  MOCK_METHOD0(GetChannels, std::vector<Channel>());
 };
 
 class NotificationChannelsProviderAndroidTest : public testing::Test {
  public:
   NotificationChannelsProviderAndroidTest()
       : mock_bridge_(new MockNotificationChannelsBridge()) {}
   ~NotificationChannelsProviderAndroidTest() {
     channels_provider_->ShutdownOnUIThread();
   }
 
@@ skipping 83 matching lines @@
 TEST_F(NotificationChannelsProviderAndroidTest,
        SetWebsiteSettingDefault_DeletesChannelAndReturnsTrue) {
   InitChannelsProvider(true /* should_use_channels */);
   EXPECT_CALL(*mock_bridge_, DeleteChannel(kTestOrigin));
   bool result = channels_provider_->SetWebsiteSetting(
       ContentSettingsPattern::FromString(kTestOrigin), ContentSettingsPattern(),
       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(), nullptr);
 
   EXPECT_TRUE(result);
 }
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenChannelsShouldNotBeUsed_ReturnsNull) {
+  InitChannelsProvider(false /* should_use_channels */);
+  EXPECT_FALSE(channels_provider_->GetRuleIterator(
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(),
+      false /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorForIncognito_ReturnsNull) {
+  InitChannelsProvider(true /* should_use_channels */);
+  EXPECT_FALSE(
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), true /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenNoChannelsExist_ReturnsNull) {
+  InitChannelsProvider(true /* should_use_channels */);
+  EXPECT_CALL(*mock_bridge_, GetChannels());
+  EXPECT_FALSE(channels_provider_->GetRuleIterator(
+      CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string(),
+      false /* incognito */));
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenOneBlockedChannelExists) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<Channel> channels;
+  channels.push_back(
+      {.origin = kTestOrigin, .status = NotificationChannelStatus::BLOCKED});

[Peter Beverloo, 2017/06/02 15:14:26]

style nit: this is C-ish struct syntax that we don't really use. More idiomatic
would be:

channels.emplace_back(kTestOrigin, NotificationChannelStatus::BLOCKED);

(If you were to give it a constructor.)

[awdf, 2017/06/02 16:59:48]

Done.

+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule rule = result->Next();
+  EXPECT_EQ(rule.primary_pattern,
+            ContentSettingsPattern::FromString(kTestOrigin));
+  EXPECT_EQ(content_settings::ValueToContentSetting(rule.value.get()),
+            CONTENT_SETTING_BLOCK);
+  EXPECT_FALSE(result->HasNext());
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenOneAllowedChannelExists) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<Channel> channels;
+  channels.push_back(
+      {.origin = kTestOrigin, .status = NotificationChannelStatus::ENABLED});
+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule rule = result->Next();
+  EXPECT_EQ(rule.primary_pattern,
+            ContentSettingsPattern::FromString(kTestOrigin));
+  EXPECT_EQ(content_settings::ValueToContentSetting(rule.value.get()),
+            CONTENT_SETTING_ALLOW);
+  EXPECT_FALSE(result->HasNext());
+}
+
+TEST_F(NotificationChannelsProviderAndroidTest,
+       GetRuleIteratorWhenMultipleChannelsExist) {
+  InitChannelsProvider(true /* should_use_channels */);
+  std::vector<Channel> channels;
+  channels.push_back({.origin = "https://abc.com",
+                      .status = NotificationChannelStatus::ENABLED});
+  channels.push_back({.origin = "https://xyz.com",
+                      .status = NotificationChannelStatus::BLOCKED});
+  EXPECT_CALL(*mock_bridge_, GetChannels()).WillOnce(Return(channels));
+  std::unique_ptr<content_settings::RuleIterator> result =
+      channels_provider_->GetRuleIterator(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+                                          std::string(), false /* incognito */);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule first_rule = result->Next();
+  EXPECT_EQ(first_rule.primary_pattern,
+            ContentSettingsPattern::FromString("https://abc.com"));
+  EXPECT_EQ(content_settings::ValueToContentSetting(first_rule.value.get()),
+            CONTENT_SETTING_ALLOW);
+  EXPECT_TRUE(result->HasNext());
+  content_settings::Rule second_rule = result->Next();
+  EXPECT_EQ(second_rule.primary_pattern,
+            ContentSettingsPattern::FromString("https://xyz.com"));
+  EXPECT_EQ(content_settings::ValueToContentSetting(second_rule.value.get()),
+            CONTENT_SETTING_BLOCK);
+  EXPECT_FALSE(result->HasNext());
+}