@qooxdoo/framework 7.0.0-beta.2 → 7.0.0-beta.6

package/source/class/qx/io/transport/Xhr.js

@@ -0,0 +1,139 @@
+/**
+ * The implementation of a HTTP Transport using the {@link qx.io.request} API,
+ * so any special configuration of the HTTP request must be done on the
+ * underlying implementation of {@link qx.io.request.AbstractRequest}.
+ *
+ * The assumption is that the payload will be JSON in both request and response.
+ * If that is not what you want, override the {@link #_createTransportImpl()} method.
+ *
+ */
+qx.Class.define("qx.io.transport.Xhr", {
+  extend: qx.io.transport.AbstractTransport,
+  implement : qx.io.transport.ITransport,
+
+  /**
+   * Constructor.
+   *
+   * @param {String} url The URL of the http endpoint
+   */
+  construct(url) {
+    this.base(arguments, url);
+  },
+
+  members: {
+
+    /**
+     * Internal implementation of the transport
+     * @var {qx.io.request.Xhr}
+     */
+    __tranportImpl : null,
+
+    /**
+     * Returns the object which implements the transport on the
+     * underlying level, so that transport-specific configuration
+     * can be done on it. Note that since in the HTTP transport,
+     * this object cannot be reused, it will return a new object
+     * each time which will be used in the immediately next request.
+     *
+     * @return {qx.io.request.Xhr}
+     */
+    getTransportImpl() {
+      this.__tranportImpl = this._createTransportImpl();
+      return this.__tranportImpl;
+    },
+
+    /**
+     * Transport the given message to the endpoint
+     *
+     * @param {String} message
+     *
+     * @return {qx.Promise} Promise that resolves (with no data)
+     * when the message has been successfully sent out, and rejects
+     * when there is an error or a cancellation up to that point.
+     */
+    async send(message) {
+      qx.core.Assert.assertString(message);
+      const req = this.__tranportImpl || this.getTransportImpl();
+      req.setRequestData(message);
+      this.__tranportImpl = null; // free the internal reference for the next request
+      try {
+        await req.sendWithPromise();
+      } catch (e) {
+        if (e instanceof qx.type.BaseError) {
+          switch (e.getComment()) {
+            case "timeout":
+              throw new qx.io.exception.Transport(
+                e.toString(),
+                qx.io.exception.Transport.TIMEOUT,
+                {message}
+              );
+            case "parseError":
+              throw new qx.io.exception.Transport(
+                e.toString(),
+                qx.io.exception.Transport.INVALID_MSG_DATA,
+                {message}
+              );
+            case "abort":
+              throw new qx.io.exception.Cancel(
+                e.toString(),
+                {message}
+              );
+            case "statusError":
+              if (req.getStatus() === 400) {
+                  // "400 Bad Request" is a really a protocol error (syntax error)
+                  break;
+              }
+              // fallthrough
+            case "error":
+              throw new qx.io.exception.Transport(
+                e.toString(),
+                qx.io.exception.Transport.FAILED,
+                {
+                  message,
+                  response: req.getResponse()
+                }
+              );
+            default:
+              // unknown error
+              throw new qx.io.exception.Exception(
+                e.toString(),
+                undefined,
+                {message, error:e}
+              );
+          }
+        }
+      }
+      // notify listeners
+      this.fireDataEvent("message", req.getResponse());
+      // discard old object
+      req.dispose();
+    },
+
+    /**
+     * Factory method to create a request object. By default, a POST
+     * request will be made, and the expected response type will be
+     * "application/json", but differently to the standard behavior,
+     * the response will not be parsed into a javascript object.
+     *
+     * Classes extending this one may override this method to obtain
+     * a Request object with different parameters and/or different
+     * authentication settings. The object must be a subclass of {@link
+     * qx.io.request.AbstractRequest} or implement its public API.
+     *
+     * @return {qx.io.request.Xhr}
+     */
+    _createTransportImpl() {
+      const req = new qx.io.request.Xhr(this.getEndpoint(), "POST");
+      req.setAccept("application/json");
+      req.setCache(false);
+      req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
+      // disable parsing, we are going to parse the JSON ourselves
+      req.setParser(response => response);
+      return req;
+    }
+  },
+
+  defer() {
+    qx.io.jsonrpc.Client.registerTransport(/^http/, qx.io.transport.Xhr);
+  }
+});

package/source/class/qx/io/transport/__init__.js

@@ -0,0 +1,18 @@
+/**
+ * <p>This namespace contains an interface for and different implementations of
+ * a transport for higher-level protocol data.</p>
+ *
+ * <p>{@link qx.io.transport.ITransport} specifies that a
+ * transport has to provide for three things:</p>
+ * <ol>
+ *   <li>It must have an "endpoint" property which is a representation of the
+ *      the endpoint. In most cases, it will be an URI which identifies where the
+ *      the server is located, but it can also be an object with which the transport
+ *      can interact.</li>
+ *   <li>It must have a "send" method which knows how to deliver an UTF-8
+ *      encoded message string to the endpoint, and</li>
+ *   <li>It must fire a "message" event when it receives such a message from
+ *      the peer, regardless if this message is a normal "response" (like in a
+ *      HTTP request) or an incoming message in a duplex communication channel.</li>
+ * </ol>
+ */

package/source/class/qx/test/io/MAssert.js

@@ -0,0 +1,46 @@
+/**
+ * Mixin containing special assert methods
+ */
+qx.Mixin.define("qx.test.io.MAssert", {
+
+  members : {
+
+    /**
+     * Deep equal comparison, using Sinon's `deepEqual` comparison.
+     * Two values are "deep equal" if:
+     *
+     *   - They are equal, according to samsam.identical
+     *   (https://sinonjs.github.io/samsam/)
+     *   - They are both date objects representing the same time
+     *   - They are both arrays containing elements that are all deepEqual
+     *   - They are objects with the same set of properties, and each property
+     *     in obj1 is deepEqual to the corresponding property in obj2
+     *
+     * Supports cyclic objects.
+     * @param {*} expected
+     * @param {*} actual
+     * @param {String?} msg
+     */
+    assertDeepEquals : function(expected, actual, msg) {
+      if (!msg) {
+        msg = `Failed to assert that ${qx.lang.Json.stringify(actual)} deeply equals ${qx.lang.Json.stringify(expected)}.`;
+      }
+      this.assert(qx.dev.unit.Sinon.getSinon().deepEqual(expected, actual), msg);
+    },
+
+    /**
+     * Asserts that a string fragment is contained in a result
+     * @param {String} expectedFragment
+     * @param {String} actual
+     * @param {String?} msg
+     */
+    assertContains: function(expectedFragment, actual, msg) {
+      this.assertString(expectedFragment);
+      this.assertString(actual);
+      if (!msg) {
+        msg = `Failed to assert that '${actual}' contains '${expectedFragment}'.`;
+      }
+      this.assert(actual.includes(expectedFragment), msg);
+    }
+  }
+});

package/source/class/qx/test/io/graphql/Client.js

@@ -0,0 +1,169 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * @require(qx.io.transport.Xhr)
+ * @ignore(fetch)
+ */
+qx.Class.define("qx.test.io.graphql.Client",
+  {
+    extend : qx.dev.unit.TestCase,
+    include : [qx.test.io.MAssert],
+    statics: {
+      TEST_ENDPOINT: "https://countries.trevorblades.com/"
+    },
+    construct() {
+      this.base(arguments);
+      let transport = new qx.io.transport.Xhr(this.constructor.TEST_ENDPOINT);
+      transport.getTransportImpl();
+      this.client = new qx.io.graphql.Client(transport);
+    },
+
+    members : {
+
+      __hasEndpoint: false,
+      __skipMsg: "Skipping test as endpoint is not available.",
+
+      async runQuery(query, expected) {
+        let req = new qx.io.graphql.protocol.Request({query});
+        let result = await this.client.send(req);
+        this.assertDeepEquals(expected, result)
+      },
+
+      async runQueryWithVariables(query, variables, expected) {
+        let req = new qx.io.graphql.protocol.Request({query});
+        req.setVariables(variables);
+        let result = await this.client.send(req);
+        this.assertDeepEquals(expected, result)
+      },
+
+      async "test: check endpoint"() {
+        try {
+          let url = this.constructor.TEST_ENDPOINT;
+          let body = '{"query":"{__typename}"}';
+          let init = {method:"POST", headers:{"Content-Type":"application/json"}, body};
+          let response = await fetch(url, init);
+          let result = await response.json();
+          this.assertDeepEquals({
+            "data": {
+              "__typename": "Query"
+            }
+          }, result);
+          this.__hasEndpoint = true;
+        } catch(e) {
+          console.error(`Endpoint ${this.constructor.TEST_ENDPOINT} is not accessible: ${e.message}`);
+        }
+      },
+
+      async "test: execute query"() {
+        if (!this.__hasEndpoint) {
+          return this.skip(this.__skipMsg);
+        }
+        await this.runQuery(`{
+          country(code: "BR") {
+            name
+            native
+            capital
+            currency
+            languages {
+              code
+              name
+            }
+          }
+        }`, {
+          "country": {
+            "name": "Brazil",
+            "native": "Brasil",
+            "capital": "Brasília",
+            "currency": "BRL",
+            "languages": [
+              {
+                "code": "pt",
+                "name": "Portuguese"
+              }
+            ]
+          }
+        });
+      },
+
+      async "test: execute query with variables"() {
+        if (!this.__hasEndpoint) {
+          return this.skip(this.__skipMsg);
+        }
+        await this.runQueryWithVariables(`query ($countryCode:ID!){
+          country(code: $countryCode) {
+            name
+            languages {
+              code
+              name
+            }
+          }
+        }`,
+          {"countryCode": "BE"},
+          {
+            "country": {
+              "name": "Belgium",
+              "languages": [
+                {
+                  "code": "nl",
+                  "name": "Dutch"
+                },
+                {
+                  "code": "fr",
+                  "name": "French"
+                },
+                {
+                  "code": "de",
+                  "name": "German"
+                }
+              ]
+            }
+        });
+      },
+
+      async "test: expect error after invalid query"() {
+        if (!this.__hasEndpoint) {
+          return this.skip(this.__skipMsg);
+        }
+        try {
+          await this.runQuery(`query { invalidSyntax }`);
+        } catch (e) {
+          this.assertInstance(e, qx.io.exception.Protocol);
+          this.assertContains("invalidSyntax", JSON.stringify(e.data));
+          return;
+        }
+        throw new Error("Query should return an error after invalid query");
+      },
+
+      async "test: expect transport error"() {
+        if (!this.__hasEndpoint) {
+          return this.skip(this.__skipMsg);
+        }
+        try {
+          const client = new qx.io.graphql.Client("https://doesnotexist.org/"+Math.random());
+          const query = "query { doesnotmatter }";
+          const request = new qx.io.graphql.protocol.Request({query});
+          await client.send(request);
+        } catch (e) {
+          this.assertInstance(e, qx.io.exception.Transport);
+          return;
+        }
+        throw new Error("Query should throw qx.io.exception.Transport");
+      }
+    }
+  });

package/source/class/qx/test/io/graphql/ClientFetch.js

@@ -0,0 +1,34 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * GraphQL tests using the Fetch API
+ */
+qx.Class.define("qx.test.io.graphql.ClientFetch",
+{
+  extend : qx.test.io.graphql.Client,
+  statics: {
+    TEST_ENDPOINT: "https://countries.trevorblades.com/"
+  },
+  construct() {
+    this.base(arguments);
+    let transport = new qx.io.transport.Fetch(this.constructor.TEST_ENDPOINT);
+    transport.getTransportImpl();
+    this.client = new qx.io.graphql.Client(transport);
+  }
+});

package/source/class/qx/test/io/graphql/Request.js

@@ -0,0 +1,42 @@
+/**
+ * @require(qx.io.transport.Xhr)
+ */
+qx.Class.define("qx.test.io.graphql.Request", {
+  extend: qx.dev.unit.TestCase,
+  include: [qx.test.io.MAssert],
+
+  members: {
+
+    "test: request can be converted to json": function() {
+      const query = "query { SomeRandomStuff }";
+      const variables = {"testKey": "testValue"};
+
+      const request = new qx.io.graphql.protocol.Request({query});
+      request.setVariables(variables);
+
+      const expected = "{\"query\":\"query { SomeRandomStuff }\",\"variables\":{\"testKey\":\"testValue\"}}";
+      this.assertEquals(expected, request.toString());
+    },
+
+    "test: no variables in the final string": function() {
+      const query = "query { SomeRandomStuff }";
+      const request = new qx.io.graphql.protocol.Request({query});
+      const expected = "{\"query\":\"query { SomeRandomStuff }\"}";
+      this.assertEquals(expected, request.toString());
+    },
+
+    "test: variables can be bound": function() {
+      const query = "query { SomeRandomStuff }";
+      const variables = {"testKey": "testValue"};
+      const request = new qx.io.graphql.protocol.Request({query});
+      request.setVariables(variables);
+
+      const model = qx.data.marshal.Json.createModel({source: "test"});
+      model.bind("source", request, "variables.testKey");
+      model.setSource("newTestValue");
+
+      this.assertMatch(request.toString(), /newTestValue/);
+    }
+  }
+});
+