@featurevisor/core 2.27.0 → 3.0.1

package/src/tester/testProject.ts

@@ -9,10 +9,11 @@ import { Dependencies } from "../dependencies";
 import { prettyDuration } from "./prettyDuration";
 import { printTestResult } from "./printTestResult";
 
-import { buildDatafile, buildScopedDatafile } from "../builder";
-import { SCHEMA_VERSION } from "../config";
+import { buildDatafile, buildTargetDatafile } from "../builder";
 import { Plugin } from "../cli";
 import { listEntities } from "../list";
+import { getProjectSetExecutions, printSetHeader } from "../sets";
+import { resolveTargets } from "../targeting";
 
 export interface TestProjectOptions {
   keyPattern?: string;
@@ -20,10 +21,8 @@ export interface TestProjectOptions {
   verbose?: boolean;
   showDatafile?: boolean;
   onlyFailures?: boolean;
-  schemaVersion?: string;
   inflate?: number;
-  withScopes?: boolean;
-  withTags?: boolean;
+  target?: string | string[];
 }
 
 export interface ExecutionResult {
@@ -34,9 +33,58 @@ export interface ExecutionResult {
   };
 }
 
-// the key can be either "<EnvironmentKey>" or "<EnvironmentKey>scope-<Scope>"
+// the key can be either "<EnvironmentKey>" or "<EnvironmentKey>-target-<Target>"
 export type DatafileContentByKey = Map<string | false, DatafileContent>;
 
+export function filterTestForTargets(test: Test, selectedTargetKeys?: string[]): Test | undefined {
+  if (!selectedTargetKeys || !(test as TestFeature).feature) return test;
+
+  const featureTest = test as TestFeature;
+  const assertions = featureTest.assertions.filter(
+    (assertion) => !assertion.target || selectedTargetKeys.includes(assertion.target),
+  );
+
+  return assertions.length > 0 ? { ...featureTest, assertions } : undefined;
+}
+
+async function buildTestDatafilesForEnvironment(
+  deps: Dependencies,
+  datafileContentByKey: DatafileContentByKey,
+  environment: string | false,
+  selectedTargetKeys?: string[],
+) {
+  const { projectConfig, datasource, options } = deps;
+  const existingState = await datasource.readState(environment);
+  const datafileContent = await buildDatafile(
+    projectConfig,
+    datasource,
+    {
+      revision: "include-all-features",
+      environment,
+      inflate: options.inflate,
+    },
+    existingState,
+  );
+
+  datafileContentByKey.set(environment, datafileContent as DatafileContent);
+
+  const targetKeys = selectedTargetKeys || (await datasource.listTargets());
+  for (const targetKey of targetKeys) {
+    const target = await datasource.readTarget(targetKey);
+    const targetDatafileContent = await buildTargetDatafile({
+      projectConfig,
+      datasource,
+      target,
+      environment,
+      existingState,
+      revision: "include-target-features",
+      inflate: options.inflate,
+    });
+
+    datafileContentByKey.set(`${environment}-target-${targetKey}`, targetDatafileContent);
+  }
+}
+
 export async function executeTest(
   test: Test,
   deps: Dependencies,
@@ -128,139 +176,26 @@ export async function testProject(
   let failedAssertionsCount = 0;
 
   const datafileContentByKey: DatafileContentByKey = new Map();
+  const selectedTargets = testOptions.target
+    ? await resolveTargets(datasource, testOptions.target, { defaultToAll: false })
+    : undefined;
+  const selectedTargetKeys = selectedTargets?.map((target) => target.key);
 
   // with environments
   if (Array.isArray(projectConfig.environments)) {
     for (const environment of projectConfig.environments) {
-      const existingState = await datasource.readState(environment);
-      const datafileContent = await buildDatafile(
-        projectConfig,
-        datasource,
-        {
-          schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-          revision: "include-all-features",
-          environment: environment,
-          inflate: options.inflate,
-        },
-        existingState,
+      await buildTestDatafilesForEnvironment(
+        deps,
+        datafileContentByKey,
+        environment,
+        selectedTargetKeys,
       );
-
-      datafileContentByKey.set(environment, datafileContent as DatafileContent);
-
-      // by scope
-      if (projectConfig.scopes && options.withScopes) {
-        for (const scope of projectConfig.scopes) {
-          const existingState = await datasource.readState(environment);
-          const datafileContent = await buildDatafile(
-            projectConfig,
-            datasource,
-            {
-              schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-              revision: "include-scoped-features",
-              environment: environment,
-              inflate: options.inflate,
-              tag: scope.tag,
-              tags: scope.tags,
-            },
-            existingState,
-          );
-
-          const scopedDatafileContent = buildScopedDatafile(
-            datafileContent as DatafileContent,
-            scope.context,
-          );
-
-          datafileContentByKey.set(`${environment}-scope-${scope.name}`, scopedDatafileContent);
-        }
-      }
-
-      // by tag
-      if (projectConfig.tags && options.withTags) {
-        for (const tag of projectConfig.tags) {
-          const existingState = await datasource.readState(environment);
-          const datafileContent = (await buildDatafile(
-            projectConfig,
-            datasource,
-            {
-              schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-              revision: "include-tagged-features",
-              environment: environment,
-              inflate: options.inflate,
-              tag: tag,
-            },
-            existingState,
-          )) as DatafileContent;
-
-          datafileContentByKey.set(`${environment}-tag-${tag}`, datafileContent);
-        }
-      }
     }
   }
 
   // no environments
-  if (projectConfig.environments === false) {
-    const existingState = await datasource.readState(false);
-    const datafileContent = await buildDatafile(
-      projectConfig,
-      datasource,
-      {
-        schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-        revision: "include-all-features",
-        environment: false,
-        inflate: options.inflate,
-      },
-      existingState,
-    );
-
-    datafileContentByKey.set(false, datafileContent as DatafileContent);
-
-    // by scope
-    if (projectConfig.scopes && options.withScopes) {
-      for (const scope of projectConfig.scopes) {
-        const existingState = await datasource.readState(false);
-        const datafileContent = await buildDatafile(
-          projectConfig,
-          datasource,
-          {
-            schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-            revision: "include-scoped-features",
-            environment: false,
-            inflate: options.inflate,
-            tag: scope.tag,
-            tags: scope.tags,
-          },
-          existingState,
-        );
-
-        const scopedDatafileContent = buildScopedDatafile(
-          datafileContent as DatafileContent,
-          scope.context,
-        );
-
-        datafileContentByKey.set(`scope-${scope.name}`, scopedDatafileContent);
-      }
-    }
-
-    // by tag
-    if (projectConfig.tags && options.withTags) {
-      for (const tag of projectConfig.tags) {
-        const existingState = await datasource.readState(false);
-        const datafileContent = (await buildDatafile(
-          projectConfig,
-          datasource,
-          {
-            schemaVersion: options.schemaVersion || SCHEMA_VERSION,
-            revision: "include-tagged-features",
-            environment: false,
-            inflate: options.inflate,
-            tag: tag,
-          },
-          existingState,
-        )) as DatafileContent;
-
-        datafileContentByKey.set(`tag-${tag}`, datafileContent);
-      }
-    }
+  if (!Array.isArray(projectConfig.environments)) {
+    await buildTestDatafilesForEnvironment(deps, datafileContentByKey, false, selectedTargetKeys);
   }
 
   const tests = await listEntities<Test>(
@@ -276,7 +211,10 @@ export async function testProject(
     "test",
   );
 
-  for (const test of tests) {
+  for (const originalTest of tests) {
+    const test = filterTestForTargets(originalTest, selectedTargetKeys);
+    if (!test) continue;
+
     const executionResult = await executeTest(test, deps, options, datafileContentByKey);
 
     if (!executionResult) {
@@ -319,15 +257,26 @@ export async function testProject(
 export const testPlugin: Plugin = {
   command: "test",
   handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
-    const hasError = await testProject(
-      {
-        rootDirectoryPath,
-        projectConfig,
-        datasource,
-        options: parsed,
-      },
-      parsed as TestProjectOptions,
-    );
+    const executions = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+    let hasError = false;
+
+    for (const execution of executions) {
+      printSetHeader(projectConfig, execution.set);
+
+      const executionHasError = await testProject(
+        {
+          rootDirectoryPath,
+          projectConfig: execution.projectConfig,
+          datasource: execution.datasource,
+          options: parsed,
+        },
+        parsed as TestProjectOptions,
+      );
+
+      if (executionHasError) {
+        hasError = true;
+      }
+    }
 
     if (hasError) {
       return false;

package/src/tester/testSegment.ts

@@ -5,15 +5,17 @@ import type {
   TestResultAssertion,
   TestResultAssertionError,
 } from "@featurevisor/types";
-import { createLogger, DatafileReader, LogLevel } from "@featurevisor/sdk";
+import { allConditionsAreMatched } from "@featurevisor/sdk";
 
 import { Datasource } from "../datasource";
 
 export async function testSegment(
   datasource: Datasource,
   test: TestSegment,
-  options: { verbose?: boolean; quiet?: boolean } = {},
+  _options: { verbose?: boolean; quiet?: boolean } = {},
 ): Promise<TestResult> {
+  void _options;
+
   const testStartTime = Date.now();
   const segmentKey = test.segment;
 
@@ -37,27 +39,8 @@ export async function testSegment(
     return testResult;
   }
 
-  let logLevel: LogLevel = "warn";
-  if (options.verbose) {
-    logLevel = "debug";
-  } else if (options.quiet) {
-    logLevel = "fatal";
-  }
-
   const parsedSegment = await datasource.readSegment(segmentKey);
   const conditions = parsedSegment.conditions as Condition | Condition[];
-  const logger = createLogger({
-    level: logLevel,
-  });
-  const datafileReader = new DatafileReader({
-    datafile: {
-      schemaVersion: "2",
-      revision: "tester",
-      segments: {},
-      features: {},
-    },
-    logger,
-  });
 
   test.assertions.forEach(function (assertion) {
     const assertionStartTime = Date.now();
@@ -69,7 +52,7 @@ export async function testSegment(
     };
 
     const expected = assertion.expectedToMatch;
-    const actual = datafileReader.allConditionsAreMatched(conditions, assertion.context);
+    const actual = allConditionsAreMatched(conditions, assertion.context);
     const passed = actual === expected;
 
     if (!passed) {

package/src/utils/git.ts

@@ -95,15 +95,12 @@ export function getCommit(
       type = "segment";
     } else if (isWithinDirectory(projectConfig.featuresDirectoryPath, relativeDir)) {
       type = "feature";
-    } else if (
-      projectConfig.splitByEnvironment &&
-      isWithinDirectory(projectConfig.environmentsDirectoryPath, relativeDir)
-    ) {
-      type = "feature";
     } else if (isWithinDirectory(projectConfig.groupsDirectoryPath, relativeDir)) {
       type = "group";
     } else if (isWithinDirectory(projectConfig.schemasDirectoryPath, relativeDir)) {
       type = "schema";
+    } else if (isWithinDirectory(projectConfig.targetsDirectoryPath, relativeDir)) {
+      type = "target";
     } else if (isWithinDirectory(projectConfig.testsDirectoryPath, relativeDir)) {
       type = "test";
     } else {
@@ -123,24 +120,19 @@ export function getCommit(
     let key = fileName.replace(extensionWithDot, "");
 
     if (
-      type === "feature" &&
-      projectConfig.splitByEnvironment &&
-      absolutePath.startsWith(projectConfig.environmentsDirectoryPath + path.sep)
-    ) {
-      const featureRelativePath = absolutePath
-        .replace(projectConfig.environmentsDirectoryPath + path.sep, "")
-        .split(path.sep)
-        .slice(1)
-        .join(path.sep)
-        .replace(extensionWithDot, "");
-
-      key = featureRelativePath.replace(/\\/g, "/");
-    } else if (
-      type === "feature" &&
-      absolutePath.startsWith(projectConfig.featuresDirectoryPath + path.sep)
+      (type === "feature" || type === "target") &&
+      absolutePath.startsWith(
+        (type === "feature"
+          ? projectConfig.featuresDirectoryPath
+          : projectConfig.targetsDirectoryPath) + path.sep,
+      )
     ) {
+      const entityDirectoryPath =
+        type === "feature"
+          ? projectConfig.featuresDirectoryPath
+          : projectConfig.targetsDirectoryPath;
       key = absolutePath
-        .replace(projectConfig.featuresDirectoryPath + path.sep, "")
+        .replace(entityDirectoryPath + path.sep, "")
         .replace(extensionWithDot, "")
         .replace(/\\/g, "/");
     }

package/tsconfig.cjs.json

@@ -2,8 +2,12 @@
   "extends": "../../tsconfig.cjs.json",
   "compilerOptions": {
     "target": "es2020",
+    "lib": ["es2020"],
+    "types": ["node"],
     "outDir": "./lib",
+    "rootDir": "./src",
     "skipLibCheck": true
   },
-  "include": ["./src/**/*.ts"]
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.spec.ts"]
 }

package/tsconfig.typecheck.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.cjs.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node", "jest"]
+  },
+  "exclude": []
+}