Merge pull request #3953 from mateuswgoettems/feat/federation-subscription-tests

test(@nestjs/apollo): add e2e coverage for subscriptions with ApolloFederationDriver

Author: kamilmysliwiec

packages/apollo/tests/subscriptions/federation-app/federation-app.module.ts

@@ -0,0 +1,27 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { GraphQLModule } from '@nestjs/graphql';
+import { ApolloDriverConfig } from '../../../lib';
+import { ApolloFederationDriver } from '../../../lib/drivers';
+import { NotificationModule } from './notification.module';
+
+export type FederationAppModuleConfig = {
+  subscriptions?: ApolloDriverConfig['subscriptions'];
+};
+
+@Module({})
+export class FederationAppModule {
+  static forRoot(options?: FederationAppModuleConfig): DynamicModule {
+    return {
+      module: FederationAppModule,
+      imports: [
+        NotificationModule,
+        GraphQLModule.forRoot<ApolloDriverConfig>({
+          driver: ApolloFederationDriver,
+          autoSchemaFile: true,
+          includeStacktraceInErrorResponses: false,
+          subscriptions: options?.subscriptions,
+        }),
+      ],
+    };
+  }
+}

packages/apollo/tests/subscriptions/federation-app/notification.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { NotificationResolver } from './notification.resolver';
+
+@Module({
+  providers: [NotificationResolver],
+})
+export class NotificationModule {}

packages/apollo/tests/subscriptions/federation-app/notification.resolver.ts

@@ -0,0 +1,28 @@
+import { Args, Query, Resolver, Subscription } from '@nestjs/graphql';
+import { PubSub } from 'graphql-subscriptions';
+import { Notification } from './notification';
+
+export const pubSub = new PubSub();
+
+@Resolver(() => Notification)
+export class NotificationResolver {
+  @Query(() => Notification)
+  getFederatedNotification(): Notification {
+    return { id: '0', recipient: 'system', message: 'ok' };
+  }
+
+  @Subscription(() => Notification, {
+    filter(payload, variables) {
+      return (
+        payload.newFederatedNotification.id === variables.id &&
+        payload.newFederatedNotification.recipient === variables.recipient
+      );
+    },
+  })
+  newFederatedNotification(
+    @Args('id', { nullable: false }) id: string,
+    @Args('recipient', { nullable: false }) recipient: string,
+  ) {
+    return pubSub.asyncIterableIterator('newFederatedNotification');
+  }
+}

packages/apollo/tests/subscriptions/federation-app/notification.ts

@@ -0,0 +1,13 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class Notification {
+  @Field({ nullable: false })
+  id: string;
+
+  @Field({ nullable: false })
+  recipient: string;
+
+  @Field({ nullable: false })
+  message: string;
+}

packages/apollo/tests/subscriptions/federation-graphql-ws.spec.ts

@@ -0,0 +1,125 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { InMemoryCache } from 'apollo-cache-inmemory';
+import ApolloClient from 'apollo-client';
+import { gql } from 'graphql-tag';
+import { Client, createClient } from 'graphql-ws';
+import request from 'supertest';
+import ws from 'ws';
+import { FederationAppModule } from './federation-app/federation-app.module';
+import { pubSub } from './federation-app/notification.resolver';
+import { GraphQLWsLink } from './utils/graphql-ws.link';
+
+const subscriptionQuery = gql`
+  subscription FederatedSubscription($id: String!, $recipient: String!) {
+    newFederatedNotification(id: $id, recipient: $recipient) {
+      id
+      recipient
+      message
+    }
+  }
+`;
+
+describe('GraphQL Federation - graphql-ws subscriptions', () => {
+  let app: INestApplication;
+  let wsClient: Client;
+  let port: number;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      imports: [
+        FederationAppModule.forRoot({
+          subscriptions: { 'graphql-ws': {} },
+        }),
+      ],
+    }).compile();
+
+    app = module.createNestApplication();
+    await app.init();
+    await app.listen(0);
+    port = app.getHttpServer().address().port;
+  });
+
+  afterEach(async () => {
+    try {
+      await wsClient?.dispose();
+    } catch {}
+    await app.close();
+  });
+
+  it('should connect and receive a filtered notification', async () => {
+    wsClient = createClient({
+      url: `ws://localhost:${port}/graphql`,
+      webSocketImpl: ws,
+      retryAttempts: 0,
+    });
+
+    wsClient.on('connected', () => {
+      setTimeout(() => {
+        pubSub.publish('newFederatedNotification', {
+          newFederatedNotification: {
+            id: '99',
+            recipient: 'alice',
+            message: 'wrong id',
+          },
+        });
+        pubSub.publish('newFederatedNotification', {
+          newFederatedNotification: {
+            id: '1',
+            recipient: 'bob',
+            message: 'wrong recipient',
+          },
+        });
+        pubSub.publish('newFederatedNotification', {
+          newFederatedNotification: {
+            id: '1',
+            recipient: 'alice',
+            message: 'Hello from federation',
+          },
+        });
+      }, 100);
+    });
+
+    const apolloClient = new ApolloClient({
+      link: new GraphQLWsLink(wsClient),
+      cache: new InMemoryCache(),
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      apolloClient
+        .subscribe({
+          query: subscriptionQuery,
+          variables: { id: '1', recipient: 'alice' },
+        })
+        .subscribe({
+          next(value: any) {
+            try {
+              expect(value.data.newFederatedNotification.id).toEqual('1');
+              expect(value.data.newFederatedNotification.recipient).toEqual(
+                'alice',
+              );
+              expect(value.data.newFederatedNotification.message).toEqual(
+                'Hello from federation',
+              );
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          },
+          complete() {},
+          error: reject,
+        });
+    });
+  });
+
+  it('should expose the Subscription type in the federation SDL', async () => {
+    const response = await request(app.getHttpServer())
+      .post('/graphql')
+      .send({ query: '{ _service { sdl } }' })
+      .expect(200);
+
+    const sdl: string = response.body.data._service.sdl;
+    expect(sdl).toContain('type Subscription');
+    expect(sdl).toContain('newFederatedNotification');
+  });
+});