4

我已经为 graphql-js 订阅编写了集成测试，这些测试显示出奇怪的行为。

我的 graphq-js 订阅在 GraphiQL 中完美运行。但是当从单元测试中调用相同的订阅时，它会失败。

Ggraphql-Js 对象，具有解析功能和订阅功能

return {
type: outputType,
args: {
  input: {type: new GraphQLNonNull(inputType)},
},
resolve(payload, args, context, info) {
  const clientSubscriptionId = (payload) ? payload.subscriptionId : null;

  const object = (payload) ? payload.object : null;
  var where = null;
  var type = null;
  var target = null;
  if (object) {
    where = (payload) ? payload.object.where : null;
    type = (payload) ? payload.object.type : null;
    target = (payload) ? payload.object.target : null;
  }

  return Promise.resolve(subscribeAndGetPayload(payload, args, context, info))
    .then(payload => ({
      clientSubscriptionId, where, type, target, object: payload.data,
    }));
},
subscribe: withFilter(
  () => pubSub.asyncIterator(modelName),
  (payload, variables, context, info) => {
    const subscriptionPayload = {
      clientSubscriptionId: variables.input.clientSubscriptionId,
      remove: variables.input.remove,
      create: variables.input.create,
      update: variables.input.update,
      opts: variables.input.options,
    };

    subscriptionPayload.model = model;

    try {
      pubSub.subscribe(info.fieldName, null, subscriptionPayload);
    } catch (ex) {
      console.log(ex);
    }
    return true;
  }
),

};

订阅查询

subscription {
  Customer(input: {create: true, clientSubscriptionId: 112}) {
    customer {
      id
      name
      age
    }
  }
}

突变查询

mutation {
  Customer {
    CustomerCreate (input:{data:{name:"Atif 50", age:50}}) {
      obj {
        id
        name
      }
    }
  }
}

集成测试

'use strict';
const ws = require('ws');
const { SubscriptionClient } = require('subscriptions-transport-ws');
const { ApolloClient } = require('apollo-client');
const { HttpLink } = require('apollo-link-http');
const { InMemoryCache } = require('apollo-cache-inmemory');


const Promise = require('bluebird');
const expect = require('chai').expect;
const chai = require('chai').use(require('chai-http'));
const server = require('../server/server');
const gql = require('graphql-tag');


let apollo;
let networkInterface;
const GRAPHQL_ENDPOINT = 'ws://localhost:5000/subscriptions';


describe('Subscription', () => {

    before(async () => {
        networkInterface = new SubscriptionClient(
            GRAPHQL_ENDPOINT, { reconnect: true }, ws);
        apollo = new ApolloClient({
            networkInterface ,
            link: new HttpLink({ uri: 'http://localhost:3000/graphql' }),
            cache: new InMemoryCache()
        });
    });

    after(done => {
        networkInterface.close() ;
    });

    it('subscription', async () => {
        const client = () => apollo;
        // SUBSCRIBE and make a promise
        const subscriptionPromise = new Promise((resolve, reject) => {
            client().subscribe({
                query: gql`
                    subscription {
                        Customer(input: {create: true, 
                            clientSubscriptionId: 112, 
                            options: {where: {age: 50}}}) {
                            customer {
                                name
                            }
                        }
                    }
                `
            }).subscribe({
                next: resolve,
                error: reject
            });
        });

        let execGraphQL;
        // MUTATE
        await execGraphQL(
            `mutation {
              Customer {
                CustomerCreate (input:{data:{name:"Atif 21", age:50}}) {
                  obj {
                    id
                    name
                  }
                }
              }
            }`
        );

        // ASSERT SUBSCRIPTION RECEIVED EVENT
        expect(await subscriptionPromise).to.deep.equal({});

    });
});

此处的问题 在运行测试时，resolve函数中的有效负载包含全局数据，而它应该包含订阅有效负载。所以代码中断了。

4

0 回答 0