@qooxdoo/framework/source/class/qx/test/bom/request/SimpleXhr.js

The JS Framework for Coders

/* ************************************************************************

   qooxdoo - the new era of web development

   http://qooxdoo.org

   Copyright:
     2013 1&1 Internet AG, Germany, http://www.1und1.de

   License:
     MIT: https://opensource.org/licenses/MIT
     See the LICENSE file in the project's top-level directory for details.

   Authors:
     * Richard Sternagel (rsternagel)

************************************************************************ */

qx.Class.define("qx.test.bom.request.SimpleXhr", {
  extend: qx.dev.unit.TestCase,

  include: [qx.dev.unit.MMock],

  members: {
    setUp() {
      this.req = new qx.bom.request.SimpleXhr();
    },

    tearDown() {
      this.req = null;
      this.getSandbox().restore();
    },

    //
    // setRequestHeader()
    // getRequestHeader()
    //

    "test: set/get request header"() {
      var key = "Accept",
        value = "application/json";

      this.assertEquals(
        value,
        this.req.setRequestHeader(key, value).getRequestHeader(key)
      );
    },

    //
    // setUrl()
    // getUrl()
    //

    "test: set/get url"() {
      var url = "http://example.org";

      this.assertEquals(url, this.req.setUrl(url).getUrl());
    },

    //
    // setMethod()
    // getMethod()
    //

    "test: set/get method"() {
      var method = "GET";

      this.assertEquals(method, this.req.setMethod(method).getMethod());
    },

    //
    // setRequestData()
    // getRequestData()
    //

    "test: set/get request data"() {
      var data = { abc: "def", uvw: "xyz" };

      this.assertEquals(data, this.req.setRequestData(data).getRequestData());
    },

    //
    // _setResponse()
    // getResponse()
    //

    "test: set/get response"() {
      var req = this.req,
        json = '{"animals": ["monkey", "mouse"]}',
        xml = "<animals><monkey/><mouse/></animals>",
        obj = { a: "b" };

      req._transport.responseText = json;
      this.assertEquals(json, req.getResponse());

      req._transport.responseXML = xml;
      this.assertEquals(xml, req.getResponse());

      req._setResponse(obj);
      this.assertEquals(obj, req.getResponse());
    },

    //
    // setTimeout()
    // getTimeout()
    //

    "test: set/get timeout in millis"() {
      this.assertEquals(150, this.req.setTimeout(150).getTimeout());
    },

    //
    //  useCaching
    //  isCaching
    //

    "test: use/is caching"() {
      this.assertTrue(this.req.useCaching(true).isCaching());
      this.assertFalse(this.req.useCaching(false).isCaching());
    },

    //
    // setParser()
    //

    "test: set (custom) parser"() {
      var req = this.req,
        acceptedParser = null,
        customParser = function () {};

      acceptedParser = req.setParser(customParser);
      this.assertEquals(customParser, acceptedParser);
    },

    //
    // _serializeData()
    //

    "test: serialize data"() {
      var data = { abc: "def", uvw: "xyz" },
        contentType = "application/json";

      this.assertNull(this.req._serializeData(null));
      this.assertEquals(
        "leaveMeIntact",
        this.req._serializeData("leaveMeIntact")
      );

      this.assertEquals("abc=def&uvw=xyz", this.req._serializeData(data));
      this.assertEquals(
        "abc=def&uvw=xyz",
        this.req._serializeData(data, "arbitrary/contentType")
      );

      this.assertEquals(
        '{"abc":"def","uvw":"xyz"}',
        this.req._serializeData(data, contentType)
      );

      this.assertEquals(
        "[1,2,3]",
        this.req._serializeData([1, 2, 3], contentType)
      );
    },

    //
    // send()
    //

    stubTransportMethods(methods) {
      var stubbedTransport = this.req._createTransport(),
        l = methods.length;

      while (l--) {
        this.stub(stubbedTransport, methods[l]);
      }
      this.req._transport = stubbedTransport;
      return stubbedTransport;
    },

    "test: send() w/ timeout"() {
      var req = this.req,
        method = "GET",
        url = "http://example.org",
        stubbedTransport = {};

      req.setUrl(url);
      req.setTimeout(150);
      stubbedTransport = this.stubTransportMethods(["open", "send"]);
      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url, true);
      this.assertCalledWith(stubbedTransport.send);
      this.assertEquals(stubbedTransport.timeout, req.getTimeout());
    },

    "test: send() w/o data and w/o headers"() {
      var req = this.req,
        method = "GET",
        url = "http://example.org",
        stubbedTransport = {};

      req.setUrl(url);
      stubbedTransport = this.stubTransportMethods(["open", "send"]);
      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url, true);
      this.assertCalledWith(stubbedTransport.send);
    },

    "test: send() GET w/ data and w/ headers"() {
      var req = this.req,
        method = "GET",
        url = "http://example.org",
        obj = { a: "b" },
        stubbedTransport = {};

      req.setUrl(url);
      req.setRequestHeader("Accept", "application/json");
      req.setRequestData(obj);
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url + "?a=b", true);
      this.assertCalledWith(
        stubbedTransport.setRequestHeader,
        "Accept",
        "application/json"
      );

      this.assertCalledWith(stubbedTransport.send);
    },

    "test: send() GET w/ enabled caching sets nocache param"() {
      var req = this.req,
        method = "GET",
        url = "http://example.org",
        expectedUrl = new RegExp(url + "\\?nocache=[0-9]{13,}"),
        stubbedTransport = {};

      req.setUrl(url);
      req.useCaching(false);
      stubbedTransport = this.stubTransportMethods(["open", "send"]);
      req.send();

      this.assertCalledWithMatch(
        stubbedTransport.open,
        method,
        expectedUrl,
        true
      );

      this.assertCalledWith(stubbedTransport.send);
    },

    "test: send() GET w/ caching header overrides cache prevention"() {
      var req = this.req,
        method = "GET",
        url = "http://example.org",
        stubbedTransport = {};

      req.setUrl(url);
      req.setRequestHeader("Cache-Control", "no-cache");
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url, true);
      this.assertCalledWith(
        stubbedTransport.setRequestHeader,
        "Cache-Control",
        "no-cache"
      );

      this.assertCalledWith(stubbedTransport.send);
    },

    "test: send() POST w/ data (default content-type)"() {
      var req = this.req,
        method = "POST",
        url = "http://example.org",
        obj = { a: "b" },
        stubbedTransport = {};

      req.setUrl(url);
      req.setMethod(method);
      req.setRequestData(obj);
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url, true);
      this.assertCalledWith(
        stubbedTransport.setRequestHeader,
        "Content-Type",
        "application/x-www-form-urlencoded"
      );

      this.assertCalledWith(stubbedTransport.send, "a=b");
    },

    "test: send() POST w/ data (application/json)"() {
      var req = this.req,
        method = "POST",
        url = "http://example.org",
        obj = { a: "b" },
        stubbedTransport = {};

      req.setUrl(url);
      req.setMethod(method);
      req.setRequestData(obj);
      req.setRequestHeader("Content-Type", "application/json");
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.open, method, url, true);
      this.assertCalledWith(stubbedTransport.send, qx.lang.Json.stringify(obj));
    },

    "test: send() POST w/ FormData"() {
      var req = this.req,
        method = "POST",
        url = "http://example.org",
        stubbedTransport = {};

      if (!window.FormData) {
        this.skip("FormData API not supported");
      }

      if (!req.setMethod) {
        this.skip("POST requests not supported by this transport");
      }

      var formData = new FormData();
      formData.append("foo", "bar");
      formData.append("baz", "qux");

      req.setUrl(url);
      req.setMethod(method);
      req.setRequestData(formData);
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.send, formData);
    },

    "test: send() POST w/ Blob"() {
      var req = this.req,
        method = "POST",
        url = "http://example.org",
        stubbedTransport = {};

      if (!window.Blob) {
        this.skip("Blob API not supported");
      }

      if (!req.setMethod) {
        this.skip("POST requests not supported by this transport");
      }

      var blob = new window.Blob(["abc123"], { type: "text/plain" });

      req.setUrl(url);
      req.setMethod(method);
      req.setRequestData(blob);
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.send, blob);
    },

    "test: send() POST w/ ArrayBuffer"() {
      var req = this.req,
        method = "POST",
        url = "http://example.org",
        stubbedTransport = {};

      if (!window.ArrayBuffer) {
        this.skip("ArrayBuffer API not supported");
      }

      if (!req.setMethod) {
        this.skip("POST requests not supported by this transport");
      }

      var arrayBuffer = new window.ArrayBuffer(512);

      req.setUrl(url);
      req.setMethod(method);
      req.setRequestData(arrayBuffer);
      stubbedTransport = this.stubTransportMethods([
        "open",
        "setRequestHeader",
        "send"
      ]);

      req.send();

      this.assertCalledWith(stubbedTransport.send, arrayBuffer);
    },

    //
    // abort()
    //

    "test: abort() aborts transport"() {
      var stubbedTransport = this.stubTransportMethods(["abort"]);
      this.req.abort();

      this.assertCalled(stubbedTransport.abort);
    },

    //
    // dispose()
    //

    "test: dispose() disposes transport"() {
      this.assertTrue(this.req.dispose());
    },

    //
    // addListenerOnce()
    //

    "test: addListenerOnce() event handler"() {
      var req = this.req,
        stubbedTransport = this.req._createTransport(),
        name = "test-success",
        listener = function () {},
        ctx = this;

      this.stub(req, "once");
      req._transport = stubbedTransport;

      req.addListenerOnce(name, listener, ctx);
      this.assertCalledWith(req.once, name, listener, ctx);
    },

    //
    // _onReadyStateChange()
    // __onReadyStateDone()
    //

    "test: _onReadyStateDone() success"() {
      var req = this.req,
        json = '{"animals": ["monkey", "mouse"]}',
        obj = { animals: ["monkey", "mouse"] },
        contentType = "application/json",
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      this.stub(stubbedTransport, "getResponseHeader").returns(contentType);
      req._transport = req._registerTransportListener(stubbedTransport);
      req._transport.readyState = qx.bom.request.Xhr.DONE;
      req._transport.responseText = json;
      req._transport.status = 200;

      req._transport.onreadystatechange();

      this.assertArrayEquals(obj.animals, req.getResponse().animals);
      this.assertCalledWith(req.emit, "success");
    },

    "test: _onReadyStateDone() fail w/ response"() {
      var req = this.req,
        json = '{"animals": ["monkey", "mouse"]}',
        obj = { animals: ["monkey", "mouse"] },
        contentType = "application/json",
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      this.stub(stubbedTransport, "getResponseHeader").returns(contentType);
      req._transport = req._registerTransportListener(stubbedTransport);
      req._transport.readyState = qx.bom.request.Xhr.DONE;
      req._transport.responseText = json;
      req._transport.status = 404;

      req._transport.onreadystatechange();

      this.assertArrayEquals(obj.animals, req.getResponse().animals);
      this.assertCalledWith(req.emit, "fail");
    },

    "test: _onReadyStateDone() fail w/o response"() {
      var req = this.req,
        contentType = "hasToExist/ButContentDoesntMatter",
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      this.stub(stubbedTransport, "getResponseHeader").returns(contentType);
      req._transport = req._registerTransportListener(stubbedTransport);
      req._transport.readyState = qx.bom.request.Xhr.DONE;
      req._transport.status = 404;

      req._transport.onreadystatechange();

      this.assertEquals("", req.getResponse());
      this.assertCalledWith(req.emit, "fail");
    },

    //
    // onLoadEnd()
    //

    "test: onLoadEnd()"() {
      var req = this.req,
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      req._transport = req._registerTransportListener(stubbedTransport);

      req._transport.onloadend();

      this.assertCalledWith(req.emit, "loadEnd");
    },

    //
    // onAbort()
    //

    "test: onAbort()"() {
      var req = this.req,
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      req._transport = req._registerTransportListener(stubbedTransport);

      req._transport.onabort();

      this.assertCalledWith(req.emit, "abort");
    },

    //
    // onTimeout()
    //

    "test: onTimeout()"() {
      var req = this.req,
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      req._transport = req._registerTransportListener(stubbedTransport);

      req._transport.ontimeout();

      this.assertCalledWith(req.emit, "timeout");
      this.assertEquals(2, req.emit.callCount); // + emit("fail")
    },

    //
    // onError()
    //

    "test: onError()"() {
      var req = this.req,
        stubbedTransport = req._createTransport();

      // prep transport
      this.stub(req, "emit");
      req._transport = req._registerTransportListener(stubbedTransport);

      req._transport.onerror();

      this.assertCalledWith(req.emit, "error");
      this.assertEquals(2, req.emit.callCount); // + emit("fail")
    },

    testGetResponseHeaders() {
      this.useFakeServer();
      this.getServer().autoRespond = true;
      this.getServer().respondWith("GET", "/foo", [
        200,
        {
          "x-affe": "AFFE"
        },

        "Response Body"
      ]);

      var req = new qx.bom.request.SimpleXhr("/foo", "GET");
      req.on(
        "success",
        function () {
          this.resume(
            function () {
              this.assertEquals("AFFE", req.getResponseHeader("x-affe"));
              var headers = req.getAllResponseHeaders();
              this.assertMatch(headers, /x-affe.*?AFFE/);
            }.bind(this)
          );
        }.bind(this)
      );

      window.setTimeout(function () {
        req.send();
      }, 100);

      this.wait(500);
    }
  }
});