Andreas Hocevar
602 lines
22 KiB
JavaScript
602 lines
22 KiB
JavaScript
// Copyright 2009 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
goog.provide('goog.uri.utilsTest');
|
|
goog.setTestOnly('goog.uri.utilsTest');
|
|
|
|
goog.require('goog.functions');
|
|
goog.require('goog.string');
|
|
goog.require('goog.testing.PropertyReplacer');
|
|
goog.require('goog.testing.jsunit');
|
|
goog.require('goog.uri.utils');
|
|
|
|
var utils = goog.uri.utils;
|
|
var stubs = new goog.testing.PropertyReplacer();
|
|
|
|
|
|
function setUpPage() {
|
|
goog.string.getRandomString = goog.functions.constant('RANDOM');
|
|
}
|
|
|
|
function tearDown() {
|
|
stubs.reset();
|
|
}
|
|
|
|
function testSplit() {
|
|
var uri = 'http://www.google.com:80/path%20path+path?q=query&hl=en#fragment';
|
|
assertEquals('http', utils.getScheme(uri));
|
|
assertNull(utils.getUserInfoEncoded(uri));
|
|
assertNull(utils.getUserInfo(uri));
|
|
assertEquals('www.google.com', utils.getDomainEncoded(uri));
|
|
assertEquals('www.google.com', utils.getDomain(uri));
|
|
assertEquals(80, utils.getPort(uri));
|
|
assertEquals('/path%20path+path', utils.getPathEncoded(uri));
|
|
assertEquals('/path path+path', utils.getPath(uri));
|
|
assertEquals('q=query&hl=en', utils.getQueryData(uri));
|
|
assertEquals('fragment', utils.getFragmentEncoded(uri));
|
|
assertEquals('fragment', utils.getFragment(uri));
|
|
|
|
assertEquals(utils.getDomain('http://[2607:f8b0:4006:802::1006]'),
|
|
'[2607:f8b0:4006:802::1006]');
|
|
assertEquals(utils.getDomain('http://[2607:f8b0:4006:802::1006]:80'),
|
|
'[2607:f8b0:4006:802::1006]');
|
|
assertEquals(utils.getPort('http://[2607:f8b0:4006:802::1006]:80'), 80);
|
|
assertEquals(utils.getDomain('http://[2607]:80/?q=]'), '[2607]');
|
|
assertEquals(utils.getDomain('http://!!!'), '!!!');
|
|
assertNull(utils.getPath('http://!!!'));
|
|
assertNull(utils.getScheme('www.x.com:80'));
|
|
assertEquals('Query data with no fragment identifier', 'foo=bar&baz=bin',
|
|
utils.getQueryData('http://google.com?foo=bar&baz=bin'));
|
|
}
|
|
|
|
function testMailtoUri() {
|
|
var uri = 'mailto:joe+random@hominid.com';
|
|
assertNull(utils.getDomain(uri));
|
|
assertEquals('mailto', utils.getScheme(uri));
|
|
assertEquals('joe+random@hominid.com', utils.getPath(uri));
|
|
}
|
|
|
|
function testSplitRelativeUri() {
|
|
var uri = '/path%20path+path?q=query&hl=en#fragment';
|
|
assertNull(utils.getScheme(uri));
|
|
assertNull(utils.getDomain(uri));
|
|
assertNull(utils.getDomainEncoded(uri));
|
|
assertNull(utils.getPort(uri));
|
|
assertEquals('/path%20path+path', utils.getPathEncoded(uri));
|
|
assertEquals('/path path+path', utils.getPath(uri));
|
|
assertEquals('q=query&hl=en', utils.getQueryData(uri));
|
|
assertEquals('fragment', utils.getFragmentEncoded(uri));
|
|
assertEquals('fragment', utils.getFragment(uri));
|
|
}
|
|
|
|
function testSplitBadAuthority() {
|
|
// This URL has a syntax error per the RFC (port number must be digits, and
|
|
// host cannot contain a colon except in [...]). This test is solely to
|
|
// 'document' the current behavior, which may affect application handling
|
|
// of erroneous URLs.
|
|
assertEquals(utils.getDomain('http://host:port/'), 'host:port');
|
|
assertNull(utils.getPort('http://host:port/'));
|
|
}
|
|
|
|
function testSplitIntoHostAndPath() {
|
|
// Splitting into host and path takes care of one of the major use cases
|
|
// of resolve, without implementing a generic algorithm that undoubtedly
|
|
// requires a huge footprint.
|
|
var uri = 'http://www.google.com:80/path%20path+path?q=query&hl=en#fragment';
|
|
assertEquals('http://www.google.com:80',
|
|
goog.uri.utils.getHost(uri));
|
|
assertEquals('/path%20path+path?q=query&hl=en#fragment',
|
|
goog.uri.utils.getPathAndAfter(uri));
|
|
|
|
var uri2 = 'http://www.google.com/calendar';
|
|
assertEquals('should handle missing fields', 'http://www.google.com',
|
|
goog.uri.utils.getHost(uri2));
|
|
assertEquals('should handle missing fields', '/calendar',
|
|
goog.uri.utils.getPathAndAfter(uri2));
|
|
}
|
|
|
|
|
|
function testRelativeUrisHaveNoPath() {
|
|
assertNull(utils.getPathEncoded('?hello'));
|
|
}
|
|
|
|
|
|
function testReservedCharacters() {
|
|
var o = '%6F';
|
|
var uri = 'http://www.g' + o + 'ogle.com%40/xxx%2feee/ccc';
|
|
assertEquals('Should not decode reserved characters in path',
|
|
'/xxx%2feee/ccc', goog.uri.utils.getPath(uri));
|
|
assertEquals('Should not decode reserved characters in domain',
|
|
'www.google.com%40', goog.uri.utils.getDomain(uri));
|
|
}
|
|
|
|
function testSetFragmentEncoded() {
|
|
var expected = 'http://www.google.com/path#bar';
|
|
assertEquals(expected,
|
|
utils.setFragmentEncoded('http://www.google.com/path#foo', 'bar'));
|
|
|
|
assertEquals(expected,
|
|
utils.setFragmentEncoded('http://www.google.com/path', 'bar'));
|
|
|
|
assertEquals('http://www.google.com/path',
|
|
utils.setFragmentEncoded('http://www.google.com/path', ''));
|
|
|
|
assertEquals('http://www.google.com/path',
|
|
utils.setFragmentEncoded('http://www.google.com/path', null));
|
|
}
|
|
|
|
|
|
function testGetParamValue() {
|
|
assertEquals('v1',
|
|
utils.getParamValue('/path?key=v1&c=d&keywithsuffix=v3&key=v2', 'key'));
|
|
|
|
assertEquals('v1',
|
|
utils.getParamValue('/path?kEY=v1&c=d&keywithsuffix=v3&key=v2', 'kEY'));
|
|
}
|
|
|
|
|
|
function testGetParamValues() {
|
|
assertArrayEquals('should ignore confusing suffixes', ['v1', 'v2'],
|
|
utils.getParamValues(
|
|
'/path?a=b&key=v1&c=d&key=v2&keywithsuffix=v3', 'key'));
|
|
assertArrayEquals('should be case sensitive', ['v2'],
|
|
utils.getParamValues('/path?a=b&keY=v1&c=d&KEy=v2&keywithsuffix=v3',
|
|
'KEy'));
|
|
assertArrayEquals('should work for the first parameter', ['v1', 'v2'],
|
|
utils.getParamValues('/path?key=v1&c=d&key=v2&keywithsuffix=v3', 'key'));
|
|
assertArrayEquals('should work for the last parameter', ['v1', 'v2'],
|
|
utils.getParamValues('/path?key=v1&c=d&keywithsuffix=v3&key=v2', 'key'));
|
|
assertArrayEquals(['1'],
|
|
utils.getParamValues('http://foo.com?q=1#?q=2&q=3', 'q'));
|
|
}
|
|
|
|
|
|
function testGetParamValueAllowsEqualInValues() {
|
|
assertEquals('equals signs can appear unencoded', 'v1=v2',
|
|
utils.getParamValue('/path?key=v1=v2', 'key'));
|
|
assertArrayEquals(['v1=v2=v3'],
|
|
utils.getParamValues('/path?key=v1=v2=v3', 'key'));
|
|
}
|
|
|
|
|
|
function testGetParamValueNoSuchKey() {
|
|
var uri = '/path?key=v1&c=d&keywithsuffix=v3&key=v2';
|
|
assertNull(utils.getParamValue(uri, 'nosuchkey'));
|
|
assertArrayEquals([], utils.getParamValues(uri, 'nosuchkey'));
|
|
assertFalse(utils.hasParam(uri, 'nosuchkey'));
|
|
assertNull(utils.getParamValue('q=1', 'q'));
|
|
assertEquals('1', utils.getParamValue('?q=1', 'q'));
|
|
}
|
|
|
|
|
|
function testGetParamValueEmptyAndMissingValueStrings() {
|
|
assertEquals('', utils.getParamValue('/path?key&bar', 'key'));
|
|
assertEquals('', utils.getParamValue('/path?foo=bar&key', 'key'));
|
|
assertEquals('', utils.getParamValue('/path?key', 'key'));
|
|
assertEquals('', utils.getParamValue('/path?key=', 'key'));
|
|
assertArrayEquals([''], utils.getParamValues('/path?key', 'key'));
|
|
assertArrayEquals([''], utils.getParamValues('/path?key&bar', 'key'));
|
|
assertArrayEquals([''], utils.getParamValues('/path?foo=bar&key', 'key'));
|
|
assertArrayEquals([''], utils.getParamValues('/path?foo=bar&key=', 'key'));
|
|
assertArrayEquals(['', '', '', 'j', ''],
|
|
utils.getParamValues('/path?key&key&key=&key=j&key', 'key'));
|
|
assertArrayEquals(['', '', '', '', ''],
|
|
utils.getParamValues('/pathqqq?q&qq&q&q=&q&q', 'q'));
|
|
assertTrue(utils.hasParam('/path?key=', 'key'));
|
|
}
|
|
|
|
|
|
function testGetParamValueDecoding() {
|
|
assertEquals('plus should be supported as alias of space', 'foo bar baz',
|
|
utils.getParamValue('/path?key=foo+bar%20baz', 'key'));
|
|
assertArrayEquals(['foo bar baz'],
|
|
utils.getParamValues('/path?key=foo%20bar%20baz', 'key'));
|
|
}
|
|
|
|
|
|
function testGetParamIgnoresParamsInFragmentIdentifiers() {
|
|
assertFalse(utils.hasParam('/path?bah#a&key=foo', 'key'));
|
|
assertEquals(null, utils.getParamValue('/path?bah#a&key=bar', 'key'));
|
|
assertArrayEquals([], utils.getParamValues('/path?bah#a&key=bar', 'key'));
|
|
}
|
|
|
|
|
|
function testGetParamIgnoresExcludesFragmentFromParameterValue() {
|
|
// Make sure the '#' doesn't get included anywhere, for parameter values
|
|
// of different lengths.
|
|
assertEquals('foo',
|
|
utils.getParamValue('/path?key=foo#key=bar&key=baz', 'key'));
|
|
assertArrayEquals(['foo'],
|
|
utils.getParamValues('/path?key=foo#key=bar&key=baz', 'key'));
|
|
assertEquals('',
|
|
utils.getParamValue('/path?key#key=bar&key=baz', 'key'));
|
|
assertArrayEquals([''],
|
|
utils.getParamValues('/path?key#key=bar&key=baz', 'key'));
|
|
assertEquals('x',
|
|
utils.getParamValue('/path?key=x#key=bar&key=baz', 'key'));
|
|
assertArrayEquals(['x'],
|
|
utils.getParamValues('/path?key=x#key=bar&key=baz', 'key'));
|
|
|
|
// Simply make sure hasParam doesn't die in this case.
|
|
assertTrue(utils.hasParam('/path?key=foo#key=bar&key=baz', 'key'));
|
|
assertTrue(utils.hasParam('/path?key=foo#key&key=baz', 'key'));
|
|
}
|
|
|
|
|
|
function testSameDomainPathsDiffer() {
|
|
var uri1 = 'http://www.google.com/a';
|
|
var uri2 = 'http://www.google.com/b';
|
|
assertTrue(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertTrue(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
}
|
|
|
|
|
|
function testSameDomainSchemesDiffer() {
|
|
var uri1 = 'http://www.google.com';
|
|
var uri2 = 'https://www.google.com';
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
}
|
|
|
|
|
|
function testSameDomainPortsDiffer() {
|
|
var uri1 = 'http://www.google.com:1234/a';
|
|
var uri2 = 'http://www.google.com/b';
|
|
var uri3 = 'http://www.google.com:2345/b';
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri1, uri3));
|
|
}
|
|
|
|
|
|
function testSameDomainDomainsDiffer() {
|
|
var uri1 = '/a';
|
|
var uri2 = 'http://www.google.com/b';
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
}
|
|
|
|
|
|
function testSameDomainSubDomainDiffers() {
|
|
var uri1 = 'http://www.google.com/a';
|
|
var uri2 = 'http://mail.google.com/b';
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertFalse(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
}
|
|
|
|
|
|
function testSameDomainNoDomain() {
|
|
var uri1 = '/a';
|
|
var uri2 = '/b';
|
|
assertTrue(goog.uri.utils.haveSameDomain(uri1, uri2));
|
|
assertTrue(goog.uri.utils.haveSameDomain(uri2, uri1));
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Simple class with a constant toString.
|
|
* @param {string} stringValue The result of toString.
|
|
* @constructor
|
|
*/
|
|
function HasString(stringValue) {
|
|
this.value_ = stringValue;
|
|
}
|
|
|
|
|
|
/** @override */
|
|
HasString.prototype.toString = function() {
|
|
return this.value_;
|
|
};
|
|
|
|
|
|
function testBuildFromEncodedParts() {
|
|
assertEquals('should handle full URL',
|
|
'http://foo@www.google.com:80/path?q=query#fragment',
|
|
utils.buildFromEncodedParts('http', 'foo', 'www.google.com',
|
|
80, '/path', 'q=query', 'fragment'));
|
|
assertEquals('should handle unspecified parameters', '/search',
|
|
utils.buildFromEncodedParts(null, null, undefined, null, '/search'));
|
|
assertEquals('should handle params of non-primitive types',
|
|
'http://foo@www.google.com:80/path?q=query#fragment',
|
|
utils.buildFromEncodedParts(new HasString('http'), new HasString('foo'),
|
|
new HasString('www.google.com'), new HasString('80'),
|
|
new HasString('/path'), new HasString('q=query'),
|
|
new HasString('fragment')));
|
|
}
|
|
|
|
|
|
function testAppendParam() {
|
|
assertEquals('http://foo.com?q=1',
|
|
utils.appendParam('http://foo.com', 'q', 1));
|
|
assertEquals('http://foo.com?q=1#preserve',
|
|
utils.appendParam('http://foo.com#preserve', 'q', 1));
|
|
assertEquals('should tolerate a lone question mark',
|
|
'http://foo.com?q=1',
|
|
utils.appendParam('http://foo.com?', 'q', 1));
|
|
assertEquals('http://foo.com?q=1&r=2',
|
|
utils.appendParam('http://foo.com?q=1', 'r', 2));
|
|
assertEquals('http://foo.com?q=1&r=2&s=3#preserve',
|
|
utils.appendParam('http://foo.com?q=1&r=2#preserve', 's', 3));
|
|
assertEquals('q=1&r=2&s=3&s=4',
|
|
utils.buildQueryData(['q', 1, 'r', 2, 's', [3, 4]]));
|
|
assertEquals('',
|
|
utils.buildQueryData([]));
|
|
assertEquals('?q=1#preserve',
|
|
utils.appendParam('#preserve', 'q', 1));
|
|
}
|
|
|
|
function testAppendParams() {
|
|
assertEquals('http://foo.com',
|
|
utils.appendParams('http://foo.com'));
|
|
assertEquals('http://foo.com?q=1&r=2&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com#preserve',
|
|
'q', 1, 'r', 2, 's', [3, 4]));
|
|
assertEquals('http://foo.com?a=1&q=1&r=2&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com?a=1#preserve',
|
|
'q', 1, 'r', 2, 's', [3, 4]));
|
|
assertEquals('http://foo.com?q=1&r=2&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com?#preserve',
|
|
'q', 1, 'r', 2, 's', [3, 4]));
|
|
assertEquals('?q=1&r=2&s=3&s=4#preserve',
|
|
utils.appendParams('#preserve',
|
|
'q', 1, 'r', 2, 's', [3, 4]));
|
|
assertEquals('A question mark must not be appended if there are no ' +
|
|
'parameters, otherwise repeated appends will be broken.',
|
|
'http://foo.com#test', utils.appendParams('http://foo.com#test'));
|
|
assertEquals('should handle objects with to-string',
|
|
'http://foo.com?q=a&r=b',
|
|
utils.appendParams('http://foo.com',
|
|
'q', new HasString('a'), 'r', [new HasString('b')]));
|
|
|
|
assertThrows('appendParams should fail with an odd number of arguments.',
|
|
function() {
|
|
utils.appendParams('http://foo.com', 'a', 1, 'b');
|
|
});
|
|
}
|
|
|
|
|
|
function testValuelessParam() {
|
|
assertEquals('http://foo.com?q',
|
|
utils.appendParam('http://foo.com', 'q'));
|
|
assertEquals('http://foo.com?q',
|
|
utils.appendParam('http://foo.com', 'q', null /* opt_value */));
|
|
assertEquals('http://foo.com?q#preserve',
|
|
utils.appendParam('http://foo.com#preserve', 'q'));
|
|
assertEquals('should tolerate a lone question mark',
|
|
'http://foo.com?q',
|
|
utils.appendParam('http://foo.com?', 'q'));
|
|
assertEquals('http://foo.com?q=1&r',
|
|
utils.appendParam('http://foo.com?q=1', 'r'));
|
|
assertEquals('http://foo.com?q=1&r=2&s#preserve',
|
|
utils.appendParam('http://foo.com?q=1&r=2#preserve', 's'));
|
|
assertTrue(utils.hasParam('http://foo.com?q=1&r=2&s#preserve', 's'));
|
|
}
|
|
|
|
|
|
function testAppendParamsAsArray() {
|
|
assertEquals('http://foo.com?q=1&r=2&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com#preserve',
|
|
['q', 1, 'r', 2, 's', [3, 4]]));
|
|
assertEquals('http://foo.com?q=1&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com#preserve',
|
|
['q', 1, 'r', null, 's', [3, 4]]));
|
|
assertEquals('http://foo.com?q=1&s=3&s=4#preserve',
|
|
utils.appendParams('http://foo.com#preserve',
|
|
['q', 1, 'r', undefined, 's', [3, 4]]));
|
|
assertEquals('http://foo.com?q=1&r=2&s=3&s=4&s=null&s=undefined#preserve',
|
|
utils.appendParams('http://foo.com#preserve',
|
|
['q', 1, 'r', 2, 's', [3, new HasString('4'), null, undefined]]));
|
|
}
|
|
|
|
|
|
function testAppendParamEscapes() {
|
|
assertEquals('http://foo.com?h=a%20b',
|
|
utils.appendParams('http://foo.com', 'h', 'a b'));
|
|
assertEquals('h=a%20b', utils.buildQueryData(['h', 'a b']));
|
|
assertEquals('h=a%20b', utils.buildQueryDataFromMap({'h': 'a b'}));
|
|
}
|
|
|
|
|
|
function testAppendParamsFromMap() {
|
|
var uri = utils.appendParamsFromMap('http://www.foo.com',
|
|
{'a': 1, 'b': 'bob', 'c': [1, 2, new HasString('3')]});
|
|
assertArrayEquals(['1'], utils.getParamValues(uri, 'a'));
|
|
assertArrayEquals(['bob'], utils.getParamValues(uri, 'b'));
|
|
assertArrayEquals(['1', '2', '3'], utils.getParamValues(uri, 'c'));
|
|
}
|
|
|
|
function testBuildQueryDataFromMap() {
|
|
assertEquals('a=1', utils.buildQueryDataFromMap({'a': 1}));
|
|
var uri = 'foo.com?' + utils.buildQueryDataFromMap(
|
|
{'a': 1, 'b': 'bob', 'c': [1, 2, new HasString('3')]});
|
|
assertArrayEquals(['1'], utils.getParamValues(uri, 'a'));
|
|
assertArrayEquals(['bob'], utils.getParamValues(uri, 'b'));
|
|
assertArrayEquals(['1', '2', '3'], utils.getParamValues(uri, 'c'));
|
|
}
|
|
|
|
|
|
function testMultiParamSkipsNullParams() {
|
|
// For the multi-param functions, null and undefined keys should be
|
|
// skipped, but null within a parameter array should still be appended.
|
|
assertEquals('buildQueryDataFromMap', 'a=null',
|
|
utils.buildQueryDataFromMap({'a': [null], 'b': null, 'c': undefined}));
|
|
assertEquals('buildQueryData', 'a=null',
|
|
utils.buildQueryData(['a', [null], 'b', null, 'c', undefined]));
|
|
assertEquals('appendParams', 'foo.com?a=null',
|
|
utils.appendParams('foo.com', 'a', [null], 'b', null, 'c', undefined));
|
|
assertEquals('empty strings should NOT be skipped', 'foo.com?a&b',
|
|
utils.appendParams('foo.com', 'a', [''], 'b', ''));
|
|
}
|
|
|
|
|
|
function testRemoveParam() {
|
|
assertEquals('remove middle', 'http://foo.com?q=1&s=3',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3', 'r'));
|
|
assertEquals('remove first', 'http://foo.com?r=2&s=3',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3', 'q'));
|
|
assertEquals('remove last', 'http://foo.com?q=1&r=2',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3', 's'));
|
|
assertEquals('remove only param', 'http://foo.com',
|
|
utils.removeParam('http://foo.com?q=1', 'q'));
|
|
}
|
|
|
|
|
|
function testRemoveParamWithFragment() {
|
|
assertEquals('remove middle', 'http://foo.com?q=1&s=3#?r=1&r=1',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3#?r=1&r=1', 'r'));
|
|
assertEquals('remove first', 'http://foo.com?r=2&s=3#?q=1&q=1',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3#?q=1&q=1', 'q'));
|
|
assertEquals('remove only param', 'http://foo.com#?q=1&q=1',
|
|
utils.removeParam('http://foo.com?q=1#?q=1&q=1', 'q'));
|
|
assertEquals('remove last', 'http://foo.com?q=1&r=2#?s=1&s=1',
|
|
utils.removeParam('http://foo.com?q=1&r=2&s=3#?s=1&s=1', 's'));
|
|
}
|
|
|
|
|
|
function testRemoveNonExistent() {
|
|
assertEquals('remove key not present', 'http://foo.com?q=1',
|
|
utils.removeParam('http://foo.com?q=1', 'nosuchkey'));
|
|
assertEquals('remove key not present', 'http://foo.com#q=1',
|
|
utils.removeParam('http://foo.com#q=1', 'q'));
|
|
assertEquals('remove key from empty string', '',
|
|
utils.removeParam('', 'nosuchkey'));
|
|
}
|
|
|
|
|
|
function testRemoveMultiple() {
|
|
assertEquals('remove four of the same', 'http://foo.com',
|
|
utils.removeParam('http://foo.com?q=1&q=2&q=3&q=4', 'q'));
|
|
assertEquals('remove four of the same with another one in the middle',
|
|
'http://foo.com?a=99',
|
|
utils.removeParam('http://foo.com?q=1&q=2&a=99&q=3&q=4', 'q'));
|
|
}
|
|
|
|
|
|
function testSetParam() {
|
|
assertEquals('middle, no fragment', 'http://foo.com?q=1&s=3&r=999',
|
|
utils.setParam('http://foo.com?q=1&r=2&s=3', 'r', 999));
|
|
assertEquals('middle', 'http://foo.com?q=1&s=3&r=999#?r=1&r=1',
|
|
utils.setParam('http://foo.com?q=1&r=2&s=3#?r=1&r=1', 'r', 999));
|
|
assertEquals('first', 'http://foo.com?r=2&s=3&q=999#?q=1&q=1',
|
|
utils.setParam('http://foo.com?q=1&r=2&s=3#?q=1&q=1', 'q', 999));
|
|
assertEquals('only param', 'http://foo.com?q=999#?q=1&q=1',
|
|
utils.setParam('http://foo.com?q=1#?q=1&q=1', 'q', 999));
|
|
assertEquals('last', 'http://foo.com?q=1&r=2&s=999#?s=1&s=1',
|
|
utils.setParam('http://foo.com?q=1&r=2&s=3#?s=1&s=1', 's', 999));
|
|
assertEquals('multiple', 'http://foo.com?s=999#?s=1&s=1',
|
|
utils.setParam('http://foo.com?s=1&s=2&s=3#?s=1&s=1', 's', 999));
|
|
assertEquals('none', 'http://foo.com?r=1&s=999#?s=1&s=1',
|
|
utils.setParam('http://foo.com?r=1#?s=1&s=1', 's', 999));
|
|
}
|
|
|
|
|
|
function testModifyQueryParams() {
|
|
var uri = 'http://foo.com?a=A&a=A2&b=B&b=B2&c=C';
|
|
|
|
uri = utils.appendParam(uri, 'd', 'D');
|
|
assertEquals('http://foo.com?a=A&a=A2&b=B&b=B2&c=C&d=D', uri);
|
|
|
|
uri = utils.removeParam(uri, 'd');
|
|
uri = utils.appendParam(uri, 'd', 'D2');
|
|
assertEquals('http://foo.com?a=A&a=A2&b=B&b=B2&c=C&d=D2', uri);
|
|
|
|
uri = utils.removeParam(uri, 'a');
|
|
uri = utils.appendParam(uri, 'a', 'A3');
|
|
assertEquals('http://foo.com?b=B&b=B2&c=C&d=D2&a=A3', uri);
|
|
|
|
uri = utils.removeParam(uri, 'a');
|
|
uri = utils.appendParam(uri, 'a', 'A4');
|
|
assertEquals('A4', utils.getParamValue(uri, 'a'));
|
|
}
|
|
|
|
|
|
function testBrowserEncoding() {
|
|
// Sanity check borrowed from old code to ensure that encodeURIComponent
|
|
// is good enough. Entire test should be safe to delete.
|
|
var allowedInFragment = /[A-Za-z0-9\-\._~!$&'()*+,;=:@/?]/g;
|
|
|
|
var sb = [];
|
|
for (var i = 33; i < 500; i++) { // arbitrarily use first 500 chars.
|
|
sb.push(String.fromCharCode(i));
|
|
}
|
|
var testString = sb.join('');
|
|
|
|
var encodedStr = encodeURIComponent(testString);
|
|
|
|
// Strip all percent encoded characters, as they're ok.
|
|
encodedStr = encodedStr.replace(/%[0-9A-F][0-9A-F]/g, '');
|
|
|
|
// Remove allowed characters.
|
|
encodedStr = encodedStr.replace(allowedInFragment, '');
|
|
|
|
// Only illegal characters should remain, which is a fail.
|
|
assertEquals('String should be empty', 0, encodedStr.length);
|
|
}
|
|
|
|
|
|
function testAppendPath() {
|
|
var uri = 'http://www.foo.com';
|
|
var expected = uri + '/dummy';
|
|
assertEquals('Path has no trailing "/", adding with leading "/" failed',
|
|
expected,
|
|
goog.uri.utils.appendPath(uri, '/dummy'));
|
|
assertEquals('Path has no trailing "/", adding with no leading "/" failed',
|
|
expected,
|
|
goog.uri.utils.appendPath(uri, 'dummy'));
|
|
uri = uri + '/';
|
|
assertEquals('Path has trailing "/", adding with leading "/" failed',
|
|
expected,
|
|
goog.uri.utils.appendPath(uri, '/dummy'));
|
|
|
|
assertEquals('Path has trailing "/", adding with no leading "/" failed',
|
|
expected,
|
|
goog.uri.utils.appendPath(uri, 'dummy'));
|
|
}
|
|
|
|
|
|
function testMakeUnique() {
|
|
assertEquals('http://www.google.com?zx=RANDOM#blob',
|
|
goog.uri.utils.makeUnique('http://www.google.com#blob'));
|
|
assertEquals('http://www.google.com?a=1&b=2&zx=RANDOM#blob',
|
|
goog.uri.utils.makeUnique('http://www.google.com?zx=9&a=1&b=2#blob'));
|
|
}
|
|
|
|
|
|
function testParseQuery() {
|
|
var result = [];
|
|
goog.uri.utils.parseQueryData(
|
|
'foo=bar&no&empty=&tricky%3D%26=%3D%26&=nothing&=&',
|
|
function(name, value) { result.push(name, value); });
|
|
assertArrayEquals(
|
|
['foo', 'bar',
|
|
'no', '',
|
|
'empty', '',
|
|
'tricky%3D%26', '=&',
|
|
'', 'nothing',
|
|
'', '',
|
|
'', ''],
|
|
result);
|
|
|
|
// Go thought buildQueryData and parseQueryData and see if we get the same
|
|
// result.
|
|
var result2 = [];
|
|
goog.uri.utils.parseQueryData(
|
|
goog.uri.utils.buildQueryData(result),
|
|
function(name, value) { result2.push(name, value); });
|
|
assertArrayEquals(result, result2);
|
|
}
|
|
|
|
|