element cannot be parsed");
29 |
30 | t.end();
31 | });
32 |
--------------------------------------------------------------------------------
/tests/lib/send-request.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var sendRequest = require("../../lib/send-request.js");
4 |
5 | // Polyfill responseURL property into XMLHttpRequest if it doesn't exist,
6 | // just for the purposes of this test
7 | // This polyfill is not complete; it won't show the updated location if a
8 | // redirection occurred, but it's fine for our purposes.
9 | if (!("responseURL" in XMLHttpRequest.prototype)) {
10 | var nativeOpen = XMLHttpRequest.prototype.open;
11 | XMLHttpRequest.prototype.open = function(method, url) {
12 | this.responseURL = url;
13 | return nativeOpen.apply(this, arguments);
14 | };
15 | }
16 |
17 | tape("test xhr request", function(t) {
18 | var url = "https://httpbin.org/get";
19 |
20 | t.test("- request is made, gets a result, and is cache-busted", function(t) {
21 | var r = sendRequest(url, { cacheBust: true }, function(result) {
22 | t.equal(
23 | r.responseURL.indexOf("?"),
24 | url.length,
25 | "XHR URL is cache-busted when configured to be"
26 | );
27 | try {
28 | result = JSON.parse(result);
29 | } catch (e) {
30 | t.fail("xhr doesn't get a JSON response");
31 | }
32 | t.same(typeof result, "object", "xhr request get a result");
33 | t.end();
34 | });
35 | });
36 | t.test("- request is not cache-busted when configured not to be", function(
37 | t
38 | ) {
39 | var r = sendRequest(url, {}, function() {
40 | t.equal(r.responseURL, url, "XHR URL is left untouched");
41 | t.end();
42 | });
43 | });
44 | t.end();
45 | });
46 |
47 | tape("request headers are sent properly", function(t) {
48 | var url = "https://httpbin.org/headers";
49 | var options = {
50 | selectors: ["div.pjax", "div.container"]
51 | };
52 |
53 | sendRequest(url, options, function(responseText) {
54 | var headers = JSON.parse(responseText).headers;
55 |
56 | t.equals(
57 | headers["X-Requested-With"],
58 | "XMLHttpRequest",
59 | "X-Requested-With header is set correctly"
60 | );
61 | // Httpbin.org changes the case to 'X-Pjax'
62 | t.equals(headers["X-Pjax"], "true", "X-PJAX header is set correctly");
63 | t.equals(
64 | headers["X-Pjax-Selectors"],
65 | '["div.pjax","div.container"]',
66 | "X-PJAX-Selectors header is set correctly"
67 | );
68 |
69 | t.end();
70 | });
71 | });
72 |
73 | tape("HTTP status codes other than 200 are handled properly", function(t) {
74 | var url = "https://httpbin.org/status/400";
75 |
76 | sendRequest(url, {}, function(responseText, request) {
77 | t.equals(responseText, null, "responseText is null");
78 | t.equals(request.status, 400, "HTTP status code is correct");
79 |
80 | t.end();
81 | });
82 | });
83 |
84 | tape.skip("XHR error is handled properly", function(t) {
85 | var url = "https://encrypted.google.com/foobar";
86 |
87 | sendRequest(url, {}, function(responseText) {
88 | t.equals(responseText, null, "responseText is null");
89 |
90 | t.end();
91 | });
92 | });
93 |
94 | tape("POST body data is sent properly", function(t) {
95 | var url = "https://httpbin.org/post";
96 | var params = [
97 | {
98 | name: "test",
99 | value: "1"
100 | }
101 | ];
102 | var options = {
103 | requestOptions: {
104 | requestMethod: "POST",
105 | requestParams: params
106 | }
107 | };
108 |
109 | sendRequest(url, options, function(responseText) {
110 | var response = JSON.parse(responseText);
111 |
112 | t.same(
113 | response.form[params[0].name],
114 | params[0].value,
115 | "requestParams were sent properly"
116 | );
117 | t.equals(
118 | response.headers["Content-Type"],
119 | "application/x-www-form-urlencoded",
120 | "Content-Type header was set properly"
121 | );
122 |
123 | t.end();
124 | });
125 | });
126 |
127 | tape("GET query data is sent properly", function(t) {
128 | var url = "https://httpbin.org/get";
129 | var params = [
130 | {
131 | name: "test",
132 | value: "1"
133 | }
134 | ];
135 | var options = {
136 | requestOptions: {
137 | requestParams: params
138 | }
139 | };
140 |
141 | sendRequest(url, options, function(responseText) {
142 | var response = JSON.parse(responseText);
143 |
144 | t.same(
145 | response.args[params[0].name],
146 | params[0].value,
147 | "requestParams were sent properly"
148 | );
149 |
150 | t.end();
151 | });
152 | });
153 |
154 | tape("XHR timeout is handled properly", function(t) {
155 | var url = "https://httpbin.org/delay/5";
156 | var options = {
157 | timeout: 1000
158 | };
159 |
160 | sendRequest(url, options, function(responseText) {
161 | t.equals(responseText, null, "responseText is null");
162 |
163 | t.end();
164 | });
165 | });
166 |
--------------------------------------------------------------------------------
/tests/lib/switch-selectors.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var switchesSelectors = require("../../lib/switches-selectors.js");
4 | var noop = require("../../lib/util/noop");
5 |
6 | var pjax = {
7 | onSwitch: function() {
8 | console.log("Switched");
9 | },
10 | state: {},
11 | log: noop
12 | };
13 |
14 | // @author darylteo
15 | tape("test switchesSelectors", function(t) {
16 | // switchesSelectors relies on a higher level function callback
17 | // should really be passed in instead so I'll leave it here as a TODO:
18 | var tmpEl = document.implementation.createHTMLDocument();
19 |
20 | // a div container is used because swapping the containers
21 | // will generate a new element, so things get weird
22 | // using "body" generates a lot of testling cruft that I don't
23 | // want so let's avoid that
24 | var container = document.createElement("div");
25 | container.innerHTML = "
Original Text
No Change";
26 | document.body.appendChild(container);
27 |
28 | var container2 = tmpEl.createElement("div");
29 | container2.innerHTML = "
New Text
New Span";
30 | tmpEl.body.appendChild(container2);
31 |
32 | switchesSelectors.bind(pjax)(
33 | {}, // switches
34 | {}, // switchesOptions
35 | ["p"], // selectors,
36 | tmpEl, // fromEl
37 | document, // toEl,
38 | {} // options
39 | );
40 |
41 | t.equals(
42 | container.innerHTML,
43 | "
New Text
No Change",
44 | "Elements correctly switched"
45 | );
46 |
47 | t.end();
48 | });
49 |
50 | tape("test switchesSelectors when number of elements don't match", function(t) {
51 | var newTempDoc = document.implementation.createHTMLDocument();
52 | var originalTempDoc = document.implementation.createHTMLDocument();
53 |
54 | // a div container is used because swapping the containers
55 | // will generate a new element, so things get weird
56 | // using "body" generates a lot of testling cruft that I don't
57 | // want so let's avoid that
58 | var container = originalTempDoc.createElement("div");
59 | container.innerHTML = "
Original text
No change";
60 | originalTempDoc.body.appendChild(container);
61 |
62 | var container2 = newTempDoc.createElement("div");
63 | container2.innerHTML =
64 | "
New text
More new text
New span";
65 | newTempDoc.body.appendChild(container2);
66 |
67 | var switchSelectorsFn = switchesSelectors.bind(
68 | pjax,
69 | {}, // switches
70 | {}, // switchesOptions
71 | ["p"], // selectors,
72 | newTempDoc, // fromEl
73 | originalTempDoc, // toEl,
74 | {} // options
75 | );
76 |
77 | t.throws(
78 | switchSelectorsFn,
79 | null,
80 | "error was thrown properly since number of elements don't match"
81 | );
82 |
83 | t.end();
84 | });
85 |
--------------------------------------------------------------------------------
/tests/lib/switches.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 | var switches = require("../../lib/switches");
3 | var noop = require("../../lib/util/noop");
4 |
5 | tape("test outerHTML switch", function(t) {
6 | var outerHTML = switches.outerHTML;
7 |
8 | var doc = document.implementation.createHTMLDocument();
9 |
10 | var container = doc.createElement("div");
11 | container.innerHTML = "
Original Text
";
12 | doc.body.appendChild(container);
13 |
14 | var p = doc.createElement("p");
15 | p.innerHTML = "New Text";
16 |
17 | outerHTML.bind({
18 | onSwitch: noop
19 | })(doc.querySelector("p"), p);
20 |
21 | t.equals(
22 | doc.querySelector("p").innerHTML,
23 | "New Text",
24 | "Elements correctly switched"
25 | );
26 | t.notEquals(
27 | doc.querySelector("p").id,
28 | "p",
29 | "other attributes overwritten correctly"
30 | );
31 |
32 | t.end();
33 | });
34 |
35 | tape("test innerHTML switch", function(t) {
36 | var innerHTML = switches.innerHTML;
37 |
38 | var doc = document.implementation.createHTMLDocument();
39 |
40 | var container = doc.createElement("div");
41 | container.innerHTML = "
Original Text
";
42 | doc.body.appendChild(container);
43 |
44 | var p = doc.createElement("p");
45 | p.innerHTML = "New Text";
46 | p.className = "p";
47 |
48 | innerHTML.bind({
49 | onSwitch: noop
50 | })(doc.querySelector("p"), p);
51 |
52 | t.equals(
53 | doc.querySelector("p").innerHTML,
54 | "New Text",
55 | "Elements correctly switched"
56 | );
57 | t.equals(doc.querySelector("p").className, "p", "classname set correctly");
58 | t.equals(doc.querySelector("p").id, "p", "other attributes set correctly");
59 |
60 | p.removeAttribute("class");
61 |
62 | innerHTML.bind({
63 | onSwitch: noop
64 | })(doc.querySelector("p"), p);
65 |
66 | t.equals(doc.querySelector("p").className, "", "classname set correctly");
67 |
68 | t.end();
69 | });
70 |
71 | tape("test replaceNode switch", function(t) {
72 | var replaceNode = switches.replaceNode;
73 |
74 | var doc = document.implementation.createHTMLDocument();
75 |
76 | var container = doc.createElement("div");
77 | container.innerHTML = "
Original Text
";
78 | doc.body.appendChild(container);
79 |
80 | var p = doc.createElement("p");
81 | p.innerHTML = "New Text";
82 |
83 | replaceNode.bind({
84 | onSwitch: noop
85 | })(doc.querySelector("p"), p);
86 |
87 | t.equals(
88 | doc.querySelector("div").innerHTML,
89 | "
New Text
",
90 | "Elements correctly switched"
91 | );
92 |
93 | t.end();
94 | });
95 |
--------------------------------------------------------------------------------
/tests/lib/uniqueid.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var uniqueid = require("../../lib/uniqueid.js");
4 |
5 | tape("test uniqueid", function(t) {
6 | var a = uniqueid();
7 | var b = uniqueid();
8 |
9 | t.notEqual(a, b, "Two calls to uniqueid produce different values");
10 |
11 | t.end();
12 | });
13 |
--------------------------------------------------------------------------------
/tests/lib/util/clone.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var clone = require("../../../lib/util/clone");
4 |
5 | tape("test clone method", function(t) {
6 | var obj = { one: 1, two: 2 };
7 | var cloned = clone(obj);
8 |
9 | t.notEqual(obj, cloned, "cloned object isn't the original object");
10 |
11 | t.same(obj, cloned, "cloned object has the same values as original object");
12 |
13 | cloned.three = 3;
14 | t.notSame(
15 | obj,
16 | cloned,
17 | "modified cloned object doesn't have the same values as original object"
18 | );
19 |
20 | t.end();
21 | });
22 |
--------------------------------------------------------------------------------
/tests/lib/util/contains.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var contains = require("../../../lib/util/contains.js");
4 |
5 | tape("test contains function", function(t) {
6 | var tempDoc = document.implementation.createHTMLDocument();
7 | tempDoc.body.innerHTML =
8 | "
";
9 | var selectors = ["div"];
10 | var el = tempDoc.body.querySelector("#el");
11 | t.equal(
12 | contains(tempDoc, selectors, el),
13 | true,
14 | "contains() returns true when a selector contains the element"
15 | );
16 |
17 | selectors = ["span"];
18 | t.equal(
19 | contains(tempDoc, selectors, el),
20 | false,
21 | "contains() returns false when the selectors do not contain the element"
22 | );
23 |
24 | t.end();
25 | });
26 |
--------------------------------------------------------------------------------
/tests/lib/util/extend.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var extend = require("../../../lib/util/extend");
4 |
5 | tape("test extend method", function(t) {
6 | var obj = { one: 1, two: 2 };
7 |
8 | var extended = extend({}, obj, { two: "two", three: 3 });
9 | t.notEqual(obj, extended, "extended object isn't the original object");
10 | t.notSame(
11 | obj,
12 | extended,
13 | "extended object doesn't have the same values as original object"
14 | );
15 | t.notSame(
16 | obj.two,
17 | extended.two,
18 | "extended object value overwrites value from original object"
19 | );
20 |
21 | extended = extend(null);
22 | t.equals(extended, null, "passing null returns null");
23 |
24 | t.end();
25 | });
26 |
--------------------------------------------------------------------------------
/tests/lib/util/noop.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var noop = require("../../../lib/util/noop");
4 |
5 | tape("test noop function", function(t) {
6 | t.equal(typeof noop, "function", "noop is a function");
7 | t.equal(noop(), undefined, "noop() returns nothing");
8 | t.end();
9 | });
10 |
--------------------------------------------------------------------------------
/tests/lib/util/update-query-string.js:
--------------------------------------------------------------------------------
1 | var tape = require("tape");
2 |
3 | var updateQueryString = require("../../../lib/util/update-query-string");
4 |
5 | tape("test update query string method", function(t) {
6 | var url = "http://example.com";
7 | var updatedUrl = updateQueryString(url, "foo", "bar");
8 |
9 | t.notEqual(url, updatedUrl, "update query string modifies URL");
10 | t.equal(
11 | updatedUrl,
12 | url + "?foo=bar",
13 | "update query string creates new query string when no query string params are set"
14 | );
15 |
16 | updatedUrl = updateQueryString(updatedUrl, "foo", "baz");
17 |
18 | t.equal(
19 | updatedUrl,
20 | url + "?foo=baz",
21 | "update query string updates existing query string param"
22 | );
23 |
24 | updatedUrl = updateQueryString(updatedUrl, "bar", "");
25 |
26 | t.equal(
27 | updatedUrl,
28 | url + "?foo=baz&bar=",
29 | "update query string appends to existing query string"
30 | );
31 |
32 | t.end();
33 | });
34 |
--------------------------------------------------------------------------------
/tests/setup.js:
--------------------------------------------------------------------------------
1 | var jsdomOptions = {
2 | url: "https://example.org/",
3 | runScripts: "dangerously"
4 | };
5 |
6 | require("jsdom-global")("", jsdomOptions);
7 |
--------------------------------------------------------------------------------
/tests/test.ts:
--------------------------------------------------------------------------------
1 | import Pjax = require("../index");
2 |
3 | let options: Pjax.IOptions = {
4 | elements: "a.pjax, form.pjax",
5 | selectors: ["div.pjax"],
6 | switches: {
7 | "a.pjax": (oldEl, newEl) => {
8 | oldEl.parentNode.replaceChild(newEl, oldEl);
9 | this.onSwitch();
10 | },
11 | "form.pjax": Pjax.switches.innerHTML
12 | },
13 | switchesOptions: {},
14 | history: true,
15 | analytics: false,
16 | scrollTo: 1,
17 | scrollRestoration: false,
18 | cacheBust: false,
19 | debug: true,
20 | timeout: 60000,
21 | currentUrlFullReload: true
22 | };
23 |
24 | options.analytics = () => {};
25 | options.scrollTo = [1, 1];
26 | options.scrollTo = false;
27 |
28 | if (Pjax.isSupported()) {
29 | delete options.switchesOptions;
30 | const pjax = new Pjax(options);
31 |
32 | pjax.reload();
33 | pjax.loadUrl("https://example.org", options);
34 |
35 | pjax._handleResponse = pjax.handleResponse;
36 | pjax.handleResponse = (requestText: string, request: XMLHttpRequest, href: string) => {
37 | pjax.abortRequest(request);
38 |
39 | return pjax._handleResponse(requestText, request, href);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------