@nictool/dns-resource-record 1.1.3

package/test/ns.js

@@ -0,0 +1,53 @@
+
+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

@@ -0,0 +1,38 @@
+
+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

@@ -0,0 +1,26 @@
+
+import * as base from './base.js'
+
+import NSEC3 from '../rr/nsec3.js'
+
+const validRecords = [
+]
+
+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

@@ -0,0 +1,26 @@
+
+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

@@ -0,0 +1,35 @@
+
+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

@@ -0,0 +1,54 @@
+
+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

@@ -0,0 +1,196 @@
+
+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)
+      })
+    }
+  })
+})

package/test/smimea.js

@@ -0,0 +1,45 @@
+
+import * as base from './base.js'
+
+import SMIMEA from '../rr/smimea.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'SMIMEA' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner                         : '_443._tcp.www.example.com.',
+    ttl                           : 3600,
+    'certificate usage'           : 0,
+    selector                      : 0,
+    'matching type'               : 1,
+    'certificate association data': '( d2abde240d7cd3ee6b4b28c54df034b9 7983a1d16e8a410e4561cb106618e971 )',
+    testB                         : '_443._tcp.www.example.com.\t3600\tIN\tSMIMEA\t0\t0\t1\t( d2abde240d7cd3ee6b4b28c54df034b9 7983a1d16e8a410e4561cb106618e971 )\n',
+    // testT                      : '',
+  },
+]
+
+const invalidRecords = [
+  {
+    ...defaults,
+    owner   : 'test.example.com.',
+    selector: 6,  // invalid
+    msg     : /certificate usage invalid/,
+  },
+]
+
+describe('SMIMEA record', function () {
+  base.valid(SMIMEA, validRecords)
+  base.invalid(SMIMEA, invalidRecords)
+
+  base.getDescription(SMIMEA)
+  base.getRFCs(SMIMEA, validRecords[0])
+  base.getFields(SMIMEA, [ 'certificate usage', 'selector', 'matching type', 'certificate association data' ])
+  base.getTypeId(SMIMEA, 53)
+
+  base.toBind(SMIMEA, validRecords)
+  // base.toTinydns(SMIMEA, validRecords)
+
+  base.fromBind(SMIMEA, validRecords)
+  // base.fromTinydns(SMIMEA, validRecords)
+})

package/test/soa.js

@@ -0,0 +1,77 @@
+
+import assert from 'assert'
+
+import * as base from './base.js'
+
+import SOA from '../rr/soa.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'SOA' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner  : 'example.com.',
+    mname  : 'ns1.example.com.',
+    rname  : 'matt.example.com.',
+    serial : 1,
+    refresh: 7200,
+    retry  : 3600,
+    expire : 1209600,
+    minimum: 3600,
+    testB  : `example.com.\t3600\tIN\tSOA\tns1.example.com.\tmatt.example.com.\t1\t7200\t3600\t1209600\t3600\n`,
+    testT  : 'Zexample.com:ns1.example.com:matt.example.com:1:7200:3600:1209600:3600:3600::\n',
+  },
+  {
+    ...defaults,
+    owner  : '2.example.com.',
+    mname  : 'ns2.example.com.',
+    rname  : 'matt.example.com.',
+    serial : 1,
+    refresh: 7200,
+    retry  : 3600,
+    expire : 1209600,
+    minimum: 3600,
+    testB  : `2.example.com.\t3600\tIN\tSOA\tns2.example.com.\tmatt.example.com.\t1\t7200\t3600\t1209600\t3600\n`,
+    testT  : 'Z2.example.com:ns2.example.com:matt.example.com:1:7200:3600:1209600:3600:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    ...defaults,
+    owner  : 'example.com.',
+    mname  : 'ns1.example.com.',
+    rname  : 'matt.example.com.',
+    serial : 4294967296,
+    refresh: 7200,
+    retry  : 3600,
+    expire : 1209600,
+    msg    : /serial must be a 32-bit integer/,
+  },
+]
+
+describe('SOA record', function () {
+  base.valid(SOA, validRecords)
+  base.invalid(SOA, invalidRecords)
+
+  base.getDescription(SOA)
+  base.getRFCs(SOA, validRecords[0])
+  base.getFields(SOA, [ 'mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'minimum' ])
+  base.getTypeId(SOA, 6)
+
+  base.toBind(SOA, validRecords)
+  base.toTinydns(SOA, validRecords)
+
+  base.fromBind(SOA, validRecords)
+  base.fromTinydns(SOA, validRecords)
+
+  for (const val of validRecords) {
+    it.skip(`imports tinydns SOA (Z) record (${val.owner})`, async function () {
+      const r = new SOA({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of [ 'owner', 'mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'ttl' ]) {
+        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+      }
+    })
+  }
+})

package/test/spf.js

@@ -0,0 +1,48 @@
+
+import assert from 'assert'
+
+import * as base from './base.js'
+
+import SPF from '../rr/spf.js'
+
+const defaults = { class: 'IN', ttl: 86400, type: 'SPF' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner: 'example.com.',
+    data : 'v=spf1 mx a include:mx.example.com -all',
+    testB: 'example.com.\t86400\tIN\tSPF\t"v=spf1 mx a include:mx.example.com -all"\n',
+    testT: ':example.com:99:v=spf1 mx a include\\072mx.example.com -all:86400::\n',
+  },
+]
+
+const invalidRecords = [
+
+]
+
+describe('SPF record', function () {
+  base.valid(SPF, validRecords)
+  base.invalid(SPF, invalidRecords)
+
+  base.getDescription(SPF)
+  base.getRFCs(SPF, validRecords[0])
+  base.getFields(SPF, [ 'data' ])
+  base.getTypeId(SPF, 99)
+
+  base.toBind(SPF, validRecords)
+  base.toTinydns(SPF, validRecords)
+
+  base.fromBind(SPF, validRecords)
+  base.fromTinydns(SPF, validRecords)
+
+  for (const val of validRecords) {
+    it.skip(`imports tinydns SPF (generic) record`, async function () {
+      const r = new SPF({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of [ 'owner', 'data', 'ttl' ]) {
+        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+      }
+    })
+  }
+})

package/test/srv.js

@@ -0,0 +1,81 @@
+
+import assert from 'assert'
+
+import * as base from './base.js'
+
+import SRV from '../rr/srv.js'
+
+const defaults = { class: 'IN', ttl: 3600, type: 'SRV' }
+
+const validRecords = [
+  {
+    ...defaults,
+    owner   : '_imaps._tcp.example.com.',
+    priority: 1,
+    weight  : 0,
+    port    : 993,
+    target  : 'mail.example.com.',
+    testB   : '_imaps._tcp.example.com.\t3600\tIN\tSRV\t1\t0\t993\tmail.example.com.\n',
+    testT   : ':_imaps._tcp.example.com:33:\\000\\001\\000\\000\\003\\341\\004mail\\007example\\003com\\000:3600::\n',
+  },
+  {
+    ...defaults,
+    owner   : '_sip._tls.example.com.',
+    priority: 100,
+    weight  : 1,
+    port    : 443,
+    target  : 'sipdir.online.lync.com.',
+    testB   : '_sip._tls.example.com.\t3600\tIN\tSRV\t100\t1\t443\tsipdir.online.lync.com.\n',
+    testT   : ':_sip._tls.example.com:33:\\000\\144\\000\\001\\001\\273\\006sipdir\\006online\\004lync\\003com\\000:3600::\n',
+  },
+]
+
+const invalidRecords = [
+  {
+    ...defaults,
+    owner : 'test.example.com.',
+    target: 'not-full-qualified.example.com',
+    msg   : /must be a 16-bit integer/,
+  },
+  {
+    ...defaults,
+    owner : 'test.example.com.',
+    target: '192.168.0.1',
+    msg   : /must be a 16-bit integer/,
+  },
+]
+
+describe('SRV record', function () {
+  base.valid(SRV, validRecords)
+  base.invalid(SRV, invalidRecords)
+
+  base.getDescription(SRV)
+  base.getRFCs(SRV, validRecords[0])
+  base.getFields(SRV, [ 'priority', 'weight', 'port', 'target' ])
+  base.getTypeId(SRV, 33)
+
+  base.toBind(SRV, validRecords)
+  base.toTinydns(SRV, validRecords)
+
+  base.fromBind(SRV, validRecords)
+  base.fromTinydns(SRV, validRecords)
+
+  for (const val of validRecords) {
+    it(`imports tinydns SRV (generic) record (${val.owner})`, async function () {
+      const r = new SRV({ tinyline: val.testT })
+      if (process.env.DEBUG) console.dir(r)
+      for (const f of [ 'owner', 'target', 'priority', 'weight', 'port', 'ttl' ]) {
+        assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+      }
+    })
+  }
+
+  it(`imports tinydns SRV (S) record`, async function () {
+    const val = validRecords[0]
+    const r = new SRV({ tinyline: 'S_imaps._tcp.example.com:mail.example.com:993:1:0:3600::' })
+    if (process.env.DEBUG) console.dir(r)
+    for (const f of [ 'owner', 'target', 'priority', 'weight', 'port', 'ttl' ]) {
+      assert.deepStrictEqual(r.get(f), val[f], `${f}: ${r.get(f)} !== ${val[f]}`)
+    }
+  })
+})