chore: 🤖 rip out all existing projects, orgs, and sub scopes

This commit is contained in:
Randall Morey committed 2020-10-27 13:39:46 -04:00
1 parent e8a015676f
commit 11d3b08b36
203 files changed
+68 -6575

No files matched your search

+11 -13
View File
@@ -6,7 +6,7 @@ import {
click,
find,
findAll,
setupOnerror,
//setupOnerror,
} from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
@@ -72,8 +72,8 @@ module('Acceptance | authentication', function (hooks) {
authMethodGlobalAuthenticateURL = `/scopes/global/authenticate/${globalAuthMethodID}`;
authMethodAuthenticateURL = `/scopes/${orgScopeID}/authenticate/${authMethodID}`;
changePasswordURL = `/account/change-password`;
orgsURL = `/scopes/global/orgs`;
projectsURL = `/scopes/${orgScopeID}/projects`;
orgsURL = `/scopes/global`;
projectsURL = `/scopes/${orgScopeID}`;
usersURL = `/scopes/${orgScopeID}/users`;
groupsURL = `/scopes/${orgScopeID}/groups`;
rolesURL = `/scopes/${orgScopeID}/roles`;
@@ -129,10 +129,10 @@ module('Acceptance | authentication', function (hooks) {
assert.notOk(currentSession().isAuthenticated);
});
test('visiting projects while unauthenticated redirects to first global authenticate method', async function (assert) {
test('visiting projects while unauthenticated redirects to first org authenticate method', async function (assert) {
assert.expect(2);
await visit(projectsURL);
assert.equal(currentURL(), authMethodGlobalAuthenticateURL);
assert.equal(currentURL(), authMethodAuthenticateURL);
assert.notOk(currentSession().isAuthenticated);
});
@@ -263,13 +263,11 @@ module('Acceptance | authentication', function (hooks) {
currentSession().isAuthenticated,
'Session begins authenticated, before encountering 401'
);
this.server.get('/scopes', () => new Response(401));
setupOnerror(() => {
assert.notOk(
currentSession().isAuthenticated,
'Session is unauthenticated, after encountering 401'
);
});
await visit(projectsURL);
this.server.get('/users', () => new Response(401));
await visit(usersURL);
assert.notOk(
currentSession().isAuthenticated,
'Session is unauthenticated, after encountering 401'
);
});
});
@@ -1,249 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, click, find, findAll } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | breadcrumbs', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
let orgScope;
let getProjectScope;
let project;
let hostCatalog;
let user;
let role;
let group;
let projectsURL, projectURL, newProjectURL;
let hostCatalogsURL, hostCatalogURL, newHostCatalogURL;
let usersURL, userURL, newUserURL;
let rolesURL, roleURL, newRoleURL;
let groupsURL, groupURL, newGroupURL;
let crumbPath;
hooks.beforeEach(function () {
authenticateSession({});
orgScope = this.server.create(
'scope',
{
type: 'org',
},
'withChildren'
);
getProjectScope = () =>
this.server.schema.scopes.where({ type: 'project' }).models[0];
project = getProjectScope();
user = this.server.create('user', { scope: orgScope });
role = this.server.create('role', { scope: orgScope });
group = this.server.create('group', { scope: orgScope });
hostCatalog = this.server.create('host-catalog', {
scope: getProjectScope(),
});
projectsURL = `/scopes/${orgScope.id}/projects`;
newProjectURL = `${projectsURL}/new`;
projectURL = `${projectsURL}/${project.id}`;
rolesURL = `/scopes/${orgScope.id}/roles`;
newRoleURL = `${rolesURL}/new`;
roleURL = `${rolesURL}/${role.id}`;
groupsURL = `/scopes/${orgScope.id}/groups`;
newGroupURL = `${groupsURL}/new`;
groupURL = `${groupsURL}/${group.id}`;
usersURL = `/scopes/${orgScope.id}/users`;
newUserURL = `${usersURL}/${user.id}`;
userURL = `${usersURL}/new`;
hostCatalogsURL = `${projectURL}/host-catalogs`;
newHostCatalogURL = `${hostCatalogsURL}/new`;
hostCatalogURL = `${hostCatalogsURL}/${hostCatalog.id}`;
});
test('can navigate via breadcrumbs to projects from project', async function (assert) {
assert.expect(3);
await visit(projectURL);
assert.equal(currentURL(), projectURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, projectURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
projectsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to projects from new project', async function (assert) {
assert.expect(3);
await visit(newProjectURL);
assert.equal(currentURL(), newProjectURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, newProjectURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
projectsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to project from host catalogs', async function (assert) {
assert.expect(3);
await visit(hostCatalogsURL);
assert.equal(
currentURL(),
hostCatalogsURL,
'We begin on the expected page.'
);
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, hostCatalogsURL, 'Last crumb has expected URL.');
await click(findAll('.rose-nav-breadcrumbs-link')[1]);
assert.equal(
currentURL(),
projectURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to host catalogs from host catalog', async function (assert) {
assert.expect(3);
await visit(hostCatalogURL);
assert.equal(
currentURL(),
hostCatalogURL,
'We begin on the expected page.'
);
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, hostCatalogURL, 'Last crumb has expected URL.');
await click(findAll('.rose-nav-breadcrumbs-link')[2]);
assert.equal(
currentURL(),
hostCatalogsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to host catalogs from new host catalog', async function (assert) {
assert.expect(3);
await visit(newHostCatalogURL);
assert.equal(
currentURL(),
newHostCatalogURL,
'We begin on the expected page.'
);
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, newHostCatalogURL, 'Last crumb has expected URL.');
await click(findAll('.rose-nav-breadcrumbs-link')[2]);
assert.equal(
currentURL(),
hostCatalogsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to roles from role', async function (assert) {
assert.expect(3);
await visit(roleURL);
assert.equal(currentURL(), roleURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, roleURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
rolesURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to roles from new role', async function (assert) {
assert.expect(3);
await visit(newRoleURL);
assert.equal(currentURL(), newRoleURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, newRoleURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
rolesURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to groups from group', async function (assert) {
assert.expect(3);
await visit(groupURL);
assert.equal(currentURL(), groupURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, groupURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
groupsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to groups from new group', async function (assert) {
assert.expect(3);
await visit(newGroupURL);
assert.equal(currentURL(), newGroupURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, newGroupURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
groupsURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to users from user', async function (assert) {
assert.expect(3);
await visit(userURL);
assert.equal(currentURL(), userURL, 'We begin on the expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, userURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
usersURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
test('can navigate via breadcrumbs to users from new user', async function (assert) {
assert.expect(3);
await visit(newUserURL);
assert.equal(currentURL(), newUserURL, 'We begin on th expected page.');
crumbPath = new URL(find('.rose-nav-breadcrumbs-link:last-child').href)
.pathname;
assert.equal(crumbPath, newUserURL, 'Last crumb has expected URL.');
await click(find('.rose-nav-breadcrumbs-link:first-child'));
assert.equal(
currentURL(),
usersURL,
'After navigating via breadcrumbs, we are one level up.'
);
});
});
@@ -1,217 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, fillIn, click, find } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | host catalogs', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
project: null,
},
hostCatalog: null,
};
const urls = {
orgScope: null,
projects: null,
project: null,
hostCatalogs: null,
newHostCatalog: null,
hostCatalog: null,
};
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession();
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: 'org' },
});
instances.hostCatalog = this.server.create('host-catalog', {
scope: instances.scopes.project,
});
// Generate route URLs for resources
urls.orgScope = `/scopes/${instances.scopes.org.id}`;
urls.projects = `${urls.orgScope}/projects`;
urls.project = `${urls.projects}/${instances.hostCatalog.scope.id}`;
urls.hostCatalogs = `${urls.project}/host-catalogs`;
urls.newHostCatalog = `${urls.hostCatalogs}/new`;
urls.hostCatalog = `${urls.hostCatalogs}/${instances.hostCatalog.id}`;
});
test('visiting host catalogs', async function (assert) {
assert.expect(1);
await visit(urls.hostCatalogs);
await a11yAudit();
assert.equal(currentURL(), urls.hostCatalogs);
});
test('can navigate to host catalog form', async function (assert) {
assert.expect(1);
await visit(urls.hostCatalogs);
await click('main tbody .rose-table-header-cell:nth-child(1) a');
await a11yAudit();
assert.equal(currentURL(), urls.hostCatalog);
});
test('can delete host catalog', async function (assert) {
assert.expect(2);
const hostCatalogsCount = this.server.db.hostCatalogs.length;
await visit(urls.hostCatalog);
assert.equal(currentURL(), urls.hostCatalog);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(this.server.db.hostCatalogs.length, hostCatalogsCount - 1);
});
test('can update host catalog and save changes', async function (assert) {
assert.expect(1);
await visit(urls.hostCatalog);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Test Name');
await click('form [type="submit"]:not(:disabled)');
assert.equal(this.server.db.hostCatalogs[0].name, 'Test Name');
});
test('can update host catalog and cancel changes', async function (assert) {
assert.expect(1);
await visit(urls.hostCatalog);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Test Name');
await click('form button:not([type="submit"])');
assert.notEqual(this.server.db.hostCatalogs[0].name, 'Test Name');
});
test('can create host catalog and save changes', async function (assert) {
assert.expect(1);
const hostCatalogsCount = this.server.db.hostCatalogs.length;
await visit(urls.newHostCatalog);
await fillIn('[name="name"]', 'Test Name');
await click('form [type="submit"]:not(:disabled)');
assert.equal(this.server.db.hostCatalogs.length, hostCatalogsCount + 1);
});
test('can create host catalog and cancel changes', async function (assert) {
assert.expect(1);
const hostCatalogsCount = this.server.db.hostCatalogs.length;
await visit(urls.newHostCatalog);
await fillIn('[name="name"]', 'Test Name');
await click('form button:not([type="submit"])');
assert.equal(this.server.db.hostCatalogs.length, hostCatalogsCount);
});
test('errors are displayed when delete host catalog fails', async function (assert) {
assert.expect(1);
this.server.del('/host-catalogs/:id', () => {
return new Response(
490,
{},
{
status: 490,
code: 'error',
message: 'Oops.',
}
);
});
await visit(urls.hostCatalog);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
await a11yAudit();
assert.ok(
find('[role="alert"]').textContent.trim(),
'Oops.',
'Displays primary error message.'
);
});
test('saving a new host catalog with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/host-catalogs', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.newHostCatalog);
await fillIn('[name="name"]', 'random string');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(
find('[role="alert"]').textContent.trim(),
'The request was invalid.',
'Displays primary error message.'
);
assert.ok(
find('.rose-form-error-message').textContent.trim(),
'Name is required.',
'Displays field-level errors.'
);
});
test('saving an existing host catalog with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.patch('/host-catalogs/:id', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.hostCatalog);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(
find('[role="alert"]').textContent.trim(),
'The request was invalid.',
'Displays primary error message.'
);
assert.ok(
find('.rose-form-error-message').textContent.trim(),
'Name is required.',
'Displays field-level errors.'
);
});
});
-203
View File
@@ -1,203 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, fillIn, click, find, findAll } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | host sets', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
project: null,
},
hostCatalog: null,
hostSet: null,
};
const urls = {
orgScope: null,
projects: null,
project: null,
hostCatalogs: null,
hostCatalog: null,
hostSets: null,
hostSet: null,
newHostSet: null
};
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession();
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: 'org' },
});
instances.hostCatalog = this.server.create('host-catalog', {
scope: instances.scopes.project,
});
instances.hostSet = this.server.create('host-set', {
scope: instances.scopes.project,
hostCatalog: instances.hostCatalog
});
// Generate route URLs for resources
urls.orgScope = `/scopes/${instances.scopes.org.id}`;
urls.projects = `${urls.orgScope}/projects`;
urls.project = `${urls.projects}/${instances.hostCatalog.scope.id}`;
urls.hostCatalogs = `${urls.project}/host-catalogs`;
urls.hostCatalog = `${urls.hostCatalogs}/${instances.hostCatalog.id}`;
urls.hostSets = `${urls.hostCatalog}/host-sets`;
urls.hostSet = `${urls.hostSets}/${instances.hostSet.id}`;
urls.newHostSet = `${urls.hostSets}/new`;
});
test('visiting a host set', async function (assert) {
assert.expect(1);
await visit(urls.hostSet);
await a11yAudit();
assert.equal(currentURL(), urls.hostSet);
});
test('can update a host set and save changes', async function (assert) {
assert.expect(3);
await visit(urls.hostSet);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Updated name');
await fillIn('[name="description"]', 'Updated description');
await click('.rose-form-actions [type="submit"]');
assert.equal(currentURL(), urls.hostSet);
assert.equal(this.server.db.hostSets[0].name, 'Updated name');
assert.equal(this.server.db.hostSets[0].description, 'Updated description');
});
test('can update a host set and cancel changes', async function (assert) {
assert.expect(1);
await visit(urls.hostSet);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Updated name');
await click('.rose-form-actions [type="button"]');
assert.notEqual(find('[name="name"]').value, 'Updated name');
});
test('can delete host set', async function (assert) {
assert.expect(2);
const hostSetsCount = this.server.db.hostSets.length;
await visit(urls.hostSet);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(currentURL(), urls.hostSets);
assert.equal(this.server.db.hostSets.length, hostSetsCount - 1);
});
test('saving an existing host set with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.patch('/host-sets/:id', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.hostSet);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'existing host');
await click('[type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
test('errors are displayed when delete on a host set fails', async function (assert) {
assert.expect(1);
this.server.del('/host-sets/:id', () => {
return new Response(
490,
{},
{
status: 490,
code: 'error',
message: 'Oops.',
}
);
});
await visit(urls.hostSet);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
await a11yAudit();
assert.ok(find('[role="alert"]'));
});
test('can create host set and save changes', async function (assert) {
assert.expect(1);
const hostSetsCount = this.server.db.hostSets.length;
await visit(urls.newHostSet);
await fillIn('[name="name"]', 'Test Name');
await fillIn('[name="description"]', 'description');
await click('form [type="submit"]:not(:disabled)');
await visit(urls.hostSets);
assert.equal(findAll('tbody tr').length, hostSetsCount + 1);
});
test('can create host set and cancel changes', async function (assert) {
assert.expect(2);
const hostSetsCount = this.server.db.hostSets.length;
await visit(urls.newHostSet);
await fillIn('[name="name"]', 'Test Name');
await click('form button:not([type="submit"])');
assert.equal(currentURL(), urls.hostSets);
assert.equal(findAll('tbody tr').length, hostSetsCount);
});
test('saving a new host set with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/host-sets', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.newHostSet);
await fillIn('[name="name"]', 'new target');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
});
@@ -1,235 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, click, find, findAll, fillIn } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | host-sets | hosts', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
project: null,
},
hostCatalog: null,
hostSet: null,
};
const urls = {
orgScope: null,
projects: null,
project: null,
hostCatalogs: null,
hostCatalog: null,
hostSets: null,
hostSet: null,
hostSetHosts: null,
addHosts: null,
newHost: null,
};
let hostSetHostsCount;
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession();
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: 'org' },
});
instances.hostCatalog = this.server.create('host-catalog', {
scope: instances.scopes.project,
}, 'withChildren');
instances.hostSet = this.server.schema.hostSets.all().models[0];
// Generate route URLs for resources
urls.orgScope = `/scopes/${instances.scopes.org.id}`;
urls.projects = `${urls.orgScope}/projects`;
urls.project = `${urls.projects}/${instances.hostCatalog.scope.id}`;
urls.hostCatalogs = `${urls.project}/host-catalogs`;
urls.hostCatalog = `${urls.hostCatalogs}/${instances.hostCatalog.id}`;
urls.hostSets = `${urls.hostCatalog}/host-sets`;
urls.hostSet = `${urls.hostSets}/${instances.hostSet.id}`;
urls.hostSetHosts = `${urls.hostSet}/hosts`;
urls.addHosts = `${urls.hostSet}/add-hosts`;
urls.newHost = `${urls.hostSet}/create-host`;
// Counts
hostSetHostsCount = instances.hostSet.hosts.length;
});
test('visiting host set hosts', async function (assert) {
assert.expect(2);
await visit(urls.hostSetHosts);
await a11yAudit();
assert.equal(currentURL(), urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, hostSetHostsCount);
});
test('can remove a host', async function (assert) {
assert.expect(2);
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, hostSetHostsCount);
await click('tbody tr .rose-dropdown-button-danger');
assert.equal(findAll('tbody tr').length, hostSetHostsCount - 1);
});
test('shows error message on host remove error', async function (assert) {
assert.expect(2);
this.server.post('/host-sets/:idMethod', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, hostSetHostsCount);
await click('tbody tr .rose-dropdown-button-danger');
assert.ok(find('[role="alert"]'));
});
test('visiting add hosts', async function(assert) {
assert.expect(1);
await visit(urls.addHosts);
await a11yAudit();
assert.equal(currentURL(), urls.addHosts);
});
test('select and save hosts to add', async function (assert) {
assert.expect(3);
instances.hostSet.update({ hostIds: [] });
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, 0);
await click('.rose-layout-page-actions a:nth-child(2)')
assert.equal(currentURL(), urls.addHosts);
// Click three times to select, unselect, then reselect (for coverage)
await click('tbody label');
await click('tbody label');
await click('tbody label');
await click('form [type="submit"]');
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, 1);
});
test('select and cancel hosts to add', async function (assert) {
assert.expect(4);
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, hostSetHostsCount);
await click('tbody tr .rose-dropdown-button-danger');
assert.equal(findAll('tbody tr').length, hostSetHostsCount - 1);
await click('.rose-layout-page-actions a:nth-child(2)')
assert.equal(currentURL(), urls.addHosts);
await click('tbody label');
await click('form [type="button"]');
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, hostSetHostsCount - 1);
});
test('shows error message on host add error', async function (assert) {
assert.expect(1);
this.server.post('/host-sets/:idMethod', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
instances.hostSet.update({ hostIds: [] });
await visit(urls.addHosts);
await click('tbody label');
await click('form [type="submit"]');
assert.ok(find('[role="alert"]'));
});
test('visiting host creation from a host set', async function (assert) {
assert.expect(1);
await visit(urls.newHost);
await a11yAudit();
assert.equal(currentURL(), urls.newHost);
});
test('create and add host to host set', async function (assert) {
assert.expect(3);
instances.hostSet.update({ hostIds: [] });
await visit(urls.hostSet);
assert.equal(findAll('tbody tr').length, 0);
await click('.rose-layout-page-actions a:nth-child(1)')
assert.equal(currentURL(), urls.newHost);
await fillIn('[name="name"]', 'Test Name');
await fillIn('[name="description"]', 'description');
await click('form [type="submit"]:not(:disabled)');
await visit(urls.hostSetHosts);
assert.equal(findAll('tbody tr').length, 1);
});
test('create and cancel host add to host set', async function (assert) {
assert.expect(1);
await visit(urls.newHost);
await click('form [type="button"]');
assert.equal(currentURL(), urls.hostSetHosts);
});
test('shows error message on host creation error', async function (assert) {
assert.expect(1);
this.server.post('/hosts', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
instances.hostSet.update({ hostIds: [] });
await visit(urls.newHost);
await fillIn('[name="name"]', 'New Host');
await click('form [type="submit"]');
assert.ok(find('[role="alert"]'));
});
test('shows error message on host addition to host set error', async function (assert) {
assert.expect(1);
this.server.post('/host-sets/:idMethod', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
instances.hostSet.update({ hostIds: [] });
await visit(urls.newHost);
await fillIn('[name="name"]', 'New Host');
await click('form [type="submit"]');
assert.ok(find('[role="alert"]'));
});
});
-205
View File
@@ -1,205 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, fillIn, click, find, findAll } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | hosts', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
project: null,
},
hostCatalog: null,
host: null,
};
const urls = {
orgScope: null,
projects: null,
project: null,
hostCatalogs: null,
hostCatalog: null,
hosts: null,
host: null,
newHost: null
};
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession();
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: 'org' },
});
instances.hostCatalog = this.server.create('host-catalog', {
scope: instances.scopes.project,
});
instances.host = this.server.create('host', {
scope: instances.scopes.project,
hostCatalog: instances.hostCatalog
});
// Generate route URLs for resources
urls.orgScope = `/scopes/${instances.scopes.org.id}`;
urls.projects = `${urls.orgScope}/projects`;
urls.project = `${urls.projects}/${instances.hostCatalog.scope.id}`;
urls.hostCatalogs = `${urls.project}/host-catalogs`;
urls.hostCatalog = `${urls.hostCatalogs}/${instances.hostCatalog.id}`;
urls.hosts = `${urls.hostCatalog}/hosts`;
urls.host = `${urls.hosts}/${instances.host.id}`;
urls.newHost = `${urls.hosts}/new`;
});
test('visiting a host', async function (assert) {
assert.expect(1);
await visit(urls.host);
await a11yAudit();
assert.equal(currentURL(), urls.host);
});
test('can update a host and save changes', async function (assert) {
assert.expect(4);
await visit(urls.host);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Updated name');
await fillIn('[name="description"]', 'Updated description');
await fillIn('[name="address"]', '::1');
await click('.rose-form-actions [type="submit"]');
assert.equal(currentURL(), urls.host);
assert.equal(this.server.db.hosts[0].name, 'Updated name');
assert.equal(this.server.db.hosts[0].description, 'Updated description');
assert.equal(this.server.db.hosts[0].attributes.address, '::1');
});
test('can update a host and cancel changes', async function (assert) {
assert.expect(1);
await visit(urls.host);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'Updated name');
await click('.rose-form-actions [type="button"]');
assert.notEqual(find('[name="name"]').value, 'Updated name');
});
test('can delete host', async function (assert) {
assert.expect(2);
const hostsCount = this.server.db.hosts.length;
await visit(urls.host);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(currentURL(), urls.hosts);
assert.equal(this.server.db.hosts.length, hostsCount - 1);
});
test('saving an existing host with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.patch('/hosts/:id', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.host);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'existing host');
await click('[type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
test('errors are displayed when delete on a host fails', async function (assert) {
assert.expect(1);
this.server.del('/hosts/:id', () => {
return new Response(
490,
{},
{
status: 490,
code: 'error',
message: 'Oops.',
}
);
});
await visit(urls.host);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
await a11yAudit();
assert.ok(find('[role="alert"]'));
});
test('can create host and save changes', async function (assert) {
assert.expect(1);
const hostsCount = this.server.db.hosts.length;
await visit(urls.newHost);
await fillIn('[name="name"]', 'Test Name');
await fillIn('[name="description"]', 'description');
await click('form [type="submit"]:not(:disabled)');
await visit(urls.hosts);
assert.equal(findAll('tbody tr').length, hostsCount + 1);
});
test('can create host and cancel changes', async function (assert) {
assert.expect(2);
const hostsCount = this.server.db.hosts.length;
await visit(urls.newHost);
await fillIn('[name="name"]', 'Test Name');
await click('form button:not([type="submit"])');
assert.equal(currentURL(), urls.hosts);
assert.equal(findAll('tbody tr').length, hostsCount);
});
test('saving a new host with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/hosts', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.newHost);
await fillIn('[name="name"]', 'new target');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
});
-148
View File
@@ -1,148 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, click, find, findAll, fillIn } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | org', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
},
orgs: null,
};
const urls = {
root: null,
scopes: null,
globalScope: null,
orgs: null,
newOrg: null,
};
let orgsCount;
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession({});
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.orgs = this.server.createList('scope', 2, {
type: 'org',
scope: { id: 'global', type: 'global' },
});
orgsCount = instances.orgs.length;
// Generate route URLs for resources
urls.root = '/';
urls.scopes = `/scopes`;
urls.globalScope = `${urls.scopes}/global`;
urls.orgs = `${urls.globalScope}/orgs`;
urls.newOrg = `${urls.orgs}/new`;
});
test('visiting orgs', async function (assert) {
assert.expect(3);
await visit(urls.orgs);
await a11yAudit();
assert.ok(orgsCount);
assert.equal(currentURL(), urls.orgs);
assert.equal(findAll('article').length, orgsCount);
});
test('visiting orgs when endpoint 404s shows an error message', async function (assert) {
assert.expect(1);
this.server.get('/scopes', () => new Response(404));
await visit(urls.orgs);
await a11yAudit();
assert.ok(find('.rose-message'));
});
test('visiting orgs is successful even when the global scope cannot be fetched', async function (assert) {
assert.expect(3);
this.server.get('/scopes/:id', ({ scopes }, { params: { id } }) => {
const scope = scopes.find(id);
return (id === 'global')
? new Response(404)
: scope;
});
await visit(urls.orgs);
await a11yAudit();
assert.ok(orgsCount);
assert.equal(currentURL(), urls.orgs);
assert.equal(findAll('article').length, orgsCount);
});
test('visiting scopes redirects to index', async function (assert) {
assert.expect(1);
await visit(urls.scopes);
assert.equal(currentURL(), urls.orgs);
});
test('visiting root redirects to index', async function (assert) {
assert.expect(1);
await visit(urls.root);
assert.equal(currentURL(), urls.orgs);
});
test('visiting orgs within a non global scope redirects to index', async function (assert) {
const nonGlobalScopeURL = `${urls.scopes}/123/orgs`;
assert.expect(1);
await visit(nonGlobalScopeURL);
assert.equal(currentURL(), urls.orgs);
});
test('can create a new org', async function (assert) {
assert.expect(1);
await visit(urls.newOrg);
await fillIn('[name="name"]', 'Org name');
await fillIn('[name="description"]', 'description');
await click('form [type="submit"]:not(:disabled)');
assert.equal(this.server.db.scopes.where(scope => scope.type === 'org').length, orgsCount + 1);
});
test('can cancel new org creation', async function (assert) {
assert.expect(2);
await visit(urls.newOrg);
await fillIn('[name="name"]', 'Org name');
await fillIn('[name="description"]', 'description');
await click('form button:not([type="submit"])');
assert.equal(currentURL(), urls.orgs);
assert.equal(this.server.db.scopes.where(scope => scope.type === 'org').length, orgsCount);
});
test('saving a new org with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/scopes', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.newOrg);
await fillIn('[name="name"]', 'new org');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
});
-264
View File
@@ -1,264 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, click, fillIn, find } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import { resolve, reject } from 'rsvp';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
import sinon from 'sinon';
module('Acceptance | projects', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
let org;
let orgID;
let projectsURL;
let newProjectURL;
let existingProject;
let existingProjectURL;
let getProjectScopesCount;
let getFirstProjectScope;
let initialProjectScopesCount;
hooks.beforeEach(function () {
authenticateSession({});
org = this.server.create('scope', { type: 'org' }, 'withChildren');
getProjectScopesCount = () =>
this.server.schema.scopes.where({ type: 'project' }).length;
getFirstProjectScope = () =>
this.server.schema.scopes.where({ type: 'project' }).models[0];
initialProjectScopesCount = getProjectScopesCount();
orgID = org.id;
projectsURL = `/scopes/${orgID}/projects`;
newProjectURL = `/scopes/${orgID}/projects/new`;
existingProject = getFirstProjectScope();
existingProjectURL = `/scopes/${orgID}/projects/${existingProject.id}`;
});
test('visiting projects', async function (assert) {
assert.expect(1);
await visit(projectsURL);
await a11yAudit();
assert.equal(currentURL(), projectsURL);
});
test('visiting projects within a project scope redirects to the parent org scope', async function (assert) {
assert.expect(2);
const wrongProjectsURL = `/scopes/${existingProject.id}/projects`;
assert.notEqual(wrongProjectsURL, projectsURL);
await visit(wrongProjectsURL);
await a11yAudit();
assert.equal(
currentURL(),
projectsURL,
'Wrong projects path was redirected to correct path.'
);
});
test('can create new projects', async function (assert) {
assert.expect(1);
await visit(newProjectURL);
await fillIn('[name="name"]', 'random string');
await click('[type="submit"]');
assert.equal(getProjectScopesCount(), initialProjectScopesCount + 1);
});
test('can cancel create new projects', async function (assert) {
assert.expect(3);
assert.equal(getProjectScopesCount(), initialProjectScopesCount);
await visit(newProjectURL);
await fillIn('[name="name"]', 'random string');
await click('.rose-form-actions [type="button"]');
assert.equal(currentURL(), projectsURL);
assert.equal(getProjectScopesCount(), initialProjectScopesCount);
});
test('saving a new project with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/scopes', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(newProjectURL);
await click('[type="submit"]');
assert.ok(
find('[role="alert"]').textContent.trim(),
'The request was invalid.',
'Displays primary error message.'
);
assert.ok(
find('.rose-form-error-message').textContent.trim(),
'Name is required.',
'Displays field-level errors.'
);
});
test('can save changes to existing project', async function (assert) {
assert.expect(3);
assert.notEqual(existingProject.name, 'random string');
await visit(existingProjectURL);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
await click('.rose-form-actions [type="submit"]');
assert.equal(currentURL(), existingProjectURL);
assert.equal(getFirstProjectScope().name, 'random string');
});
test('can cancel changes to existing project', async function (assert) {
assert.expect(2);
await visit(existingProjectURL);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
await click('.rose-form-actions [type="button"]');
assert.notEqual(existingProject.name, 'random string');
assert.equal(find('[name="name"]').value, existingProject.name);
});
test('can discard unsaved changes via dialog', async function (assert) {
assert.expect(5);
const confirmService = this.owner.lookup('service:confirm');
confirmService.enabled = true;
assert.notEqual(existingProject.name, 'random string');
await visit(existingProjectURL);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
assert.equal(currentURL(), existingProjectURL);
try {
await visit(projectsURL);
} catch (e) {
assert.ok(find('.rose-dialog'));
await click('.rose-dialog-footer button:first-child');
assert.equal(currentURL(), projectsURL);
assert.notEqual(getFirstProjectScope().name, 'random string');
}
});
test('can cancel discard unsaved changes via dialog', async function (assert) {
assert.expect(5);
const confirmService = this.owner.lookup('service:confirm');
confirmService.enabled = true;
assert.notEqual(existingProject.name, 'random string');
await visit(existingProjectURL);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
assert.equal(currentURL(), existingProjectURL);
try {
await visit(projectsURL);
} catch (e) {
assert.ok(find('.rose-dialog'));
await click('.rose-dialog-footer button:last-child');
assert.equal(currentURL(), existingProjectURL);
assert.notEqual(getFirstProjectScope().name, 'random string');
}
});
test('can delete project', async function (assert) {
assert.expect(1);
await visit(existingProjectURL);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(getProjectScopesCount(), initialProjectScopesCount - 1);
});
test('can delete project with confirmation acceptance', async function (assert) {
assert.expect(2);
const confirmService = this.owner.lookup('service:confirm');
confirmService.enabled = true;
confirmService.confirm = sinon.fake.returns(resolve());
await visit(existingProjectURL);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(getProjectScopesCount(), initialProjectScopesCount - 1);
assert.ok(confirmService.confirm.calledOnce);
});
test('cannot delete project with confirmation denial', async function (assert) {
assert.expect(2);
const confirmService = this.owner.lookup('service:confirm');
confirmService.enabled = true;
confirmService.confirm = sinon.fake.returns(reject());
await visit(existingProjectURL);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(getProjectScopesCount(), initialProjectScopesCount);
assert.ok(confirmService.confirm.calledOnce);
});
test('saving an existing project with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.patch('/scopes/:id', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(existingProjectURL);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'random string');
await click('[type="submit"]');
assert.ok(
find('[role="alert"]').textContent.trim(),
'The request was invalid.',
'Displays primary error message.'
);
assert.ok(
find('.rose-form-error-message').textContent.trim(),
'Name is required.',
'Displays field-level errors.'
);
});
test('errors are displayed when delete project fails', async function (assert) {
assert.expect(1);
this.server.del('/scopes/:id', () => {
return new Response(
490,
{},
{
status: 490,
code: 'error',
message: 'Oops.',
}
);
});
await visit(existingProjectURL);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.ok(
find('[role="alert"]').textContent.trim(),
'Oops.',
'Displays primary error message.'
);
});
});
-104
View File
@@ -1,104 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, findAll, find, click } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { run, later } from '@ember/runloop';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | sessions', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
},
sessions: null,
};
const urls = {
orgScope: null,
sessions: null,
};
hooks.beforeEach(function () {
authenticateSession({});
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: instances.scopes.org.type },
});
this.server.createList('group', 1, { scope: instances.scopes.org }, 'withMembers');
this.server.createList('host-catalog', 1, { scope: instances.scopes.project }, 'withChildren');
this.server.createList('target', 1, { scope: instances.scopes.project }, 'withRandomHostSets');
instances.sessions = this.server.createList('session', 3, {
scope: instances.scopes.project,
status: 'active'
}, 'withAssociations');
urls.sessions = `/scopes/${instances.scopes.org.id}/projects/${instances.scopes.project.id}/sessions`;
});
test('visiting sessions', async function (assert) {
assert.expect(2);
authenticateSession({});
later(async () => {
run.cancelTimers();
await a11yAudit();
assert.equal(currentURL(), urls.sessions);
assert.equal(findAll('tbody tr').length, instances.sessions.length);
}, 750);
await visit(urls.sessions);
});
test('visiting sessions without users or targets is OK', async function (assert) {
assert.expect(2);
instances.sessions[0].update({
userId: null,
targetId: null
});
authenticateSession({});
later(async () => {
run.cancelTimers();
await a11yAudit();
assert.equal(currentURL(), urls.sessions);
assert.equal(findAll('tbody tr').length, instances.sessions.length);
}, 750);
await visit(urls.sessions);
});
test('cancelling a session', async function (assert) {
assert.expect(2);
authenticateSession({});
later(async () => {
run.cancelTimers();
await click('tbody tr:first-child td:last-child button');
assert.ok(find('[role="alert"].is-success'));
}, 750);
await visit(urls.sessions);
assert.equal(currentURL(), urls.sessions);
});
test('cancelling a session with error shows notification', async function (assert) {
assert.expect(2);
this.server.post('/sessions/:id_method', () => new Response(400));
authenticateSession({});
later(async () => {
run.cancelTimers();
await click('tbody tr:first-child td:last-child button');
assert.ok(find('[role="alert"].is-error'));
}, 750);
await visit(urls.sessions);
assert.equal(currentURL(), urls.sessions);
});
});
-316
View File
@@ -1,316 +0,0 @@
import { module, test } from 'qunit';
import { visit, currentURL, click, find, findAll, fillIn } from '@ember/test-helpers';
import { setupApplicationTest } from 'ember-qunit';
import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
import a11yAudit from 'ember-a11y-testing/test-support/audit';
import { Response } from 'miragejs';
import {
authenticateSession,
// These are left here intentionally for future reference.
//currentSession,
//invalidateSession,
} from 'ember-simple-auth/test-support';
module('Acceptance | targets', function (hooks) {
setupApplicationTest(hooks);
setupMirage(hooks);
const instances = {
scopes: {
global: null,
org: null,
project: null,
},
target: null,
hostSets: null,
};
const urls = {
orgScope: null,
projects: null,
project: null,
targets: null,
newTarget: null,
target: null,
targetHostSets: null,
targetAddHostSets: null,
};
hooks.beforeEach(function () {
// Setup Mirage mock resources for this test
authenticateSession({});
instances.scopes.global = this.server.create('scope', { id: 'global' });
instances.scopes.org = this.server.create('scope', {
type: 'org',
scope: { id: 'global', type: 'global' },
});
instances.scopes.project = this.server.create('scope', {
type: 'project',
scope: { id: instances.scopes.org.id, type: 'org' },
});
instances.hostCatalog = this.server.create('host-catalog', {
scope: instances.scopes.project
}, 'withChildren');
instances.target = this.server.create('target', {
scope: instances.scopes.project,
hostSets: instances.hostCatalog.hostSets
});
// Generate route URLs for resources
urls.orgScope = `/scopes/${instances.scopes.org.id}`;
urls.projects = `${urls.orgScope}/projects`;
urls.project = `${urls.projects}/${instances.scopes.project.id}`;
urls.targets = `${urls.project}/targets`;
urls.newTarget = `${urls.targets}/new`;
urls.target = `${urls.targets}/${instances.target.id}`;
urls.targetHostSets = `${urls.target}/host-sets`;
urls.targetAddHostSets = `${urls.target}/add-host-sets`;
});
hooks.afterEach(async function() {
const notification = find('.rose-notification');
if(notification) {
await click('.rose-notification-dismiss');
}
});
test('visiting targets', async function (assert) {
assert.expect(1);
await visit(urls.targets);
await a11yAudit();
assert.equal(currentURL(), urls.targets);
});
test('can navigate to a target form', async function (assert) {
assert.expect(1);
await visit(urls.targets);
await click('main tbody .rose-table-header-cell:nth-child(1) a');
await a11yAudit();
assert.equal(currentURL(), urls.target);
});
test('can update a target and save changes', async function (assert) {
assert.expect(2);
await visit(urls.target);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'update name');
await fillIn('[name="default_port"]', '1234');
await click('form [type="submit"]:not(:disabled)');
assert.equal(this.server.db.targets[0].name, 'update name');
assert.equal(this.server.db.targets[0].attributes.default_port, '1234');
});
test('can update a target and cancel changes', async function (assert) {
assert.expect(2);
await visit(urls.target);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'update name');
await fillIn('[name="default_port"]', '1234');
await click('form button:not([type="submit"])');
assert.notEqual(this.server.db.targets[0].name, 'update name');
assert.notEqual(this.server.db.targets[0].port, '1234');
});
test('can create new target', async function (assert) {
assert.expect(1);
const targetsCount = this.server.db.targets.length;
await visit(urls.newTarget);
await fillIn('[name="name"]', 'Target name');
await fillIn('[name="description"]', 'description');
await fillIn('[name="default_port"]', '1234');
await click('form [type="submit"]:not(:disabled)');
assert.equal(this.server.db.targets.length, targetsCount + 1);
});
test('can cancel new target creation', async function (assert) {
assert.expect(2);
const targetsCount = this.server.db.targets.length;
await visit(urls.newTarget);
await fillIn('[name="name"]', 'Target Name');
await click('form button:not([type="submit"])');
assert.equal(this.server.db.targets.length, targetsCount);
assert.equal(currentURL(), urls.targets);
});
test('can delete a target', async function(assert) {
assert.expect(1);
const targetsCount = this.server.db.targets.length;
await visit(urls.target);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
assert.equal(this.server.db.targets.length, targetsCount - 1);
});
test('saving a new target with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.post('/targets', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.newTarget);
await fillIn('[name="name"]', 'new target');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
test('errors are displayed when delete on a target fails', async function (assert) {
assert.expect(1);
this.server.del('/targets/:id', () => {
return new Response(
490,
{},
{
status: 490,
code: 'error',
message: 'Oops.',
}
);
});
await visit(urls.target);
await click('.rose-layout-page-actions .rose-dropdown-button-danger');
await a11yAudit();
assert.ok(find('[role="alert"]'));
});
test('saving an existing target with invalid fields displays error messages', async function (assert) {
assert.expect(2);
this.server.patch('/targets/:id', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {
request_fields: [
{
name: 'name',
description: 'Name is required.',
},
],
},
}
);
});
await visit(urls.target);
await click('form [type="button"]', 'Activate edit mode');
await fillIn('[name="name"]', 'existing target');
await click('form [type="submit"]');
await a11yAudit();
assert.ok(find('[role="alert"]'));
assert.ok(find('.rose-form-error-message'));
});
test('visiting target host sets', async function (assert) {
assert.expect(3);
const targetHostSetCount = instances.target.hostSets.length;
await visit(urls.targetHostSets);
await a11yAudit();
assert.equal(currentURL(), urls.targetHostSets);
assert.ok(targetHostSetCount);
assert.equal(findAll('tbody tr').length, targetHostSetCount);
});
test('can remove a host sets', async function (assert) {
assert.expect(2);
const targetHostSetCount = instances.target.hostSets.length;
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, targetHostSetCount);
await click('tbody tr .rose-dropdown-button-danger');
assert.equal(findAll('tbody tr').length, targetHostSetCount - 1);
});
test('shows error message on host set remove', async function (assert) {
assert.expect(2);
this.server.post('/targets/:idMethod', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
const targetHostSetCount = instances.target.hostSets.length;
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, targetHostSetCount);
await click('tbody tr .rose-dropdown-button-danger');
assert.ok(find('[role="alert"]'));
});
test('select and save host sets to add', async function (assert) {
assert.expect(3);
instances.target.update({ hostSetIds: [] });
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, 0);
await click('.rose-layout-page-actions a')
assert.equal(currentURL(), urls.targetAddHostSets);
// Click three times to select, unselect, then reselect (for coverage)
await click('tbody label');
await click('tbody label');
await click('tbody label');
await click('form [type="submit"]');
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, 1);
});
test('select and cancel host sets to add', async function (assert) {
assert.expect(4);
const targetHostSetCount = instances.target.hostSets.length;
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, targetHostSetCount);
// first, remove a target host set (otherwise none would be available to add)
await click('tbody tr .rose-dropdown-button-danger');
assert.equal(findAll('tbody tr').length, targetHostSetCount - 1);
await click('.rose-layout-page-actions a')
assert.equal(currentURL(), urls.targetAddHostSets);
await click('tbody label');
await click('form [type="button"]');
await visit(urls.targetHostSets);
assert.equal(findAll('tbody tr').length, targetHostSetCount - 1);
});
test('shows error message on host set add', async function (assert) {
assert.expect(4);
this.server.post('/targets/:idMethod', () => {
return new Response(
400,
{},
{
status: 400,
code: 'invalid_argument',
message: 'The request was invalid.',
details: {},
}
);
});
instances.target.update({ hostSetIds: [] });
await visit(urls.targetAddHostSets);
assert.equal(instances.target.hostSets.length, 0);
assert.equal(currentURL(), urls.targetAddHostSets);
await click('tbody label');
await click('form [type="submit"]');
assert.equal(currentURL(), urls.targetAddHostSets);
assert.equal(instances.target.hostSets.length, 0);
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/host-catalog', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::HostCatalog
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/host-set', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::HostSet
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
// import { render } from '@ember/test-helpers';
// import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/host-set/add-hosts', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
assert.expect(0);
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/host', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::Host
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/org', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::Org
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/project', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::Project
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,23 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
import { render, find } from '@ember/test-helpers';
import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/target', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
// Set any properties with this.set('myProperty', 'value');
// Handle any actions with this.set('myAction', function(val) { ... });
this.submit = () => {};
this.cancel = () => {};
await render(hbs`
<Form::Target
@submit={{this.submit}}
@cancel={{this.cancel}}
/>`);
assert.ok(find('form'));
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupRenderingTest } from 'ember-qunit';
// import { render } from '@ember/test-helpers';
// import { hbs } from 'ember-cli-htmlbars';
module('Integration | Component | form/target/add-host-sets', function (hooks) {
setupRenderingTest(hooks);
test('it renders', async function (assert) {
assert.expect(0);
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/orgs', function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup('controller:scopes/scope/orgs');
assert.ok(controller);
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/orgs/new', function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup('controller:scopes/scope/orgs/new');
assert.ok(controller);
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects', function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup('controller:scopes/scope/projects');
assert.ok(controller);
});
});
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects/new', function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup('controller:scopes/scope/projects/new');
assert.ok(controller);
});
});
@@ -1,14 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects/project', function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project'
);
assert.ok(controller);
});
});
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set'
);
assert.ok(controller);
});
}
);
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/create-host', function(hooks) {
setupTest(hooks);
// TODO: Replace this with your real tests.
test('it exists', function(assert) {
let controller = this.owner.lookup('controller:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/create-host');
assert.ok(controller);
});
});
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/new',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/new'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/hosts',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/hosts'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/new',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/new'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/host-catalogs/new',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/host-catalogs/new'
);
assert.ok(controller);
});
}
);
@@ -1,12 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects/project/sessions', function(hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function(assert) {
let controller = this.owner.lookup('controller:scopes/scope/projects/project/sessions');
assert.ok(controller);
});
});
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Controller | scopes/scope/projects/project/targets', function (
hooks
) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/targets'
);
assert.ok(controller);
});
});
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/targets/new',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/targets/new'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/targets/target',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/targets/target'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/targets/target/add-host-sets',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/targets/target/add-host-sets'
);
assert.ok(controller);
});
}
);
@@ -1,17 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Controller | scopes/scope/projects/project/targets/target/host-sets',
function (hooks) {
setupTest(hooks);
// Replace this with your real tests.
test('it exists', function (assert) {
let controller = this.owner.lookup(
'controller:scopes/scope/projects/project/targets/target/host-sets'
);
assert.ok(controller);
});
}
);
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/orgs', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/orgs');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/orgs/index', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/orgs/index');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/orgs/new', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/orgs/new');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/projects');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/index', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/projects/index');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/new', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/projects/new');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/projects/project');
assert.ok(route);
});
});
@@ -1,15 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/host-catalogs', function (
hooks
) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs'
);
assert.ok(route);
});
});
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/add-hosts',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/add-hosts'
);
assert.ok(route);
});
}
);
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/create-host', function(hooks) {
setupTest(hooks);
test('it exists', function(assert) {
let route = this.owner.lookup('route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/create-host');
assert.ok(route);
});
});
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/hosts',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/hosts'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/host-set/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/new',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/host-sets/new'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/hosts',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/hosts'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/host/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/hosts/new',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/hosts/new'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/host-catalog/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/host-catalog/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/index'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/host-catalogs/new',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/host-catalogs/new'
);
assert.ok(route);
});
}
);
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/index', function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup('route:scopes/scope/projects/project/index');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/sessions', function(hooks) {
setupTest(hooks);
test('it exists', function(assert) {
let route = this.owner.lookup('route:scopes/scope/projects/project/sessions');
assert.ok(route);
});
});
@@ -1,11 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/sessions/index', function(hooks) {
setupTest(hooks);
test('it exists', function(assert) {
let route = this.owner.lookup('route:scopes/scope/projects/project/sessions/index');
assert.ok(route);
});
});
@@ -1,15 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/targets', function (
hooks
) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets'
);
assert.ok(route);
});
});
@@ -1,15 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/targets/index', function (
hooks
) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/index'
);
assert.ok(route);
});
});
@@ -1,15 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/targets/new', function (
hooks
) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/new'
);
assert.ok(route);
});
});
@@ -1,15 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module('Unit | Route | scopes/scope/projects/project/targets/target', function (
hooks
) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/target'
);
assert.ok(route);
});
});
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/targets/target/add-host-sets',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/target/add-host-sets'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/targets/target/host-sets',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/target/host-sets'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/targets/target/host-sets/host-set',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/target/host-sets/host-set'
);
assert.ok(route);
});
}
);
@@ -1,16 +0,0 @@
import { module, test } from 'qunit';
import { setupTest } from 'ember-qunit';
module(
'Unit | Route | scopes/scope/projects/project/targets/target/index',
function (hooks) {
setupTest(hooks);
test('it exists', function (assert) {
let route = this.owner.lookup(
'route:scopes/scope/projects/project/targets/target/index'
);
assert.ok(route);
});
}
);