Collapsable ui

server/api/app/resolver.ts

@@ -44,4 +44,22 @@ export default class AppResolver {
 
     return "";
   }
+
+  @Mutation(returns => String)
+  openFailure(@Arg("failure") failure: string) {
+    // The following regex matches the first line of the form: \w at <some text> (<file path>)
+    // it captures <file path> and returns that in the second position of the match array
+    let re = new RegExp('^\\s+at.*?\\((.*?)\\)$', 'm');
+    let match = failure.match(re);
+    if (match && match.length === 2) {
+      const path = match[1];
+      launch(path, process.env.EDITOR || "code", (path: string, err: any) => {
+        console.log("Failed to open file in editor. You may need to install the code command to your PATH if you are using VSCode: ", err);
+      });
+    }
+    else {
+      console.log("Failed to find a path to a file to load in the failure string.");
+    }
+    return "";
+  }
 }

server/api/workspace/resolver.ts

@@ -56,6 +56,7 @@ export default class WorkspaceResolver {
       result.numPendingTests = payload.numPendingTests;
       result.testResults = payload.testResults;
       result.consoleLogs = payload.console;
+      this.results.addTestIdsToTestResults(result);
       this.results.setTestReport(payload.path, result);
       this.notifySummaryChange();
     });

server/api/workspace/test-result/test-item-result.ts

@@ -19,4 +19,7 @@ export class TestItemResult {
 
   @Field()
   duration: number;
+
+  @Field()
+  id: string;
 }

server/services/ast/idManager.ts

@@ -0,0 +1,88 @@
+// This file manages a cache of Ids. The purpose for this cache in Majestic is to 
+// maintain consistent ids for test and describe blocks that do not change name between
+// file reloads. By maintaining consistent Ids for the same blocks, we can do things in 
+// the UI like persistent open/collapse state
+//
+// How this works: Each describe block within a file and the file itself gets its own IdManager
+// The IdManager maintains the list of Ids for that block. These could be Ids of other describe
+// blocks, or they could be Ids of the tests themselves. The IdManager is also responsible for
+// handing out the ids so that it can then associate the Id with the object.
+//
+// managing the IdManagers is done with the IdManagerFactory. It keeps a cache of the IdManagers
+// and you can lookup/create an IdManager based on an Id or file path.
+//
+// How to use these classes:
+//
+// When loading in a file, call IdManagerFactory.getManagerForFile with the file's full path
+// this will return an IdManger to use for the file. Set this as the current IdManager
+//
+// when finding a describe block, cal IdManagerFactory.getManagerForBlock with the Id of the 
+// describe block, this becomes the current IdManager for everythign in the describe block
+//
+// when finding any type of block and we need an Id for it, we call currentManager.createId
+// it will return the proper Id to use for that element, either an existing one or a new one
+
+import * as nanoid from "nanoid";
+
+interface IdEntry {
+  name: string;
+  id: string;
+}
+
+export class IdManager {
+  private ids: IdEntry[]
+  constructor() {
+    this.ids = [];
+  }
+
+  public createId(name: string): string {
+    for(let e of this.ids) {
+        if (e.name === name) {
+          return e.id;
+        }
+    }
+    // name was not found in the list of Ids so create it
+    let newId = {
+      name,
+      id: nanoid()
+    };
+    this.ids.push(newId);
+    return newId.id;
+  }
+}
+
+interface FileManagerEntry {
+  filePath: string;
+  idManager: IdManager;
+}
+export class IdManagerFactory {
+  static describeManagers: {key: string};
+  static fileManagers: FileManagerEntry[];
+
+  static init() {
+    IdManagerFactory.describeManagers = {} as {key: string};
+    IdManagerFactory.fileManagers = [];
+  }
+
+  static getManagerForBlock(id: string): IdManager {
+    let existingManager = IdManagerFactory.describeManagers[id];
+    if (existingManager === undefined) {
+      existingManager = new IdManager();
+      IdManagerFactory.describeManagers[id] = existingManager;
+    }
+    return existingManager;
+  }
+  static getManagerForFile(filePath: string): IdManager {
+    for(let e of IdManagerFactory.fileManagers) {
+      if (e.filePath === filePath) return e.idManager;
+    }
+    let newManager = {
+      filePath,
+      idManager: new IdManager()
+    };
+    IdManagerFactory.fileManagers.push(newManager);
+    return newManager.idManager;
+  }
+}
+
+IdManagerFactory.init();

server/services/ast/inspector.ts

@@ -1,8 +1,8 @@
 import traverse from "@babel/traverse";
-import * as nanoid from "nanoid";
 import { parse } from "./parser";
 import { readFile } from "fs";
 import { TestItem, TestItemType } from "../../api/workspace/test-item";
+import {IdManagerFactory, IdManager} from './idManager';
 
 export async function inspect(path: string): Promise<TestItem[]> {
   return new Promise((resolve, reject) => {
@@ -24,11 +24,12 @@ export async function inspect(path: string): Promise<TestItem[]> {
         }
 
         const result: TestItem[] = [];
+        const fileIdManager = IdManagerFactory.getManagerForFile(path);
 
         traverse(ast, {
           CallExpression(path: any) {
             if (path.scope.block.type === "Program") {
-              findItems(path, result);
+              findItems(path, result, fileIdManager);
             }
           }
         });
@@ -46,14 +47,19 @@ function getTemplateLiteralName(path: any) {
         `\`\$\{${
           path.node.arguments[0].expressions[currentExpressionIndex++].name
         }\}\``
-      );
+        );
     } else {
       return finalText.concat(q.value.raw);
     }
   }, "");
 }
+function getNodeName(path: any): string {
+  return (path.node.arguments[0].type === "TemplateLiteral")
+    ? getTemplateLiteralName(path)
+    : path.node.arguments[0].value;
+}
 
-function findItems(path: any, result: TestItem[], parentId?: any) {
+function findItems(path: any, result: TestItem[], idManager: IdManager, parentId?: any) {
   let type: string;
   let only: boolean = false;
   if (path.node.callee.name === "fdescribe") {
@@ -80,66 +86,38 @@ function findItems(path: any, result: TestItem[], parentId?: any) {
   }
 
   if (type === "describe") {
-    let describe: any;
-    if (path.node.arguments[0].type === "TemplateLiteral") {
-      describe = {
-        id: nanoid(),
-        type: "describe" as TestItemType,
-        name: getTemplateLiteralName(path),
-        only,
-        parent: parentId
-      };
-    } else {
-      describe = {
-        id: nanoid(),
+    const nodeName = getNodeName(path);
+    let describe = {
+        id: idManager.createId(nodeName),
         type: "describe" as TestItemType,
-        name: path.node.arguments[0].value,
+        name: nodeName,
         only,
         parent: parentId
       };
-    }
     result.push(describe);
     path.skip();
     path.traverse({
       CallExpression(itPath: any) {
-        findItems(itPath, result, describe.id);
+        findItems(itPath, result, IdManagerFactory.getManagerForBlock(describe.id), describe.id);
       }
     });
   } else if (type === "it") {
-    if (path.node.arguments[0].type === "TemplateLiteral") {
-      result.push({
-        id: nanoid(),
-        type: "it",
-        name: getTemplateLiteralName(path),
-        only,
-        parent: parentId
-      });
-    } else {
-      result.push({
-        id: nanoid(),
-        type: "it",
-        name: path.node.arguments[0].value,
-        only,
-        parent: parentId
-      });
-    }
+    const nodeName = getNodeName(path);
+    result.push({
+      id: idManager.createId(nodeName),
+      type: "it",
+      name: nodeName,
+      only,
+      parent: parentId
+    });
   } else if (type === "todo") {
-    if (path.node.arguments[0].type === "TemplateLiteral") {
-      result.push({
-        id: nanoid(),
-        type: "todo",
-        name: getTemplateLiteralName(path),
-        only,
-        parent: parentId
-      });
-    } else {
-      result.push({
-        id: nanoid(),
-        type: "todo",
-        name: path.node.arguments[0].value,
-        only,
-        parent: parentId
-      });
-    }
+    const nodeName = getNodeName(path);
+    result.push({
+      id: idManager.createId(nodeName),
+      type: "todo",
+      name: nodeName,
+      only,
+      parent: parentId
+    });
   }
 }

server/services/results.ts

@@ -5,6 +5,8 @@ import { join } from "path";
 import { MajesticConfig } from "./types";
 import { spawnSync } from "child_process";
 import { createLogger } from "../logger";
+import { IdManager, IdManagerFactory } from "./ast/idManager";
+import { TestFileResult } from "../api/workspace/test-result/file-result";
 
 const log = createLogger("Results");
 
@@ -83,6 +85,23 @@ export default class Results {
     }
   }
 
+  public addTestIdsToTestResults(results: TestFileResult) {
+    const fileIds = IdManagerFactory.getManagerForFile(results.path);
+    let currentParentName: string =  '';
+    let currentParentIds: IdManager = undefined as any;
+    for(const r of results.testResults) {
+      if (r.ancestorTitles[r.ancestorTitles.length-1] !== currentParentName) {
+        currentParentIds = fileIds;
+        for(const p of r.ancestorTitles) {
+          const parentId = currentParentIds.createId(p);
+          currentParentIds = IdManagerFactory.getManagerForBlock(parentId);
+          currentParentName = p;
+        }
+      }
+      r.id = currentParentIds.createId(r.title);
+    }
+  }
+
   public getResult(path: string) {
     return this.results[path] || null;
   }

ui/test-file/collapseStore.ts

@@ -0,0 +1,24 @@
+// This static class keeps track of the collapse state of every describe block that is shown in the UI.
+// It starts empty and grows with each describe block that the user collapses or expands. 
+// If a describe block has never been collapsed it does not have an entry in the strucure and isCollapsed will
+// always return false. This allows us to get away with an empty structure to start with.
+// If we ever add Redux to the product, then this can move into Redux
+
+export class CollapseStore {
+  static store: {[key: string]: boolean}
+
+  static init() {
+    CollapseStore.store = {} as {[key: string]: boolean};
+  }
+
+  static isCollapsed(id: string): boolean {
+    return CollapseStore.store[id] === true;
+  }
+
+  static setState(id: string, state: boolean) {
+    CollapseStore.store[id] = state;
+  }
+}
+
+// Create the global instance of the store.
+CollapseStore.init();

ui/test-file/open-failure.gql

@@ -0,0 +1,3 @@
+mutation OpenFailure($failure: String!) {
+  openFailure(failure: $failure)
+}

ui/test-file/result.gql

@@ -11,6 +11,7 @@ query Results($path: String!) {
       failureMessages
       ancestorTitles
       duration
+      id
     }
     consoleLogs {
       message

ui/test-file/subscription.gql

@@ -11,6 +11,7 @@ subscription Results($path: String!) {
       failureMessages
       ancestorTitles
       duration
+      id
     }
     consoleLogs {
       message