device-agent/utest/test_connection.cpp

   1 #include <iostream>
   2 #include <gmock/gmock.h>
   3 #include <gtest/gtest.h>
   4 #include <functional>
   5 #include <thread>
   6 #include "reportcomposer.h"
   7 #include "connection.h"
   8 #include "eventlistener.h"
   9 #include "restservicemock.h"
  10
  11 using namespace NetworkManager;
  12 using ::testing::_;
  13 using ::testing::Eq;
  14 using ::testing::Return;
  15 using ::testing::Throw;
  16 using ::testing::DoAll;
  17 using ::testing::Invoke;
  18 using ::testing::WithArgs;
  19
  20 #define TAG "Tests"
  21
  22 namespace
  23 {
  24 const std::chrono::milliseconds TEST_KEEP_ALIVE(10);
  25 const std::string TEST_SERVER_ADDRESS{"test-server"};
  26 const std::string TEST_DEVICE_ID{"device-id"};
  27
  28 const std::string TEST_EVENT_TYPE{"report"};
  29 const std::string TEST_EVENT_DATA1{"{sdfssdfsdfffsdfsdfsd}"};
  30 const std::string TEST_EVENT_DATA2{"{--------------------}"};
  31 const std::string TEST_UPDATES{ R"-([
  32     {"type":"policy","uri":"policy-uri"},
  33     {"type":"action","uri":"action-uri"},
  34     {"type":"unused","uri":"unused-uri"}
  35 ])-"};
  36 const std::string TEST_POLICY_URI{"policy-uri"};
  37 const std::string TEST_ACTION_URI{"action-uri"};
  38
  39 }
  40
  41 class TestConnection: public ::testing::Test
  42 {
  43 public:
  44     void SetUp() override
  45     {
  46         Settings& settings = Settings::instance();
  47         settings.setKeepAliveTimeout(TEST_KEEP_ALIVE);
  48         settings.setServerAddress(TEST_SERVER_ADDRESS);
  49         settings.setDeviceId(TEST_DEVICE_ID);
  50     }
  51
  52     void TearDown() override
  53     {
  54
  55     }
  56 };
  57
  58 class EventListenerMock: public EventListener
  59 {
  60 public:
  61     EventListenerMock(Connection& conn, const std::string& type): EventListener(conn, type)
  62     {
  63     }
  64
  65     MOCK_METHOD1(accept, void(Event& event));
  66 };
  67
  68 namespace NetworkManager
  69 {
  70
  71 bool operator==(const SessionInfo& si1, const SessionInfo& si2)
  72 {
  73     return si1.duid == si2.duid && si1.authToken == si2.authToken;
  74 }
  75
  76 }
  77
  78 TEST_F(TestConnection, test_signal)
  79 {
  80     Settings& settings = Settings::instance();
  81     RestServiceMock rest;
  82     settings.setDeviceId("");
  83     Connection conn(settings, &rest);
  84     ReportComposer rc;
  85     rc.addEvent(std::make_pair(TEST_EVENT_TYPE, TEST_EVENT_DATA1));
  86     rc.addEvent(std::make_pair(TEST_EVENT_TYPE, TEST_EVENT_DATA2));
  87     SessionInfo checkSessState{"", ""};
  88
  89     EXPECT_CALL(rest, registerDevice(Eq(checkSessState)))
  90             .WillOnce(Throw(std::runtime_error("")))
  91             .WillOnce(Return(TEST_DEVICE_ID));
  92     EXPECT_CALL(rest, getUpdates(_))
  93             .WillRepeatedly(Return(""));
  94     EXPECT_CALL(rest, sendReport(_, ::testing::Matcher<const Json::Value&>(rc.get())))
  95             .Times(1);
  96
  97     std::thread t(&Connection::loop, &conn);
  98     conn.addReportEvent(TEST_EVENT_TYPE, TEST_EVENT_DATA1);
  99     conn.addReportEvent(TEST_EVENT_TYPE, TEST_EVENT_DATA2);
 100
 101     std::this_thread::sleep_for(std::chrono::milliseconds(70));
 102
 103     conn.stop();
 104
 105     t.join();
 106 }
 107
 108 void fakeInvoker(Event& e)
 109 {
 110     e.getContent();
 111 }
 112
 113 TEST_F(TestConnection, test_Listeners)
 114 {
 115     try {
 116         Settings& settings = Settings::instance();
 117         RestServiceMock rest;
 118         Connection conn(settings, &rest);
 119
 120         EventListenerMock el1{conn, "policy"};
 121         EventListenerMock el2{conn, "policy"};
 122         EventListenerMock el3{conn, "action"};
 123
 124         EXPECT_CALL(rest, getUpdates(_))
 125                 .WillRepeatedly(Return(TEST_UPDATES));
 126         EXPECT_CALL(rest, doGet(_, TEST_POLICY_URI))
 127                 .WillOnce(Return(TEST_EVENT_DATA1));
 128         EXPECT_CALL(rest, doGet(_, TEST_ACTION_URI))
 129                 .WillOnce(Return(TEST_EVENT_DATA2));
 130         EXPECT_CALL(el1, accept(_))
 131                 .WillOnce(WithArgs<0>(Invoke(fakeInvoker)));
 132         EXPECT_CALL(el2, accept(_))
 133                 .WillOnce(WithArgs<0>(Invoke(fakeInvoker)));
 134         EXPECT_CALL(el3, accept(_))
 135                 .WillOnce(WithArgs<0>(Invoke(fakeInvoker)));
 136
 137         std::thread t(&Connection::loop, &conn);
 138
 139         std::this_thread::sleep_for(std::chrono::milliseconds(15));
 140
 141         conn.stop();
 142
 143         t.join();
 144     } catch (std::exception& e) {
 145         FAIL() << e.what();
 146     }
 147 }