1 // Copyright 2013 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 5 #include "base/cancelable_callback.h" 6 #include "base/command_line.h" 7 #include "base/memory/scoped_ptr.h" 8 #include "base/run_loop.h" 9 #include "base/strings/stringprintf.h" 10 #include "base/synchronization/waitable_event.h" 11 #include "base/test/simple_test_clock.h" 12 #include "base/test/test_timeouts.h" 13 #include "chrome/browser/extensions/activity_log/activity_log.h" 14 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h" 15 #include "chrome/browser/extensions/extension_service.h" 16 #include "chrome/browser/extensions/test_extension_system.h" 17 #include "chrome/common/chrome_constants.h" 18 #include "chrome/common/chrome_switches.h" 19 #include "chrome/test/base/chrome_render_view_host_test_harness.h" 20 #include "chrome/test/base/testing_profile.h" 21 #include "content/public/test/test_browser_thread_bundle.h" 22 #include "extensions/common/extension_builder.h" 23 #include "sql/statement.h" 24 #include "testing/gtest/include/gtest/gtest.h" 25 26 #if defined(OS_CHROMEOS) 27 #include "chrome/browser/chromeos/login/users/user_manager.h" 28 #include "chrome/browser/chromeos/settings/cros_settings.h" 29 #include "chrome/browser/chromeos/settings/device_settings_service.h" 30 #endif 31 32 using content::BrowserThread; 33 34 namespace extensions { 35 36 class FullStreamUIPolicyTest : public testing::Test { 37 public: 38 FullStreamUIPolicyTest() 39 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 40 saved_cmdline_(CommandLine::NO_PROGRAM) { 41 #if defined OS_CHROMEOS 42 test_user_manager_.reset(new chromeos::ScopedTestUserManager()); 43 #endif 44 CommandLine command_line(CommandLine::NO_PROGRAM); 45 saved_cmdline_ = *CommandLine::ForCurrentProcess(); 46 profile_.reset(new TestingProfile()); 47 CommandLine::ForCurrentProcess()->AppendSwitch( 48 switches::kEnableExtensionActivityLogging); 49 CommandLine::ForCurrentProcess()->AppendSwitch( 50 switches::kEnableExtensionActivityLogTesting); 51 extension_service_ = static_cast<TestExtensionSystem*>( 52 ExtensionSystem::Get(profile_.get()))->CreateExtensionService 53 (&command_line, base::FilePath(), false); 54 } 55 56 virtual ~FullStreamUIPolicyTest() { 57 #if defined OS_CHROMEOS 58 test_user_manager_.reset(); 59 #endif 60 base::RunLoop().RunUntilIdle(); 61 profile_.reset(NULL); 62 base::RunLoop().RunUntilIdle(); 63 // Restore the original command line and undo the affects of SetUp(). 64 *CommandLine::ForCurrentProcess() = saved_cmdline_; 65 } 66 67 // A wrapper function for CheckReadFilteredData, so that we don't need to 68 // enter empty string values for parameters we don't care about. 69 void CheckReadData( 70 ActivityLogDatabasePolicy* policy, 71 const std::string& extension_id, 72 int day, 73 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 74 CheckReadFilteredData( 75 policy, extension_id, Action::ACTION_ANY, "", "", "", day, checker); 76 } 77 78 // A helper function to call ReadFilteredData on a policy object and wait for 79 // the results to be processed. 80 void CheckReadFilteredData( 81 ActivityLogDatabasePolicy* policy, 82 const std::string& extension_id, 83 const Action::ActionType type, 84 const std::string& api_name, 85 const std::string& page_url, 86 const std::string& arg_url, 87 const int days_ago, 88 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 89 // Submit a request to the policy to read back some data, and call the 90 // checker function when results are available. This will happen on the 91 // database thread. 92 policy->ReadFilteredData( 93 extension_id, 94 type, 95 api_name, 96 page_url, 97 arg_url, 98 days_ago, 99 base::Bind(&FullStreamUIPolicyTest::CheckWrapper, 100 checker, 101 base::MessageLoop::current()->QuitClosure())); 102 103 // Set up a timeout for receiving results; if we haven't received anything 104 // when the timeout triggers then assume that the test is broken. 105 base::CancelableClosure timeout( 106 base::Bind(&FullStreamUIPolicyTest::TimeoutCallback)); 107 base::MessageLoop::current()->PostDelayedTask( 108 FROM_HERE, timeout.callback(), TestTimeouts::action_timeout()); 109 110 // Wait for results; either the checker or the timeout callbacks should 111 // cause the main loop to exit. 112 base::MessageLoop::current()->Run(); 113 114 timeout.Cancel(); 115 } 116 117 static void CheckWrapper( 118 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker, 119 const base::Closure& done, 120 scoped_ptr<Action::ActionVector> results) { 121 checker.Run(results.Pass()); 122 done.Run(); 123 } 124 125 static void TimeoutCallback() { 126 base::MessageLoop::current()->QuitWhenIdle(); 127 FAIL() << "Policy test timed out waiting for results"; 128 } 129 130 static void RetrieveActions_LogAndFetchActions( 131 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 132 ASSERT_EQ(2, static_cast<int>(i->size())); 133 } 134 135 static void RetrieveActions_FetchFilteredActions0( 136 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 137 ASSERT_EQ(0, static_cast<int>(i->size())); 138 } 139 140 static void RetrieveActions_FetchFilteredActions1( 141 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 142 ASSERT_EQ(1, static_cast<int>(i->size())); 143 } 144 145 static void RetrieveActions_FetchFilteredActions2( 146 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 147 ASSERT_EQ(2, static_cast<int>(i->size())); 148 } 149 150 static void RetrieveActions_FetchFilteredActions300( 151 scoped_ptr<std::vector<scoped_refptr<Action> > > i) { 152 ASSERT_EQ(300, static_cast<int>(i->size())); 153 } 154 155 static void Arguments_Present(scoped_ptr<Action::ActionVector> i) { 156 scoped_refptr<Action> last = i->front(); 157 CheckAction(*last, "odlameecjipmbmbejkplpemijjgpljce", 158 Action::ACTION_API_CALL, "extension.connect", 159 "[\"hello\",\"world\"]", "", "", ""); 160 } 161 162 static void Arguments_GetTodaysActions( 163 scoped_ptr<Action::ActionVector> actions) { 164 ASSERT_EQ(2, static_cast<int>(actions->size())); 165 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 166 "[\"vamoose\"]", "http://www.google.com/", "Page Title", 167 "http://www.arg-url.com/"); 168 CheckAction(*actions->at(1), "punky", Action::ACTION_API_CALL, "brewster", 169 "[\"woof\"]", "", "Page Title", "http://www.arg-url.com/"); 170 } 171 172 static void Arguments_GetOlderActions( 173 scoped_ptr<Action::ActionVector> actions) { 174 ASSERT_EQ(2, static_cast<int>(actions->size())); 175 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 176 "[\"vamoose\"]", "http://www.google.com/", "", ""); 177 CheckAction(*actions->at(1), "punky", Action::ACTION_API_CALL, "brewster", 178 "[\"woof\"]", "", "", ""); 179 } 180 181 static void AllURLsRemoved(scoped_ptr<Action::ActionVector> actions) { 182 ASSERT_EQ(2, static_cast<int>(actions->size())); 183 CheckAction(*actions->at(0), "punky", Action::ACTION_API_CALL, "lets", 184 "[\"vamoose\"]", "", "", ""); 185 CheckAction(*actions->at(1), "punky", Action::ACTION_DOM_ACCESS, "lets", 186 "[\"vamoose\"]", "", "", ""); 187 } 188 189 static void SomeURLsRemoved(scoped_ptr<Action::ActionVector> actions) { 190 // These will be in the vector in reverse time order. 191 ASSERT_EQ(5, static_cast<int>(actions->size())); 192 CheckAction(*actions->at(0), "punky", Action::ACTION_DOM_ACCESS, "lets", 193 "[\"vamoose\"]", "http://www.google.com/", "Google", 194 "http://www.args-url.com/"); 195 CheckAction(*actions->at(1), "punky", Action::ACTION_DOM_ACCESS, "lets", 196 "[\"vamoose\"]", "http://www.google.com/", "Google", ""); 197 CheckAction(*actions->at(2), "punky", Action::ACTION_DOM_ACCESS, "lets", 198 "[\"vamoose\"]", "", "", ""); 199 CheckAction(*actions->at(3), "punky", Action::ACTION_DOM_ACCESS, "lets", 200 "[\"vamoose\"]", "", "", "http://www.google.com/"); 201 CheckAction(*actions->at(4), "punky", Action::ACTION_DOM_ACCESS, "lets", 202 "[\"vamoose\"]", "", "", ""); 203 } 204 205 static void CheckAction(const Action& action, 206 const std::string& expected_id, 207 const Action::ActionType& expected_type, 208 const std::string& expected_api_name, 209 const std::string& expected_args_str, 210 const std::string& expected_page_url, 211 const std::string& expected_page_title, 212 const std::string& expected_arg_url) { 213 ASSERT_EQ(expected_id, action.extension_id()); 214 ASSERT_EQ(expected_type, action.action_type()); 215 ASSERT_EQ(expected_api_name, action.api_name()); 216 ASSERT_EQ(expected_args_str, 217 ActivityLogPolicy::Util::Serialize(action.args())); 218 ASSERT_EQ(expected_page_url, action.SerializePageUrl()); 219 ASSERT_EQ(expected_page_title, action.page_title()); 220 ASSERT_EQ(expected_arg_url, action.SerializeArgUrl()); 221 ASSERT_NE(-1, action.action_id()); 222 } 223 224 // A helper function initializes the policy with a number of actions, calls 225 // RemoveActions on a policy object and then checks the result of the 226 // deletion. 227 void CheckRemoveActions( 228 ActivityLogDatabasePolicy* policy, 229 const std::vector<int64>& action_ids, 230 const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) { 231 232 // Use a mock clock to ensure that events are not recorded on the wrong day 233 // when the test is run close to local midnight. 234 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 235 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 236 base::TimeDelta::FromHours(12)); 237 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 238 239 // Record some actions 240 scoped_refptr<Action> action = 241 new Action("punky1", 242 mock_clock->Now() - base::TimeDelta::FromMinutes(40), 243 Action::ACTION_DOM_ACCESS, 244 "lets1"); 245 action->mutable_args()->AppendString("vamoose1"); 246 action->set_page_url(GURL("http://www.google1.com")); 247 action->set_page_title("Google1"); 248 action->set_arg_url(GURL("http://www.args-url1.com")); 249 policy->ProcessAction(action); 250 // Record the same action twice, so there are multiple entries in the 251 // database. 252 policy->ProcessAction(action); 253 254 action = new Action("punky2", 255 mock_clock->Now() - base::TimeDelta::FromMinutes(30), 256 Action::ACTION_API_CALL, 257 "lets2"); 258 action->mutable_args()->AppendString("vamoose2"); 259 action->set_page_url(GURL("http://www.google2.com")); 260 action->set_page_title("Google2"); 261 action->set_arg_url(GURL("http://www.args-url2.com")); 262 policy->ProcessAction(action); 263 // Record the same action twice, so there are multiple entries in the 264 // database. 265 policy->ProcessAction(action); 266 267 // Submit a request to delete actions. 268 policy->RemoveActions(action_ids); 269 270 // Check the result of the deletion. The checker function gets all 271 // activities in the database. 272 CheckReadData(policy, "", -1, checker); 273 274 // Clean database. 275 policy->DeleteDatabase(); 276 } 277 278 static void AllActionsDeleted(scoped_ptr<Action::ActionVector> actions) { 279 ASSERT_EQ(0, static_cast<int>(actions->size())); 280 } 281 282 static void NoActionsDeleted(scoped_ptr<Action::ActionVector> actions) { 283 // These will be in the vector in reverse time order. 284 ASSERT_EQ(4, static_cast<int>(actions->size())); 285 CheckAction(*actions->at(0), 286 "punky2", 287 Action::ACTION_API_CALL, 288 "lets2", 289 "[\"vamoose2\"]", 290 "http://www.google2.com/", 291 "Google2", 292 "http://www.args-url2.com/"); 293 ASSERT_EQ(3, actions->at(0)->action_id()); 294 CheckAction(*actions->at(1), 295 "punky2", 296 Action::ACTION_API_CALL, 297 "lets2", 298 "[\"vamoose2\"]", 299 "http://www.google2.com/", 300 "Google2", 301 "http://www.args-url2.com/"); 302 ASSERT_EQ(4, actions->at(1)->action_id()); 303 CheckAction(*actions->at(2), 304 "punky1", 305 Action::ACTION_DOM_ACCESS, 306 "lets1", 307 "[\"vamoose1\"]", 308 "http://www.google1.com/", 309 "Google1", 310 "http://www.args-url1.com/"); 311 ASSERT_EQ(1, actions->at(2)->action_id()); 312 CheckAction(*actions->at(3), 313 "punky1", 314 Action::ACTION_DOM_ACCESS, 315 "lets1", 316 "[\"vamoose1\"]", 317 "http://www.google1.com/", 318 "Google1", 319 "http://www.args-url1.com/"); 320 ASSERT_EQ(2, actions->at(3)->action_id()); 321 } 322 323 static void Action1Deleted(scoped_ptr<Action::ActionVector> actions) { 324 // These will be in the vector in reverse time order. 325 ASSERT_EQ(2, static_cast<int>(actions->size())); 326 CheckAction(*actions->at(0), 327 "punky2", 328 Action::ACTION_API_CALL, 329 "lets2", 330 "[\"vamoose2\"]", 331 "http://www.google2.com/", 332 "Google2", 333 "http://www.args-url2.com/"); 334 ASSERT_EQ(3, actions->at(0)->action_id()); 335 CheckAction(*actions->at(1), 336 "punky2", 337 Action::ACTION_API_CALL, 338 "lets2", 339 "[\"vamoose2\"]", 340 "http://www.google2.com/", 341 "Google2", 342 "http://www.args-url2.com/"); 343 ASSERT_EQ(4, actions->at(1)->action_id()); 344 } 345 346 static void Action2Deleted(scoped_ptr<Action::ActionVector> actions) { 347 // These will be in the vector in reverse time order. 348 ASSERT_EQ(2, static_cast<int>(actions->size())); 349 CheckAction(*actions->at(0), 350 "punky1", 351 Action::ACTION_DOM_ACCESS, 352 "lets1", 353 "[\"vamoose1\"]", 354 "http://www.google1.com/", 355 "Google1", 356 "http://www.args-url1.com/"); 357 ASSERT_EQ(1, actions->at(0)->action_id()); 358 CheckAction(*actions->at(1), 359 "punky1", 360 Action::ACTION_DOM_ACCESS, 361 "lets1", 362 "[\"vamoose1\"]", 363 "http://www.google1.com/", 364 "Google1", 365 "http://www.args-url1.com/"); 366 ASSERT_EQ(2, actions->at(1)->action_id()); 367 } 368 369 protected: 370 ExtensionService* extension_service_; 371 scoped_ptr<TestingProfile> profile_; 372 content::TestBrowserThreadBundle thread_bundle_; 373 // Used to preserve a copy of the original command line. 374 // The test framework will do this itself as well. However, by then, 375 // it is too late to call ActivityLog::RecomputeLoggingIsEnabled() in 376 // TearDown(). 377 CommandLine saved_cmdline_; 378 379 #if defined OS_CHROMEOS 380 chromeos::ScopedTestDeviceSettingsService test_device_settings_service_; 381 chromeos::ScopedTestCrosSettings test_cros_settings_; 382 scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_; 383 #endif 384 }; 385 386 TEST_F(FullStreamUIPolicyTest, Construct) { 387 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 388 policy->Init(); 389 scoped_refptr<const Extension> extension = 390 ExtensionBuilder() 391 .SetManifest(DictionaryBuilder() 392 .Set("name", "Test extension") 393 .Set("version", "1.0.0") 394 .Set("manifest_version", 2)) 395 .Build(); 396 extension_service_->AddExtension(extension.get()); 397 scoped_ptr<base::ListValue> args(new base::ListValue()); 398 scoped_refptr<Action> action = new Action(extension->id(), 399 base::Time::Now(), 400 Action::ACTION_API_CALL, 401 "tabs.testMethod"); 402 action->set_args(args.Pass()); 403 policy->ProcessAction(action); 404 policy->Close(); 405 } 406 407 TEST_F(FullStreamUIPolicyTest, LogAndFetchActions) { 408 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 409 policy->Init(); 410 scoped_refptr<const Extension> extension = 411 ExtensionBuilder() 412 .SetManifest(DictionaryBuilder() 413 .Set("name", "Test extension") 414 .Set("version", "1.0.0") 415 .Set("manifest_version", 2)) 416 .Build(); 417 extension_service_->AddExtension(extension.get()); 418 GURL gurl("http://www.google.com"); 419 420 // Write some API calls 421 scoped_refptr<Action> action_api = new Action(extension->id(), 422 base::Time::Now(), 423 Action::ACTION_API_CALL, 424 "tabs.testMethod"); 425 action_api->set_args(make_scoped_ptr(new base::ListValue())); 426 policy->ProcessAction(action_api); 427 428 scoped_refptr<Action> action_dom = new Action(extension->id(), 429 base::Time::Now(), 430 Action::ACTION_DOM_ACCESS, 431 "document.write"); 432 action_dom->set_args(make_scoped_ptr(new base::ListValue())); 433 action_dom->set_page_url(gurl); 434 policy->ProcessAction(action_dom); 435 436 CheckReadData( 437 policy, 438 extension->id(), 439 0, 440 base::Bind(&FullStreamUIPolicyTest::RetrieveActions_LogAndFetchActions)); 441 442 policy->Close(); 443 } 444 445 TEST_F(FullStreamUIPolicyTest, LogAndFetchFilteredActions) { 446 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 447 policy->Init(); 448 scoped_refptr<const Extension> extension = 449 ExtensionBuilder() 450 .SetManifest(DictionaryBuilder() 451 .Set("name", "Test extension") 452 .Set("version", "1.0.0") 453 .Set("manifest_version", 2)) 454 .Build(); 455 extension_service_->AddExtension(extension.get()); 456 GURL gurl("http://www.google.com"); 457 458 // Write some API calls 459 scoped_refptr<Action> action_api = new Action(extension->id(), 460 base::Time::Now(), 461 Action::ACTION_API_CALL, 462 "tabs.testMethod"); 463 action_api->set_args(make_scoped_ptr(new base::ListValue())); 464 policy->ProcessAction(action_api); 465 466 scoped_refptr<Action> action_dom = new Action(extension->id(), 467 base::Time::Now(), 468 Action::ACTION_DOM_ACCESS, 469 "document.write"); 470 action_dom->set_args(make_scoped_ptr(new base::ListValue())); 471 action_dom->set_page_url(gurl); 472 policy->ProcessAction(action_dom); 473 474 CheckReadFilteredData( 475 policy, 476 extension->id(), 477 Action::ACTION_API_CALL, 478 "tabs.testMethod", 479 "", 480 "", 481 -1, 482 base::Bind( 483 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 484 485 CheckReadFilteredData( 486 policy, 487 "", 488 Action::ACTION_DOM_ACCESS, 489 "", 490 "", 491 "", 492 -1, 493 base::Bind( 494 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 495 496 CheckReadFilteredData( 497 policy, 498 "", 499 Action::ACTION_DOM_ACCESS, 500 "", 501 "http://www.google.com/", 502 "", 503 -1, 504 base::Bind( 505 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 506 507 CheckReadFilteredData( 508 policy, 509 "", 510 Action::ACTION_DOM_ACCESS, 511 "", 512 "http://www.google.com", 513 "", 514 -1, 515 base::Bind( 516 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 517 518 CheckReadFilteredData( 519 policy, 520 "", 521 Action::ACTION_DOM_ACCESS, 522 "", 523 "http://www.goo", 524 "", 525 -1, 526 base::Bind( 527 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 528 529 CheckReadFilteredData( 530 policy, 531 extension->id(), 532 Action::ACTION_ANY, 533 "", 534 "", 535 "", 536 -1, 537 base::Bind( 538 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions2)); 539 540 policy->Close(); 541 } 542 543 TEST_F(FullStreamUIPolicyTest, LogWithArguments) { 544 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 545 policy->Init(); 546 scoped_refptr<const Extension> extension = 547 ExtensionBuilder() 548 .SetManifest(DictionaryBuilder() 549 .Set("name", "Test extension") 550 .Set("version", "1.0.0") 551 .Set("manifest_version", 2)) 552 .Build(); 553 extension_service_->AddExtension(extension.get()); 554 555 scoped_ptr<base::ListValue> args(new base::ListValue()); 556 args->Set(0, new base::StringValue("hello")); 557 args->Set(1, new base::StringValue("world")); 558 scoped_refptr<Action> action = new Action(extension->id(), 559 base::Time::Now(), 560 Action::ACTION_API_CALL, 561 "extension.connect"); 562 action->set_args(args.Pass()); 563 564 policy->ProcessAction(action); 565 CheckReadData(policy, 566 extension->id(), 567 0, 568 base::Bind(&FullStreamUIPolicyTest::Arguments_Present)); 569 policy->Close(); 570 } 571 572 TEST_F(FullStreamUIPolicyTest, GetTodaysActions) { 573 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 574 policy->Init(); 575 576 // Use a mock clock to ensure that events are not recorded on the wrong day 577 // when the test is run close to local midnight. Note: Ownership is passed 578 // to the policy, but we still keep a pointer locally. The policy will take 579 // care of destruction; this is safe since the policy outlives all our 580 // accesses to the mock clock. 581 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 582 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 583 base::TimeDelta::FromHours(12)); 584 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 585 586 // Record some actions 587 scoped_refptr<Action> action = 588 new Action("punky", 589 mock_clock->Now() - base::TimeDelta::FromMinutes(40), 590 Action::ACTION_API_CALL, 591 "brewster"); 592 action->mutable_args()->AppendString("woof"); 593 action->set_arg_url(GURL("http://www.arg-url.com")); 594 action->set_page_title("Page Title"); 595 policy->ProcessAction(action); 596 597 action = 598 new Action("punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 599 action->mutable_args()->AppendString("vamoose"); 600 action->set_page_url(GURL("http://www.google.com")); 601 action->set_arg_url(GURL("http://www.arg-url.com")); 602 action->set_page_title("Page Title"); 603 policy->ProcessAction(action); 604 605 action = new Action( 606 "scoobydoo", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 607 action->mutable_args()->AppendString("vamoose"); 608 action->set_page_url(GURL("http://www.google.com")); 609 action->set_arg_url(GURL("http://www.arg-url.com")); 610 policy->ProcessAction(action); 611 612 CheckReadData( 613 policy, 614 "punky", 615 0, 616 base::Bind(&FullStreamUIPolicyTest::Arguments_GetTodaysActions)); 617 policy->Close(); 618 } 619 620 // Check that we can read back less recent actions in the db. 621 TEST_F(FullStreamUIPolicyTest, GetOlderActions) { 622 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 623 policy->Init(); 624 625 // Use a mock clock to ensure that events are not recorded on the wrong day 626 // when the test is run close to local midnight. 627 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 628 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 629 base::TimeDelta::FromHours(12)); 630 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 631 632 // Record some actions 633 scoped_refptr<Action> action = 634 new Action("punky", 635 mock_clock->Now() - base::TimeDelta::FromDays(3) - 636 base::TimeDelta::FromMinutes(40), 637 Action::ACTION_API_CALL, 638 "brewster"); 639 action->mutable_args()->AppendString("woof"); 640 policy->ProcessAction(action); 641 642 action = new Action("punky", 643 mock_clock->Now() - base::TimeDelta::FromDays(3), 644 Action::ACTION_DOM_ACCESS, 645 "lets"); 646 action->mutable_args()->AppendString("vamoose"); 647 action->set_page_url(GURL("http://www.google.com")); 648 policy->ProcessAction(action); 649 650 action = new Action("punky", 651 mock_clock->Now(), 652 Action::ACTION_DOM_ACCESS, 653 "lets"); 654 action->mutable_args()->AppendString("too new"); 655 action->set_page_url(GURL("http://www.google.com")); 656 policy->ProcessAction(action); 657 658 action = new Action("punky", 659 mock_clock->Now() - base::TimeDelta::FromDays(7), 660 Action::ACTION_DOM_ACCESS, 661 "lets"); 662 action->mutable_args()->AppendString("too old"); 663 action->set_page_url(GURL("http://www.google.com")); 664 policy->ProcessAction(action); 665 666 CheckReadData( 667 policy, 668 "punky", 669 3, 670 base::Bind(&FullStreamUIPolicyTest::Arguments_GetOlderActions)); 671 policy->Close(); 672 } 673 674 TEST_F(FullStreamUIPolicyTest, RemoveAllURLs) { 675 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 676 policy->Init(); 677 678 // Use a mock clock to ensure that events are not recorded on the wrong day 679 // when the test is run close to local midnight. 680 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 681 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 682 base::TimeDelta::FromHours(12)); 683 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 684 685 // Record some actions 686 scoped_refptr<Action> action = 687 new Action("punky", mock_clock->Now(), 688 Action::ACTION_DOM_ACCESS, "lets"); 689 action->mutable_args()->AppendString("vamoose"); 690 action->set_page_url(GURL("http://www.google.com")); 691 action->set_page_title("Google"); 692 action->set_arg_url(GURL("http://www.google.com")); 693 policy->ProcessAction(action); 694 695 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 696 action = new Action( 697 "punky", mock_clock->Now(), Action::ACTION_API_CALL, "lets"); 698 action->mutable_args()->AppendString("vamoose"); 699 action->set_page_url(GURL("http://www.google2.com")); 700 action->set_page_title("Google"); 701 // Deliberately no arg url set to make sure it still works when there is no 702 // arg url. 703 policy->ProcessAction(action); 704 705 // Clean all the URLs. 706 std::vector<GURL> no_url_restrictions; 707 policy->RemoveURLs(no_url_restrictions); 708 709 CheckReadData( 710 policy, 711 "punky", 712 0, 713 base::Bind(&FullStreamUIPolicyTest::AllURLsRemoved)); 714 policy->Close(); 715 } 716 717 TEST_F(FullStreamUIPolicyTest, RemoveSpecificURLs) { 718 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 719 policy->Init(); 720 721 // Use a mock clock to ensure that events are not recorded on the wrong day 722 // when the test is run close to local midnight. 723 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 724 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 725 base::TimeDelta::FromHours(12)); 726 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 727 728 // Record some actions 729 // This should have the page url and args url cleared. 730 scoped_refptr<Action> action = new Action("punky", mock_clock->Now(), 731 Action::ACTION_DOM_ACCESS, "lets"); 732 action->mutable_args()->AppendString("vamoose"); 733 action->set_page_url(GURL("http://www.google1.com")); 734 action->set_page_title("Google"); 735 action->set_arg_url(GURL("http://www.google1.com")); 736 policy->ProcessAction(action); 737 738 // This should have the page url cleared but not args url. 739 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 740 action = new Action( 741 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 742 action->mutable_args()->AppendString("vamoose"); 743 action->set_page_url(GURL("http://www.google1.com")); 744 action->set_page_title("Google"); 745 action->set_arg_url(GURL("http://www.google.com")); 746 policy->ProcessAction(action); 747 748 // This should have the page url cleared. The args url is deliberately not set 749 // to make sure this doesn't cause any issues. 750 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 751 action = new Action( 752 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 753 action->mutable_args()->AppendString("vamoose"); 754 action->set_page_url(GURL("http://www.google2.com")); 755 action->set_page_title("Google"); 756 policy->ProcessAction(action); 757 758 // This should have the args url cleared but not the page url or page title. 759 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 760 action = new Action( 761 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 762 action->mutable_args()->AppendString("vamoose"); 763 action->set_page_url(GURL("http://www.google.com")); 764 action->set_page_title("Google"); 765 action->set_arg_url(GURL("http://www.google1.com")); 766 policy->ProcessAction(action); 767 768 // This should have neither cleared. 769 mock_clock->Advance(base::TimeDelta::FromSeconds(1)); 770 action = new Action( 771 "punky", mock_clock->Now(), Action::ACTION_DOM_ACCESS, "lets"); 772 action->mutable_args()->AppendString("vamoose"); 773 action->set_page_url(GURL("http://www.google.com")); 774 action->set_page_title("Google"); 775 action->set_arg_url(GURL("http://www.args-url.com")); 776 policy->ProcessAction(action); 777 778 // Clean some URLs. 779 std::vector<GURL> urls; 780 urls.push_back(GURL("http://www.google1.com")); 781 urls.push_back(GURL("http://www.google2.com")); 782 urls.push_back(GURL("http://www.url_not_in_db.com")); 783 policy->RemoveURLs(urls); 784 785 CheckReadData( 786 policy, 787 "punky", 788 0, 789 base::Bind(&FullStreamUIPolicyTest::SomeURLsRemoved)); 790 policy->Close(); 791 } 792 793 TEST_F(FullStreamUIPolicyTest, RemoveExtensionData) { 794 FullStreamUIPolicy* policy = new FullStreamUIPolicy(profile_.get()); 795 policy->Init(); 796 797 // Use a mock clock to ensure that events are not recorded on the wrong day 798 // when the test is run close to local midnight. 799 base::SimpleTestClock* mock_clock = new base::SimpleTestClock(); 800 mock_clock->SetNow(base::Time::Now().LocalMidnight() + 801 base::TimeDelta::FromHours(12)); 802 policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock)); 803 804 // Record some actions 805 scoped_refptr<Action> action = new Action("deleteextensiondata", 806 mock_clock->Now(), 807 Action::ACTION_DOM_ACCESS, 808 "lets"); 809 action->mutable_args()->AppendString("vamoose"); 810 action->set_page_title("Google"); 811 action->set_arg_url(GURL("http://www.google.com")); 812 policy->ProcessAction(action); 813 policy->ProcessAction(action); 814 policy->ProcessAction(action); 815 816 scoped_refptr<Action> action2 = new Action("dontdelete", 817 mock_clock->Now(), 818 Action::ACTION_DOM_ACCESS, 819 "lets"); 820 action->mutable_args()->AppendString("vamoose"); 821 action->set_page_title("Google"); 822 action->set_arg_url(GURL("http://www.google.com")); 823 policy->ProcessAction(action2); 824 825 policy->Flush(); 826 policy->RemoveExtensionData("deleteextensiondata"); 827 828 CheckReadFilteredData( 829 policy, 830 "deleteextensiondata", 831 Action::ACTION_ANY, 832 "", 833 "", 834 "", 835 -1, 836 base::Bind( 837 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions0)); 838 839 CheckReadFilteredData( 840 policy, 841 "dontdelete", 842 Action::ACTION_ANY, 843 "", 844 "", 845 "", 846 -1, 847 base::Bind( 848 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions1)); 849 policy->Close(); 850 } 851 852 TEST_F(FullStreamUIPolicyTest, CapReturns) { 853 FullStreamUIPolicy* policy = new FullStreamUIPolicy(profile_.get()); 854 policy->Init(); 855 856 for (int i = 0; i < 305; i++) { 857 scoped_refptr<Action> action = 858 new Action("punky", 859 base::Time::Now(), 860 Action::ACTION_API_CALL, 861 base::StringPrintf("apicall_%d", i)); 862 policy->ProcessAction(action); 863 } 864 865 policy->Flush(); 866 BrowserThread::PostTaskAndReply( 867 BrowserThread::DB, 868 FROM_HERE, 869 base::Bind(&base::DoNothing), 870 base::MessageLoop::current()->QuitClosure()); 871 base::MessageLoop::current()->Run(); 872 873 CheckReadFilteredData( 874 policy, 875 "punky", 876 Action::ACTION_ANY, 877 "", 878 "", 879 "", 880 -1, 881 base::Bind( 882 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions300)); 883 policy->Close(); 884 } 885 886 TEST_F(FullStreamUIPolicyTest, DeleteDatabase) { 887 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 888 policy->Init(); 889 scoped_refptr<const Extension> extension = 890 ExtensionBuilder() 891 .SetManifest(DictionaryBuilder() 892 .Set("name", "Test extension") 893 .Set("version", "1.0.0") 894 .Set("manifest_version", 2)) 895 .Build(); 896 extension_service_->AddExtension(extension.get()); 897 GURL gurl("http://www.google.com"); 898 899 // Write some API calls. 900 scoped_refptr<Action> action_api = new Action(extension->id(), 901 base::Time::Now(), 902 Action::ACTION_API_CALL, 903 "tabs.testMethod"); 904 action_api->set_args(make_scoped_ptr(new base::ListValue())); 905 policy->ProcessAction(action_api); 906 907 scoped_refptr<Action> action_dom = new Action(extension->id(), 908 base::Time::Now(), 909 Action::ACTION_DOM_ACCESS, 910 "document.write"); 911 action_dom->set_args(make_scoped_ptr(new base::ListValue())); 912 action_dom->set_page_url(gurl); 913 policy->ProcessAction(action_dom); 914 915 CheckReadData( 916 policy, 917 extension->id(), 918 0, 919 base::Bind(&FullStreamUIPolicyTest::RetrieveActions_LogAndFetchActions)); 920 921 // Now delete them. 922 policy->DeleteDatabase(); 923 924 CheckReadFilteredData( 925 policy, 926 "", 927 Action::ACTION_ANY, 928 "", 929 "", 930 "", 931 -1, 932 base::Bind( 933 &FullStreamUIPolicyTest::RetrieveActions_FetchFilteredActions0)); 934 935 policy->Close(); 936 } 937 938 TEST_F(FullStreamUIPolicyTest, RemoveActions) { 939 ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(profile_.get()); 940 policy->Init(); 941 942 std::vector<int64> action_ids; 943 944 CheckRemoveActions(policy, 945 action_ids, 946 base::Bind(&FullStreamUIPolicyTest::NoActionsDeleted)); 947 948 action_ids.push_back(-1); 949 action_ids.push_back(-10); 950 action_ids.push_back(0); 951 action_ids.push_back(5); 952 action_ids.push_back(10); 953 CheckRemoveActions(policy, 954 action_ids, 955 base::Bind(&FullStreamUIPolicyTest::NoActionsDeleted)); 956 action_ids.clear(); 957 958 for (int i = 0; i < 50; i++) { 959 action_ids.push_back(i + 5); 960 } 961 CheckRemoveActions(policy, 962 action_ids, 963 base::Bind(&FullStreamUIPolicyTest::NoActionsDeleted)); 964 action_ids.clear(); 965 966 // CheckRemoveActions pushes four actions to the Activity Log database with 967 // IDs 1, 2, 3, and 4. 968 action_ids.push_back(1); 969 action_ids.push_back(2); 970 action_ids.push_back(3); 971 action_ids.push_back(4); 972 CheckRemoveActions(policy, 973 action_ids, 974 base::Bind(&FullStreamUIPolicyTest::AllActionsDeleted)); 975 action_ids.clear(); 976 977 action_ids.push_back(1); 978 action_ids.push_back(2); 979 CheckRemoveActions( 980 policy, action_ids, base::Bind(&FullStreamUIPolicyTest::Action1Deleted)); 981 action_ids.clear(); 982 983 action_ids.push_back(3); 984 action_ids.push_back(4); 985 CheckRemoveActions( 986 policy, action_ids, base::Bind(&FullStreamUIPolicyTest::Action2Deleted)); 987 action_ids.clear(); 988 989 policy->Close(); 990 } 991 992 } // namespace extensions 993
