Current Dev State

static/js/ketcher2/node_modules/gulp-cond/tests/index.mocha.js

@@ -0,0 +1,294 @@
+'use strict';
+
+var StreamTest = require('streamtest');
+var assert = require('assert');
+var gulpCond = require('../src');
+var Stream = require('readable-stream');
+var File = require('vinyl');
+
+function getStream(version) {
+  return StreamTest[version].fromObjects([
+    new File({
+      path: 'file.foo',
+      contents: null
+    }),
+    new File({
+      path: 'file.foo',
+      contents: null
+    }),
+    new File({
+      path: 'file.foo',
+      contents: null
+    })
+  ]);
+}
+
+function getTrans(prefix) {
+  return Stream.Transform({
+    objectMode: true,
+    transform: function(file, unused, cb) {
+      file.path = prefix + file.path;
+      cb(null, file);
+    }
+  });
+}
+
+describe('gulp-cond', function() {
+
+  StreamTest.versions.forEach(function (version) {
+
+    describe('for ' + version + ' streams', function() {
+
+      describe('with a valid condition', function() {
+
+        describe('as a value', function() {
+
+          it('should work with stream', function(done) {
+            var n = 0;
+            var ended1 = false;
+            var ended2 = false;
+
+            getStream(version)
+              .pipe(gulpCond(true, getTrans('1').once('end', function() {
+                ended1 = true;
+              }), getTrans('2').once('end', function() {
+                ended2 = true;
+              })))
+              .pipe(StreamTest[version].toObjects(function(err, objs) {
+                objs.forEach(function (file) {
+                  assert.equal(file.path, '1file.foo');
+                  assert.equal(file.contents, null);
+                  n++;
+                });
+                assert.equal(ended1, true);
+                assert.equal(ended2, false);
+                assert.equal(n, 3);
+                done();
+              }));
+          });
+
+          it('should work with fn returning a stream', function(done) {
+            var n = 0;
+
+            getStream(version)
+              .pipe(gulpCond(true, getTrans.bind(null, '1'), getTrans.bind(null, '2')))
+              .pipe(StreamTest[version].toObjects(function(err, objs) {
+                objs.forEach(function (file) {
+                  assert.equal(file.path, '1file.foo');
+                  assert.equal(file.contents, null);
+                  n++;
+                });
+                assert.equal(n, 3);
+                done();
+              }));
+          });
+
+        });
+
+      });
+
+      describe('as a function', function() {
+
+        it('should work', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return true;
+            }, getTrans('1'), getTrans('2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '1file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+        it('should work with fn returning a stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return true;
+            }, getTrans.bind(null, '1'), getTrans.bind(null, '2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '1file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+      });
+
+    });
+
+    describe('with an invalid condition and a expr2', function() {
+
+      describe('as a value', function() {
+
+        it('should work with stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(false, getTrans('1'), getTrans('2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '2file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+        it('should work with fn returning a stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(false, getTrans.bind(null, '1'), getTrans.bind(null, '2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '2file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+      });
+
+      describe('as a function', function() {
+
+        it('should work', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return false;
+            }, getTrans('1'), getTrans('2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '2file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+        it('should work with fn returning a stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return false;
+            }, getTrans.bind(null, '1'), getTrans.bind(null, '2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '2file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+      });
+
+    });
+
+    describe('with an invalid condition and no expr2', function() {
+
+      describe('as a value', function() {
+
+        it('should work with stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(false, getTrans('1')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, 'file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+        it('should work with fn returning a stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(false, getTrans.bind(null, '1')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, 'file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+      });
+
+      describe('as a function', function() {
+
+        it('should work', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return false;
+            }, getTrans('1')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, 'file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+        it('should work with fn returning a stream', function(done) {
+          var n = 0;
+
+          getStream(version)
+            .pipe(gulpCond(function () {
+              return false;
+            }, getTrans.bind(null, '1'), getTrans.bind(null, '2')))
+            .pipe(StreamTest[version].toObjects(function(err, objs) {
+              objs.forEach(function (file) {
+                assert.equal(file.path, '2file.foo');
+                assert.equal(file.contents, null);
+                n++;
+              });
+              assert.equal(n, 3);
+              done();
+            }));
+        });
+
+      });
+
+    });
+
+  });
+
+});