@nictool/dns-resource-record 1.2.2 → 1.2.3

package/test/ptr.js

@@ -1,56 +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,212 +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.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)
-      })
-    }
-  })
-})

package/test/smimea.js

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

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

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

@@ -1,101 +0,0 @@
-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]}`,
-      )
-    }
-  })
-})

package/test/sshfp.js

@@ -1,69 +0,0 @@
-import * as base from './base.js'
-
-import SSHFP from '../rr/sshfp.js'
-
-const common = { type: 'SSHFP', ttl: 86400, class: 'IN' }
-
-const validRecords = [
-  {
-    ...common,
-    owner: 'mail.example.com.',
-    algorithm: 1,
-    fptype: 1,
-    fingerprint:
-      'ed8c6e16fdae4f633eee6a7b8f64fdd356bbb32841d535565d777014c9ea4c26',
-    testB:
-      'mail.example.com.\t86400\tIN\tSSHFP\t1\t1\ted8c6e16fdae4f633eee6a7b8f64fdd356bbb32841d535565d777014c9ea4c26\n',
-    testT:
-      ':mail.example.com:44:\\001\\001\\355\\214\\156\\026\\375\\256\\117\\143\\076\\356\\152\\173\\217\\144\\375\\323\\126\\273\\263\\050\\101\\325\\065\\126\\135\\167\\160\\024\\311\\352\\114\\046:86400::\n',
-  },
-  {
-    ...common,
-    owner: 'jails.example.com.',
-    algorithm: 1,
-    fptype: 1,
-    fingerprint: '684981f1b57cc6b05bb2a5a7fd51a9114fef064d',
-    testB:
-      'jails.example.com.\t86400\tIN\tSSHFP\t1\t1\t684981f1b57cc6b05bb2a5a7fd51a9114fef064d\n',
-    testT:
-      ':jails.example.com:44:\\001\\001\\150\\111\\201\\361\\265\\174\\306\\260\\133\\262\\245\\247\\375\\121\\251\\021\\117\\357\\006\\115:86400::\n',
-  },
-  {
-    ...common,
-    owner: 'jails.example.com.',
-    algorithm: 3,
-    fptype: 2,
-    fingerprint:
-      '81f9dbc4c009a1297336d69fcc2264f2a28417b781dafdd9c1ef7ff256066a35',
-    testB:
-      'jails.example.com.\t86400\tIN\tSSHFP\t3\t2\t81f9dbc4c009a1297336d69fcc2264f2a28417b781dafdd9c1ef7ff256066a35\n',
-  },
-  {
-    ...common,
-    owner: 'jails.example.com.',
-    algorithm: 1,
-    fptype: 2,
-    fingerprint:
-      'ed8c6e16fdae4f633eee6a7b8f64fdd356bbb32841d535565d777014c9ea4c26',
-    testB:
-      'jails.example.com.\t86400\tIN\tSSHFP\t1\t2\ted8c6e16fdae4f633eee6a7b8f64fdd356bbb32841d535565d777014c9ea4c26\n',
-  },
-]
-
-const invalidRecords = []
-
-describe('SSHFP record', function () {
-  base.valid(SSHFP, validRecords)
-  base.invalid(SSHFP, invalidRecords)
-
-  base.getDescription(SSHFP)
-  base.getRFCs(SSHFP, validRecords[0])
-  base.getFields(SSHFP, ['algorithm', 'fptype', 'fingerprint'])
-  base.getTypeId(SSHFP, 44)
-
-  base.toBind(SSHFP, validRecords)
-  base.toTinydns(SSHFP, validRecords)
-
-  base.fromBind(SSHFP, validRecords)
-  base.fromTinydns(SSHFP, validRecords)
-})

package/test/svcb.js

@@ -1,56 +0,0 @@
-import * as base from './base.js'
-
-import SVCB from '../rr/svcb.js'
-
-const defaults = { class: 'IN', ttl: 3600, type: 'SVCB' }
-
-const validRecords = [
-  {
-    ...defaults,
-    owner: '_8443._foo.api.example.com.',
-    ttl: 7200,
-    priority: 0,
-    'target name': 'svc4.example.net.',
-    params: 'alpn="bar" port="8004" ech="..."',
-    testB:
-      '_8443._foo.api.example.com.\t7200\tIN\tSVCB\t0\tsvc4.example.net.\talpn="bar" port="8004" ech="..."\n',
-  },
-  {
-    ...defaults,
-    owner: '_8080._foo.example.com.',
-    priority: 0,
-    'target name': 'foosvc.example.net.',
-    params: '',
-    testB:
-      '_8080._foo.example.com.\t3600\tIN\tSVCB\t0\tfoosvc.example.net.\t\n',
-  },
-  /*
-  _1234._bar.example.com. 300 IN SVCB 1 svc1.example.net. ( ech="111..." ipv6hint=2001:db8::1 port=1234 )
-                                 SVCB 2 svc2.example.net. ( ech="222..." ipv6hint=2001:db8::2 port=1234 )
-*/
-]
-
-const invalidRecords = [
-  // {
-  //   ...defaults,
-  //   owner : 'test.example.com.',
-  //   'target name': 'not-full-qualified.example.com',
-  //   params  : /must be a 16-bit integer/,
-  // },
-]
-
-describe('SVCB record', function () {
-  base.valid(SVCB, validRecords)
-  base.invalid(SVCB, invalidRecords)
-
-  base.getDescription(SVCB)
-  base.getRFCs(SVCB, validRecords[0])
-  base.getFields(SVCB, ['priority', 'target name', 'params'])
-  base.getTypeId(SVCB, 64)
-
-  base.toBind(SVCB, validRecords)
-  // base.toTinydns(SVCB, validRecords)
-
-  base.fromBind(SVCB, validRecords)
-  // base.fromTinydns(SVCB, validRecords)
-})