components/permissions/permission_request_queue_unittest.cc

   1 // Copyright 2022 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stddef.h>
   6 #include <memory>
   7 #include <string>
   8
   9 #include "base/command_line.h"
  10 #include "base/functional/bind.h"
  11 #include "base/test/scoped_feature_list.h"
  12 #include "build/build_config.h"
  13 #include "components/permissions/features.h"
  14 #include "components/permissions/permission_request.h"
  15 #include "components/permissions/permission_request_queue.h"
  16 #include "components/permissions/permission_util.h"
  17 #include "components/permissions/request_type.h"
  18 #include "components/permissions/test/mock_permission_prompt_factory.h"
  19 #include "components/permissions/test/mock_permission_request.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace permissions {
  23
  24 class PermissionRequestQueueTest : public ::testing::Test {
  25  public:
  26   PermissionRequestQueueTest()
  27       : request_low1_(RequestType::kGeolocation,
  28                       PermissionRequestGestureType::GESTURE),
  29         request_low2_(RequestType::kNotifications,
  30                       PermissionRequestGestureType::NO_GESTURE),
  31         request_normal1_(RequestType::kMultipleDownloads,
  32                          PermissionRequestGestureType::GESTURE),
  33         request_normal2_(RequestType::kClipboard,
  34                          PermissionRequestGestureType::NO_GESTURE),
  35         request_pepc1_(RequestType::kCameraStream,
  36                        /*embedded_permission_element_initiated=*/true),
  37         request_pepc2_(RequestType::kGeolocation,
  38                        /*embedded_permission_element_initiated=*/true) {}
  39
  40  protected:
  41   PermissionRequestQueue permission_request_queue_;
  42   MockPermissionRequest request_low1_;
  43   MockPermissionRequest request_low2_;
  44   MockPermissionRequest request_normal1_;
  45   MockPermissionRequest request_normal2_;
  46   MockPermissionRequest request_pepc1_;
  47   MockPermissionRequest request_pepc2_;
  48   base::test::ScopedFeatureList feature_list_;
  49 };
  50
  51 TEST_F(PermissionRequestQueueTest, CountNumberOfRequestsInQueue) {
  52   EXPECT_EQ(0ul, permission_request_queue_.size());
  53
  54   permission_request_queue_.Push(&request_normal1_);
  55   permission_request_queue_.Push(&request_normal2_);
  56   EXPECT_EQ(2ul, permission_request_queue_.size());
  57
  58   permission_request_queue_.Pop();
  59   EXPECT_EQ(1ul, permission_request_queue_.size());
  60 }
  61
  62 TEST_F(PermissionRequestQueueTest, CountDuplicateRequests) {
  63   EXPECT_EQ(0ul, permission_request_queue_.size());
  64
  65   permission_request_queue_.Push(&request_normal1_);
  66   permission_request_queue_.Push(&request_normal1_);
  67   EXPECT_EQ(2ul, permission_request_queue_.size());
  68 }
  69
  70 TEST_F(PermissionRequestQueueTest, CountNumberOfRequestOccurencesInQueue) {
  71   EXPECT_EQ(0ul, permission_request_queue_.Count(&request_normal1_));
  72
  73   permission_request_queue_.Push(&request_normal1_);
  74   permission_request_queue_.Push(&request_normal1_);
  75   permission_request_queue_.Push(&request_normal2_);
  76
  77   EXPECT_EQ(2ul, permission_request_queue_.Count(&request_normal1_));
  78 }
  79
  80 TEST_F(PermissionRequestQueueTest, OnlyEmptyWithoutRequests) {
  81   EXPECT_TRUE(permission_request_queue_.IsEmpty());
  82
  83   permission_request_queue_.Push(&request_normal1_);
  84   EXPECT_FALSE(permission_request_queue_.IsEmpty());
  85
  86   permission_request_queue_.Pop();
  87   EXPECT_TRUE(permission_request_queue_.IsEmpty());
  88 }
  89
  90 TEST_F(PermissionRequestQueueTest, ShouldFindDuplicateRequest) {
  91   permission_request_queue_.Push(&request_normal1_);
  92   permission_request_queue_.Push(&request_normal2_);
  93
  94   EXPECT_EQ(&request_normal2_,
  95             permission_request_queue_.FindDuplicate(&request_normal2_));
  96 }
  97
  98 TEST_F(PermissionRequestQueueTest, ShouldNotFindDuplicateIfNotPresent) {
  99   permission_request_queue_.Push(&request_normal1_);
 100
 101   EXPECT_EQ(nullptr,
 102             permission_request_queue_.FindDuplicate(&request_normal2_));
 103 }
 104
 105 TEST_F(PermissionRequestQueueTest, PeekedElementIsNextPoppedElement) {
 106   permission_request_queue_.Push(&request_normal1_);
 107   permission_request_queue_.Push(&request_normal2_);
 108   PermissionRequest* peekedElement = permission_request_queue_.Peek();
 109
 110   EXPECT_EQ(peekedElement, permission_request_queue_.Pop());
 111 }
 112
 113 TEST_F(PermissionRequestQueueTest, VerifyPushOrder) {
 114   permission_request_queue_.Push(&request_normal1_);
 115   permission_request_queue_.Push(&request_normal2_);
 116   permission_request_queue_.Push(&request_normal2_);
 117
 118   if (!PermissionUtil::DoesPlatformSupportChip()) {
 119     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 120     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 121     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 122   } else {
 123     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 124     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 125     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 126   }
 127 }
 128
 129 TEST_F(PermissionRequestQueueTest, VerifyPushOrderLowPriority) {
 130   permission_request_queue_.Push(&request_low1_);
 131   permission_request_queue_.Push(&request_normal1_);
 132   permission_request_queue_.Push(&request_low2_);
 133   permission_request_queue_.Push(&request_normal2_);
 134
 135   if (PermissionUtil::DoesPlatformSupportChip()) {
 136     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 137     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 138     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 139     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 140   } else {
 141     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 142     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 143     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 144     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 145   }
 146 }
 147
 148 TEST_F(PermissionRequestQueueTest, VerifyPushFrontOrder) {
 149   permission_request_queue_.PushFront(&request_pepc1_);
 150   permission_request_queue_.PushFront(&request_low1_);
 151   permission_request_queue_.PushFront(&request_normal1_);
 152   permission_request_queue_.PushFront(&request_normal2_);
 153   permission_request_queue_.PushFront(&request_low2_);
 154
 155   if (PermissionUtil::DoesPlatformSupportChip()) {
 156     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 157     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 158     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 159     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 160     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 161   } else {
 162     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 163     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 164     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 165     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 166     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 167   }
 168 }
 169
 170 TEST_F(PermissionRequestQueueTest, VerifyPushBackOrder) {
 171   permission_request_queue_.PushBack(&request_low1_);
 172   permission_request_queue_.PushBack(&request_pepc1_);
 173   permission_request_queue_.PushBack(&request_normal1_);
 174   permission_request_queue_.PushBack(&request_normal2_);
 175   permission_request_queue_.PushBack(&request_low2_);
 176   permission_request_queue_.PushBack(&request_pepc2_);
 177
 178   if (PermissionUtil::DoesPlatformSupportChip()) {
 179     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 180     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc2_);
 181     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 182     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 183     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 184     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 185   } else {
 186     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 187     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc2_);
 188     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 189     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 190     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal2_);
 191     EXPECT_EQ(permission_request_queue_.Pop(), &request_low2_);
 192   }
 193 }
 194
 195 TEST_F(PermissionRequestQueueTest, PEPCPushesOtherRequests) {
 196   permission_request_queue_.Push(&request_low1_);
 197   permission_request_queue_.Push(&request_normal1_);
 198   permission_request_queue_.Push(&request_pepc1_);
 199
 200   if (PermissionUtil::DoesPlatformSupportChip()) {
 201     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 202     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 203     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 204   } else {
 205     EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 206     EXPECT_EQ(permission_request_queue_.Pop(), &request_low1_);
 207     EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 208   }
 209 }
 210
 211 TEST_F(PermissionRequestQueueTest, PEPCNotPushedByOtherRequests) {
 212   permission_request_queue_.Push(&request_pepc1_);
 213   permission_request_queue_.Push(&request_normal1_);
 214
 215   EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 216   EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 217 }
 218
 219 TEST_F(PermissionRequestQueueTest, PEPCDoesNotPushOtherPEPCRequests) {
 220   permission_request_queue_.Push(&request_pepc1_);
 221   permission_request_queue_.Push(&request_normal1_);
 222   permission_request_queue_.Push(&request_pepc2_);
 223
 224   EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc1_);
 225   EXPECT_EQ(permission_request_queue_.Pop(), &request_pepc2_);
 226   EXPECT_EQ(permission_request_queue_.Pop(), &request_normal1_);
 227 }
 228
 229 }  // namespace permissions