minimum_viable_product 0.0.10 → 0.0.11

data/test/dummy/node_modules/asn1.js/test/error-test.js

@@ -0,0 +1,222 @@
+var assert = require('assert');
+var asn1 = require('..');
+var bn = asn1.bignum;
+var fixtures = require('./fixtures');
+var jsonEqual = fixtures.jsonEqual;
+
+var Buffer = require('buffer').Buffer;
+
+describe('asn1.js error', function() {
+  describe('encoder', function() {
+    function test(name, model, input, expected) {
+      it('should support ' + name, function() {
+        var M = asn1.define('TestModel', model);
+
+        var error;
+        assert.throws(function() {
+          try {
+            var encoded = M.encode(input, 'der');
+          } catch (e) {
+            error = e;
+            throw e;
+          }
+        });
+
+        assert(expected.test(error.stack),
+               'Failed to match, expected: ' + expected + ' got: ' +
+                   JSON.stringify(error.stack));
+      });
+    }
+
+    describe('primitives', function() {
+      test('int', function() {
+        this.int();
+      }, 'hello', /no values map/i);
+
+      test('enum', function() {
+        this.enum({ 0: 'hello', 1: 'world' });
+      }, 'gosh', /contain: "gosh"/);
+
+      test('objid', function() {
+        this.objid();
+      }, 1, /objid\(\) should be either array or string, got: 1/);
+
+      test('numstr', function() {
+        this.numstr();
+      }, 'hello', /only digits and space/);
+
+      test('printstr', function() {
+        this.printstr();
+      }, 'hello!', /only latin upper and lower case letters/);
+    });
+
+    describe('composite', function() {
+      test('shallow', function() {
+        this.seq().obj(
+          this.key('key').int()
+        );
+      }, { key: 'hello' } , /map at: \["key"\]/i);
+
+      test('deep and empty', function() {
+        this.seq().obj(
+          this.key('a').seq().obj(
+            this.key('b').seq().obj(
+              this.key('c').int()
+            )
+          )
+        );
+      }, { } , /input is not object at: \["a"\]\["b"\]/i);
+
+      test('deep', function() {
+        this.seq().obj(
+          this.key('a').seq().obj(
+            this.key('b').seq().obj(
+              this.key('c').int()
+            )
+          )
+        );
+      }, { a: { b: { c: 'hello' } } } , /map at: \["a"\]\["b"\]\["c"\]/i);
+
+      test('use', function() {
+        var S = asn1.define('S', function() {
+          this.seq().obj(
+            this.key('x').int()
+          );
+        });
+
+        this.seq().obj(
+          this.key('a').seq().obj(
+            this.key('b').use(S)
+          )
+        );
+      }, { a: { b: { x: 'hello' } } } , /map at: \["a"\]\["b"\]\["x"\]/i);
+    });
+  });
+
+  describe('decoder', function() {
+    function test(name, model, input, expected) {
+      it('should support ' + name, function() {
+        var M = asn1.define('TestModel', model);
+
+        var error;
+        assert.throws(function() {
+          try {
+            var decoded = M.decode(new Buffer(input, 'hex'), 'der');
+          } catch (e) {
+            error = e;
+            throw e;
+          }
+        });
+        var partial = M.decode(new Buffer(input, 'hex'), 'der', {
+          partial: true
+        });
+
+        assert(expected.test(error.stack),
+               'Failed to match, expected: ' + expected + ' got: ' +
+                   JSON.stringify(error.stack));
+
+        assert.equal(partial.errors.length, 1);
+        assert(expected.test(partial.errors[0].stack),
+               'Failed to match, expected: ' + expected + ' got: ' +
+                   JSON.stringify(partial.errors[0].stack));
+      });
+    }
+
+    describe('primitive', function() {
+      test('int', function() {
+        this.int();
+      }, '2201', /body of: "int"/);
+
+      test('int', function() {
+        this.int();
+      }, '', /tag of "int"/);
+
+      test('bmpstr invalid length', function() {
+        this.bmpstr();
+      }, '1e0b041f04400438043204350442', /bmpstr length mismatch/);
+
+      test('numstr unsupported characters', function() {
+        this.numstr();
+      }, '12024141', /numstr unsupported characters/);
+
+      test('printstr unsupported characters', function() {
+        this.printstr();
+      }, '13024121', /printstr unsupported characters/);
+    });
+
+    describe('composite', function() {
+      test('shallow', function() {
+        this.seq().obj(
+          this.key('a').seq().obj()
+        );
+      }, '30', /length of "seq"/);
+
+      test('deep and empty', function() {
+        this.seq().obj(
+          this.key('a').seq().obj(
+            this.key('b').seq().obj(
+              this.key('c').int()
+            )
+          )
+        );
+      }, '300430023000', /tag of "int" at: \["a"\]\["b"\]\["c"\]/);
+
+      test('deep and incomplete', function() {
+        this.seq().obj(
+          this.key('a').seq().obj(
+            this.key('b').seq().obj(
+              this.key('c').int()
+            )
+          )
+        );
+      }, '30053003300122', /length of "int" at: \["a"\]\["b"\]\["c"\]/);
+    });
+  });
+
+  describe('partial decoder', function() {
+    function test(name, model, input, expectedObj, expectedErrs) {
+      it('should support ' + name, function() {
+        var M = asn1.define('TestModel', model);
+
+        var decoded = M.decode(new Buffer(input, 'hex'), 'der', {
+          partial: true
+        });
+
+        jsonEqual(decoded.result, expectedObj);
+
+        assert.equal(decoded.errors.length, expectedErrs.length);
+        expectedErrs.forEach(function(expected, i) {
+          assert(expected.test(decoded.errors[i].stack),
+                 'Failed to match, expected: ' + expected + ' got: ' +
+                     JSON.stringify(decoded.errors[i].stack));
+        });
+      });
+    }
+
+    test('last key not present', function() {
+      this.seq().obj(
+        this.key('a').seq().obj(
+          this.key('b').seq().obj(
+            this.key('c').int()
+          ),
+          this.key('d').int()
+        )
+      );
+    }, '30073005300022012e', { a: { b: {}, d: new bn(46) } }, [
+      /"int" at: \["a"\]\["b"\]\["c"\]/
+    ]);
+
+    test('first key not present', function() {
+      this.seq().obj(
+        this.key('a').seq().obj(
+          this.key('b').seq().obj(
+            this.key('c').int()
+          ),
+          this.key('d').int()
+        )
+      );
+    }, '30073005300322012e', { a: { b: { c: new bn(46) } } }, [
+      /"int" at: \["a"\]\["d"\]/
+    ]);
+  });
+});

data/test/dummy/node_modules/asn1.js/test/fixtures.js

@@ -0,0 +1,7 @@
+var assert = require('assert');
+
+function jsonEqual(a, b) {
+  assert.deepEqual(JSON.parse(JSON.stringify(a)),
+                   JSON.parse(JSON.stringify(b)));
+}
+exports.jsonEqual = jsonEqual;

data/test/dummy/node_modules/asn1.js/test/pem-test.js

@@ -0,0 +1,54 @@
+var assert = require('assert');
+var asn1 = require('..');
+var BN = require('bn.js');
+
+var Buffer = require('buffer').Buffer;
+
+describe('asn1.js PEM encoder/decoder', function() {
+  var model = asn1.define('Model', function() {
+    this.seq().obj(
+      this.key('a').int(),
+      this.key('b').bitstr(),
+      this.key('c').int()
+    );
+  });
+
+  var hundred = new Buffer(100);
+  hundred.fill('A');
+
+  it('should encode PEM', function() {
+
+    var out = model.encode({
+      a: new BN(123),
+      b: {
+        data: hundred,
+        unused: 0
+      },
+      c: new BN(456)
+    }, 'pem', {
+      label: 'MODEL'
+    });
+
+    var expected =
+        '-----BEGIN MODEL-----\n' +
+        'MG4CAXsDZQBBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\n' +
+        'QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\n' +
+        'QUFBQUFBQUFBQUFBAgIByA==\n' +
+        '-----END MODEL-----';
+    assert.equal(out, expected);
+  });
+
+  it('should decode PEM', function() {
+    var expected =
+        '-----BEGIN MODEL-----\n' +
+        'MG4CAXsDZQBBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\n' +
+        'QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\n' +
+        'QUFBQUFBQUFBQUFBAgIByA==\n' +
+        '-----END MODEL-----';
+
+    var out = model.decode(expected, 'pem', { label: 'MODEL' });
+    assert.equal(out.a.toString(), '123');
+    assert.equal(out.b.data.toString(), hundred.toString());
+    assert.equal(out.c.toString(), '456');
+  });
+});

data/test/dummy/node_modules/asn1.js/test/ping-pong-test.js

@@ -0,0 +1,170 @@
+var assert = require('assert');
+var asn1 = require('..');
+var fixtures = require('./fixtures');
+var jsonEqual = fixtures.jsonEqual;
+
+var Buffer = require('buffer').Buffer;
+
+describe('asn1.js ping/pong', function() {
+  function test(name, model, input, expected) {
+    it('should support ' + name, function() {
+      var M = asn1.define('TestModel', model);
+
+      var encoded = M.encode(input, 'der');
+      var decoded = M.decode(encoded, 'der');
+      jsonEqual(decoded, expected !== undefined ? expected : input);
+    });
+  }
+
+  describe('primitives', function() {
+    test('bigint', function() {
+      this.int();
+    }, new asn1.bignum('0102030405060708', 16));
+
+    test('enum', function() {
+      this.enum({ 0: 'hello', 1: 'world' });
+    }, 'world');
+
+    test('octstr', function() {
+      this.octstr();
+    }, new Buffer('hello'));
+
+    test('bitstr', function() {
+      this.bitstr();
+    }, { unused: 4, data: new Buffer('hello!') });
+
+    test('ia5str', function() {
+      this.ia5str();
+    }, 'hello');
+
+    test('utf8str', function() {
+      this.utf8str();
+    }, 'hello');
+
+    test('bmpstr', function() {
+      this.bmpstr();
+    }, 'hello');
+
+    test('numstr', function() {
+      this.numstr();
+    }, '1234 5678 90');
+
+    test('printstr', function() {
+      this.printstr();
+    }, 'hello');
+
+    test('gentime', function() {
+      this.gentime();
+    }, 1385921175000);
+
+    test('utctime', function() {
+      this.utctime();
+    }, 1385921175000);
+
+    test('utctime regression', function() {
+      this.utctime();
+    }, 1414454400000);
+
+    test('null', function() {
+      this.null_();
+    }, null);
+
+    test('objid', function() {
+      this.objid({
+        '1 3 6 1 5 5 7 48 1 1': 'id-pkix-ocsp-basic'
+      });
+    }, 'id-pkix-ocsp-basic');
+
+    test('true', function() {
+      this.bool();
+    }, true);
+
+    test('false', function() {
+      this.bool();
+    }, false);
+
+    test('any', function() {
+      this.any();
+    }, new Buffer('02210081347a0d3d674aeeb563061d94a3aea5f6a7' +
+                  'c6dc153ea90a42c1ca41929ac1b9', 'hex'));
+
+    test('default explicit', function() {
+      this.seq().obj(
+        this.key('version').def('v1').explicit(0).int({
+          0: 'v1',
+          1: 'v2'
+        })
+      );
+    }, {}, {'version': 'v1'});
+
+    test('implicit', function() {
+      this.implicit(0).int({
+        0: 'v1',
+        1: 'v2'
+      });
+    }, 'v2', 'v2');
+  });
+
+  describe('composite', function() {
+    test('2x int', function() {
+      this.seq().obj(
+        this.key('hello').int(),
+        this.key('world').int()
+      );
+    }, { hello: 4, world: 2 });
+
+    test('enum', function() {
+      this.seq().obj(
+        this.key('hello').enum({ 0: 'world', 1: 'devs' })
+      );
+    }, { hello: 'devs' });
+
+    test('optionals', function() {
+      this.seq().obj(
+        this.key('hello').enum({ 0: 'world', 1: 'devs' }),
+        this.key('how').optional().def('are you').enum({
+          0: 'are you',
+          1: 'are we?!'
+        })
+      );
+    }, { hello: 'devs', how: 'are we?!' });
+
+    test('optionals #2', function() {
+      this.seq().obj(
+        this.key('hello').enum({ 0: 'world', 1: 'devs' }),
+        this.key('how').optional().def('are you').enum({
+          0: 'are you',
+          1: 'are we?!'
+        })
+      );
+    }, { hello: 'devs' }, { hello: 'devs', how: 'are you' });
+
+    test('optionals #3', function() {
+      this.seq().obj(
+        this.key('content').optional().int()
+      );
+    }, {}, {});
+
+    test('optional + any', function() {
+      this.seq().obj(
+        this.key('content').optional().any()
+      );
+    }, { content: new Buffer('0500', 'hex') });
+
+    test('seqof', function() {
+      var S = asn1.define('S', function() {
+        this.seq().obj(
+          this.key('a').def('b').int({ 0: 'a', 1: 'b' }),
+          this.key('c').def('d').int({ 2: 'c', 3: 'd' })
+        );
+      });
+      this.seqof(S);
+    }, [{}, { a: 'a', c: 'c' }], [{ a: 'b', c: 'd' }, { a: 'a', c: 'c' }]);
+
+    test('choice', function() {
+      this.choice({
+        apple: this.bool()
+      });
+    }, { type: 'apple', value: true });
+  });
+});