/**
 * Copy all the project's files from its "intermediate build directory" and
 * into the build. The intermediate directory can either be the root of the
 * project or some other location defined in the project's `package.json`.
 *
 * When copying all the files into the build, we exclude `node_modules` because
 * we want the Kibana build to be responsible for actually installing all
 * dependencies. The primary reason for allowing the Kibana build process to
 * manage dependencies is that it will "dedupe" them, so we don't include
 * unnecessary copies of dependencies.
 */
async function copyToBuild(project: Project, kibanaRoot: string, buildRoot: string) {
  // We want the package to have the same relative location within the build
  const relativeProjectPath = relative(kibanaRoot, project.path);
  const buildProjectPath = resolve(buildRoot, relativeProjectPath);

  await copy(['**/*', '!node_modules/**'], buildProjectPath, {
    cwd: project.getIntermediateBuildDirectory(),
    dot: true,
    nodir: true,
    parents: true,
  });

  // If a project is using an intermediate build directory, we special-case our
  // handling of `package.json`, as the project build process might have copied
  // (a potentially modified) `package.json` into the intermediate build
  // directory already. If so, we want to use that `package.json` as the basis
  // for creating the production-ready `package.json`. If it's not present in
  // the intermediate build, we fall back to using the project's already defined
  // `package.json`.
  const packageJson = (await isFile(join(buildProjectPath, 'package.json')))
    ? await readPackageJson(buildProjectPath)
    : project.json;

  await writePackageJson(buildProjectPath, packageJson);
}

async function copyAppStaticAssets() {
  const staticPath = 'shared/static';
  return cpy(`src/${staticPath}/**`, `dist/${staticPath}`, {
    cwd: path.join(__dirname, `../packages/react-cosmos`),
    parents: false
  });
}

  beforeEach(async () => {
    tmpDir = tempy.directory();
    buildRoot = tempy.directory();
    const fixturesPath = resolve(__dirname, '__fixtures__');

    // Copy all the test fixtures into a tmp dir, as we will be mutating them
    await copy(['**/*'], tmpDir, {
      cwd: fixturesPath,
      dot: true,
      nodir: true,
      parents: true,
    });

    const projects = await getProjects(tmpDir, ['.', './packages/*']);

    for (const project of projects.values()) {
      // This will both install dependencies and generate `yarn.lock` files
      await project.installDependencies({
        extraArgs: ['--silent', '--no-progress'],
      });
    }
  }, timeout);

    async () => {
      const tmpDir = tempy.directory();
      const buildRoot = tempy.directory();
      const fixturesPath = resolve(__dirname, '__fixtures__');

      // Copy all the test fixtures into a tmp dir, as we will be mutating them
      await copy(['**/*'], tmpDir, {
        cwd: fixturesPath,
        dot: true,
        nodir: true,
        parents: true,
      });

      const projects = await getProjects(tmpDir, ['.', './packages/*']);

      for (const project of projects.values()) {
        // This will both install dependencies and generate `yarn.lock` files
        await project.installDependencies({
          extraArgs: ['--silent', '--no-progress'],
        });
      }

      await buildProductionProjects({ kibanaRoot: tmpDir, buildRoot });

      const files = await globby(['**/*', '!**/node_modules/**'], {
        cwd: buildRoot,
      });

      expect(files.sort()).toMatchSnapshot();

      for (const file of files) {
        if (file.endsWith('package.json')) {
          expect(await readPackageJson(join(buildRoot, file))).toMatchSnapshot(
            file
          );
        }
      }
    },