Skip to content

Commit

Permalink
Fix Node.js 0.8 return value inconsistencies
Browse files Browse the repository at this point in the history
  • Loading branch information
@dougwilson
dougwilson committed Apr 10, 2019
1 parent 494fa92 commit bbda82b
Show file tree
Hide file tree
Showing 3 changed files with 92 additions and 79 deletions.
5 changes: 5 additions & 0 deletions HISTORY.md
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,8 @@
unreleased
==========

* Fix Node.js 0.8 return value inconsistencies

1.3.2 / 2017-09-09
==================

Expand Down
8 changes: 6 additions & 2 deletions index.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -128,11 +128,15 @@ function fastparse (str) {
var url = Url !== undefined
? new Url()
: {}

url.path = str
url.href = str
url.pathname = pathname
url.query = query
url.search = search

if (search !== null) {
url.query = query
url.search = search
}

return url
}
Expand Down
158 changes: 81 additions & 77 deletions test/test.js
View file
Original file line number Diff line number Diff line change
@@ -1,47 +1,51 @@

var assert = require('assert')
var parseurl = require('..')
var url = require('url')

var URL_EMPTY_VALUE = url.Url
? null : undefined

describe('parseurl(req)', function () {
it('should parse the requrst URL', function () {
var req = createReq('/foo/bar')
var url = parseurl(req)
assert.equal(url.host, null)
assert.equal(url.hostname, null)
assert.equal(url.href, '/foo/bar')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, null)
assert.equal(url.query, null)
assert.equal(url.search, null)
assert.strictEqual(url.host, URL_EMPTY_VALUE)
assert.strictEqual(url.hostname, URL_EMPTY_VALUE)
assert.strictEqual(url.href, '/foo/bar')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, URL_EMPTY_VALUE)
assert.strictEqual(url.query, URL_EMPTY_VALUE)
assert.strictEqual(url.search, URL_EMPTY_VALUE)
})

it('should parse with query string', function () {
var req = createReq('/foo/bar?fizz=buzz')
var url = parseurl(req)
assert.equal(url.host, null)
assert.equal(url.hostname, null)
assert.equal(url.href, '/foo/bar?fizz=buzz')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, null)
assert.equal(url.query, 'fizz=buzz')
assert.equal(url.search, '?fizz=buzz')
assert.strictEqual(url.host, URL_EMPTY_VALUE)
assert.strictEqual(url.hostname, URL_EMPTY_VALUE)
assert.strictEqual(url.href, '/foo/bar?fizz=buzz')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, URL_EMPTY_VALUE)
assert.strictEqual(url.query, 'fizz=buzz')
assert.strictEqual(url.search, '?fizz=buzz')
})

it('should parse a full URL', function () {
var req = createReq('http://localhost:8888/foo/bar')
var url = parseurl(req)
assert.equal(url.host, 'localhost:8888')
assert.equal(url.hostname, 'localhost')
assert.equal(url.href, 'http://localhost:8888/foo/bar')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, '8888')
assert.equal(url.query, null)
assert.equal(url.search, null)
assert.strictEqual(url.host, 'localhost:8888')
assert.strictEqual(url.hostname, 'localhost')
assert.strictEqual(url.href, 'http://localhost:8888/foo/bar')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, '8888')
assert.strictEqual(url.query, URL_EMPTY_VALUE)
assert.strictEqual(url.search, URL_EMPTY_VALUE)
})

it('should not choke on auth-looking URL', function () {
var req = createReq('//todo@txt')
assert.equal(parseurl(req).pathname, '//todo@txt')
assert.strictEqual(parseurl(req).pathname, '//todo@txt')
})

it('should return undefined missing url', function () {
Expand All @@ -53,9 +57,9 @@ describe('parseurl(req)', function () {
describe('when using the same request', function () {
it('should parse multiple times', function () {
var req = createReq('/foo/bar')
assert.equal(parseurl(req).pathname, '/foo/bar')
assert.equal(parseurl(req).pathname, '/foo/bar')
assert.equal(parseurl(req).pathname, '/foo/bar')
assert.strictEqual(parseurl(req).pathname, '/foo/bar')
assert.strictEqual(parseurl(req).pathname, '/foo/bar')
assert.strictEqual(parseurl(req).pathname, '/foo/bar')
})

it('should reflect url changes', function () {
Expand All @@ -64,13 +68,13 @@ describe('parseurl(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

req.url = '/bar/baz'
url = parseurl(req)
assert.equal(url._token, undefined)
assert.equal(parseurl(req).pathname, '/bar/baz')
assert.strictEqual(url._token, undefined)
assert.strictEqual(parseurl(req).pathname, '/bar/baz')
})

it('should cache parsing', function () {
Expand All @@ -79,12 +83,12 @@ describe('parseurl(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

url = parseurl(req)
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')
})

it('should cache parsing where href does not match', function () {
Expand All @@ -93,12 +97,12 @@ describe('parseurl(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

url = parseurl(req)
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')
})
})
})
Expand All @@ -107,37 +111,37 @@ describe('parseurl.original(req)', function () {
it('should parse the request original URL', function () {
var req = createReq('/foo/bar', '/foo/bar')
var url = parseurl.original(req)
assert.equal(url.host, null)
assert.equal(url.hostname, null)
assert.equal(url.href, '/foo/bar')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, null)
assert.equal(url.query, null)
assert.equal(url.search, null)
assert.strictEqual(url.host, URL_EMPTY_VALUE)
assert.strictEqual(url.hostname, URL_EMPTY_VALUE)
assert.strictEqual(url.href, '/foo/bar')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, URL_EMPTY_VALUE)
assert.strictEqual(url.query, URL_EMPTY_VALUE)
assert.strictEqual(url.search, URL_EMPTY_VALUE)
})

it('should parse originalUrl when different', function () {
var req = createReq('/bar', '/foo/bar')
var url = parseurl.original(req)
assert.equal(url.host, null)
assert.equal(url.hostname, null)
assert.equal(url.href, '/foo/bar')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, null)
assert.equal(url.query, null)
assert.equal(url.search, null)
assert.strictEqual(url.host, URL_EMPTY_VALUE)
assert.strictEqual(url.hostname, URL_EMPTY_VALUE)
assert.strictEqual(url.href, '/foo/bar')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, URL_EMPTY_VALUE)
assert.strictEqual(url.query, URL_EMPTY_VALUE)
assert.strictEqual(url.search, URL_EMPTY_VALUE)
})

it('should parse req.url when originalUrl missing', function () {
var req = createReq('/foo/bar')
var url = parseurl.original(req)
assert.equal(url.host, null)
assert.equal(url.hostname, null)
assert.equal(url.href, '/foo/bar')
assert.equal(url.pathname, '/foo/bar')
assert.equal(url.port, null)
assert.equal(url.query, null)
assert.equal(url.search, null)
assert.strictEqual(url.host, URL_EMPTY_VALUE)
assert.strictEqual(url.hostname, URL_EMPTY_VALUE)
assert.strictEqual(url.href, '/foo/bar')
assert.strictEqual(url.pathname, '/foo/bar')
assert.strictEqual(url.port, URL_EMPTY_VALUE)
assert.strictEqual(url.query, URL_EMPTY_VALUE)
assert.strictEqual(url.search, URL_EMPTY_VALUE)
})

it('should return undefined missing req.url and originalUrl', function () {
Expand All @@ -149,9 +153,9 @@ describe('parseurl.original(req)', function () {
describe('when using the same request', function () {
it('should parse multiple times', function () {
var req = createReq('/foo/bar', '/foo/bar')
assert.equal(parseurl.original(req).pathname, '/foo/bar')
assert.equal(parseurl.original(req).pathname, '/foo/bar')
assert.equal(parseurl.original(req).pathname, '/foo/bar')
assert.strictEqual(parseurl.original(req).pathname, '/foo/bar')
assert.strictEqual(parseurl.original(req).pathname, '/foo/bar')
assert.strictEqual(parseurl.original(req).pathname, '/foo/bar')
})

it('should reflect changes', function () {
Expand All @@ -160,13 +164,13 @@ describe('parseurl.original(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

req.originalUrl = '/bar/baz'
url = parseurl.original(req)
assert.equal(url._token, undefined)
assert.equal(parseurl.original(req).pathname, '/bar/baz')
assert.strictEqual(url._token, undefined)
assert.strictEqual(parseurl.original(req).pathname, '/bar/baz')
})

it('should cache parsing', function () {
Expand All @@ -175,12 +179,12 @@ describe('parseurl.original(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

url = parseurl.original(req)
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')
})

it('should cache parsing if req.url changes', function () {
Expand All @@ -189,13 +193,13 @@ describe('parseurl.original(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

req.url = '/baz'
url = parseurl.original(req)
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')
})

it('should cache parsing where href does not match', function () {
Expand All @@ -204,12 +208,12 @@ describe('parseurl.original(req)', function () {
var val = Math.random()

url._token = val
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')

url = parseurl.original(req)
assert.equal(url._token, val)
assert.equal(url.pathname, '/foo/bar')
assert.strictEqual(url._token, val)
assert.strictEqual(url.pathname, '/foo/bar')
})
})
})
Expand Down

0 comments on commit bbda82b

Please sign in to comment.