@ember/app-blueprint 0.8.2 → 6.6.0

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

package/tests/default.test.mjs

@@ -1,155 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { join } from 'path';
-import { existsSync, writeFileSync } from 'fs';
-import stripAnsi from 'strip-ansi';
-import { newProjectWithFixtures } from './helpers.mjs';
-
-const SCENARIOS = [
-  {
-    name: 'defaults',
-    flags: [],
-    fixturePath: join(import.meta.dirname, 'fixture'),
-  },
-  {
-    name: 'compat (v1 addon support)',
-    // @glimmer/component >= 2.0.0 is a v2 addon, which we don't need when testing "compat mode"
-    // this test is "compat mode"
-    // compat mode forces us to use v1 addon infra, ember-cli, etc
-    flags: [
-      /* none, default */
-    ],
-    packageJson: {
-      devDependencies: {
-        '@glimmer/component': '^1.1.2',
-      },
-    },
-    fixturePath: join(import.meta.dirname, 'fixture'),
-  },
-  {
-    name: 'typescript',
-    flags: ['--typescript'],
-    fixturePath: join(import.meta.dirname, 'fixture-ts'),
-  },
-];
-
-describe('basic functionality', function () {
-  for (let { name, flags, packageJson, fixturePath } of SCENARIOS) {
-    describe(name, function () {
-      let project = newProjectWithFixtures({
-        fixturePath,
-        flags,
-        packageJson,
-      });
-
-      it('verify files', async function () {
-        expect(
-          !existsSync(join(project.dir(), 'app/index.html')),
-          'the app index.html has been removed',
-        );
-        expect(
-          existsSync(join(project.dir(), 'index.html')),
-          'the root index.html has been added',
-        );
-      });
-
-      it('successfully builds', async function () {
-        let result = await project.execa('pnpm', ['build']);
-
-        console.log(result.stdout);
-      });
-
-      it('successfully runs tests', async function () {
-        let result;
-
-        try {
-          result = await project.execa('pnpm', ['test']);
-        } catch (err) {
-          console.log(err.stdout, err.stderr);
-          throw 'Failed to successfully run test';
-        }
-
-        // make sure that each of the tests that we expect actually show up
-        // alternatively we can change this to search for `pass 3`
-        expect(result.stdout).to.contain(
-          'Acceptance | welcome page: visiting /index shows the welcome page',
-        );
-        expect(result.stdout).to.contain(
-          'Acceptance | styles: visiting /styles',
-        );
-
-        console.log(result.stdout);
-      });
-
-      it('successfully runs tests in dev mode', async function () {
-        await project.$`pnpm install --save-dev testem http-proxy`;
-        let appURL;
-
-        let server;
-
-        try {
-          server = project.execa('pnpm', ['start']);
-
-          await new Promise((resolve) => {
-            server.stdout.on('data', (line) => {
-              let result = /Local:\s+(https?:\/\/.*)\//g.exec(
-                stripAnsi(line.toString()),
-              );
-
-              if (result) {
-                appURL = result[1];
-                resolve();
-              }
-            });
-          });
-
-          writeFileSync(
-            join(project.dir(), 'testem-dev.js'),
-            `module.exports = {
-  test_page: 'tests/index.html?hidepassed',
-  disable_watching: true,
-  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,
-        '--headless',
-        '--disable-dev-shm-usage',
-        '--disable-software-rasterizer',
-        '--mute-audio',
-        '--remote-debugging-port=0',
-        '--window-size=1440,900',
-      ].filter(Boolean),
-    },
-  },
-  middleware: [
-    require(__dirname + '/testem-proxy.js')('${appURL}')
-  ],
-};
-`,
-          );
-
-          let testResult = await project.execa('pnpm', [
-            'testem',
-            '--file',
-            'testem-dev.js',
-            'ci',
-          ]);
-          expect(testResult.exitCode).to.eq(0, testResult.output);
-        } finally {
-          server?.kill('SIGINT');
-        }
-      });
-
-      it('successfully optimizes deps', function () {
-        return project.execa('pnpm', ['vite', 'optimize', '--force']);
-      });
-
-      it('can run generators', function () {
-        return project.execa('pnpm', ['ember', 'g', 'route', 'fancy']);
-      });
-    });
-  }
-});

package/tests/fixture/app/components/custom-component.hbs

@@ -1,3 +0,0 @@
-<div id="custom-component">
-    I am a custom component
-</div>

package/tests/fixture/app/styles/app.css

@@ -1,5 +0,0 @@
-/* Ember supports plain CSS out of the box. More info: https://cli.emberjs.com/release/advanced-use/stylesheets/ */
-
-.styles-test {
-  background-color: blue;
-}

package/tests/fixture/app/templates/application.hbs

@@ -1,3 +0,0 @@
-{{page-title "FancyApp"}}
-
-{{outlet}}