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

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

@@ -0,0 +1,267 @@
+/* ************************************************************************
+
+   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: function () {
+      this.req && this.req.dispose();
+      this.req = new qx.io.request.Xhr();
+      this.req.setUrl("url");
+    },
+
+    setUpFakeTransport: function () {
+      if (this.transport && this.transport.send.restore) {
+        return;
+      }
+      this.transport = this.injectStub(qx.io.request.Xhr.prototype, "_createTransport");
+      this.setUpRequest();
+    },
+
+    setUpFakeXhr: function () {
+      // 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: function (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: function (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: function () {
+      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": function () {
+      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" : function() {
+      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" : function() {
+      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);
+    },
+
+    "test: call jsonrpc method and receive response with single result" : async function() {
+      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);
+    },
+
+    "test: call jsonrpc method and receive batched response" : async function() {
+      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" : function() {
+      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,80 @@
+/* ************************************************************************
+
+   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() {
+    this.base(arguments);
+    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());
+    }
+  }
+});

package/source/class/qx/test/io/transport/PostMessage.js

@@ -0,0 +1,56 @@
+/* ************************************************************************
+
+   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 the postMessage transport
+ * @ignore(URL)
+ * @ignore(Worker)
+ * @ignore(self)
+ */
+qx.Class.define("qx.test.io.transport.PostMessage", {
+  extend: qx.dev.unit.TestCase,
+
+  members: {
+
+    setUp() {
+      // see https://medium.com/@dee_bloo/make-multithreading-easier-with-inline-web-workers-a58723428a42
+      function createWorker(fn) {
+        let blob = new Blob(['self.onmessage = ', fn.toString()], { type: 'text/javascript' });
+        return new Worker(URL.createObjectURL(blob));
+      }
+      // create echo server
+      const worker = createWorker(evt => {
+        self.postMessage(evt.data);
+      });
+      this.transport = new qx.io.transport.PostMessage(worker);
+    },
+
+    async "test: send message to worker and check response"() {
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/io/transport/Websocket.js

@@ -0,0 +1,63 @@
+/* ************************************************************************
+
+   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 the websocket transport
+ */
+qx.Class.define("qx.test.io.transport.Websocket", {
+  extend: qx.dev.unit.TestCase,
+
+  statics: {
+    TEST_ENDPOINT: "echo.websocket.events"
+  },
+
+  members: {
+
+    __hasEndpoint : false,
+    __skipMsg: "Skipping test as endpoint is not available.",
+
+    setUp() {
+      this.transport = new qx.io.transport.Websocket("wss://" + this.constructor.TEST_ENDPOINT);
+    },
+
+    async "test: check endpoint"() {
+      try {
+        await this.transport.send("test");
+        this.__hasEndpoint = true;
+      } catch(e) {
+        console.error(`Endpoint ${this.constructor.TEST_ENDPOINT} is not accessible: ${e.message}`);
+      }
+    },
+
+    async "test: send message to public websocket echo server and check response"() {
+      if (!this.__hasEndpoint) {
+        return this.skip(this.__skipMsg);
+      }
+      let message = "Hello World!";
+      await new qx.Promise((resolve, reject) => {
+        this.transport.addListenerOnce("message", evt => {
+          this.assertEquals(message, evt.getData());
+        });
+        this.transport.send(message)
+          .then(resolve)
+          .catch(reject);
+      });
+    }
+  }
+});

package/source/class/qx/test/ui/embed/Iframe.js

@@ -88,6 +88,7 @@ qx.Class.define("qx.test.ui.embed.Iframe",
       this.wait(10000);
     },
 
+    /** @ignore(require) */
     testSyncSourceAfterDOMMove : function ()
     {
       // This breaks (very) frequently when run under headless chrome on Travis; we can't

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

@@ -87,48 +87,6 @@ qx.Class.define("qx.test.ui.form.ComboBox",
       this.flush();
     },
 
-    testFocusTextOnClose: function() {
-      var combobox = this.__createComboBox();
-      this.getRoot().add(combobox);
-      this.flush();
-
-      // Open list popup
-      combobox.open();
-      this.flush();
-
-      // Select item
-      var list = combobox.getChildControl("list");
-      var item = list.findItem("Item 0");
-      list.setSelection([item]);
-      this.flush();
-
-      // Asssert focus on close
-      this.spy(combobox, "tabFocus");
-      combobox.close();
-      this.assertCalled(combobox.tabFocus);
-
-      this.getRoot().removeAll();
-      combobox.dispose();
-    },
-
-    testNotFocusTextOnCloseWhenInvisibleBefore: function() {
-      var combobox = this.__createComboBox();
-      this.getRoot().add(combobox);
-      this.flush();
-
-      // Enter value
-      combobox.setValue("Item 0");
-      this.flush();
-
-      // Assert not focus on close
-      this.spy(combobox, "tabFocus");
-      combobox.close();
-      this.assertNotCalled(combobox.tabFocus);
-
-      this.getRoot().removeAll();
-      combobox.dispose();
-    },
-
     __createComboBox : function(initValue)
     {
       var comboBox = new qx.ui.form.ComboBox();

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

@@ -805,15 +805,54 @@ qx.Class.define("qx.test.util.DateFormat",
         this._testIsoMasks(date, 'isoDate', 'yyyy-MM-dd');
         this._testIsoMasks(date, 'isoTime', 'HH:mm:ss');
         this._testIsoMasks(date, 'isoDateTime', "yyyy-MM-dd'T'HH:mm:ss");
-
-//        var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
-//        var df = new qx.util.format.DateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
-//        var isoDateFormatted = isodf.format(date);
-//        var dateFormatted = df.format(date);
-//        this.assertEquals(isodf.parse(isoDateFormatted).getTime(),df.parse(dateFormatted).getTime());
+        this._testIsoMasks(date, 'isoDateTimeTz', "yyyy-MM-dd'T'HH:mm:ssZ");
+        //this._testIsoMasks(date, 'isoUtcDateTime', "yyyy-MM-dd'T'HH:mm:ss'Z'");
       }
   },
 
+  testIsoTz : function() {
+    var isodf = new qx.util.format.DateFormat('isoDateTimeTz');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00+0000");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    parsedDate = isodf.parse("2004-04-04T04:04:04-0500")
+    this.assertEquals(parsedDate.getUTCFullYear(), 2004);
+    this.assertEquals(parsedDate.getUTCMonth(), 3);
+    this.assertEquals(parsedDate.getUTCDate(), 3);
+    this.assertEquals(parsedDate.getUTCHours(), 23);
+    this.assertEquals(parsedDate.getUTCMinutes(), 4);
+    this.assertEquals(parsedDate.getUTCSeconds(), 4);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+  },
+
+  testUtc : function () {
+    var isodf = new qx.util.format.DateFormat('isoUtcDateTime');
+    var parsedDate = isodf.parse("2013-01-01T00:00:00Z");
+    this.assertEquals(parsedDate.getUTCFullYear(), 2013);
+    this.assertEquals(parsedDate.getUTCMonth(), 0);
+    this.assertEquals(parsedDate.getUTCDate(), 1);
+    this.assertEquals(parsedDate.getUTCHours(), 0);
+    this.assertEquals(parsedDate.getUTCMinutes(), 0);
+    this.assertEquals(parsedDate.getUTCSeconds(), 0);
+    this.assertEquals(parsedDate.getUTCMilliseconds(), 0);
+
+    // checks that UTC hours are calculated correctly
+    parsedDate = isodf.parse("2004-04-04T04:04:04Z");
+    this.assertEquals(parsedDate.getUTCHours(), 4);
+
+    // checks that UTC format does not parse a date with a timezone
+    this.assertException(function() {
+      isodf.parse("2004-04-04T04:04:04+05:00");
+    }, Error);
+
+  },
+
   testChangingLocales : function()
   {
     var manager = qx.locale.Manager.getInstance();

package/source/class/qx/tool/cli/Cli.js

@@ -239,7 +239,9 @@ Version: v${await qx.tool.config.Utils.getQxVersion()}
       this._compilerApi.setCommand(command);
       await this.__notifyLibraries();
       try {
-        return await command.process();
+        const res = await command.process();
+        await this._compilerApi.afterProcessFinished(command, res);
+        return res;
       } catch (e) {
         qx.tool.compiler.Console.error("Error: " + (e.stack || e.message));
         process.exit(1);
@@ -420,8 +422,8 @@ Version: v${await qx.tool.config.Utils.getQxVersion()}
       if (config.libraries && needLibraries) {
         let neededLibraries = config.libraries.filter(libData => !fs.existsSync(libData + "/Manifest.json"));
         if (neededLibraries.length) {
-          if (!fs.existsSync(qx.tool.config.Manifest.config.fileName)) { 
-            qx.tool.compiler.Console.error("Libraries are missing and there is no Manifest.json in the current directory so we cannot attempt to install them; the missing libraries are: \n     " + neededLibraries.join("\n     "));  
+          if (!fs.existsSync(qx.tool.config.Manifest.config.fileName)) {
+            qx.tool.compiler.Console.error("Libraries are missing and there is no Manifest.json in the current directory so we cannot attempt to install them; the missing libraries are: \n     " + neededLibraries.join("\n     "));
             process.exit(1);
           }
           qx.tool.compiler.Console.info("One or more libraries not found - trying to install them from library repository...");

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

@@ -25,7 +25,7 @@ const fs = qx.tool.utils.Promisify.fs;
 
 /**
  * Provides an API for the compiler
- * 
+ *
  */
 qx.Class.define("qx.tool.cli.api.CompilerApi", {
   extend: qx.tool.cli.api.AbstractApi,
@@ -75,7 +75,7 @@ qx.Class.define("qx.tool.cli.api.CompilerApi", {
 
     /**
      * called after deployment happens
-     * 
+     *
      * @param data {Object}  contains deployment infos with the following properties:
      *           targetDir  : {String}  The target dir of the build
      *           deployDir  : {String}  The output dir for the deployment
@@ -89,7 +89,7 @@ qx.Class.define("qx.tool.cli.api.CompilerApi", {
 
     /**
      * Loads the configuration data
-     * 
+     *
      * @overridden
      */
     async load() {
@@ -102,6 +102,16 @@ qx.Class.define("qx.tool.cli.api.CompilerApi", {
       return this.base(arguments);
     },
 
+    /**
+     * runs after the whole process is finished
+     * @param cmd {qx.tool.cli.commands.Command} current command
+     * @param res {boolean} result of the just finished process
+     */
+    async afterProcessFinished(cmd, res) {
+      // Nothing
+    },
+
+
     /**
      * Called after all libraries have been loaded and added to the compilation data
      */
@@ -113,7 +123,7 @@ qx.Class.define("qx.tool.cli.api.CompilerApi", {
 
     /**
      * Adds a library configuration
-     * 
+     *
      * @param libraryApi {LibraryApi} the configuration for the library
      */
     addLibraryApi(libraryApi) {
@@ -123,7 +133,7 @@ qx.Class.define("qx.tool.cli.api.CompilerApi", {
 
     /**
      * Returns an array of library configurations
-     * 
+     *
      * @return {LibraryApi[]}
      */
     getLibraryApis() {

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

@@ -127,6 +127,13 @@ qx.Class.define("qx.tool.cli.commands.Command", {
      */
     getQxPath: qx.tool.config.Utils.getQxPath.bind(qx.tool.config.Utils),
 
+    /**
+     *
+     * @returns @see {@link qx.tool.config.Utils#getCompilerVersion}
+     */
+    getCompilerVersion() {
+      return qx.tool.config.Utils.getCompilerVersion();
+    },
 
     /**
      * Returns the qooxdoo version, either from the `--qx-version` command line