@usebruno/filestore 0.11.0 → 0.13.0

package/src/formats/yml/grpc-round-trip.spec.ts

@@ -0,0 +1,110 @@
+import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
+import stringifyItem from './stringifyItem';
+import parseItem from './parseItem';
+
+const parseGrpcItem = (yml: string) => parseItem(yml).request as BrunoGrpcRequest;
+
+const grpcItem = (script: Record<string, string | null>, tests: string | null = null) => ({
+  uid: 'i1',
+  type: 'grpc-request',
+  name: 'say hello',
+  seq: 1,
+  request: {
+    url: 'grpc://localhost:50051',
+    method: '/hello.Greeter/SayHello',
+    methodType: 'unary',
+    headers: [],
+    auth: { mode: 'none' },
+    body: { mode: 'grpc', grpc: [{ name: 'message 1', content: '{}' }] },
+    script,
+    tests,
+    vars: { req: [], res: [] },
+    assertions: []
+  }
+}) as any;
+
+describe('grpc lifecycle hooks — stringify/parse round trip', () => {
+  it('writes every hook as a grpc-prefixed script type and reads them back', () => {
+    const yml = stringifyItem(grpcItem({
+      beforeCallStart: 'bru.setVar("a", 1);',
+      afterCallEnd: 'bru.setVar("b", 2);',
+      beforeMessageSend: 'bru.setVar("c", 3);',
+      afterMessageReceive: 'bru.setVar("d", 4);'
+    }));
+
+    expect(yml).toContain('grpc:before-call-start');
+    expect(yml).toContain('grpc:after-call-end');
+    expect(yml).toContain('grpc:before-message-send');
+    expect(yml).toContain('grpc:after-message-receive');
+
+    const { script } = parseGrpcItem(yml);
+    expect(script!.beforeCallStart).toBe('bru.setVar("a", 1);');
+    expect(script!.afterCallEnd).toBe('bru.setVar("b", 2);');
+    expect(script!.beforeMessageSend).toBe('bru.setVar("c", 3);');
+    expect(script!.afterMessageReceive).toBe('bru.setVar("d", 4);');
+  });
+
+  it('preserves a multiline hook verbatim', () => {
+    const beforeCallStart = ['const now = 1;', 'if (now) {', '  bru.setVar("startedAt", now);', '}'].join('\n');
+
+    const yml = stringifyItem(grpcItem({ beforeCallStart, afterCallEnd: null }));
+    const { script } = parseGrpcItem(yml);
+
+    expect(script!.beforeCallStart).toBe(beforeCallStart);
+  });
+
+  it('round-trips one hook without inventing the others', () => {
+    const yml = stringifyItem(grpcItem({ beforeCallStart: null, afterCallEnd: 'bru.setVar("b", 2);' }));
+
+    expect(yml).not.toContain('grpc:before-call-start');
+    expect(yml).not.toContain('grpc:before-message-send');
+    expect(yml).not.toContain('grpc:after-message-receive');
+
+    const { script } = parseGrpcItem(yml);
+    expect(script!.beforeCallStart).toBeNull();
+    expect(script!.afterCallEnd).toBe('bru.setVar("b", 2);');
+    expect(script!.beforeMessageSend).toBeNull();
+    expect(script!.afterMessageReceive).toBeNull();
+  });
+
+  it('writes no scripts block when every hook is empty', () => {
+    const yml = stringifyItem(grpcItem({
+      beforeCallStart: null,
+      afterCallEnd: '   ',
+      beforeMessageSend: null,
+      afterMessageReceive: '   '
+    }));
+
+    expect(yml).not.toContain('scripts:');
+
+    const { script } = parseGrpcItem(yml);
+    expect(script!.beforeCallStart).toBeNull();
+    expect(script!.afterCallEnd).toBeNull();
+    expect(script!.beforeMessageSend).toBeNull();
+    expect(script!.afterMessageReceive).toBeNull();
+  });
+
+  it('keeps tests alongside the hooks', () => {
+    const yml = stringifyItem(
+      grpcItem({ beforeCallStart: 'bru.setVar("a", 1);', afterCallEnd: null }, 'test("ok", () => {});')
+    );
+
+    const request = parseGrpcItem(yml);
+    expect(request.script!.beforeCallStart).toBe('bru.setVar("a", 1);');
+    expect(request.tests).toBe('test("ok", () => {});');
+  });
+
+  it('survives a second round trip unchanged', () => {
+    const item = grpcItem({
+      beforeCallStart: 'bru.setVar("a", 1);',
+      afterCallEnd: 'bru.setVar("b", 2);',
+      beforeMessageSend: 'bru.setVar("c", 3);',
+      afterMessageReceive: 'bru.setVar("d", 4);'
+    });
+
+    const firstPass = stringifyItem(item);
+    const secondPass = stringifyItem(parseItem(firstPass));
+
+    expect(secondPass).toBe(firstPass);
+  });
+});

package/src/formats/yml/index.ts

@@ -2,19 +2,23 @@ import parseYmlItem from './parseItem';
 import parseYmlFolder from './parseFolder';
 import parseYmlCollection from './parseCollection';
 import parseYmlEnvironment from './parseEnvironment';
+import parseYmlMockServer from './parseMockServer';
 
 import stringifyYmlItem from './stringifyItem';
 import stringifyYmlFolder from './stringifyFolder';
 import stringifyYmlCollection from './stringifyCollection';
 import stringifyYmlEnvironment from './stringifyEnvironment';
+import stringifyYmlMockServer from './stringifyMockServer';
 
 export {
   parseYmlItem,
   parseYmlFolder,
   parseYmlCollection,
   parseYmlEnvironment,
+  parseYmlMockServer,
   stringifyYmlItem,
   stringifyYmlFolder,
   stringifyYmlCollection,
-  stringifyYmlEnvironment
+  stringifyYmlEnvironment,
+  stringifyYmlMockServer
 };

package/src/formats/yml/items/parseGraphQLRequest.ts

@@ -9,6 +9,8 @@ import { toBrunoPostResponseVariables } from '../common/actions';
 import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { uuid, ensureString } from '../../../utils';
+import { utils } from '@usebruno/common';
+const { toBool, toMaxRedirects } = utils;
 
 const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -110,11 +112,7 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
   if (ocRequest.settings) {
     const settings: BrunoHttpItemSettings = {};
 
-    if (typeof ocRequest.settings.encodeUrl === 'boolean') {
-      settings.encodeUrl = ocRequest.settings.encodeUrl;
-    } else {
-      settings.encodeUrl = true;
-    }
+    settings.encodeUrl = toBool(ocRequest.settings.encodeUrl, true);
 
     if (typeof ocRequest.settings.timeout === 'number') {
       settings.timeout = ocRequest.settings.timeout;
@@ -124,17 +122,9 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
       settings.timeout = 0;
     }
 
-    if (typeof ocRequest.settings.followRedirects === 'boolean') {
-      settings.followRedirects = ocRequest.settings.followRedirects;
-    } else {
-      settings.followRedirects = true;
-    }
-
-    if (typeof ocRequest.settings.maxRedirects === 'number') {
-      settings.maxRedirects = ocRequest.settings.maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
-    }
+    settings.followRedirects = toBool(ocRequest.settings.followRedirects, true);
+    settings.maxRedirects = toMaxRedirects(ocRequest.settings.maxRedirects);
+    settings.forwardAuthorizationHeader = toBool(ocRequest.settings.forwardAuthorizationHeader, true);
 
     brunoItem.settings = settings;
   }

package/src/formats/yml/items/parseGrpcRequest.ts

@@ -51,8 +51,10 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
       grpc: []
     },
     script: {
-      req: null,
-      res: null
+      beforeCallStart: null,
+      beforeMessageSend: null,
+      afterMessageReceive: null,
+      afterCallEnd: null
     },
     vars: {
       req: [],
@@ -80,11 +82,17 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
   // scripts
   const scripts = toBrunoScripts(runtime?.scripts);
   if (scripts?.script && brunoRequest.script) {
-    if (scripts.script.req) {
-      brunoRequest.script.req = scripts.script.req;
+    if (scripts.script.beforeCallStart) {
+      brunoRequest.script.beforeCallStart = scripts.script.beforeCallStart;
     }
-    if (scripts.script.res) {
-      brunoRequest.script.res = scripts.script.res;
+    if (scripts.script.beforeMessageSend) {
+      brunoRequest.script.beforeMessageSend = scripts.script.beforeMessageSend;
+    }
+    if (scripts.script.afterMessageReceive) {
+      brunoRequest.script.afterMessageReceive = scripts.script.afterMessageReceive;
+    }
+    if (scripts.script.afterCallEnd) {
+      brunoRequest.script.afterCallEnd = scripts.script.afterCallEnd;
     }
   }
   if (scripts?.tests) {

package/src/formats/yml/items/parseHttpRequest.ts

@@ -10,7 +10,10 @@ import { toBrunoPostResponseVariables } from '../common/actions';
 import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { toBrunoApp } from '../common/app';
+import { normalizeOmitHeaders } from '../common/omit-headers';
 import { uuid, ensureString } from '../../../utils';
+import { utils } from '@usebruno/common';
+const { toBool, toMaxRedirects } = utils;
 
 const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -113,11 +116,7 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
   if (ocRequest.settings) {
     const settings: BrunoHttpItemSettings = {};
 
-    if (typeof ocRequest.settings.encodeUrl === 'boolean') {
-      settings.encodeUrl = ocRequest.settings.encodeUrl;
-    } else {
-      settings.encodeUrl = true;
-    }
+    settings.encodeUrl = toBool(ocRequest.settings.encodeUrl, true);
 
     if (typeof ocRequest.settings.timeout === 'number') {
       settings.timeout = ocRequest.settings.timeout;
@@ -127,16 +126,13 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
       settings.timeout = 0;
     }
 
-    if (typeof ocRequest.settings.followRedirects === 'boolean') {
-      settings.followRedirects = ocRequest.settings.followRedirects;
-    } else {
-      settings.followRedirects = true;
-    }
+    settings.followRedirects = toBool(ocRequest.settings.followRedirects, true);
+    settings.maxRedirects = toMaxRedirects(ocRequest.settings.maxRedirects);
+    settings.forwardAuthorizationHeader = toBool(ocRequest.settings.forwardAuthorizationHeader, true);
 
-    if (typeof ocRequest.settings.maxRedirects === 'number') {
-      settings.maxRedirects = ocRequest.settings.maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
+    const omitHeaders = normalizeOmitHeaders(ocRequest.settings.omitHeaders);
+    if (omitHeaders) {
+      settings.omitHeaders = omitHeaders;
     }
 
     brunoItem.settings = settings;

package/src/formats/yml/items/stringifyGraphQLRequest.ts

@@ -8,7 +8,7 @@ import type { Assertion } from '@opencollection/types/common/assertions';
 import type { Action } from '@opencollection/types/common/actions';
 import type { HttpRequestParam, HttpRequestHeader } from '@opencollection/types/requests/http';
 import { stringifyYml } from '../utils';
-import { isNonEmptyString, isNumber } from '../../../utils';
+import { isNonEmptyString } from '../../../utils';
 import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders } from '../common/headers';
 import { toOpenCollectionParams } from '../common/params';
@@ -16,6 +16,8 @@ import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
+import { resolveTimeoutSetting, toMaxRedirects } from '@usebruno/common/utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyGraphQLRequest = (item: BrunoItem): string => {
   try {
@@ -96,7 +98,7 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;
@@ -132,12 +134,7 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
       settings.encodeUrl = true;
     }
 
-    const timeout = httpSettings?.timeout;
-    if (isNumber(timeout)) {
-      settings.timeout = timeout;
-    } else {
-      settings.timeout = 0;
-    }
+    settings.timeout = resolveTimeoutSetting(httpSettings?.timeout);
 
     if (httpSettings?.followRedirects === true) {
       settings.followRedirects = true;
@@ -147,12 +144,9 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
       settings.followRedirects = true;
     }
 
-    const maxRedirects = httpSettings?.maxRedirects;
-    if (isNumber(maxRedirects)) {
-      settings.maxRedirects = maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
-    }
+    settings.maxRedirects = toMaxRedirects(httpSettings?.maxRedirects);
+
+    settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
 
     ocRequest.settings = settings;
 

package/src/formats/yml/items/stringifyGrpcRequest.ts

@@ -12,6 +12,7 @@ import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
+import { GRPC_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyGrpcRequest = (item: BrunoItem): string => {
   try {
@@ -103,7 +104,7 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, GRPC_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;

package/src/formats/yml/items/stringifyHttpRequest.ts

@@ -17,7 +17,10 @@ import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
-import { isNumber, isNonEmptyString } from '../../../utils';
+import { normalizeOmitHeaders } from '../common/omit-headers';
+import { isNonEmptyString } from '../../../utils';
+import { resolveTimeoutSetting, toMaxRedirects } from '@usebruno/common/utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyHttpRequest = (item: BrunoItem): string => {
   try {
@@ -84,7 +87,7 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;
@@ -120,12 +123,7 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.encodeUrl = true;
     }
 
-    const timeout = httpSettings?.timeout;
-    if (isNumber(timeout)) {
-      settings.timeout = timeout;
-    } else {
-      settings.timeout = 0;
-    }
+    settings.timeout = resolveTimeoutSetting(httpSettings?.timeout);
 
     if (httpSettings?.followRedirects === true) {
       settings.followRedirects = true;
@@ -135,11 +133,13 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.followRedirects = true;
     }
 
-    const maxRedirects = httpSettings?.maxRedirects;
-    if (isNumber(maxRedirects)) {
-      settings.maxRedirects = maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
+    settings.maxRedirects = toMaxRedirects(httpSettings?.maxRedirects);
+
+    settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
+
+    const omitHeaders = normalizeOmitHeaders(httpSettings?.omitHeaders);
+    if (omitHeaders) {
+      settings.omitHeaders = omitHeaders;
     }
 
     ocRequest.settings = settings;

package/src/formats/yml/items/stringifyWebsocketRequest.ts

@@ -11,6 +11,7 @@ import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders } from '../common/headers';
 import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionScripts } from '../common/scripts';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const stringifyWebsocketRequest = (item: BrunoItem): string => {
   try {
@@ -92,7 +93,8 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
     }
 
     // scripts
-    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest);
+    // TODO: Modify to WS scripts once WS scripts are implemented.
+    const scripts: Scripts | undefined = toOpenCollectionScripts(brunoRequest, HTTP_SCRIPT_KEYS);
     if (scripts) {
       runtime.scripts = scripts;
       hasRuntime = true;

package/src/formats/yml/mockServerTypes.ts

@@ -0,0 +1,95 @@
+import type { HttpRequestHeader, HttpResponseHeader, HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
+
+export interface MockRuleCondition {
+  target?: string;
+  key?: string;
+  operator?: string;
+  value?: string;
+}
+
+export interface MockRouteRules {
+  operator?: 'AND' | 'OR';
+  conditions?: MockRuleCondition[];
+}
+
+export interface MockRouteEntry {
+  name?: string;
+  description?: string;
+  request?: {
+    method?: string;
+    url?: string;
+    headers?: HttpRequestHeader[];
+    params?: HttpRequestParam[];
+    body?: HttpRequestBody;
+  };
+  response?: {
+    status?: number;
+    statusText?: string;
+    headers?: HttpResponseHeader[];
+    body?: {
+      type?: string;
+      data?: string;
+    };
+  };
+  rules?: MockRouteRules;
+  copiedFrom?: {
+    example?: string | null;
+    requestPath?: string | null;
+  };
+}
+
+export interface MockServerFile {
+  info?: {
+    name?: string;
+    type?: 'mock';
+  };
+  mock?: {
+    port?: number;
+    delay?: number;
+    source?: {
+      type?: 'collection' | 'spec';
+      path?: string;
+    };
+  };
+  routes?: MockRouteEntry[];
+}
+
+export interface BrunoMockRoute {
+  name: string;
+  description: string;
+  request: {
+    url: string;
+    method: string;
+    headers: any[];
+    params: any[];
+    body: any;
+  };
+  response: {
+    status: number;
+    statusText: string;
+    headers: any[];
+    body: {
+      type: string;
+      content: string;
+    };
+  };
+  rules: {
+    operator: 'AND' | 'OR';
+    conditions: Array<{ target: string; key: string; operator: string; value: string }>;
+  };
+  copiedFrom?: {
+    exampleName: string | null;
+    requestPathname: string | null;
+  };
+}
+
+export interface BrunoMockServer {
+  name: string;
+  port: number | null;
+  delay: number;
+  source: {
+    type: 'collection' | 'spec';
+    path: string;
+  } | null;
+  routes: BrunoMockRoute[];
+}

package/src/formats/yml/parseCollection.spec.ts

@@ -52,6 +52,129 @@ request:
   });
 });
 
+describe('parseCollection — script execution flow', () => {
+  it('reads flow: sequential from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sequential
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sequential');
+  });
+
+  it('reads flow: sandwich from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sandwich
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sandwich');
+  });
+
+  it('ignores an unrecognized flow value', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: parallel
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+
+  it('has no scripts.flow when the file does not set one', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n');
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+});
+
+describe('parseCollection — client certificates', () => {
+  it('maps pem and pkcs12 certs to Bruno cert/pfx shapes', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      passphrase: secret
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([
+      {
+        domain: 'localhost',
+        type: 'cert',
+        certFilePath: './certs/client-cert.pem',
+        keyFilePath: './certs/client-key.pem',
+        passphrase: 'secret'
+      },
+      {
+        domain: 'example.com',
+        type: 'pfx',
+        pfxFilePath: './certs/client.pfx',
+        passphrase: ''
+      }
+    ]);
+  });
+
+  it('drops certs with an unrecognized type', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: bogus
+      certificateFilePath: ./certs/client-cert.pem
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([]);
+  });
+
+  it('reads a per-cert disabled flag when set to true, otherwise leaves it off', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      disabled: true
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+      disabled: true
+    - domain: other.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/other.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs[0].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[1].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[2]).not.toHaveProperty('disabled');
+  });
+});
+
 describe('parseCollection — reading the collection version', () => {
   it('reads the version from the file as text', () => {
     const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n  version: v1.0.0\n');