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

package/source/class/qx/test/io/rest/ResourceWithRemote.js

@@ -27,112 +27,129 @@
  * @asset(qx/test/xmlhttp/sample.txt)
  */
 
-qx.Class.define("qx.test.io.rest.ResourceWithRemote",
-{
-  extend : qx.dev.unit.TestCase,
+qx.Class.define("qx.test.io.rest.ResourceWithRemote", {
+  extend: qx.dev.unit.TestCase,
 
-  include : [qx.dev.unit.MRequirements,
-             qx.test.io.MRemoteTest],
+  include: [qx.dev.unit.MRequirements, qx.test.io.MRemoteTest],
 
-  members :
-  {
-    setUp: function() {
+  members: {
+    setUp() {
       this.require(["http", "php"]);
       this.res = new qx.io.rest.Resource();
     },
 
-    tearDown: function() {
+    tearDown() {
       this.res.dispose();
     },
 
-    "test: invoke action and handle response": function() {
+    "test: invoke action and handle response"() {
       // Handles GET
       var url = this.getUrl("qx/test/xmlhttp/sample.txt"),
-          res = this.res;
+        res = this.res;
 
       res.map("get", "GET", url);
-      res.addListener("getSuccess", function(e) {
-        this.resume(function() {
-          this.assertEquals("SAMPLE", e.getData());
-        }, this);
-      }, this);
+      res.addListener(
+        "getSuccess",
+        function (e) {
+          this.resume(function () {
+            this.assertEquals("SAMPLE", e.getData());
+          }, this);
+        },
+        this
+      );
 
       res.get();
       this.wait();
     },
 
-    "test: invoke action and handle failure": function() {
+    "test: invoke action and handle failure"() {
       this.require(["http"]);
 
       var url = "/not-found",
-          res = this.res;
+        res = this.res;
 
       res.map("get", "GET", url);
-      res.addListener("error", function(e) {
-        this.resume(function() {
-          this.assertEquals("statusError", e.getPhase());
-          this.assertEquals("get", e.getAction());
-        }, this);
-      }, this);
+      res.addListener(
+        "error",
+        function (e) {
+          this.resume(function () {
+            this.assertEquals("statusError", e.getPhase());
+            this.assertEquals("get", e.getAction());
+          }, this);
+        },
+        this
+      );
 
       res.get();
       this.wait();
     },
 
-    "test: poll action": function() {
+    "test: poll action"() {
       // Handles GET
       this.require(["php"]);
       var url = this.getUrl("qx/test/xmlhttp/random.php"),
-          res = this.res,
-          count = 0,
-          previousResponse = "";
+        res = this.res,
+        count = 0,
+        previousResponse = "";
 
       res.map("get", "GET", url);
 
       // Response headers must contain explicit cache control for this
       // to work in IE
-      res.addListener("getSuccess", function(e) {
-        var response = e.getData();
-        count++;
-
-        this.assert(response.length === 32, "Response must be MD5");
-        this.assertNotEquals(previousResponse, response,
-          "Response must be different from previous");
-        previousResponse = response;
-
-        if (count >= 10) {
-          this.resume();
-        }
-
-      }, this);
+      res.addListener(
+        "getSuccess",
+        function (e) {
+          var response = e.getData();
+          count++;
+
+          this.assert(response.length === 32, "Response must be MD5");
+          this.assertNotEquals(
+            previousResponse,
+            response,
+            "Response must be different from previous"
+          );
+
+          previousResponse = response;
+
+          if (count >= 10) {
+            this.resume();
+          }
+        },
+        this
+      );
 
       res.poll("get", 100);
       this.wait();
     },
 
-    "test: long poll": function() {
+    "test: long poll"() {
       this.require(["php"]);
       var res = this.res,
-          url = this.getUrl("qx/test/xmlhttp/long_poll.php"),
-          count = 0,
-          responses = [];
+        url = this.getUrl("qx/test/xmlhttp/long_poll.php"),
+        count = 0,
+        responses = [];
 
       res.map("get", "GET", url);
-      res.addListener("getSuccess", function(e) {
-        var response = e.getData();
-        responses.push(response);
-
-        if (++count >= 5) {
-          this.resume(function() {
-            this.assert(parseFloat(responses[4]) > parseFloat(responses[0]),
-              "Must increase");
-          }, this);
-        }
-      }, this);
+      res.addListener(
+        "getSuccess",
+        function (e) {
+          var response = e.getData();
+          responses.push(response);
+
+          if (++count >= 5) {
+            this.resume(function () {
+              this.assert(
+                parseFloat(responses[4]) > parseFloat(responses[0]),
+                "Must increase"
+              );
+            }, this);
+          }
+        },
+        this
+      );
 
       res.longPoll("get");
       this.wait();
     }
-
   }
 });

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,64 @@
+/* ************************************************************************
+
+   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/lang/Array.js

@@ -17,196 +17,170 @@
 
 ************************************************************************ */
 
-qx.Class.define("qx.test.lang.Array",
-{
-  extend : qx.dev.unit.TestCase,
+qx.Class.define("qx.test.lang.Array", {
+  extend: qx.dev.unit.TestCase,
 
-  members :
-  {
+  members: {
     /**
      * Array tests
      *
      */
-    testAppend : function()
-    {
+    testAppend() {
       this.assertNotUndefined(qx.lang.Array.append);
-      var a = [ 1, 2, 3 ];
-      qx.lang.Array.append(a, [ 4, 5, 6 ]);
-      this.assertJsonEquals(a, [ 1, 2, 3, 4, 5, 6 ]);
+      var a = [1, 2, 3];
+      qx.lang.Array.append(a, [4, 5, 6]);
+      this.assertJsonEquals(a, [1, 2, 3, 4, 5, 6]);
 
-      var a = [ 1, 2, 3 ];
-      qx.lang.Array.append(a, new qx.data.Array([ 4, 5, 6 ]));
-      this.assertJsonEquals(a, [ 1, 2, 3, 4, 5, 6 ]);
+      var a = [1, 2, 3];
+      qx.lang.Array.append(a, new qx.data.Array([4, 5, 6]));
+      this.assertJsonEquals(a, [1, 2, 3, 4, 5, 6]);
 
-      var a = new qx.data.Array([ 1, 2, 3 ]);
-      qx.lang.Array.append(a, [ 4, 5, 6 ]);
-      this.assertJsonEquals(a.toArray(), [ 1, 2, 3, 4, 5, 6 ]);
+      var a = new qx.data.Array([1, 2, 3]);
+      qx.lang.Array.append(a, [4, 5, 6]);
+      this.assertJsonEquals(a.toArray(), [1, 2, 3, 4, 5, 6]);
       a.dispose();
 
       var error = false;
 
       try {
         qx.lang.Array.append(a, 1);
-      } catch(ex) {
+      } catch (ex) {
         error = true;
       }
 
       this.assert(error);
     },
-    
-    
-    testExclude : function() {
-      var a = [ 1, 2, 3, 4, 5 ];
-      qx.lang.Array.exclude(a, [ 2, 4 ]);
-      this.assertJsonEquals([ 1, 3, 5 ], a);
-      
-      var a = [0,1,2,3,4,5,6,7,8,9];
-      qx.lang.Array.exclude(a, [1,2,3]);
-      this.assertJsonEquals([0,4,5,6,7,8,9], a);
-      
-      var a = [ 1, 2, 3, 4, 5 ];
-      qx.lang.Array.exclude(a, new qx.data.Array([ 1, 3, 5 ]));
-      this.assertJsonEquals([ 2, 4 ], a);
-      
-      var a = [0,1,2,3,4,5,6,7,8,9];
-      qx.lang.Array.exclude(a, new qx.data.Array([ 1,2,3 ]));
-      this.assertJsonEquals([0,4,5,6,7,8,9], a);
-      
-      var a = new qx.data.Array([ 1, 2, 3, 4, 5 ]);
-      qx.lang.Array.exclude(a, [ 1, 3, 5 ]);
-      this.assertJsonEquals([ 2, 4 ], a.toArray());
+
+    testExclude() {
+      var a = [1, 2, 3, 4, 5];
+      qx.lang.Array.exclude(a, [2, 4]);
+      this.assertJsonEquals([1, 3, 5], a);
+
+      var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+      qx.lang.Array.exclude(a, [1, 2, 3]);
+      this.assertJsonEquals([0, 4, 5, 6, 7, 8, 9], a);
+
+      var a = [1, 2, 3, 4, 5];
+      qx.lang.Array.exclude(a, new qx.data.Array([1, 3, 5]));
+      this.assertJsonEquals([2, 4], a);
+
+      var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+      qx.lang.Array.exclude(a, new qx.data.Array([1, 2, 3]));
+      this.assertJsonEquals([0, 4, 5, 6, 7, 8, 9], a);
+
+      var a = new qx.data.Array([1, 2, 3, 4, 5]);
+      qx.lang.Array.exclude(a, [1, 3, 5]);
+      this.assertJsonEquals([2, 4], a.toArray());
       a.dispose();
-      
-      var a = new qx.data.Array([0,1,2,3,4,5,6,7,8,9]);
-      qx.lang.Array.exclude(a, [1,2,3]);
-      this.assertJsonEquals([0,4,5,6,7,8,9], a.toArray());
+
+      var a = new qx.data.Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      qx.lang.Array.exclude(a, [1, 2, 3]);
+      this.assertJsonEquals([0, 4, 5, 6, 7, 8, 9], a.toArray());
       a.dispose();
     },
 
-
-    testMinNumeric : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+    testMinNumeric() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       var result = qx.lang.Array.min(a);
       this.assertEquals(-3, result);
     },
 
-
-    testMaxNumeric : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+    testMaxNumeric() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       var result = qx.lang.Array.max(a);
       this.assertEquals(3, result);
     },
 
-
-    testMinMixed : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3, 'foo', 'bar', undefined, null ];
+    testMinMixed() {
+      var a = [-3, -2, -1, 0, 1, 2, 3, "foo", "bar", undefined, null];
       var result = qx.lang.Array.min(a);
       this.assertEquals(-3, result);
     },
 
-
-    testMaxMixed : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3, 'foo', 'bar', undefined, null ];
+    testMaxMixed() {
+      var a = [-3, -2, -1, 0, 1, 2, 3, "foo", "bar", undefined, null];
       var result = qx.lang.Array.max(a);
       this.assertEquals(3, result);
     },
 
-
-    testMinEmpty : function()
-    {
-      var a = [ ];
+    testMinEmpty() {
+      var a = [];
       var result = qx.lang.Array.min(a);
       this.assertEquals(null, result);
     },
 
-
-    testMaxEmpty : function()
-    {
-      var a = [ ];
+    testMaxEmpty() {
+      var a = [];
       var result = qx.lang.Array.max(a);
       this.assertEquals(null, result);
     },
 
-
-    testRemove : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+    testRemove() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       qx.lang.Array.remove(a, 2);
 
-      this.assertJsonEquals(a, [ -3, -2, -1, 0, 1, 3 ]);
+      this.assertJsonEquals(a, [-3, -2, -1, 0, 1, 3]);
       this.assertEquals(6, a.length);
-      
-      var da = new qx.data.Array([ -3, -2, -1, 0, 1, 2, 3 ]);
+
+      var da = new qx.data.Array([-3, -2, -1, 0, 1, 2, 3]);
       qx.lang.Array.remove(da, 2);
 
-      this.assertJsonEquals(da.toArray(), [ -3, -2, -1, 0, 1, 3 ]);
+      this.assertJsonEquals(da.toArray(), [-3, -2, -1, 0, 1, 3]);
       this.assertEquals(6, da.length);
     },
 
-
-    testRemoveAt : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+    testRemoveAt() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       qx.lang.Array.removeAt(a, 3);
 
-      this.assertJsonEquals(a, [ -3, -2, -1, 1, 2, 3 ]);
+      this.assertJsonEquals(a, [-3, -2, -1, 1, 2, 3]);
       this.assertEquals(6, a.length);
     },
 
-
-    testRemoveAll : function()
-    {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+    testRemoveAll() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       qx.lang.Array.removeAll(a);
 
       this.assertJsonEquals(a, []);
       this.assertEquals(0, a.length);
     },
-    
-    
-    testContains: function() {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+
+    testContains() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       var da = new qx.data.Array(a);
 
       this.assertTrue(a.includes(-2));
       this.assertFalse(a.includes(-10));
       this.assertTrue(da.includes(-2));
       this.assertFalse(da.includes(-10));
-      
+
       da.dispose();
     },
-    
-    
-    testEquals : function() {
-      var a = [ -3, -2, -1, 0, 1, 2, 3 ];
+
+    testEquals() {
+      var a = [-3, -2, -1, 0, 1, 2, 3];
       var da = new qx.data.Array(a);
-      
+
       this.assertFalse(da.toArray() === a);
       this.assertTrue(qx.lang.Array.equals(a, da));
       this.assertTrue(qx.lang.Array.equals(da, a));
-      this.assertFalse(qx.lang.Array.equals(a, [ 4, 5, 6 ]));
+      this.assertFalse(qx.lang.Array.equals(a, [4, 5, 6]));
     },
-    
-    
-    testReplace: function() {
-      var a = [ 1, 2, 3 ];
-      var tmp = qx.lang.Array.replace(a, [ "one", "two", "three" ]);
+
+    testReplace() {
+      var a = [1, 2, 3];
+      var tmp = qx.lang.Array.replace(a, ["one", "two", "three"]);
       this.assertTrue(a === tmp);
-      this.assertArrayEquals([ "one", "two", "three" ], a);
+      this.assertArrayEquals(["one", "two", "three"], a);
     },
 
-
-    testToNativeArray : function() {
-      var da = new qx.data.Array([ 1, 2, 3 ]);
+    testToNativeArray() {
+      var da = new qx.data.Array([1, 2, 3]);
       var na = qx.lang.Array.toNativeArray(da);
       this.assertTrue(da.toArray() === na);
       na = qx.lang.Array.toNativeArray(da, true);
       this.assertTrue(da.toArray() !== na);
-      this.assertArrayEquals([ 1, 2, 3 ], na);
+      this.assertArrayEquals([1, 2, 3], na);
     }
   }
 });