@qooxdoo/framework 7.7.1 → 7.8.0

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/ui/embed/Iframe.js

@@ -145,7 +145,7 @@ qx.Class.define("qx.test.ui.embed.Iframe", {
             this.assertEquals("Hello World!", innerText);
           });
         }.bind(this),
-        4000
+        5000
       );
 
       this.wait(10000);

package/source/class/qx/test/ui/form/TextArea.js

@@ -294,6 +294,10 @@ qx.Class.define("qx.test.ui.form.TextArea", {
         this.skip();
       }
 
+      if ((qx.core.Environment.get("engine.name") === "gecko") && (navigator.plugins.length == 0)) {
+        this.skip("test disabled on headless firefox browser");
+      }
+
       var textArea = this.__textArea;
       textArea.set({
         autoSize: true,

package/source/class/qx/test/util/DeferredCall.js

@@ -24,6 +24,12 @@ qx.Class.define("qx.test.util.DeferredCall", {
       if (navigator.plugins.length == 0) {
         this.skip("test disabled on headless browsers");
       }
+      
+      if (qx.core.Environment.get("browser.name") == "safari") {
+        this.skip(
+          "we can not detect headless mode in safari"
+        );
+      }
 
       var fail = function () {
         throw new Error("fail");

package/source/class/qx/test/util/Function.js

@@ -30,7 +30,7 @@ qx.Class.define("qx.test.util.Function", {
       this.assertNotCalled(test);
       debouncedTest(false);
       this.wait(
-        100,
+        250,
         function () {
           this.assertCalledOnce(test);
           this.assertCalledWith(test, false);
@@ -52,7 +52,7 @@ qx.Class.define("qx.test.util.Function", {
       debouncedTest(true);
       debouncedTest(false);
       this.wait(
-        100,
+        250,
         function () {
           this.assertCalledTwice(test);
           this.assertCalledWith(test, false);

package/source/class/qx/tool/cli/api/Test.js

@@ -1,3 +1,16 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2020 Henner Kollmann
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project"s top-level directory for details.
+************************************************************************ */
 /**
  * This is used to add an test case for qx test
  */
@@ -47,6 +60,15 @@ qx.Class.define("qx.tool.cli.api.Test", {
       init: true
     },
 
+    /**
+     * If this special test fails exit process
+     */
+    failFast: {
+      check: "Boolean",
+      nullable: false,
+      init: false
+    },
+
     /**
      * The test function called by qx test
      *

package/source/class/qx/tool/cli/commands/Compile.js

@@ -789,9 +789,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
       }
 
       for (let filename of classFiles) {
-        if (this.argv.verbose) {
-          qx.tool.compiler.Console.info(`Processing ${filename} ...`);
-        }
         await metaDb.addFile(filename, !!this.argv.clean);
       }
       await metaDb.reparseAll();
@@ -1348,6 +1345,15 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
         if (data.environment) {
           maker.setEnvironment(data.environment);
         }
+
+        /*
+        Libraries have to be added first because there is qx library
+        which includes a framework version
+        */
+        for (let library of librariesArray) {
+          maker.getAnalyser().addLibrary(library);
+        }
+
         let targetEnvironment = {
           "qx.version": maker.getAnalyser().getQooxdooVersion(),
           "qx.compiler.targetType": target.getType(),
@@ -1398,6 +1404,14 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
 
         maker.getAnalyser().setBabelConfig(babelConfig);
 
+        let browserifyConfig = qx.lang.Object.clone(data.browserify || {}, true);
+        browserifyConfig.options = browserifyConfig.options || {};
+        qx.lang.Object.mergeWith(
+          browserifyConfig.options,
+          targetConfig.browserifyOptions || {}
+        );
+        maker.getAnalyser().setBrowserifyConfig(browserifyConfig);
+
         var addCreatedAt =
           targetConfig["addCreatedAt"] || t.argv["addCreatedAt"];
         if (addCreatedAt) {
@@ -1409,10 +1423,6 @@ Framework: v${await this.getQxVersion()} in ${await this.getQxPath()}`);
           maker.getAnalyser().setVerboseCreatedAt(true);
         }
 
-        for (let library of librariesArray) {
-          maker.getAnalyser().addLibrary(library);
-        }
-
         let allApplicationTypes = {};
         appConfigs.forEach(appConfig => {
           var app = (appConfig.app = new qx.tool.compiler.app.Application(

package/source/class/qx/tool/cli/commands/Test.js

@@ -99,7 +99,7 @@ qx.Class.define("qx.tool.cli.commands.Test", {
       let exitCode = evt.getData();
       // overwrite error code only in case of errors
       if (exitCode !== 0 && argv.failFast) {
-        process.exit(exitCode);
+        process.exit(Math.min(255, exitCode));
       }
     });
   },
@@ -152,6 +152,9 @@ qx.Class.define("qx.tool.cli.commands.Test", {
         }
         // overwrite error code only in case of errors
         if (exitCode !== 0) {
+          if (test.getFailFast()) {
+            this.argv.failFast = true;
+          }  
           this.setExitCode(exitCode);
         }
       });
@@ -194,6 +197,9 @@ qx.Class.define("qx.tool.cli.commands.Test", {
 
       this.addListener("afterStart", async () => {
         qx.tool.compiler.Console.info(`Running unit tests`);
+        if (this.argv.verbose) {
+          console.log(this.argv);
+        }
         await this.fireDataEventAsync("runTests", this);
         if (
           this.getCompilerApi() &&

package/source/class/qx/tool/compiler/Analyser.js

@@ -126,6 +126,13 @@ qx.Class.define("qx.tool.compiler.Analyser", {
       check: "Object"
     },
 
+    /** configuration of browserify */
+    browserifyConfig: {
+      init: null,
+      nullable: true,
+      check: "Object"
+    },
+
     /** list of global ignores */
     ignores: {
       init: [],

package/source/class/qx/tool/compiler/ClassFile.js

@@ -962,14 +962,15 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
 
         CallExpression(path) {
           const name = collapseMemberExpression(path.node.callee);
+          const env = t.__analyser.getEnvironment();
 
           if (
+            env["qx.environment.allowRuntimeMutations"] !== true &&
             (name === "qx.core.Environment.select" ||
               name === "qx.core.Environment.get") &&
-            types.isLiteral(path.node.arguments[0])
+            types.isLiteral(path.node.arguments[0]) 
           ) {
             const arg = path.node.arguments[0];
-            const env = t.__analyser.getEnvironment();
             const envValue = env[arg.value];
 
             if (envValue !== undefined) {
@@ -1349,8 +1350,12 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
           t.__hasDefer = true;
           t.__inDefer = true;
         }
-        t.__classMeta.functionName = FUNCTION_NAMES[keyName] || keyName;
-        if (FUNCTION_NAMES[keyName] !== undefined) {
+        var isSpecialFunctionName =
+          Object.keys(FUNCTION_NAMES).includes(keyName);
+        t.__classMeta.functionName = isSpecialFunctionName
+          ? FUNCTION_NAMES[keyName]
+          : keyName;
+        if (isSpecialFunctionName) {
           makeMeta(keyName, null, functionNode);
         }
         enterFunction(path, functionNode);
@@ -1393,8 +1398,9 @@ qx.Class.define("qx.tool.compiler.ClassFile", {
           }
           var keyName = getKeyName(prop.key);
           checkValidTopLevel(path);
-
-          if (FUNCTION_NAMES[keyName] !== undefined) {
+          var isSpecialFunctionName =
+            Object.keys(FUNCTION_NAMES).includes(keyName);
+          if (isSpecialFunctionName) {
             let val = path.node.value;
             val.leadingComments = (path.node.leadingComments || []).concat(
               val.leadingComments || []

package/source/class/qx/tool/compiler/MetaExtraction.js

@@ -109,11 +109,6 @@ qx.Class.define("qx.tool.compiler.MetaExtraction", {
 
       const babelCore = require("@babel/core");
       let src = await fs.promises.readFile(classFilename, "utf8");
-      let babelConfig = {
-        options: {
-          modules: false
-        }
-      };
 
       let plugins = [require("@babel/plugin-syntax-jsx"), this.__plugin()];
 

package/source/class/qx/tool/compiler/targets/Target.js

@@ -373,10 +373,10 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
 
       appMeta.setSourceUri(mapTo ? mapTo : targetUri + "transpiled/");
       mapTo = this.getPathMapping(
-        path.join(appRootDir, this.getOutputDir(), "resource/")
+        path.join(appRootDir, this.getOutputDir(), "resource")
       );
 
-      appMeta.setResourceUri(mapTo ? mapTo : targetUri + "resource/");
+      appMeta.setResourceUri(mapTo ? mapTo : targetUri + "resource");
 
       const requiredLibs = application.getRequiredLibraries();
 

package/source/class/qx/tool/compiler/targets/meta/Browserify.js

@@ -158,12 +158,18 @@ qx.Class.define("qx.tool.compiler.targets.meta.Browserify", {
       builtins.process = builtins._process;
 
       return new Promise((resolve, reject) => {
-        let b = browserify([], {
+        const options = {
           builtins: builtins,
           ignoreMissing: true,
           insertGlobals: true,
           detectGlobals: true
-        });
+        };
+        qx.lang.Object.mergeWith(
+          options,
+          this.getAppMeta().getAnalyser().getBrowserifyConfig()?.options || {},
+          false
+        );
+        let b = browserify([], options);
 
         b._mdeps.on("missing", (id, parent) => {
           let message = [];