broccoli-test-helper's Introduction

broccoli-test-helper

Test helpers for BroccoliPlugins that make testing build and rebuild behavior dead simple and diff friendly.

Has TypeScript declarations and supports async/await style testing.

Usage Examples
- QUnit and TypeScript
- Mocha and co
API

Usage Examples

QUnit and TypeScript

Example works in Node 4+ by using tsc -t ES2015 -m commonjs to compile async/await to generator wrapped in a helper.

import { createBuilder, createTempDir } from "broccoli-test-helper";
import Herp2Derp = require("../index");

QUnit.module("Herp2Derp", () => {
  QUnit.test("test build", async assert => {
    const input = await createTempDir();
    try {
      const subject = new Herp2Derp(input.path());
      const output = createBuilder(subject);
      try {
        // INITIAL
        input.write({
          "a.herp": "A",
          lib: {
            "b.herp": "B",
            "c.herp": "C",
          },
        });
        await output.build();

        assert.deepEqual(output.read(), {
          "a.derp": "derp A!",
          lib: {
            "b.derp": "derp B!",
            "c.derp": "derp C!",
          },
        });
        assert.deepEqual(output.changes(), {
          "a.derp": "create",
          "lib/": "mkdir",
          "lib/b.derp": "create",
          "lib/c.derp": "create",
        });

        // UPDATE
        input.write({
          "a.herp": "AA", // change
          lib: null, // rmdir
        });
        await output.build();

        assert.deepEqual(output.read(), {
          "a.derp": "derp AA!",
        });
        assert.deepEqual(output.changes(), {
          "lib/c.derp": "unlink",
          "lib/b.derp": "unlink",
          "lib/": "rmdir",
          "a.derp": "change",
        });

        // NOOP
        await output.build();

        assert.deepEqual(output.changes(), {});
      } finally {
        await output.dispose();
      }
    } finally {
      await input.dispose();
    }
  });
});

Mocha

Example works in Node 8+ by using async/await.

const { createBuilder, createTempDir } = require('broccoli-test-helper');
const { expect } = require('chai');
const Herp2Derp = require('../index');

describe('Herp2Derp', function () {
  it('should build', async function () {
    const input = await createTempDir();
    try {
      const subject = new Herp2Derp(input.path());
      const output = createBuilder(subject);
      try {
        // INITIAL
        input.write({
          'a.herp': 'A',
          lib: {
            'b.herp': 'B',
            'c.herp': 'C',
          },
        });
        await output.build();

        expect(output.read()).to.deep.equal({
          'a.derp': 'derp A!',
          lib: {
            'b.derp': 'derp B!',
            'c.derp': 'derp C!',
          },
        });
        expect(output.changes()).to.deep.equal({
          'a.derp': 'create',
          'lib/': 'mkdir',
          'lib/b.derp': 'create',
          'lib/c.derp': 'create',
        });

        // UPDATE
        input.write({
          'a.herp': 'AA', // change
          lib: null, // rmdir
        });
        await output.build();

        expect(output.read()).to.deep.equal({
          'a.derp': 'derp AA!',
        });
        expect(output.changes()).to.deep.equal({
          'lib/c.derp': 'unlink',
          'lib/b.derp': 'unlink',
          'lib/': 'rmdir',
          'a.derp': 'change',
        });

        // NOOP
        await output.build();

        expect(output.changes()).to.deep.equal({});
      } finally {
        await output.dispose();
      }
    } finally {
      await input.dispose();
    }
  });
});

broccoli-test-helper's People

Contributors

Stargazers

Watchers

broccoli-test-helper's Issues

Sourcemaps seems to be missing?

While stepping into code from this library I can only see a blank screen (no code):

should we move this to the broccolijs org?

thoughts @rwjblue ?

Add `output.files()` method?

I commonly have to write the following code to ensure that the list of files is as expected:

it('...', co.wrap(function* () {
  // ...snip...
  output = createBuilder(someTree);

  yield output.build();

  let files = walkSync(output.path(), { directories: false });
  expect(files).to.deep.equal(['some.txt', 'list.pdf', 'of.png', 'files.gif']);
});