660 lines
18 KiB
JavaScript
660 lines
18 KiB
JavaScript
"use strict";
|
|
|
|
var _ = require("..");
|
|
|
|
var _EnumTypeComposer = require("../EnumTypeComposer");
|
|
|
|
var _InputTypeComposer = require("../InputTypeComposer");
|
|
|
|
var _InterfaceTypeComposer = require("../InterfaceTypeComposer");
|
|
|
|
var _ScalarTypeComposer = require("../ScalarTypeComposer");
|
|
|
|
var _ObjectTypeComposer = require("../ObjectTypeComposer");
|
|
|
|
var _UnionTypeComposer = require("../UnionTypeComposer");
|
|
|
|
beforeEach(() => {
|
|
_.schemaComposer.clear();
|
|
});
|
|
describe('Extensions', () => {
|
|
describe('ObjectTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has field Extensions methods', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
},
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
});
|
|
it('has field extension initializers', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: {
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
nonExistingType: {
|
|
type: 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
thunkedField: () => ({
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensionsInitializers(tc);
|
|
});
|
|
it('has field arg Extensions methods', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
fieldWithArgs: {
|
|
type: 'String!',
|
|
args: {
|
|
argId: 'ID!',
|
|
argName: {
|
|
type: 'String'
|
|
},
|
|
argNonExistingType: {
|
|
type: 'Bar'
|
|
},
|
|
argThunked: {
|
|
type: () => 'Bar'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldArgExtensions(tc, 'fieldWithArgs');
|
|
});
|
|
it('has fieldArg extension initializers', () => {
|
|
const tc = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
fieldWithArgs: {
|
|
type: 'String',
|
|
args: {
|
|
argId: 'ID!',
|
|
argName: {
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
argNonExistingType: {
|
|
type: 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
argThunked: {
|
|
type: () => 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldArgExtensionsInitializers(tc);
|
|
});
|
|
});
|
|
describe('InputTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const tc = _InputTypeComposer.InputTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has field Extensions methods', () => {
|
|
const tc = _InputTypeComposer.InputTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const tc = _InputTypeComposer.InputTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
},
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
});
|
|
it('has field extension initializers', () => {
|
|
const tc = _InputTypeComposer.InputTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: {
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
nonExistingType: {
|
|
type: 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
thunkedField: () => ({
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensionsInitializers(tc);
|
|
});
|
|
});
|
|
describe('InterfaceTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has field Extensions methods', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String',
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String'
|
|
},
|
|
nonExistingType: 'Bar',
|
|
thunkedField: () => ({
|
|
type: 'String'
|
|
}),
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
});
|
|
it('has field extension initializers', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: {
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
nonExistingType: {
|
|
type: 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
thunkedField: () => ({
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
})
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldExtensionsInitializers(tc);
|
|
});
|
|
it('has field arg Extensions methods', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
fieldWithArgs: {
|
|
type: 'String!',
|
|
args: {
|
|
argId: 'ID!',
|
|
argName: {
|
|
type: 'String'
|
|
},
|
|
argNonExistingType: {
|
|
type: 'Bar'
|
|
},
|
|
argThunked: {
|
|
type: () => 'Bar'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldArgExtensions(tc, 'fieldWithArgs');
|
|
});
|
|
it('has fieldArg extension initializers', () => {
|
|
const tc = _InterfaceTypeComposer.InterfaceTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
fieldWithArgs: {
|
|
type: 'String',
|
|
args: {
|
|
argId: 'ID!',
|
|
argName: {
|
|
type: 'String',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
argNonExistingType: {
|
|
type: 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
},
|
|
argThunked: {
|
|
type: () => 'Bar',
|
|
extensions: {
|
|
noFilter: true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testFieldArgExtensionsInitializers(tc);
|
|
});
|
|
});
|
|
describe('EnumTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const tc = _EnumTypeComposer.EnumTypeComposer.create({
|
|
name: 'Foo',
|
|
values: {
|
|
FOO: {
|
|
value: 'FOO'
|
|
},
|
|
BAR: {
|
|
value: 'BAR'
|
|
}
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const tc = _EnumTypeComposer.EnumTypeComposer.create({
|
|
name: 'Foo',
|
|
values: {
|
|
FOO: {
|
|
value: 'FOO',
|
|
extensions: {
|
|
tags: ['a']
|
|
}
|
|
},
|
|
BAR: {
|
|
value: 'BAR',
|
|
extensions: {
|
|
tags: ['b']
|
|
}
|
|
}
|
|
},
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
expect(tc.getFieldExtensions('FOO')).toEqual({
|
|
tags: ['a']
|
|
});
|
|
expect(tc.getFieldExtensions('BAR')).toEqual({
|
|
tags: ['b']
|
|
});
|
|
});
|
|
});
|
|
describe('UnionTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const foo = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String'
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
const tc = _UnionTypeComposer.UnionTypeComposer.create({
|
|
name: 'FooUnion',
|
|
types: [foo]
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const foo = _ObjectTypeComposer.ObjectTypeComposer.create({
|
|
name: 'Foo',
|
|
fields: {
|
|
id: 'ID!',
|
|
name: 'String'
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
const tc = _UnionTypeComposer.UnionTypeComposer.create({
|
|
name: 'FooUnion',
|
|
types: [foo],
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
});
|
|
});
|
|
describe('ScalarTypeComposer', () => {
|
|
it('has type Extensions methods', () => {
|
|
const tc = _ScalarTypeComposer.ScalarTypeComposer.create({
|
|
name: 'Foo',
|
|
|
|
serialize() {}
|
|
|
|
}, _.schemaComposer);
|
|
|
|
testTypeExtensions(tc);
|
|
});
|
|
it('has type extension initializers', () => {
|
|
const tc = _ScalarTypeComposer.ScalarTypeComposer.create({
|
|
name: 'Foo',
|
|
serialize: () => {},
|
|
extensions: {
|
|
tags: ['generated']
|
|
}
|
|
}, _.schemaComposer);
|
|
|
|
expect(tc.getExtensions()).toEqual({
|
|
tags: ['generated']
|
|
});
|
|
});
|
|
});
|
|
|
|
function testTypeExtensions(instance) {
|
|
expect(instance.getExtensions()).toEqual({});
|
|
instance.setExtensions({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getExtensions()).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.extendExtensions({
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getExtensions()).toEqual({
|
|
tags: ['generated'],
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getExtension('source')).toEqual('user');
|
|
expect(instance.hasExtension('source')).toEqual(true);
|
|
expect(instance.hasExtension('nonExistant')).toEqual(false);
|
|
instance.setExtension('source', 'inference');
|
|
expect(instance.getExtensions()).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getExtension('source')).toEqual('inference');
|
|
instance.removeExtension('originalName');
|
|
expect(instance.getExtensions()).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearExtensions();
|
|
expect(instance.getExtensions()).toEqual({});
|
|
expect(instance.hasExtension('source')).toEqual(false);
|
|
instance.setExtensions({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getExtensions()).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearExtensions();
|
|
}
|
|
|
|
function testFieldExtensions(instance) {
|
|
['id', 'name', 'nonExistingType', 'thunkedField'].forEach(fieldName => {
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({});
|
|
instance.setFieldExtensions(fieldName, {
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.extendFieldExtensions(fieldName, {
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldExtension(fieldName, 'source')).toEqual('user');
|
|
expect(instance.hasFieldExtension(fieldName, 'source')).toEqual(true);
|
|
expect(instance.hasFieldExtension(fieldName, 'nonExistant')).toEqual(false);
|
|
instance.setFieldExtension(fieldName, 'source', 'inference');
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldExtension(fieldName, 'source')).toEqual('inference');
|
|
instance.removeFieldExtension(fieldName, 'originalName');
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearFieldExtensions(fieldName);
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({});
|
|
expect(instance.hasFieldExtension(fieldName, 'source')).toEqual(false);
|
|
instance.setFieldExtensions(fieldName, {
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getFieldExtensions(fieldName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearFieldExtensions(fieldName);
|
|
});
|
|
}
|
|
|
|
function testFieldExtensionsInitializers(instance) {
|
|
expect(instance.getFieldExtensions('name')).toEqual({
|
|
noFilter: true
|
|
});
|
|
expect(instance.getFieldExtensions('nonExistingType')).toEqual({
|
|
noFilter: true
|
|
});
|
|
expect(instance.getFieldExtensions('thunkedField')).toEqual({
|
|
noFilter: true
|
|
});
|
|
}
|
|
|
|
function testFieldArgExtensionsInitializers(instance) {
|
|
expect(instance.getFieldArgExtensions('fieldWithArgs', 'argName')).toEqual({
|
|
noFilter: true
|
|
});
|
|
expect(instance.getFieldArgExtensions('fieldWithArgs', 'argNonExistingType')).toEqual({
|
|
noFilter: true
|
|
});
|
|
expect(instance.getFieldArgExtensions('fieldWithArgs', 'argThunked')).toEqual({
|
|
noFilter: true
|
|
});
|
|
}
|
|
|
|
function testFieldArgExtensions(instance, fieldName) {
|
|
['argId', 'argName', 'argNonExistingType', 'argThunked'].forEach(argName => {
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({});
|
|
instance.setFieldArgExtensions(fieldName, argName, {
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.extendFieldArgExtensions(fieldName, argName, {
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'user',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldArgExtension(fieldName, argName, 'source')).toEqual('user');
|
|
expect(instance.hasFieldArgExtension(fieldName, argName, 'source')).toEqual(true);
|
|
expect(instance.hasFieldArgExtension(fieldName, argName, 'nonExistant')).toEqual(false);
|
|
instance.setFieldArgExtension(fieldName, argName, 'source', 'inference');
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference',
|
|
originalName: 'foo'
|
|
});
|
|
expect(instance.getFieldArgExtension(fieldName, argName, 'source')).toEqual('inference');
|
|
instance.removeFieldArgExtension(fieldName, argName, 'originalName');
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearFieldArgExtensions(fieldName, argName);
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({});
|
|
expect(instance.hasFieldArgExtension(fieldName, argName, 'source')).toEqual(false);
|
|
instance.setFieldArgExtensions(fieldName, argName, {
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
expect(instance.getFieldArgExtensions(fieldName, argName)).toEqual({
|
|
tags: ['generated'],
|
|
source: 'inference'
|
|
});
|
|
instance.clearFieldArgExtensions(fieldName, argName);
|
|
});
|
|
}
|
|
}); |