Faster

Author: ardatan

e2e/grpc-multiple/grpc-multiple.test.ts

@@ -1,7 +1,7 @@
 import { createTenv, type Serve } from '@e2e/tenv';
 
 describe('gRPC Multiple', () => {
-  it('composes', async () => {
+  it.concurrent('composes', async () => {
     await using tenv = createTenv(__dirname);
     await using Pets = await tenv.service('Pets');
     await using Stores = await tenv.service('Stores');

e2e/hoist-and-prefix-transform/hoist-and-prefix-transform.test.ts

@@ -1,30 +1,30 @@
 import { createTenv, type Service } from '@e2e/tenv';
 
-const { compose, serve, service, fs } = createTenv(__dirname);
+const { compose, gateway, service, fs } = createTenv(__dirname);
 
 let weather: Service;
 
 beforeAll(async () => {
   weather = await service('weather');
 });
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose({
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose({
     services: [weather],
     maskServicePorts: true,
   });
   expect(result).toMatchSnapshot();
 });
 
-it('should compose and execute', async () => {
-  const { output } = await compose({ output: 'graphql', services: [weather] });
+it.concurrent('should compose and execute', async () => {
+  const { supergraphPath } = await compose({ output: 'graphql', services: [weather] });
 
   // hoisted
-  const supergraph = await fs.read(output);
+  const supergraph = await fs.read(supergraphPath);
   expect(supergraph).toContain('Test_Weather');
   expect(supergraph).toContain('chanceOfRain');
 
-  const { execute } = await serve({ supergraph: output });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(
     execute({
       query: /* GraphQL */ `

e2e/js-config/js-config.test.ts

@@ -1,15 +1,15 @@
 import { createTenv } from '@e2e/tenv';
 import { fetch } from '@whatwg-node/fetch';
 
-const { serve, compose, fs } = createTenv(__dirname);
+const { gateway, compose, fs } = createTenv(__dirname);
 
-it('should compose and serve', async () => {
-  const { result: composedSchema } = await compose();
+it.concurrent('should compose and serve', async () => {
+  const { supergraphSdl: composedSchema } = await compose();
   expect(composedSchema).toMatchSnapshot();
 
   const supergraphPath = await fs.tempfile('supergraph.graphql');
   await fs.write(supergraphPath, composedSchema);
-  const { hostname, port } = await serve({ supergraph: supergraphPath });
+  const { hostname, port } = await gateway({ supergraph: supergraphPath });
   const res = await fetch(`http://${hostname}:${port}/graphql?query={hello}`);
   expect(res.ok).toBeTruthy();
   await expect(res.text()).resolves.toMatchInlineSnapshot(`"{"data":{"hello":"world"}}"`);

e2e/json-schema-subscriptions/json-schema-subscriptions.test.ts

@@ -3,21 +3,24 @@ import { createTenv } from '@e2e/tenv';
 import { fetch } from '@whatwg-node/fetch';
 import { getAvailablePort } from '../../packages/testing/getAvailablePort';
 
-const { compose, serve, service } = createTenv(__dirname);
+const { compose, gateway, service } = createTenv(__dirname);
 
-it('should compose the appropriate schema', async () => {
+it.concurrent('should compose the appropriate schema', async () => {
   const api = await service('api');
-  const { result } = await compose({ services: [api], maskServicePorts: true });
+  const { supergraphSdl: result } = await compose({ services: [api], maskServicePorts: true });
   expect(result).toMatchSnapshot();
 });
 
 ['todoAddedFromSource', 'todoAddedFromExtensions'].forEach(subscriptionField => {
   describe(`Listen to ${subscriptionField}`, () => {
-    it('should query, mutate and subscribe', async () => {
+    it.concurrent('should query, mutate and subscribe', async () => {
       const servePort = await getAvailablePort();
       const api = await service('api', { servePort });
-      const { output } = await compose({ output: 'graphql', services: [api] });
-      const { hostname, port, execute } = await serve({ supergraph: output, port: servePort });
+      const { supergraphPath } = await compose({ output: 'graphql', services: [api] });
+      const { hostname, port, execute } = await gateway({
+        supergraph: supergraphPath,
+        port: servePort,
+      });
 
       await expect(
         execute({

e2e/logs-to-stderr-results-to-stdout/logs-to-stderr-results-to-stdout.test.ts

@@ -2,7 +2,7 @@ import { createTenv } from '@e2e/tenv';
 
 const { compose } = createTenv(__dirname);
 
-it('should write compose output to stdout and logs to stderr', async () => {
+it.concurrent('should write compose output to stdout and logs to stderr', async () => {
   const { getStd } = await compose();
   expect(getStd('out')).toContain('type Query @join__type(graph: HELLOWORLD)');
   expect(getStd('err')).toContain('Done!');

e2e/manual-transport-def/manual-transport-def.test.ts

@@ -1,21 +1,21 @@
 import { createTenv } from '@e2e/tenv';
 
-const { compose, serve, service } = createTenv(__dirname);
+const { compose, gateway, service } = createTenv(__dirname);
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose({
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose({
     services: [await service('greetings'), await service('helloer')],
     maskServicePorts: true,
   });
   expect(result).toMatchSnapshot();
 });
 
-it('should execute the query', async () => {
-  const { output } = await compose({
+it.concurrent('should execute the query', async () => {
+  const { supergraphPath } = await compose({
     output: 'graphql',
     services: [await service('greetings'), await service('helloer')],
   });
-  const { execute } = await serve({ supergraph: output });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(
     execute({
       query: /* GraphQL */ `

e2e/mysql-employees/mysql-employees.test.ts

@@ -1,6 +1,6 @@
 import { createTenv, type Container } from '@e2e/tenv';
 
-const { compose, serve, container } = createTenv(__dirname);
+const { compose, gateway, container } = createTenv(__dirname);
 
 let mysql!: Container;
 beforeAll(async () => {
@@ -20,8 +20,8 @@ beforeAll(async () => {
   });
 });
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose({
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose({
     services: [mysql],
     maskServicePorts: true,
   });
@@ -59,7 +59,7 @@ it.concurrent.each([
     `,
   },
 ])('should execute $name', async ({ query }) => {
-  const { output } = await compose({ output: 'graphql', services: [mysql] });
-  const { execute } = await serve({ supergraph: output });
+  const { supergraphPath } = await compose({ output: 'graphql', services: [mysql] });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(execute({ query })).resolves.toMatchSnapshot();
 });

e2e/mysql-rfam/mysql-rfam.test.ts

@@ -1,9 +1,9 @@
 import { createTenv } from '@e2e/tenv';
 
-const { compose, serve } = createTenv(__dirname);
+const { compose, gateway } = createTenv(__dirname);
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose();
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose();
   expect(result).toMatchSnapshot();
 });
 
@@ -25,7 +25,7 @@ it.concurrent.each([
     `,
   },
 ])('should execute $name', async ({ query }) => {
-  const { output } = await compose({ output: 'graphql' });
-  const { execute } = await serve({ supergraph: output });
+  const { supergraphPath } = await compose({ output: 'graphql' });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(execute({ query })).resolves.toMatchSnapshot();
 });

e2e/neo4j-example/neo4j-example.test.ts

@@ -1,6 +1,6 @@
 import { createTenv, type Container } from '@e2e/tenv';
 
-const { compose, container, serve, spawn } = createTenv(__dirname);
+const { compose, container, gateway, spawn } = createTenv(__dirname);
 
 let neo4j: Container;
 beforeAll(async () => {
@@ -31,8 +31,8 @@ beforeAll(async () => {
   await waitForLoad;
 });
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose({
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose({
     services: [neo4j],
     maskServicePorts: true,
   });
@@ -56,10 +56,10 @@ it.concurrent.each([
     `,
   },
 ])('should execute $name', async ({ query }) => {
-  const { output } = await compose({
+  const { supergraphPath } = await compose({
     services: [neo4j],
     output: 'graphql',
   });
-  const { execute } = await serve({ supergraph: output });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(execute({ query })).resolves.toMatchSnapshot();
 });

e2e/odata-trippin/odata-trippin.test.ts

@@ -1,17 +1,17 @@
 import { createTenv } from '@e2e/tenv';
 
-const { compose, serve } = createTenv(__dirname);
+const { compose, gateway } = createTenv(__dirname);
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose();
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose();
   expect(result).toMatchSnapshot();
 });
 
-it('executes a query', async () => {
-  const { output } = await compose({
+it.concurrent('executes a query', async () => {
+  const { supergraphPath } = await compose({
     output: 'graphql',
   });
-  const { execute } = await serve({ supergraph: output });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   const result = await execute({
     query: /* GraphQL */ `
       query GetMe {

e2e/openapi-additional-resolvers/openapi-additional-resolvers.test.ts

@@ -1,10 +1,10 @@
 import { createTenv } from '@e2e/tenv';
 
-const { compose, serve } = createTenv(__dirname);
+const { compose, gateway } = createTenv(__dirname);
 
-it('should execute Metrics with banana', async () => {
-  const { output } = await compose({ output: 'graphql' });
-  const { execute } = await serve({ supergraph: output });
+it.concurrent('should execute Metrics with banana', async () => {
+  const { supergraphPath } = await compose({ output: 'graphql' });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   const result = await execute({
     query: /* GraphQL */ `
       query Metrics {
@@ -36,9 +36,9 @@ it('should execute Metrics with banana', async () => {
   ).toEqual('🍌');
 });
 
-it('should execute Metrics with apple', async () => {
-  const { output } = await compose({ output: 'graphql' });
-  const { execute } = await serve({ supergraph: output });
+it.concurrent('should execute Metrics with apple', async () => {
+  const { supergraphPath } = await compose({ output: 'graphql' });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   const result = await execute({
     query: /* GraphQL */ `
       query Metrics {

e2e/openapi-arg-rename/openapi-arg-rename.test.ts

@@ -1,23 +1,23 @@
 import { createTenv } from '@e2e/tenv';
 
 describe('OpenAPI Arg Rename', () => {
-  const { compose, serve, service } = createTenv(__dirname);
-  it('composes the schema', async () => {
-    const { result } = await compose({
+  const { compose, gateway, service } = createTenv(__dirname);
+  it.concurrent('composes the schema', async () => {
+    const { supergraphSdl: result } = await compose({
       output: 'graphql',
       services: [await service('Wiki')],
       maskServicePorts: true,
     });
 
     expect(result).toMatchSnapshot();
   });
-  it('should work with untouched schema', async () => {
-    const { output } = await compose({
+  it.concurrent('should work with untouched schema', async () => {
+    const { supergraphPath } = await compose({
       output: 'graphql',
       services: [await service('Wiki')],
     });
 
-    const { execute } = await serve({ supergraph: output });
+    const { execute } = await gateway({ supergraph: supergraphPath });
     const queryResult = await execute({
       query: /* GraphQL */ `
         mutation Good {
@@ -37,13 +37,13 @@ describe('OpenAPI Arg Rename', () => {
     });
   });
 
-  it('should work with renamed argument', async () => {
-    const { output } = await compose({
+  it.concurrent('should work with renamed argument', async () => {
+    const { supergraphPath } = await compose({
       output: 'graphql',
       services: [await service('Wiki')],
     });
 
-    const { execute } = await serve({ supergraph: output });
+    const { execute } = await gateway({ supergraph: supergraphPath });
     const queryResult = await execute({
       query: /* GraphQL */ `
         mutation Bad {

e2e/openapi-hateoas/openapi-hateoas.test.ts

@@ -1,33 +1,29 @@
-import { createTenv, type Service } from '@e2e/tenv';
+import { createTenv } from '@e2e/tenv';
 
 describe('OpenAPI HATEOAS', () => {
-  const { compose, serve, service } = createTenv(__dirname);
-
-  let oasService: Service;
-
-  beforeAll(async () => {
-    oasService = await service('OASService');
-  });
-
-  it('should compose', async () => {
-    const { result } = await compose({
+  it.concurrent('should compose', async () => {
+    await using tenv = createTenv(__dirname);
+    await using OASService = await tenv.service('OASService');
+    await using composition = await tenv.compose({
       output: 'graphql',
-      services: [oasService],
+      services: [OASService],
       maskServicePorts: true,
     });
-    expect(result).toMatchSnapshot();
+    expect(composition.supergraphSdl).toMatchSnapshot();
   });
 
-  it('should execute and follow HATEOAS links', async () => {
-    const { output } = await compose({
+  it.concurrent('should execute and follow HATEOAS links', async () => {
+    await using tenv = createTenv(__dirname);
+    await using OASService = await tenv.service('OASService');
+    await using composition = await tenv.compose({
       output: 'graphql',
-      services: [oasService],
+      services: [OASService],
     });
 
-    const { execute } = await serve({
-      supergraph: output,
+    const gw = await tenv.gateway({
+      supergraph: composition.supergraphPath,
     });
-    const queryResult = await execute({
+    const queryResult = await gw.execute({
       query: /* GraphQL */ `
         query GetProductsById {
           getProductById(id: 1) {

e2e/openapi-javascript-wiki/openapi-javascript-wiki.test.ts

@@ -1,9 +1,9 @@
 import { createTenv } from '@e2e/tenv';
 
-const { compose, serve } = createTenv(__dirname);
+const { compose, gateway } = createTenv(__dirname);
 
-it('should compose the appropriate schema', async () => {
-  const { result } = await compose();
+it.concurrent('should compose the appropriate schema', async () => {
+  const { supergraphSdl: result } = await compose();
   expect(result).toMatchSnapshot();
 });
 
@@ -30,7 +30,7 @@ it.concurrent.each([
     `,
   },
 ])('should execute $name', async ({ query }) => {
-  const { output } = await compose({ output: 'graphql' });
-  const { execute } = await serve({ supergraph: output });
+  const { supergraphPath } = await compose({ output: 'graphql' });
+  const { execute } = await gateway({ supergraph: supergraphPath });
   await expect(execute({ query })).resolves.toMatchSnapshot();
 });