@nictool/dns-resource-record 1.2.0 → 1.2.2

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]}`,
+        )
+      }
+    })
+  }
+})

package/test/rr.js

@@ -0,0 +1,212 @@
+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.ok(/must be fully qualified/.test(e.message))
+      }
+    })
+  })
+
+  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)
+      })
+    }
+  })
+})