@qooxdoo/framework 7.0.0-beta.1 → 7.0.0-beta.10

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

@@ -0,0 +1,190 @@
+/* ************************************************************************
+
+   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() {
+    super();
+    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() {
+    super();
+    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,41 @@
+/**
+ * @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"() {
+      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"() {
+      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"() {
+      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/);
+    }
+  }
+});

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

@@ -0,0 +1,333 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de & contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with a qx.test.io.request.Xhr transport
+ */
+qx.Class.define("qx.test.io.jsonrpc.Client", {
+  extend: qx.dev.unit.TestCase,
+
+  include: [qx.dev.unit.MMock, qx.test.io.MAssert],
+
+  members: {
+    setUp() {
+      this.sinon = qx.dev.unit.Sinon.getSinon();
+      this.setUpRequest();
+      this.setUpFakeTransport();
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    setUpRequest() {
+      this.req && this.req.dispose();
+      this.req = new qx.io.request.Xhr();
+      this.req.setUrl("url");
+    },
+
+    setUpFakeTransport() {
+      if (this.transport && this.transport.send.restore) {
+        return;
+      }
+      this.transport = this.injectStub(
+      	qx.io.request.Xhr.prototype,
+        "_createTransport",
+        this.deepStub(qx.io.request.Xhr.prototype._createTransport())
+      );
+
+      this.setUpRequest();
+    },
+
+    setUpFakeXhr() {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeXMLHttpRequest();
+      this.setUpRequest();
+    },
+
+    /**
+     * Sets up the fake server and instructs it to send the given response(s)
+     * @param {String} response The server response to the first request
+     */
+    setUpFakeServer(response) {
+      // Not fake transport
+      this.getSandbox().restore();
+      this.useFakeServer();
+      this.setUpRequest();
+      this.getServer().respondWith("POST", /.*/, [
+        200,
+        { "Content-Type": "application/json; charset=utf-8" },
+        response
+      ]);
+
+      this.getServer().autoRespond = true;
+    },
+
+    /**
+     * Assert that the given exception is thrown on receiving the given result
+     * @param {String} response
+     * @param {Class|Number} exception If class, the exception class, which must
+     * be a subclass of qx.io.exception.Exception. If number, the error number
+     */
+    assertExceptionThrown(response, exception) {
+      if (
+        !(
+          qx.lang.Type.isNumber(exception) ||
+          qx.Class.isSubClassOf(exception, qx.io.exception.Exception)
+        )
+      ) {
+        throw new Error(
+          "Second argument must be a Number or a subclass of qx.io.exception.Exception"
+        );
+      }
+      this.setUpFakeServer(response);
+      const message_out = new qx.io.jsonrpc.protocol.Request("foo", [1, 2, 3]);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      const errorCallback = this.spy(err => {
+        //console.warn(err);
+        if (qx.lang.Type.isNumber(exception)) {
+          if (!(err instanceof qx.io.exception.Exception)) {
+            throw err;
+          }
+          this.assertEquals(exception, err.code, `Error code does not match`);
+        } else {
+          this.assertInstance(
+            err,
+            exception,
+            `Exception class does not match. Expected ${exception.classname}, got ${err}.`
+          );
+        }
+      });
+      // check message promise
+      message_out.getPromise().catch(errorCallback);
+      // check event
+      client.addListener("error", evt => errorCallback(evt.getData()));
+      // check transport promise
+      client.send(message_out).catch(errorCallback);
+      this.wait(100, () => {
+        if (
+          // the request promise will not be called since the promise is already rejected
+          exception === qx.io.exception.Transport.DUPLICATE_ID ||
+          // or the send promise will not be rejected because we have a server-side error
+          exception === qx.io.exception.Protocol
+        ) {
+          this.assertCalledTwice(errorCallback);
+        } else {
+          // the error handler will be called three times
+          this.assertCalledThrice(errorCallback);
+        }
+      });
+    },
+
+    tearDown() {
+      this.getSandbox().restore();
+      this.req.dispose();
+    },
+
+    resetId() {
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    //
+    // Auth, should be moved into qx.test.io.request.Xhr
+    //
+
+    "test: Bearer authentication"() {
+      this.setUpFakeTransport();
+
+      var transport = this.transport,
+        auth,
+        call,
+        key,
+        credentials;
+
+      auth = new qx.io.request.authentication.Bearer("TOKEN");
+      this.req.setAuthentication(auth);
+      this.req.send();
+
+      call = transport.setRequestHeader.getCall(1);
+      key = "Authorization";
+      credentials = /Bearer\s(.*)/.exec(call.args[1])[1];
+      this.assertEquals(key, call.args[0]);
+      this.assertEquals("TOKEN", credentials);
+    },
+
+    //
+    // JSON-RPC
+    //
+
+    "test: throw on invalid response id"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({
+        jsonrpc: "2.0",
+        result: 19,
+        id: 2
+      });
+
+      this.assertExceptionThrown(
+        response,
+        qx.io.exception.Transport.UNKNOWN_ID
+      );
+    },
+
+    "test: throw on duplicate response id"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        { jsonrpc: "2.0", result: 19, id: 1 },
+        { jsonrpc: "2.0", result: 19, id: 1 }
+      ]);
+
+      this.assertExceptionThrown(
+        response,
+        qx.io.exception.Transport.DUPLICATE_ID
+      );
+    },
+
+    async "test: call jsonrpc method and receive response with single result"() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let message_in = new qx.io.jsonrpc.protocol.Result(
+        message_out.getId(),
+        result
+      );
+
+      this.setUpFakeServer(message_in.toString());
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    async "test: call jsonrpc method and receive batched response"() {
+      this.resetId();
+      let message_out = new qx.io.jsonrpc.protocol.Request("foo", ["bar"]);
+      let result = "Hello World!";
+      let response = new qx.io.jsonrpc.protocol.Batch()
+        .add(new qx.io.jsonrpc.protocol.Result(message_out.getId(), result))
+        .addRequest("foo", ["bar"])
+        .addNotification("logout")
+        .toString();
+      this.setUpFakeServer(response);
+      const client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      let spy = this.spy(value => this.assertEquals(result, value));
+      message_out.getPromise().then(spy);
+      await client.send(message_out);
+      this.assertCalled(spy);
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse "() {
+      this.assertExceptionThrown(
+        "helloworld!",
+        qx.io.exception.Transport.INVALID_JSON
+      );
+    },
+
+    "test: call jsonrpc method and expect error on invalid reponse - missing result"() {
+      this.assertExceptionThrown("null", qx.io.exception.Transport.NO_DATA);
+    },
+
+    "test: call jsonrpc method and expect error response"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32600, message: "Division by zero!" },
+        id: 1
+      });
+
+      this.assertExceptionThrown(response, qx.io.exception.Protocol);
+    },
+
+    "test: send batched requests"() {
+      this.resetId();
+      var response = qx.lang.Json.stringify([
+        { jsonrpc: "2.0", result: 7, id: 1 },
+        { jsonrpc: "2.0", result: "foo", id: 2 },
+        {
+          jsonrpc: "2.0",
+          error: { code: -32600, message: "Invalid Request" },
+          id: 3
+        },
+
+        {
+          jsonrpc: "2.0",
+          error: { code: -32601, message: "Method not found" },
+          id: 4
+        },
+
+        { jsonrpc: "2.0", result: ["hello", 5], id: 5 }
+      ]);
+
+      this.setUpFakeServer(response);
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spies = [];
+      var batch = new qx.io.jsonrpc.protocol.Batch();
+      for (var i = 1; i < 6; i++) {
+        spies[i] = { result: this.spy(), error: this.spy() };
+        let request = new qx.io.jsonrpc.protocol.Request("someMethod", []);
+        request.getPromise().then(spies[i].result).catch(spies[i].error);
+        batch.add(request);
+      }
+      client.sendBatch(batch).catch(err => {
+        this.assertInstance(err, qx.io.exception.Protocol);
+      });
+      this.wait(
+        100,
+        function () {
+          this.assertCalledWith(spies[1].result, 7);
+          this.assertCalledWith(spies[2].result, "foo");
+          this.assertCalled(spies[3].error);
+          this.assertCalled(spies[4].error);
+          this.assertCalledWith(spies[5].result, ["hello", 5]);
+        },
+        this
+      );
+    },
+
+    "test: receive jsonrpc requests from server"() {
+      this.resetId();
+      var response = [
+        {
+          jsonrpc: "2.0",
+          method: "clientMethod",
+          params: ["foo", "bar"],
+          id: 1
+        },
+
+        { jsonrpc: "2.0", method: "clientNotification", params: [] }
+      ];
+
+      this.setUpFakeServer(qx.lang.Json.stringify(response));
+      var client = new qx.io.jsonrpc.Client("http://jsonrpc");
+      var spy = this.spy();
+      client.addListener("incomingRequest", evt => {
+        let message = evt.getData().toObject();
+        this.assertDeepEquals(response.shift(), message);
+        spy(message);
+      });
+      client.sendNotification("ping");
+      this.wait(
+        100,
+        function () {
+          this.assertCalledTwice(spy);
+        },
+        this
+      );
+    }
+  }
+});

package/source/class/qx/test/io/jsonrpc/Protocol.js

@@ -0,0 +1,108 @@
+/* ************************************************************************
+
+   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)
+
+************************************************************************ */
+
+qx.Class.define("qx.test.io.jsonrpc.Protocol", {
+  extend: qx.dev.unit.TestCase,
+  include: [qx.test.io.MAssert],
+  construct() {
+    super();
+    this.parser = new qx.io.jsonrpc.protocol.Parser();
+  },
+  members: {
+    "test: JSON-RPC request message object"() {
+      let message = new qx.io.jsonrpc.protocol.Request("foo", [
+        "bar",
+        1,
+        false
+      ]);
+
+      let expected = {
+        id: 1,
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(
+        expected,
+        this.parser.parse(JSON.stringify(expected)).toObject()
+      );
+    },
+
+    "test: JSON-RPC request notification object"() {
+      let message = new qx.io.jsonrpc.protocol.Notification("foo", [
+        "bar",
+        1,
+        false
+      ]);
+
+      let expected = {
+        jsonrpc: "2.0",
+        method: "foo",
+        params: ["bar", 1, false]
+      };
+
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(
+        expected,
+        this.parser.parse(JSON.stringify(expected)).toObject()
+      );
+    },
+
+    "test: JSON-RPC error object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0",
+        id: 1,
+        error: {
+          code: 5,
+          message: "error!"
+        }
+      };
+
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(
+        expected,
+        this.parser.parse(JSON.stringify(expected)).toObject()
+      );
+    },
+
+    "test: JSON-RPC result object"() {
+      let message = new qx.io.jsonrpc.protocol.Error(1, 5, "error!");
+      let expected = {
+        jsonrpc: "2.0",
+        id: 1,
+        error: {
+          code: 5,
+          message: "error!"
+        }
+      };
+
+      this.assertDeepEquals(expected, message.toObject());
+      // test parser
+      this.assertDeepEquals(
+        expected,
+        this.parser.parse(JSON.stringify(expected)).toObject()
+      );
+    }
+  }
+});