13 files changed, 549 insertions(+), 2 deletions(-)

M module-db/tests/QueryInterface.cpp
M module-services/service-desktop/endpoints/Context.hpp
M module-services/service-desktop/tests/unittest.cpp
A test/service-desktop-test/defs.py
A test/service-desktop-test/main.py
A test/service-desktop-test/test.py
A test/service-desktop-test/tests/backup.py
A test/service-desktop-test/tests/contacts.py
A test/service-desktop-test/tests/deviceinfo.py
A test/service-desktop-test/tests/factoryReset.py
A test/service-desktop-test/tests/messages.py
A test/service-desktop-test/tests/templates.py
A test/service-desktop-test/tests/update.py

@@ 9,6 9,8 @@
 #include "queries/sms/QuerySMSSearch.hpp"
 
 #include <memory>
+#include <module-db/queries/sms/QuerySMSGetCount.hpp>
+#include <module-utils/json/json11.hpp>
 
 namespace db
 {


@@ 56,4 58,32 @@ TEST_CASE("Query interface")
         auto result = threadInterface->runQuery(query);
         REQUIRE(dynamic_cast<db::query::SMSSearchResult *>(result.get()));
     }
+
+    SECTION("Endpoint callback test")
+    {
+        std::shared_ptr<db::Query> query = std::make_shared<db::query::SMSGetCount>();
+        auto testMessage                 = R"({"endpoint":6, "method":1, "uuid":12345, "body":{"test":"test"}})";
+        std::string err;
+        auto msgJson = json11::Json::parse(testMessage, err);
+        REQUIRE(err.empty());
+
+        Context context(msgJson);
+        auto listener = std::make_unique<db::EndpointListener>(
+            [=](db::QueryResult *result, Context &context) {
+                if (auto SMSResult = dynamic_cast<db::query::SMSGetCountResult *>(result)) {
+                    auto id   = SMSResult->getResults();
+                    auto body = json11::Json::object{{"count", static_cast<int>(id)}};
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            context);
+
+        query->setQueryListener(std::move(listener));
+        auto result        = smsInterface->runQuery(query);
+        auto queryListener = result->getRequestQuery()->getQueryListener();
+        REQUIRE(queryListener->handleQueryResponse(result.get()) == true);
+    }
 }

@@ 20,6 20,8 @@ namespace parserFSM
         json11::Json body = json11::Json();
     };
 
+    constexpr int invalidUuid = 0;
+
     class Context
     {
       private:


@@ 37,6 39,9 @@ namespace parserFSM
             if (static_cast<int>(endpoint) > lastEndpoint) {
                 endpoint = EndpointType::invalid;
             }
+            if (method > http::Method::del) {
+                method = http::Method::get;
+            }
         }
         auto buildResponseStr(std::size_t responseSize, std::string responsePayloadString) -> std::string
         {


@@ 57,6 62,14 @@ namespace parserFSM
             body     = js[json::body];
             endpoint = static_cast<EndpointType>(js[json::endpoint].int_value());
             uuid     = js[json::uuid].int_value();
+            if (uuid == invalidUuid) {
+                try {
+                    uuid = stoi(js[json::uuid].string_value());
+                }
+                catch (...) {
+                    uuid = invalidUuid;
+                }
+            }
             method   = static_cast<http::Method>(js[json::method].int_value());
             validate();
         }


@@ 64,7 77,7 @@ namespace parserFSM
         {
             body     = json11::Json();
             endpoint = EndpointType::invalid;
-            uuid     = 0;
+            uuid     = invalidUuid;
             method   = http::Method::get;
         }
 

@@ 11,7 11,8 @@
 #include "messages/MessageHelper.hpp"
 #include "queries/sms/QuerySMSSearchByType.hpp"
 #include "service-desktop/ServiceDesktop.hpp"
-
+#include "EndpointFactory.hpp"
+#include "contacts/ContactsEndpoint.hpp"
 #include "json/json11.hpp"
 #include <memory>
 #include <vfs.hpp>


@@ 230,3 231,65 @@ TEST_CASE("DB Helpers test - json encoding (messages)")
     REQUIRE(messageTemplateJson[json::messages::id] == 1);
 }
 
+TEST_CASE("Context class test")
+{
+    SECTION("Correct message")
+    {
+        auto testMessage = R"({"endpoint":6, "method":1, "uuid":12345, "body":{"test":"test"}})";
+        std::string err;
+        auto msgJson = json11::Json::parse(testMessage, err);
+        REQUIRE(err.empty());
+
+        Context context(msgJson);
+        REQUIRE(context.getBody()["test"] == "test");
+        REQUIRE(context.getMethod() == http::Method::get);
+        REQUIRE(context.getUuid() == 12345);
+        REQUIRE(context.getEndpoint() == EndpointType::contacts);
+        REQUIRE(context.createSimpleResponse() ==
+                R"(#000000061{"body": null, "endpoint": 6, "status": 200, "uuid": "12345"})");
+
+        context.setResponseBody(context.getBody());
+        REQUIRE(context.createSimpleResponse() ==
+                R"(#000000073{"body": {"test": "test"}, "endpoint": 6, "status": 200, "uuid": "12345"})");
+    }
+    SECTION("Invalid message")
+    {
+        auto testMessage = R"({"endpoint":25, "method":8, "uuid":"0", "body":{"te":"test"}})";
+        std::string err;
+        auto msgJson = json11::Json::parse(testMessage, err);
+        REQUIRE(err.empty());
+
+        Context context(msgJson);
+        REQUIRE(context.getBody()["test"] == json11::Json());
+        REQUIRE(context.getMethod() == http::Method::get);
+        REQUIRE(context.getUuid() == invalidUuid);
+        REQUIRE(context.getEndpoint() == EndpointType::invalid);
+    }
+}
+
+TEST_CASE("Endpoint Factory test")
+{
+    SECTION("Proper endpoint")
+    {
+        auto testMessage = R"({"endpoint":6, "method":1, "uuid":12345, "body":{"test":"test"}})";
+        std::string err;
+        auto msgJson = json11::Json::parse(testMessage, err);
+        REQUIRE(err.empty());
+
+        Context context(msgJson);
+        auto handler = EndpointFactory::create(context, nullptr);
+        REQUIRE(dynamic_cast<ContactsEndpoint *>(handler.get()));
+    }
+
+    SECTION("Wrong endpoint")
+    {
+        auto testMessage = R"({"endpoint":25, "method":8, "uuid":"12345", "body":{"te":"test"}})";
+        std::string err;
+        auto msgJson = json11::Json::parse(testMessage, err);
+        REQUIRE(err.empty());
+
+        Context context(msgJson);
+        auto handler = EndpointFactory::create(context, nullptr);
+        REQUIRE(handler == nullptr);
+    }
+}

@@ 0,0 1,22 @@
+endpoint = {
+    "deviceInfo": 1,
+    "update": 2,
+    "backup": 3,
+    "restore": 4,
+    "factory": 5,
+    "contacts": 6,
+    "messages": 7
+}
+
+method = {
+    "get": 1,
+    "post": 2,
+    "put": 3,
+    "del": 4
+}
+
+status = {
+    "OK": 200,
+    "BadRequest": 400,
+    "InternalServerError": 500
+}

@@ 0,0 1,35 @@
+from tests.messages import *
+from tests.templates import *
+from tests.contacts import *
+from tests.update import *
+from tests.deviceinfo import *
+from tests.factoryReset import *
+from tests.backup import *
+from termcolor import colored
+
+
+def main(port_name='/dev/ttyACM1'):
+    phone.port = port_name
+    phone.timeout = 10
+    phone.open()
+    phone.flushInput()
+    final_result = True
+    failed_tests = []
+    for test_instance in (DeviceInfoTest(), UpdateTest(), BackupTest(), MessageTest(),
+                          MessageTemplateTest(), ContactTest(), FactoryResetTest()):
+        test_name = type(test_instance).__name__
+        result = test_instance.run()
+        if result == False:
+            failed_tests.append(test_name)
+        final_result = final_result and result
+        print(
+            f'[{test_name}] {colored("PASS", "green") if result else colored("FAIL", "red")}')
+
+    print("\nFinal result:", colored("PASS", "green") if final_result else colored("FAIL", "red"))
+    print("Failed tests:")
+    for test in failed_tests:
+        print(colored(test, "red"))
+
+
+if __name__ == '__main__':
+    main()

@@ 0,0 1,43 @@
+import serial
+import json
+import random
+
+phone = serial.Serial()
+
+
+class Test:
+    def __init__(self, payload, expected_result):
+        self.result = ""
+        self.message = build_message(payload)
+        self.expected_result = expected_result
+
+    def execute(self):
+        phone.write(self.message.encode())
+        header = phone.read(10).decode()
+        payload_length = int(header[1:])
+        result = phone.read(payload_length).decode()
+        # print("result full:" + result)
+        self.result = json.loads(result)
+        return self.result == self.expected_result, self.result["body"]
+
+
+def build_message(json_data):
+    json_dump = json.dumps(json_data)
+    return "#%09d%s" % (len(json_dump), json_dump)
+
+
+def prepare_message(endpoint, method, status, msg_body, result_body={}):
+    uuid = random.randint(1, 32768)
+    msg = {
+        "endpoint": endpoint,
+        "method": method,
+        "uuid": uuid,
+        "body": msg_body
+    }
+    msg_result = {
+        "endpoint": endpoint,
+        "status": status,
+        "uuid": str(uuid),
+        "body": result_body
+    }
+    return msg, msg_result

@@ 0,0 1,43 @@
+from defs import *
+from test import *
+
+
+class BackupTest:
+    def run(self):
+
+        msg, result_msg = prepare_message(endpoint["backup"], method["get"], status["OK"],
+                                          {"backupReady": True}, {"backupReady": False})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        msg, result_msg = prepare_message(endpoint["backup"], method["get"], status["OK"],
+                                          {}, {"backupRequest": False})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        msg, result_msg = prepare_message(endpoint["backup"], method["get"], status["OK"],
+                                          {"backupRequest": True}, {"backupRequest": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        msg, result_msg = prepare_message(endpoint["backup"], method["get"], status["OK"],
+                                          {"backupReady": True}, {"backupReady": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        msg, result_msg = prepare_message(endpoint["backup"], method["post"], status["OK"],
+                                          {"backupUpload": True}, {"backupUpload": False})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        return True

@@ 0,0 1,109 @@
+from defs import *
+from test import *
+
+
+class ContactTest:
+    def run(self):
+        # get contacts count
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        count = result['count']
+        if count == 0:
+            print("count = 0!")
+            return False
+
+        # get all contacts
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"count": count})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        records_length = len(result)
+        contact_to_update = result[0]
+        if records_length != count:
+            print("received record count mismatch!")
+            return False
+
+        # add contact
+        msg, result_msg = prepare_message(endpoint["contacts"], method["put"], status["OK"],
+                                          {"address": "6 Czeczota St.\n02600 Warsaw",
+                                           "altName": "Testowy",
+                                           "blocked": True,
+                                           "favourite": True,
+                                           "numbers": ["547623521"],
+                                           "priName": "Test"}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        # again check contacts count
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if result["count"] != count + 1:
+            print("record count unchanged after add!")
+            return False
+
+        # update contact
+        msg, result_msg = prepare_message(endpoint["contacts"], method["post"], status["OK"],
+                                          {"address": "6 Czeczota St.\n02600 Warsaw",
+                                           "altName": "Testowy2",
+                                           "blocked": True,
+                                           "favourite": True,
+                                           "numbers": ["547623521"],
+                                           "priName": "Test2",
+                                           "id": contact_to_update["id"]}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        # check updated contact
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"id": contact_to_update["id"]})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        contact = {"address": "6 Czeczota St.\n02600 Warsaw",
+                   "altName": "Testowy2",
+                   "blocked": True,
+                   "favourite": True,
+                   "numbers": ["547623521"],
+                   "priName": "Test2",
+                   "id": contact_to_update["id"]}
+        print(result)
+        print(contact)
+        if result != contact:
+            print("updated record mismatch!")
+            return False
+
+        # get contact to remove
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"count": count + 1})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        for contact in result:
+            if contact["priName"] == "Test" and contact["altName"] == "Testowy":
+                id = contact["id"]
+                break
+
+        # remove contact
+        msg, result_msg = prepare_message(endpoint["contacts"], method["del"], status["OK"],
+                                          {"id": id}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        # again check contacts count
+        msg, result_msg = prepare_message(endpoint["contacts"], method["get"], status["OK"],
+                                          {"count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if result["count"] != count:
+            print("record count unchanged after remove!")
+            return False
+
+        return True

@@ 0,0 1,17 @@
+from defs import *
+from test import *
+
+
+class DeviceInfoTest:
+    def run(self):
+
+        msg, result_msg = prepare_message(endpoint["deviceInfo"], method["get"], status["OK"], {})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+
+        if int(result["fsFreePercent"]) == 0 or int(result["fsFreePercent"]) > 100:
+            return False
+        if int(result["batteryState"]) != 1:
+            return False
+
+        return True

@@ 0,0 1,11 @@
+from defs import *
+from test import *
+
+
+class FactoryResetTest:
+    def run(self):
+        msg, result_msg = prepare_message(endpoint["factory"], method["post"], status["OK"], {"factoryRequest": True},
+                                          {'factoryRequest': True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        return ret

@@ 0,0 1,63 @@
+from defs import *
+from test import *
+
+
+class MessageTest:
+    def run(self):
+        # get messages count
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"], {"count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        count = result['count']
+        if count == 0:
+            print("count = 0!")
+            return False
+
+        # get all messages
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"], {"count": count})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        records_length = len(result)
+        if records_length != count:
+            print("received record count mismatch!")
+            return False
+
+        # remove message
+        sms_to_remove = result[0]
+        msg, result_msg = prepare_message(endpoint["messages"], method["del"], status["OK"],
+                                          {"id": sms_to_remove["id"]}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return ret
+
+        # check if the message was removed
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"], {"count": count})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        for message in result:
+            if message["id"] == sms_to_remove["id"]:
+                print("contact still exists!")
+                return False
+
+        # get messages binded to contactID
+        contact_id = 2
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"], {"contactID": contact_id})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        for message in result:
+            if message["contactID"] != contact_id:
+                print("wrong contactID!")
+                return False
+
+        thread_id = 1
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"threadID": thread_id, "count": 10})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        for message in result:
+            if message["threadID"] != thread_id:
+                print("wrong threadID!")
+                return False
+
+        return True

@@ 0,0 1,71 @@
+from defs import *
+from test import *
+
+
+class MessageTemplateTest:
+    def run(self):
+        # get templates count
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"template": True, "count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        count = result['count']
+        if count == 0:
+            print("count = 0!")
+            return False
+
+        # get all templates
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"template": True, "count": count})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        records_length = len(result)
+        if records_length != count:
+            print("received record count mismatch!")
+            return False
+
+        # add template
+        msg, result_msg = prepare_message(endpoint["messages"], method["put"], status["OK"],
+                                          {"template": True, "text": "test template"}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        # again check templates count
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"template": True, "count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if result["count"] != count + 1:
+            print("record count unchanged after add!")
+            return False
+
+        # get template to remove
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"template": True, "count": count + 1})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        for template in result:
+            if template["text"] == "test template":
+                id = template["id"]
+                break
+
+        # remove template
+        msg, result_msg = prepare_message(endpoint["messages"], method["del"], status["OK"],
+                                          {"template": True, "id": id}, None)
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if ret == False:
+            return False
+
+        # again check templates count
+        msg, result_msg = prepare_message(endpoint["messages"], method["get"], status["OK"],
+                                          {"template": True, "count": True})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if result["count"] != count:
+            print("record count unchanged after remove!")
+            return False
+
+        return True

@@ 0,0 1,27 @@
+from defs import *
+from test import *
+
+
+class UpdateTest:
+    def run(self):
+        # perform update endpoint test
+        msg, result_msg = prepare_message(endpoint["update"], method["get"], status["OK"], {})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        filename = ""
+        if len(result) > 0:
+            filename = result
+
+        if len(filename) > 1:
+            filename = filename[0]
+        msg, result_msg = prepare_message(endpoint["update"], method["post"], status["OK"], {"filename": filename})
+        test = Test(msg, result_msg)
+        ret, result = test.execute()
+        if filename != "":
+            if result["updateReady"] == True:
+                return True
+        else:
+            if result["updateReady"] != False:
+                return False
+
+        return True