From 26eda4c6fea836cd93102afd0b3db757556c5d0b Mon Sep 17 00:00:00 2001 From: ssube Date: Fri, 15 Nov 2019 19:47:38 -0600 Subject: [PATCH] lint: split rule visitor tests --- test/rule/TestRule.ts | 171 +--------------------------------- test/rule/TestRuleVisitor.ts | 174 +++++++++++++++++++++++++++++++++++ 2 files changed, 175 insertions(+), 170 deletions(-) create mode 100644 test/rule/TestRuleVisitor.ts diff --git a/test/rule/TestRule.ts b/test/rule/TestRule.ts index fe62f3f..335bb60 100644 --- a/test/rule/TestRule.ts +++ b/test/rule/TestRule.ts @@ -1,11 +1,8 @@ import { expect } from 'chai'; -import { LogLevel, NullLogger } from 'noicejs'; -import { mock, spy, stub } from 'sinon'; +import { LogLevel } from 'noicejs'; import { createRuleSelector, createRuleSources, resolveRules } from '../../src/rule'; -import { RuleVisitor } from '../../src/rule/RuleVisitor'; import { SchemaRule } from '../../src/rule/SchemaRule'; -import { VisitorContext } from '../../src/visitor/VisitorContext'; import { describeLeaks, itLeaks } from '../helpers/async'; const TEST_RULES = [new SchemaRule({ @@ -102,172 +99,6 @@ describeLeaks('rule resolver', async () => { }); }); -describeLeaks('rule visitor', async () => { - itLeaks('should only call visit for selected items', async () => { - const ctx = new VisitorContext({ - logger: NullLogger.global, - schemaOptions: { - coerce: false, - defaults: false, - mutate: false, - }, - }); - const data = {}; - const rule = new SchemaRule({ - check: {}, - desc: '', - level: LogLevel.Info, - name: 'foo', - select: '$', - tags: [], - }); - - const mockRule = mock(rule); - mockRule.expects('visit').never(); - - const pickStub = mockRule.expects('pick').once().withArgs(ctx, data); - pickStub.onFirstCall().returns(Promise.resolve([])); - pickStub.throws(); - - const visitor = new RuleVisitor({ - rules: [rule], - }); - await visitor.visit(ctx, {}); - - mockRule.verify(); - expect(ctx.errors.length).to.equal(0); - }); - - itLeaks('should call visit for each selected item', async () => { - const ctx = new VisitorContext({ - logger: NullLogger.global, - schemaOptions: { - coerce: false, - defaults: false, - mutate: false, - }, - }); - const data = {}; - const rule = new SchemaRule({ - check: {}, - desc: '', - level: LogLevel.Info, - name: 'foo', - select: '$', - tags: [], - }); - - const mockRule = mock(rule); - - const pickStub = mockRule.expects('pick').once().withArgs(ctx, data); - pickStub.onFirstCall().returns(Promise.resolve([data])); - pickStub.throws(); - - const visitStub = mockRule.expects('visit').once().withArgs(ctx, data); - visitStub.onFirstCall().returns(Promise.resolve(ctx)); - visitStub.throws(); - - const visitor = new RuleVisitor({ - rules: [rule], - }); - await visitor.visit(ctx, {}); - - mockRule.verify(); - expect(ctx.errors.length).to.equal(0); - }); - - itLeaks('should visit individual items', async () => { - const ctx = new VisitorContext({ - logger: NullLogger.global, - schemaOptions: { - coerce: false, - defaults: false, - mutate: false, - }, - }); - const data = { - foo: [1, 2, 3], - }; - const rule = new SchemaRule({ - check: {}, - desc: '', - level: LogLevel.Info, - name: 'foo', - select: '$.foo.*', - tags: [], - }); - - const pickSpy = spy(rule, 'pick'); - const visitStub = stub(rule, 'visit').returns(Promise.resolve({ - changes: [], - errors: [], - })); - - const visitor = new RuleVisitor({ - rules: [rule], - }); - await visitor.visit(ctx, data); - - expect(pickSpy).to.have.callCount(1).and.to.have.been.calledWithExactly(ctx, data); - expect(visitStub).to.have.callCount(3); - }); - - itLeaks('should visit individual items', async () => { - const ctx = new VisitorContext({ - logger: NullLogger.global, - schemaOptions: { - coerce: false, - defaults: false, - mutate: false, - }, - }); - const data = { - foo: [1, 2, 3], - }; - const rule = new SchemaRule({ - check: {}, - desc: '', - level: LogLevel.Info, - name: 'foo', - select: '$.foo.*', - tags: [], - }); - - const visitStub = stub(rule, 'visit').returns(Promise.resolve({ - changes: [], - errors: [{ - data: {}, - level: LogLevel.Error, - msg: 'kaboom!', - }], - })); - - const visitor = new RuleVisitor({ - rules: [rule], - }); - await visitor.visit(ctx, data); - - expect(visitStub).to.have.callCount(3); - expect(ctx.errors.length).to.equal(3); - }); - - itLeaks('should not pick items', async () => { - const ctx = new VisitorContext({ - logger: NullLogger.global, - schemaOptions: { - coerce: false, - defaults: false, - mutate: false, - }, - }); - const visitor = new RuleVisitor({ - rules: [], - }); - - return expect(visitor.pick(ctx, {})).to.eventually.deep.equal([]); - }); -}); - describe('create rule sources helper', () => { it('should ensure every field is an array', () => { const sources = createRuleSources({}); diff --git a/test/rule/TestRuleVisitor.ts b/test/rule/TestRuleVisitor.ts new file mode 100644 index 0000000..444414d --- /dev/null +++ b/test/rule/TestRuleVisitor.ts @@ -0,0 +1,174 @@ +import { expect } from 'chai'; +import { LogLevel, NullLogger } from 'noicejs'; +import { mock, spy, stub } from 'sinon'; + +import { RuleVisitor } from '../../src/rule/RuleVisitor'; +import { SchemaRule } from '../../src/rule/SchemaRule'; +import { VisitorContext } from '../../src/visitor/VisitorContext'; +import { describeLeaks, itLeaks } from '../helpers/async'; + +describeLeaks('rule visitor', async () => { + itLeaks('should only call visit for selected items', async () => { + const ctx = new VisitorContext({ + logger: NullLogger.global, + schemaOptions: { + coerce: false, + defaults: false, + mutate: false, + }, + }); + const data = {}; + const rule = new SchemaRule({ + check: {}, + desc: '', + level: LogLevel.Info, + name: 'foo', + select: '$', + tags: [], + }); + + const mockRule = mock(rule); + mockRule.expects('visit').never(); + + const pickStub = mockRule.expects('pick').once().withArgs(ctx, data); + pickStub.onFirstCall().returns(Promise.resolve([])); + pickStub.throws(); + + const visitor = new RuleVisitor({ + rules: [rule], + }); + await visitor.visit(ctx, {}); + + mockRule.verify(); + expect(ctx.errors.length).to.equal(0); + }); + + itLeaks('should call visit for each selected item', async () => { + const ctx = new VisitorContext({ + logger: NullLogger.global, + schemaOptions: { + coerce: false, + defaults: false, + mutate: false, + }, + }); + const data = {}; + const rule = new SchemaRule({ + check: {}, + desc: '', + level: LogLevel.Info, + name: 'foo', + select: '$', + tags: [], + }); + + const mockRule = mock(rule); + + const pickStub = mockRule.expects('pick').once().withArgs(ctx, data); + pickStub.onFirstCall().returns(Promise.resolve([data])); + pickStub.throws(); + + const visitStub = mockRule.expects('visit').once().withArgs(ctx, data); + visitStub.onFirstCall().returns(Promise.resolve(ctx)); + visitStub.throws(); + + const visitor = new RuleVisitor({ + rules: [rule], + }); + await visitor.visit(ctx, {}); + + mockRule.verify(); + expect(ctx.errors.length).to.equal(0); + }); + + itLeaks('should visit individual items', async () => { + const ctx = new VisitorContext({ + logger: NullLogger.global, + schemaOptions: { + coerce: false, + defaults: false, + mutate: false, + }, + }); + const data = { + foo: [1, 2, 3], + }; + const rule = new SchemaRule({ + check: {}, + desc: '', + level: LogLevel.Info, + name: 'foo', + select: '$.foo.*', + tags: [], + }); + + const pickSpy = spy(rule, 'pick'); + const visitStub = stub(rule, 'visit').returns(Promise.resolve({ + changes: [], + errors: [], + })); + + const visitor = new RuleVisitor({ + rules: [rule], + }); + await visitor.visit(ctx, data); + + expect(pickSpy).to.have.callCount(1).and.to.have.been.calledWithExactly(ctx, data); + expect(visitStub).to.have.callCount(3); + }); + + itLeaks('should visit individual items', async () => { + const ctx = new VisitorContext({ + logger: NullLogger.global, + schemaOptions: { + coerce: false, + defaults: false, + mutate: false, + }, + }); + const data = { + foo: [1, 2, 3], + }; + const rule = new SchemaRule({ + check: {}, + desc: '', + level: LogLevel.Info, + name: 'foo', + select: '$.foo.*', + tags: [], + }); + + const visitStub = stub(rule, 'visit').returns(Promise.resolve({ + changes: [], + errors: [{ + data: {}, + level: LogLevel.Error, + msg: 'kaboom!', + }], + })); + + const visitor = new RuleVisitor({ + rules: [rule], + }); + await visitor.visit(ctx, data); + + expect(visitStub).to.have.callCount(3); + expect(ctx.errors.length).to.equal(3); + }); + + itLeaks('should not pick items', async () => { + const ctx = new VisitorContext({ + logger: NullLogger.global, + schemaOptions: { + coerce: false, + defaults: false, + mutate: false, + }, + }); + const visitor = new RuleVisitor({ + rules: [], + }); + + return expect(visitor.pick(ctx, {})).to.eventually.deep.equal([]); + }); +});