graphql-validity
Version:
Make business logic validation easy on the graphql side without adding any declarations or modifications to the existing graphql schema.
509 lines • 19.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var chai = require("chai");
var chaiAsPromised = require("chai-as-promised");
chai.use(chaiAsPromised);
var expect = chai.expect;
const schema_wrapper_1 = require("../src/schema-wrapper");
const __1 = require("..");
describe('schema-wrapper', () => {
describe('wrapResolvers', () => {
it('should create proxy for field resolver', () => {
const resolve = function () {
return true;
};
const field = { resolve };
schema_wrapper_1.wrapResolvers(field);
expect(field.resolve).to.not.equal(resolve);
});
it('should create proxy for field resolvers on a given object type', () => {
const resolve = function () {
return true;
};
const field = { resolve };
const type = new GraphQLObjectType([field], 'Test');
schema_wrapper_1.wrapResolvers(type);
expect(field.resolve).to.not.equal(resolve);
});
it('should create proxy for field resolvers on a given schema', () => {
const resolve = function () {
return true;
};
const field = { resolve };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
expect(field.resolve).to.not.equal(resolve);
});
it('should set Processed to true', () => {
const resolve = function () {
return true;
};
const field = { resolve };
schema_wrapper_1.wrapResolvers(field);
expect(field[schema_wrapper_1.Processed]).to.be.true;
});
it('resolve should return result if validity is not set up', async () => {
const resolve = function () {
return true;
};
const field = { resolve };
schema_wrapper_1.wrapResolvers(field);
const result = await field.resolve();
expect(result).to.be.true;
});
it('resolve should return result if validity is set up', async () => {
__1.FieldValidationDefinitions['$'] = [() => { return new Error('test1'); }];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
const result = await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(result).to.be.true;
});
it('resolve should perform validation if validity is set up', async () => {
__1.FieldValidationDefinitions['$'] = [() => { return new Error('test1'); }];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___validationResults.length).to.equal(1);
expect(validity.___validationResults[0].message).to.equal('test1');
});
it('resolve should perform profiling if validity is set up and profiling enabled', async () => {
__1.FieldValidationDefinitions['$'] = [() => { return new Error('test1'); }];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
unhandledErrorWrapper: (err) => { return err; }
});
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___profilingData.length).to.equal(1);
});
it('resolve should perform profiling if validity is set up and profiling enabled and validator returns promise', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test1')]);
});
}];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
profilingResultHandler: () => { }
});
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___profilingData.length).to.equal(1);
});
it('resolve should perform profiling if validity is set up and profiling enabled and resolver returns promise', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return [];
}];
const resolve = function (...args) {
return new Promise((resolve) => {
resolve([new Error('test1')]);
});
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
profilingResultHandler: () => { }
});
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___profilingData.length).to.equal(1);
});
it('resolve should perform profiling if validity is set up and profiling enabled and both resolver and validation returns promise', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve, reject) => resolve([]));
}];
const resolve = function (...args) {
return new Promise((resolve) => {
resolve([new Error('test1')]);
});
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
unhandledErrorWrapper: (err) => { return err; }
});
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___profilingData.length).to.equal(1);
});
it('resolve should not throw exception during profiling failure', async () => {
__1.FieldValidationDefinitions['$'] = [() => { return new Error('test2'); }];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
unhandledErrorWrapper: (err) => { return err; }
});
const validity = {};
expect(field.resolve).to.not.throw(({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
}));
});
it('resolve should not throw during validator exception being returned', async () => {
__1.FieldValidationDefinitions['$'] = [() => { return new Error('test2'); }];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
unhandledErrorWrapper: (err) => { return err; }
});
const validity = {};
expect(field.resolve).to.not.throw(({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
}));
});
it('resolve should throw during validator promise rejection', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve, reject) => reject('test2'));
}];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema, {
wrapErrors: false,
enableProfiling: true,
unhandledErrorWrapper: (err) => { return err; }
});
const validity = {};
expect(field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
})).to.eventually.be.rejected;
});
it('resolve should return result if validity is set up to return promise', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test1')]);
});
}];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
const result = await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(result).to.be.true;
});
it('resolve should perform validation if validity is set up to return promise', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test2')]);
});
}];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const type = new GraphQLObjectType([field], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
const validity = {
___validationResults: [],
___globalValidationResultsCaptured: false,
___profilingData: []
};
await field.resolve({
parentType: 'Test',
rootValue: {
__graphQLValidity: validity
}
});
expect(validity.___validationResults.length).to.equal(1);
expect(validity.___validationResults[0].message).to.equal('test2');
});
it('shouldn\'t replace resolver for type not implementing getFields', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test2')]);
});
}];
const resolve = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const field2 = {
resolve: function (...args) {
return true;
}, name: 'Test2'
};
const type = new GraphQLObjectTypeWithoutFields([field, field2], 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
expect(type.fields[0].resolve).to.equal(resolve);
});
it('shouldn\'t replace resolvers for functions that aren\'t related to types', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test2')]);
});
}];
const resolve = function (...args) {
return true;
};
const resolve2 = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const field2 = {
resolve: resolve2, name: 'Test2'
};
const type = new GraphQLObjectTypeFieldAsObject(new FieldsType2(field, field2), 'Test');
const typesMap = {
'Test': type
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
expect(field.resolve).to.not.equal(resolve);
expect(field2.resolve).to.not.equal(resolve2);
});
it('shouldn\'t replace resolvers for parent schema object', async () => {
__1.FieldValidationDefinitions['$'] = [() => {
return new Promise((resolve) => {
resolve([new Error('test2')]);
});
}];
const resolve = function (...args) {
return true;
};
const resolve2 = function (...args) {
return true;
};
const field = { resolve, name: 'Test' };
const field2 = {
resolve: resolve2, name: 'Test2'
};
const type = new GraphQLObjectType2([field, field2], 'Test33');
const type2 = new GraphQLObjectType2([field, field2], 'Test44');
const typesMap = {
'Test33': type,
'Test44': type2
};
const schema = new GraphQLSchema(typesMap);
schema_wrapper_1.wrapResolvers(schema);
expect(field.resolve).to.not.equal(resolve);
expect(field2.resolve).to.not.equal(resolve2);
});
});
});
class GraphQLObjectTypeWithoutFields {
constructor(fields, name) {
this.fields = fields;
this.name = name;
}
}
class GraphQLObjectTypeFieldAsObject {
constructor(fields, name) {
this.fields = fields;
this.name = name;
}
getFields() {
return this.fields;
}
}
class GraphQLObjectType {
constructor(fields, name) {
this.fields = fields;
this.name = name;
}
getFields() {
return this.fields;
}
}
class GraphQLObjectType2 extends GraphQLObjectType {
constructor(fields, name) {
super(fields, name);
this.fields = fields;
this.name = name;
}
getFields() {
return this.fields;
}
}
class GraphQLSchema2 {
constructor(types) {
this.types = types;
}
getTypeMap() {
return this.types;
}
}
class GraphQLSchema extends GraphQLSchema2 {
constructor(types) {
super(types);
this.types = types;
}
getTypeMap() {
return this.types;
}
}
class FieldsType1 {
constructor(field) {
this.field = field;
}
}
class FieldsType2 extends FieldsType1 {
constructor(field1, field2) {
super(field2);
this.field1 = field1;
}
}
//# sourceMappingURL=schema-wrapper.js.map