Start tests

tests/util/support/Pipe.test.ts

@@ -0,0 +1,249 @@
+import { expect } from 'chai'
+import * as sinon from 'sinon'
+import { Pipe, AsyncPipe } from '../../../lib'
+
+describe('util -> support -> Pipe', () => {
+    describe('static.wrap', () => {
+        it('should return a Pipe containing the input value', () => {
+            const sym = Symbol()
+            const pipe = Pipe.wrap(sym)
+            expect(pipe).to.be.an.instanceof(Pipe)
+            expect(pipe.get()).to.be.equal(sym)
+        })
+    })
+
+    describe('constructor', () => {
+        it('should instantiate a Pipe with the input value', () => {
+            const sym = Symbol()
+            const pipe = new Pipe(sym)
+            expect(pipe).to.be.an.instanceof(Pipe)
+            expect(pipe.get()).to.be.equal(sym)
+        })
+    })
+
+    describe('tap', () => {
+        const pipe = Pipe.wrap(123)
+
+        it('should call the input operator with the value of the pipe', () => {
+            const spy = sinon.spy()
+            pipe.tap(spy)
+            expect(spy.callCount).to.be.equal(1)
+            expect(spy.firstCall.firstArg).to.be.equal(123)
+        })
+
+        it('should return a new Pipe', () => {
+            const ret = pipe.tap(x => x)
+            expect(ret).to.be.an.instanceof(Pipe)
+            expect(ret).to.not.be.equal(pipe)
+        })
+
+        it('should return the operator value in the new pipe', () => {
+            const ret = pipe.tap(() => 456)
+            expect(ret.get()).to.be.equal(456)
+        })
+
+        it('should not modify the base pipe', () => {
+            pipe.tap(() => false)
+            expect(pipe.get()).to.be.equal(123)
+        })
+    })
+
+    describe('peek', () => {
+        const pipe = Pipe.wrap(123)
+
+        it('should call the input operator with the value of the pipe', () => {
+            const spy = sinon.spy()
+            pipe.peek(spy)
+            expect(spy.callCount).to.be.equal(1)
+            expect(spy.firstCall.firstArg).to.be.equal(123)
+        })
+
+        it('should return the same pipe', () => {
+            const ret = pipe.peek(x => x)
+            expect(ret).to.be.eql(pipe)
+        })
+
+        it('should not modify the base pipe', () => {
+            pipe.peek(() => false)
+            expect(pipe.get()).to.be.equal(123)
+        })
+    })
+
+    describe('when', () => {
+        const pipe = Pipe.wrap(123)
+
+        describe('condition is true', () => {
+            it('should call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.when(true, spy)
+                expect(spy.callCount).to.be.equal(1)
+                expect(spy.firstCall.firstArg).to.be.equal(123)
+            })
+
+            it('should return a new Pipe', () => {
+                const ret = pipe.when(true, x => x)
+                expect(ret).to.be.an.instanceof(Pipe)
+                expect(ret).to.not.be.equal(pipe)
+            })
+
+            it('should return the operator value in the new pipe', () => {
+                const ret = pipe.when(true, () => 456)
+                expect(ret.get()).to.be.equal(456)
+            })
+
+            it('should not modify the base pipe', () => {
+                pipe.when(true, () => 456)
+                expect(pipe.get()).to.be.equal(123)
+            })
+        })
+
+        describe('condition evaluates to true', () => {
+            it('should call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.when(() => true, spy)
+                expect(spy.callCount).to.be.equal(1)
+                expect(spy.firstCall.firstArg).to.be.equal(123)
+            })
+
+            it('should return a new Pipe', () => {
+                const ret = pipe.when(() => true, x => x)
+                expect(ret).to.be.an.instanceof(Pipe)
+                expect(ret).to.not.be.equal(pipe)
+            })
+
+            it('should return the operator value in the new pipe', () => {
+                const ret = pipe.when(() => true, () => 456)
+                expect(ret.get()).to.be.equal(456)
+            })
+
+            it('should not modify the base pipe', () => {
+                pipe.when(() => true, () => 456)
+                expect(pipe.get()).to.be.equal(123)
+            })
+        })
+
+        describe('condition is false', () => {
+            it('should not call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.when(false, spy)
+                expect(spy.callCount).to.be.equal(0)
+            })
+
+            it('should return the same Pipe', () => {
+                const ret = pipe.when(false, x => x)
+                expect(ret).to.be.equal(pipe)
+            })
+        })
+
+        describe('condition evaluates to false', () => {
+            it('should not call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.when(() => false, spy)
+                expect(spy.callCount).to.be.equal(0)
+            })
+
+            it('should return the same Pipe', () => {
+                const ret = pipe.when(() => false, x => x)
+                expect(ret).to.be.equal(pipe)
+            })
+        })
+    })
+
+    describe('unless', () => {
+        const pipe = Pipe.wrap(123)
+
+        describe('condition is false', () => {
+            it('should call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.unless(false, spy)
+                expect(spy.callCount).to.be.equal(1)
+                expect(spy.firstCall.firstArg).to.be.equal(123)
+            })
+
+            it('should return a new Pipe', () => {
+                const ret = pipe.unless(false, x => x)
+                expect(ret).to.be.an.instanceof(Pipe)
+                expect(ret).to.not.be.equal(pipe)
+            })
+
+            it('should return the operator value in the new pipe', () => {
+                const ret = pipe.unless(false, () => 456)
+                expect(ret.get()).to.be.equal(456)
+            })
+
+            it('should not modify the base pipe', () => {
+                pipe.unless(false, () => 456)
+                expect(pipe.get()).to.be.equal(123)
+            })
+        })
+
+        describe('condition evaluates to false', () => {
+            it('should call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.unless(() => false, spy)
+                expect(spy.callCount).to.be.equal(1)
+                expect(spy.firstCall.firstArg).to.be.equal(123)
+            })
+
+            it('should return a new Pipe', () => {
+                const ret = pipe.unless(() => false, x => x)
+                expect(ret).to.be.an.instanceof(Pipe)
+                expect(ret).to.not.be.equal(pipe)
+            })
+
+            it('should return the operator value in the new pipe', () => {
+                const ret = pipe.unless(() => false, () => 456)
+                expect(ret.get()).to.be.equal(456)
+            })
+
+            it('should not modify the base pipe', () => {
+                pipe.unless(() => false, () => 456)
+                expect(pipe.get()).to.be.equal(123)
+            })
+        })
+
+        describe('condition is true', () => {
+            it('should not call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.unless(true, spy)
+                expect(spy.callCount).to.be.equal(0)
+            })
+
+            it('should return the same Pipe', () => {
+                const ret = pipe.unless(true, x => x)
+                expect(ret).to.be.equal(pipe)
+            })
+        })
+
+        describe('condition evaluates to true', () => {
+            it('should not call the input operator with the value of the pipe', () => {
+                const spy = sinon.spy()
+                pipe.unless(() => true, spy)
+                expect(spy.callCount).to.be.equal(0)
+            })
+
+            it('should return the same Pipe', () => {
+                const ret = pipe.unless(() => true, x => x)
+                expect(ret).to.be.equal(pipe)
+            })
+        })
+    })
+
+    describe('get', () => {
+        it('should return the value in the pipe', () => {
+            expect(Pipe.wrap(123).get())
+                .to.be.equal(123)
+
+            const sym = Symbol()
+            expect(Pipe.wrap(sym).get())
+                .to.be.eql(sym)
+        })
+    })
+
+    describe('async', () => {
+        it('should return an async pipe', () => {
+            expect(Pipe.wrap(123).async())
+                .to.be.an.instanceof(AsyncPipe)
+        })
+    })
+})