jid.spec.js

var assert = require('assert')
  , JID = require('./jid')

describe('JID', function() {

    describe('parsing', function() {

        it('should parse a "domain" JID', function() {
            var j = new JID('d')
            assert.equal(j.getLocal(), null)
            assert.equal(j.getDomain(), 'd')
            assert.equal(j.getResource(), null)
        })
        it('should parse a "user@domain" JID', function() {
            var j = new JID('u@d')
            assert.equal(j.getLocal(), 'u')
            assert.equal(j.getDomain(), 'd')
            assert.equal(j.getResource(), null)
        })
        it('should parse a "domain/resource" JID', function() {
            var j = new JID('d/r')
            assert.equal(j.getLocal(), null)
            assert.equal(j.getDomain(), 'd')
            assert.equal(j.getResource(), 'r')
        })
        it('should parse a "user@domain/resource" JID', function() {
            var j = new JID('u@d/r')
            assert.equal(j.getLocal(), 'u')
            assert.equal(j.getDomain(), 'd')
            assert.equal(j.getResource(), 'r')
        })
        it('should parse an internationalized domain name as unicode', function() {
            var j = new JID('öko.de')
            assert.equal(j.getDomain(), 'öko.de')
        })
        it('should parse an empty domain JID (#109)', function() {
            var j = new JID('u@d', '')
            assert.equal(j.getLocal(), 'u')
            assert.equal(j.getDomain(), 'd')
            assert.equal(j.getResource(), null)
        })
        it('should allow access to jid parts using (old) keys', function() {
            var j = new JID('u@d/r', '')
            assert.equal(j.user, 'u')
            assert.equal(j.domain, 'd')
            assert.equal(j.resource, 'r')
        })
        it('should allow access to jid parts using (old) keys', function() {
            var j = new JID('u@d/r', '')
            assert.equal(j.local, 'u')
            assert.equal(j.domain, 'd')
            assert.equal(j.resource, 'r')
        })

        it('shouldn\'t get U_STRINGPREP_PROHIBITED_ERROR (#93)', function() {
            assert.doesNotThrow(function () {
                var j = new JID('f u@d')
                j.toString()
            })
        })

        it('should correctly detect local and resouce parts (#49)', function() {
            var j = new JID('lloyd.watkin@somewhere/something@blah/ hello')
            assert.equal(j.local, 'lloyd.watkin')
            assert.equal(j.domain, 'somewhere')
            assert.equal(j.resource, 'something@blah/ hello')
        })

        try {
            // HACK: these tests fail if node-stringprep is not used
            require('node-stringprep')

            it('should parse an internationalized domain name as ascii/punycode', function() {
                var j = new JID('xn--ko-eka.de')
                assert.equal(j.getDomain(), 'öko.de')
            })

            it('should parse a JID with punycode', function() {
                var j = new JID('Сергей@xn--lsa92diaqnge.xn--p1ai')
                assert.equal(j.getLocal(), 'сергей')
                assert.equal(j.getDomain(), 'приме́р.рф')
            })

        } catch (ex) {
            //ignore
        }
    })

    /* jshint -W044 */
    describe('Escaping', function() {

        it('Should not change string - issue 43', function() {
            var test = 'test\32@example.com'

            var jid = new JID(test)
            assert.equal(jid.escapeLocal('test\32'), 'test\32')
        })

        it('Should escape - issue 43', function() {
            var test = 'test\32a@example.com'

            /* jshint -W100 */
            /* jshint -W113 */
            var jid = new JID(test)
            assert.equal(jid.escapeLocal('test\32a'), 'testa')
        })
    })

    describe('serialization', function() {

        it('should serialize a "domain" JID', function() {
            var j = new JID(null, 'd')
            assert.equal(j.toString(), 'd')
        })

        it('should serialize a "user@domain" JID', function() {
            var j = new JID('u', 'd')
            assert.equal(j.toString(), 'u@d')
        })

        it('should serialize a "domain/resource" JID', function() {
            var j = new JID(null, 'd', 'r')
            assert.equal(j.toString(), 'd/r')
        })

        it('should serialize a "user@domain/resource" JID', function() {
            var j = new JID('u', 'd', 'r')
            assert.equal(j.toString(), 'u@d/r')
        })

    })

    describe('equality', function() {

        it('should parsed JIDs should be equal', function() {
            var j1 = new JID('foo@bar/baz')
            var j2 = new JID('foo@bar/baz')
            assert.equal(j1.equals(j2), true)
        })

        it('should parsed JIDs should be not equal', function() {
            var j1 = new JID('foo@bar/baz')
            var j2 = new JID('quux@bar/baz')
            assert.equal(j1.equals(j2), false)
        })

        it('should should ignore case in user', function() {
            var j1 = new JID('foo@bar/baz')
            var j2 = new JID('FOO@bar/baz')
            assert.equal(j1.equals(j2), true)
        })

        it('should should ignore case in domain', function() {
            var j1 = new JID('foo@bar/baz')
            var j2 = new JID('foo@BAR/baz')
            assert.equal(j1.equals(j2), true)
        })

        it('should should not ignore case in resource', function() {
            var j1 = new JID('foo@bar/baz')
            var j2 = new JID('foo@bar/Baz')
            assert.equal(j1.equals(j2), false)
        })

        it('should should ignore international caseness', function() {
            var j1 = new JID('föö@bär/baß')
            var j2 = new JID('fÖö@BÄR/baß')
            assert.equal(j1.equals(j2), true)
        })

        it('should work with bare JIDs', function() {
            var j1 = new JID('romeo@example.net/9519407536580081')
            var j2 = new JID('romeo@example.net')
            assert.equal(j1.bare().equals(j2), true)
        })

    })

})