tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_provider_notification.js (7663B)

      1 /* Any copyright is dedicated to the Public Domain.
      2 * http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 "use strict";
      5 
      6 let firstProvider;
      7 let secondProvider;
      8 let context;
      9 
     10 add_setup(async function () {
     11  firstProvider = new UrlbarTestUtils.TestProvider({
     12    results: [
     13      new UrlbarResult({
     14        type: UrlbarUtils.RESULT_TYPE.URL,
     15        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
     16        payload: {
     17          url: "https://mozilla.com/",
     18          tags: [],
     19          title: "mozilla.com",
     20        },
     21      }),
     22    ],
     23    priority: 999,
     24    type: UrlbarUtils.PROVIDER_TYPE.PROFILE,
     25    name: "firstProvider",
     26    onEngagement: () => {},
     27    onAbandonment: () => {},
     28    onImpression: () => {},
     29    onSearchSessionEnd: () => {},
     30  });
     31 
     32  secondProvider = new UrlbarTestUtils.TestProvider({
     33    results: [
     34      new UrlbarResult({
     35        type: UrlbarUtils.RESULT_TYPE.URL,
     36        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
     37        payload: {
     38          url: "https://example.com/",
     39          tags: [],
     40          title: "example.com",
     41        },
     42      }),
     43    ],
     44    priority: 999,
     45    type: UrlbarUtils.PROVIDER_TYPE.PROFILE,
     46    name: "secondProvider",
     47  });
     48 
     49  context = createContext("", {
     50    providers: [firstProvider.name, secondProvider.name],
     51  });
     52 
     53  UrlbarProvidersManager.registerProvider(firstProvider);
     54  UrlbarProvidersManager.registerProvider(secondProvider);
     55 
     56  registerCleanupFunction(() => {
     57    UrlbarProvidersManager.unregisterProvider(firstProvider);
     58    UrlbarProvidersManager.unregisterProvider(secondProvider);
     59    sinon.restore();
     60  });
     61 });
     62 
     63 add_task(async function testOnEngagementNotification() {
     64  let spyFirstProviderOnEngagement = sinon.spy(firstProvider, "onEngagement");
     65 
     66  const engagedResult = makeVisitResult(context, {
     67    uri: "https://mozilla.com/",
     68    title: "mozilla.com",
     69    providerName: "firstProvider",
     70    source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
     71  });
     72 
     73  await check_results({
     74    context,
     75    matches: [
     76      engagedResult,
     77      makeVisitResult(context, {
     78        uri: "https://example.com/",
     79        title: "example.com",
     80        providerName: "secondProvider",
     81        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
     82      }),
     83    ],
     84  });
     85 
     86  let controller = UrlbarTestUtils.newMockController();
     87  controller.setView({
     88    get visibleResults() {
     89      return context.results;
     90    },
     91  });
     92 
     93  await UrlbarProvidersManager.notifyEngagementChange(
     94    "engagement",
     95    context,
     96    {
     97      result: engagedResult,
     98    },
     99    controller
    100  );
    101 
    102  Assert.equal(
    103    spyFirstProviderOnEngagement.callCount,
    104    1,
    105    "onEngagement called once for first provider"
    106  );
    107 });
    108 
    109 add_task(async function testOnAbandonmentNotification() {
    110  let spyFirstProviderOnAbandonment = sinon.spy(firstProvider, "onAbandonment");
    111 
    112  await check_results({
    113    context,
    114    matches: [
    115      makeVisitResult(context, {
    116        uri: "https://mozilla.com/",
    117        title: "mozilla.com",
    118        providerName: "firstProvider",
    119        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    120      }),
    121      makeVisitResult(context, {
    122        uri: "https://example.com/",
    123        title: "example.com",
    124        providerName: "secondProvider",
    125        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    126      }),
    127    ],
    128  });
    129 
    130  let controller = UrlbarTestUtils.newMockController();
    131  controller.setView({
    132    get visibleResults() {
    133      return context.results;
    134    },
    135  });
    136 
    137  await UrlbarProvidersManager.notifyEngagementChange(
    138    "abandonment",
    139    context,
    140    {},
    141    controller
    142  );
    143 
    144  Assert.equal(
    145    spyFirstProviderOnAbandonment.callCount,
    146    1,
    147    "onAbandonment called once for first provider"
    148  );
    149 });
    150 
    151 add_task(async function testOnImpressionNotification() {
    152  let spyFirstProviderOnImpression = sinon.spy(firstProvider, "onImpression");
    153 
    154  const engagedResult = makeVisitResult(context, {
    155    uri: "https://mozilla.com/",
    156    title: "mozilla.com",
    157    providerName: "firstProvider",
    158    source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    159  });
    160 
    161  await check_results({
    162    context,
    163    matches: [
    164      engagedResult,
    165      makeVisitResult(context, {
    166        uri: "https://example.com/",
    167        title: "example.com",
    168        providerName: "secondProvider",
    169        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    170      }),
    171    ],
    172  });
    173 
    174  let controller = UrlbarTestUtils.newMockController();
    175  controller.setView({
    176    get visibleResults() {
    177      return context.results;
    178    },
    179  });
    180 
    181  await UrlbarProvidersManager.notifyEngagementChange(
    182    "engagement",
    183    context,
    184    {
    185      isSessionOngoing: false,
    186      result: engagedResult,
    187    },
    188    controller
    189  );
    190 
    191  Assert.equal(
    192    spyFirstProviderOnImpression.callCount,
    193    1,
    194    "onImpression called for first provider after an engagement event"
    195  );
    196 
    197  await UrlbarProvidersManager.notifyEngagementChange(
    198    "abandonment",
    199    context,
    200    {
    201      isSessionOngoing: false,
    202    },
    203    controller
    204  );
    205 
    206  Assert.equal(
    207    spyFirstProviderOnImpression.callCount,
    208    2,
    209    "onImpression called once more for first provider after an abandonment \
    210     event"
    211  );
    212 });
    213 
    214 add_task(async function testOnSearchSessionEndNotification() {
    215  let spyFirstProviderOnSearchSessionEnd = sinon.spy(
    216    firstProvider,
    217    "onSearchSessionEnd"
    218  );
    219 
    220  const engagedResult = makeVisitResult(context, {
    221    uri: "https://mozilla.com/",
    222    title: "mozilla.com",
    223    providerName: "firstProvider",
    224    source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    225  });
    226 
    227  await check_results({
    228    context,
    229    matches: [
    230      engagedResult,
    231      makeVisitResult(context, {
    232        uri: "https://example.com/",
    233        title: "example.com",
    234        providerName: "secondProvider",
    235        source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
    236      }),
    237    ],
    238  });
    239 
    240  let controller = UrlbarTestUtils.newMockController();
    241  controller.setView({
    242    get visibleResults() {
    243      return context.results;
    244    },
    245  });
    246 
    247  await UrlbarProvidersManager.notifyEngagementChange(
    248    "engagement",
    249    context,
    250    {
    251      isSessionOngoing: false,
    252      result: engagedResult,
    253    },
    254    controller
    255  );
    256 
    257  Assert.equal(
    258    spyFirstProviderOnSearchSessionEnd.callCount,
    259    1,
    260    "onSearchSessionEnd called for first provider after an engagement event"
    261  );
    262 
    263  await UrlbarProvidersManager.notifyEngagementChange(
    264    "abandonment",
    265    context,
    266    {
    267      isSessionOngoing: false,
    268    },
    269    controller
    270  );
    271 
    272  Assert.equal(
    273    spyFirstProviderOnSearchSessionEnd.callCount,
    274    2,
    275    "onSearchSessionEnd called once more for first provider after an \
    276     abandonment event"
    277  );
    278 });
    279 
    280 add_task(async function testProviderPresenceInMap() {
    281  const notificationMethods = [
    282    "onEngagement",
    283    "onAbandonment",
    284    "onImpression",
    285    "onSearchSessionEnd",
    286  ];
    287 
    288  for (const method of notificationMethods) {
    289    const providersForMethod =
    290      UrlbarProvidersManager.providersByNotificationType[method];
    291 
    292    const isFirstProviderPresent = providersForMethod.has(firstProvider);
    293    const isSecondProviderPresent = providersForMethod.has(secondProvider);
    294 
    295    Assert.ok(
    296      isFirstProviderPresent,
    297      `The key ${method} includes the firstProvider`
    298    );
    299    Assert.ok(
    300      !isSecondProviderPresent,
    301      `The key ${method} does not include secondProvider`
    302    );
    303  }
    304 
    305  UrlbarProvidersManager.unregisterProvider(firstProvider);
    306 
    307  for (const method of notificationMethods) {
    308    const providersForMethod =
    309      UrlbarProvidersManager.providersByNotificationType[method];
    310    const isPresent = providersForMethod.has(firstProvider);
    311    Assert.ok(
    312      !isPresent,
    313      `FirstProvider should no longer be present for ${method} after being
    314       unregistered`
    315    );
    316  }
    317 });