@teambit/tester 1.0.106 → 1.0.108

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/tester",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "homepage": "https://bit.cloud/teambit/defender/tester",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.defender",
     "name": "tester",
-    "version": "1.0.106"
+    "version": "1.0.108"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -19,43 +19,39 @@
     "cli-highlight": "2.1.9",
     "junit-report-builder": "3.0.1",
     "strip-ansi": "6.0.0",
-    "core-js": "^3.0.0",
-    "@babel/runtime": "7.20.0",
     "@teambit/harmony": "0.4.6",
     "@teambit/component-id": "1.2.0",
+    "@teambit/tests-results": "1.0.4",
     "@teambit/defender.ui.test-compare-section": "0.0.100",
     "@teambit/defender.ui.test-compare": "0.0.255",
     "@teambit/defender.ui.test-page": "0.0.34",
     "@teambit/bit-error": "0.0.404",
-    "@teambit/cli": "0.0.839",
-    "@teambit/logger": "0.0.932",
-    "@teambit/workspace": "1.0.106",
-    "@teambit/envs": "1.0.106",
-    "@teambit/component": "1.0.106",
-    "@teambit/graphql": "1.0.106",
-    "@teambit/builder": "1.0.106",
-    "@teambit/dev-files": "1.0.106",
-    "@teambit/tests-results": "1.0.4",
-    "@teambit/ui": "1.0.106",
-    "@teambit/compiler": "1.0.106",
-    "@teambit/component-compare": "1.0.106"
+    "@teambit/cli": "0.0.840",
+    "@teambit/logger": "0.0.933",
+    "@teambit/workspace": "1.0.108",
+    "@teambit/envs": "1.0.108",
+    "@teambit/component": "1.0.108",
+    "@teambit/graphql": "1.0.108",
+    "@teambit/builder": "1.0.108",
+    "@teambit/dev-files": "1.0.108",
+    "@teambit/ui": "1.0.108",
+    "@teambit/compiler": "1.0.108",
+    "@teambit/component-compare": "1.0.108"
   },
   "devDependencies": {
-    "@types/react": "^17.0.8",
     "@types/fs-extra": "9.0.7",
     "@types/lodash.compact": "3.0.6",
     "@types/lodash": "4.14.165",
     "@types/mocha": "9.1.0",
-    "@types/node": "12.20.4",
-    "@types/react-dom": "^17.0.5",
-    "@types/jest": "^26.0.0",
-    "@types/testing-library__jest-dom": "5.9.5",
-    "@teambit/defender.content.tester-overview": "1.95.0"
+    "@types/jest": "^29.2.2",
+    "@types/testing-library__jest-dom": "^5.9.5",
+    "@teambit/defender.content.tester-overview": "1.95.0",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.13"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.624",
-    "react": "^16.8.0 || ^17.0.0",
-    "react-dom": "^16.8.0 || ^17.0.0"
+    "react": "^17.0.0 || ^18.0.0",
+    "@types/react": "^18.2.12",
+    "@teambit/legacy": "1.0.624"
   },
   "license": "Apache-2.0",
   "optionalDependencies": {},
@@ -69,7 +65,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=12.22.0"
+    "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
@@ -78,12 +74,9 @@
   "keywords": [
     "bit",
     "bit-aspect",
+    "bit-core-aspect",
     "components",
     "collaboration",
-    "web",
-    "react",
-    "react-components",
-    "angular",
-    "angular-components"
+    "web"
   ]
 }

package/tester-env.ts

@@ -0,0 +1,6 @@
+import { EnvHandler } from '@teambit/envs';
+import { Tester } from './tester';
+
+export interface TesterEnv {
+  tester(): EnvHandler<Tester>;
+}

package/tester.aspect.ts

@@ -0,0 +1,7 @@
+import { Aspect } from '@teambit/harmony';
+
+export const TesterAspect = Aspect.create({
+  id: 'teambit.defender/tester',
+});
+
+export default TesterAspect;

package/tester.graphql.ts

@@ -0,0 +1,80 @@
+import { GraphqlMain, Schema } from '@teambit/graphql';
+import { ComponentFactory } from '@teambit/component';
+import { withFilter } from 'graphql-subscriptions';
+import { ComponentID } from '@teambit/component-id';
+import gql from 'graphql-tag';
+
+import { TesterMain } from './tester.main.runtime';
+import { OnTestsChanged } from './tester.service';
+
+export function testerSchema(tester: TesterMain, graphql: GraphqlMain): Schema {
+  return {
+    typeDefs: gql`
+      extend type ComponentHost {
+        getTests(id: String!): Tests
+      }
+
+      type Subscription {
+        testsChanged(id: String!): Tests
+      }
+
+      type Tests {
+        loading: Boolean!
+        testsResults: TestsResults
+      }
+
+      type TestsChanged {
+        testsResults: TestsResults
+      }
+
+      type TestsResults {
+        testFiles: [TestFiles]
+        success: Boolean
+        start: Int
+      }
+
+      type TestFiles {
+        file: String
+        tests: [Tests]
+        pass: Int
+        failed: Int
+        pending: Int
+        duration: Int
+        slow: Boolean
+        errorStr: String
+      }
+
+      type Tests {
+        ancestor: [String]
+        name: String
+        duration: String
+        status: String
+        error: String
+      }
+    `,
+    resolvers: {
+      Subscription: {
+        testsChanged: {
+          subscribe: withFilter(
+            () => graphql.pubsub.asyncIterator(OnTestsChanged),
+            (payload, variables) => {
+              return payload.testsChanged.id === variables.id;
+            }
+          ),
+        },
+      },
+
+      ComponentHost: {
+        getTests: async (host: ComponentFactory, { id }: { id: string }) => {
+          const componentId = await host.resolveComponentId(id);
+          const idHasVersion = ComponentID.fromString(id).hasVersion();
+          const component = await host.get(componentId);
+          if (!component) return null;
+          const testsResults = await tester.getTestsResults(component, idHasVersion);
+          if (!testsResults) return null;
+          return testsResults;
+        },
+      },
+    },
+  };
+}

package/tester.main.runtime.ts

@@ -0,0 +1,268 @@
+import fs from 'fs-extra';
+import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
+import { Component, IComponent } 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(
+    private patterns: string[],
+    /**
+     * 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: IComponent,
+    idHasVersion = true
+  ): Promise<{ testsResults?: TestsResult; loading: boolean } | undefined> {
+    const entry = component.get(TesterAspect.id);
+    const isModified = !idHasVersion && (await component.isModified());
+    const data = this.builder.getDataByAspect(component, TesterAspect.id) as { tests: TestsResult };
+    if ((entry || data) && !isModified) {
+      return { testsResults: data?.tests || entry?.data.tests, loading: false };
+    }
+    return this.getTestsResultsFromState(component);
+  }
+
+  private getTestsResultsFromState(component: IComponent) {
+    const tests = this._testsResults[component.id.toString()];
+    return { testsResults: tests?.results, loading: tests?.loading || false };
+  }
+
+  /**
+   * Get the tests patterns from the config. (used as default patterns in case the env does not provide them via getTestsDevPatterns)
+   * @returns
+   */
+  getPatterns() {
+    return this.patterns;
+  }
+
+  getComponentDevPatterns(component: Component) {
+    const env = this.envs.calculateEnv(component, { skipWarnings: !!this.workspace?.inInstallContext }).env;
+    const componentPatterns: string[] = env.getTestsDevPatterns
+      ? env.getTestsDevPatterns(component)
+      : this.getPatterns();
+    return { name: 'tests', pattern: componentPatterns };
+  }
+
+  getDevPatternToRegister() {
+    return this.getComponentDevPatterns.bind(this);
+  }
+
+  /**
+   * 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: false,
+  };
+
+  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, logger, graphql.pubsub, devFiles);
+    envs.registerService(testerService);
+    const tester = new TesterMain(
+      config.patterns,
+      graphql,
+      envs,
+      workspace,
+      testerService,
+      new TesterTask(TesterAspect.id, devFiles),
+      devFiles,
+      builder
+    );
+    devFiles.registerDevPattern(tester.getDevPatternToRegister());
+
+    if (workspace) {
+      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.task.ts

@@ -0,0 +1,116 @@
+import { BuildContext, BuiltTaskResult, BuildTask, CAPSULE_ARTIFACTS_DIR } 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';
+
+/**
+ * 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 components = context.capsuleNetwork.originalSeedersCapsules.getAllComponents();
+    const tester: Tester = context.env.getTester();
+    const componentsSpecFiles = ComponentMap.as(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 patternsWithCapsule = ComponentMap.as(components, (component) => {
+      const componentSpecFiles = componentsSpecFiles.get(component);
+      if (!componentSpecFiles) throw new Error('capsule not found');
+      const [, specs] = componentSpecFiles;
+      const capsule = context.capsuleNetwork.graphCapsules.getCapsule(component.id);
+      if (!capsule) throw new Error('capsule not found');
+      const compiler: Compiler = context.env.getCompiler();
+      if (!compiler) {
+        throw new Error(`compiler not found for ${component.id.toString()}`);
+      }
+      // @ts-ignore. not sure why ts complain that compiler might be undefined, when we check it above.
+      const distFolder = compiler.getDistDir() || compiler.distDir;
+      return {
+        componentDir: join(capsule.path, distFolder),
+        paths: specs.map((specFile) => {
+          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 specFilesWithCapsule = ComponentMap.as(components, (component) => {
+      const patternEntry = patternsWithCapsule.get(component);
+      // @ts-ignore
+      const [, val] = patternEntry;
+      return val.paths;
+    });
+
+    const testerContext = Object.assign(context, {
+      release: true,
+      specFiles: specFilesWithCapsule,
+      rootPath: context.capsuleNetwork.capsulesRootDir,
+      patterns: patternsWithCapsule,
+    });
+
+    // 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.outputFile(join(capsule.path, getJUnitArtifactPath()), junit);
+      })
+    );
+
+    return {
+      artifacts: getArtifactDef(), // @ts-ignore
+      componentsResults: testsResults.components.map((componentTests) => {
+        const componentErrors = componentTests.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,
+        };
+      }),
+    };
+  }
+}
+
+export function getJUnitArtifactPath() {
+  return join(CAPSULE_ARTIFACTS_DIR, '__bit_junit.xml');
+}
+
+export function getArtifactDef() {
+  return [
+    {
+      name: 'junit',
+      globPatterns: [getJUnitArtifactPath()],
+      rootDir: CAPSULE_ARTIFACTS_DIR,
+    },
+  ];
+}