diff options
Diffstat (limited to 'src/components/connection_handler/test/connection_handler_impl_test.cc')
| -rw-r--r-- | src/components/connection_handler/test/connection_handler_impl_test.cc | 663 |
1 files changed, 392 insertions, 271 deletions
diff --git a/src/components/connection_handler/test/connection_handler_impl_test.cc b/src/components/connection_handler/test/connection_handler_impl_test.cc index ec4e12ffe2..d0b9ce4ae4 100644 --- a/src/components/connection_handler/test/connection_handler_impl_test.cc +++ b/src/components/connection_handler/test/connection_handler_impl_test.cc @@ -37,8 +37,10 @@ #include "connection_handler/connection_handler_impl.h" #include "protocol/common.h" // TODO(EZamakhov): move security test +#ifdef ENABLE_SECURITY #include "security_manager/mock_security_manager.h" #include "security_manager/mock_ssl_context.h" +#endif // ENABLE_SECURITY #include "protocol_handler/mock_protocol_handler.h" #include "connection_handler/mock_connection_handler_observer.h" #include "connection_handler/mock_connection_handler_settings.h" @@ -61,6 +63,7 @@ using ::testing::Mock; using ::testing::Return; using ::testing::ReturnRefOfCopy; using ::testing::SaveArg; +using ::testing::SaveArgPointee; // custom action to call a member function with 3 arguments ACTION_P5(InvokeMemberFuncWithArg3, ptr, memberFunc, a, b, c) { @@ -118,42 +121,51 @@ class ConnectionHandlerTest : public ::testing::Test { void AddTestSession() { protocol_handler_test::MockProtocolHandler temp_protocol_handler; connection_handler_->set_protocol_handler(&temp_protocol_handler); - EXPECT_CALL(temp_protocol_handler, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce( - DoAll(SaveArg<2>(&start_session_id_), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(temp_protocol_handler, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&out_context_)); connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); connection_handler_->set_protocol_handler(NULL); - EXPECT_NE(0u, start_session_id_); - EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_); - connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_); - CheckSessionExists(uid_, start_session_id_); + EXPECT_NE(0u, out_context_.new_session_id_); + EXPECT_EQ(SessionHash(uid_, out_context_.new_session_id_), + out_context_.hash_id_); + connection_key_ = + connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); + CheckSessionExists(uid_, out_context_.new_session_id_); } uint32_t SessionHash(const uint32_t connection, const uint32_t session) { return connection_handler_->KeyFromPair(connection, session); } void AddTestService(ServiceType service_type) { - EXPECT_NE(0u, start_session_id_); - EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_); - connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_); - CheckSessionExists(uid_, start_session_id_); + EXPECT_NE(0u, out_context_.new_session_id_); + EXPECT_EQ(SessionHash(uid_, out_context_.new_session_id_), + out_context_.hash_id_); + connection_key_ = + connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); + CheckSessionExists(uid_, out_context_.new_session_id_); + + // Set protocol version to 3 if audio or video service should be tested + if (service_type == ServiceType::kAudio || + service_type == ServiceType::kMobileNav) { + ChangeProtocol(uid_, + out_context_.new_session_id_, + protocol_handler::PROTOCOL_VERSION_3); + } - uint32_t session_id = 0; + SessionContext context; protocol_handler_test::MockProtocolHandler temp_protocol_handler; connection_handler_->set_protocol_handler(&temp_protocol_handler); - EXPECT_CALL(temp_protocol_handler, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id)); + EXPECT_CALL(temp_protocol_handler, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&context)); connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, service_type, PROTECTION_OFF, static_cast<BsonObject*>(0)); connection_handler_->set_protocol_handler(NULL); - EXPECT_EQ(session_id, start_session_id_); + EXPECT_EQ(context.new_session_id_, out_context_.new_session_id_); } // Check Service Wrapper @@ -165,7 +177,7 @@ class ConnectionHandlerTest : public ::testing::Test { ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); - const Connection& connection = *connection_list.begin()->second; + const Connection& connection = *conn_it->second; const SessionMap& session_map = connection.session_map(); SessionMap::const_iterator sess_it = session_map.find(session_id); @@ -196,7 +208,7 @@ class ConnectionHandlerTest : public ::testing::Test { ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); - const Connection& connection = *connection_list.begin()->second; + const Connection& connection = *conn_it->second; const SessionMap& session_map = connection.session_map(); ASSERT_FALSE(session_map.empty()); @@ -213,7 +225,9 @@ class ConnectionHandlerTest : public ::testing::Test { ASSERT_EQ(serv_it, service_list.end()); } } - // Check Service Wrapper + +// Check Service Wrapper +#ifdef ENABLE_SECURITY void CheckService(const int connectionId, const int session_id, const ::protocol_handler::ServiceType serviceId, @@ -225,16 +239,14 @@ class ConnectionHandlerTest : public ::testing::Test { ASSERT_FALSE(connection_list.empty()); ConnectionList::const_iterator conn_it = connection_list.find(connectionId); ASSERT_NE(conn_it, connection_list.end()); - const Connection& connection = *connection_list.begin()->second; + const Connection& connection = *conn_it->second; const SessionMap& session_map = connection.session_map(); ASSERT_FALSE(session_map.empty()); SessionMap::const_iterator sess_it = session_map.find(session_id); ASSERT_NE(sess_it, session_map.end()); const Session& session = sess_it->second; -#ifdef ENABLE_SECURITY ASSERT_EQ(session.ssl_context, ssl_context); -#endif // ENABLE_SECURITY const ServiceList& service_list = session.service_list; ASSERT_FALSE(service_list.empty()); ServiceList::const_iterator serv_it = @@ -243,14 +255,39 @@ class ConnectionHandlerTest : public ::testing::Test { const Service& service = *serv_it; EXPECT_EQ(PROTECTION_OFF, service.is_protected_); -#ifdef ENABLE_SECURITY if (is_protected) { // Emulate success protection - check enable service flag const uint32_t connection_key_ = connection_handler_->KeyFromPair(connectionId, session_id); connection_handler_->SetProtectionFlag(connection_key_, serviceId); } + } #endif // ENABLE_SECURITY + + void CheckService(const int connectionId, + const int session_id, + const ::protocol_handler::ServiceType serviceId) { + // Check all tree to find Service and check own protected value + const ConnectionList& connection_list = + connection_handler_->getConnectionList(); + ASSERT_FALSE(connection_list.empty()); + ConnectionList::const_iterator conn_it = connection_list.find(connectionId); + ASSERT_NE(conn_it, connection_list.end()); + const Connection& connection = *conn_it->second; + + const SessionMap& session_map = connection.session_map(); + ASSERT_FALSE(session_map.empty()); + SessionMap::const_iterator sess_it = session_map.find(session_id); + ASSERT_NE(sess_it, session_map.end()); + const Session& session = sess_it->second; + const ServiceList& service_list = session.service_list; + ASSERT_FALSE(service_list.empty()); + ServiceList::const_iterator serv_it = + std::find(service_list.begin(), service_list.end(), serviceId); + ASSERT_NE(serv_it, service_list.end()); + + const Service& service = *serv_it; + EXPECT_EQ(PROTECTION_OFF, service.is_protected_); } void ChangeProtocol(const int connectionId, @@ -279,8 +316,7 @@ class ConnectionHandlerTest : public ::testing::Test { transport_manager::DeviceHandle device_handle_; transport_manager::ConnectionUID uid_; uint32_t connection_key_; - uint32_t start_session_id_; - uint32_t out_hash_id_; + protocol_handler::SessionContext out_context_; std::string connection_type_; std::string device_name_; @@ -295,17 +331,17 @@ TEST_F(ConnectionHandlerTest, StartSession_NoConnection) { // Null sessionId for start new session const uint8_t sessionID = 0; // Start new session with RPC service - uint32_t result_fail = 0; + protocol_handler::SessionContext context; + connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&result_fail), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&context)); connection_handler_->OnSessionStartedCallback( uid_, sessionID, kRpc, PROTECTION_ON, static_cast<BsonObject*>(NULL)); // Unknown connection error is '0' - EXPECT_EQ(0u, result_fail); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + EXPECT_EQ(0u, context.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, context.hash_id_); ASSERT_TRUE(connection_handler_->getConnectionList().empty()); } @@ -340,11 +376,12 @@ TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) { AddTestSession(); uint32_t app_id = 0; - const uint32_t testid = SessionHash(uid_, start_session_id_); + const uint32_t testid = SessionHash(uid_, out_context_.new_session_id_); + connection_handler::DeviceHandle null_handle = 0; EXPECT_EQ(0, connection_handler_->GetDataOnSessionKey( - connection_key_, &app_id, NULL, NULL)); + connection_key_, &app_id, NULL, &null_handle)); EXPECT_EQ(testid, app_id); } @@ -352,9 +389,10 @@ TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey_SessionNotStarted) { AddTestDeviceConnection(); uint32_t app_id = 0; + connection_handler::DeviceHandle null_handle = 0; EXPECT_EQ(-1, connection_handler_->GetDataOnSessionKey( - connection_key_, &app_id, NULL, NULL)); + connection_key_, &app_id, NULL, &null_handle)); } TEST_F(ConnectionHandlerTest, GetDeviceID) { @@ -405,7 +443,8 @@ TEST_F(ConnectionHandlerTest, GetApplicationsOnDevice) { 0, connection_handler_->GetDataOnDeviceID(handle, NULL, &applications_list)); - uint32_t test_id = connection_handler_->KeyFromPair(uid_, start_session_id_); + uint32_t test_id = + connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); EXPECT_EQ(1u, applications_list.size()); EXPECT_EQ(test_id, applications_list.front()); @@ -417,7 +456,7 @@ TEST_F(ConnectionHandlerTest, GetDefaultProtocolVersion) { uint8_t protocol_version = 0; EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( - uid_, start_session_id_, protocol_version)); + uid_, out_context_.new_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version); } @@ -425,11 +464,11 @@ TEST_F(ConnectionHandlerTest, GetDefaultProtocolVersion) { TEST_F(ConnectionHandlerTest, GetProtocolVersion) { AddTestDeviceConnection(); AddTestSession(); - ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3); + ChangeProtocol(uid_, out_context_.new_session_id_, PROTOCOL_VERSION_3); uint8_t protocol_version = 0; EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( - uid_, start_session_id_, protocol_version)); + uid_, out_context_.new_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version); } @@ -439,14 +478,14 @@ TEST_F(ConnectionHandlerTest, GetProtocolVersionAfterBinding) { AddTestSession(); uint8_t protocol_version = 0; EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( - uid_, start_session_id_, protocol_version)); + uid_, out_context_.new_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version); connection_handler_->BindProtocolVersionWithSession(connection_key_, PROTOCOL_VERSION_3); EXPECT_TRUE(connection_handler_->ProtocolVersionUsed( - uid_, start_session_id_, protocol_version)); + uid_, out_context_.new_session_id_, protocol_version)); EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version); } @@ -458,15 +497,22 @@ TEST_F(ConnectionHandlerTest, GetPairFromKey) { uint32_t test_uid = 0; connection_handler_->PairFromKey(connection_key_, &test_uid, &session_id); EXPECT_EQ(uid_, test_uid); - EXPECT_EQ(start_session_id_, session_id); + EXPECT_EQ(out_context_.new_session_id_, session_id); } TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) { AddTestDeviceConnection(); AddTestSession(); - ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3); - EXPECT_TRUE( - connection_handler_->IsHeartBeatSupported(uid_, start_session_id_)); + ChangeProtocol(uid_, out_context_.new_session_id_, PROTOCOL_VERSION_3); + EXPECT_TRUE(connection_handler_->IsHeartBeatSupported( + uid_, out_context_.new_session_id_)); +} + +MATCHER_P(SameDevice, device, "") { + return arg.device_handle() == device.device_handle() && + arg.user_friendly_name() == device.user_friendly_name() && + arg.mac_address() == device.mac_address() && + arg.connection_type() == device.connection_type(); } TEST_F(ConnectionHandlerTest, SendEndServiceWithoutSetProtocolHandler) { @@ -552,8 +598,8 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) { connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) - .Times(1); + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)).Times(1); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, OnServiceEndedCallback(connection_key_, kMobileNav, kCommon)); @@ -579,7 +625,8 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack_SessionFound) { &mock_connection_handler_observer); connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)); + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, OnServiceEndedCallback(connection_key_, kMobileNav, kFlood)); @@ -853,7 +900,8 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)) .WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; @@ -894,7 +942,8 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)) .WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; @@ -935,8 +984,8 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) - .Times(0); + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)).Times(0); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, @@ -975,8 +1024,8 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) - .Times(0); + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)).Times(0); InSequence seq; EXPECT_CALL(mock_connection_handler_observer, @@ -1015,7 +1064,8 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) { TestAsyncWaiter waiter; uint32_t times = 0; - EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_)) + EXPECT_CALL(mock_protocol_handler_, + SendEndSession(uid_, out_context_.new_session_id_)) .WillOnce(NotifyTestAsyncWaiter(&waiter)); times++; @@ -1046,34 +1096,34 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { // Add virtual device and connection AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); - uint32_t start_audio = 0; - uint32_t start_video = 0; + SessionContext audio_context, video_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&start_audio), SaveArg<3>(&out_hash_id_))) - .WillOnce(DoAll(SaveArg<2>(&start_video), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&audio_context)) + .WillOnce(SaveArg<0>(&video_context)); // Start Audio service connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, start_audio); - CheckServiceExists(uid_, start_session_id_, kAudio, true); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); + EXPECT_NE(0u, audio_context.new_session_id_); + CheckServiceExists(uid_, audio_context.new_session_id_, kAudio, true); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, audio_context.hash_id_); // Start Audio service connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kMobileNav, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, start_video); - CheckServiceExists(uid_, start_session_id_, kMobileNav, true); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); + EXPECT_NE(0u, video_context.new_session_id_); + CheckServiceExists(uid_, video_context.new_session_id_, kMobileNav, true); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_); connection_handler_->set_protocol_handler(NULL); } @@ -1081,22 +1131,27 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { TEST_F(ConnectionHandlerTest, StartService_withServices_withParams) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); + + SessionContext video_context; - uint32_t start_video = 0; // create a dummy pointer int dummy = 0; std::vector<std::string> empty; BsonObject* dummy_param = reinterpret_cast<BsonObject*>(&dummy); connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, empty)) - .WillOnce(DoAll(SaveArg<2>(&start_video), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, empty)) + .WillOnce(SaveArg<0>(&video_context)); - connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kMobileNav, PROTECTION_OFF, dummy_param); - EXPECT_EQ(start_session_id_, start_video); - CheckServiceExists(uid_, start_session_id_, kMobileNav, true); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); + connection_handler_->OnSessionStartedCallback(uid_, + out_context_.new_session_id_, + kMobileNav, + PROTECTION_OFF, + dummy_param); + EXPECT_EQ(out_context_.new_session_id_, video_context.new_session_id_); + CheckServiceExists(uid_, out_context_.new_session_id_, kMobileNav, true); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_); connection_handler_->set_protocol_handler(NULL); } @@ -1117,39 +1172,39 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) { uint32_t dummy_hash = 0u; const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, &dummy_hash, kAudio); + uid_, out_context_.new_session_id_, &dummy_hash, kAudio); EXPECT_EQ(0u, end_session_result); - CheckServiceExists(uid_, start_session_id_, kAudio, false); + CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false); } TEST_F(ConnectionHandlerTest, ServiceStop) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); - uint32_t start_audio = 0; + SessionContext audio_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillRepeatedly( - DoAll(SaveArg<2>(&start_audio), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillRepeatedly(SaveArg<0>(&audio_context)); // Check ignoring hash_id on stop non-rpc service for (uint32_t some_hash_id = 0; some_hash_id < 0xFF; ++some_hash_id) { // Start audio service connection_handler_->OnSessionStartedCallback( uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, start_audio); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); + EXPECT_EQ(out_context_.new_session_id_, audio_context.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, audio_context.hash_id_); const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, &some_hash_id, kAudio); + uid_, out_context_.new_session_id_, &some_hash_id, kAudio); EXPECT_EQ(connection_key_, end_session_result); - CheckServiceExists(uid_, start_session_id_, kAudio, false); + CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false); } } @@ -1158,18 +1213,18 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckHash) { for (uint32_t session = 0; session < 0xFF; ++session) { AddTestSession(); - const uint32_t hash = connection_key_; + uint32_t hash = connection_key_; uint32_t wrong_hash = hash + 1; const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, &wrong_hash, kRpc); + uid_, out_context_.new_session_id_, &wrong_hash, kRpc); EXPECT_EQ(0u, end_audio_wrong_hash); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, wrong_hash); - CheckSessionExists(uid_, start_session_id_); + CheckSessionExists(uid_, out_context_.new_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, hash, kRpc); + uid_, out_context_.new_session_id_, &hash, kRpc); EXPECT_EQ(connection_key_, end_audio); CheckSessionExists(uid_, 0); } @@ -1181,17 +1236,17 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) { AddTestSession(); uint32_t wrong_hash = protocol_handler::HASH_ID_WRONG; - const uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED; + uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED; const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, wrong_hash, kRpc); + uid_, out_context_.new_session_id_, &wrong_hash, kRpc); EXPECT_EQ(0u, end_audio_wrong_hash); EXPECT_EQ(protocol_handler::HASH_ID_WRONG, wrong_hash); - CheckSessionExists(uid_, start_session_id_); + CheckSessionExists(uid_, out_context_.new_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid_, start_session_id_, hash, kRpc); + uid_, out_context_.new_session_id_, &hash, kRpc); EXPECT_EQ(connection_key_, end_audio); CheckSessionExists(uid_, 0); } @@ -1200,16 +1255,17 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) { TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) { // Add virtual device and connection AddTestDeviceConnection(); + out_context_.initial_session_id_ = 1u; // Expect that rpc service has started connection_handler_test::MockConnectionHandlerObserver mock_connection_handler_observer; connection_handler_->set_connection_handler_observer( &mock_connection_handler_observer); - uint32_t session_key = - connection_handler_->KeyFromPair(uid_, start_session_id_); std::vector<std::string> empty; + uint32_t session_key = + connection_handler_->KeyFromPair(uid_, out_context_.initial_session_id_); EXPECT_CALL(mock_connection_handler_observer, - OnServiceStartedCallback(device_handle_, session_key, kRpc, NULL)) + OnServiceStartedCallback(device_handle_, _, kRpc, NULL)) .WillOnce(InvokeMemberFuncWithArg3( connection_handler_, &ConnectionHandler::NotifyServiceStartedResult, @@ -1217,22 +1273,25 @@ TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) { true, ByRef(empty))); - uint32_t new_session_id = 0; + EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) + .WillOnce(Return(true)); + connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&new_session_id), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&out_context_)); // Start new session with RPC service connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_NE(0u, new_session_id); + EXPECT_NE(0u, out_context_.new_session_id_); } TEST_F(ConnectionHandlerTest, ServiceStarted_Video_SUCCESS) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); int dummy = 0; BsonObject* dummy_params = reinterpret_cast<BsonObject*>(&dummy); @@ -1242,7 +1301,7 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_SUCCESS) { connection_handler_->set_connection_handler_observer( &mock_connection_handler_observer); uint32_t session_key = - connection_handler_->KeyFromPair(uid_, start_session_id_); + connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); std::vector<std::string> empty; EXPECT_CALL(mock_connection_handler_observer, OnServiceStartedCallback( @@ -1253,23 +1312,28 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_SUCCESS) { session_key, true, ByRef(empty))); + EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) + .WillOnce(Return(true)); - // confirm that NotifySessionStartedResult() is called - uint32_t new_session_id = 0; + // confirm that NotifySessionStarted() is called connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, false, empty)) - .WillOnce(DoAll(SaveArg<2>(&new_session_id), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, empty)) + .WillOnce(SaveArg<0>(&out_context_)); - connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kMobileNav, PROTECTION_OFF, dummy_params); + connection_handler_->OnSessionStartedCallback(uid_, + out_context_.new_session_id_, + kMobileNav, + PROTECTION_OFF, + dummy_params); - EXPECT_NE(0u, new_session_id); + EXPECT_NE(0u, out_context_.new_session_id_); } TEST_F(ConnectionHandlerTest, ServiceStarted_Video_FAILURE) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); int dummy = 0; BsonObject* dummy_params = reinterpret_cast<BsonObject*>(&dummy); @@ -1279,7 +1343,7 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_FAILURE) { connection_handler_->set_connection_handler_observer( &mock_connection_handler_observer); uint32_t session_key = - connection_handler_->KeyFromPair(uid_, start_session_id_); + connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); std::vector<std::string> empty; EXPECT_CALL(mock_connection_handler_observer, OnServiceStartedCallback( @@ -1290,18 +1354,21 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_FAILURE) { session_key, false, ByRef(empty))); + EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) + .WillOnce(Return(true)); - // confirm that NotifySessionStartedResult() is called - uint32_t new_session_id = 0; + // confirm that NotifySessionStarted() is called connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, false, empty)) - .WillOnce(DoAll(SaveArg<2>(&new_session_id), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, empty)) + .WillOnce(SaveArg<0>(&out_context_)); - connection_handler_->OnSessionStartedCallback( - uid_, start_session_id_, kMobileNav, PROTECTION_OFF, dummy_params); + connection_handler_->OnSessionStartedCallback(uid_, + out_context_.new_session_id_, + kMobileNav, + PROTECTION_OFF, + dummy_params); - EXPECT_EQ(0u, new_session_id); + EXPECT_EQ(0u, out_context_.new_session_id_); } /* @@ -1312,17 +1379,13 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_FAILURE) { TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { AddTestDeviceConnection(); - uint32_t rpc_session_id1; - uint32_t rpc_session_id2; - uint32_t hash_id1; - uint32_t hash_id2; + SessionContext context_first, context_second; protocol_handler_test::MockProtocolHandler temp_protocol_handler; connection_handler_->set_protocol_handler(&temp_protocol_handler); - EXPECT_CALL(temp_protocol_handler, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&rpc_session_id1), SaveArg<3>(&hash_id1))) - .WillOnce(DoAll(SaveArg<2>(&rpc_session_id2), SaveArg<3>(&hash_id2))); + EXPECT_CALL(temp_protocol_handler, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&context_first)) + .WillOnce(SaveArg<0>(&context_second)); // add two sessions connection_handler_->OnSessionStartedCallback( @@ -1330,12 +1393,14 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_NE(0u, rpc_session_id1); - EXPECT_NE(0u, rpc_session_id2); - EXPECT_EQ(SessionHash(uid_, rpc_session_id1), hash_id1); - EXPECT_EQ(SessionHash(uid_, rpc_session_id2), hash_id2); - CheckSessionExists(uid_, rpc_session_id1); - CheckSessionExists(uid_, rpc_session_id2); + EXPECT_NE(0u, context_first.new_session_id_); + EXPECT_NE(0u, context_second.new_session_id_); + EXPECT_EQ(SessionHash(uid_, context_first.new_session_id_), + context_first.hash_id_); + EXPECT_EQ(SessionHash(uid_, context_second.new_session_id_), + context_second.hash_id_); + CheckSessionExists(uid_, context_first.new_session_id_); + CheckSessionExists(uid_, context_second.new_session_id_); connection_handler_->set_protocol_handler(NULL); @@ -1347,11 +1412,17 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { connection_handler_->set_connection_handler_observer( &mock_connection_handler_observer); uint32_t session_key1 = - connection_handler_->KeyFromPair(uid_, rpc_session_id1); + connection_handler_->KeyFromPair(uid_, context_first.new_session_id_); uint32_t session_key2 = - connection_handler_->KeyFromPair(uid_, rpc_session_id2); + connection_handler_->KeyFromPair(uid_, context_second.new_session_id_); std::vector<std::string> empty; + ChangeProtocol(uid_, + context_first.new_session_id_, + protocol_handler::PROTOCOL_VERSION_3); + ChangeProtocol(uid_, + context_second.new_session_id_, + protocol_handler::PROTOCOL_VERSION_3); EXPECT_CALL(mock_connection_handler_observer, OnServiceStartedCallback( @@ -1375,27 +1446,30 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { session_key1, true, ByRef(empty)))); + EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) + .Times(2) + .WillRepeatedly(Return(true)); // verify that connection handler will not mix up the two results - uint32_t new_session_id1 = 0; - uint32_t new_session_id2 = 0; + SessionContext new_context_first, new_context_second; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL( - mock_protocol_handler_, - NotifySessionStartedResult(_, rpc_session_id1, _, _, false, empty)) - .WillOnce(SaveArg<2>(&new_session_id1)); - EXPECT_CALL( - mock_protocol_handler_, - NotifySessionStartedResult(_, rpc_session_id2, _, _, false, empty)) - .WillOnce(SaveArg<2>(&new_session_id2)); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, empty)) + .WillOnce(SaveArg<0>(&new_context_second)) + .WillOnce(SaveArg<0>(&new_context_first)); - connection_handler_->OnSessionStartedCallback( - uid_, rpc_session_id1, kMobileNav, PROTECTION_OFF, dummy_params); - connection_handler_->OnSessionStartedCallback( - uid_, rpc_session_id2, kMobileNav, PROTECTION_OFF, dummy_params); + connection_handler_->OnSessionStartedCallback(uid_, + context_first.new_session_id_, + kMobileNav, + PROTECTION_OFF, + dummy_params); + connection_handler_->OnSessionStartedCallback(uid_, + context_second.new_session_id_, + kMobileNav, + PROTECTION_OFF, + dummy_params); - EXPECT_NE(0u, new_session_id1); // result is positive - EXPECT_EQ(0u, new_session_id2); // result is negative + EXPECT_NE(0u, new_context_first.new_session_id_); // result is positive + EXPECT_EQ(0u, new_context_second.new_session_id_); // result is negative } TEST_F(ConnectionHandlerTest, @@ -1408,23 +1482,23 @@ TEST_F(ConnectionHandlerTest, protected_services_.push_back(kRpc); SetSpecificServices(); - uint32_t session_id_fail = 0; - uint32_t session_id = 0; + SessionContext fail_context; + SessionContext positive_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&session_id_fail), SaveArg<3>(&out_hash_id_))) - .WillOnce(DoAll(SaveArg<2>(&session_id), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&fail_context)) + .WillOnce(SaveArg<0>(&positive_context)); // Start new session with RPC service connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(0u, session_id_fail); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + EXPECT_EQ(0u, fail_context.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, fail_context.hash_id_); #else - EXPECT_EQ(1u, session_id_fail); - EXPECT_EQ(SessionHash(uid_, session_id_fail), out_hash_id_); + EXPECT_EQ(1u, fail_context.new_session_id_); + EXPECT_EQ(SessionHash(uid_, fail_context.new_session_id_), + fail_context.hash_id_); #endif // ENABLE_SECURITY // Allow start kRPC without encryption @@ -1434,9 +1508,10 @@ TEST_F(ConnectionHandlerTest, // Start new session with RPC service connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_NE(0u, session_id); - CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); - EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); + EXPECT_NE(0u, positive_context.new_session_id_); + CheckService(uid_, positive_context.new_session_id_, kRpc); + EXPECT_EQ(SessionHash(uid_, positive_context.new_session_id_), + positive_context.hash_id_); } TEST_F(ConnectionHandlerTest, @@ -1450,21 +1525,20 @@ TEST_F(ConnectionHandlerTest, unprotected_services_.push_back(kControl); SetSpecificServices(); - uint32_t session_id_fail = 0; - uint32_t session_id = 0; + SessionContext fail_context; + SessionContext positive_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id_fail)) - .WillOnce(DoAll(SaveArg<2>(&session_id), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&fail_context)) + .WillOnce(SaveArg<0>(&positive_context)); // Start new session with RPC service connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_ON, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(0u, session_id_fail); + EXPECT_EQ(0u, fail_context.new_session_id_); #else - EXPECT_EQ(1u, session_id_fail); + EXPECT_EQ(1u, fail_context.new_session_id_); #endif // ENABLE_SECURITY // Allow start kRPC with encryption @@ -1474,17 +1548,21 @@ TEST_F(ConnectionHandlerTest, // Start new session with RPC service connection_handler_->OnSessionStartedCallback( uid_, 0, kRpc, PROTECTION_ON, static_cast<BsonObject*>(NULL)); - EXPECT_NE(0u, session_id); - EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); - + EXPECT_NE(0u, positive_context.new_session_id_); + EXPECT_EQ(SessionHash(uid_, positive_context.new_session_id_), + positive_context.hash_id_); +#ifdef ENABLE_SECURITY // Protection steal FALSE because of APPlink Protocol implementation - CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); + CheckService(uid_, positive_context.new_session_id_, kRpc); +#endif // ENABLE_SECURITY } TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprotect) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); // Forbid start kAudio without encryption protected_services_.push_back(UnnamedService::kServedService1); @@ -1493,24 +1571,22 @@ TEST_F(ConnectionHandlerTest, protected_services_.push_back(kControl); SetSpecificServices(); - uint32_t session_id2 = 0; - uint32_t session_id3 = 0; + SessionContext context_first, context_second; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id2)) - .WillOnce(DoAll(SaveArg<2>(&session_id3), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&context_first)) + .WillOnce(SaveArg<0>(&context_second)); // Start new session with Audio service connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(0u, session_id2); + EXPECT_EQ(0u, context_first.new_session_id_); #else - EXPECT_EQ(1u, session_id2); + EXPECT_EQ(1u, context_first.new_session_id_); #endif // ENABLE_SECURITY // Allow start kAudio without encryption protected_services_.clear(); @@ -1520,18 +1596,19 @@ TEST_F(ConnectionHandlerTest, protected_services_.push_back(kControl); SetSpecificServices(); connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); // Returned original session id #ifdef ENABLE_SECURITY - EXPECT_EQ(start_session_id_, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, session_id3, kRpc, NULL, PROTECTION_OFF); + EXPECT_EQ(out_context_.new_session_id_, context_second.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, context_second.hash_id_); + CheckService( + uid_, context_second.new_session_id_, kRpc, NULL, PROTECTION_OFF); #else - EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + EXPECT_EQ(0u, context_second.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, context_second.hash_id_); #endif // ENABLE_SECURITY } @@ -1539,6 +1616,8 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); // Forbid start kAudio with encryption unprotected_services_.push_back(UnnamedService::kServedService1); @@ -1547,101 +1626,97 @@ TEST_F(ConnectionHandlerTest, unprotected_services_.push_back(kControl); SetSpecificServices(); - uint32_t session_id_reject = 0; - uint32_t session_id3 = 0; + SessionContext rejected_context, positive_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id_reject)) - .WillOnce(DoAll(SaveArg<2>(&session_id3), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&rejected_context)) + .WillOnce(SaveArg<0>(&positive_context)); // Start new session with Audio service connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_ON, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(0u, session_id_reject); + EXPECT_EQ(0u, rejected_context.new_session_id_); #else - EXPECT_EQ(1u, session_id_reject); + EXPECT_EQ(1u, rejected_context.new_session_id_); #endif // ENABLE_SECURITY // Allow start kAudio with encryption unprotected_services_.clear(); SetSpecificServices(); connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_ON, static_cast<BsonObject*>(NULL)); // Returned original session id #ifdef ENABLE_SECURITY - EXPECT_EQ(start_session_id_, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, session_id3, kAudio, NULL, PROTECTION_ON); + EXPECT_EQ(out_context_.new_session_id_, positive_context.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, positive_context.hash_id_); + CheckService( + uid_, positive_context.new_session_id_, kAudio, NULL, PROTECTION_ON); #else - EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); - CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); + EXPECT_EQ(0u, positive_context.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, positive_context.hash_id_); #endif // ENABLE_SECURITY } TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) { AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); - uint32_t session_id_new = 0; - uint32_t session_id2 = 0; - uint32_t session_id3 = 0; + SessionContext context_new, context_second, context_third; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(DoAll(SaveArg<2>(&session_id_new), SaveArg<3>(&out_hash_id_))) - .WillOnce(DoAll(SaveArg<2>(&session_id2), SaveArg<3>(&out_hash_id_))) - .WillOnce(DoAll(SaveArg<2>(&session_id3), SaveArg<3>(&out_hash_id_))); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&context_new)) + .WillOnce(SaveArg<0>(&context_second)) + .WillOnce(SaveArg<0>(&context_third)); // Start RPC protection connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kRpc, PROTECTION_ON, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(start_session_id_, session_id_new); + EXPECT_EQ(out_context_.new_session_id_, context_new.new_session_id_); // Post protection nedd no hash - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, context_new.hash_id_); + CheckService(uid_, context_new.new_session_id_, kRpc, NULL, PROTECTION_ON); #else - EXPECT_EQ(0u, session_id_new); + EXPECT_EQ(0u, context_new.new_session_id_); // Post protection nedd no hash - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); - CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, context_new.hash_id_); #endif // ENABLE_SECURITY // Start Audio session without protection connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_OFF, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, session_id2); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); + EXPECT_EQ(out_context_.new_session_id_, context_second.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, context_second.hash_id_); + CheckService(uid_, context_second.new_session_id_, kAudio); // Start Audio protection connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_ON, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(start_session_id_, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); - CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_ON); + EXPECT_EQ(out_context_.new_session_id_, context_third.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, context_third.hash_id_); + CheckService( + uid_, context_third.new_session_id_, kAudio, NULL, PROTECTION_ON); #else - EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); - CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); + EXPECT_EQ(0u, context_third.new_session_id_); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, context_third.hash_id_); #endif // ENABLE_SECURITY } @@ -1649,22 +1724,20 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) { AddTestDeviceConnection(); AddTestSession(); - uint32_t session_id_new = 0; + SessionContext new_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id_new)); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&new_context)); connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kBulk, PROTECTION_ON, static_cast<BsonObject*>(NULL)); #ifdef ENABLE_SECURITY - EXPECT_EQ(start_session_id_, session_id_new); - CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON); + EXPECT_EQ(out_context_.new_session_id_, new_context.new_session_id_); + CheckService(uid_, new_context.new_session_id_, kRpc, NULL, PROTECTION_ON); #else - EXPECT_EQ(0u, session_id_new); - CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF); + EXPECT_EQ(0u, new_context.new_session_id_); #endif // ENABLE_SECURITY } @@ -1743,6 +1816,9 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) { testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); + ChangeProtocol( + uid_, out_context_.new_session_id_, protocol_handler::PROTOCOL_VERSION_3); + EXPECT_EQ( connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); @@ -1754,20 +1830,23 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) { EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), reinterpret_cast<security_manager::SSLContext*>(NULL)); - uint32_t session_id = 0; + SessionContext new_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id)); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&new_context)); // Open kAudio service connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kAudio, PROTECTION_ON, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(session_id, start_session_id_); - CheckService(uid_, session_id, kAudio, &mock_ssl_context, PROTECTION_ON); + EXPECT_EQ(new_context.new_session_id_, out_context_.new_session_id_); + CheckService(uid_, + new_context.new_session_id_, + kAudio, + &mock_ssl_context, + PROTECTION_ON); // kAudio is not exists yet EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), @@ -1788,20 +1867,23 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) { EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), reinterpret_cast<security_manager::SSLContext*>(NULL)); - uint32_t session_id = 0; + SessionContext new_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id)); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&new_context)); // Protect kRpc (Bulk will be protect also) connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kRpc, PROTECTION_ON, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, session_id); - CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); + EXPECT_EQ(out_context_.new_session_id_, new_context.new_session_id_); + CheckService(uid_, + new_context.new_session_id_, + kRpc, + &mock_ssl_context, + PROTECTION_ON); // kRpc is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), @@ -1825,20 +1907,23 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) { EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), reinterpret_cast<security_manager::SSLContext*>(NULL)); - uint32_t session_id = 0; + SessionContext new_context; connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, - NotifySessionStartedResult(_, _, _, _, _, _)) - .WillOnce(SaveArg<2>(&session_id)); + EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) + .WillOnce(SaveArg<0>(&new_context)); // Protect Bulk (kRpc will be protected also) connection_handler_->OnSessionStartedCallback(uid_, - start_session_id_, + out_context_.new_session_id_, kBulk, PROTECTION_ON, static_cast<BsonObject*>(NULL)); - EXPECT_EQ(start_session_id_, session_id); - CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); + EXPECT_EQ(out_context_.new_session_id_, new_context.new_session_id_); + CheckService(uid_, + new_context.new_session_id_, + kRpc, + &mock_ssl_context, + PROTECTION_ON); // kRpc is protected EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), @@ -1854,8 +1939,9 @@ TEST_F(ConnectionHandlerTest, SendHeartBeat) { AddTestDeviceConnection(); AddTestSession(); connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, SendHeartBeat(uid_, start_session_id_)); - connection_handler_->SendHeartBeat(uid_, start_session_id_); + EXPECT_CALL(mock_protocol_handler_, + SendHeartBeat(uid_, out_context_.new_session_id_)); + connection_handler_->SendHeartBeat(uid_, out_context_.new_session_id_); } TEST_F(ConnectionHandlerTest, RunAppOnDevice_NoAppOnDevice_UNSUCCESS) { @@ -1892,6 +1978,41 @@ TEST_F(ConnectionHandlerTest, RunAppOnDevice_AppOnDevice_SUCCESS) { connection_handler_->RunAppOnDevice(hash_of_mac_address, bundle_id); } +TEST_F(ConnectionHandlerTest, OnDeviceConnectionSwitching) { + connection_handler_test::MockConnectionHandlerObserver + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + const transport_manager::DeviceInfo device_info_1( + device_handle_, mac_address_, device_name_, connection_type_); + + connection_handler_->OnDeviceAdded(device_info_1); + + const auto second_mac_address = "second_mac_address"; + const transport_manager::DeviceInfo device_info_2(device_handle_ + 1, + second_mac_address, + "second_device_name", + "second_connection_type"); + + connection_handler_->OnDeviceAdded(device_info_2); + + connection_handler::Device d1(device_info_1.device_handle(), + device_info_1.name(), + device_info_1.mac_address(), + device_info_1.connection_type()); + + connection_handler::Device d2(device_info_2.device_handle(), + device_info_2.name(), + device_info_2.mac_address(), + device_info_2.connection_type()); + + EXPECT_CALL(mock_connection_handler_observer, + OnDeviceSwitchingStart(SameDevice(d1), SameDevice(d2))); + + connection_handler_->OnDeviceSwitchingStart(mac_address_, second_mac_address); +} + } // namespace connection_handler_test } // namespace components } // namespace test |