@nictool/dns-resource-record 1.2.1 → 1.2.2

package/test/loc.js

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

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

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

@@ -0,0 +1,56 @@
+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})`, 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,37 @@
+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,47 @@
+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

@@ -0,0 +1,23 @@
+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/nxt.js

@@ -0,0 +1,37 @@
+import * as base from './base.js'
+
+import NXT from '../rr/nxt.js'
+
+const validRecords = [
+  {
+    owner: 'big.example.com.',
+    ttl: 86400,
+    class: 'IN',
+    type: 'NXT',
+    'next domain': 'medium.example.com.',
+    'type bit map': 'A SIG NXT',
+    testB: `big.example.com.\t86400\tIN\tNXT\tmedium.example.com.\tA SIG NXT\n`,
+    // testT        : '\n',
+  },
+]
+
+const invalidRecords = [
+  // {
+  // },
+]
+
+describe('NXT record', function () {
+  base.valid(NXT, validRecords)
+  base.invalid(NXT, invalidRecords, { ttl: 3600 })
+
+  base.getDescription(NXT)
+  base.getRFCs(NXT, validRecords[0])
+  base.getFields(NXT, ['next domain', 'type bit map'])
+  base.getTypeId(NXT, 30)
+
+  base.toBind(NXT, validRecords)
+  // base.toTinydns(NXT, validRecords)
+
+  base.fromBind(NXT, validRecords)
+  // base.fromTinydns(NXT, validRecords)
+})

package/test/openpgpkey.js

@@ -0,0 +1,85 @@
+import * as base from './base.js'
+
+import OPENPGPKEY from '../rr/openpgpkey.js'
+
+const validRecords = [
+  {
+    owner: 'matt.example.com.',
+    ttl: 86400,
+    class: 'IN',
+    type: 'OPENPGPKEY',
+    'public key': `-----BEGIN PGP PUBLIC KEY BLOCK-----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+=kezp
+-----END PGP PUBLIC KEY BLOCK-----`,
+    testB:
+      'matt.example.com.\t86400\tIN\tOPENPGPKEY\t-----BEGIN PGP PUBLIC KEY BLOCK-----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\n0VFBNRBmWIMXRAtmrzPyNp/nD7BymAQ=\n=kezp\n-----END PGP PUBLIC KEY BLOCK-----\n',
+    //   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,56 @@
+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]}`,
+        )
+      }
+    })
+  }
+})