TypeScript helpers.setupCurrentUser函数代码示例

  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('when logged in', function(hooks) {
    setupCurrentUser(hooks);

    hooks.beforeEach(async function() {
      const store = getService<StoreService>('store');

      await store.createRecord('relay', defaultRelays[0]).save();
      await store.createRecord('relay', defaultRelays[1]).save();
      await store.createRecord('relay', defaultRelays[2]).save();
      await visit(path);
    });

    test('the default relays are rendered', function(assert) {
      assert.equal(page.table.rows.length, 3, '1 row per relay');
    });

    module('user removes a relay', function(hooks) {
      hooks.beforeEach(async function(assert) {
        assert.equal(page.table.rows.length, 3, 'there are 3 relays');

        await page.table.rows.objectAt(1).remove();
      });

      test('there is one less row', function(assert) {
        assert.equal(page.table.rows.length, 2, 'there are 2 relays');
      });
    });

    module('user clicks add relay', function(hooks) {
      hooks.beforeEach(async function(assert) {
        assert.notOk(page.form.isVisible, 'form is not visible');
        await page.addRelay();
      });

      test('the form appears', function(assert) {
        assert.ok(page.form.isVisible, 'form is visible');
      });

      module('user saves the relay', function(hooks) {
        hooks.beforeEach(async function() {
          await page.form.fillSocket('socket url');
          await page.form.fillOg('og url');
          await page.form.save();
          await waitUntil(() => !page.form.isVisible);
        });

        test('the form hides', function(assert) {
          assert.notOk(page.form.isVisible, 'form is not visible');
        });

        test('there is now one additional relay in the table', function(assert) {
          assert.equal(page.table.rows.length, 4, '1 row per relay');
        });
      });
    });
  });

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('is logged in', function(hooks) {
    setupCurrentUser(hooks);

    module('visits /setup', function(hooks) {
      hooks.beforeEach(async function() {
        await visit('/setup');
      });

      test('redirects to warning', function(assert) {
        assert.equal(currentURL(), '/setup/overwrite');
      });
    });
  });

  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);
    });
  });