tst_webchannel.qml

qt/qtwebchannel/tests/auto/qml/data/tst_webchannel.qml

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

import QtQuick

import QtTest

import QtWebChannel

import QtWebChannel.Tests

import "qrc:///qtwebchannel/qwebchannel.js" as JSClient

TestCase {

    name: "WebChannel"

    Client {

        id: client

    property var lastMethodArg

    QtObject {

        id: myObj

        property int myProperty: 1

        signal mySignal(var arg, QtObject object)

        function myMethod(arg)

            lastMethodArg = arg;

        WebChannel.id: "myObj"

    QtObject {

        id: myOtherObj

        property var foo: 1

        property var bar: 1

        WebChannel.id: "myOtherObj"

    QtObject {

        id: myValueObj

        property var value: undefined

        WebChannel.id: "myValueObj"

    property var lastFactoryObj

    QtObject{ id: bar; objectName: "bar" }

    QtObject{ id: baz; objectName: "baz" }

    QtObject {

        id: myFactory

        function create(id)

            lastFactoryObj = component.createObject(myFactory, {objectName: id});

            return lastFactoryObj;

        function switchObject() {

            otherObject = myOtherObj;

        property var objectInProperty: QtObject {

            objectName: "foo"

        property var otherObject: myObj

        property var objects: [ bar, baz ];

        WebChannel.id: "myFactory"

    Component {

        id: component

        QtObject {

            property var myProperty : 0

            function myMethod(arg) {

                lastMethodArg = arg;

                return myProperty;

            signal mySignal(var arg1, var arg2)

    TestObject {

        id: testObject

        WebChannel.id: "testObject"

    TestWebChannel {

        id: webChannel

        transports: [client.serverTransport]

        registeredObjects: [myObj, myOtherObj, myValueObj, myFactory, testObject]

    WebChannel {

        id: nullTest

    function initChannel() {

        client.serverTransport.receiveMessage(JSON.stringify({type: JSClient.QWebChannelMessageTypes.idle}));

        webChannel.blockUpdates = true;

        webChannel.blockUpdates = false;

    function init()

        myObj.myProperty = 1

        // immediately send pending updates

        // to avoid property changed signals

        // during run of test case

        initChannel();

        client.cleanup();

    function cleanup() {

        // make tests a bit more strict and predictable

        // by assuming that a test consumes all messages

        initChannel();

        compare(client.clientMessages.length, 0);

    function test_notifyProperty()

        compare(myObj.myProperty, 1);

        var initialValue;

        var changedValue;

        var channel = client.createChannel(function(channel) {

            initialValue = channel.objects.myObj.myProperty;

            channel.objects.myObj.myPropertyChanged.connect(function() {

                changedValue = channel.objects.myObj.myProperty;

});

            // now trigger a write from the client side

            channel.objects.myObj.myProperty = 3;

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(initialValue, 1);

        compare(myObj.myProperty, 3);

        client.awaitIdle(); // init

        // change property, should be propagated to HTML client and a message be send there

        myObj.myProperty = 2;

        compare(myObj.myProperty, 2);

        client.awaitIdle(); // property update

        compare(changedValue, 2);

        compare(channel.objects.myObj.myProperty, 2)

    function test_bindableProperty()

        compare(testObject.stringProperty, "foo");

        var initialValue;

        var channel = client.createChannel(function(channel) {

            initialValue = channel.objects.testObject.stringProperty;

            // now trigger a write from the client side

            channel.objects.testObject.stringProperty = "bar";

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(initialValue, "foo");

        compare(testObject.stringProperty, "bar");

        client.awaitIdle(); // init

        // Change property, should be propagated to HTML client.

        // This is a bindable property only. Not change signal will be emitted

        // because there is none.

        testObject.stringProperty = "baz";

        compare(testObject.stringProperty, "baz");

        client.awaitIdle(); // property update

        compare(channel.objects.testObject.stringProperty, "baz");

    function test_method()

        var channel = client.createChannel(function (channel) {

            channel.objects.myObj.myMethod("test");

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        compare(msg.object, "myObj");

        compare(msg.args, ["test"]);

        compare(lastMethodArg, "test")

        client.awaitIdle();

    function test_signal()

        var signalReceivedArg;

        var signalReceivedObject;

        var channel = client.createChannel(function(channel) {

            channel.objects.myObj.mySignal.connect(function(arg, object) {

                signalReceivedArg = arg;

                signalReceivedObject = object;

});

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "myObj");

        client.awaitIdle(); // initialization

        myObj.mySignal("test", myObj);

        compare(signalReceivedArg, "test");

        compare(signalReceivedObject.__id__, "myObj");

        var newObj = myFactory.create("newObj");

        myObj.mySignal(newObj, newObj);

        compare(signalReceivedArg.objectName, newObj.objectName);

        compare(signalReceivedObject.objectName, newObj.objectName);

    function test_grouping()

        var receivedPropertyUpdates = 0;

        var properties = 0;

        var channel = client.createChannel(function(channel) {

            var originalHandler = channel.handlePropertyUpdate;

            channel.handlePropertyUpdate = function(message) {

                originalHandler(message);

                receivedPropertyUpdates++;

                properties = [channel.objects.myObj.myProperty, channel.objects.myOtherObj.foo, channel.objects.myOtherObj.bar];

};

});

        client.awaitInit();

        client.awaitIdle();

        // change properties a lot, we expect this to be grouped into a single update notification

        for (var i = 0; i < 10; ++i) {

            myObj.myProperty = i;

            myOtherObj.foo = i;

            myOtherObj.bar = i;

        client.awaitIdle();

        compare(receivedPropertyUpdates, 1);

        compare(properties, [myObj.myProperty, myOtherObj.foo, myOtherObj.bar]);

        verify(!client.awaitMessage());

    function test_wrapper()

        var signalArgs;

        var testObjBeforeDeletion;

        var testObjAfterDeletion;

        var testObjId;

        var testReturn;

        var channel = client.createChannel(function(channel) {

            channel.objects.myFactory.create("testObj", function(obj) {

                testObjId = obj.__id__;

                compare(channel.objects[testObjId], obj);

                obj.mySignal.connect(function() {

                    signalArgs = arguments;

                    testObjBeforeDeletion = obj;

                    obj.deleteLater();

                    testObjAfterDeletion = obj;

});

                obj.myProperty = 42;

                obj.myMethod("foobar").then(function(result) {

                    testReturn = result;

});

});

});

        client.awaitInit();

        client.awaitResponse();

        // create testObj

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        compare(msg.object, "myFactory");

        client.awaitResponse();

        verify(lastFactoryObj);

        compare(lastFactoryObj.objectName, "testObj");

        compare(channel.objects[testObjId].objectName, "testObj");

        // mySignal connection

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, testObjId);

        // set myProperty

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.setProperty);

        compare(msg.object, testObjId);

        compare(lastFactoryObj.myProperty, 42);

        // call myMethod

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        compare(msg.object, testObjId);

        compare(msg.args, ["foobar"]);

        client.awaitResponse();

        compare(lastMethodArg, "foobar");

        client.awaitIdle();

        // the server should eventually notify the client about the property update

        client.awaitPropertyUpdate();

        // check that the Promise from myMethod was resolved

        // must happen after waiting for something so the Promise callback

        // can execute

        compare(testReturn, 42);

        client.awaitIdle();

        // property should be wrapped

        compare(channel.objects.myFactory.objectInProperty.objectName, "foo");

        // list property as well

        compare(channel.objects.myFactory.objects.length, 2);

        compare(channel.objects.myFactory.objects[0].objectName, "bar");

        compare(channel.objects.myFactory.objects[1].objectName, "baz");

        // map property as well

        compare(channel.objects.testObject.objectMap.subObject.objectName,

            "embedded");

        // also works with properties that reference other registered objects

        compare(channel.objects.myFactory.otherObject, channel.objects.myObj);

        // change object property

        channel.objects.myFactory.switchObject();

        client.awaitMessage();

        client.awaitResponse();

        client.awaitIdle();

        client.awaitPropertyUpdate();

        compare(channel.objects.myFactory.otherObject, channel.objects.myOtherObj);

        // trigger a signal and ensure it gets transmitted

        lastFactoryObj.mySignal("foobar", 42);

        client.awaitSignal();

        // deleteLater call

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        compare(msg.object, testObjId);

        client.awaitResponse();

        // now the signalArgs should also be set

        compare(signalArgs, {"0": "foobar", "1": 42});

        // and also a destroyed signal

        client.awaitSignal();

        compare(JSON.stringify(testObjBeforeDeletion), JSON.stringify({}));

        compare(JSON.stringify(testObjAfterDeletion), JSON.stringify({}));

        compare(typeof channel.objects[testObjId], "undefined");

    // test if returned QObjects get inserted into list of

    // objects even if no callback function is set

    function test_wrapper_wrapEveryQObject()

        var testObj;

        var channel = client.createChannel(function(channel) {

            channel.objects.myFactory.create("testObj", function(obj) {

                testObj = obj;

});

});

        client.awaitInit();

        client.awaitResponse();

        // call to myFactory.create()

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitResponse();

        client.awaitIdle();

        verify(testObj);

        var testObjId = testObj.__id__;

        testObj.deleteLater();

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        compare(msg.object, testObjId);

        client.awaitResponse();

        // destroyed signal

        client.awaitSignal();

        compare(lastFactoryObj, null);

        compare(typeof channel.objects[testObjId], "undefined");

    function test_wrapper_propertyUpdateOfWrappedObjects()

        var testObj;

        var testObjId;

        var channel = client.createChannel(function(channel) {

            channel.objects.myFactory.create("testObj", function(obj) {

                testObj = lastFactoryObj;

                testObjId = obj.__id__;

});

});

        client.awaitInit();

        client.awaitResponse();

        // call to myFactory.create()

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitResponse();

        client.awaitIdle();

        testObj.myProperty = 42;

        client.awaitPropertyUpdate();

        client.awaitIdle();

        compare(channel.objects[testObjId].myProperty, 42);

        channel.objects[testObjId].deleteLater();

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitResponse();

        // destroyed signal

        client.awaitSignal();

    function test_disconnect()

        var signalArg;

        var channel = client.createChannel(function(channel) {

            channel.objects.myObj.mySignal.connect(function(arg) {

                signalArg = arg;

                channel.objects.myObj.mySignal.disconnect(this);

});

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "myObj");

        client.awaitIdle();

        myObj.mySignal(42, myObj);

        compare(signalArg, 42);

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.disconnectFromSignal);

        compare(msg.object, "myObj");

        myObj.mySignal(0, myObj);

        compare(signalArg, 42);

    // see also: https://bugreports.qt.io/browse/QTBUG-54074

    function test_signalArgumentTypeConversion()

        var signalArgs = [];

        function logSignalArgs(arg) {

            signalArgs.push(arg);

        var channel = client.createChannel(function(channel) {

            var testObject = channel.objects.testObject;

            testObject.testSignalBool.connect(logSignalArgs);

            testObject.testSignalInt.connect(logSignalArgs);

            testObject.triggerSignals();

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "testObject");

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "testObject");

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitIdle();

        compare(signalArgs, [

            true,

            false,

42,

1,

]);

    function test_multiConnect()

        var signalArgs = [];

        function logSignalArgs(arg) {

            signalArgs.push(arg);

        var channel = client.createChannel(function(channel) {

            var testObject = channel.objects.testObject;

            testObject.testSignalInt.connect(logSignalArgs);

            testObject.testSignalInt.connect(logSignalArgs);

            testObject.triggerSignals();

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "testObject");

        msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitIdle();

        compare(signalArgs, [42, 42, 1, 1, 0, 0]);

    function test_connectDuringEmit()

        var cb1 = 0;

        var cb2 = 0;

        var channel = client.createChannel(function(channel) {

            var myObj = channel.objects.myObj;

            myObj.mySignal.connect(function() {

                cb1++;

                myObj.mySignal.connect(function() {

                    cb2++;

});

});

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "myObj");

        client.awaitIdle();

        myObj.mySignal(42, myObj);

        compare(cb1, 1);

        compare(cb2, 0);

    function test_disconnectDuringEmit()

        var cb1 = 0;

        var cb2 = 0;

        var cb3 = 0;

        var channel = client.createChannel(function(channel) {

            var myObj = channel.objects.myObj;

            var cb1impl = function() {

                cb1++;

};

            myObj.mySignal.connect(cb1impl);

            myObj.mySignal.connect(function() {

                cb2++;

                myObj.mySignal.disconnect(cb1impl);

});

            myObj.mySignal.connect(function() {

                cb3++;

});

});

        client.awaitInit();

        var msg = client.awaitMessage();

        compare(msg.type, JSClient.QWebChannelMessageTypes.connectToSignal);

        compare(msg.object, "myObj");

        client.awaitIdle();

        myObj.mySignal(42, myObj);

        compare(cb1, 1);

        compare(cb2, 1);

        compare(cb3, 1);

    function test_overloading()

        var signalArgs_implicit = [];

        var signalArgs_explicit1 = [];

        var signalArgs_explicit2 = [];

        var signalArgs_explicit3 = [];

        function logSignalArgs(container) {

            return function(...args) {

                container.push(args);

};

        var returnValues = [];

        function logReturnValue(value) {

            returnValues.push(value);

        var channel = client.createChannel(function(channel) {

            var testObject = channel.objects.testObject;

            testObject.testOverloadSignal.connect(logSignalArgs(signalArgs_implicit));

            testObject["testOverloadSignal(int)"].connect(logSignalArgs(signalArgs_explicit1));

            testObject["testOverloadSignal(QString)"].connect(logSignalArgs(signalArgs_explicit2));

            testObject["testOverloadSignal(QString,int)"].connect(logSignalArgs(signalArgs_explicit3));

            testObject.testOverload(99, logReturnValue);

            testObject["testOverload(int)"](41, logReturnValue);

            testObject["testOverload(QString)"]("hello world", logReturnValue);

            testObject["testOverload(QString,int)"]("the answer is ", 41, logReturnValue);

});

        client.awaitInit();

        function awaitMessage(type)

            var msg = client.awaitMessage();

            compare(msg.type, type);

            compare(msg.object, "testObject");

        console.log("sig1");

        awaitMessage(JSClient.QWebChannelMessageTypes.connectToSignal);

        console.log("sig2");

        awaitMessage(JSClient.QWebChannelMessageTypes.connectToSignal);

        console.log("sig3");

        awaitMessage(JSClient.QWebChannelMessageTypes.connectToSignal);

        console.log("method1");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("method2");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("method3");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("method4");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitIdle();

        compare(signalArgs_implicit, [[99], [41]]);

        compare(signalArgs_explicit1, signalArgs_implicit);

        compare(signalArgs_explicit2, [["hello world"]]);

        compare(signalArgs_explicit3, [["the answer is ", 41]]);

        compare(returnValues, [100, 42, "HELLO WORLD", "THE ANSWER IS 42"]);

    function test_variantType()

        var returnValues = [];

        function logReturnValue(value) {

            returnValues.push(value);

        var channel = client.createChannel(function(channel) {

            var testObject = channel.objects.testObject;

            testObject.testVariantType(0.25, logReturnValue);

            testObject.testVariantType("0", logReturnValue);

            testObject.testVariantType(null, logReturnValue);

            testObject.testVariantType(testObject, logReturnValue);

});

        client.awaitInit();

        function awaitMessage(type)

            var msg = client.awaitMessage();

            compare(msg.type, type);

            compare(msg.object, "testObject");

        console.log("double arg");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("string arg");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("null arg");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        console.log("QObject arg");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitIdle();

        // QMetaType::Double: 6, QMetaType::QString: 10, QMetaType::Nullptr: 51,

        // QMetaType::QObjectStar: 39

        compare(returnValues, [6, 10, 51, 39]);

    function test_embeddedQObject()

        var success = false;

        function logReturnValue(value) {

            success = value;

        var channel = client.createChannel(function(channel) {

            var testObject = channel.objects.testObject;

            testObject.testEmbeddedObjects([testObject, { obj: testObject }], logReturnValue);

});

        client.awaitInit();

        function awaitMessage(type)

            var msg = client.awaitMessage();

            compare(msg.type, type);

            compare(msg.object, "testObject");

        awaitMessage(JSClient.QWebChannelMessageTypes.invokeMethod);

        client.awaitIdle();

        compare(success, true);

    function test_customUpcaseWrapper()

        var channel = client.createChannel(function(channel) {

            channel.objects.testObject.stringProperty = "foo";

        }, function(arg) { return (typeof arg === "string") ? arg.toUpperCase() : undefined });

        client.awaitInit();

        function awaitMessage(type)

            var msg = client.awaitMessage();

            compare(msg.type, type);

            compare(msg.object, "testObject");

        awaitMessage(JSClient.QWebChannelMessageTypes.setProperty);

        compare(testObject.stringProperty, "foo"); // Don't convert in this direction

        client.awaitIdle(); // init

        testObject.stringProperty = "bar";

        compare(testObject.stringProperty, "bar");

        client.awaitIdle(); // property update

        compare(channel.objects.testObject.stringProperty, "BAR"); // Case converted

    function test_dateWrapper()

        var channel = client.createChannel(undefined, "Date");

        client.awaitInit();

        client.awaitIdle();

        var dateString = "2022-01-01T10:00:00Z";

        myValueObj.value = dateString;

        compare(myValueObj.value, dateString);

        client.awaitIdle(); // property update

        var value = channel.objects.myValueObj.value;

        verify(value instanceof Date);

        verify(!isNaN(value));

        compare(value.getUTCFullYear(), 2022);

        compare(value.getUTCMonth(), 0); // 0 = January

        compare(value.getUTCDate(), 1);

        compare(value.getUTCHours(), 10);

        compare(value.getUTCMinutes(), 0);

        compare(value.getUTCSeconds(), 0);

        var invalidDate = "2022-13-31T10:00:00Z"; // Month after december

        myValueObj.value = invalidDate;

        compare(myValueObj.value, invalidDate);

        client.awaitIdle(); // property update

        value = channel.objects.myValueObj.value;

        verify(typeof value === "string"); // Not converted to Date

        compare(value, invalidDate);

    function test_registerNull()

        nullTest.registeredObjects = [null]

        compare(nullTest.registeredObjects, [])

    function test_noContext()

        nullTest.registeredObjects = [testObject.createQObject()]

        compare(nullTest.registeredObjects, [])