` this repository
+* `cd test-app`
+* `npm install`
+
+## Running / Development
+
+* `npm run start`
+* Visit your app at [http://localhost:4200](http://localhost:4200).
+* Visit your tests at [http://localhost:4200/tests](http://localhost:4200/tests).
+
+### Code Generators
+
+Make use of the many generators for code, try `ember help generate` for more details
+
+### Running Tests
+
+* `npm run test`
+* `npm run test:ember -- --server`
+
+### Linting
+
+* `npm run lint`
+* `npm run lint:fix`
+
+### Building
+
+* `npm exec ember build` (development)
+* `npm run build` (production)
+
+### Deploying
+
+Specify what it takes to deploy your app.
+
+## Further Reading / Useful Links
+
+* [ember.js](https://emberjs.com/)
+* [ember-cli](https://cli.emberjs.com/release/)
+* Development Browser Extensions
+ * [ember inspector for chrome](https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi)
+ * [ember inspector for firefox](https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/)
diff --git a/test-app/app/adapters/application.js b/test-app/app/adapters/application.js
new file mode 100644
index 00000000..b2250b16
--- /dev/null
+++ b/test-app/app/adapters/application.js
@@ -0,0 +1,26 @@
+import JSONAPIAdapter from '@ember-data/adapter/json-api';
+import { service } from '@ember/service';
+import ENV from 'test-app/config/environment';
+
+export default class ApplicationAdapter extends JSONAPIAdapter {
+ namespace = 'api';
+ host = ENV.api;
+
+ @service session;
+
+ get headers() {
+ if (this.session.isAuthenticated) {
+ return {
+ Authorization: `Bearer ${this.session.data.authenticated.token}`,
+ };
+ } else {
+ return {};
+ }
+ }
+
+ handleResponse(status) {
+ if (status === 401 && this.session.isAuthenticated) {
+ this.session.invalidate();
+ }
+ }
+}
\ No newline at end of file
diff --git a/test-app/app/app.js b/test-app/app/app.js
new file mode 100644
index 00000000..1ba93424
--- /dev/null
+++ b/test-app/app/app.js
@@ -0,0 +1,12 @@
+import Application from '@ember/application';
+import Resolver from 'ember-resolver';
+import loadInitializers from 'ember-load-initializers';
+import config from 'test-app/config/environment';
+
+export default class App extends Application {
+ modulePrefix = config.modulePrefix;
+ podModulePrefix = config.podModulePrefix;
+ Resolver = Resolver;
+}
+
+loadInitializers(App, config.modulePrefix);
diff --git a/test-app/app/components/header.hbs b/test-app/app/components/header.hbs
new file mode 100644
index 00000000..f37e0240
--- /dev/null
+++ b/test-app/app/components/header.hbs
@@ -0,0 +1,6 @@
+
+ - Home Page
+ - Secure Page
+
+
+Access token {{if this.willTokenRefresh "refresh" "expires"}} in: {{this.displayMinutes}}:{{this.displaySeconds}}
diff --git a/test-app/app/components/header.js b/test-app/app/components/header.js
new file mode 100644
index 00000000..32ffd02d
--- /dev/null
+++ b/test-app/app/components/header.js
@@ -0,0 +1,96 @@
+import Component from '@glimmer/component';
+import { action } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+import { service } from '@ember/service';
+import ENV from 'test-app/config/environment';
+
+export default class HeaderComponent extends Component {
+ @service router;
+ @service session;
+
+ willTokenRefresh = false;
+ countdown = null;
+ refreshLeeway = 0;
+ @tracked remainingMinutes = 0;
+ @tracked remainingSeconds = 0;
+
+ get displayMinutes() {
+ return this.remainingMinutes.toString();
+ }
+
+ get displaySeconds() {
+ let seconds = this.remainingSeconds.toString();
+ return seconds.length < 2 ? '0' + seconds : seconds;
+ }
+
+ constructor() {
+ super(...arguments);
+ if (ENV['ember-simple-auth-token'].refreshAccessTokens) {
+ this.willTokenRefresh = true;
+ if (typeof ENV['ember-simple-auth-token'].refreshLeeway !== 'undefined') {
+ this.refreshLeeway = ENV['ember-simple-auth-token'].refreshLeeway * 1000;
+ }
+ }
+
+ if (ENV.environment.match(/test/) === null) {
+ this.setCountdown();
+ }
+ }
+
+ setCountdown() {
+ let minutes = 0;
+ let seconds = 0;
+ let now = new Date().valueOf();
+ let diff = Math.round((this.session.data.authenticated.exp * 1000) - (now + this.refreshLeeway));
+ if (diff < 0) {
+ setTimeout(() => {
+ this.setCountdown();
+ }, 500);
+ return;
+ }
+ let mod = 0;
+ if (diff >= 60000) {
+ mod = diff % 60000;
+ minutes = (diff - mod) / 60000;
+ seconds = Math.round(mod / 1000);
+ } else {
+ seconds = Math.round(diff / 1000);
+ }
+ this.remainingSeconds = seconds;
+ if (minutes) {
+ this.remainingMinutes = minutes;
+ }
+ setTimeout(() => {
+ this.doCountdown();
+ }, 1000);
+ }
+
+ doCountdown() {
+ if (this.remainingSeconds === 0) {
+ this.remainingMinutes = this.remainingMinutes - 1;
+ this.remainingSeconds = 59;
+ } else {
+ this.remainingSeconds = this.remainingSeconds - 1;
+ }
+ if (this.remainingSeconds === 0 && this.remainingMinutes === 0) {
+ setTimeout(() => {
+ this.setCountdown();
+ }, 500);
+ return;
+ }
+ setTimeout(() => {
+ this.doCountdown();
+ }, 1000);
+ }
+
+ @action
+ logout() {
+ if (ENV.environment.match(/test/) === null) {
+ this.session.invalidate();
+ } else {
+ this.session.invalidate().then(() => { // ember-simple-auth does not transition on session.invalidate() in tests
+ this.router.transitionTo('login');
+ });
+ }
+ }
+}
diff --git a/test-app/app/controllers/login.js b/test-app/app/controllers/login.js
new file mode 100644
index 00000000..dd244a02
--- /dev/null
+++ b/test-app/app/controllers/login.js
@@ -0,0 +1,52 @@
+import Controller from '@ember/controller';
+import { service } from '@ember/service';
+import { action } from '@ember/object';
+import { tracked } from '@glimmer/tracking';
+
+export default class LoginController extends Controller {
+ @service session;
+ @service router;
+
+ @tracked errorMessage = '';
+ username = 'admin';
+ password = 'abc123';
+
+ @action
+ async authenticate(e) {
+ this.errorMessage = '';
+ e.preventDefault();
+ e.stopPropagation();
+ this.session.authenticate('authenticator:jwt', {username: this.username, password: this.password}).catch(err => {
+ if (err.status === 401) {
+ this.errorMessage = 'Incorrect username or password';
+ return;
+ }
+ let errorMessage = '';
+ if (err.text) {
+ try {
+ if (this.isJsonResponse(err.text)) {
+ errorMessage = JSON.parse(err.text).errors[0].message;
+ } else {
+ errorMessage = err.text;
+ }
+ } catch(er) {
+ this.errorMessage = 'An unexpected error occurred. ' + er.toString();
+ }
+ } else {
+ errorMessage = err;
+ }
+ this.errorMessage = errorMessage;
+ });
+ }
+
+ isJsonResponse(response) {
+ if (typeof response !== 'string') return false;
+ try {
+ const result = JSON.parse(response);
+ const type = Object.prototype.toString.call(result);
+ return type === '[object Object]' || type === '[object Array]';
+ } catch (err) {
+ return false;
+ }
+ }
+}
diff --git a/tests/dummy/app/index.html b/test-app/app/index.html
similarity index 78%
rename from tests/dummy/app/index.html
rename to test-app/app/index.html
index 61400b20..98584848 100644
--- a/tests/dummy/app/index.html
+++ b/test-app/app/index.html
@@ -2,15 +2,14 @@
-
- Dummy
+ ember-simple-auth-token
{{content-for "head"}}
-
+
{{content-for "head-footer"}}
@@ -18,7 +17,7 @@
{{content-for "body"}}
-
+
{{content-for "body-footer"}}
diff --git a/test-app/app/router.js b/test-app/app/router.js
new file mode 100644
index 00000000..bb7c74c6
--- /dev/null
+++ b/test-app/app/router.js
@@ -0,0 +1,16 @@
+import EmberRouter from '@ember/routing/router';
+import config from 'test-app/config/environment';
+
+export default class Router extends EmberRouter {
+ location = config.locationType;
+ rootURL = config.rootURL;
+}
+
+Router.map(function () {
+ this.route('login');
+ this.route('authenticated', { path: '' }, function() {
+ // all routes that require the session to be authenticated
+ this.route('index', { path: '' });
+ this.route('secure');
+ });
+});
diff --git a/test-app/app/routes/application.js b/test-app/app/routes/application.js
new file mode 100644
index 00000000..0d7678ba
--- /dev/null
+++ b/test-app/app/routes/application.js
@@ -0,0 +1,17 @@
+import Route from '@ember/routing/route';
+import { inject } from '@ember/service';
+//import ENV from 'test-app/config/environment';
+
+export default class ApplicationRoute extends Route {
+ @inject session;
+
+ async beforeModel() {
+ // test if the api solution (mirage / express) is running
+ /*fetch(`${ENV.api}/api/helloworld`).then(response => {
+ response.text().then(text => {
+ console.log(JSON.parse(text).message);
+ });
+ });*/
+ await this.session.setup();
+ }
+}
diff --git a/test-app/app/routes/authenticated.js b/test-app/app/routes/authenticated.js
new file mode 100644
index 00000000..5dcc2e09
--- /dev/null
+++ b/test-app/app/routes/authenticated.js
@@ -0,0 +1,10 @@
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+
+export default class AuthenticatedRoute extends Route {
+ @service session;
+
+ beforeModel(transition) {
+ this.session.requireAuthentication(transition, 'login');
+ }
+}
diff --git a/test-app/app/routes/authenticated/index.js b/test-app/app/routes/authenticated/index.js
new file mode 100644
index 00000000..ecf85b95
--- /dev/null
+++ b/test-app/app/routes/authenticated/index.js
@@ -0,0 +1,3 @@
+import Route from '../authenticated';
+
+export default class IndexRoute extends Route {}
diff --git a/test-app/app/routes/authenticated/secure.js b/test-app/app/routes/authenticated/secure.js
new file mode 100644
index 00000000..335980c9
--- /dev/null
+++ b/test-app/app/routes/authenticated/secure.js
@@ -0,0 +1,3 @@
+import Route from '../authenticated';
+
+export default class SecureRoute extends Route {}
diff --git a/test-app/app/routes/login.js b/test-app/app/routes/login.js
new file mode 100644
index 00000000..4c53ef54
--- /dev/null
+++ b/test-app/app/routes/login.js
@@ -0,0 +1,10 @@
+import Route from '@ember/routing/route';
+import { inject } from '@ember/service';
+
+export default class LoginRoute extends Route {
+ @inject session;
+
+ beforeModel() {
+ this.session.prohibitAuthentication('authenticated.index');
+ }
+}
diff --git a/test-app/app/services/store.js b/test-app/app/services/store.js
new file mode 100644
index 00000000..fa482881
--- /dev/null
+++ b/test-app/app/services/store.js
@@ -0,0 +1 @@
+export { default } from '@ember-data/store';
diff --git a/test-app/app/styles/app.css b/test-app/app/styles/app.css
new file mode 100644
index 00000000..2fe8647b
--- /dev/null
+++ b/test-app/app/styles/app.css
@@ -0,0 +1,10 @@
+/* Ember supports plain CSS out of the box. More info: https://cli.emberjs.com/release/advanced-use/stylesheets/ */
+ul {
+ display: inline-block;
+ padding-left: 0;
+}
+
+li {
+ display: inline;
+ margin-right: 5px;
+}
\ No newline at end of file
diff --git a/test-app/app/templates/application.hbs b/test-app/app/templates/application.hbs
new file mode 100644
index 00000000..e2147cab
--- /dev/null
+++ b/test-app/app/templates/application.hbs
@@ -0,0 +1 @@
+{{outlet}}
\ No newline at end of file
diff --git a/test-app/app/templates/authenticated.hbs b/test-app/app/templates/authenticated.hbs
new file mode 100644
index 00000000..4a2aa2cc
--- /dev/null
+++ b/test-app/app/templates/authenticated.hbs
@@ -0,0 +1,3 @@
+
+
+{{outlet}}
diff --git a/test-app/app/templates/authenticated/index.hbs b/test-app/app/templates/authenticated/index.hbs
new file mode 100644
index 00000000..12cb8b28
--- /dev/null
+++ b/test-app/app/templates/authenticated/index.hbs
@@ -0,0 +1,2 @@
+Home Page
+This is a protected page only visible to authenticated users! Refreshing the page will keep the user logged in. Navigating to /login while authenticated will redirect to /index.
diff --git a/test-app/app/templates/authenticated/secure.hbs b/test-app/app/templates/authenticated/secure.hbs
new file mode 100644
index 00000000..58306f56
--- /dev/null
+++ b/test-app/app/templates/authenticated/secure.hbs
@@ -0,0 +1,2 @@
+Secure Page
+This is a protected page only visible to authenticated users! Refreshing the page will keep the user logged in. Navigating to /login while authenticated will redirect to /index.
diff --git a/test-app/app/templates/login.hbs b/test-app/app/templates/login.hbs
new file mode 100644
index 00000000..0423b5a8
--- /dev/null
+++ b/test-app/app/templates/login.hbs
@@ -0,0 +1,9 @@
+Login
+
\ No newline at end of file
diff --git a/test-app/config/ember-try.js b/test-app/config/ember-try.js
new file mode 100644
index 00000000..de74a31a
--- /dev/null
+++ b/test-app/config/ember-try.js
@@ -0,0 +1,88 @@
+'use strict';
+
+const getChannelURL = require('ember-source-channel-url');
+
+module.exports = async function() {
+ return Promise.all([
+ getChannelURL('release'),
+ getChannelURL('beta'),
+ getChannelURL('canary')
+ ]).then(urls => {
+ return {
+ scenarios: [
+ {
+ name: 'ember-lts-4.4-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': '^4.4.0',
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-lts-4.8-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': '^4.8.0',
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-lts-4.12-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': '^4.12.0',
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-lts-5.4-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': '^5.4.0',
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-lts-5.8-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': '^5.8.0',
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-release-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': urls[0],
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-beta-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': urls[1],
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ },
+ {
+ name: 'ember-canary-ember-simple-auth-6.0',
+ npm: {
+ devDependencies: {
+ 'ember-source': urls[2],
+ 'ember-simple-auth': '^6.0.0'
+ }
+ }
+ }
+ ]
+ };
+ });
+};
diff --git a/test-app/config/environment.js b/test-app/config/environment.js
new file mode 100644
index 00000000..b4dde63b
--- /dev/null
+++ b/test-app/config/environment.js
@@ -0,0 +1,112 @@
+'use strict';
+
+const { MIRAGE_SCENARIO } = process.env;
+
+module.exports = function (environment) {
+ const ENV = {
+ modulePrefix: 'test-app',
+ environment,
+ rootURL: '/',
+ locationType: 'history',
+ EmberENV: {
+ EXTEND_PROTOTYPES: false,
+ FEATURES: {
+ // Here you can enable experimental features on an ember canary build
+ // e.g. EMBER_NATIVE_DECORATOR_SUPPORT: true
+ },
+ },
+
+ APP: {
+ // Here you can pass flags/options to your application instance
+ // when it is created
+ },
+
+ MIRAGE_SCENARIO,
+
+ };
+
+ ENV['ember-simple-auth'] = {
+ routeAfterAuthentication: 'authenticated.index',
+ routeAfterInvalidation: 'login',
+ };
+
+ if (environment === 'development') { // run the test-app with express api
+ // ENV.APP.LOG_RESOLVER = true;
+ // ENV.APP.LOG_ACTIVE_GENERATION = true;
+ // ENV.APP.LOG_TRANSITIONS = true;
+ // ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
+ // ENV.APP.LOG_VIEW_LOOKUPS = true;
+
+ ENV['ember-simple-auth-token'] = {
+ serverTokenEndpoint: 'http://localhost:3000/api/token-auth',
+ serverTokenRefreshEndpoint: 'http://localhost:3000/api/token-refresh/',
+ refreshAccessTokens: true,
+ refreshLeeway: 1
+ }
+
+ ENV['ember-cli-mirage'] = {
+ enabled: false
+ };
+ ENV.api = 'http://localhost:3000';
+ }
+
+ if (environment === 'mirage') { // run the test-app with mirage api mock
+ ENV['ember-simple-auth-token'] = {
+ serverTokenEndpoint: 'http://localhost:8080/api/token-auth',
+ serverTokenRefreshEndpoint: 'http://localhost:8080/api/token-refresh/',
+ refreshAccessTokens: true,
+ refreshLeeway: 1
+ }
+
+ ENV['ember-cli-mirage'] = {
+ enabled: true
+ };
+ ENV.api = 'http://localhost:8080';
+ }
+
+ if (environment === 'mirage-test') { // for viewing tests in the browser; localhost:4201/tests;
+ ENV['ember-simple-auth-token'] = {
+ serverTokenEndpoint: 'http://localhost:8080/api/token-auth',
+ serverTokenRefreshEndpoint: 'http://localhost:8080/api/token-refresh/',
+ refreshAccessTokens: false,
+ refreshLeeway: 1,
+ disableScheduleAccessTokenExpiration: true
+ }
+
+ ENV['ember-cli-mirage'] = {
+ enabled: false // mirage is started in the tests
+ };
+ ENV.api = 'http://localhost:8080';
+ ENV.locationType = 'none';
+ ENV.APP.LOG_ACTIVE_GENERATION = false;
+ ENV.APP.LOG_VIEW_LOOKUPS = false;
+ ENV.APP.rootElement = '#ember-testing';
+ ENV.APP.autoboot = false;
+ }
+
+ if (environment === 'test') {
+ ENV['ember-simple-auth-token'] = {
+ serverTokenEndpoint: 'http://localhost:8080/api/token-auth',
+ serverTokenRefreshEndpoint: 'http://localhost:8080/api/token-refresh/',
+ refreshAccessTokens: false,
+ refreshLeeway: 1,
+ disableScheduleAccessTokenExpiration: true
+ }
+
+ ENV['ember-cli-mirage'] = {
+ enabled: true
+ };
+ ENV.api = 'http://localhost:8080';
+ // Testem prefers this...
+ ENV.locationType = 'none';
+
+ // keep test console output quieter
+ ENV.APP.LOG_ACTIVE_GENERATION = false;
+ ENV.APP.LOG_VIEW_LOOKUPS = false;
+
+ ENV.APP.rootElement = '#ember-testing';
+ ENV.APP.autoboot = false;
+ }
+
+ return ENV;
+};
diff --git a/test-app/config/optional-features.json b/test-app/config/optional-features.json
new file mode 100644
index 00000000..5329dd99
--- /dev/null
+++ b/test-app/config/optional-features.json
@@ -0,0 +1,7 @@
+{
+ "application-template-wrapper": false,
+ "default-async-observers": true,
+ "jquery-integration": false,
+ "template-only-glimmer-components": true,
+ "no-implicit-route-model": true
+}
diff --git a/test-app/config/targets.js b/test-app/config/targets.js
new file mode 100644
index 00000000..1e48e059
--- /dev/null
+++ b/test-app/config/targets.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const browsers = [
+ 'last 1 Chrome versions',
+ 'last 1 Firefox versions',
+ 'last 1 Safari versions',
+];
+
+module.exports = {
+ browsers,
+};
diff --git a/test-app/ember-cli-build.js b/test-app/ember-cli-build.js
new file mode 100644
index 00000000..afa19ce0
--- /dev/null
+++ b/test-app/ember-cli-build.js
@@ -0,0 +1,30 @@
+'use strict';
+
+const EmberApp = require('ember-cli/lib/broccoli/ember-app');
+const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
+
+module.exports = function (defaults) {
+ let app = new EmberApp(defaults, {
+ autoImport: {
+ watchDependencies: ['ember-simple-auth-token'],
+ }
+ });
+
+ /*const { maybeEmbroider } = require('@embroider/test-setup');
+ return maybeEmbroider(app);*/
+
+ const { Webpack } = require('@embroider/webpack');
+ return require('@embroider/compat').compatBuild(app, Webpack, {
+ packagerOptions: {
+ webpackConfig: {
+ node: {global: true},
+ plugins: [
+ new NodePolyfillPlugin({
+ includeAliases: ['Buffer', 'crypto', 'fs', 'process', 'stream', 'util', 'vm']
+ })
+ ],
+ devtool: 'eval-source-map' // optional for browser tools debugging
+ },
+ },
+ });
+};
diff --git a/test-app/mirage/config.js b/test-app/mirage/config.js
new file mode 100644
index 00000000..9720cab7
--- /dev/null
+++ b/test-app/mirage/config.js
@@ -0,0 +1,87 @@
+import { createServer, Response } from 'miragejs';
+import { sign, verify } from 'jsonwebtoken';
+
+const secret = '0123456789';
+const algorithm = 'HS512';
+const expiration = '5m';
+
+const payload = {
+ userAccount: {
+ id: '7a887474-26bb-43ec-a063-6b8c6aba727e',
+ firstName: 'test',
+ lastName: 'user'
+ }
+};
+
+const options = {
+ expiresIn: expiration,
+ algorithm: algorithm
+};
+
+export default function (config) {
+ const finalConfig = {
+ ...config,
+ // uncomment to opt into ember-cli-mirage to auto discover ember serializers
+ // serializers: applyEmberDataSerializers(config.serializers),
+ routes,
+ };
+
+ return createServer(finalConfig);
+}
+
+function routes() {
+ this.urlPrefix = 'http://localhost:8080';
+ /* Note: these only affect routes defined *after* them! */
+
+ this.namespace = '/api';
+ this.timing = 0; // delay for each request, automatically set to 0 during testing
+
+ /*
+ Shorthand cheatsheet:
+
+ this.get('/posts');
+ this.post('/posts');
+ this.get('/posts/:id');
+ this.put('/posts/:id'); // or this.patch
+ this.del('/posts/:id');
+
+ https://miragejs.com/docs/getting-started/overview/
+ */
+
+ this.get('/helloworld', function() {
+ return {message: 'Hello World!'};
+ });
+
+ this.post('/token-auth', function(schema, request) {
+ let body = JSON.parse(request.requestBody);
+ if (body.username === 'admin' && body.password === 'abc123') {
+ let token = sign(payload, secret, options);
+ return {
+ token: token,
+ refresh_token: token
+ };
+ } else {
+ return new Response(401, {}, {errors: [{status: 401, message: 'Incorrect email or password'}]});
+ }
+ });
+
+ this.post('/token-refresh', function(schema, request) {
+ return verify(JSON.parse(request.requestBody).refresh_token, secret, function(err, decoded) {
+ if (err) {
+ return new Response(401, {}, {errors: [{status: 401, message: 'Incorrect email or password'}]});
+ } else {
+ delete decoded.iat;
+ delete decoded.exp;
+ let token = sign(decoded, secret, options);
+ return {
+ token: token,
+ refresh_token: token
+ };
+ }
+ });
+ });
+
+ this.post('/endpoint', function() {
+ return {response: 'true'}
+ });
+}
diff --git a/test-app/package.json b/test-app/package.json
new file mode 100644
index 00000000..46178af1
--- /dev/null
+++ b/test-app/package.json
@@ -0,0 +1,92 @@
+{
+ "name": "test-app",
+ "private": true,
+ "description": "Test app for ember-simple-auth-token addon",
+ "repository": "https://github.com/fenichelar/ember-simple-auth-token",
+ "license": "MIT",
+ "author": {
+ "name": "Alec Fenichel"
+ },
+ "directories": {
+ "doc": "doc",
+ "test": "tests"
+ },
+ "scripts": {
+ "build": "ember build --environment=production",
+ "lint": "concurrently \"npm:lint:*(!fix)\" --names \"lint:\"",
+ "lint:css": "stylelint \"**/*.css\"",
+ "lint:css:fix": "concurrently \"npm:lint:css -- --fix\"",
+ "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
+ "lint:hbs": "ember-template-lint .",
+ "lint:hbs:fix": "ember-template-lint . --fix",
+ "lint:js": "eslint . --cache",
+ "lint:js:fix": "eslint . --fix",
+ "start": "ember serve",
+ "test": "concurrently \"npm:lint\" \"npm:test:*\" --names \"lint,test:\"",
+ "test:ember": "ember test"
+ },
+ "devDependencies": {
+ "@babel/core": "^7.25.2",
+ "@babel/eslint-parser": "^7.23.10",
+ "@babel/plugin-proposal-decorators": "^7.24.0",
+ "@ember/optional-features": "^2.1.0",
+ "@ember/string": "^3.1.1",
+ "@ember/test-helpers": "^3.3.0",
+ "@embroider/compat": "^3.6.0",
+ "@embroider/test-setup": "^4.0.0",
+ "@embroider/webpack": "^4.0.4",
+ "@glimmer/component": "^1.1.2",
+ "@glimmer/tracking": "^1.1.2",
+ "body-parser": "1.20.2",
+ "broccoli-asset-rev": "^3.0.0",
+ "concurrently": "^8.2.2",
+ "ember-auto-import": "^2.7.2",
+ "ember-cli": "~5.10.0",
+ "ember-cli-app-version": "^6.0.1",
+ "ember-cli-babel": "^8.2.0",
+ "ember-cli-clean-css": "^3.0.0",
+ "ember-cli-dependency-checker": "^3.3.2",
+ "ember-cli-htmlbars": "^6.3.0",
+ "ember-cli-inject-live-reload": "^2.1.0",
+ "ember-cli-mirage": "3.0.3",
+ "ember-cli-sri": "^2.1.1",
+ "ember-cli-terser": "^4.0.2",
+ "ember-data": "~5.3.3",
+ "ember-load-initializers": "^2.1.2",
+ "ember-modifier": "^4.1.0",
+ "ember-qunit": "^8.0.2",
+ "ember-resolver": "^11.0.1",
+ "ember-simple-auth": "~6.0.0",
+ "ember-simple-auth-token": "^6.0.0",
+ "ember-source": "~5.4.1",
+ "ember-source-channel-url": "^3.0.0",
+ "ember-template-lint": "^5.13.0",
+ "ember-try": "^3.0.0",
+ "eslint": "^8.57.0",
+ "eslint-plugin-ember": "^11.12.0",
+ "eslint-plugin-n": "^16.6.2",
+ "eslint-plugin-qunit": "^8.1.1",
+ "express": "4.19.2",
+ "glob": "10.3.12",
+ "jsonwebtoken": "8.5.1",
+ "loader.js": "^4.7.0",
+ "morgan": "1.10.0",
+ "node-polyfill-webpack-plugin": "^3.0.0",
+ "qunit": "^2.20.1",
+ "qunit-dom": "^2.0.0",
+ "sinon": "4.2.2",
+ "stylelint": "^15.11.0",
+ "stylelint-config-standard": "^34.0.0",
+ "tracked-built-ins": "^3.3.0",
+ "webpack": "^5.90.3"
+ },
+ "peerDependencies": {
+ "miragejs": "0.1.48"
+ },
+ "engines": {
+ "node": ">= 16 <=20"
+ },
+ "ember": {
+ "edition": "octane"
+ }
+}
diff --git a/test-app/public/favicon.ico b/test-app/public/favicon.ico
new file mode 100644
index 00000000..acd6a52f
Binary files /dev/null and b/test-app/public/favicon.ico differ
diff --git a/tests/dummy/public/robots.txt b/test-app/public/robots.txt
similarity index 100%
rename from tests/dummy/public/robots.txt
rename to test-app/public/robots.txt
diff --git a/test-app/server/index.js b/test-app/server/index.js
new file mode 100644
index 00000000..d971c3db
--- /dev/null
+++ b/test-app/server/index.js
@@ -0,0 +1,34 @@
+module.exports = function() {
+ if (['mirage', 'mirage-test', 'test'].includes(process.env.EMBER_ENV)) {
+ return false;
+ }
+ const express = require('express');
+ const app = express();
+ const { globSync } = require('glob');
+ var mocks = globSync('server/mocks/api/*.js', {cwd: process.cwd()});
+
+ // Log proxy requests
+ var morgan = require('morgan');
+ app.use(morgan('dev'));
+
+ app.get('/api/helloworld', function(req, res) {
+ res.set('Access-Control-Allow-Origin', 'http://localhost:4201');
+ res.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+ return res.send({message: 'Hello World!'});
+ });
+
+ app.options('/api/*', function(req, res) {
+ res.set('Access-Control-Allow-Origin', 'http://localhost:4201');
+ res.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+ return res.status(200).end();
+ });
+
+ mocks.map(function(cwd, len, fileNames) {
+ fileNames.forEach(function(fileName) {
+ var route = require('.' + fileName.replace('server', ''));
+ route(app);
+ })
+ });
+ console.log('express is running on localhost:3000');
+ app.listen(3000);
+};
diff --git a/server/mocks/api/token-auth.js b/test-app/server/mocks/api/token-auth.js
similarity index 51%
rename from server/mocks/api/token-auth.js
rename to test-app/server/mocks/api/token-auth.js
index 53df136d..3c05aabf 100644
--- a/server/mocks/api/token-auth.js
+++ b/test-app/server/mocks/api/token-auth.js
@@ -5,12 +5,20 @@ module.exports = function(app) {
var apiTokenAuthRouter = express.Router();
apiTokenAuthRouter.post('/', function(req, res) {
- jwt.sign(req.body, 'secret', { expiresIn: 10 }, function(err, token) {
+ res.set('Access-Control-Allow-Origin', 'http://localhost:4201');
+ res.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+
+ if (req.body.username !== 'admin' || req.body.password !== 'abc123') {
+ return res.send(401);
+ }
+
+ jwt.sign(req.body, 'secret', { expiresIn: '5m' }, function(err, token) {
if (err) {
return res.send(500);
}
return res.send({
- token: token
+ token: token,
+ refresh_token: token
});
});
});
diff --git a/server/mocks/api/token-refresh.js b/test-app/server/mocks/api/token-refresh.js
similarity index 60%
rename from server/mocks/api/token-refresh.js
rename to test-app/server/mocks/api/token-refresh.js
index ebda5b73..015b4a56 100644
--- a/server/mocks/api/token-refresh.js
+++ b/test-app/server/mocks/api/token-refresh.js
@@ -5,7 +5,10 @@ module.exports = function(app) {
var apiTokenRefreshRouter = express.Router();
apiTokenRefreshRouter.post('/', function(req, res) {
- jwt.verify(req.body.token, 'secret', function(err, decoded) {
+ res.set('Access-Control-Allow-Origin', 'http://localhost:4201');
+ res.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+
+ jwt.verify(req.body.refresh_token, 'secret', function(err, decoded) {
if (err) {
return res.status(401).send({
error: err
@@ -13,8 +16,10 @@ module.exports = function(app) {
} else {
delete decoded.iat;
delete decoded.exp;
+ var token = jwt.sign(decoded, 'secret', { expiresIn: '5m' });
return res.send({
- token: jwt.sign(decoded, 'secret', { expiresIn: 10 })
+ token: token,
+ refresh_token: token
});
}
});
diff --git a/testem.js b/test-app/testem.js
similarity index 70%
rename from testem.js
rename to test-app/testem.js
index a729a835..ed2f3712 100644
--- a/testem.js
+++ b/test-app/testem.js
@@ -1,26 +1,23 @@
+'use strict';
+
module.exports = {
test_page: 'tests/index.html?hidepassed',
disable_watching: true,
- launch_in_ci: [
- 'Chrome'
- ],
- launch_in_dev: [
- 'Chrome'
- ],
+ launch_in_ci: ['Chrome'],
+ launch_in_dev: ['Chrome'],
+ browser_start_timeout: 120,
browser_args: {
Chrome: {
ci: [
// --no-sandbox is needed when running Chrome inside a container
process.env.CI ? '--no-sandbox' : null,
-
- '--disable-gpu',
'--headless',
'--disable-dev-shm-usage',
'--disable-software-rasterizer',
'--mute-audio',
'--remote-debugging-port=0',
- '--window-size=1440,900'
- ].filter(Boolean)
- }
- }
+ '--window-size=1440,900',
+ ].filter(Boolean),
+ },
+ },
};
diff --git a/test-app/tests/acceptance/login-test.js b/test-app/tests/acceptance/login-test.js
new file mode 100644
index 00000000..b5779b7f
--- /dev/null
+++ b/test-app/tests/acceptance/login-test.js
@@ -0,0 +1,56 @@
+import { module, test } from 'qunit';
+import { click, fillIn, visit, currentURL, settled, waitFor } from '@ember/test-helpers';
+import { setupApplicationTest } from 'test-app/tests/helpers';
+import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
+
+module('Acceptance | login', function (hooks) {
+ setupApplicationTest(hooks);
+ setupMirage(hooks);
+
+ test('successful login/logout', async function (assert) {
+ assert.expect(3);
+ await visit('/login');
+
+ assert.strictEqual(currentURL(), '/login');
+
+ await fillIn('#username', 'admin');
+ await fillIn('#password', 'abc123');
+
+ await click('#btn-login');
+
+ await waitFor('#h1-home', { timeout: 2000 })
+
+ assert.dom('#h1-home').hasText('Home Page');
+
+ await click('#btn-logout');
+
+ await waitFor('#h1-login', { timeout: 2000 })
+
+ assert.strictEqual(currentURL(), '/login');
+ });
+
+ test('unsuccessful login', async function (assert) {
+ assert.expect(2);
+ await visit('/login');
+
+ assert.strictEqual(currentURL(), '/login');
+
+ await fillIn('#username', 'admin');
+ await fillIn('#password', 'invalid');
+
+ await click('#btn-login');
+
+ await settled();
+
+ assert.dom('#error-message').hasText('Incorrect username or password');
+ });
+
+ test('redirect to login', async function (assert) {
+ assert.expect(1);
+ await visit('/secure');
+
+ await settled();
+
+ assert.strictEqual(currentURL(), '/login');
+ });
+});
diff --git a/test-app/tests/helpers/index.js b/test-app/tests/helpers/index.js
new file mode 100644
index 00000000..d37dd680
--- /dev/null
+++ b/test-app/tests/helpers/index.js
@@ -0,0 +1,42 @@
+import {
+ setupApplicationTest as upstreamSetupApplicationTest,
+ setupRenderingTest as upstreamSetupRenderingTest,
+ setupTest as upstreamSetupTest,
+} from 'ember-qunit';
+
+// This file exists to provide wrappers around ember-qunit's
+// test setup functions. This way, you can easily extend the setup that is
+// needed per test type.
+
+function setupApplicationTest(hooks, options) {
+ upstreamSetupApplicationTest(hooks, options);
+
+ // Additional setup for application tests can be done here.
+ //
+ // For example, if you need an authenticated session for each
+ // application test, you could do:
+ //
+ // hooks.beforeEach(async function () {
+ // await authenticateSession(); // ember-simple-auth
+ // });
+ //
+ // This is also a good place to call test setup functions coming
+ // from other addons:
+ //
+ // setupIntl(hooks); // ember-intl
+ // setupMirage(hooks); // ember-cli-mirage
+}
+
+function setupRenderingTest(hooks, options) {
+ upstreamSetupRenderingTest(hooks, options);
+
+ // Additional setup for rendering tests can be done here.
+}
+
+function setupTest(hooks, options) {
+ upstreamSetupTest(hooks, options);
+
+ // Additional setup for unit tests can be done here.
+}
+
+export { setupApplicationTest, setupRenderingTest, setupTest };
diff --git a/tests/index.html b/test-app/tests/index.html
similarity index 66%
rename from tests/index.html
rename to test-app/tests/index.html
index 5209b852..e4b2e696 100644
--- a/tests/index.html
+++ b/test-app/tests/index.html
@@ -2,8 +2,7 @@
-
- Dummy Tests
+ TestApp Tests
@@ -11,7 +10,7 @@
{{content-for "test-head"}}
-
+
{{content-for "head-footer"}}
@@ -21,10 +20,17 @@
{{content-for "body"}}
{{content-for "test-body"}}
-
+
+
+
+
-
+
{{content-for "body-footer"}}
diff --git a/test-app/tests/test-helper.js b/test-app/tests/test-helper.js
new file mode 100644
index 00000000..81843044
--- /dev/null
+++ b/test-app/tests/test-helper.js
@@ -0,0 +1,12 @@
+import Application from 'test-app/app';
+import config from 'test-app/config/environment';
+import * as QUnit from 'qunit';
+import { setApplication } from '@ember/test-helpers';
+import { setup } from 'qunit-dom';
+import { start } from 'ember-qunit';
+
+setApplication(Application.create(config.APP));
+
+setup(QUnit.assert);
+
+start();
diff --git a/test-app/tests/unit/authenticators/jwt-test.js b/test-app/tests/unit/authenticators/jwt-test.js
new file mode 100644
index 00000000..2a53dece
--- /dev/null
+++ b/test-app/tests/unit/authenticators/jwt-test.js
@@ -0,0 +1,661 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'test-app/tests/helpers';
+import { setupMirage } from 'ember-cli-mirage/test-support';
+import { getSettledState } from '@ember/test-helpers';
+import { sign } from 'jsonwebtoken';
+import sinon from 'sinon';
+
+const secret = '0123456789';
+
+const payload = {
+ userAccount: {
+ id: '7a887474-26bb-43ec-a063-6b8c6aba727e',
+ firstName: 'test',
+ lastName: 'user'
+ }
+};
+
+const options = {
+ expiresIn: '5m',
+ algorithm: 'HS512',
+};
+
+module('Unit | Authenticator | authenticators/jwt.js', function (hooks) {
+ setupTest(hooks);
+ setupMirage(hooks);
+
+ hooks.beforeEach(function() {
+ this.owner.application.jwt = this.owner.lookup('authenticator:jwt');
+ });
+
+ const createFakeCredentials = () => {
+ return {
+ username: 'admin',
+ password: 'abc123'
+ };
+ };
+
+ const createFakeToken = obj => {
+ let encryptPayload = {...payload};
+ let encryptOptions = {...options};
+ if (typeof obj === 'string'){
+ return `a.${btoa(JSON.stringify(obj))}.b`;
+ } else if (obj) {
+ if (obj.exp) {
+ encryptOptions.expiresIn = obj.exp;
+ } else if (obj.username) {
+ encryptPayload = obj;
+ }
+ }
+ return sign(encryptPayload, secret, encryptOptions);
+ };
+
+ const getConvertedTime = time => {
+ return Math.round(time / 1000);
+ };
+
+ const clearState = jwt => {
+ let state = getSettledState();
+ if (state.hasPendingTimers || state.hasRunLoop) {
+ jwt.cancelAllTimers();
+ }
+ };
+
+ test('authenticators/jwt exists', function(assert) {
+ assert.expect(1);
+ assert.ok(this.owner.application.jwt.getCurrentTime());
+ });
+
+ test('getCurrentTime works', function(assert) {
+ assert.expect(1);
+ assert.strictEqual(this.owner.application.jwt.getCurrentTime(), Math.floor(new Date().valueOf() / 1000));
+ });
+
+ test('#restore resolves when the data includes `token` and `expiresAt`', function(assert) {
+ assert.expect(1);
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const tokenData = {
+ exp: expiresAt
+ };
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const data = {
+ token: token,
+ exp: expiresAt,
+ tokenData: tokenData
+ };
+
+ this.owner.application.jwt.restore(data).then(content => {
+ assert.propEqual(content, data);
+ });
+ });
+
+ test('#restore resolves when the data includes `token` and excludes `expiresAt`', function(assert) {
+ assert.expect(1);
+
+ const token = createFakeToken();
+ const data = {
+ token: token
+ };
+
+ this.owner.application.jwt.restore(data).then(content => {
+ assert.propEqual(content, data);
+ });
+ });
+
+
+ test('#restore resolves when the data includes `token` and `expiresAt` and the token is expired', function(assert) {
+ assert.expect(1);
+
+ const expiresAt = getConvertedTime(Date.now()) - 60 * 60;
+ const tokenData = {
+ exp: expiresAt
+ };
+ const token = createFakeToken(tokenData);
+ const refreshToken = createFakeToken();
+ const data = {
+ token: token,
+ refresh_token: refreshToken,
+ exp: expiresAt,
+ tokenData: tokenData
+ };
+
+ this.owner.application.jwt.restore(data).catch(err => {
+ assert.strictEqual(err.toString(), 'Error: token is expired');
+ });
+ });
+
+ test('#restore rejects when the data includes `token` and `expiresAt`, the token is expired, and `refreshAccessTokens` is false', function(assert) {
+ assert.expect(1);
+
+ const expiresAt = getConvertedTime(Date.now()) - 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const data = {
+ token: token,
+ exp: expiresAt
+ };
+
+ this.owner.application.jwt.restore(data).catch(err => {
+ assert.strictEqual(err.toString(), 'Error: token is expired');
+ });
+ });
+
+ test('#restore resolves when the data includes `token` and `expiresAt` and `tokenPropertyName` is a nested object', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.tokenPropertyName = 'auth.nested.token';
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const data = {
+ auth: {
+ nested: {
+ token: token
+ }
+ },
+ exp: expiresAt
+ };
+
+ this.owner.application.jwt.restore(data).then(content => {
+ assert.propEqual(content, data);
+ });
+ });
+
+ test('#restore rejects when `token` is excluded', function(assert) {
+ assert.expect(1);
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const data = {
+ token: null,
+ exp: expiresAt
+ };
+
+ this.owner.application.jwt.restore(data).catch(response => {
+ assert.strictEqual(response.toString(), 'Error: empty token');
+ });
+ });
+
+ test('#restore schedules a token refresh when `refreshAccessTokens` is true', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshAccessTokens = true;
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const refreshToken = createFakeToken();
+ const data = {
+ token: token,
+ exp: expiresAt,
+ refresh_token: refreshToken
+ };
+
+ this.owner.application.jwt.restore(data).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#restore does not schedule a token refresh when `refreshAccessTokens` is false', function(assert) {
+ assert.expect(1);
+
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const refreshToken = createFakeToken();
+ const credentials = createFakeCredentials();
+ const data = {
+ token: token,
+ exp: expiresAt,
+ refresh_token: refreshToken
+ };
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.jwt.restore(data).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 0);
+ });
+ });
+
+ test('#restore immediately refreshes the token when the token is expired', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshAccessTokens = true;
+ sinon.spy(this.owner.application.jwt, 'refreshAccessToken');
+
+ const expiresAt = getConvertedTime(Date.now()) - 60;
+ let token = createFakeToken({
+ exp: expiresAt
+ });
+
+ const data = {
+ token: token,
+ exp: expiresAt,
+ refresh_token: token
+ };
+ this.owner.application.jwt.restore(data).then(() => {
+ assert.strictEqual(this.owner.application.jwt.refreshAccessToken.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#restore schedules a token refresh when the token is farther than the `refreshLeeway` to expiration', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshLeeway = 1;
+ this.owner.application.jwt.refreshAccessTokens = true;
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const refreshToken = createFakeToken();
+ const data = {
+ token: token,
+ exp: expiresAt,
+ refresh_token: refreshToken
+ };
+
+ this.owner.application.jwt.restore(data).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#restore immediately refreshes the token when the token is closer than the `refreshLeeway` to expiration', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshLeeway = 120;
+ this.owner.application.jwt.refreshAccessTokens = true;
+ sinon.spy(this.owner.application.jwt, 'refreshAccessToken');
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const refreshToken = createFakeToken();
+ const data = {
+ token: token,
+ exp: expiresAt,
+ refresh_token: refreshToken
+ };
+
+ this.owner.application.jwt.restore(data).then(() => {
+ assert.strictEqual(this.owner.application.jwt.refreshAccessToken.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#authenticate successfully resolves with the correct data', function(assert) {
+ assert.expect(1);
+
+ const token = createFakeToken();
+ const refreshToken = createFakeToken();
+ const credentials = createFakeCredentials();
+ const response = {
+ token: token,
+ refresh_token: refreshToken
+ };
+
+ this.server.post('/token-auth', () => ({
+ token: token,
+ refresh_token: refreshToken
+ }), 200);
+
+ this.owner.application.jwt.authenticate(credentials).then(data => {
+ delete data.exp;
+ delete data.tokenData;
+ assert.propEqual(data, response);
+ });
+ });
+
+ test('#authenticate sends a fetch request to the token endpoint', function(assert) {
+ assert.expect(4);
+
+ const token = createFakeToken();
+ const credentials = createFakeCredentials();
+
+ this.server.post('/token-auth', () => ({
+ token: token,
+ refresh_token: token
+ }), 200);
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.jwt.authenticate(credentials);
+ });
+
+ test('#authenticate sends a fetch request to the token endpoint when `tokenPropertyName` is a nested object', function(assert) {
+ assert.expect(4);
+
+ this.owner.application.jwt.tokenPropertyName = 'auth.nested.token';
+
+ const token = createFakeToken();
+
+ this.server.post('/token-auth', () => ({
+ auth: {nested: {token: token}},
+ refresh_token: token
+ }), 200);
+
+ const credentials = createFakeCredentials();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.jwt.authenticate(credentials);
+ });
+
+ test('#authenticate sends an fetch request with custom headers', function(assert) {
+ assert.expect(4);
+
+ this.owner.application.jwt.headers = {
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': 0,
+ 'Accept': 'application/json'
+ };
+
+ const credentials = createFakeCredentials();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': '0',
+ }));
+ };
+
+ this.owner.application.jwt.authenticate(credentials);
+ });
+
+ test('#authenticate sends an fetch request with dynamic headers', function(assert) {
+ assert.expect(4);
+
+ const headers = {
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': 0,
+ 'Accept': 'application/json'
+ };
+
+ const credentials = createFakeCredentials();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': '0',
+ }));
+ };
+
+ this.owner.application.jwt.authenticate(credentials, headers);
+ });
+
+ test('#authenticate rejects with the correct error', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.authenticate({username: 'admin', password: 'incorrectPassword'}).catch(error => {
+ assert.strictEqual(error.status, 401);
+ });
+ });
+
+ test('#authenticate schedules a token refresh when `refreshAccessTokens` is true', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshAccessTokens = true;
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const credentials = createFakeCredentials();
+
+ this.owner.application.jwt.authenticate(credentials).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#authenticate does not schedule a token refresh when `refreshAccessTokens` is false', function(assert) {
+ assert.expect(1);
+
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const credentials = createFakeCredentials();
+
+ this.owner.application.jwt.authenticate(credentials).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 0);
+ });
+ });
+
+ test('#authenticate immediately refreshes the token when the token is expired', function(assert) {
+ assert.expect(1);
+
+ sinon.spy(this.owner.application.jwt, 'refreshAccessToken');
+
+ const credentials = createFakeCredentials();
+
+ this.owner.application.jwt.authenticate(credentials).then(() => {
+ assert.strictEqual(this.owner.application.jwt.refreshAccessToken.callCount, 0);
+ });
+ });
+
+ test('#authenticate schedules a token refresh when the token is farther than the `refreshLeeway` to expiration', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.jwt.refreshAccessTokens = true;
+ this.owner.application.jwt.refreshLeeway = 1;
+ sinon.spy(this.owner.application.jwt, 'scheduleAccessTokenRefresh');
+
+ const credentials = createFakeCredentials();
+
+ this.owner.application.jwt.authenticate(credentials).then(() => {
+ assert.strictEqual(this.owner.application.jwt.scheduleAccessTokenRefresh.callCount, 1);
+ clearState(this.owner.application.jwt);
+ });
+ });
+
+ test('#refreshAccessToken sends a fetch request to the refresh token endpoint', function(assert) {
+ assert.expect(4);
+
+ const refreshToken = createFakeToken();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-refresh/');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify({refresh_token: refreshToken}));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken);
+ });
+
+ test('#refreshAccessToken sends an fetch request to the refresh token endpoint when `refreshTokenPropertyName` is a nested object', function(assert) {
+ assert.expect(4);
+
+ this.owner.application.jwt.tokenPropertyName = 'auth.nested.token';
+ this.owner.application.jwt.refreshTokenPropertyName = 'auth.nested.refreshToken';
+
+ const token = createFakeToken();
+ const refreshToken = createFakeToken();
+
+ this.server.post('/token-refresh', () => ({
+ auth: {nested: {token: token}},
+ refresh_token: token
+ }), 200);
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-refresh/');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify({
+ auth: {
+ nested: {
+ refreshToken: refreshToken
+ }
+ }
+ }));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken);
+ });
+
+ test('#refreshAccessToken sends an fetch request with custom headers', function(assert) {
+ assert.expect(4);
+
+ this.owner.application.jwt.headers = {
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': 0,
+ 'Accept': 'application/json'
+ };
+
+ const refreshToken = createFakeToken();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-refresh/');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify({refresh_token: refreshToken}));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': '0',
+ }));
+ };
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken);
+ });
+
+ test('#refreshAccessToken triggers the `sessionDataUpdated` event on successful request', function(assert) {
+ assert.expect(3);
+
+ const expiresAt = getConvertedTime(Date.now()) + 60;
+ const token = createFakeToken({
+ exp: expiresAt
+ });
+ const refreshToken = createFakeToken();
+
+ this.server.post('/token-refresh', () => ({
+ token: token,
+ refresh_token: token
+ }), 200);
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken).then(data => {
+ assert.ok(data.exp);
+ assert.ok(data.exp > 0);
+ assert.propEqual(data.token, token);
+ });
+ });
+
+
+ test('#refreshAccessToken invalidates session when the server responds with 401', function(assert) {
+ assert.expect(1);
+
+ const token = createFakeToken();
+
+ sinon.spy(this.owner.application.jwt, 'invalidate');
+
+ this.server.post('/token-refresh', () => ({}), 401);
+
+ this.owner.application.jwt.refreshAccessToken(token).catch(() => {
+ assert.strictEqual(this.owner.application.jwt.invalidate.callCount, 1);
+ });
+ });
+
+ test('#refreshAccessToken invalidates session when the server responds with 403', function(assert) {
+ assert.expect(1);
+
+ const refreshToken = createFakeToken();
+
+ sinon.spy(this.owner.application.jwt, 'invalidate');
+
+ this.server.post('/token-refresh', () => ({}), 403);
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken).catch(() => {
+ assert.strictEqual(this.owner.application.jwt.invalidate.callCount, 1);
+ });
+ });
+
+ test('#refreshAccessToken does not invalidate session when the server responds with 500', function(assert) {
+ assert.expect(1);
+
+ const refreshToken = createFakeToken();
+
+ sinon.spy(this.owner.application.jwt, 'invalidate');
+
+ this.server.post('/token-refresh', () => ({}), 500);
+
+ this.owner.application.jwt.refreshAccessToken(refreshToken).catch(() => {
+ assert.strictEqual(this.owner.application.jwt.invalidate.callCount, 0);
+ });
+ });
+
+ test('#getTokenData returns correct data', function(assert) {
+ assert.expect(2);
+
+ const stringTokenData = 'test@test.com';
+ const objectTokenData = {
+ username: stringTokenData
+ };
+
+ const objectToken = createFakeToken(objectTokenData);
+ const stringToken = createFakeToken(stringTokenData);
+
+ assert.strictEqual(this.owner.application.jwt.getTokenData(objectToken).username, objectTokenData.username);
+ assert.strictEqual(this.owner.application.jwt.getTokenData(stringToken), stringTokenData);
+ });
+
+ test('#getTokenData returns correctly encoded data', function(assert) {
+ assert.expect(1);
+
+ const token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0NTQxNzM1NzEsImRhdGEiOnsiYXV0aGVudGljYXRlZCI6dHJ1ZSwidXNlciI6eyJpZCI6IjdhMWRkYzJmLWI5MTAtNDY2Yi04MDhhLTUxOTUyOTkwZjUyNyIsIm5hbWUiOiJUaG9yYmrDuHJuIEhlcm1hbnNlbiIsIm1vYmlsZSI6IjQwNDUxMzg5IiwiZW1haWwiOiJ0aEBza2FsYXIubm8iLCJsb2NhbGUiOiJuYiIsInNpZ25faW5fY291bnQiOjI1fX19.se8PT5e1G1_xhPTQf_16BIv0Q9uEjQxLGE3iTJwhAec';
+
+ const data = this.owner.application.jwt.getTokenData(token);
+ assert.strictEqual(data.data.user.name, 'Thorbjørn Hermansen');
+ });
+
+});
diff --git a/test-app/tests/unit/authenticators/token-test.js b/test-app/tests/unit/authenticators/token-test.js
new file mode 100644
index 00000000..10f43ea0
--- /dev/null
+++ b/test-app/tests/unit/authenticators/token-test.js
@@ -0,0 +1,253 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'test-app/tests/helpers';
+import { setupMirage } from 'ember-cli-mirage/test-support';
+
+module('Unit | Authenticator | authenticators/token.js', function (hooks) {
+ setupTest(hooks);
+ setupMirage(hooks);
+
+ hooks.beforeEach(function() {
+ this.owner.application.token = this.owner.lookup('authenticator:token');
+ });
+
+ const createFakeCredentials = () => {
+ return {
+ username: 'admin',
+ password: 'abc123'
+ };
+ };
+
+ test('token exists', function (assert) {
+ assert.expect(1);
+ const token = this.owner.lookup('authenticator:token');
+ assert.ok(token);
+ });
+
+ test('#makeRequest successfully resolves with the correct data', function(assert) {
+ assert.expect(1);
+
+ const response = {
+ 'testing': '123'
+ };
+ const credentials = createFakeCredentials();
+
+ this.server.post('/endpoint', () => ({
+ ...response
+ }), 201);
+
+ this.owner.application.token.makeRequest('http://localhost:8080/api/endpoint', credentials).then(data => {
+ assert.propEqual({
+ statusText: 'Created',
+ status: 201,
+ headers: {
+ map: {
+ 'content-type': 'application/json'
+ }
+ },
+ text: JSON.stringify(response),
+ json: response
+ }, JSON.parse(JSON.stringify(data)));
+ });
+ });
+
+ test('#makeRequest successfully rejects with the correct data on JSON error', function(assert) {
+ assert.expect(1);
+
+ const response = {
+ 'testing': '123'
+ };
+ const credentials = createFakeCredentials();
+
+ this.server.post('/endpoint', () => ({
+ ...response
+ }), 403);
+
+ this.owner.application.token.makeRequest('http://localhost:8080/api/endpoint', credentials).catch(data => {
+ assert.propEqual({
+ statusText: 'Forbidden',
+ status: 403,
+ headers: {
+ map: {
+ 'content-type': 'application/json'
+ }
+ },
+ text: JSON.stringify(response),
+ json: response
+ }, JSON.parse(JSON.stringify(data)));
+ });
+ });
+
+ test('#makeRequest successfully rejects with the correct data on HTML error', function(assert) {
+ assert.expect(1);
+
+ const response = 'Error
';
+ const credentials = createFakeCredentials();
+
+ this.server.post('/endpoint', () => ({
+ response
+ }), 403);
+
+ this.owner.application.token.makeRequest('http://localhost:8080/api/endpoint', credentials).catch(data => {
+ delete data.headers.append;
+ assert.propEqual(data, {
+ statusText: 'Forbidden',
+ status: 403,
+ headers: {
+ 'map': {
+ 'content-type': 'application/json'
+ }
+ },
+ json: {
+ response: response
+ },
+ text: "{\"response\":\"Error
\"}"
+ });
+ });
+ });
+
+ test('#restore resolves with the correct data', function(assert) {
+ assert.expect(1);
+
+ const response = {
+ token: 'secret token!'
+ };
+
+ this.server.post('/token-auth', () => ({
+ ...response
+ }), 201);
+
+ this.owner.application.token.restore(response).then(content => {
+ assert.propEqual(content, response);
+ });
+ });
+
+ test('#authenticate sends a fetch request to the token endpoint', function(assert) {
+ assert.expect(4);
+
+ const credentials = createFakeCredentials();
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.token.authenticate(credentials);
+ });
+
+ test('#authenticate successfully resolves with the correct data', function(assert) {
+ assert.expect(1);
+
+ const response = {
+ token: 'secret token!'
+ };
+ const credentials = createFakeCredentials();
+
+ this.server.post('/token-auth', () => ({
+ ...response
+ }), 201);
+
+ this.owner.application.token.authenticate(credentials).then(data => {
+ assert.propEqual(data, response);
+ });
+ });
+
+ test('#authenticate sends a fetch request to the token endpoint when `tokenPropertyName` is a nested object', function(assert) {
+ assert.expect(4);
+
+ this.owner.application.token.tokenPropertyName = 'auth.nested.token';
+
+ const response = {
+ token: 'secret token!'
+ };
+ const credentials = createFakeCredentials();
+
+ this.server.post('/token-auth', () => ({
+ ...response
+ }), 201);
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ }));
+ };
+
+ this.owner.application.token.authenticate(credentials);
+ });
+
+ test('#authenticate sends an fetch request with custom headers', function(assert) {
+ assert.expect(4);
+
+ const credentials = createFakeCredentials();
+
+ this.owner.application.token.headers = {
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': 0,
+ 'Accept': 'application/json'
+ };
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': '0'
+ }));
+ };
+
+ this.owner.application.token.authenticate(credentials);
+ });
+
+ test('#authenticate sends an fetch request with dynamic headers', function(assert) {
+ assert.expect(4);
+
+ const credentials = createFakeCredentials();
+
+ const headers = {
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': 0,
+ 'Accept': 'application/json'
+ };
+
+ this.server.pretender.handledRequest = (verb, path, request) => {
+ assert.strictEqual(path, 'http://localhost:8080/api/token-auth');
+ assert.strictEqual(verb, 'POST');
+ assert.strictEqual(request.requestBody, JSON.stringify(credentials));
+ assert.strictEqual(JSON.stringify(request.requestHeaders), JSON.stringify({
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json',
+ 'X-API-KEY': '123-abc',
+ 'X-ANOTHER-HEADER': '0',
+ }));
+ };
+
+ this.owner.application.token.authenticate(credentials, headers);
+ });
+
+ test('#authenticate rejects with the correct error', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.token.authenticate({username: 'admin', password: 'incorrectPassword'}).catch(error => {
+ assert.strictEqual(error.status, 401);
+ });
+ });
+
+ test('#invalidate returns a resolving promise', function(assert) {
+ assert.expect(1);
+
+ this.owner.application.token.invalidate().then(() => {
+ assert.ok(true);
+ });
+ });
+});
diff --git a/tests/dummy/app/adapters/application.js b/tests/dummy/app/adapters/application.js
deleted file mode 100644
index bfa538a2..00000000
--- a/tests/dummy/app/adapters/application.js
+++ /dev/null
@@ -1,4 +0,0 @@
-import DS from 'ember-data';
-import TokenAuthorizerMixin from 'ember-simple-auth-token/mixins/token-authorizer';
-
-export default DS.RESTAdapter.extend(TokenAuthorizerMixin);
diff --git a/tests/dummy/app/app.js b/tests/dummy/app/app.js
deleted file mode 100644
index b3b2bd67..00000000
--- a/tests/dummy/app/app.js
+++ /dev/null
@@ -1,14 +0,0 @@
-import Application from '@ember/application';
-import Resolver from './resolver';
-import loadInitializers from 'ember-load-initializers';
-import config from './config/environment';
-
-const App = Application.extend({
- modulePrefix: config.modulePrefix,
- podModulePrefix: config.podModulePrefix,
- Resolver
-});
-
-loadInitializers(App, config.modulePrefix);
-
-export default App;
diff --git a/tests/dummy/app/controllers/.gitkeep b/tests/dummy/app/controllers/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/dummy/app/controllers/application.js b/tests/dummy/app/controllers/application.js
deleted file mode 100644
index f8d172ab..00000000
--- a/tests/dummy/app/controllers/application.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Controller from '@ember/controller';
-import { inject } from '@ember/service';
-import { get, computed } from '@ember/object';
-import config from '../config/environment';
-
-export default Controller.extend({
- session: inject('session'),
-
- config: computed(function() {
- return JSON.stringify(get(config, 'ember-simple-auth-token'), null, '\t');
- }),
-
- sessionData: computed('session.session.content.authenticated', function() {
- return JSON.stringify(this.get('session.session.content.authenticated'), null, '\t');
- })
-});
diff --git a/tests/dummy/app/controllers/login.js b/tests/dummy/app/controllers/login.js
deleted file mode 100644
index 0bae9b46..00000000
--- a/tests/dummy/app/controllers/login.js
+++ /dev/null
@@ -1,17 +0,0 @@
-import Controller from '@ember/controller';
-import { inject } from '@ember/service';
-
-export default Controller.extend({
- session: inject('session'),
- username: 'admin',
- password: 'abc123',
-
- actions: {
- authenticate: function() {
- const credentials = this.getProperties('username', 'password');
- const authenticator = 'authenticator:jwt';
-
- this.get('session').authenticate(authenticator, credentials);
- }
- }
-});
diff --git a/tests/dummy/app/helpers/.gitkeep b/tests/dummy/app/helpers/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/dummy/app/models/.gitkeep b/tests/dummy/app/models/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/dummy/app/resolver.js b/tests/dummy/app/resolver.js
deleted file mode 100644
index 2fb563d6..00000000
--- a/tests/dummy/app/resolver.js
+++ /dev/null
@@ -1,3 +0,0 @@
-import Resolver from 'ember-resolver';
-
-export default Resolver;
diff --git a/tests/dummy/app/router.js b/tests/dummy/app/router.js
deleted file mode 100644
index 93d7b4db..00000000
--- a/tests/dummy/app/router.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import EmberRouter from '@ember/routing/router';
-import config from './config/environment';
-
-const Router = EmberRouter.extend({
- location: config.locationType,
- rootURL: config.rootURL
-});
-
-Router.map(function() {
- this.route('login');
-});
-
-export default Router;
diff --git a/tests/dummy/app/routes/.gitkeep b/tests/dummy/app/routes/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/dummy/app/routes/application.js b/tests/dummy/app/routes/application.js
deleted file mode 100644
index 3b151c2a..00000000
--- a/tests/dummy/app/routes/application.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import Route from '@ember/routing/route';
-import { inject } from '@ember/service';
-import ApplicationRouteMixin from 'ember-simple-auth/mixins/application-route-mixin';
-
-export default Route.extend(ApplicationRouteMixin, {
- session: inject('session'),
-
- actions: {
- invalidateSession: function() {
- this.get('session').invalidate();
- }
- }
-});
diff --git a/tests/dummy/app/routes/index.js b/tests/dummy/app/routes/index.js
deleted file mode 100644
index e8ac1313..00000000
--- a/tests/dummy/app/routes/index.js
+++ /dev/null
@@ -1,18 +0,0 @@
-import Route from '@ember/routing/route';
-import { getOwner } from '@ember/application';
-import AuthenticatedRouteMixin from 'ember-simple-auth/mixins/authenticated-route-mixin';
-import ENV from '../config/environment';
-
-export default Route.extend(AuthenticatedRouteMixin, {
- model: function () {
- const adapter = getOwner(this).lookup('adapter:application');
-
- return adapter.ajax(`${ENV['API_URL'] || ''}/api/users/`, 'GET');
- },
-
- setupController: function (controller, model) {
- if (!model.username) {
- this.get('session').invalidate();
- }
- }
-});
diff --git a/tests/dummy/app/routes/login.js b/tests/dummy/app/routes/login.js
deleted file mode 100644
index 4c7989e6..00000000
--- a/tests/dummy/app/routes/login.js
+++ /dev/null
@@ -1,4 +0,0 @@
-import Route from '@ember/routing/route';
-import UnauthenticatedRouteMixin from 'ember-simple-auth/mixins/unauthenticated-route-mixin';
-
-export default Route.extend(UnauthenticatedRouteMixin);
diff --git a/tests/dummy/app/styles/app.css b/tests/dummy/app/styles/app.css
deleted file mode 100644
index 9adb5ad0..00000000
--- a/tests/dummy/app/styles/app.css
+++ /dev/null
@@ -1,3 +0,0 @@
-html, body {
- margin: 20px;
-}
diff --git a/tests/dummy/app/templates/application.hbs b/tests/dummy/app/templates/application.hbs
deleted file mode 100644
index 9ca9e8fc..00000000
--- a/tests/dummy/app/templates/application.hbs
+++ /dev/null
@@ -1,26 +0,0 @@
-Demo: ember-simple-auth-token
-
-
- {{#link-to "index" tagName="li"}}
- Protected Page
- {{/link-to}}
- {{#if session.isAuthenticated}}
- -
- Logout
-
- {{else}}
- {{#link-to "login" tagName="li"}}
- Login
- {{/link-to}}
- {{/if}}
-
-
-{{outlet}}
-
-
-
-Config:
-{{config}}
-
-Session Data:
-{{sessionData}}
diff --git a/tests/dummy/app/templates/components/.gitkeep b/tests/dummy/app/templates/components/.gitkeep
deleted file mode 100644
index e69de29b..00000000
diff --git a/tests/dummy/app/templates/index.hbs b/tests/dummy/app/templates/index.hbs
deleted file mode 100644
index a4fc559a..00000000
--- a/tests/dummy/app/templates/index.hbs
+++ /dev/null
@@ -1 +0,0 @@
-This is a protected page only visible to authenticated users!
diff --git a/tests/dummy/app/templates/login.hbs b/tests/dummy/app/templates/login.hbs
deleted file mode 100644
index e833ef34..00000000
--- a/tests/dummy/app/templates/login.hbs
+++ /dev/null
@@ -1,7 +0,0 @@
-
diff --git a/tests/dummy/config/environment.js b/tests/dummy/config/environment.js
deleted file mode 100644
index 6339dad4..00000000
--- a/tests/dummy/config/environment.js
+++ /dev/null
@@ -1,81 +0,0 @@
-'use strict';
-
-module.exports = function(environment) {
- const ENV = {
- modulePrefix: 'dummy',
- environment,
- rootURL: '/',
- locationType: 'auto',
- EmberENV: {
- FEATURES: {
- // Here you can enable experimental features on an ember canary build
- // e.g. 'with-controller': true
- },
- EXTEND_PROTOTYPES: {
- // Prevent Ember Data from overriding Date.parse.
- Date: false
- }
- },
-
- APP: {
- // Here you can pass flags/options to your application instance
- // when it is created
- },
-
- contentSecurityPolicy: {
- 'default-src': "'none'",
- 'script-src': "'self' 'unsafe-eval'",
- 'font-src': "'self' https://maxcdn.bootstrapcdn.com",
- 'connect-src': "'self'",
- 'img-src': "'self'",
- 'style-src': "'self' 'unsafe-inline' https://maxcdn.bootstrapcdn.com",
- 'media-src': "'self'"
- }
- };
-
- if (environment === 'development') {
- // ENV.APP.LOG_RESOLVER = true;
- // ENV.APP.LOG_ACTIVE_GENERATION = true;
- // ENV.APP.LOG_TRANSITIONS = true;
- // ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
- // ENV.APP.LOG_VIEW_LOOKUPS = true;
-
- ENV['ember-simple-auth-token'] = {
- refreshTokenPropertyName: 'token',
- serverTokenEndpoint: '/api/token-auth/',
- serverTokenRefreshEndpoint: '/api/token-refresh/',
- refreshLeeway: 5
- };
- }
-
- if (environment === 'test') {
- // Testem prefers this...
- ENV.locationType = 'none';
-
- // keep test console output quieter
- ENV.APP.LOG_ACTIVE_GENERATION = false;
- ENV.APP.LOG_VIEW_LOOKUPS = false;
-
- ENV.APP.rootElement = '#ember-testing';
- ENV.APP.autoboot = false;
- }
-
- if (environment === 'production') {
- // here you can enable a production-specific feature
- ENV.rootURL = '/ember-simple-auth-token';
- ENV.API_URL = 'https://simple-auth-token-server.herokuapp.com';
-
- ENV['ember-simple-auth-token'] = {
- refreshTokenPropertyName: 'token',
- serverTokenEndpoint: `${ENV.API_URL}/api/token-auth/`,
- serverTokenRefreshEndpoint: `${ENV.API_URL}/api/token-refresh/`,
- refreshLeeway: 5
- };
- }
-
- ENV['ember-simple-auth'] = {
- applicationRootUrl: ENV.rootURL
- };
-
- return ENV;
-};
diff --git a/tests/dummy/config/targets.js b/tests/dummy/config/targets.js
deleted file mode 100644
index 8ffae363..00000000
--- a/tests/dummy/config/targets.js
+++ /dev/null
@@ -1,18 +0,0 @@
-'use strict';
-
-const browsers = [
- 'last 1 Chrome versions',
- 'last 1 Firefox versions',
- 'last 1 Safari versions'
-];
-
-const isCI = !!process.env.CI;
-const isProduction = process.env.EMBER_ENV === 'production';
-
-if (isCI || isProduction) {
- browsers.push('ie 11');
-}
-
-module.exports = {
- browsers
-};
diff --git a/tests/dummy/public/crossdomain.xml b/tests/dummy/public/crossdomain.xml
deleted file mode 100644
index 0c16a7a0..00000000
--- a/tests/dummy/public/crossdomain.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
diff --git a/tests/helpers/destroy-app.js b/tests/helpers/destroy-app.js
deleted file mode 100644
index e7f983bd..00000000
--- a/tests/helpers/destroy-app.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import { run } from '@ember/runloop';
-
-export default function destroyApp(application) {
- run(application, 'destroy');
-}
diff --git a/tests/helpers/module-for-acceptance.js b/tests/helpers/module-for-acceptance.js
deleted file mode 100644
index 1beed82e..00000000
--- a/tests/helpers/module-for-acceptance.js
+++ /dev/null
@@ -1,21 +0,0 @@
-import { module } from 'qunit';
-import { resolve } from 'rsvp';
-import startApp from '../helpers/start-app';
-import destroyApp from '../helpers/destroy-app';
-
-export default function(name, options = {}) {
- module(name, {
- beforeEach() {
- this.application = startApp();
-
- if (options.beforeEach) {
- return options.beforeEach.apply(this, arguments);
- }
- },
-
- afterEach() {
- const afterEach = options.afterEach && options.afterEach.apply(this, arguments);
- return resolve(afterEach).then(() => destroyApp(this.application));
- }
- });
-}
diff --git a/tests/helpers/resolver.js b/tests/helpers/resolver.js
deleted file mode 100644
index ebfb4e4d..00000000
--- a/tests/helpers/resolver.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import Resolver from 'ember/resolver';
-import config from '../../config/environment';
-
-const resolver = Resolver.create();
-
-resolver.namespace = {
- modulePrefix: config.modulePrefix,
- podModulePrefix: config.podModulePrefix
-};
-
-export default resolver;
diff --git a/tests/helpers/start-app.js b/tests/helpers/start-app.js
deleted file mode 100644
index 25dbb5ed..00000000
--- a/tests/helpers/start-app.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Application from '../../app';
-import config from '../../config/environment';
-import { assign } from '@ember/polyfills';
-import { run } from '@ember/runloop';
-
-export default function startApp(attrs) {
- let attributes = assign({}, config.APP);
- attributes = assign(attributes, attrs); // use defaults, but you can override;
-
- return run(() => {
- const application = Application.create(attributes);
- application.setupForTesting();
- application.injectTestHelpers();
- return application;
- });
-}
diff --git a/tests/test-helper.js b/tests/test-helper.js
deleted file mode 100644
index 6c75fdb6..00000000
--- a/tests/test-helper.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import Application from '../app';
-import config from '../config/environment';
-import { setApplication } from '@ember/test-helpers';
-import { start } from 'ember-qunit';
-import setupSinon from 'ember-sinon-qunit';
-
-setApplication(Application.create(config.APP));
-
-setupSinon();
-
-start();
diff --git a/tests/unit/authenticators/jwt-test.js b/tests/unit/authenticators/jwt-test.js
deleted file mode 100644
index ff8f800f..00000000
--- a/tests/unit/authenticators/jwt-test.js
+++ /dev/null
@@ -1,1042 +0,0 @@
-import { module } from 'qunit';
-import { test } from 'ember-qunit';
-import sinon from 'sinon';
-import startApp from '../../helpers/start-app';
-import * as fetchWrapper from 'fetch';
-import { assign } from '@ember/polyfills';
-import JWT from 'ember-simple-auth-token/authenticators/jwt';
-
-let App;
-
-const createFakeCredentials = () => {
- return {
- username: 'test@test.com',
- password: 'password'
- };
-};
-
-const createFakeToken = obj => {
- return `a.${btoa(JSON.stringify(obj))}.b`;
-};
-
-const createFakeRefreshToken = () => {
- return btoa('91df47a8-8c7f-4411-98e7-43bfd32df5c4');
-};
-
-const getConvertedTime = time => {
- return Math.round(time / 1000);
-};
-
-module('JWT Authenticator', {
- beforeEach() {
- App = startApp();
- App.xhr = sinon.useFakeXMLHttpRequest();
- App.server = sinon.fakeServer.create();
- App.server.autoRespond = true;
- App.authenticator = JWT.create();
- sinon.spy(fetchWrapper, 'default');
- sinon.spy(App.authenticator, 'invalidate');
- sinon.spy(App.authenticator, 'refreshAccessToken');
- sinon.spy(App.authenticator, 'scheduleAccessTokenRefresh');
- }
-});
-
-test('#restore resolves when the data includes `token` and `expiresAt`', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const tokenData = {
- [App.authenticator.tokenExpireName]: expiresAt
- };
- const token = createFakeToken(tokenData);
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.tokenDataPropertyName]: tokenData
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(content => {
- assert.deepEqual(content, data);
- });
-});
-
-test('#restore resolves when the data includes `token` and excludes `expiresAt`', assert => {
- assert.expect(1);
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(content => {
- assert.deepEqual(content, data);
- });
-});
-
-test('#restore resolves when the data includes `token` and `expiresAt` and the token is expired', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime - 60 * 60;
- const tokenData = {
- [App.authenticator.tokenExpireName]: expiresAt
- };
- const token = createFakeToken(tokenData);
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.tokenDataPropertyName]: tokenData
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(content => {
- assert.deepEqual(content, data);
- });
-});
-
-test('#restore rejects when the data includes `token` and `expiresAt`, the token is expired, and `refreshAccessTokens` is false', assert => {
- assert.expect(1);
-
- App.authenticator.refreshAccessTokens = false;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime - 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).catch(() => {
- assert.ok(true);
- });
-});
-
-test('#restore resolves when the data includes `token` and `expiresAt` and `tokenPropertyName` is a nested object', assert => {
- assert.expect(1);
-
- App.authenticator.tokenPropertyName = 'auth.nested.token';
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- auth: {
- nested: {
- token: token
- }
- },
- [App.authenticator.tokenExpireName]: expiresAt
- };
- const response = {
- auth: {
- nested: {
- token: token
- }
- },
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(content => {
- assert.deepEqual(content, data);
- });
-});
-
-test('#restore rejects when `token` is excluded', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: null,
- [App.authenticator.tokenExpireName]: expiresAt
- };
- const response = {
- [App.authenticator.tokenPropertyName]: null,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).catch(() => {
- assert.ok(true);
- });
-});
-
-test('#restore schedules a token refresh when `refreshAccessTokens` is true', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 1);
- });
-});
-
-test('#restore does not schedule a token refresh when `refreshAccessTokens` is false', assert => {
- assert.expect(1);
-
- App.authenticator.refreshAccessTokens = false;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 0);
- });
-});
-
-test('#restore immediately refreshes the token when the token is expired', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime - 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(() => {
- assert.equal(App.authenticator.refreshAccessToken.callCount, 1);
- });
-});
-
-test('#restore schedules a token refresh when the token is farther than the `refreshLeeway` to expiration', assert => {
- assert.expect(1);
-
- App.authenticator.refreshLeeway = 30;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 1);
- });
-});
-
-test('#restore immediately refreshes the token when the token is closer than the `refreshLeeway` to expiration', assert => {
- assert.expect(1);
-
- App.authenticator.refreshLeeway = 120;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const data = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.tokenExpireName]: expiresAt,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(data).catch(() => {
- assert.equal(App.authenticator.refreshAccessToken.callCount, 1);
- });
-});
-
-test('#authenticate successfully resolves with the correct data', assert => {
- assert.expect(1);
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(data => {
- delete data[App.authenticator.tokenExpireName];
- delete data[App.authenticator.tokenDataPropertyName];
- assert.deepEqual(data, response);
- });
-});
-
-test('#authenticate sends a fetch request to the token endpoint', assert => {
- assert.expect(3);
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#authenticate sends a fetch request to the token endpoint when `tokenPropertyName` is a nested object', assert => {
- assert.expect(3);
-
- App.authenticator.tokenPropertyName = 'auth.nested.token';
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- auth: {
- nested: {
- token: token
- }
- },
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- auth: {
- nested: {
- token: token
- }
- },
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#authenticate sends an fetch request with custom headers', assert => {
- assert.expect(3);
-
- App.authenticator.headers = {
- 'X-API-KEY': '123-abc',
- 'X-ANOTHER-HEADER': 0,
- 'Accept': 'application/vnd.api+json'
- };
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: assign({
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }, App.authenticator.headers)
- });
- });
-});
-
-test('#authenticate sends an fetch request with dynamic headers', assert => {
- assert.expect(3);
-
- const headers = {
- 'X-API-KEY': '123-abc',
- 'X-ANOTHER-HEADER': 0,
- 'Accept': 'application/vnd.api+json'
- };
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials, headers).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: assign({
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }, headers)
- });
- });
-});
-
-test('#authenticate rejects with the correct error', assert => {
- assert.expect(1);
-
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 400,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify({})
- ]);
-
- return App.authenticator.authenticate(credentials).catch(error => {
- assert.equal(error.status, 400);
- });
-});
-
-test('#authenticate schedules a token refresh when `refreshAccessTokens` is true', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 1);
- });
-});
-
-test('#authenticate does not schedule a token refresh when `refreshAccessTokens` is false', assert => {
- assert.expect(1);
-
- App.authenticator.refreshAccessTokens = false;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 0);
- });
-});
-
-test('#authenticate immediately refreshes the token when the token is expired', assert => {
- assert.expect(1);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime - 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(App.authenticator.refreshAccessToken.callCount, 0);
- });
-});
-
-test('#authenticate schedules a token refresh when the token is farther than the `refreshLeeway` to expiration', assert => {
- assert.expect(1);
-
- App.authenticator.refreshLeeway = 30;
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const credentials = createFakeCredentials();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
- const refreshResponse = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(refreshResponse)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(App.authenticator.scheduleAccessTokenRefresh.callCount, 1);
- });
-});
-
-test('#refreshAccessToken sends an fetch request to the refresh token endpoint', assert => {
- assert.expect(3);
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenRefreshEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify({
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- }),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#refreshAccessToken sends an fetch request to the refresh token endpoint when `refreshTokenPropertyName` is a nested object', assert => {
- assert.expect(3);
-
- App.authenticator.refreshTokenPropertyName = 'auth.nested.refreshToken';
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- auth: {
- nested: {
- refreshToken: refreshToken
- }
- }
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenRefreshEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify({
- auth: {
- nested: {
- refreshToken: refreshToken
- }
- }
- }),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#refreshAccessToken sends an fetch request with custom headers', assert => {
- assert.expect(3);
-
- App.authenticator.headers = {
- 'X-API-KEY': '123-abc',
- 'X-ANOTHER-HEADER': 0,
- 'Accept': 'application/vnd.api+json'
- };
-
- const token = createFakeToken();
- const refreshToken = createFakeRefreshToken();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenRefreshEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify({
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- }),
- headers: assign({
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }, App.authenticator.headers)
- });
- });
-});
-
-test('#refreshAccessToken triggers the `sessionDataUpdated` event on successful request', assert => {
- assert.expect(3);
-
- const currentTime = getConvertedTime(Date.now());
- const expiresAt = currentTime + 60;
- const token = createFakeToken({
- [App.authenticator.tokenExpireName]: expiresAt
- });
- const refreshToken = createFakeRefreshToken();
- const response = {
- [App.authenticator.tokenPropertyName]: token,
- [App.authenticator.refreshTokenPropertyName]: refreshToken
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).then(data => {
- assert.ok(data[App.authenticator.tokenExpireName]);
- assert.ok(data[App.authenticator.tokenExpireName] > 0);
- assert.deepEqual(data.token, token);
- });
-});
-
-
-test('#refreshAccessToken invalidates session when the server responds with 401', assert => {
- assert.expect(1);
-
- const refreshToken = createFakeRefreshToken();
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 401,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify({})
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).catch(() => {
- assert.equal(App.authenticator.invalidate.callCount, 1);
- });
-});
-
-test('#refreshAccessToken invalidates session when the server responds with 403', assert => {
- assert.expect(1);
-
- const refreshToken = createFakeRefreshToken();
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 403,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify({})
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).catch(() => {
- assert.equal(App.authenticator.invalidate.callCount, 1);
- });
-});
-
-test('#refreshAccessToken does not invalidate session when the server responds with 500', assert => {
- assert.expect(1);
-
- const refreshToken = createFakeRefreshToken();
-
- App.server.respondWith('POST', App.authenticator.serverTokenRefreshEndpoint, [
- 500,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify({})
- ]);
-
- return App.authenticator.refreshAccessToken(refreshToken).catch(() => {
- assert.equal(App.authenticator.invalidate.callCount, 0);
- });
-});
-
-test('#getTokenData returns correct data', assert => {
- assert.expect(2);
-
- const stringTokenData = 'test@test.com';
- const objectTokenData = {
- username: stringTokenData
- };
-
- const objectToken = createFakeToken(objectTokenData);
- const stringToken = createFakeToken(stringTokenData);
-
- assert.deepEqual(App.authenticator.getTokenData(objectToken), objectTokenData);
- assert.equal(App.authenticator.getTokenData(stringToken), stringTokenData);
-});
-
-test('#getTokenData returns correctly encoded data', assert => {
- assert.expect(1);
-
- const token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0NTQxNzM1NzEsImRhdGEiOnsiYXV0aGVudGljYXRlZCI6dHJ1ZSwidXNlciI6eyJpZCI6IjdhMWRkYzJmLWI5MTAtNDY2Yi04MDhhLTUxOTUyOTkwZjUyNyIsIm5hbWUiOiJUaG9yYmrDuHJuIEhlcm1hbnNlbiIsIm1vYmlsZSI6IjQwNDUxMzg5IiwiZW1haWwiOiJ0aEBza2FsYXIubm8iLCJsb2NhbGUiOiJuYiIsInNpZ25faW5fY291bnQiOjI1fX19.se8PT5e1G1_xhPTQf_16BIv0Q9uEjQxLGE3iTJwhAec';
-
- const data = App.authenticator.getTokenData(token);
- assert.equal(data.data.user.name, 'Thorbjørn Hermansen');
-});
diff --git a/tests/unit/authenticators/token-test.js b/tests/unit/authenticators/token-test.js
deleted file mode 100644
index 24707f43..00000000
--- a/tests/unit/authenticators/token-test.js
+++ /dev/null
@@ -1,318 +0,0 @@
-import { module } from 'qunit';
-import { test } from 'ember-qunit';
-import sinon from 'sinon';
-import startApp from '../../helpers/start-app';
-import * as fetchWrapper from 'fetch';
-import { assign } from '@ember/polyfills';
-import Token from 'ember-simple-auth-token/authenticators/token';
-
-let App;
-
-const createFakeCredentials = () => {
- return {
- username: 'test@test.com',
- password: 'password'
- };
-};
-
-module('Token Authenticator', {
- beforeEach: () => {
- App = startApp();
- App.xhr = sinon.useFakeXMLHttpRequest();
- App.server = sinon.fakeServer.create();
- App.server.autoRespond = true;
- App.authenticator = Token.create();
- sinon.spy(fetchWrapper, 'default');
- }
-});
-
-test('#makeRequest successfully resolves with the correct data', assert => {
- assert.expect(1);
-
- const response = {
- 'testing': '123'
- };
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', '/endpoint', [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.makeRequest('/endpoint', credentials).then(data => {
- assert.deepEqual({
- statusText: 'Created',
- status: 201,
- headers: {
- map: {
- 'content-type': 'application/json'
- }
- },
- text: JSON.stringify(response),
- json: response
- }, JSON.parse(JSON.stringify(data)));
- });
-});
-
-test('#makeRequest successfully rejects with the correct data on JSON error', assert => {
- assert.expect(1);
-
- const response = {
- 'testing': '123'
- };
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', '/endpoint', [
- 403,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.makeRequest('/endpoint', credentials).catch(data => {
- assert.deepEqual({
- statusText: 'Forbidden',
- status: 403,
- headers: {
- map: {
- 'content-type': 'application/json'
- }
- },
- text: JSON.stringify(response),
- json: response
- }, JSON.parse(JSON.stringify(data)));
- });
-});
-
-test('#makeRequest successfully rejects with the correct data on HTML error', assert => {
- assert.expect(1);
-
- const response = 'Error
';
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', '/endpoint', [
- 403,
- {
- 'Content-Type': 'text/html'
- },
- response
- ]);
-
- return App.authenticator.makeRequest('/endpoint', credentials).catch(data => {
- assert.deepEqual({
- statusText: 'Forbidden',
- status: 403,
- headers: {
- map: {
- 'content-type': 'text/html'
- }
- },
- text: response
- }, JSON.parse(JSON.stringify(data)));
- });
-});
-
-test('#restore resolves with the correct data', assert => {
- assert.expect(1);
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.restore(response).then(content => {
- assert.deepEqual(content, response);
- });
-});
-
-test('#authenticate sends a fetch request to the token endpoint', assert => {
- assert.expect(3);
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#authenticate successfully resolves with the correct data', assert => {
- assert.expect(1);
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.authenticate(credentials).then(data => {
- assert.deepEqual(data, response);
- });
-});
-
-test('#authenticate sends a fetch request to the token endpoint when `tokenPropertyName` is a nested object', assert => {
- assert.expect(3);
-
- App.authenticator.tokenPropertyName = 'auth.nested.token';
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }
- });
- });
-});
-
-test('#authenticate sends an fetch request with custom headers', assert => {
- assert.expect(3);
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
- const credentials = createFakeCredentials();
-
- App.authenticator.headers = {
- 'X-API-KEY': '123-abc',
- 'X-ANOTHER-HEADER': 0,
- 'Accept': 'application/vnd.api+json'
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.authenticate(credentials).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: assign({
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }, App.authenticator.headers)
- });
- });
-});
-
-test('#authenticate sends an fetch request with dynamic headers', assert => {
- assert.expect(3);
-
- const response = {
- [App.authenticator.tokenPropertyName]: 'secret token!'
- };
- const credentials = createFakeCredentials();
-
- const headers = {
- 'X-API-KEY': '123-abc',
- 'X-ANOTHER-HEADER': 0,
- 'Accept': 'application/vnd.api+json'
- };
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 201,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify(response)
- ]);
-
- return App.authenticator.authenticate(credentials, headers).then(() => {
- assert.equal(fetchWrapper.default.callCount, 1);
- assert.equal(fetchWrapper.default.getCall(0).args[0], App.authenticator.serverTokenEndpoint);
- assert.deepEqual(fetchWrapper.default.getCall(0).args[1], {
- method: 'POST',
- body: JSON.stringify(credentials),
- headers: assign({
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- }, headers)
- });
- });
-});
-
-test('#authenticate rejects with the correct error', assert => {
- assert.expect(1);
-
- const credentials = createFakeCredentials();
-
- App.server.respondWith('POST', App.authenticator.serverTokenEndpoint, [
- 400,
- {
- 'Content-Type': 'application/json'
- },
- JSON.stringify({})
- ]);
-
- return App.authenticator.authenticate(credentials).catch(error => {
- assert.equal(error.status, 400);
- });
-});
-
-test('#invalidate returns a resolving promise', assert => {
- assert.expect(1);
-
- return App.authenticator.invalidate().then(() => {
- assert.ok(true);
- });
-});
diff --git a/tests/unit/mixins/token-adapter-test.js b/tests/unit/mixins/token-adapter-test.js
deleted file mode 100644
index 2738043f..00000000
--- a/tests/unit/mixins/token-adapter-test.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import EmberObject from '@ember/object';
-import TokenAdapterMixin from 'ember-simple-auth-token/mixins/token-adapter';
-import { module, test } from 'qunit';
-
-module('Unit | Mixin | token-adapter', function() {
- test('it works', function (assert) {
- const TokenAdapterObject = EmberObject.extend(TokenAdapterMixin);
- const subject = TokenAdapterObject.create();
- assert.ok(subject);
- });
-});
diff --git a/tests/unit/mixins/token-authorizer-test.js b/tests/unit/mixins/token-authorizer-test.js
deleted file mode 100644
index 62b3a454..00000000
--- a/tests/unit/mixins/token-authorizer-test.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import EmberObject from '@ember/object';
-import TokenAuthorizerMixin from 'ember-simple-auth-token/mixins/token-authorizer';
-import { module, test } from 'qunit';
-
-module('Unit | Mixin | token-authorizer', function() {
- test('it works', function (assert) {
- const TokenAuthorizerObject = EmberObject.extend(TokenAuthorizerMixin);
- const subject = TokenAuthorizerObject.create();
- assert.ok(subject);
- });
-});
diff --git a/vendor/.gitkeep b/vendor/.gitkeep
deleted file mode 100644
index e69de29b..00000000