@featurevisor/core 1.31.0 → 1.32.0

package/src/site/generateSiteSearchIndex.ts

@@ -23,6 +23,10 @@ export async function generateSiteSearchIndex(
 
   const result: SearchIndex = {
     links: undefined,
+    projectConfig: {
+      tags: projectConfig.tags,
+      environments: projectConfig.environments,
+    },
     entities: {
       attributes: [],
       segments: [],
@@ -115,10 +119,52 @@ export async function generateSiteSearchIndex(
       });
     }
 
-    Object.keys(parsed.environments).forEach((environmentKey) => {
-      const env = parsed.environments[environmentKey];
+    // with environments
+    if (parsed.environments) {
+      Object.keys(parsed.environments).forEach((environmentKey) => {
+        const env = parsed.environments[environmentKey];
+
+        env.rules.forEach((rule) => {
+          if (rule.segments && rule.segments !== "*") {
+            extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
+              if (!segmentsUsedInFeatures[segmentKey]) {
+                segmentsUsedInFeatures[segmentKey] = new Set();
+              }
+
+              segmentsUsedInFeatures[segmentKey].add(entityName);
+            });
+          }
+        });
+
+        if (env.force) {
+          env.force.forEach((force) => {
+            if (force.segments && force.segments !== "*") {
+              extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+                if (!segmentsUsedInFeatures[segmentKey]) {
+                  segmentsUsedInFeatures[segmentKey] = new Set();
+                }
 
-      env.rules.forEach((rule) => {
+                segmentsUsedInFeatures[segmentKey].add(entityName);
+              });
+            }
+
+            if (force.conditions) {
+              extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+                if (!attributesUsedInFeatures[attributeKey]) {
+                  attributesUsedInFeatures[attributeKey] = new Set();
+                }
+
+                attributesUsedInFeatures[attributeKey].add(entityName);
+              });
+            }
+          });
+        }
+      });
+    }
+
+    // no environments
+    if (parsed.rules) {
+      parsed.rules.forEach((rule) => {
         if (rule.segments && rule.segments !== "*") {
           extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
             if (!segmentsUsedInFeatures[segmentKey]) {
@@ -129,32 +175,33 @@ export async function generateSiteSearchIndex(
           });
         }
       });
+    }
 
-      if (env.force) {
-        env.force.forEach((force) => {
-          if (force.segments && force.segments !== "*") {
-            extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
-              if (!segmentsUsedInFeatures[segmentKey]) {
-                segmentsUsedInFeatures[segmentKey] = new Set();
-              }
+    if (parsed.force) {
+      parsed.force.forEach((force) => {
+        if (force.segments && force.segments !== "*") {
+          extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+            if (!segmentsUsedInFeatures[segmentKey]) {
+              segmentsUsedInFeatures[segmentKey] = new Set();
+            }
 
-              segmentsUsedInFeatures[segmentKey].add(entityName);
-            });
-          }
+            segmentsUsedInFeatures[segmentKey].add(entityName);
+          });
+        }
 
-          if (force.conditions) {
-            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
-              if (!attributesUsedInFeatures[attributeKey]) {
-                attributesUsedInFeatures[attributeKey] = new Set();
-              }
+        if (force.conditions) {
+          extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+            if (!attributesUsedInFeatures[attributeKey]) {
+              attributesUsedInFeatures[attributeKey] = new Set();
+            }
 
-              attributesUsedInFeatures[attributeKey].add(entityName);
-            });
-          }
-        });
-      }
-    });
+            attributesUsedInFeatures[attributeKey].add(entityName);
+          });
+        }
+      });
+    }
 
+    // push
     result.entities.features.push({
       ...parsed,
       key: entityName,

package/src/tester/matrix.ts

@@ -105,7 +105,7 @@ export function getFeatureAssertionsFromMatrix(
 ): FeatureAssertion[] {
   if (!assertionWithMatrix.matrix) {
     const assertion = { ...assertionWithMatrix };
-    assertion.description = `Assertion #${aIndex + 1}: (${assertion.environment}) ${
+    assertion.description = `Assertion #${aIndex + 1}:${assertion.environment ? ` (${assertion.environment})` : ""} ${
       assertion.description || `at ${assertion.at}%`
     }`;
 
@@ -118,7 +118,7 @@ export function getFeatureAssertionsFromMatrix(
   for (let cIndex = 0; cIndex < combinations.length; cIndex++) {
     const combination = combinations[cIndex];
     const assertion = applyCombinationToFeatureAssertion(combination, assertionWithMatrix);
-    assertion.description = `Assertion #${aIndex + 1}: (${assertion.environment}) ${
+    assertion.description = `Assertion #${aIndex + 1}:${assertion.environment ? ` (${assertion.environment})` : ""} ${
       assertion.description || `at ${assertion.at}%`
     }`;
 

package/src/tester/testFeature.ts

@@ -13,6 +13,7 @@ import { ProjectConfig } from "../config";
 import { checkIfArraysAreEqual } from "./checkIfArraysAreEqual";
 import { checkIfObjectsAreEqual } from "./checkIfObjectsAreEqual";
 import { getFeatureAssertionsFromMatrix } from "./matrix";
+import type { DatafileContentByEnvironment } from "./testProject";
 
 export async function testFeature(
   datasource: Datasource,
@@ -20,7 +21,7 @@ export async function testFeature(
   test: TestFeature,
   options: { verbose?: boolean; showDatafile?: boolean } = {},
   patterns,
-  datafileContentByEnvironment: { [environment: string]: DatafileContent } = {},
+  datafileContentByEnvironment: DatafileContentByEnvironment,
 ): Promise<TestResult> {
   const testStartTime = Date.now();
   const featureKey = test.feature;
@@ -54,7 +55,7 @@ export async function testFeature(
         continue;
       }
 
-      const datafileContent = datafileContentByEnvironment[assertion.environment];
+      const datafileContent = datafileContentByEnvironment.get(assertion.environment || false);
 
       if (options.showDatafile) {
         console.log("");

package/src/tester/testProject.ts

@@ -36,9 +36,7 @@ export interface ExecutionResult {
   };
 }
 
-export interface DatafileContentByEnvironment {
-  [environment: string]: DatafileContent;
-}
+export type DatafileContentByEnvironment = Map<string | false, DatafileContent>;
 
 export async function executeTest(
   testFile: string,
@@ -151,23 +149,44 @@ export async function testProject(
   let passedAssertionsCount = 0;
   let failedAssertionsCount = 0;
 
-  const datafileContentByEnvironment: DatafileContentByEnvironment = {};
+  const datafileContentByEnvironment: DatafileContentByEnvironment = new Map();
+
+  // 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,
+      );
+
+      datafileContentByEnvironment.set(environment, datafileContent);
+    }
+  }
 
-  for (const environment of projectConfig.environments) {
-    const existingState = await datasource.readState(environment);
+  // 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: environment,
+        environment: false,
         inflate: options.inflate,
       },
       existingState,
     );
 
-    datafileContentByEnvironment[environment] = datafileContent;
+    datafileContentByEnvironment.set(false, datafileContent);
   }
 
   for (const testFile of testFiles) {