@qooxdoo/framework 7.7.2 → 7.9.0

package/source/class/qx/test/bom/client/Pdfjs.js

@@ -33,6 +33,10 @@ qx.Class.define("qx.test.bom.client.Pdfjs", {
     "test: is PDF.js available"() {
       this.require(["firefox"]);
 
+      if (navigator.plugins.length == 0) {
+        this.skip("test disabled on headless browsers");
+      }
+
       qx.core.Environment.getAsync(
         "plugin.pdfjs",
         function (result) {

package/source/class/qx/test/bom/element/AnimationJs.js

@@ -66,6 +66,9 @@ qx.Class.define("qx.test.bom.element.AnimationJs", {
       if (qx.core.Environment.get("browser.name") == "chrome") {
         throw new qx.dev.unit.RequirementError();
       }
+      if (qx.core.Environment.get("browser.name") == "safari") {
+        throw new qx.dev.unit.RequirementError();
+      }
 
       var handle = qx.bom.element.Animation.animate(this.__el, {
         duration: 100,

package/source/class/qx/test/bom/element/Style.js

@@ -98,6 +98,7 @@ qx.Class.define("qx.test.bom.element.Style", {
         qx.core.Environment.get("browser.version") < 6;
 
       if (
+        engine == "gecko" ||
         engine == "opera" ||
         (engine == "webkit" &&
           !isOldSafari &&

package/source/class/qx/test/bom/media/MediaTestCase.js

@@ -202,6 +202,12 @@ qx.Class.define("qx.test.bom.media.MediaTestCase", {
           "HTML5 audio/video playback must be triggered by user interaction in Chrome on Android."
         );
       }
+      if (qx.core.Environment.get("browser.name") == "safari") {
+        this.skip(
+          "we can not detect headless mode in safari"
+        );
+      }
+
       this.assertTrue(this._media.isPaused());
 
       this._media.addListener("play", e => {

package/source/class/qx/test/core/Environment.js

@@ -537,6 +537,50 @@ qx.Class.define("qx.test.core.Environment", {
 
       // 3d transform support
       this.assertBoolean(qx.core.Environment.get("css.transform.3d"));
+    },
+
+    /**
+     * This test is only run if "qx.environment.allowRuntimeMutations" is false which you need to
+     * manually set in the test runner configuration.
+     */
+    testRuntimeMutationsIfNotAvailable() {
+      if (qx.core.Environment.get("qx.environment.allowRuntimeMutations") === false) {
+        // the mutation methods should not be available
+        for (let key in ['set', 'remove', 'reset']) {
+          this.assertUndefined(qx.core.Environment[key], `The method "qx.core.Environment.${key}()" should not be available.`);
+        }
+      } else {
+        this.skip("Runtime mutations are enabled.");
+      }
+    },
+
+    testRuntimeMutationsIfAvailable() {
+      if (qx.core.Environment.get("qx.environment.allowRuntimeMutations") === false) {
+        this.skip("Runtime mutations are disabled.");
+        return;
+      }
+      // compile-time environment
+      const qxVersion = qx.core.Environment.get("qx.version");
+      qx.core.Environment.set("qx.version", "1.0");
+      this.assertEquals("1.0", qx.core.Environment.get("qx.version"));
+      qx.core.Environment.reset("qx.version");
+      this.assertEquals(qxVersion, qx.core.Environment.get("qx.version"));
+      qx.core.Environment.remove("qx.version");
+      this.assertUndefined(qx.core.Environment.get("qx.version"));
+
+      // runtime environment
+      const browserName = qx.core.Environment.get("browser.name");
+      qx.core.Environment.set("browser.name", "lynx");
+      this.assertEquals("lynx", qx.core.Environment.get("browser.name"));
+      qx.core.Environment.reset("browser.name");
+      this.assertEquals(browserName, qx.core.Environment.get("browser.name"));
+      qx.core.Environment.remove("browser.name");
+      this.assertUndefined(qx.core.Environment.get("browser.name"));
+
+      // cleanup
+      qx.core.Environment.reset();
+      this.assertEquals(qxVersion, qx.core.Environment.get("qx.version"));
+      this.assertEquals(browserName, qx.core.Environment.get("browser.name"));
     }
   }
 });

package/source/class/qx/test/data/controller/List.js

@@ -25,7 +25,13 @@ qx.Class.define("qx.test.data.controller.List", {
   include: qx.dev.unit.MMock,
 
   members: {
+    /**
+     * @type {qx.ui.form.List}
+     */
     __list: null,
+    /**
+     * @type {qx.data.controller.List}
+     */
     __controller: null,
     __data: null,
     __model: null,

package/source/class/qx/test/data/marshal/Json.js

@@ -1498,6 +1498,35 @@ qx.Class.define("qx.test.data.marshal.Json", {
 
       model.dispose();
       qx.Class.undefine("qx.test.Array");
+    },
+
+    testNonPojoObjects() {
+      function NativeClass() {
+        this.foo = "bar";
+      }
+
+      NativeClass.prototype.myMethod = function () {
+        return "method";
+      };
+
+      let data = {
+        name: "Michael",
+        nonPojo: new NativeClass()
+      };
+
+      this.__marshaler.dispose();
+      this.__marshaler = new qx.data.marshal.Json();
+      this.__marshaler.toClass(data);
+      var model = this.__marshaler.toModel(data);
+
+      this.assertEquals("Michael", model.getName());
+
+      if (qx.core.Environment.get("qx.data.marshal.Json.breakOnNonPojos")) {
+        this.assertEquals("method", model.getNonPojo().myMethod());
+        this.assertEquals("bar", model.getNonPojo().foo);
+      } else {
+        this.assertEquals("bar", model.getNonPojo().getFoo());
+      }
     }
   }
 });

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

@@ -41,6 +41,100 @@ qx.Mixin.define("qx.test.io.MAssert", {
         msg = `Failed to assert that '${actual}' contains '${expectedFragment}'.`;
       }
       this.assert(actual.includes(expectedFragment), msg);
+    },
+
+    PROMISE: {
+      map: null,
+      PENDING: "pending",
+      FULFILLED: "fulfilled",
+      REJECTED: "rejected"
+    },
+
+    /**
+     * Observes a promise so that its state can later be determined for the assertPromise*()
+     * methods.
+     * @param {Promise} promise
+     */
+    observePromise(promise) {
+      if (!this.PROMISE.map) {
+        this.PROMISE.map = new WeakMap();
+      }
+      let state = this.PROMISE.PENDING;
+      promise.then(
+        () => (state = this.PROMISE.FULFILLED),
+        () => (state = this.PROMISE.REJECTED)
+      );
+      let stateFn = () => state;
+      this.PROMISE.map.set(promise, stateFn);
+    },
+
+    /**
+     * Returns the state of the given promise, which is either "pending", "fulfilled", or "rejected".
+     * Requires that the observePromise() method has previously been called with given promise.
+     * @param {Promise} promise
+     * @returns {String}
+     */
+    getPromiseState(promise) {
+      let stateFn = this.PROMISE.map && this.PROMISE.map.get(promise);
+      if (!stateFn) {
+        throw new Error(
+          "Promise is not being observed, call observePromise() first."
+        );
+      }
+      return stateFn();
+    },
+
+    /**
+     * Asserts that the given promise object is still pending
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromisePending(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.PENDING,
+        msg || `Promise should be pending, but is ${state}.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object is settled, i.e. has either
+     * been fulfilled or rejected
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseSettled(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state != this.PROMISE.PENDING,
+        msg || `Promise should be settled, but is pending.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object has been fulfilled
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseFulfilled(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.FULFILLED,
+        msg || `Promise should be fulfilled, but is ${state}.`
+      );
+    },
+
+    /**
+     * Asserts that the given promise object has been rejected
+     * @param {Promise} promise
+     * @param {String?} msg Optional failure message
+     */
+    assertPromiseRejected(promise, msg) {
+      let state = this.getPromiseState(promise);
+      this.assert(
+        state == this.PROMISE.REJECTED,
+        msg || `Promise should be rejected, but is ${state}.`
+      );
     }
   }
 });

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

@@ -0,0 +1,47 @@
+/* ************************************************************************
+
+   qooxdoo - the javascript framework for coders
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025 qooxdoo contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with qx.test.io.request.PostMessage transport
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.TestMAssert", {
+  extend: qx.dev.unit.TestCase,
+
+  include: [qx.test.io.MAssert],
+
+  members: {
+
+    /**
+     * Test the promise Assertion API
+     */
+    testPromiseAssertions() {
+      let p1 = new Promise(resolve => setTimeout(resolve, 10));
+      this.observePromise(p1);
+      this.assertPromisePending(p1);
+      this.wait(100, () => this.assertPromiseFulfilled(p1));
+      let p2 = new Promise((_, reject) => setTimeout(reject, 10));
+      this.observePromise(p2);
+      this.wait(100, () => {
+        this.assertPromiseRejected(p2);
+        this.assertPromiseSettled(p2);
+      });
+    }
+  }
+});

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

@@ -60,21 +60,33 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
     },
 
     /**
-     * Sets up the fake server and instructs it to send the given response(s)
-     * @param {String} response The server response to the first request
+     * Sets up the fake server and instructs it to send the given response
+     * @param {String} response Optional server response
      */
     setUpFakeServer(response) {
       // Not fake transport
       this.getSandbox().restore();
       this.useFakeServer();
       this.setUpRequest();
+      if (response) {
+        this.setServerResponse(response);
+      }
+      this.getServer().autoRespond = true;
+    },
+
+    /**
+     * Set the fake server's response
+     * @param {{String|Object} } response Server response. Will be stringified to a JSON string if not a string
+     */
+    setServerResponse(response) {
+      if (typeof response != "string") {
+        response = JSON.stringify(response);
+      }
       this.getServer().respondWith("POST", /.*/, [
         200,
         { "Content-Type": "application/json; charset=utf-8" },
         response
       ]);
-
-      this.getServer().autoRespond = true;
     },
 
     /**
@@ -103,7 +115,7 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
           if (!(err instanceof qx.io.exception.Exception)) {
             throw err;
           }
-          this.assertEquals(exception, err.code, `Error code does not match`);
+          this.assertEquals(exception, err.code, `Error code does not match.  Expected ${exception}, got ${err.code}.`);
         } else {
           this.assertInstance(
             err,
@@ -119,16 +131,20 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
       // check transport promise
       client.send(message_out).catch(errorCallback);
       this.wait(100, () => {
+        // in case of a transport error, ...
+        const n = qx.core.Environment.select("qx.io.jsonrpc.forwardTransportPromiseRejectionToRequest", {
+          true: 1, // ... we are rejecting the request promise only, v8 default
+          false: 2 // ... both request promise and transport promise are rejected, v7 default
+        })
         if (
-          // the request promise will not be called since the promise is already rejected
+          // the request promise will not be rejected because it already is rejected in this special case
           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
+          // or the send promise will not be rejected because we have a server-side error, v7 default only
+          (exception === qx.io.exception.Protocol && !qx.core.Environment.get("qx.io.jsonrpc.forwardTransportPromiseRejectionToRequest"))
         ) {
-          this.assertCalledTwice(errorCallback);
+          this.assertCallCount(errorCallback, n);
         } else {
-          // the error handler will be called three times
-          this.assertCalledThrice(errorCallback);
+          this.assertCallCount(errorCallback, n+1);
         }
       });
     },
@@ -208,10 +224,9 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
 
       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);
+      const value = await message_out.getPromise();
+      this.assertEquals(result, value);
     },
 
     async "test: call jsonrpc method and receive batched response"() {
@@ -225,10 +240,9 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
         .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);
+      const value = await message_out.getPromise();
+      this.assertEquals(result, value);
     },
 
     "test: call jsonrpc method and expect error on invalid reponse "() {
@@ -321,10 +335,56 @@ qx.Class.define("qx.test.io.jsonrpc.Client", {
         spy(message);
       });
       client.sendNotification("ping");
+      this.wait(100, () => this.assertCalledTwice(spy) );
+    },
+
+    /**
+     * Issue #10739
+     */
+    testIssue10739() {
+      this.resetId();
+      this.setUpFakeServer();
+      const successCallback = this.spy(result =>
+        this.debug(`Server response is "${result}"`)
+      );
+      const errorCallback = this.spy(error => console.error(error.message));
+      const client = new qx.io.jsonrpc.Client("http://test.local");
+      const auth = new qx.io.request.authentication.Bearer("TOKEN");
+      client.getTransport().getTransportImpl().setAuthentication(auth);
+      this.setServerResponse({
+        jsonrpc: "2.0",
+        error: {
+          code: 8,
+          message: "stale or uninitialized auth token/rune"
+        },
+        id: 1
+      });
+      const sendRequest = this.spy(() => {
+        this.debug("sendRequest() was called");
+        client
+          .sendRequest("service.method", ["foo"])
+          .then(successCallback)
+          .catch(err => {
+            if (err.code == 8) {
+              this.debug(`Received expected error message.`);
+              this.setServerResponse({
+                jsonrpc: "2.0",
+                result: "OK",
+                id: 2
+              });
+              sendRequest(); // second request
+            } else {
+              errorCallback(err);
+            }
+          });
+      });
+      sendRequest();
       this.wait(
-        100,
+        250,
         function () {
-          this.assertCalledTwice(spy);
+          this.assertCalledTwice(sendRequest);
+          this.assertCalledOnce(successCallback);
+          this.assertNotCalled(errorCallback);
         },
         this
       );

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

@@ -0,0 +1,152 @@
+/* ************************************************************************
+
+   qooxdoo - the javascript framework for coders
+
+   http://qooxdoo.org
+
+   Copyright:
+     2025 qooxdoo contributors
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Tests for qx.io.jsonrpc.Client with qx.test.io.request.PostMessage transport
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.jsonrpc.PostMessageClient", {
+  extend: qx.dev.unit.TestCase,
+
+  include: [qx.dev.unit.MMock, qx.test.io.MAssert],
+
+  members: {
+    setUp() {
+      qx.io.jsonrpc.protocol.Request.resetId();
+    },
+
+    tearDown() {
+      this.getSandbox().restore();
+    },
+
+    /**
+     * Given a function, return a `Worker` object which calls the function
+     * with the function whenever the Worker receives a message from the main
+     * thread.
+     * @param {Function} fn
+     * @returns {Worker}
+     */
+    createOnMessageWorker(fn) {
+      let blob = new Blob(["self.onmessage = ", fn.toString()], {
+        type: "text/javascript"
+      });
+      return new Worker(URL.createObjectURL(blob));
+    },
+
+    async "test: receive 10 out-of-order jsonrpc responses from server, all successful"() {
+      qx.io.jsonrpc.protocol.Request.resetId();
+
+      // create server worker which sends a response with random delay
+      const server = this.createOnMessageWorker(evt => {
+        let request = JSON.parse(evt.data);
+        let id = request.id;
+        let response = JSON.stringify({
+          jsonrpc: "2.0",
+          result: `Result for #${id}`,
+          id
+        });
+        setTimeout(() => {
+          console.log(`Sending response for request #${id}`);
+          self.postMessage(response);
+        }, Math.random() * 1000);
+      });
+      const transport = new qx.io.transport.PostMessage(server);
+      const client = new qx.io.jsonrpc.Client(transport);
+      const promises = [];
+      // send 10 requests without waiting for the response
+      for (let i = 0; i < 10; i++) {
+        let request = new qx.io.jsonrpc.protocol.Request("someMethod", ["foo"]);
+        await client.send(request);
+        promises.push(request.getPromise());
+      }
+      // Make sure that alle requests have been responded to, i.e. that their promises have
+      // been settled.
+      const allSettledPromise = Promise.allSettled(promises);
+      this.observePromise(allSettledPromise);
+      this.assertPromisePending(allSettledPromise);
+      this.wait(2000, () => {
+        this.assertPromiseFulfilled(
+          allSettledPromise,
+          "Some request promises were not fulfilled"
+        );
+      });
+    },
+
+    async "test: receive 100 out-of-order jsonrpc responses from server, with jsonrpc errors"() {
+      qx.io.jsonrpc.protocol.Request.resetId();
+
+      // create server worker which sends a response with random delay
+      // some requests fail
+      const server = this.createOnMessageWorker(evt => {
+        let request = JSON.parse(evt.data);
+        let id = request.id;
+        let response = JSON.stringify(
+          Math.random() > 0.5
+            ? {
+                jsonrpc: "2.0",
+                result: "OK",
+                id
+              }
+            : {
+                jsonrpc: "2.0",
+                error: {
+                  code: -1,
+                  message: "error",
+                },
+                id
+              }
+        );
+        setTimeout(() => {
+          self.postMessage(response);
+        }, Math.random() * 1000);
+      });
+      const transport = new qx.io.transport.PostMessage(server);
+      const client = new qx.io.jsonrpc.Client(transport);
+      const promises = [];
+      const spies = [];
+      // send 100 requests without waiting for the response
+      for (let i = 0; i < 100; i++) {
+        let request = new qx.io.jsonrpc.protocol.Request("someMethod", ["foo"]);
+        await client.send(request);
+        // create a spy to receive error objects
+        let spy = this.spy()
+        spies.push(spy)
+        promises.push(request.getPromise().then(spy,spy));
+      }
+      // Make sure that alle requests have been responded to, i.e. that their promises have
+      // been settled.
+      const allSettledPromise = Promise.allSettled(promises);
+      this.observePromise(allSettledPromise);
+      this.assertPromisePending(allSettledPromise);
+      this.wait(2000, () => {
+        this.assertPromiseSettled(
+          allSettledPromise,
+          "Some request promises were not settled"
+        );
+        for(let spy of spies){
+          const firstCallArg = spy.getCall(0)?.args[0];
+          this.assert(
+            (firstCallArg instanceof qx.io.exception.Protocol || typeof firstCallArg == "string"),
+            `An unexpected error occurred: "${firstCallArg}"`
+          );
+        }
+      });
+    }
+  }
+});

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

@@ -25,11 +25,7 @@ qx.Class.define("qx.test.io.jsonrpc.Protocol", {
   },
   members: {
     "test: JSON-RPC request message object"() {
-      let message = new qx.io.jsonrpc.protocol.Request("foo", [
-        "bar",
-        1,
-        false
-      ]);
+      let message = new qx.io.jsonrpc.protocol.Request("foo", ["bar",1,false], 1);
 
       let expected = {
         id: 1,

package/source/class/qx/test/io/request/Xhr.js

@@ -760,6 +760,12 @@ qx.Class.define("qx.test.io.request.Xhr", {
         this.skip("Skipping because qx.promise==false");
       }
 
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        this.skip(
+          "Skipping because qx.Promise.useNativePromise===true, meaning we can't cancel promises."
+        );
+      }
+
       this.setUpFakeTransport();
       var req = this.req;
 
@@ -818,6 +824,11 @@ qx.Class.define("qx.test.io.request.Xhr", {
       if (!qx.core.Environment.get("qx.promise")) {
         this.skip("Skipping because qx.promise==false");
       }
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        this.skip(
+          "Skipping because qx.Promise.useNativePromise===true, meaning we can't cancel promises."
+        );
+      }
 
       this.setUpFakeTransport();
       var req = this.req;
@@ -863,6 +874,11 @@ qx.Class.define("qx.test.io.request.Xhr", {
       if (!qx.core.Environment.get("qx.promise")) {
         this.skip("Skipping because qx.promise==false");
       }
+      if (qx.core.Environment.get("qx.Promise.useNativePromise")) {
+        this.skip(
+          "Skipping because qx.Promise.useNativePromise===true, meaning we can't cancel promises."
+        );
+      }
 
       this.setUpFakeTransport();
       var req = this.req;