TypeScript helpers.clearLocalStorage函数代码示例

module('Acceptance | Settings | Relays', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);

  let path = '/settings/danger-zone';

  module('when not logged in', function(hooks) {
    hooks.beforeEach(async function() {
      await visit(path);
    });

    test('is redirected to setup', function(assert) {
      assert.equal(currentURL(), '/setup/new');
    });
  });

  module('when logged in', function(hooks) {
    setupCurrentUser(hooks);

    hooks.beforeEach(async function() {
      await visit(path);
    });

    test('delete messages button is visible', function(assert) {
      assert.ok(page.deleteMessages.isVisible, 'button is visible');
    });
  });
});

module('TestHelper | create-current-user', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);

  test('a new user is created and kept in cache', async function(assert) {
    const before = getStore().peekAll('user');

    assert.equal(before.length, 0);

    await createCurrentUser();

    const after = getStore().peekAll('user');

    assert.equal(after.length, 1);
    assert.equal(after.toArray()[0].id, 'me');
  });

  test('a new user is created and stored', async function(assert) {
    const before = await getStore().findAll('user');

    assert.equal(before.length, 0);

    await createCurrentUser();

    const after = await getStore().findAll('user');

    assert.equal(after.length, 1);
    assert.equal(after.toArray()[0].id, 'me');
  });

  test('the user is set on the identity service', async function(assert) {
    const before = getService<CurrentUserService>('currentUser').record;

    assert.notOk(before);

    const user = await createCurrentUser();

    const after = getService<CurrentUserService>('currentUser').record;

    assert.deepEqual(after, user);
  });

  module('user is setup in a beforeEach', function(hooks) {
    setupCurrentUser(hooks);

    test('the user is logged in', function(assert) {
      const isLoggedIn = getService<CurrentUserService>('currentUser').isLoggedIn;

      assert.ok(isLoggedIn);
    });

    test('identity exists', async function(assert) {
      const exists = await getService<CurrentUserService>('currentUser').exists();

      assert.ok(exists);
    });
  });
});

module('Acceptance | Notification Permission Prompt', function(hooks) {
  setupApplicationTest(hooks);
  setupRelayConnectionMocks(hooks);
  clearLocalStorage(hooks);
  setupWindowNotification(hooks);
  setupCurrentUser(hooks);

  module('permission has not yet been asked for', function(hooks) {
    hooks.beforeEach(async function() {
      window.Notification = {
        permission: undefined,
      };

      await visit('/chat/privately-with/me');
    });

    test('the prompt is shown', function(assert) {
      assert.equal(prompt.isVisible, true);
    });

    test('never ask again is clicked', async function(assert) {
      assert.expect(2);

      await prompt.askNever();

      assert.equal(prompt.isVisible, false, 'prompt hides initially');

      await refresh(() => stubConnection());

      assert.equal(prompt.isVisible, false, 'still is not shown even after refresh');
    });

    module('ask later is clicked', function(hooks) {
      hooks.beforeEach(async function() {
        await prompt.askLater();
      });

      test('the prompt is not shown', function(assert) {
        assert.equal(prompt.isVisible, false);
      });

      module('on refresh', function(hooks) {
        hooks.beforeEach(async function() {
          await refresh(() => stubConnection());
        });

        test('the prompt is shown', function(assert) {
          assert.equal(prompt.isVisible, true);
        });
      });
    });

    module('enabled is clicked', function() {});
  });
});

module('Acceptance | Logout', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);

  module('When not logged in', function(hooks) {
    hooks.beforeEach(async function() {
      stubService('currentUser', {
        isLoggedIn: false,
        load() {},
        exists: () => false,
      });

      await visit('/logout');
    });

    test('redirects to setup', function(assert) {
      assert.equal(currentURL(), '/setup/new');
      assertExternal(assert as any);
    });
  });

  module('When logged in', function(hooks) {
    setupCurrentUser(hooks);

    hooks.beforeEach(async function() {
      await visit('/');
    });

    module('user dropdown is open', function(hooks) {
      hooks.beforeEach(async function() {
        await app.userDropdown.open();
      });

      test('shows the logout button', function(assert) {
        assert.ok(app.userDropdown.logoutButton());
        assertExternal(assert as any);
      });

      module('clicking logout', function(hooks) {
        hooks.beforeEach(async function() {
          await app.userDropdown.clickLogout();
        });

        test('navigates to the logout warning page', function(assert) {
          assert.equal(currentURL(), '/logout');
          assertExternal(assert as any);
        });
      });
    });
  });
});

module('Acceptance | Chat', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);

  module('when not logged in', function(hooks) {
    hooks.beforeEach(async function() {
      await visit('/chat');
    });

    test('is redirected to setup', function(assert) {
      assert.equal(currentURL(), '/setup/new');
    });
  });
});

module('Acceptance | Chat', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);
  setupCurrentUser(hooks);

  module('Unread Messages', function(hooks) {
    hooks.beforeEach(async function() {
      // we can't receive unread messages from ourselves
      // so start on that screen
      await visit('/chat/privately-with/me');
    });

    // TODO: this indicator is a mobile only thing, so..
    //       maybe we need some sort of breakpoint testing?
    test('when there are 0 messages', function(assert) {
      assert.notOk(page.headerUnread.isPresent, 'indicator is rendered');
    });

    module('Has unread messages', function(hooks) {
      hooks.beforeEach(async function() {
        const store = getService<StoreService>('store');
        const record = store.createRecord('message', {
          target: 'whatever',
          type: 'not ping',
          body: 'a test message',
          to: 'me',
          readAt: null,
        });
        await record.save();
        await waitFor(selectors.headerUnread);
      });

      test('1 message is unread', function(assert) {
        assert.ok(page.headerUnread.isPresent, 'indicator is rendered');
        assert.ok(
          page.headerUnread.text.includes('1'),
          `has one unread message. detected text: ${page.headerUnread.text}`
        );

        percySnapshot(assert as any);
      });
    });
  });
});

module('Acceptance | Navigation Scrolling', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);

  hooks.beforeEach(async function() {
    await visit('/');
  });

  module('When in a short viewport', function(hooks) {
    hooks.beforeEach(function() {
      (app.scrollContainer()!.style as any) = 'height: 300px';
    });

    hooks.afterEach(function() {
      (app.scrollContainer()!.style as any) = '';
    });

    module('When scrolled to the bottom', function(hooks) {
      hooks.beforeEach(async function() {
        await app.footer.faq().scrollIntoView(false);
        await triggerEvent(window as any, 'scroll');
      });

      test('the top of the page is not visible', function(assert) {
        const position = app.scrollContainer().scrollTop;

        assert.notEqual(position, 0, 'the scroll container is not at the top');
      });

      module('Clicking to another page', function(hooks) {
        hooks.beforeEach(async function() {
          await app.footer.clickFaq();
        });

        test('the top of the page is visible', function(assert) {
          const position = app.scrollContainer().scrollTop;

          assert.equal(position, 0, 'the scroll container is at the top');
        });
      });
    });
  });
});

module('Acceptance | Compatibility', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);
  setupWindowNotification(hooks);

  // stub things that may not exist (esp in headless / c.i.)
  hooks.beforeEach(function() {
    window.ServiceWorker = window.ServiceWorker || 'for testing';
  });

  module('the browser supports all required features', function(hooks) {
    hooks.beforeEach(async function() {
      await visit('/');
    });

    test('the compatibility message is not shown', function(assert) {
      let modal = find('[data-test-compatibility-modal]');

      assert.notOk(modal, 'the modal should not be in the dom');
    });
  });

  module('the browser does not support a required feature', function(hooks) {
    let backupDb: any;
    hooks.beforeEach(async function() {
      backupDb = window.indexedDB;
      delete (window as any).indexedDB;
      await visit('/');
    });
    hooks.afterEach(function() {
      (window as any).indexedDB = backupDb;
    });

    test('the compatibility message is shown', function(assert) {
      let modal = find('[data-test-compatibility-modal]');

      assert.ok(modal, 'the modal should be in the dom');
    });
  });
});

module('Acceptance | Notifications Service', function(hooks) {
  setupApplicationTest(hooks);
  clearLocalStorage(hooks);
  setupRelayConnectionMocks(hooks);
  setupWindowNotification(hooks);

  module('permission has not yet been asked for', function(hooks) {
    let notifications!: Notifications;

    hooks.beforeEach(async function() {
      await visit('/');
      window.Notification = {
        permission: undefined,
      };

      notifications = getService<Notifications>('notifications');
    });

    module('permission denied', function(hooks) {
      hooks.beforeEach(function() {
        window.Notification = { permission: 'denied' };
      });

      module('a notification is attempted', function(hooks) {
        hooks.beforeEach(async function() {
          notifications.info('a test message');
          await waitFor(app.selectors.toast);
        });

        test('a toast is displayed', function(assert) {
          assert.ok(app.toastText()!.match(/a test message/));
        });
      });
    });

    // module('permission granted', function(hooks) {});

    // module('permission: later', function(hooks) {});
  });
});