Skip to content

Commit 7bd8d89

Browse files
nodkznodkz
committed
Add resolvers with tests: updateById, updateOne, updateMany
1 parent de922a4 commit 7bd8d89

File tree

6 files changed

+514
-17
lines changed

6 files changed

+514
-17
lines changed

‎src/resolvers/__tests__/updateById-test.js‎

Lines changed: 149 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,149 @@
1+
/* @flow */
2+
3+
import { expect } from 'chai';
4+
import { UserModel } from '../../__mocks__/userModel.js';
5+
import updateById from '../updateById';
6+
import Resolver from '../../../../graphql-compose/src/resolver/resolver';
7+
import TypeComposer from '../../../../graphql-compose/src/typeComposer';
8+
import InputTypeComposer from '../../../../graphql-compose/src/typeInputComposer';
9+
import { convertModelToGraphQL } from '../../fieldsConverter';
10+
import {
11+
GraphQLNonNull,
12+
GraphQLInputObjectType,
13+
getNullableType,
14+
} from 'graphql';
15+
import GraphQLMongoID from '../../types/mongoid';
16+
17+
const UserType = convertModelToGraphQL(UserModel, 'User');
18+
19+
describe('updateById() ->', () => {
20+
let user1;
21+
let user2;
22+
23+
before('clear UserModel collection', (done) => {
24+
UserModel.collection.drop(done);
25+
});
26+
27+
before('add test user document to mongoDB', () => {
28+
user1 = new UserModel({
29+
name: 'userName1',
30+
skills: ['js', 'ruby', 'php', 'python'],
31+
gender: 'male',
32+
relocation: true,
33+
});
34+
35+
user2 = new UserModel({
36+
name: 'userName2',
37+
skills: ['go', 'erlang'],
38+
gender: 'female',
39+
relocation: true,
40+
});
41+
42+
return Promise.all([
43+
user1.save(),
44+
user2.save(),
45+
]);
46+
});
47+
48+
it('should return Resolver object', () => {
49+
const resolver = updateById(UserModel, UserType);
50+
expect(resolver).to.be.instanceof(Resolver);
51+
});
52+
53+
describe('Resolver.args', () => {
54+
it('should have `input` arg', () => {
55+
const resolver = updateById(UserModel, UserType);
56+
expect(resolver.hasArg('input')).to.be.true;
57+
const argConfig = resolver.getArg('input');
58+
expect(argConfig).has.deep.property('type.name', 'UpdateByIdUserInput');
59+
});
60+
61+
it('should have `input._id` required arg', () => {
62+
const resolver = updateById(UserModel, UserType);
63+
const argConfig = resolver.getArg('input') || {};
64+
expect(argConfig).property('type').instanceof(GraphQLInputObjectType);
65+
if (argConfig.type) {
66+
const _idFieldType = new InputTypeComposer(argConfig.type).getFieldType('_id');
67+
expect(_idFieldType).instanceof(GraphQLNonNull);
68+
expect(getNullableType(_idFieldType)).equal(GraphQLMongoID);
69+
}
70+
});
71+
});
72+
73+
describe('Resolver.resolve():Promise', () => {
74+
it('should be promise', () => {
75+
const result = updateById(UserModel, UserType).resolve({});
76+
expect(result).instanceof(Promise);
77+
result.catch(() => 'catch error if appear, hide it from mocha');
78+
});
79+
80+
it('should rejected with Error if args.input._id is empty', async () => {
81+
const result = updateById(UserModel, UserType).resolve({ args: { input: {} } });
82+
await expect(result).be.rejectedWith(Error, 'requires args.input._id');
83+
});
84+
85+
it('should return payload.recordId', async () => {
86+
const result = await updateById(UserModel, UserType).resolve({
87+
args: {
88+
input: { _id: user1.id, name: 'some name' },
89+
},
90+
});
91+
expect(result).have.property('recordId', user1.id);
92+
});
93+
94+
it('should change data via args.input in model', async () => {
95+
const result = await updateById(UserModel, UserType).resolve({
96+
args: {
97+
input: { _id: user1.id, name: 'newName' },
98+
},
99+
});
100+
expect(result).have.deep.property('record.name', 'newName');
101+
});
102+
103+
it('should change data via args.input in database', (done) => {
104+
const checkedName = 'nameForMongoDB';
105+
updateById(UserModel, UserType).resolve({
106+
args: {
107+
input: { _id: user1.id, name: checkedName },
108+
},
109+
}).then(() => {
110+
UserModel.collection.findOne({ _id: user1._id }, (err, doc) => {
111+
expect(doc.name).to.be.equal(checkedName);
112+
done();
113+
});
114+
});
115+
});
116+
117+
it('should return payload.record', async () => {
118+
const checkedName = 'anyName123';
119+
const result = await updateById(UserModel, UserType).resolve({
120+
args: {
121+
input: { _id: user1.id, name: checkedName },
122+
},
123+
});
124+
expect(result).have.deep.property('record.id', user1.id);
125+
expect(result).have.deep.property('record.name', checkedName);
126+
});
127+
});
128+
129+
describe('Resolver.getOutputType()', () => {
130+
it('should have correct output type name', () => {
131+
const outputType = updateById(UserModel, UserType).getOutputType();
132+
expect(outputType.name).to.equal(`UpdateById${UserType.name}Payload`);
133+
});
134+
135+
it('should have recordId field', () => {
136+
const outputType = updateById(UserModel, UserType).getOutputType();
137+
const typeComposer = new TypeComposer(outputType);
138+
expect(typeComposer.hasField('recordId')).to.be.true;
139+
expect(typeComposer.getField('recordId').type).to.equal(GraphQLMongoID);
140+
});
141+
142+
it('should have record field', () => {
143+
const outputType = updateById(UserModel, UserType).getOutputType();
144+
const typeComposer = new TypeComposer(outputType);
145+
expect(typeComposer.hasField('record')).to.be.true;
146+
expect(typeComposer.getField('record').type).to.equal(UserType);
147+
});
148+
});
149+
});

‎src/resolvers/__tests__/updateMany-test.js‎

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
/* @flow */
2+
3+
import { expect } from 'chai';
4+
import { UserModel } from '../../__mocks__/userModel.js';
5+
import updateMany from '../updateMany';
6+
import Resolver from '../../../../graphql-compose/src/resolver/resolver';
7+
import TypeComposer from '../../../../graphql-compose/src/typeComposer';
8+
import { convertModelToGraphQL } from '../../fieldsConverter';
9+
import { GraphQLInt } from 'graphql';
10+
11+
const UserType = convertModelToGraphQL(UserModel, 'User');
12+
13+
describe('updateMany() ->', () => {
14+
let user1;
15+
let user2;
16+
17+
before('clear UserModel collection', (done) => {
18+
UserModel.collection.drop(done);
19+
});
20+
21+
before('add test user document to mongoDB', () => {
22+
user1 = new UserModel({
23+
name: 'userName1',
24+
skills: ['js', 'ruby', 'php', 'python'],
25+
gender: 'male',
26+
relocation: true,
27+
});
28+
29+
user2 = new UserModel({
30+
name: 'userName2',
31+
skills: ['go', 'erlang'],
32+
gender: 'female',
33+
relocation: true,
34+
});
35+
36+
return Promise.all([
37+
user1.save(),
38+
user2.save(),
39+
]);
40+
});
41+
42+
it('should return Resolver object', () => {
43+
const resolver = updateMany(UserModel, UserType);
44+
expect(resolver).to.be.instanceof(Resolver);
45+
});
46+
47+
describe('Resolver.args', () => {
48+
it('should have `filter` arg', () => {
49+
const resolver = updateMany(UserModel, UserType);
50+
expect(resolver.hasArg('filter')).to.be.true;
51+
});
52+
53+
it('should have `limit` arg', () => {
54+
const resolver = updateMany(UserModel, UserType);
55+
expect(resolver.hasArg('limit')).to.be.true;
56+
});
57+
58+
it('should have `skip` arg', () => {
59+
const resolver = updateMany(UserModel, UserType);
60+
expect(resolver.hasArg('skip')).to.be.true;
61+
});
62+
63+
it('should have `sort` arg', () => {
64+
const resolver = updateMany(UserModel, UserType);
65+
expect(resolver.hasArg('sort')).to.be.true;
66+
});
67+
68+
it('should have `input` arg', () => {
69+
const resolver = updateMany(UserModel, UserType);
70+
expect(resolver.hasArg('input')).to.be.true;
71+
const argConfig = resolver.getArg('input');
72+
expect(argConfig).has.deep.property('type.name', 'UpdateManyUserInput');
73+
});
74+
});
75+
76+
describe('Resolver.resolve():Promise', () => {
77+
it('should be promise', () => {
78+
const result = updateMany(UserModel, UserType).resolve({});
79+
expect(result).instanceof(Promise);
80+
result.catch(() => 'catch error if appear, hide it from mocha');
81+
});
82+
83+
it('should rejected with Error if args.input is empty', async () => {
84+
const result = updateMany(UserModel, UserType).resolve({ args: {} });
85+
await expect(result).be.rejectedWith(Error, 'at least one value in args.input');
86+
});
87+
88+
it('should change data via args.input in database', (done) => {
89+
const checkedName = 'nameForMongoDB';
90+
updateMany(UserModel, UserType).resolve({
91+
args: {
92+
filter: { _id: user1.id },
93+
input: { name: checkedName },
94+
},
95+
}).then(() => {
96+
UserModel.collection.findOne({ _id: user1._id }, (err, doc) => {
97+
expect(doc).property('name').to.be.equal(checkedName);
98+
done();
99+
});
100+
});
101+
});
102+
103+
it('should return payload.numAffected', async () => {
104+
const result = await updateMany(UserModel, UserType).resolve({
105+
args: {
106+
input: { gender: 'female' },
107+
},
108+
});
109+
expect(result).have.deep.property('numAffected', 2);
110+
});
111+
});
112+
113+
describe('Resolver.getOutputType()', () => {
114+
it('should have correct output type name', () => {
115+
const outputType = updateMany(UserModel, UserType).getOutputType();
116+
expect(outputType).property('name').to.equal(`UpdateMany${UserType.name}Payload`);
117+
});
118+
119+
it('should have numAffected field', () => {
120+
const outputType = updateMany(UserModel, UserType).getOutputType();
121+
const numAffectedField = new TypeComposer(outputType).getField('numAffected');
122+
expect(numAffectedField).property('type').to.equal(GraphQLInt);
123+
});
124+
});
125+
});

‎src/resolvers/__tests__/updateOne-test.js‎

Lines changed: 43 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,9 @@ import { expect } from 'chai';
44
import { UserModel } from '../../__mocks__/userModel.js';
55
import updateOne from '../updateOne';
66
import Resolver from '../../../../graphql-compose/src/resolver/resolver';
7+
import TypeComposer from '../../../../graphql-compose/src/typeComposer';
78
import { convertModelToGraphQL } from '../../fieldsConverter';
9+
import { GraphQLString } from 'graphql';
810

911
const UserType = convertModelToGraphQL(UserModel, 'User');
1012

@@ -42,19 +44,28 @@ describe('updateOne() ->', () => {
4244
expect(resolver).to.be.instanceof(Resolver);
4345
});
4446

45-
it('Resolver object should have `filter` arg', () => {
46-
const resolver = updateOne(UserModel, UserType);
47-
expect(resolver.hasArg('filter')).to.be.true;
48-
});
47+
describe('Resolver.args', () => {
48+
it('should have `filter` arg', () => {
49+
const resolver = updateOne(UserModel, UserType);
50+
expect(resolver.hasArg('filter')).to.be.true;
51+
});
4952

50-
it('Resolver object should have `skip` arg', () => {
51-
const resolver = updateOne(UserModel, UserType);
52-
expect(resolver.hasArg('skip')).to.be.true;
53-
});
53+
it('should have `skip` arg', () => {
54+
const resolver = updateOne(UserModel, UserType);
55+
expect(resolver.hasArg('skip')).to.be.true;
56+
});
5457

55-
it('Resolver object should have `sort` arg', () => {
56-
const resolver = updateOne(UserModel, UserType);
57-
expect(resolver.hasArg('sort')).to.be.true;
58+
it('should have `sort` arg', () => {
59+
const resolver = updateOne(UserModel, UserType);
60+
expect(resolver.hasArg('sort')).to.be.true;
61+
});
62+
63+
it('should have `input` arg', () => {
64+
const resolver = updateOne(UserModel, UserType);
65+
expect(resolver.hasArg('input')).to.be.true;
66+
const argConfig = resolver.getArg('input');
67+
expect(argConfig).has.deep.property('type.name', 'UpdateOneUserInput');
68+
});
5869
});
5970

6071
describe('Resolver.resolve():Promise', () => {
@@ -140,4 +151,25 @@ describe('updateOne() ->', () => {
140151
expect(result1.record.id).to.not.equal(result2.record.id);
141152
});
142153
});
154+
155+
describe('Resolver.getOutputType()', () => {
156+
it('should have correct output type name', () => {
157+
const outputType = updateOne(UserModel, UserType).getOutputType();
158+
expect(outputType.name).to.equal(`UpdateOne${UserType.name}Payload`);
159+
});
160+
161+
it('should have recordId field', () => {
162+
const outputType = updateOne(UserModel, UserType).getOutputType();
163+
const typeComposer = new TypeComposer(outputType);
164+
expect(typeComposer.hasField('recordId')).to.be.true;
165+
expect(typeComposer.getField('recordId').type).to.equal(GraphQLString);
166+
});
167+
168+
it('should have record field', () => {
169+
const outputType = updateOne(UserModel, UserType).getOutputType();
170+
const typeComposer = new TypeComposer(outputType);
171+
expect(typeComposer.hasField('record')).to.be.true;
172+
expect(typeComposer.getField('record').type).to.equal(UserType);
173+
});
174+
});
143175
});

0 commit comments

Comments
 (0)