test('Displays basic info about addon', async function(assert) {
let addon = server.create('addon', {
name: 'fake-addon',
description: 'Foo bar baz',
latestVersionDate: moment().subtract(1, 'day').toISOString(),
score: 5,
hasBeenReviewed: true,
repositoryUrl: 'http://example.com/fake-addon',
demoUrl: 'http://example.org/demo',
});
let newestAddonVersion = server.create('version', {
addon,
version: '1.1.3',
});
addon.update('latestAddonVersionId', newestAddonVersion.id);
await visitAddon(addon);
await percySnapshot('/admin/review/addon');
assert.dom('.test-addon-link').includesText('fake-addon');
assert.dom('.test-description').includesText('Foo bar baz');
assert.dom('.test-last-updated').hasText('1.1.3 from a day ago');
assert.dom('.test-addon-demo-url').includesText('http://example.org/demo');
assert.dom('.test-addon-package-url').includesText('https://www.npmjs.com/package/fake-addon');
assert.dom('.test-score').hasText('5.0');
assert.dom('.test-repo-url').hasText('http://example.com/fake-addon');
assert.dom('.test-repo-url').hasAttribute('href', 'http://example.com/fake-addon');
assert.dom('.test-repo-url').hasAttribute('target', 'repo', 'Has fixed target to facilitate multi-window workflow');
});
test('on a repository with auto-cancellation', async function (assert) {
this.repository.createSetting({ name: 'auto_cancel_pushes', value: true });
this.repository.createSetting({ name: 'auto_cancel_pull_requests', value: false });
await settingsPage.visit({ organization: 'org-login', repo: 'repository-name' });
assert.ok(settingsPage.autoCancellationSection.exists, 'expected auto-cancellation section to exist');
assert.ok(settingsPage.autoCancelPushes.isActive, 'expected auto-cancel pushes to be present and enabled');
assert.notOk(settingsPage.autoCancelPullRequests.isActive, 'expected auto-cancel pull requests to be present but disabled');
const settingToRequestBody = {};
server.patch(`/repo/${this.repository.id}/setting/:setting`, function (schema, request) {
settingToRequestBody[request.params.setting] = JSON.parse(request.requestBody);
});
await settingsPage.autoCancelPullRequests.toggle();
assert.ok(settingsPage.autoCancelPullRequests.isActive, 'expected auto-cancel pull requests to be enabled');
assert.deepEqual(settingToRequestBody.auto_cancel_pull_requests, { 'setting.value': true });
await settingsPage.autoCancelPushes.toggle();
assert.notOk(settingsPage.autoCancelPushes.isActive, 'expected auto-cancel pushes to be disabled');
assert.deepEqual(settingToRequestBody.auto_cancel_pushes, { 'setting.value': false });
percySnapshot(assert);
});
test('it renders', function(assert) {
this.render(hbs`{{dummy-box}}`);
assert.equal(this.$().text().trim(), '');
this.render(hbs`
{{#dummy-box}}
This is a dummy box!
{{/dummy-box}}
`);
assert.equal(this.$().text().trim(), 'This is a dummy box!');
percySnapshot('dummy box test');
// Tests that per-snapshot breakpoints override default breakpoints.
percySnapshot('dummy box test on small width only', {breakpoints: ['mobile']});
});
test('the home page shows running tab when feature flag enabled', async function (assert) {
enableFeature('show-running-jobs-in-sidebar');
await visit('/');
await click('[data-test-sidebar-running-tab] a');
assert.dom('[data-test-sidebar-running-tab]').hasText('Running (0/1)', 'running tab correctly shows number of started/queued jobs');
assert.dom('[data-test-sidebar-queued-job]').exists('expected one queued job');
percySnapshot(assert);
});
test('/crates is accessible', async function(assert) {
assert.expect(0);
this.server.loadFixtures();
await visit('/crates');
percySnapshot(assert);
await a11yAudit(axeConfig);
});
test('visiting /', async function (assert) {
await visit('/')
assert.expect(3)
assert.equal(currentURL(), '/')
assert.equal(find('[data-test-title-home]').textContent.trim(), 'Software Engineer & Photographer from Toronto, Canada')
percySnapshot('home page')
await a11yAudit()
assert.ok(true, 'no a11y errors found!')
})
test('visiting /contact', async function (assert) {
await visit('/contact')
assert.expect(3)
assert.equal(currentURL(), '/contact')
assert.equal(find('[data-test-title-contact]').textContent.trim(), 'Contact')
percySnapshot('contact page')
await a11yAudit()
assert.ok(true, 'no a11y errors found!')
})
test('visiting /about', async function (assert) {
await visit('/about')
assert.expect(3)
assert.equal(currentURL(), '/about')
assert.equal(find('[data-test-section-about-blurb]').textContent.trim(), 'Hi, I’m Jeff Jewiss, a developer & designer who builds web applications. I strive to create the best experiences possible for all types of users by applying pragmatism to my work.')
percySnapshot('about page')
await a11yAudit()
assert.ok(true, 'no a11y errors found!')
})
return section.get('pages').reduce(async (prev, page) => {
await prev;
let url = get(page, 'url');
await visit(`/release/${url}`);
let name = `/${page.url}/index.html`;
if (page.url.endsWith('index')) {
name = `/${page.url}.html`;
} else if (page.url.endsWith('index/')) {
name = '/index.html';
}
await percySnapshot(name);
}, Promise.resolve());
test('redirects to current day', async function(assert) {
let addon = server.create('addon');
let addonVersion = server.create('version', { addonId: addon.id });
server.create('testResult', {
versionId: addonVersion.id,
canary: true,
createdAt: moment('2016-08-07 16:30').utc()
});
await visit('/canary-test-results');
await percySnapshot('/canary-test-results/date');
assert.equal(currentRouteName(), 'canary-test-results.date', 'transitions to canary test results date route');
});
test('Dashboard pagination works', async function (assert) {
enableFeature('dashboard');
server.createList('repository', 12);
await visit('/dashboard');
assert.equal(page.starredRepos.length, 1);
assert.equal(page.activeRepos.repos.length, 10);
assert.dom('[data-test-components-pagination-navigation]').exists();
assert.dom('[data-test-page-pagination-link]').exists({ count: 2 });
assert.dom('[data-test-next-pagination-link]').exists();
percySnapshot(assert);
await click('[data-test-page-pagination-link="2"]');
assert.equal(page.starredRepos.length, 1, 'still lists starred repos on top');
assert.equal(page.activeRepos.repos.length, 6, 'lists other repos on the 2nd page');
});
test('listing my builds', async function (assert) {
enableFeature('dashboard');
await page.visit();
await page.myBuilds.visit();
percySnapshot(assert);
assert.equal(currentURL(), '/dashboard/builds');
assert.equal(page.myBuilds.builds.length, 4);
page.myBuilds.builds[0].as(build => {
assert.ok(build.isPublic);
assert.ok(build.isPassed);
assert.equal(build.owner.text, 'travis-ci');
assert.ok(build.owner.href.endsWith('/travis-ci'));
assert.equal(build.repo.text, 'travis-lol-a-very-long-repository');
assert.ok(build.repo.href.endsWith('/travis-ci/travis-lol-a-very-long-repository'));
assert.equal(build.branch.text, 'another-branch');
assert.ok(build.branch.href.endsWith('travis-ci/travis-lol-a-very-long-repository/tree/another-branch'));
assert.equal(build.message.text, 'get used to it');
assert.equal(build.message.title, 'get used to it');
assert.equal(build.stateAndNumber.text, '#44 passed');
assert.ok(build.stateAndNumber.href.endsWith('/travis-ci/travis-lol-a-very-long-repository/builds/1919'));
assert.equal(build.sha.text, 'acab');
assert.ok(build.sha.href.endsWith('/travis-ci/travis-lol-a-very-long-repository/commit/acab'));
assert.equal(build.duration.text, '19 min 19 sec');
assert.equal(build.duration.title, `Started ${prettyDate([this.permissionBuild.started_at])}`);
assert.equal(build.finished.text, 'about a year ago');
assert.equal(build.finished.title, this.permissionBuild.finished_at.toISOString());
});
page.myBuilds.builds[3].as(build => {
assert.equal(build.finished.text, 'still running');
});
page.myBuilds.builds[1].as(build => {
assert.ok(build.isFailed);
assert.ok(build.isPrivate);
});
assert.equal(page.starredRepos.length, 1);
await page.myBuilds.builds[0].restart();
assert.equal(topPage.flashMessage.text, 'The build was successfully restarted.');
const commit = server.create('commit', {
id: 100,
sha: 'acab',
branch: 'primary',
message: 'Add new chapter',
committed_at: '2016-12-02T22:02:34Z',
});
let build = this.branch.createBuild({
id: 100,
number: 15,
repository: this.repository,
pull_request: false,
event_type: 'push',
state: 'created',
started_at: new Date(),
createdBy: this.currentUser
});
let job = build.createJob({
id: 100,
repository: this.repository,
build,
commit,
number: '15.1',
state: 'created',
});
await this.owner.application.pusher.receive('job:created', generatePusherPayload(job));
await this.owner.application.pusher.receive('build:created', {
build: generatePusherPayload(build),
commit: generatePusherPayload(commit),
repository: generatePusherPayload(this.repository, { current_build_id: build.id })
});
await waitForElement('.my-build:nth-child(1)');
page.myBuilds.builds[0].as(build => {
assert.equal(build.stateAndNumber.text, '#15 received');
});
let otherUser = server.create('user');
let otherBranch = server.create('branch', {
lastBuild: server.create('build', {
createdBy: otherUser
})
});
let otherRepository = server.create('repository', {
defaultBranch: otherBranch
});
let otherBuild = otherBranch.createBuild({
started_at: new Date(),
createdBy: otherUser,
repository: otherRepository
});
let otherCommit = server.create('commit');
let otherJob = otherBuild.createJob({
id: otherBuild.id,
repository: otherRepository,
build: otherBuild,
commit: otherCommit,
number: '1999.1',
state: 'passed'
});
await this.owner.application.pusher.receive('job:created', generatePusherPayload(otherJob));
await this.owner.application.pusher.receive('build:created', {
build: generatePusherPayload(otherBuild),
commit: generatePusherPayload(otherCommit),
repository: generatePusherPayload(otherRepository, { current_build_id: otherBuild.id })
});
await waitForElement('.my-build:nth-child(5)');
assert.equal(page.myBuilds.builds.length, 5, 'expected the user’s new build to show but not the other user’s');
await page.activeRepos.visit();
assert.equal(page.activeRepos.repos.length, 4);
});
test('it works', async function(assert) {
await visit('/flights/87296');
await percySnapshot('Flight Page');
assert.dom('[data-test-pilot-names]').hasText('Tobias Bieniek');
});
test('users can delete their accounts on the setting page', async function(assert) {
let { server } = this.polly;
let settings = {
id: 123,
firstName: 'John',
lastName: 'Doe',
name: 'John Doe',
email: '*****@*****.**',
altitudeUnit: 0,
distanceUnit: 1,
liftUnit: 0,
speedUnit: 1,
};
server.get('/api/settings').intercept((req, res) => {
res.status(200);
res.json(settings);
});
server.post('/api/users/check-email').intercept((req, res) => {
res.status(200);
res.json({ result: 'self' });
});
server.post('/api/settings/password/check').intercept((req, res) => {
let json = JSON.parse(req.body);
let result = json.password === 'secret123';
res.status(200);
res.json({ result });
});
server.delete('/api/account').intercept((req, res) => {
let json = JSON.parse(req.body);
assert.equal(json.password, 'secret123');
assert.step('account-deleted');
res.status(200);
res.json({});
});
await authenticateSession({ settings });
assert.ok(isAuthenticated());
// visit the front page
await visit('/');
await percySnapshot('Index');
// open the menu
await click('[data-test-nav-bar] [data-test-user-menu-toggle]');
assert.dom('[data-test-nav-bar] [data-test-user-menu] [data-test-setting-link]').isVisible();
// click on the "Settings" link
await click('[data-test-nav-bar] [data-test-user-menu] [data-test-setting-link]');
assert.equal(currentURL(), '/settings/profile');
await percySnapshot('Settings');
// click on the "Delete Account" button
await click('[data-test-delete-account-button]');
assert.dom('[data-test-delete-account-modal] .modal-dialog').isVisible();
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .form-group').doesNotHaveClass('has-error');
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .help-block').doesNotExist();
assert.dom('[data-test-delete-account-modal] [data-test-submit-button]').isDisabled();
// enter incorrect password
await fillIn('[data-test-delete-account-modal] [data-test-password-form] input', 'foo');
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .form-group').hasClass('has-error');
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .help-block').isVisible();
assert.dom('[data-test-delete-account-modal] [data-test-submit-button]').isDisabled();
await percySnapshot('Delete Account Modal');
// enter correct password
await fillIn('[data-test-delete-account-modal] [data-test-password-form] input', 'secret123');
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .form-group').hasClass('has-success');
assert.dom('[data-test-delete-account-modal] [data-test-password-form] .help-block').doesNotExist();
assert.dom('[data-test-delete-account-modal] [data-test-submit-button]').isNotDisabled();
assert.ok(isAuthenticated());
// click "Delete Account" confirmation button
await click('[data-test-delete-account-modal] [data-test-submit-button]');
assert.verifySteps(['account-deleted']);
assert.notOk(isAuthenticated());
});
test('sorting search results', async function(assert) {
let addonA = server.create('addon', {
name: 'ember-try',
score: 3,
latestVersionDate: window.moment().subtract(2, 'days')
});
let addonB = server.create('addon', {
name: 'ember-blanket',
score: 2,
latestVersionDate: window.moment().subtract(3, 'days')
});
let addonC = server.create('addon', {
name: 'ember-foo',
score: 1,
latestVersionDate: window.moment().subtract(1, 'days')
});
server.get('/search/addons', () => {
return {
results: [
{
addon: addonA.id,
count: 1
},
{
addon: addonB.id,
count: 2
},
{
addon: addonC.id,
count: 3
}
]
};
});
await visit('/code-search');
await fillIn('#code-search-input', 'foo');
await click('.test-submit-search');
let nameSortButton = findByText('.test-sort button','Name');
let usageSortButton = findByText('.test-sort button', 'Usages');
let addonNames = findAll('.test-addon-name');
assert.dom(addonNames[0]).containsText('ember-blanket', 'Default sort is ascending by addon name');
assert.dom(addonNames[1]).containsText('ember-foo', 'Default sort is ascending by addon name');
assert.dom(addonNames[2]).containsText('ember-try', 'Default sort is ascending by addon name');
assert.dom(nameSortButton).hasClass('selected');
assert.ok(nameSortButton.querySelector('.icon-expand-less'));
await click(usageSortButton);
await percySnapshot('/code-search');
let resortedAddonNames = findAll('.test-addon-name');
assert.dom(resortedAddonNames[0]).containsText('ember-foo', 'Addons are sorted descending by default for switch to usage count sort');
assert.dom(resortedAddonNames[1]).containsText('ember-blanket', 'Addons are sorted descending by usage count');
assert.dom(resortedAddonNames[2]).containsText('ember-try', 'Addons are sorted descending by usage count');
assert.equal(currentURL(), '/code-search?codeQuery=foo&sort=usages&sortAscending=false', 'Sort and sort direction is in query params');
assert.dom(usageSortButton).hasClass('selected');
assert.ok(usageSortButton.querySelector('.icon-expand-more'));
await click(usageSortButton);
resortedAddonNames = findAll('.test-addon-name');
assert.dom(resortedAddonNames[0]).containsText('ember-try', 'Addons are sorted ascending by usage count when direction toggled');
assert.dom(resortedAddonNames[1]).containsText('ember-blanket', 'Addons are sorted ascending by usage count');
assert.dom(resortedAddonNames[2]).containsText('ember-foo', 'Addons are sorted ascending by usage count');
assert.equal(currentURL(), '/code-search?codeQuery=foo&sort=usages', 'Sort is in query params');
assert.dom(usageSortButton).hasClass('selected');
assert.ok(usageSortButton.querySelector('.icon-expand-less'));
await click(nameSortButton);
resortedAddonNames = findAll('.test-addon-name');
assert.dom(resortedAddonNames[0]).containsText('ember-blanket', 'Addons sorted ascending addon name');
assert.dom(resortedAddonNames[1]).containsText('ember-foo', 'Addons sorted ascending addon name');
assert.dom(resortedAddonNames[2]).containsText('ember-try', 'Addons sorted ascending addon name');
assert.equal(currentURL(), '/code-search?codeQuery=foo', 'Sort and sort direction not in query params when default');
assert.dom(nameSortButton).hasClass('selected');
assert.ok(nameSortButton.querySelector('.icon-expand-less'));
await click(nameSortButton);
resortedAddonNames = findAll('.test-addon-name');
assert.dom(resortedAddonNames[0]).containsText('ember-try', 'Addons sorted descending addon name');
assert.dom(resortedAddonNames[1]).containsText('ember-foo', 'Addons sorted descending addon name');
assert.dom(resortedAddonNames[2]).containsText('ember-blanket', 'Addons sorted descending addon name');
assert.equal(currentURL(), '/code-search?codeQuery=foo&sortAscending=false', 'Sort direction is in query params');
assert.dom(nameSortButton).hasClass('selected');
assert.ok(nameSortButton.querySelector('.icon-expand-more'));
await click(findByText('.test-sort button','Score'));
let scoreSortedAddonNames = findAll('.test-addon-name');
assert.dom(scoreSortedAddonNames[0]).containsText('ember-try', 'Addons are sorted by descending score by default');
assert.dom(scoreSortedAddonNames[1]).containsText('ember-blanket', 'Addons are sorted by score');
assert.dom(scoreSortedAddonNames[2]).containsText('ember-foo', 'Addons are sorted by score');
assert.equal(currentURL(), '/code-search?codeQuery=foo&sort=score&sortAscending=false', 'Sort is in query params');
await click(findByText('.test-sort button','Updated'));
let latestVersionDateSortedNames = findAll('.test-addon-name');
assert.dom(latestVersionDateSortedNames[0]).containsText('ember-foo', 'Addons are sorted by descending latest version date by default');
assert.dom(latestVersionDateSortedNames[1]).containsText('ember-try', 'Addons are sorted by latest version date');
assert.dom(latestVersionDateSortedNames[2]).containsText('ember-blanket', 'Addons are sorted by latest version date');
assert.equal(currentURL(), '/code-search?codeQuery=foo&sort=updated&sortAscending=false', 'Sort is in query params');
});