diff options
Diffstat (limited to 'src/components/transport_manager/test/tcp_transport_adapter_test.cc')
| -rw-r--r-- | src/components/transport_manager/test/tcp_transport_adapter_test.cc | 641 |
1 files changed, 270 insertions, 371 deletions
diff --git a/src/components/transport_manager/test/tcp_transport_adapter_test.cc b/src/components/transport_manager/test/tcp_transport_adapter_test.cc index c91736b9f4..d849d94d48 100644 --- a/src/components/transport_manager/test/tcp_transport_adapter_test.cc +++ b/src/components/transport_manager/test/tcp_transport_adapter_test.cc @@ -30,430 +30,329 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include <sys/time.h> -#include <sys/socket.h> -#include <sys/types.h> -#include <netinet/in.h> - +#include "gtest/gtest.h" #include "transport_manager/tcp/tcp_transport_adapter.h" -#include "transport_manager/transport_adapter/transport_adapter_listener.h" -#include "include/mock_transport_adapter_listener.h" +#include "transport_manager/transport_adapter/connection.h" +#include "config_profile/profile.h" +#include "resumption/last_state.h" #include "protocol/raw_message.h" -#include "utils/logger.h" - -namespace transport_manager { -namespace transport_adapter { - -using namespace ::protocol_handler; - -TEST(TcpAdapterBasicTest, GetDeviceType_Return_sdltcp) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - // Assert - EXPECT_EQ(TCP, transport_adapter->GetDeviceType()); - - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, isServerOriginatedConnectSupported_Return_True) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_TRUE(transport_adapter->IsServerOriginatedConnectSupported()); - - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, isClientOriginatedConnectSupported_Return_True) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_TRUE(transport_adapter->IsClientOriginatedConnectSupported()); - - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, isSearchDevicesSupported_Return_True) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_TRUE(transport_adapter->IsSearchDevicesSupported()); +#include "include/transport_adapter_listener_mock.h" +#include "include/device_mock.h" +#include "include/connection_mock.h" - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_EQ(TransportAdapter::BAD_STATE, transport_adapter->SearchDevices()); - - delete transport_adapter; -} - -//TODO(KKolodiy)APPLINK-11045 -TEST(TcpAdapterBasicTest, DISABLED_NotInitialised_Return_OK_InConnect) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_EQ(TransportAdapter::OK, - transport_adapter->Connect(DeviceUID("xxx"), 2)); - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE_inDisconnect) { +namespace test { +namespace components { +namespace transport_manager_test { - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); - - //assert - EXPECT_EQ(TransportAdapter::BAD_STATE, - transport_adapter->Disconnect(DeviceUID("xxx"), 2)); - delete transport_adapter; -} - -TEST(TcpAdapterBasicTest, NotInitialised_Return_BAD_STATE_in_DisconnectDevice) { - - //arrange - TransportAdapter* transport_adapter = new TcpTransportAdapter(12345); +using ::testing::Return; +using ::testing::_; - //assert - EXPECT_EQ(TransportAdapter::BAD_STATE, - transport_adapter->DisconnectDevice(DeviceUID("xxx"))); - delete transport_adapter; -} +using namespace ::protocol_handler; +using namespace ::transport_manager; +using namespace transport_manager::transport_adapter; -class ClientTcpSocket { +class TestTCPTransportAdapter : public TcpTransportAdapter { public: - bool Connect(uint16_t server_port) { - - socket_ = socket(AF_INET, SOCK_STREAM, 0); - std::cout << "socket is " << socket_ << "\n\n"; - if (socket_ < 0) - return false; - - struct sockaddr_in addr; - memset((char*) &addr, 0, sizeof(addr)); - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); - addr.sin_port = htons(server_port); - - if (::connect(socket_, (struct sockaddr*) &addr, sizeof(addr)) < 0) - return false; - else - return true; + TestTCPTransportAdapter(uint16_t port) : TcpTransportAdapter(port) { + ::profile::Profile::instance()->config_file_name( + "smartDeviceLink_test.ini"); } + MOCK_CONST_METHOD2(FindEstablishedConnection, + ConnectionSPtr(const DeviceUID& device_handle, + const ApplicationHandle& app_handle)); + + MOCK_CONST_METHOD1(FindDevice, DeviceSptr(const DeviceUID& device_handle)); + MOCK_METHOD2(Connect, + TransportAdapter::Error(const DeviceUID& device_handle, + const ApplicationHandle& app_handle)); + void CallStore() { Store(); } + bool CallRestore() { return Restore(); } +}; - bool Send(const std::string& str) { - size_t size = str.size(); - ssize_t written = write(socket_, str.c_str(), size); - if (written != -1) { - size_t count = static_cast<size_t>(written); - return count == size; - } else { - return false; - } +class TcpAdapterTest : public ::testing::Test { + protected: + static void SetUpTestCase() { + ::profile::Profile::instance()->config_file_name( + "smartDeviceLink_test.ini"); } - - std::string receive(size_t size) { - char* buf = new char[size]; - ssize_t read = recv(socket_, buf, size, MSG_WAITALL); - if (read != -1) { - return std::string(buf, buf + read); - } else { - return std::string(); - } + virtual void SetUp() { + resumption::LastState::instance()->dictionary = Json::Value(); } - void Disconnect() { - close(socket_); - } + virtual void TearDown() { resumption::LastState::destroy(); } - private: - uint16_t port_; - int socket_; + const uint32_t port = 12345; + const std::string string_port = "12345"; }; -using ::testing::_; -using ::testing::Invoke; - -void Disconnect(const TransportAdapter* transport_adapter, - const DeviceUID device_handle, - const ApplicationHandle app_handle) { - EXPECT_EQ( - TransportAdapter::OK, - const_cast<TransportAdapter*>(transport_adapter)->Disconnect( - device_handle, app_handle)); - - std::cout << "adapter is disconnected" << "\n"; +TEST_F(TcpAdapterTest, DISABLED_StoreDataWithOneDeviceAndOneApplication) { + // Prepare + TestTCPTransportAdapter transport_adapter(port); + std::string uniq_id = "unique_device_name"; + utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id); + transport_adapter.AddDevice(mockdev); + + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, devList.size()); + EXPECT_EQ(uniq_id, devList[0]); + + const int app_handle = 1; + std::vector<int> intList = {app_handle}; + EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList)); + + ConnectionSPtr mock_connection = new ConnectionMock(); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, app_handle)) + .WillOnce(Return(mock_connection)); + + EXPECT_CALL(*mockdev, GetApplicationPort(app_handle)).WillOnce(Return(port)); + + transport_adapter.CallStore(); + + // Check that value is saved + Json::Value& tcp_dict = resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]; + + ASSERT_TRUE(tcp_dict.isObject()); + ASSERT_FALSE(tcp_dict["devices"].isNull()); + ASSERT_FALSE(tcp_dict["devices"][0]["applications"].isNull()); + ASSERT_FALSE(tcp_dict["devices"][0]["address"].isNull()); + EXPECT_EQ(1u, tcp_dict["devices"][0]["applications"].size()); + EXPECT_EQ(string_port, + tcp_dict["devices"][0]["applications"][0]["port"].asString()); + EXPECT_EQ(uniq_id, tcp_dict["devices"][0]["name"].asString()); } -class TcpAdapterTest : public ::testing::Test { - public: - TcpAdapterTest() - : port_(ChoosePort()), - transport_adapter_(new TcpTransportAdapter(port_)), - suspended_(false), - finished_(false) { - pthread_mutex_init(&suspend_mutex_, 0); - pthread_cond_init(&suspend_cond_, 0); +TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevicesAndOneApplication) { + // Prepare + TestTCPTransportAdapter transport_adapter(port); + const uint32_t count_dev = 10; + utils::SharedPtr<TCPDeviceMock> mockdev[count_dev]; + std::string uniq_id[count_dev]; + for (uint32_t i = 0; i < count_dev; i++) { + char numb[12]; + std::snprintf(numb, 12, "%d", i); + uniq_id[i] = "unique_device_name" + std::string(numb); + mockdev[i] = new TCPDeviceMock(port, uniq_id[i]); + EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false)); + transport_adapter.AddDevice(mockdev[i]); } - uint16_t ChoosePort() { - return getpid() % 1000 + 3000; - } + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(count_dev, devList.size()); + EXPECT_EQ(uniq_id[0], devList[0]); - virtual void SetUp() { - const TransportAdapter::Error error = transport_adapter_->Init(); - ASSERT_EQ(TransportAdapter::OK, error); - transport_adapter_->AddListener(&mock_dal_); - time_t end_time = time(NULL) + 5; - while (!transport_adapter_->IsInitialised() && time(NULL) < end_time) - sleep(0); - ASSERT_TRUE(transport_adapter_->IsInitialised()); - } + const int app_handle = 1; + std::vector<int> intList = {app_handle}; - virtual void TearDown() { - transport_adapter_->StopClientListening(); - } + ConnectionSPtr mock_connection = new ConnectionMock(); + for (uint32_t i = 0; i < count_dev; i++) { + EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i])) + .WillOnce(Return(mockdev[i])); + EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList)); - virtual ~TcpAdapterTest() { - pthread_mutex_lock(&suspend_mutex_); - if (!finished_) - suspended_ = true; - struct timeval now; - gettimeofday(&now, NULL); - timespec abs_time; - abs_time.tv_sec = now.tv_sec + 1; - abs_time.tv_nsec = now.tv_usec * 1000; - while (suspended_) { - if (ETIMEDOUT - == pthread_cond_timedwait(&suspend_cond_, &suspend_mutex_, - &abs_time)) { - break; - } - } - pthread_mutex_unlock(&suspend_mutex_); - delete transport_adapter_; + EXPECT_CALL(transport_adapter, + FindEstablishedConnection(uniq_id[i], app_handle)) + .WillOnce(Return(mock_connection)); - pthread_mutex_destroy(&suspend_mutex_); - pthread_cond_destroy(&suspend_cond_); + EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle)) + .WillOnce(Return(port)); } - - void wakeUp() { - pthread_mutex_lock(&suspend_mutex_); - finished_ = true; - suspended_ = false; - pthread_cond_signal(&suspend_cond_); - pthread_mutex_unlock(&suspend_mutex_); + transport_adapter.CallStore(); + + // Check that values are saved + Json::Value& tcp_dict = resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]; + ASSERT_TRUE(tcp_dict.isObject()); + ASSERT_FALSE(tcp_dict["devices"].isNull()); + for (uint32_t i = 0; i < count_dev; i++) { + ASSERT_FALSE(tcp_dict["devices"][i]["applications"].isNull()); + ASSERT_FALSE(tcp_dict["devices"][i]["address"].isNull()); + EXPECT_EQ(1u, tcp_dict["devices"][i]["applications"].size()); + EXPECT_EQ(string_port, + tcp_dict["devices"][i]["applications"][0]["port"].asString()); + EXPECT_EQ(uniq_id[i], tcp_dict["devices"][i]["name"].asString()); } +} - uint16_t port() const { - return port_; +TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevicesAndSeveralApplications) { + // Prepare + TestTCPTransportAdapter transport_adapter(port); + const uint32_t count_dev = 10; + + utils::SharedPtr<TCPDeviceMock> mockdev[count_dev]; + std::string uniq_id[count_dev]; + for (uint32_t i = 0; i < count_dev; i++) { + char numb[12]; + std::snprintf(numb, 12, "%d", i); + uniq_id[i] = "unique_device_name" + std::string(numb); + mockdev[i] = new TCPDeviceMock(port, uniq_id[i]); + EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false)); + transport_adapter.AddDevice(mockdev[i]); } - const uint16_t port_; - TransportAdapter* transport_adapter_; - ::test::components::transport_manager::MockTransportAdapterListener mock_dal_; - ClientTcpSocket client_; - - pthread_cond_t suspend_cond_; - pthread_mutex_t suspend_mutex_; - bool suspended_; - bool finished_; - -}; - -class TcpAdapterTestWithListenerAutoStart : public TcpAdapterTest { - virtual void SetUp() { - TcpAdapterTest::SetUp(); - transport_adapter_->StartClientListening(); + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(count_dev, devList.size()); + EXPECT_EQ(uniq_id[0], devList[0]); + + const uint32_t connection_count = 3; + const int app_handle[connection_count] = {1, 2, 3}; + std::vector<int> intList = {app_handle[0], app_handle[1], app_handle[2]}; + const std::string ports[connection_count] = {"11111", "67890", "98765"}; + const int int_port[connection_count] = {11111, 67890, 98765}; + ConnectionSPtr mock_connection = new ConnectionMock(); + for (uint32_t i = 0; i < count_dev; i++) { + EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i])) + .WillOnce(Return(mockdev[i])); + EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList)); + + for (uint32_t j = 0; j < connection_count; j++) { + EXPECT_CALL(transport_adapter, + FindEstablishedConnection(uniq_id[i], app_handle[j])) + .WillOnce(Return(mock_connection)); + EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle[j])) + .WillOnce(Return(int_port[j])); + } } - -}; - -MATCHER_P(ContainsMessage, str, ""){ return strlen(str) == arg->data_size() && 0 == memcmp(str, arg->data(), arg->data_size());} - -// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Connect_Return_True) { - { - ::testing::InSequence seq; - EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_)); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); + transport_adapter.CallStore(); + + // Check that value is saved + Json::Value& tcp_dict = resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]; + + ASSERT_TRUE(tcp_dict.isObject()); + ASSERT_FALSE(tcp_dict["devices"].isNull()); + for (uint32_t i = 0; i < count_dev; i++) { + ASSERT_FALSE(tcp_dict["devices"][i]["applications"].isNull()); + ASSERT_FALSE(tcp_dict["devices"][i]["address"].isNull()); + for (uint32_t j = 0; j < intList.size(); j++) { + EXPECT_EQ(ports[j], + tcp_dict["devices"][i]["applications"][j]["port"].asString()); + EXPECT_EQ(uniq_id[i], tcp_dict["devices"][i]["name"].asString()); + } } - EXPECT_TRUE(client_.Connect(port())); } -// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SecondConnect_Return_True) { - { - ::testing::InSequence seq; - EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_)); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); - } - EXPECT_TRUE(client_.Connect(port())); +TEST_F(TcpAdapterTest, StoreData_ConnectionNotExist_DataNotStored) { + // Prepare + TestTCPTransportAdapter transport_adapter(port); + std::string uniq_id = "unique_device_name"; + utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id); + transport_adapter.AddDevice(mockdev); + + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, devList.size()); + EXPECT_EQ(uniq_id, devList[0]); + std::vector<int> intList = {}; + EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList)); + + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, _)) + .Times(0); + EXPECT_CALL(*mockdev, GetApplicationPort(_)).Times(0); + transport_adapter.CallStore(); + + // Check that value is not saved + Json::Value& tcp_dict = + resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]["devices"]; + ASSERT_TRUE(tcp_dict.isNull()); } -// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Receive_Return_True) { - { - ::testing::InSequence seq; - - EXPECT_CALL(mock_dal_, OnDeviceListUpdated(_)); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)); - - EXPECT_CALL( - mock_dal_, - OnDataReceiveDone(transport_adapter_, _, _, ContainsMessage("abcd"))). - WillOnce(InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); - } - EXPECT_TRUE(client_.Connect(port())); - EXPECT_TRUE(client_.Send("abcd")); +TEST_F(TcpAdapterTest, RestoreData_DataNotStored) { + Json::Value& tcp_adapter_dictionary = + resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]; + tcp_adapter_dictionary = Json::Value(); + TestTCPTransportAdapter transport_adapter(port); + EXPECT_CALL(transport_adapter, Connect(_, _)).Times(0); + EXPECT_TRUE(transport_adapter.CallRestore()); } -struct SendHelper { - explicit SendHelper(TransportAdapter::Error expected_error) - : expected_error_(expected_error), - message_( - new RawMessage( - 1, - 1, - const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>("efgh")), - 4)) { - } - void sendMessage(const TransportAdapter* transport_adapter, - const DeviceUID device_handle, - const ApplicationHandle app_handle) { - EXPECT_EQ( - expected_error_, - const_cast<TransportAdapter*>(transport_adapter)->SendData( - device_handle, app_handle, message_)); - } - TransportAdapter::Error expected_error_; - RawMessagePtr message_; -}; +TEST_F(TcpAdapterTest, DISABLED_StoreDataWithOneDevice_RestoreData) { + TestTCPTransportAdapter transport_adapter(port); + std::string uniq_id = "unique_device_name"; + utils::SharedPtr<TCPDeviceMock> mockdev = new TCPDeviceMock(port, uniq_id); + transport_adapter.AddDevice(mockdev); -// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_Send_Message) { - SendHelper helper(TransportAdapter::OK); - { - ::testing::InSequence seq; - - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - Invoke(&helper, &SendHelper::sendMessage)); - EXPECT_CALL(mock_dal_, - OnDataSendDone(transport_adapter_, _, _, helper.message_)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); - } - - EXPECT_TRUE(client_.Connect(port())); - EXPECT_EQ("efgh", client_.receive(4)); -} + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, devList.size()); + EXPECT_EQ(uniq_id, devList[0]); -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_DisconnectFromClient) { - { - ::testing::InSequence seq; + const int app_handle = 1; + std::vector<int> intList = {app_handle}; + EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(intList)); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)); - EXPECT_CALL(mock_dal_, OnUnexpectedDisconnect(transport_adapter_, _, _, _)); - EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); - } - EXPECT_TRUE(client_.Connect(port())); - client_.Disconnect(); -} + ConnectionSPtr mock_connection = new ConnectionMock(); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + EXPECT_CALL(transport_adapter, FindEstablishedConnection(uniq_id, app_handle)) + .WillOnce(Return(mock_connection)); -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_DisconnectFromServer) { - { - ::testing::InSequence seq; + EXPECT_CALL(*mockdev, GetApplicationPort(app_handle)).WillOnce(Return(port)); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - Invoke(Disconnect)); - EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); - } - EXPECT_TRUE(client_.Connect(port())); + transport_adapter.CallStore(); -} + EXPECT_CALL(transport_adapter, Connect(uniq_id, app_handle)) + .WillOnce(Return(TransportAdapter::OK)); -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SendToDisconnected) { - SendHelper* helper = new SendHelper(TransportAdapter::BAD_PARAM); - { - ::testing::InSequence seq; + EXPECT_TRUE(transport_adapter.CallRestore()); - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - Invoke(Disconnect)); - EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce( - ::testing::DoAll(Invoke(helper, &SendHelper::sendMessage), - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp))); - } - EXPECT_TRUE(client_.Connect(port())); + devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, devList.size()); + EXPECT_EQ(uniq_id, devList[0]); } -TEST_F(TcpAdapterTestWithListenerAutoStart, DISABLED_SendFailed) { -// static unsigned char zzz[2000000]; //message will send without fail because socket buffer can contain it - //this test works correctly starting with number 2539009 - static unsigned char zzz[2600000]; - SendHelper* helper = new SendHelper(TransportAdapter::OK); - helper->message_ = new RawMessage(1, 1, zzz, sizeof(zzz)); - { - ::testing::InSequence seq; - EXPECT_CALL(mock_dal_, OnConnectDone(transport_adapter_, _, _)).WillOnce( - Invoke(helper, &SendHelper::sendMessage)); - EXPECT_CALL( - mock_dal_, - OnDataSendFailed(transport_adapter_, _, _, helper->message_, _)); - EXPECT_CALL(mock_dal_, OnDisconnectDone(transport_adapter_, _, _)).WillOnce( - InvokeWithoutArgs(this, &TcpAdapterTest::wakeUp)); +TEST_F(TcpAdapterTest, DISABLED_StoreDataWithSeveralDevices_RestoreData) { + TestTCPTransportAdapter transport_adapter(port); + const uint32_t count_dev = 10; + + utils::SharedPtr<TCPDeviceMock> mockdev[count_dev]; + std::string uniq_id[count_dev]; + for (uint32_t i = 0; i < count_dev; i++) { + char numb[12]; + std::snprintf(numb, 12, "%d", i); + uniq_id[i] = "unique_device_name" + std::string(numb); + mockdev[i] = new TCPDeviceMock(port, uniq_id[i]); + EXPECT_CALL(*(mockdev[i]), IsSameAs(_)).WillRepeatedly(Return(false)); + transport_adapter.AddDevice(mockdev[i]); } - EXPECT_TRUE(client_.Connect(port())); - client_.receive(2); - client_.Disconnect(); -} -// TODO{ALeshin} APPLINK-11090 - transport_adapter_->IsInitialised() doesn't return true as expected -TEST_F(TcpAdapterTest, DISABLED_StartStop) { + std::vector<std::string> devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(count_dev, devList.size()); + EXPECT_EQ(uniq_id[0], devList[0]); - //assert - EXPECT_EQ(TransportAdapter::BAD_STATE, - transport_adapter_->StopClientListening()); - EXPECT_TRUE(client_.Connect(port())); - EXPECT_EQ(TransportAdapter::OK, transport_adapter_->StartClientListening()); - EXPECT_TRUE(client_.Connect(port())); + const int app_handle = 1; + std::vector<int> intList = {app_handle}; - //act - client_.Disconnect(); + ConnectionSPtr mock_connection = new ConnectionMock(); + for (uint32_t i = 0; i < count_dev; i++) { + EXPECT_CALL(transport_adapter, FindDevice(uniq_id[i])) + .WillOnce(Return(mockdev[i])); + EXPECT_CALL(*(mockdev[i]), GetApplicationList()).WillOnce(Return(intList)); - //assert - EXPECT_EQ(TransportAdapter::BAD_STATE, - transport_adapter_->StartClientListening()); - EXPECT_TRUE(client_.Connect(port())); + EXPECT_CALL(transport_adapter, + FindEstablishedConnection(uniq_id[i], app_handle)) + .WillOnce(Return(mock_connection)); - //act - client_.Disconnect(); + EXPECT_CALL(*(mockdev[i]), GetApplicationPort(app_handle)) + .WillOnce(Return(port)); + } + transport_adapter.CallStore(); - //assert - EXPECT_EQ(TransportAdapter::OK, transport_adapter_->StopClientListening()); - EXPECT_TRUE(client_.Connect(port())); + for (uint32_t i = 0; i < count_dev; i++) { + EXPECT_CALL(transport_adapter, Connect(uniq_id[i], app_handle)) + .WillOnce(Return(TransportAdapter::OK)); + } - //act - wakeUp(); -} + EXPECT_TRUE(transport_adapter.CallRestore()); -} // namespace -} // namespace + devList = transport_adapter.GetDeviceList(); + ASSERT_EQ(count_dev, devList.size()); + for (uint32_t i = 0; i < count_dev; i++) { + EXPECT_EQ(uniq_id[i], devList[i]); + } +} +} // namespace transport_manager_test +} // namespace components +} // namespace test |