firefox/toolkit/components/places/tests/gtest/test_IHistory.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "places_test_harness.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsString.h"
#include "mozilla/Attributes.h"
#include "mozilla/SpinEventLoopUntil.h"
#include "mozilla/StackWalk.h"
#include "mozilla/StaticPrefs_layout.h"
#include "nsNetUtil.h"

#include "mock_Link.h"
using namespace mozilla;
using namespace mozilla::dom;

/**
 * This file tests the IHistory interface.
 */

////////////////////////////////////////////////////////////////////////////////
//// Helper Methods

void expect_visit(Link::State aState) {
  do_check_true(aState == Link::State::Visited);
}

void expect_no_visit(Link::State aState) {
  do_check_true(aState == Link::State::Unvisited);
}

already_AddRefed<nsIURI> new_test_uri() {
  // Create a unique spec.
  static int32_t specNumber = 0;
  nsCString spec = "http://mozilla.org/"_ns;
  spec.AppendInt(specNumber++);

  // Create the URI for the spec.
  nsCOMPtr<nsIURI> testURI;
  nsresult rv = NS_NewURI(getter_AddRefs(testURI), spec);
  do_check_success(rv);
  return testURI.forget();
}

class VisitURIObserver final : public nsIObserver {
  ~VisitURIObserver() = default;

 public:
  NS_DECL_ISUPPORTS

  explicit VisitURIObserver(int aExpectedVisits = 1)
      : mVisits(0), mExpectedVisits(aExpectedVisits) {
    nsCOMPtr<nsIObserverService> observerService =
        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
    do_check_true(observerService);
    (void)observerService->AddObserver(this, "uri-visit-saved", false);
  }

  void WaitForNotification() {
    SpinEventLoopUntil("places:VisitURIObserver::WaitForNotification"_ns,
                       [&]() { return mVisits >= mExpectedVisits; });
  }

  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
                     const char16_t* aData) override {
    mVisits++;

    if (mVisits == mExpectedVisits) {
      nsCOMPtr<nsIObserverService> observerService =
          do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
      (void)observerService->RemoveObserver(this, "uri-visit-saved");
    }

    return NS_OK;
  }

 private:
  int mVisits;
  int mExpectedVisits;
};
NS_IMPL_ISUPPORTS(VisitURIObserver, nsIObserver)

////////////////////////////////////////////////////////////////////////////////
//// Test Functions

void test_set_places_enabled() {
  // Ensure places is enabled for everyone.
  nsresult rv;
  nsCOMPtr<nsIPrefBranch> prefBranch =
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
  do_check_success(rv);

  rv = prefBranch->SetBoolPref("places.history.enabled", true);
  do_check_success(rv);

  // Run the next test.
  run_next_test();
}

void test_wait_checkpoint() {
  // This "fake" test is here to wait for the initial WAL checkpoint we force
  // after creating the database schema, since that may happen at any time,
  // and cause concurrent readers to access an older checkpoint.
  nsCOMPtr<mozIStorageConnection> db = do_get_db();
  nsCOMPtr<mozIStorageAsyncStatement> stmt;
  db->CreateAsyncStatement("SELECT 1"_ns, getter_AddRefs(stmt));
  RefPtr<PlacesAsyncStatementSpinner> spinner =
      new PlacesAsyncStatementSpinner();
  nsCOMPtr<mozIStoragePendingStatement> pending;
  (void)stmt->ExecuteAsync(spinner, getter_AddRefs(pending));
  spinner->SpinUntilCompleted();

  // Run the next test.
  run_next_test();
}

// These variables are shared between part 1 and part 2 of the test.  Part 2
// sets the nsCOMPtr's to nullptr, freeing the reference.
namespace test_unvisited_does_not_notify {
MOZ_RUNINIT nsCOMPtr<nsIURI> testURI;
MOZ_RUNINIT RefPtr<mock_Link> testLink;
}  // namespace test_unvisited_does_not_notify
void test_unvisited_does_not_notify_part1() {
  using namespace test_unvisited_does_not_notify;

  // This test is done in two parts.  The first part registers for a URI that
  // should not be visited.  We then run another test that will also do a
  // lookup and will be notified.  Since requests are answered in the order they
  // are requested (at least as long as the same URI isn't asked for later), we
  // will know that the Link was not notified.

  // First, we need a test URI.
  testURI = new_test_uri();

  // Create our test Link.
  testLink = new mock_Link(expect_no_visit);

  // Now, register our Link to be notified.
  nsCOMPtr<IHistory> history = do_get_IHistory();
  history->RegisterVisitedCallback(testURI, testLink);

  // Run the next test.
  run_next_test();
}

void test_visited_notifies() {
  // First, we add our test URI to history.
  nsCOMPtr<nsIURI> testURI = new_test_uri();
  addURI(testURI);

  // Create our test Link.  The callback function will release the reference we
  // have on the Link.
  RefPtr<Link> link = new mock_Link(expect_visit);

  // Now, register our Link to be notified.
  nsCOMPtr<IHistory> history = do_get_IHistory();
  history->RegisterVisitedCallback(testURI, link);

  // Note: test will continue upon notification.
}

void test_unvisited_does_not_notify_part2() {
  using namespace test_unvisited_does_not_notify;

  SpinEventLoopUntil("places:test_unvisited_does_not_notify_part2"_ns,
                     [&]() { return testLink->GotNotified(); });

  // We would have had a failure at this point had the content node been told it
  // was visited. Therefore, now we change it so that it expects a visited
  // notification, and unregisters itself after addURI.
  testLink->AwaitNewNotification(expect_visit);
  addURI(testURI);

  // Clear the stored variables now.
  testURI = nullptr;
  testLink = nullptr;
}

void test_same_uri_notifies_both() {
  // First, we add our test URI to history.
  nsCOMPtr<nsIURI> testURI = new_test_uri();
  addURI(testURI);

  // Create our two test Links.  The callback function will release the
  // reference we have on the Links.  Only the second Link should run the next
  // test!
  RefPtr<Link> link1 = new mock_Link(expect_visit, false);
  RefPtr<Link> link2 = new mock_Link(expect_visit);

  // Now, register our Link to be notified.
  nsCOMPtr<IHistory> history = do_get_IHistory();
  history->RegisterVisitedCallback(testURI, link1);
  history->RegisterVisitedCallback(testURI, link2);

  // Note: test will continue upon notification.
}

void test_unregistered_visited_does_not_notify() {
  // This test must have a test that has a successful notification after it.
  // The Link would have been notified by now if we were buggy and notified
  // unregistered Links (due to request serialization).

  nsCOMPtr<nsIURI> testURI = new_test_uri();
  RefPtr<Link> link = new mock_Link(expect_no_visit, false);
  nsCOMPtr<IHistory> history(do_get_IHistory());
  history->RegisterVisitedCallback(testURI, link);

  // Unregister the Link.
  history->UnregisterVisitedCallback(testURI, link);

  // And finally add a visit for the URI.
  addURI(testURI);

  // If history tries to notify us, we'll either crash because the Link will
  // have been deleted (we are the only thing holding a reference to it), or our
  // expect_no_visit call back will produce a failure.  Either way, the test
  // will be reported as a failure.

  // Run the next test.
  run_next_test();
}

void test_new_visit_notifies_waiting_Link() {
  // Create our test Link.  The callback function will release the reference we
  // have on the link.
  //
  // Note that this will query the database and we'll get an _unvisited_
  // notification, then (after we addURI) a _visited_ one.
  RefPtr<mock_Link> link = new mock_Link(expect_no_visit);

  // Now, register our content node to be notified.
  nsCOMPtr<nsIURI> testURI = new_test_uri();
  nsCOMPtr<IHistory> history = do_get_IHistory();
  history->RegisterVisitedCallback(testURI, link);

  SpinEventLoopUntil("places:test_new_visit_notifies_waiting_Link"_ns,
                     [&]() { return link->GotNotified(); });

  link->AwaitNewNotification(expect_visit);

  // Add ourselves to history.
  addURI(testURI);

  // Note: test will continue upon notification.
}

void test_RegisterVisitedCallback_returns_before_notifying() {
  // Add a URI so that it's already in history.
  nsCOMPtr<nsIURI> testURI = new_test_uri();
  addURI(testURI);

  // Create our test Link.
  RefPtr<Link> link = new mock_Link(expect_no_visit, false);

  // Now, register our content node to be notified.  It should not be notified.
  nsCOMPtr<IHistory> history = do_get_IHistory();
  history->RegisterVisitedCallback(testURI, link);

  // Remove ourselves as an observer.  We would have failed if we had been
  // notified.
  history->UnregisterVisitedCallback(testURI, link);

  run_next_test();
}

void test_visituri_inserts() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();

  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);

  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  PlaceRecord place;
  do_get_place(visitedURI, place);

  do_check_true(place.id > 0);
  do_check_false(place.hidden);
  do_check_false(place.typed);
  do_check_eq(place.visitCount, 1);

  run_next_test();
}

void test_visituri_updates() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
  RefPtr<VisitURIObserver> finisher;

  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);
  finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);
  finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  PlaceRecord place;
  do_get_place(visitedURI, place);

  do_check_eq(place.visitCount, 2);

  run_next_test();
}

void test_visituri_preserves_shown_and_typed() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();

  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);
  // this simulates the uri visit happening in a frame.  Normally frame
  // transitions would be hidden unless it was previously loaded top-level
  history->VisitURI(nullptr, visitedURI, lastURI, 0, 0);

  RefPtr<VisitURIObserver> finisher = new VisitURIObserver(2);
  finisher->WaitForNotification();

  PlaceRecord place;
  do_get_place(visitedURI, place);
  do_check_false(place.hidden);

  run_next_test();
}

void test_visituri_creates_visit() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();

  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);
  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  PlaceRecord place;
  VisitRecord visit;
  do_get_place(visitedURI, place);
  do_get_lastVisit(place.id, visit);

  do_check_true(visit.id > 0);
  do_check_eq(visit.lastVisitId, 0);
  do_check_eq(visit.transitionType, nsINavHistoryService::TRANSITION_LINK);

  run_next_test();
}

void test_visituri_frecency() {
  // Adding a visit calculates frecency immediately.
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
  RefPtr<WaitForNotificationSpinner> spinner =
      new WaitForNotificationSpinner(PlacesEventType::Pages_rank_changed);
  history->VisitURI(nullptr, visitedURI, nullptr, mozilla::IHistory::TOP_LEVEL,
                    0);
  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();
  spinner->SpinUntilCompleted();
  PlaceRecord place;
  do_get_place(visitedURI, place);
  do_check_true(place.frecency > 0);
  run_next_test();
}

void test_visituri_hidden() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  {
    // Insert a framed link visit.
    nsCOMPtr<nsIURI> visitedURI = new_test_uri();
    nsCOMPtr<nsINavHistoryService> navHistory = do_get_NavHistory();
    navHistory->MarkPageAsFollowedLink(visitedURI);
    history->VisitURI(nullptr, visitedURI, nullptr, 0, 0);
    RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
    finisher->WaitForNotification();
    PlaceRecord place;
    do_get_place(visitedURI, place);
    do_check_true(place.hidden);
  }

  // Insert a redirect.
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
  history->VisitURI(nullptr, visitedURI, nullptr,
                    mozilla::IHistory::TOP_LEVEL | IHistory::REDIRECT_SOURCE,
                    0);
  {
    RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
    finisher->WaitForNotification();
    PlaceRecord place;
    do_get_place(visitedURI, place);
    do_check_true(place.hidden);
  }

  // Now add a non-hidden visit to the hidden page, check it gets unhidden.
  history->VisitURI(nullptr, visitedURI, nullptr, mozilla::IHistory::TOP_LEVEL,
                    0);
  {
    RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
    finisher->WaitForNotification();
    PlaceRecord place;
    do_get_place(visitedURI, place);
    do_check_false(place.hidden);
  }

  // Add another hidden visit, it should stay unhidden.
  history->VisitURI(nullptr, visitedURI, nullptr,
                    mozilla::IHistory::TOP_LEVEL | IHistory::REDIRECT_SOURCE,
                    0);
  {
    RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
    finisher->WaitForNotification();
    PlaceRecord place;
    do_get_place(visitedURI, place);
    do_check_false(place.hidden);
  }

  run_next_test();
}

void test_visituri_transition_typed() {
  nsCOMPtr<nsINavHistoryService> navHistory = do_get_NavHistory();
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();

  navHistory->MarkPageAsTyped(visitedURI);
  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
                    0);
  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  PlaceRecord place;
  VisitRecord visit;
  do_get_place(visitedURI, place);
  do_get_lastVisit(place.id, visit);

  do_check_true(visit.transitionType == nsINavHistoryService::TRANSITION_TYPED);

  run_next_test();
}

void test_visituri_transition_embed() {
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsCOMPtr<nsIURI> lastURI = new_test_uri();
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();

  history->VisitURI(nullptr, visitedURI, lastURI, 0, 0);
  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  PlaceRecord place;
  VisitRecord visit;
  do_get_place(visitedURI, place);
  do_get_lastVisit(place.id, visit);

  do_check_eq(place.id, 0);
  do_check_eq(visit.id, 0);

  run_next_test();
}

void test_new_visit_adds_place_guid() {
  // First, add a visit and wait.  This will also add a place.
  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
  nsCOMPtr<IHistory> history = do_get_IHistory();
  nsresult rv = history->VisitURI(nullptr, visitedURI, nullptr,
                                  mozilla::IHistory::TOP_LEVEL, 0);
  do_check_success(rv);
  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
  finisher->WaitForNotification();

  // Check that we have a guid for our visit.
  PlaceRecord place;
  do_get_place(visitedURI, place);
  do_check_eq(place.visitCount, 1);
  do_check_eq(place.guid.Length(), 12u);

  run_next_test();
}

////////////////////////////////////////////////////////////////////////////////
//// Test Harness

/**
 * Note: for tests marked "Order Important!", please see the test for details.
 */
Test gTests[] = {
    PTEST(test_set_places_enabled),               // Must come first!
    PTEST(test_wait_checkpoint),                  // Must come second!
    PTEST(test_unvisited_does_not_notify_part1),  // Order Important!
    PTEST(test_visited_notifies),
    PTEST(test_unvisited_does_not_notify_part2),  // Order Important!
    PTEST(test_same_uri_notifies_both),
    PTEST(test_unregistered_visited_does_not_notify),  // Order Important!
    PTEST(test_new_visit_adds_place_guid),
    PTEST(test_new_visit_notifies_waiting_Link),
    PTEST(test_RegisterVisitedCallback_returns_before_notifying),
    PTEST(test_visituri_inserts),
    PTEST(test_visituri_updates),
    PTEST(test_visituri_preserves_shown_and_typed),
    PTEST(test_visituri_creates_visit),
    PTEST(test_visituri_frecency),
    PTEST(test_visituri_hidden),
    PTEST(test_visituri_transition_typed),
    PTEST(test_visituri_transition_embed),
};

int gTestsIndex = 0;

class RunNextTest : public mozilla::Runnable {
 public:
  RunNextTest() : mozilla::Runnable("RunNextTest") {}
  NS_IMETHOD Run() override {
    MOZ_RELEASE_ASSERT(NS_IsMainThread(), "Not running on the main thread?");
    if (gTestsIndex < int(std::size(gTests))) {
      do_test_pending();
      Test& test = gTests[gTestsIndex++];
      (void)fprintf(stderr, TEST_INFO_STR "Running %s.\n", test.name);
      test.func();
    }

    do_test_finished();
    return NS_OK;
  }
};

static const bool kDebugRunNextTest = false;

void run_next_test() {
  if (kDebugRunNextTest) {
    printf_stderr("run_next_test()\n");
    MozWalkTheStack(stderr);
  }
  nsCOMPtr<nsIRunnable> event = new RunNextTest();
  do_check_success(NS_DispatchToCurrentThread(event));
}

int gPendingTests = 0;

void do_test_pending() {
  MOZ_RELEASE_ASSERT(NS_IsMainThread(), "Not running on the main thread?");
  if (kDebugRunNextTest) {
    printf_stderr("do_test_pending()\n");
    MozWalkTheStack(stderr);
  }
  gPendingTests++;
}

void do_test_finished() {
  MOZ_RELEASE_ASSERT(NS_IsMainThread(), "Not running on the main thread?");
  MOZ_RELEASE_ASSERT(gPendingTests > 0, "Invalid pending test count!");
  gPendingTests--;
}

TEST(IHistory, Test)
{
  RefPtr<WaitForConnectionClosed> spinClose = new WaitForConnectionClosed();

  // Tinderboxes are constantly on idle.  Since idle tasks can interact with
  // tests, causing random failures, disable the idle service.
  disable_idle_service();

  do_test_pending();
  run_next_test();

  // Spin the event loop until we've run out of tests to run.
  mozilla::SpinEventLoopUntil("places:TEST(IHistory, Test)"_ns,
                              [&]() { return !gPendingTests; });

  // And let any other events finish before we quit.
  (void)NS_ProcessPendingEvents(nullptr);
}