@ember/app-blueprint 0.8.2 → 6.7.1

package/tests/{fixture-ts → fixtures/tests-ts-10}/app/router.ts

@@ -1,4 +1,4 @@
-import EmberRouter from '@ember/routing/router';
+import EmberRouter from '@embroider/router';
 import config from 'test-app/config/environment';
 
 export default class Router extends EmberRouter {
@@ -7,6 +7,5 @@ export default class Router extends EmberRouter {
 }
 
 Router.map(function () {
-  this.route('styles');
-  this.route('custom-component');
+  this.route('fancy');
 });

package/tests/{fixture-ts/app/routes/styles.ts → fixtures/tests-ts-10/app/routes/fancy.ts}

@@ -3,6 +3,6 @@ import { service } from '@ember/service';
 
 import type RouterService from '@ember/routing/router-service';
 
-export default class StylesRoute extends Route {
+export default class FancyRoute extends Route {
   @service declare router: RouterService;
 }

package/tests/fixtures/tests-ts-10/app/styles/app.css

@@ -0,0 +1,3 @@
+.purple {
+  color: rebeccapurple;
+}

package/tests/fixtures/tests-ts-10/app/templates/application.gts

@@ -0,0 +1,15 @@
+import { pageTitle } from 'ember-page-title';
+import { WelcomePage } from 'ember-welcome-page';
+import { LinkTo } from '@ember/routing';
+
+<template>
+  {{pageTitle "TestApp"}}
+
+  {{outlet}}
+
+  {{! The following component displays Ember's default welcome message. }}
+  <WelcomePage />
+  {{! Feel free to remove this! }}
+
+  <LinkTo @route="fancy" data-test-a>Fancy</LinkTo>
+</template>

package/tests/fixtures/tests-ts-10/app/templates/fancy.gts

@@ -0,0 +1,12 @@
+import { pageTitle } from 'ember-page-title';
+import Sweet from '../components/sweet.gts';
+
+<template>
+  {{pageTitle "Fancy"}}
+
+  <Sweet />
+
+  <p class="purple">Fancy</p>
+
+  {{outlet}}
+</template>

package/tests/fixtures/tests-ts-10/tests/acceptance/index-test.ts

@@ -0,0 +1,26 @@
+import { module, test } from 'qunit';
+import { visit, currentURL, click } from '@ember/test-helpers';
+import { setupApplicationTest } from 'test-app/tests/helpers';
+
+module('Acceptance | index', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('visiting /', async function (assert) {
+    await visit('/');
+
+    assert.strictEqual(currentURL(), '/');
+
+    await click('[data-test-a]');
+
+    assert.strictEqual(currentURL(), '/fancy');
+
+    assert.dom('p').hasText('Fancy');
+
+    assert.dom('p.purple').hasStyle(
+      {
+        'color': 'rgb(102, 51, 153)',
+      },
+      'The text should be purple if the app styles are working correctly',
+    )
+  });
+});

package/tests/fixtures/tests-ts-10/tests/integration/components/sweet-test.gjs

@@ -0,0 +1,28 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'test-app/tests/helpers';
+import { render } from '@ember/test-helpers';
+import Sweet from 'test-app/components/sweet';
+
+module('Integration | Component | sweet', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    // Updating values is achieved using autotracking, just like in app code. For example:
+    // class State { @tracked myProperty = 0; }; const state = new State();
+    // and update using state.myProperty = 1; await rerender();
+    // Handle any actions with function myAction(val) { ... };
+
+    await render(<template><Sweet /></template>);
+
+    assert.dom().hasText('');
+
+    // Template block usage:
+    await render(<template>
+      <Sweet>
+        template block text
+      </Sweet>
+    </template>);
+
+    assert.dom().hasText('template block text');
+  });
+});

package/tests/fixtures/tests-ts-10/tests/routes/fancy-test.js

@@ -0,0 +1,11 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'test-app/tests/helpers';
+
+module('Unit | Route | fancy', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    let route = this.owner.lookup('route:fancy');
+    assert.ok(route);
+  });
+});

package/tests/generators.test.mjs

@@ -0,0 +1,60 @@
+import { beforeAll, describe, it, expect } from 'vitest';
+
+import { generateApp } from './helpers.mjs';
+
+describe('Slow(JavaScript): Generate individual files', function () {
+  let app;
+
+  beforeAll(async function () {
+    app = await generateApp({ flags: ['--pnpm'], skipNpm: false });
+  });
+
+  it('can generate a route', async function () {
+    let { exitCode, stdout } = await app.execa('pnpm', [
+      'ember',
+      'g',
+      'route',
+      'fancy',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout);
+    }
+
+    expect(exitCode).to.equal(0);
+    expect(app.files.app.routes['fancy.js']).to.not.be.undefined;
+    expect(app.files.app['router.js']).to.contain(`this.route('fancy')`);
+    expect(app.files.tests.unit.routes['fancy-test.js']).to.not.be.undefined;
+  });
+
+  // Note: We could run additional generators here (component, controller, etc)
+});
+
+describe('Slow(TypeScript): Generate individual files', function () {
+  let app;
+
+  beforeAll(async function () {
+    app = await generateApp({
+      flags: ['--pnpm', '--typescript'],
+      skipNpm: false,
+    });
+  });
+
+  it('can generate a route', async function () {
+    let { exitCode, stdout } = await app.execa('pnpm', [
+      'ember',
+      'g',
+      'route',
+      'fancy',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout);
+    }
+
+    expect(exitCode).to.equal(0);
+    expect(app.files.app.routes['fancy.ts']).to.not.be.undefined;
+    expect(app.files.app['router.ts']).to.contain(`this.route('fancy')`);
+    expect(app.files.tests.unit.routes['fancy-test.ts']).to.not.be.undefined;
+  });
+});

package/tests/helpers.mjs

@@ -1,80 +1,45 @@
-import assert from 'node:assert';
-
-import { beforeAll } from 'vitest';
-import { sync as resolveBinSync } from 'resolve-bin';
 import { execa } from 'execa';
 import tmp from 'tmp-promise';
-import fs from 'node:fs/promises';
 import { join } from 'node:path';
 import fixturify from 'fixturify';
 
 let localEmberCli = require.resolve('ember-cli/bin/ember');
 const blueprintPath = join(__dirname, '..');
 
-function findEmber() {
-  return resolveBinSync('ember-cli', { executable: 'ember' });
-}
-
-export const emberCli = findEmber();
-
-const appName = 'test-app';
-
-export function newProject({ name = appName, flags = [] } = {}) {
-  let dir;
-
-  beforeAll(async () => {
-    const tmpDir = (await tmp.dir()).path;
-    dir = join(tmpDir, name);
-    await execa({
-      cwd: tmpDir,
-    })`${localEmberCli} new ${name} -b ${blueprintPath} --skip-git --pnpm ${flags}`;
-  });
-
-  return {
-    appName: () => name,
-    dir: () => dir,
-    $: (...args) => execa({ cwd: dir })(...args),
-    execa: (program, args, options = {}) => {
-      return execa(program, args, {
-        cwd: dir,
-        ...options,
-      });
-    },
-  };
-}
-
-export function newProjectWithFixtures({
+export async function generateApp({
+  name = 'test-app',
   flags = [],
-  fixturePath,
-  packageJson = {},
-  name = appName,
+  skipNpm = true,
 } = {}) {
-  let dir;
+  const tmpDir = (await tmp.dir()).path;
+  const dir = join(tmpDir, name);
 
-  assert(fixturePath, `a fixturePath is required`);
-
-  beforeAll(async () => {
-    const tmpDir = (await tmp.dir()).path;
-    dir = join(tmpDir, name);
-    await execa({
-      cwd: tmpDir,
-    })`${localEmberCli} new ${name} -b ${blueprintPath} --skip-git --pnpm ${flags}`;
+  if (skipNpm) {
+    flags.push('--skip-npm');
+  }
 
-    let addonFixture = fixturify.readSync(fixturePath);
-    fixturify.writeSync(dir, addonFixture);
+  const execaOptions = {
+    cwd: tmpDir,
+  };
 
-    await mergePackageJson(dir, packageJson);
+  if (!process.env.CI) {
+    execaOptions.stdio = 'inherit';
+  }
 
-    // Sync the lints for the fixtures with the project's config
-    await execa(`pnpm`, ['lint:fix'], {
-      cwd: dir,
-    });
-  });
+  const { stdout, stderr } = await execa(
+    localEmberCli,
+    ['new', name, '--blueprint', blueprintPath, '--skip-git', ...flags],
+    execaOptions,
+  );
 
   return {
-    appName: () => name,
-    dir: () => dir,
-    $: (...args) => execa({ cwd: dir })(...args),
+    stdout,
+    stderr,
+    name,
+    dir,
+    get files() {
+      return fixturify.readSync(dir);
+    },
     execa: (program, args, options = {}) => {
       return execa(program, args, {
         cwd: dir,
@@ -83,33 +48,3 @@ export function newProjectWithFixtures({
     },
   };
 }
-
-async function mergePackageJson(dir, packageJson) {
-  let rootKeys = Object.keys(packageJson || {});
-
-  if (rootKeys.length === 0) {
-    return;
-  }
-
-  let packageJsonPath = join(dir, 'package.json');
-  let testPackageJson = JSON.parse(
-    (await fs.readFile(packageJsonPath)).toString(),
-  );
-
-  for (let rootKey of rootKeys) {
-    /**
-     * For searchability in logs
-     */
-    console.log(`Modifying ${rootKey} in package.json @ ${packageJsonPath}`);
-    let value = packageJson[rootKey];
-
-    let isObject = typeof value === 'object' && !Array.isArray(value);
-    if (!isObject) {
-      throw new Error(`${rootKey} customization is currently not implemented`);
-    }
-
-    Object.assign(testPackageJson[rootKey], value);
-  }
-
-  await fs.writeFile(packageJsonPath, JSON.stringify(testPackageJson, null, 2));
-}

package/tests/lint.test.mjs

@@ -1,26 +1,43 @@
-import { describe, it, expect } from 'vitest';
+import { beforeAll, describe, it, expect } from 'vitest';
 
-import { newProject } from './helpers.mjs';
+import { generateApp } from './helpers.mjs';
 
 describe('linting & formatting', function () {
-  describe('JavaScript', function () {
-    let project = newProject();
+  let app;
 
-    it('yields output for JavaScript without errors', async function () {
-      let { exitCode } = await project.execa('pnpm', ['lint']);
+  beforeAll(async function () {
+    app = await generateApp({ flags: ['--typescript'], skipNpm: false });
+  });
+
+  describe('JavaScript', function () {
+    it('yields output without errors', async function () {
+      let { exitCode } = await app.execa('pnpm', ['lint']);
 
       expect(exitCode).to.equal(0);
     });
   });
 
   describe('TypeScript', function () {
-    let project = newProject({
-      flags: ['--typescript'],
+    let app;
+
+    beforeAll(async function () {
+      app = await generateApp({ flags: ['--typescript'], skipNpm: false });
     });
 
-    it('yields output for JavaScript without errors', async function () {
-      let { exitCode } = await project.execa('pnpm', ['lint']);
+    it('yields output without errors', async function () {
+      let { exitCode } = await app.execa('pnpm', ['lint']);
+
+      expect(exitCode).to.equal(0);
+    });
+
+    it('glint passes', async function () {
+      expect(
+        JSON.parse(app.files['package.json']).scripts['lint:types'],
+      ).to.equal('glint');
+
+      let { exitCode, stdout } = await app.execa('pnpm', ['lint:types']);
 
+      console.log(stdout);
       expect(exitCode).to.equal(0);
     });
   });

package/tests/tests.test.mjs

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest';
+import fixturify from 'fixturify';
+import stripAnsi from 'strip-ansi';
+
+import { generateApp } from './helpers.mjs';
+
+describe('Slow(JavaScript): Runs tests', async function () {
+  it('runs in a freshly generated app', async function () {
+    let app = await generateApp({ flags: ['--pnpm'], skipNpm: false });
+
+    let { stdout: stdout1, exitCode: exitCode1 } = await app.execa('pnpm', [
+      'test',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout1);
+    }
+
+    expect(stdout1).to.contain('# tests 1');
+    expect(stdout1).to.contain('# pass  1');
+    expect(stdout1).to.contain('# skip  0');
+    expect(stdout1).to.contain('# todo  0');
+    expect(stdout1).to.contain('# ok');
+    expect(exitCode1).to.equal(0);
+  });
+
+  it('runs in an app with fixtures', async function () {
+    let app = await generateApp({ flags: ['--pnpm'], skipNpm: false });
+
+    fixturify.writeSync(
+      app.dir,
+      fixturify.readSync('./tests/fixtures/tests-js-10'),
+    );
+
+    let { stdout: stdout2, exitCode: exitCode2 } = await app.execa('pnpm', [
+      'test',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout2);
+    }
+
+    expect(stdout2).to.match(/ok .* Acceptance \| app route/);
+    expect(stdout2).to.match(/ok .* Acceptance \| index/);
+    expect(stdout2).to.match(/ok .* Integration \| Component \| sweet/);
+    expect(stdout2).to.match(/ok .* Unit \| Route \| fancy/);
+    expect(stdout2).to.match(/ok .* Ember.onerror/);
+
+    expect(stdout2).to.contain('# tests 6');
+    expect(stdout2).to.contain('# pass  6');
+    expect(stdout2).to.contain('# skip  0');
+    expect(stdout2).to.contain('# todo  0');
+    expect(stdout2).to.contain('# ok');
+    expect(exitCode2).to.equal(0);
+  });
+
+  it('runs when serving /tests', async function () {
+    let app = await generateApp({ flags: ['--pnpm'], skipNpm: false });
+
+    await app.execa('pnpm', ['install', '--save-dev', 'testem', 'http-proxy']);
+
+    let fixtures = fixturify.readSync('./tests/fixtures/tests-js-20');
+    let server;
+
+    try {
+      server = app.execa('pnpm', ['start']);
+
+      let appURL = await new Promise((resolve) => {
+        // Read app url from Vite server output
+        server.stdout.on('data', (line) => {
+          let parsed = stripAnsi(line.toString());
+          let result = /Local:\s+(https?:\/\/.*)\//g.exec(parsed);
+
+          if (process.env.CI) {
+            console.log(parsed);
+          }
+
+          if (result) {
+            resolve(result[1]);
+          }
+        });
+      });
+
+      fixtures['testem-dev.js'] = fixtures['testem-dev.js'].replace(
+        '%APP_URL%',
+        appURL,
+      );
+      fixturify.writeSync(app.dir, fixtures);
+
+      let testResult = await app.execa('pnpm', [
+        'testem',
+        '--file',
+        'testem-dev.js',
+        'ci',
+      ]);
+
+      if (process.env.CI) {
+        console.log(testResult.stdout);
+        console.log(testResult.stderr);
+      }
+
+      expect(testResult.exitCode).to.eq(0);
+    } finally {
+      server?.kill('SIGKILL');
+    }
+  });
+});
+
+describe('Slow(TypeScript): Runs tests', async function () {
+  it('runs in a freshly generated app', async function () {
+    let app = await generateApp({
+      flags: ['--pnpm', '--typescript'],
+      skipNpm: false,
+    });
+
+    let { stdout: stdout1, exitCode: exitCode1 } = await app.execa('pnpm', [
+      'test',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout1);
+    }
+
+    expect(stdout1).to.contain('# tests 1');
+    expect(stdout1).to.contain('# pass  1');
+    expect(stdout1).to.contain('# skip  0');
+    expect(stdout1).to.contain('# todo  0');
+    expect(stdout1).to.contain('# ok');
+    expect(exitCode1).to.equal(0);
+  });
+
+  it('runs in an app with fixtures', async function () {
+    let app = await generateApp({
+      flags: ['--pnpm', '--typescript'],
+      skipNpm: false,
+    });
+
+    fixturify.writeSync(
+      app.dir,
+      fixturify.readSync('./tests/fixtures/tests-ts-10'),
+    );
+
+    let { stdout: stdout2, exitCode: exitCode2 } = await app.execa('pnpm', [
+      'test',
+    ]);
+
+    if (!process.env.CI) {
+      console.log(stdout2);
+    }
+
+    expect(stdout2).to.match(/ok .* Acceptance \| app route/);
+    expect(stdout2).to.match(/ok .* Acceptance \| index/);
+    expect(stdout2).to.match(/ok .* Integration \| Component \| sweet/);
+    expect(stdout2).to.match(/ok .* Unit \| Route \| fancy/);
+    expect(stdout2).to.match(/ok .* Ember.onerror/);
+
+    expect(stdout2).to.contain('# tests 6');
+    expect(stdout2).to.contain('# pass  6');
+    expect(stdout2).to.contain('# skip  0');
+    expect(stdout2).to.contain('# todo  0');
+    expect(stdout2).to.contain('# ok');
+    expect(exitCode2).to.equal(0);
+  });
+
+  it('runs when serving /tests', async function () {
+    let app = await generateApp({
+      flags: ['--pnpm', '--typescript'],
+      skipNpm: false,
+    });
+
+    await app.execa('pnpm', ['install', '--save-dev', 'testem', 'http-proxy']);
+
+    let fixtures = fixturify.readSync('./tests/fixtures/tests-js-20');
+    let server;
+
+    try {
+      server = app.execa('pnpm', ['start']);
+
+      let appURL = await new Promise((resolve) => {
+        // Read app url from Vite server output
+        server.stdout.on('data', (line) => {
+          let parsed = stripAnsi(line.toString());
+          let result = /Local:\s+(https?:\/\/.*)\//g.exec(parsed);
+
+          if (process.env.CI) {
+            console.log(parsed);
+          }
+
+          if (result) {
+            resolve(result[1]);
+          }
+        });
+      });
+
+      fixtures['testem-dev.js'] = fixtures['testem-dev.js'].replace(
+        '%APP_URL%',
+        appURL,
+      );
+      fixturify.writeSync(app.dir, fixtures);
+
+      let testResult = await app.execa('pnpm', [
+        'testem',
+        '--file',
+        'testem-dev.js',
+        'ci',
+      ]);
+
+      if (process.env.CI) {
+        console.log(testResult.stdout);
+        console.log(testResult.stderr);
+      }
+
+      expect(testResult.exitCode).to.eq(0);
+    } finally {
+      server?.kill('SIGKILL');
+    }
+  });
+});

package/vitest.config.ts

@@ -4,7 +4,7 @@ const ONE_SECOND = 1_000;
 
 export default defineConfig({
   test: {
-    testTimeout: 100 * ONE_SECOND,
-    hookTimeout: 150 * ONE_SECOND,
+    testTimeout: 240 * ONE_SECOND,
+    hookTimeout: 240 * ONE_SECOND,
   },
 });