@teambit/tester 0.0.554 → 0.0.558

package/tester.main.runtime.ts

@@ -1,245 +0,0 @@
-import fs from 'fs-extra';
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { Component } from '@teambit/component';
-import compact from 'lodash.compact';
-import { EnvsAspect, EnvsExecutionResult, EnvsMain } from '@teambit/envs';
-import { LoggerAspect, LoggerMain } from '@teambit/logger';
-import { Workspace, WorkspaceAspect } from '@teambit/workspace';
-import { GraphqlAspect, GraphqlMain } from '@teambit/graphql';
-import { BuilderAspect, BuilderMain } from '@teambit/builder';
-import { UiMain, UIAspect } from '@teambit/ui';
-import { merge } from 'lodash';
-import DevFilesAspect, { DevFilesMain } from '@teambit/dev-files';
-import { TestsResult } from '@teambit/tests-results';
-import { ComponentsResults, CallbackFn, Tests } from './tester';
-import { TestCmd } from './test.cmd';
-import { TesterAspect } from './tester.aspect';
-import { TesterService } from './tester.service';
-import { TesterTask } from './tester.task';
-import { detectTestFiles } from './utils';
-import { testerSchema } from './tester.graphql';
-import { testsResultsToJUnitFormat } from './utils/junit-generator';
-
-export type TesterExtensionConfig = {
-  /**
-   * regex of the text environment.
-   */
-  testRegex: string;
-
-  /**
-   * determine whether to watch on start.
-   */
-  watchOnStart: boolean;
-  patterns: string[];
-};
-
-export type TesterOptions = {
-  /**
-   * start the tester in watch mode.
-   */
-  watch: boolean;
-
-  /**
-   * start the tester in debug mode.
-   */
-  debug: boolean;
-
-  /**
-   * start the tester in debug mode.
-   */
-  ui?: boolean;
-
-  /**
-   * initiate the tester on given env.
-   */
-  env?: string;
-
-  /**
-   * generate JUnit files on the specified dir
-   */
-  junit?: string;
-
-  /**
-   * show code coverage
-   */
-  coverage?: boolean;
-
-  callback?: CallbackFn;
-};
-
-export class TesterMain {
-  static runtime = MainRuntime;
-  static dependencies = [
-    CLIAspect,
-    EnvsAspect,
-    WorkspaceAspect,
-    LoggerAspect,
-    GraphqlAspect,
-    UIAspect,
-    DevFilesAspect,
-    BuilderAspect,
-  ];
-
-  constructor(
-    /**
-     * graphql extension.
-     */
-    private graphql: GraphqlMain,
-
-    /**
-     * envs extension.
-     */
-    private envs: EnvsMain,
-
-    /**
-     * workspace extension.
-     */
-    private workspace: Workspace,
-
-    /**
-     * tester service.
-     */
-    readonly service: TesterService,
-
-    /**
-     * build task.
-     */
-    readonly task: TesterTask,
-
-    private devFiles: DevFilesMain,
-
-    private builder: BuilderMain
-  ) {}
-
-  _testsResults: { [componentId: string]: ComponentsResults } | undefined[] = [];
-
-  async test(components: Component[], opts?: TesterOptions): Promise<EnvsExecutionResult<Tests>> {
-    const options = this.getOptions(opts);
-    const envsRuntime = await this.envs.createEnvironment(components);
-    if (opts?.env) {
-      return envsRuntime.runEnv(opts.env, this.service, options);
-    }
-    const results = await envsRuntime.run(this.service, options);
-    if (opts?.junit) {
-      await this.generateJUnit(opts?.junit, results);
-    }
-    return results;
-  }
-
-  private async generateJUnit(filePath: string, testsResults: EnvsExecutionResult<Tests>) {
-    const components = testsResults.results.map((envResult) => envResult.data?.components).flat();
-    const jUnit = testsResultsToJUnitFormat(compact(components));
-    await fs.outputFile(filePath, jUnit);
-  }
-
-  /**
-   * watch all components for changes and test upon each.
-   */
-  async watch(components: Component[], opts?: TesterOptions) {
-    const options = this.getOptions(opts);
-    const envsRuntime = await this.envs.createEnvironment(components);
-    if (opts?.env) {
-      return envsRuntime.runEnv(opts.env, this.service, options);
-    }
-
-    this.service.onTestRunComplete((results) => {
-      results.components.forEach((component) => {
-        this._testsResults[component.componentId.toString()] = component;
-      });
-    });
-    return envsRuntime.run(this.service, options);
-  }
-
-  async uiWatch() {
-    const components = await this.workspace.list();
-    return this.watch(components, { watch: true, debug: false, ui: true });
-  }
-
-  async getTestsResults(component: Component): Promise<{ testsResults?: TestsResult; loading: boolean } | undefined> {
-    const entry = component.state.aspects.get(TesterAspect.id);
-    const componentStatus = await this.workspace?.getComponentStatus(component);
-    const data = this.builder.getDataByAspect(component, TesterAspect.id) as { tests: TestsResult };
-    if ((entry || data) && !componentStatus?.modifyInfo?.hasModifiedFiles) {
-      return { testsResults: data?.tests || entry?.data.tests, loading: false };
-    }
-    return this.getTestsResultsFromState(component);
-  }
-
-  private getTestsResultsFromState(component: Component) {
-    const tests = this._testsResults[component.id.toString()];
-    return { testsResults: tests?.results, loading: tests?.loading || false };
-  }
-
-  /**
-   * get all test files of a component.
-   */
-  getTestFiles(component: Component) {
-    return detectTestFiles(component, this.devFiles);
-  }
-
-  private getOptions(options?: TesterOptions): TesterOptions {
-    const defaults = {
-      watch: false,
-      debug: false,
-    };
-
-    return merge(defaults, options);
-  }
-
-  static defaultConfig = {
-    /**
-     * default test regex for which files tester to apply on.
-     */
-    patterns: ['**/*.spec.+(js|ts|jsx|tsx)', '**/*.test.+(js|ts|jsx|tsx)'],
-
-    /**
-     * determine whether to watch on start.
-     */
-    watchOnStart: true,
-  };
-
-  static async provider(
-    [cli, envs, workspace, loggerAspect, graphql, ui, devFiles, builder]: [
-      CLIMain,
-      EnvsMain,
-      Workspace,
-      LoggerMain,
-      GraphqlMain,
-      UiMain,
-      DevFilesMain,
-      BuilderMain
-    ],
-    config: TesterExtensionConfig
-  ) {
-    const logger = loggerAspect.createLogger(TesterAspect.id);
-    const testerService = new TesterService(workspace, config.patterns, logger, graphql.pubsub, devFiles);
-    envs.registerService(testerService);
-    devFiles.registerDevPattern(config.patterns);
-    const tester = new TesterMain(
-      graphql,
-      envs,
-      workspace,
-      testerService,
-      new TesterTask(TesterAspect.id, devFiles),
-      devFiles,
-      builder
-    );
-
-    if (workspace && !workspace.consumer.isLegacy) {
-      cli.unregister('test');
-      ui.registerOnStart(async () => {
-        if (!config.watchOnStart) return undefined;
-        await tester.uiWatch();
-        return undefined;
-      });
-
-      cli.register(new TestCmd(tester, workspace, logger));
-    }
-
-    graphql.register(testerSchema(tester, graphql));
-
-    return tester;
-  }
-}
-
-TesterAspect.addRuntime(TesterMain);

package/tester.service.tsx

@@ -1,161 +0,0 @@
-import { Logger } from '@teambit/logger';
-import { resolve } from 'path';
-import React from 'react';
-import { Text, Newline } from 'ink';
-import { EnvService, ExecutionContext, EnvDefinition } from '@teambit/envs';
-import { ComponentMap } from '@teambit/component';
-import { Workspace } from '@teambit/workspace';
-import highlight from 'cli-highlight';
-import { PubSub } from 'graphql-subscriptions';
-import { DevFilesMain } from '@teambit/dev-files';
-import { Tester, Tests, CallbackFn } from './tester';
-import { TesterAspect } from './tester.aspect';
-import { TesterOptions } from './tester.main.runtime';
-import { detectTestFiles } from './utils';
-import { NoTestFilesFound } from './exceptions';
-
-const chalk = require('chalk');
-
-export const OnTestsChanged = 'OnTestsChanged';
-
-export type TesterDescriptor = {
-  /**
-   * id of the tester (e.g. jest/mocha)
-   */
-  id: string;
-
-  /**
-   * display name of the tester (e.g. Jest / Mocha)
-   */
-  displayName: string;
-
-  /**
-   * icon of the configured tester.
-   */
-  icon: string;
-
-  /**
-   * string containing the config for display.
-   */
-  config: string;
-
-  version?: string;
-};
-
-export class TesterService implements EnvService<Tests, TesterDescriptor> {
-  name = 'tester';
-
-  constructor(
-    readonly workspace: Workspace,
-    /**
-     * regex used to identify which files to test.
-     */
-    readonly patterns: string[],
-
-    private logger: Logger,
-
-    private pubsub: PubSub,
-
-    private devFiles: DevFilesMain
-  ) {}
-
-  _callback: CallbackFn | undefined;
-
-  render(env: EnvDefinition) {
-    const descriptor = this.getDescriptor(env);
-    return (
-      <Text key={descriptor?.id}>
-        <Text color="cyan">configured tester: </Text>
-        <Text>
-          {descriptor?.id} ({descriptor?.displayName} @ {descriptor?.version})
-        </Text>
-        <Newline />
-        <Text underline color="cyan">
-          tester config:
-        </Text>
-        <Newline />
-        <Text>
-          {/* refactor a separate component which highlights for cli */}
-          {highlight(descriptor?.config || '', { language: 'javascript', ignoreIllegals: true })}
-        </Text>
-        <Newline />
-      </Text>
-    );
-  }
-
-  getDescriptor(environment: EnvDefinition) {
-    if (!environment.env.getTester) return undefined;
-    const tester: Tester = environment.env.getTester();
-
-    return {
-      id: tester.id || '',
-      displayName: tester.displayName || '',
-      icon: tester.icon || '',
-      config: tester.displayConfig ? tester.displayConfig() : '',
-      version: tester.version ? tester.version() : '?',
-    };
-  }
-
-  onTestRunComplete(callback: CallbackFn) {
-    this._callback = callback;
-  }
-
-  async run(context: ExecutionContext, options: TesterOptions): Promise<Tests> {
-    const tester: Tester = context.env.getTester();
-    const specFiles = ComponentMap.as(context.components, (component) => {
-      return detectTestFiles(component, this.devFiles);
-    });
-    const testCount = specFiles.toArray().reduce((acc, [, specs]) => acc + specs.length, 0);
-
-    const componentWithTests = specFiles.toArray().reduce((acc: number, [, specs]) => {
-      if (specs.length > 0) acc += 1;
-      return acc;
-    }, 0);
-
-    if (testCount === 0 && !options.ui) throw new NoTestFilesFound(this.patterns.join(','));
-
-    if (!options.ui)
-      this.logger.console(`testing ${componentWithTests} components with environment ${chalk.cyan(context.id)}\n`);
-
-    const patterns = ComponentMap.as(context.components, (component) => {
-      const dir = this.workspace.componentDir(component.id);
-      const componentPatterns = this.devFiles.getDevPatterns(component, TesterAspect.id);
-      return componentPatterns.map((pattern: string) => ({ path: resolve(dir, pattern), relative: pattern }));
-    });
-
-    const testerContext = Object.assign(context, {
-      release: false,
-      specFiles,
-      patterns,
-      rootPath: this.workspace.path,
-      workspace: this.workspace,
-      debug: options.debug,
-      watch: options.watch,
-      ui: options.ui,
-      coverage: options.coverage,
-    });
-
-    if (options.watch && options.ui && tester.watch) {
-      if (tester.onTestRunComplete) {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        tester.onTestRunComplete((results) => {
-          if (this._callback) this._callback(results);
-          results.components.forEach((component) => {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.pubsub.publish(OnTestsChanged, {
-              testsChanged: {
-                id: component.componentId.toString(),
-                testsResults: component.results,
-                loading: component.loading,
-              },
-            });
-          });
-        });
-      }
-
-      return tester.watch(testerContext);
-    }
-
-    return tester.test(testerContext);
-  }
-}

package/tester.task.ts

@@ -1,111 +0,0 @@
-import { BuildContext, BuiltTaskResult, BuildTask } from '@teambit/builder';
-import fs from 'fs-extra';
-import { join } from 'path';
-import { Compiler, CompilerAspect } from '@teambit/compiler';
-import { DevFilesMain } from '@teambit/dev-files';
-import { ComponentMap } from '@teambit/component';
-import { Tester } from './tester';
-import { detectTestFiles } from './utils';
-import { testsResultsToJUnitFormat } from './utils/junit-generator';
-
-const JUNIT_PATH = '__bit_junit.xml';
-
-/**
- * tester build task. Allows to test components during component build.
- */
-export class TesterTask implements BuildTask {
-  readonly name = 'TestComponents';
-  readonly dependencies = [CompilerAspect.id];
-  constructor(readonly aspectId: string, private devFiles: DevFilesMain) {}
-
-  async execute(context: BuildContext): Promise<BuiltTaskResult> {
-    const tester: Tester = context.env.getTester();
-    const componentsSpecFiles = ComponentMap.as(context.components, (component) => {
-      return detectTestFiles(component, this.devFiles);
-    });
-
-    const testCount = componentsSpecFiles.toArray().reduce((acc, [, specs]) => acc + specs.length, 0);
-    if (testCount === 0)
-      return {
-        artifacts: [],
-        componentsResults: [],
-      };
-
-    const specFilesWithCapsule = ComponentMap.as(context.components, (component) => {
-      const componentSpecFiles = componentsSpecFiles.get(component);
-      if (!componentSpecFiles) throw new Error('capsule not found');
-      const [, specs] = componentSpecFiles;
-      return specs.map((specFile) => {
-        const capsule = context.capsuleNetwork.graphCapsules.getCapsule(component.id);
-        if (!capsule) throw new Error('capsule not found');
-        const compiler: Compiler = context.env.getCompiler();
-        const distPath = compiler.getDistPathBySrcPath(specFile.relative);
-
-        // TODO: fix spec type file need to capsule will return files with type AbstractVinyl
-        return { path: join(capsule.path, distPath), relative: distPath };
-      });
-    });
-
-    const testerContext = Object.assign(context, {
-      release: true,
-      specFiles: specFilesWithCapsule,
-      rootPath: context.capsuleNetwork.capsulesRootDir,
-      patterns: specFilesWithCapsule,
-    });
-
-    // TODO: remove after fix AbstractVinyl on capsule
-    // @ts-ignore
-    const testsResults = await tester.test(testerContext);
-
-    // write junit files
-    await Promise.all(
-      testsResults.components.map(async (compResult) => {
-        const junit = testsResultsToJUnitFormat([compResult]);
-        const capsule = context.capsuleNetwork.graphCapsules.getCapsule(compResult.componentId);
-        if (!capsule) {
-          throw new Error(`unable to find ${compResult.componentId.toString()} in capsules`);
-        }
-        await fs.writeFile(join(capsule.path, JUNIT_PATH), junit);
-        await this.writeNpmIgnore(capsule.path);
-      })
-    );
-
-    return {
-      artifacts: [
-        {
-          name: 'junit',
-          globPatterns: [JUNIT_PATH],
-        },
-      ], // @ts-ignore
-      componentsResults: testsResults.components.map((componentTests) => {
-        const componentErrors = componentTests.results?.testFiles.reduce((errors: string[], file) => {
-          if (file?.error?.failureMessage) {
-            errors.push(file.error.failureMessage);
-          }
-          file.tests.forEach((test) => {
-            if (test.error) errors.push(test.error);
-            if (test.failure) errors.push(test.failure);
-          });
-
-          return errors;
-        }, []);
-        const component = context.capsuleNetwork.graphCapsules.getCapsule(componentTests.componentId)?.component;
-        if (!component) {
-          throw new Error(`unable to find ${componentTests.componentId.toString()} in capsules`);
-        }
-        return {
-          component,
-          metadata: { tests: componentTests.results },
-          errors: componentErrors,
-        };
-      }),
-    };
-  }
-
-  private async writeNpmIgnore(dir: string) {
-    const NPM_IGNORE_FILE = '.npmignore';
-    const npmIgnorePath = join(dir, NPM_IGNORE_FILE);
-    const npmIgnoreEntriesStr = `\n${JUNIT_PATH}\n`;
-    await fs.appendFile(npmIgnorePath, npmIgnoreEntriesStr);
-  }
-}

package/tester.ts

@@ -1,126 +0,0 @@
-import { Component, ComponentID, ComponentMap } from '@teambit/component';
-import { ExecutionContext } from '@teambit/envs';
-import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
-import { TestsResult } from '@teambit/tests-results';
-
-export type Tests = {
-  components: ComponentsResults[];
-  errors?: Error[];
-};
-
-export type ComponentsResults = {
-  componentId: ComponentID;
-  results?: TestsResult;
-  loading?: boolean;
-};
-
-export type SpecFiles = ComponentMap<AbstractVinyl[]>;
-export type ComponentPatternsMap = ComponentMap<{ path: string; relative: string }[]>;
-
-export interface TesterContext extends ExecutionContext {
-  /**
-   * whether the tester run for release (during bit build/tag) or not (during bit test command).
-   */
-  release: boolean;
-
-  /**
-   * list of components to test.
-   */
-  components: Component[];
-
-  /**
-   * component workspace.
-   */
-  // workspace: Workspace;
-
-  /**
-   * defines whether tester is expected to run in quiet mode.
-   */
-  quiet?: boolean;
-
-  /**
-   * list of spec files to test.
-   */
-  specFiles: SpecFiles;
-
-  /**
-   * rootPath of the component workspace or the capsule root dir (during build).
-   */
-  rootPath: string;
-
-  /**
-   * determines whether tester is expected to run in debug mode.
-   */
-  debug?: boolean;
-
-  /**
-   * is start from ui
-   */
-  ui?: boolean;
-
-  /**
-   * determines whether to start the tester in watch mode.
-   */
-  watch?: boolean;
-
-  /**
-   * whether the tester should show code coverage
-   */
-  coverage?: boolean;
-
-  /**
-   * array of patterns to test.
-   */
-  patterns: ComponentPatternsMap;
-}
-
-/**
- * tester interface allows extensions to implement a component tester into bit.
- */
-export interface Tester {
-  /**
-   * display name of the tester.
-   */
-  displayName?: string;
-
-  /**
-   * icon of the tester.
-   */
-  icon?: string;
-
-  /**
-   * serialized config of the tester.
-   */
-  displayConfig?(): string;
-
-  /**
-   * path to the config in the filesystem.
-   */
-  configPath?: string;
-
-  /**
-   * id of the tester.
-   */
-  id: string;
-
-  /**
-   * on test run complete. (applies only during watch)
-   * @param callback
-   */
-  onTestRunComplete?(callback: CallbackFn): Promise<void>;
-
-  /**
-   * execute tests on all components in the given execution context.
-   */
-  test(context: TesterContext): Promise<Tests>;
-
-  /**
-   * watch tests on all components
-   */
-  watch?(context: TesterContext): Promise<Tests>;
-  /**
-   * return the tester version.
-   */
-  version(): string;
-}
-export type CallbackFn = (testSuite: Tests) => void;

package/tester.ui.runtime.tsx

@@ -1,42 +0,0 @@
-import { ComponentType } from 'react';
-import { UIRuntime } from '@teambit/ui';
-import { SlotRegistry, Slot } from '@teambit/harmony';
-import { ComponentAspect, ComponentUI } from '@teambit/component';
-import { TestsSection } from './tests.section';
-import { TesterAspect } from './tester.aspect';
-
-export type EmptyStateSlot = SlotRegistry<ComponentType>;
-export class TesterUI {
-  static dependencies = [ComponentAspect];
-
-  static runtime = UIRuntime;
-
-  stageKey?: string;
-
-  constructor(private component: ComponentUI, private emptyStateSlot: EmptyStateSlot) {}
-
-  /**
-   * register a new tester empty state. this allows to register a different empty state from each environment for example.
-   */
-  registerEmptyState(emptyStateComponent: ComponentType) {
-    this.emptyStateSlot.register(emptyStateComponent);
-    return this;
-  }
-
-  static slots = [Slot.withType<ComponentType>()];
-
-  static async provider([component]: [ComponentUI], config, [emptyStateSlot]: [EmptyStateSlot]) {
-    const testerUi = new TesterUI(component, emptyStateSlot);
-
-    const section = new TestsSection(emptyStateSlot);
-
-    component.registerRoute(section.route);
-    component.registerNavigation(section.navigationLink, section.order);
-
-    return testerUi;
-  }
-}
-
-export default TesterUI;
-
-TesterAspect.addRuntime(TesterUI);

package/tests.section.tsx

@@ -1,18 +0,0 @@
-import React from 'react';
-import { Section } from '@teambit/component';
-import { TestsPage } from './ui/tests-page';
-import { EmptyStateSlot } from './tester.ui.runtime';
-
-export class TestsSection implements Section {
-  constructor(private emptyStateSlot: EmptyStateSlot) {}
-
-  route = {
-    path: '~tests',
-    children: <TestsPage emptyState={this.emptyStateSlot} />,
-  };
-  navigationLink = {
-    href: '~tests',
-    children: 'Tests',
-  };
-  order = 40;
-}