@nictool/dns-resource-record 1.1.7 → 1.2.1

package/test/key.js

@@ -1,37 +0,0 @@
-
-import * as base from './base.js'
-
-import KEY from '../rr/key.js'
-
-const validRecords = [
-  {
-    owner    : 'example.com.',
-    ttl      : 3600,
-    class    : 'IN',
-    type     : 'KEY',
-    flags    : 256,
-    protocol : 3,
-    algorithm: 5,
-    publickey: `( AQPSKmynfzW4kyBv015MUG2DeIQ3 Cbl+BBZH4b/0PY1kxkmvHjcZc8no kfzj31GajIQKY+5CptLr3buXA10h WqTkF7H6RfoRqXQeogmMHfpftf6z Mv1LyBUgia7za6ZEzOJBOztyvhjL 742iU/TpPSEDhm2SNKLijfUppn1U aNvv4w== )`,
-    testB    : 'example.com.\t3600\tIN\tKEY\t256\t3\t5\t( AQPSKmynfzW4kyBv015MUG2DeIQ3 Cbl+BBZH4b/0PY1kxkmvHjcZc8no kfzj31GajIQKY+5CptLr3buXA10h WqTkF7H6RfoRqXQeogmMHfpftf6z Mv1LyBUgia7za6ZEzOJBOztyvhjL 742iU/TpPSEDhm2SNKLijfUppn1U aNvv4w== )\n',
-  },
-]
-
-const invalidRecords = [
-]
-
-describe('KEY record', function () {
-  base.valid(KEY, validRecords)
-  base.invalid(KEY, invalidRecords, { ttl: 3600 })
-
-  base.getDescription(KEY)
-  base.getRFCs(KEY, validRecords[0])
-  base.getFields(KEY, [ 'flags', 'protocol', 'algorithm', 'publickey' ])
-  base.getTypeId(KEY, 25)
-
-  base.toBind(KEY, validRecords)
-  // base.toTinydns(KEY, validRecords)
-
-  base.fromBind(KEY, validRecords)
-  // base.fromTinydns(KEY, validRecords)
-})

package/test/loc.js

@@ -1,71 +0,0 @@
-
-import assert from 'assert'
-
-import * as base from './base.js'
-
-import LOC from '../rr/loc.js'
-
-const defaults = { class: 'IN', ttl: 3600, type: 'LOC' }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner  : 'loc.home.example.com.',
-    address: '47 43 47 N 122 21 35 W 132m 100m 100m 2m',
-    testB  : `loc.home.example.com.\t3600\tIN\tLOC\t47 43 47 N 122 21 35 W 132m 100m 100m 2m\n`,
-    testT  : ':loc.home.example.com:29:\\000\\024\\024\\042\\212\\075\\337\\070\\145\\276\\224\\150\\000\\230\\312\\020:3600::\n',
-  },
-  {
-    ...defaults,
-    owner  : 'cambridge-net.kei.com.',
-    address: '42 21 54 N 71 6 18 W -24m 30m',
-    testB  : 'cambridge-net.kei.com.\t3600\tIN\tLOC\t42 21 54 N 71 6 18 W -24m 30m\n',
-    testT  : ':cambridge-net.kei.com:29:\\000\\063\\000\\000\\211\\027\\055\\320\\160\\276\\025\\360\\000\\230\\215\\040:3600::\n',
-  },
-  {
-    ...defaults,
-    owner  : 'rwy04l.logan-airport.boston.',
-    address: '42 21 28.764 N 71 0 51.617 W -44m 2000m',
-    testB  : 'rwy04l.logan-airport.boston.\t3600\tIN\tLOC\t42 21 28.764 N 71 0 51.617 W -44m 2000m\n',
-    testT  : ':rwy04l.logan-airport.boston:29:\\000\\045\\000\\000\\211\\026\\313\\074\\160\\303\\020\\337\\000\\230\\205\\120:3600::\n',
-  },
-]
-
-const invalidRecords = [
-  {
-    ...defaults,
-    owner  : 'server.example.com.',
-    address: '', // empty
-    msg    : /address is required/,
-  },
-]
-
-describe('LOC record', function () {
-  base.valid(LOC, validRecords)
-  base.invalid(LOC, invalidRecords)
-
-  base.getDescription(LOC)
-  base.getRFCs(LOC, validRecords[0])
-  base.getFields(LOC, [ 'address' ])
-  base.getTypeId(LOC, 29)
-
-  base.toBind(LOC, validRecords)
-  base.toTinydns(LOC, validRecords)
-
-  describe('toExponent', function () {
-    const loc = new LOC(validRecords[0])
-    it('converts a SIZE/PREC to exponent format', function () {
-      assert.equal(loc.toExponent(100), 18)
-    })
-  })
-
-  describe('fromExponent', function () {
-    const loc = new LOC(validRecords[0])
-    it('decodes an exponent format to SIZE/PREC', function () {
-      assert.equal(loc.fromExponent(18), 100)
-    })
-  })
-
-  base.fromTinydns(LOC, validRecords)
-  base.fromBind(LOC, validRecords)
-})

package/test/mx.js

@@ -1,75 +0,0 @@
-
-import assert from 'assert'
-
-import * as base from './base.js'
-
-import MX from '../rr/mx.js'
-
-const defaults = { class: 'IN', ttl: 3600, type: 'MX', preference: 0 }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner     : 'test.example.com.',
-    preference: 0,
-    exchange  : 'mail.example.com.',
-    testB     : 'test.example.com.\t3600\tIN\tMX\t0\tmail.example.com.\n',
-    testT     : '@test.example.com::mail.example.com:0:3600::\n',
-  },
-  {
-    ...defaults,
-    owner     : 'www.example.com.',
-    ttl       : 86400,
-    preference: 0,
-    exchange  : '.', // null MX, RFC 7505
-    testB     : 'www.example.com.\t86400\tIN\tMX\t0\t.\n',
-    testT     : '@www.example.com::.:0:86400::\n',
-  },
-]
-
-const invalidRecords = [
-  {
-    ...defaults,
-    owner   : 'test.example.com.',
-    exchange: 'not-full-qualified.example.com',
-    msg     : /exchange must be fully qualified/,
-  },
-  {
-    ...defaults,
-    owner   : 'test.example.com.',
-    exchange: '192.0.2.1',
-    msg     : /exchange must be a FQDN/,
-  },
-  {
-    ...defaults,
-    owner   : 'test.example.com.',
-    exchange: '-blah',
-    msg     : /exchange must be fully qualified/,
-  },
-]
-
-describe('MX record', function () {
-  base.valid(MX, validRecords)
-  base.invalid(MX, invalidRecords)
-
-  base.getDescription(MX)
-  base.getRFCs(MX, validRecords[0])
-  base.getFields(MX, [ 'preference', 'exchange' ])
-  base.getTypeId(MX, 15)
-
-  base.toBind(MX, validRecords)
-  base.toTinydns(MX, validRecords)
-
-  base.fromBind(MX, validRecords)
-  base.fromTinydns(MX, validRecords)
-
-  for (const val of validRecords) {
-    it.skip(`imports tinydns MX (@) record (${val.owner})`, async function () {
-      const r = new MX({ tinyline: val.testT })
-      if (process.env.DEBUG) console.dir(r)
-      for (const f of [ 'owner', 'exchange', 'preference', 'ttl' ]) {
-        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
-      }
-    })
-  }
-})

package/test/naptr.js

@@ -1,40 +0,0 @@
-
-import * as base from './base.js'
-
-import NAPTR from '../rr/naptr.js'
-
-const validRecords = [
-  {
-    owner      : 'cid.urn.arpa.',
-    ttl        : 86400,
-    class      : 'IN',
-    type       : 'NAPTR',
-    order      : 100,
-    preference : 10,
-    flags      : '',
-    service    : '',
-    regexp     : '!^urn:cid:.+@([^\\.]+\\.)(.*)$!\x02!i',
-    replacement: '.',
-    testB      : 'cid.urn.arpa.\t86400\tIN\tNAPTR\t100\t10\t""\t""\t"!^urn:cid:.+@([^\\.]+\\.)(.*)$!\x02!i"\t.\n',
-    testT      : ':cid.urn.arpa:35:\\000\\144\\000\\012\\000\\000\\040!^urn\\072cid\\072.+@([^\\134.]+\\134.)(.*)$!\x02!i\\001.\\000:86400::\n',
-  },
-]
-
-const invalidRecords = [
-]
-
-describe('NAPTR record', function () {
-  base.valid(NAPTR, validRecords)
-  base.invalid(NAPTR, invalidRecords)
-
-  base.getDescription(NAPTR)
-  base.getRFCs(NAPTR, validRecords[0])
-  base.getFields(NAPTR, [ 'order', 'preference', 'flags', 'service', 'regexp', 'replacement' ])
-  base.getTypeId(NAPTR, 35)
-
-  base.toBind(NAPTR, validRecords)
-  base.toTinydns(NAPTR, validRecords)
-
-  base.fromBind(NAPTR, validRecords)
-  base.fromTinydns(NAPTR, validRecords)
-})

package/test/ns.js

@@ -1,53 +0,0 @@
-
-import assert from 'assert'
-
-import * as base from './base.js'
-
-import NS from '../rr/ns.js'
-
-const defaults = { class: 'IN', ttl: 3600, type: 'NS' }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner: 'example.com.',
-    dname: 'ns1.example.com.',
-    testB: 'example.com.\t3600\tIN\tNS\tns1.example.com.\n',
-    testT: '&example.com::ns1.example.com:3600::\n',
-  },
-]
-
-const invalidRecords = [
-  {
-    ...defaults,
-    owner: 'example.com.',
-    dname: '1.2.3.4',  // FQDN required
-    msg  : /dname must be fully qualified/,
-  },
-]
-
-describe('NS record', function () {
-  base.valid(NS, validRecords)
-  base.invalid(NS, invalidRecords)
-
-  base.getDescription(NS)
-  base.getRFCs(NS, validRecords[0])
-  base.getFields(NS, [ 'dname' ])
-  base.getTypeId(NS, 2)
-
-  base.toBind(NS, validRecords)
-  base.toTinydns(NS, validRecords)
-
-  base.fromBind(NS, validRecords)
-  base.fromTinydns(NS, validRecords)
-
-  for (const val of validRecords) {
-    it.skip(`imports tinydns NS (&) record (${val.owner})`, async function () {
-      const r = new NS({ tinyline: val.testT })
-      if (process.env.DEBUG) console.dir(r)
-      for (const f of [ 'owner', 'dname', 'ttl' ]) {
-        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
-      }
-    })
-  }
-})

package/test/nsec.js

@@ -1,38 +0,0 @@
-
-import * as base from './base.js'
-
-import NSEC from '../rr/nsec.js'
-
-const validRecords = [
-  {
-    owner          : 'alfa.example.com.',
-    ttl            : 86400,
-    class          : 'IN',
-    type           : 'NSEC',
-    'next domain'  : 'host.example.com.',
-    'type bit maps': 'A MX RRSIG NSEC TYPE1234',
-    testB          : `alfa.example.com.\t86400\tIN\tNSEC\thost.example.com.\tA MX RRSIG NSEC TYPE1234\n`,
-    // testT        : '\n',
-  },
-]
-
-const invalidRecords = [
-  // {
-  // },
-]
-
-describe('NSEC record', function () {
-  base.valid(NSEC, validRecords)
-  base.invalid(NSEC, invalidRecords, { ttl: 3600 })
-
-  base.getDescription(NSEC)
-  base.getRFCs(NSEC, validRecords[0])
-  base.getFields(NSEC, [ 'next domain', 'type bit maps' ])
-  base.getTypeId(NSEC, 47)
-
-  base.toBind(NSEC, validRecords)
-  // base.toTinydns(NSEC, validRecords)
-
-  base.fromBind(NSEC, validRecords)
-  // base.fromTinydns(NSEC, validRecords)
-})

package/test/nsec3.js

@@ -1,40 +0,0 @@
-
-import * as base from './base.js'
-
-import NSEC3 from '../rr/nsec3.js'
-
-const defaults = { class: 'IN', ttl: 3600, type: 'NSEC3' }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner                   : 'test.example.com.',
-    'hash algorithm'        : 1,
-    flags                   : 1,
-    iterations              : 12,
-    salt                    : 'aabbccdd',
-    'type bit maps'         : 'A\tRRSIG',
-    'next hashed owner name': '2vptu5timamqttgl4luu9kg21e0aor3s',
-    testB                   : 'test.example.com.\t3600\tIN\tNSEC3\t1\t1\t12\taabbccdd\t(2vptu5timamqttgl4luu9kg21e0aor3s\tA\tRRSIG)\n',
-    testT                   : ':test.example.com:50:\\001\\001\\000\\014aabbccdd2vptu5timamqttgl4luu9kg21e0aor3sA\\011RRSIG:3600::\n',
-  },
-]
-
-const invalidRecords = [
-]
-
-describe('NSEC3 record', function () {
-  base.valid(NSEC3, validRecords)
-  base.invalid(NSEC3, invalidRecords, { ttl: 3600 })
-
-  base.getDescription(NSEC3)
-  base.getRFCs(NSEC3, validRecords[0])
-  base.getFields(NSEC3, [ 'hash algorithm', 'flags', 'iterations', 'salt',  'next hashed owner name', 'type bit maps' ])
-  base.getTypeId(NSEC3, 50)
-
-  base.toBind(NSEC3, validRecords)
-  base.toTinydns(NSEC3, validRecords)
-
-  base.fromBind(NSEC3, validRecords)
-  // base.fromTinydns(NSEC3, validRecords)
-})

package/test/nsec3param.js

@@ -1,26 +0,0 @@
-
-import * as base from './base.js'
-
-import NSEC3PARAM from '../rr/nsec3param.js'
-
-const validRecords = [
-]
-
-const invalidRecords = [
-]
-
-describe('NSEC3PARAM record', function () {
-  base.valid(NSEC3PARAM, validRecords)
-  base.invalid(NSEC3PARAM, invalidRecords, { ttl: 3600 })
-
-  base.getDescription(NSEC3PARAM)
-  base.getRFCs(NSEC3PARAM, validRecords[0])
-  base.getFields(NSEC3PARAM, [ 'hash algorithm', 'flags', 'iterations', 'salt' ])
-  base.getTypeId(NSEC3PARAM, 51)
-
-  // base.toBind(NSEC3PARAM, validRecords)
-  // base.toTinydns(NSEC3PARAM, validRecords)
-
-  // base.fromBind(NSEC3PARAM, validRecords)
-  // base.fromTinydns(NSEC3PARAM, validRecords)
-})

package/test/openpgpkey.js

@@ -1,35 +0,0 @@
-
-import * as base from './base.js'
-
-import OPENPGPKEY from '../rr/openpgpkey.js'
-
-const validRecords = [
-  // {
-  //   owner    : 'example.com.',
-  //   ttl      : 3600,
-  //   class    : 'IN',
-  //   type     : 'OPENPGPKEY',
-  //   'public key': ``,
-  //   testB    : '',
-  //   testT    : '',
-  // },
-]
-
-const invalidRecords = [
-]
-
-describe('OPENPGPKEY record', function () {
-  base.valid(OPENPGPKEY, validRecords)
-  base.invalid(OPENPGPKEY, invalidRecords, { ttl: 3600 })
-
-  base.getDescription(OPENPGPKEY)
-  base.getRFCs(OPENPGPKEY)
-  base.getFields(OPENPGPKEY, [ 'public key' ])
-  base.getTypeId(OPENPGPKEY, 61)
-
-  base.toBind(OPENPGPKEY, validRecords)
-  // base.toTinydns(OPENPGPKEY, validRecords)
-
-  base.fromBind(OPENPGPKEY, validRecords)
-  // base.fromTinydns(OPENPGPKEY, validRecords)
-})

package/test/ptr.js

@@ -1,54 +0,0 @@
-
-import assert from 'assert'
-
-import * as base from './base.js'
-
-import PTR from '../rr/ptr.js'
-
-const defaults = { class: 'IN', ttl: 86400, type: 'PTR' }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner: '2.2.0.192.in-addr.arpa.',
-    dname: 'dhcp.example.com.',
-    testB: '2.2.0.192.in-addr.arpa.\t86400\tIN\tPTR\tdhcp.example.com.\n',
-    testT: '^2.2.0.192.in-addr.arpa:dhcp.example.com:86400::\n',
-  },
-]
-
-const invalidRecords = [
-  {
-    ...defaults,
-    owner: 'example.com.',
-    dname: '192.0.2.4',  // FQDN required
-    msg  : /dname must be fully qualified/,
-  },
-]
-
-describe('PTR record', function () {
-  base.valid(PTR, validRecords)
-  base.invalid(PTR, invalidRecords)
-
-  base.getDescription(PTR)
-  base.getRFCs(PTR, validRecords[0])
-  base.getFields(PTR, [ 'dname' ])
-  base.getTypeId(PTR, 12)
-
-  base.toBind(PTR, validRecords)
-  base.toTinydns(PTR, validRecords)
-
-  base.fromBind(PTR, validRecords)
-  base.fromTinydns(PTR, validRecords)
-
-  for (const val of validRecords) {
-
-    it.skip(`imports tinydns PTR (^) record (${val.owner})`, async function () {
-      const r = new PTR({ tinyline: val.testT })
-      if (process.env.DEBUG) console.dir(r)
-      for (const f of [ 'owner', 'dname', 'ttl' ]) {
-        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
-      }
-    })
-  }
-})

package/test/rr.js

@@ -1,196 +0,0 @@
-
-import assert from 'assert'
-
-import RR from '../rr.js'
-import A  from '../rr/a.js'
-
-const cases = [
-  // { name: 'RR class'   , obj: RR          , expect: [ 'owner', 'ttl', 'class', 'type' ] },
-  { name: 'RR instance', obj: new RR(null), expect: [ 'owner', 'ttl', 'class', 'type' ] },
-  // { name: 'A class'    , obj: A           , expect: [ 'owner', 'ttl', 'class', 'type', 'address' ] },
-  { name: 'A instance' , obj: new A(null) , expect: [ 'owner', 'ttl', 'class', 'type', 'address' ] },
-]
-
-for (const c of cases) {
-  describe(`${c.name}`, function () {
-    describe('getFields', function () {
-      it('gets expected fields', async function () {
-        assert.deepStrictEqual(c.obj.getFields(), c.expect)
-      })
-    })
-  })
-}
-
-describe('RR', function () {
-  const r = new RR(null)
-
-  describe('setTtl', function () {
-    const invalid = [ -1, -4, -299, 2147483648, undefined ]
-    for (const i of invalid) {
-      it(`throws on invalid TTL: ${i}`, async function () {
-        try {
-          assert.deepStrictEqual(r.setTtl(i), false)
-        }
-        catch (e) {
-          assert.ok(e.message)
-          console.error(e.message)
-        }
-      })
-    }
-  })
-
-  describe('setClass', function () {
-    for (const i of [ 'IN', 'CH', 'ANY', 'NONE' ]) {
-      it(`accepts valid class: ${i}`, async function () {
-        r.setClass(i)
-        assert.deepEqual(r.get('class'), i)
-      })
-    }
-
-    for (const i of [ 'matt', 'in', 0 ]) {
-      it(`throws on invalid class: ${i}`, async function () {
-        try {
-          assert.strictEqual(r.setClass(i), false)
-        }
-        catch (e) {
-          assert.ok(e.message)
-        }
-      })
-    }
-  })
-
-  describe('fullyQualify', function () {
-    it('does nothing to empty  hostname', async () => {
-      assert.equal(r.fullyQualify(''), '')
-    })
-
-    it('fully qualifies a valid hostname', async () => {
-      assert.equal(r.fullyQualify('example.com'), 'example.com.')
-    })
-  })
-
-  describe('getFQDN', function () {
-    it('adds a period to hostnames', async () => {
-      const rr = new RR(null)
-      rr.set('owner', 'www.example.com') // bypass FQ check
-      assert.equal(rr.getFQDN('owner'), 'www.example.com.')
-    })
-
-    it('reduces origin on request', async () => {
-      const rr = new RR(null)
-      const zone_opts = { origin: 'example.com.', hide: { origin: true } }
-      rr.setOwner('www.example.com.')
-      assert.equal(rr.getFQDN('owner', zone_opts), 'www')
-    })
-  })
-
-  describe('isFullyQualified', function () {
-    it('should detect FQDNs', async function () {
-      assert.deepEqual(r.isFullyQualified('$type', '$field', 'host.example.com.'), true)
-
-      try {
-        assert.deepEqual(r.isFullyQualified('$type', '$field', 'host.example.com'), false)
-      }
-      catch (e) {
-        assert.deepEqual(e.message, '$type: $field must be fully qualified')
-      }
-    })
-  })
-
-  describe('is8bitInt', function () {
-    const valid = [ 1, 2, 255 ]
-    const invalid = [ -1, 'a', new Date(), undefined, 256 ]
-
-    for (const i of valid) {
-      it(`returns true for valid int: ${i}`, async function () {
-        assert.strictEqual(r.is8bitInt('test', 'field', i), true)
-      })
-    }
-
-    for (const i of invalid) {
-      it(`throws on invalid int: ${i}`, async function () {
-        try {
-          assert.strictEqual(r.is8bitInt('test', 'field', i), false)
-        }
-        catch (e) {
-          assert.strictEqual(e.message, 'test field must be a 8-bit integer (in the range 0-255)')
-        }
-      })
-    }
-  })
-
-  describe('is16bitInt', function () {
-    const valid = [ 0, 1, 2, 55555, 65535 ]
-    const invalid = [ 'a', new Date(), undefined, 65536 ]
-
-    for (const i of valid) {
-      it(`returns true for valid int: ${i}`, async function () {
-        assert.strictEqual(r.is16bitInt('test', 'field', i), true)
-      })
-    }
-
-    for (const i of invalid) {
-      it(`throws on invalid int: ${i}`, async function () {
-        try {
-          assert.strictEqual(r.is16bitInt('test', 'field', i), false)
-        }
-        catch (e) {
-          assert.strictEqual(e.message, 'test field must be a 16-bit integer (in the range 0-65535)')
-        }
-      })
-    }
-  })
-
-  describe('is32bitInt', function () {
-    const valid = [ 1, 2, 55555, 2147483647 ]
-    const invalid = [ 'a', new Date(), undefined, 2147483648 ]
-
-    for (const i of valid) {
-      it(`returns true for valid int: ${i}`, async function () {
-        assert.strictEqual(r.is32bitInt('test', 'field', i), true)
-      })
-    }
-
-    for (const i of invalid) {
-      it(`throws on invalid int: ${i}`, async function () {
-        try {
-          assert.strictEqual(r.is32bitInt('test', 'field', i), false)
-        }
-        catch (e) {
-          assert.strictEqual(e.message, 'test field must be a 32-bit integer (in the range 0-2147483647)')
-        }
-      })
-    }
-  })
-
-  describe('getQuoted', function () {
-    it('returns a quoted string', async () => {
-      r.set('cpu', '"already quoted"')
-      assert.equal(r.get('cpu'), '"already quoted"')
-      assert.equal(r.getQuoted('cpu'), '"already quoted"') // doesn't double quote
-    })
-
-    it('doesn\'t double quote a quoted string', async () => {
-      r.set('cpu', '"already quoted"')
-      assert.equal(r.getQuoted('cpu'), '"already quoted"')
-    })
-  })
-
-  describe('isQuoted', function () {
-    it('detects a quoted strings', async function () {
-      assert.deepEqual(r.isQuoted('"yes, this is"'), true)
-    })
-
-    it('detects non-quoted strings', async function () {
-      assert.deepEqual(r.isQuoted('nope, not quoted'), false)
-    })
-  })
-
-  describe('isValidHostname', function () {
-    for (const n of [ 'x', '2x', '*', '*.something' ]) {
-      it(`passes name: ${n}`, async function () {
-        assert.deepEqual(r.isValidHostname(n), true)
-      })
-    }
-  })
-})