1 files changed, 42 insertions, 16 deletions

diff --git a/src/components/security_manager/test/crypto_manager_impl_test.cc b/src/components/security_manager/test/crypto_manager_impl_test.cc
index b30684e5f6..5e096194f3 100644
--- a/src/components/security_manager/test/crypto_manager_impl_test.cc
+++ b/src/components/security_manager/test/crypto_manager_impl_test.cc
@@ -39,7 +39,6 @@
 #include <fstream>
 #include <sstream>
 
-#include "utils/make_shared.h"
 #include "gtest/gtest.h"
 #include "security_manager/crypto_manager_impl.h"
 #include "security_manager/mock_security_manager_settings.h"
@@ -52,6 +51,10 @@ namespace {
 const size_t kUpdatesBeforeHour = 24;
 const std::string kAllCiphers = "ALL";
 const std::string kCaCertPath = "";
+const uint32_t kServiceNumber = 2u;
+const size_t kMaxSizeVector = 1u;
+const std::string kCertPath = "certificate.crt";
+const std::string kPrivateKeyPath = "private.key";
 
 #ifdef __QNXNTO__
 const std::string kFordCipher = SSL3_TXT_RSA_DES_192_CBC3_SHA;
@@ -86,9 +89,11 @@ class CryptoManagerTest : public testing::Test {
   void SetUp() OVERRIDE {
     ASSERT_FALSE(certificate_data_base64_.empty());
     mock_security_manager_settings_ =
-        utils::MakeShared<MockCryptoManagerSettings>();
+        std::make_shared<MockCryptoManagerSettings>();
     crypto_manager_ =
-        utils::MakeShared<CryptoManagerImpl>(mock_security_manager_settings_);
+        std::make_shared<CryptoManagerImpl>(mock_security_manager_settings_);
+    forced_protected_services_.reserve(kMaxSizeVector);
+    forced_unprotected_services_.reserve(kMaxSizeVector);
   }
 
   void InitSecurityManager() {
@@ -101,6 +106,10 @@ class CryptoManagerTest : public testing::Test {
   void SetInitialValues(security_manager::Mode mode,
                         security_manager::Protocol protocol,
                         const std::string& cipher) {
+    ON_CALL(*mock_security_manager_settings_, force_unprotected_service())
+        .WillByDefault(ReturnRef(forced_unprotected_services_));
+    ON_CALL(*mock_security_manager_settings_, force_protected_service())
+        .WillByDefault(ReturnRef(forced_protected_services_));
     ON_CALL(*mock_security_manager_settings_, security_manager_mode())
         .WillByDefault(Return(mode));
     ON_CALL(*mock_security_manager_settings_, security_manager_protocol_name())
@@ -111,14 +120,21 @@ class CryptoManagerTest : public testing::Test {
         .WillByDefault(ReturnRef(cipher));
     ON_CALL(*mock_security_manager_settings_, ca_cert_path())
         .WillByDefault(ReturnRef(kCaCertPath));
+    ON_CALL(*mock_security_manager_settings_, module_cert_path())
+        .WillByDefault(ReturnRef(kCertPath));
+    ON_CALL(*mock_security_manager_settings_, module_key_path())
+        .WillByDefault(ReturnRef(kPrivateKeyPath));
     ON_CALL(*mock_security_manager_settings_, verify_peer())
         .WillByDefault(Return(false));
   }
 
-  utils::SharedPtr<CryptoManagerImpl> crypto_manager_;
-  utils::SharedPtr<MockCryptoManagerSettings> mock_security_manager_settings_;
+  std::shared_ptr<CryptoManagerImpl> crypto_manager_;
+  std::shared_ptr<MockCryptoManagerSettings> mock_security_manager_settings_;
   static std::string certificate_data_base64_;
+  std::vector<int> forced_protected_services_;
+  std::vector<int> forced_unprotected_services_;
 };
+
 std::string CryptoManagerTest::certificate_data_base64_;
 
 TEST_F(CryptoManagerTest, UsingBeforeInit) {
@@ -133,16 +149,15 @@ TEST_F(CryptoManagerTest, WrongInit) {
   // Unknown protocol version
   security_manager::Protocol UNKNOWN =
       static_cast<security_manager::Protocol>(-1);
+  // Unexistent cipher value
+  const std::string invalid_cipher = "INVALID_UNKNOWN_CIPHER";
+  const security_manager::Mode mode = security_manager::SERVER;
 
-  EXPECT_CALL(*mock_security_manager_settings_, security_manager_mode())
-      .WillRepeatedly(Return(security_manager::SERVER));
-  EXPECT_CALL(*mock_security_manager_settings_,
-              security_manager_protocol_name()).WillOnce(Return(UNKNOWN));
-  EXPECT_FALSE(crypto_manager_->Init());
+  SetInitialValues(mode, UNKNOWN, invalid_cipher);
 
+  EXPECT_FALSE(crypto_manager_->Init());
   EXPECT_NE(std::string(), crypto_manager_->LastError());
-  // Unexistent cipher value
-  const std::string invalid_cipher = "INVALID_UNKNOWN_CIPHER";
+
   EXPECT_CALL(*mock_security_manager_settings_,
               security_manager_protocol_name())
       .WillOnce(Return(security_manager::TLSv1_2));
@@ -151,7 +166,6 @@ TEST_F(CryptoManagerTest, WrongInit) {
   EXPECT_CALL(*mock_security_manager_settings_, ciphers_list())
       .WillRepeatedly(ReturnRef(invalid_cipher));
   EXPECT_FALSE(crypto_manager_->Init());
-
   EXPECT_NE(std::string(), crypto_manager_->LastError());
 }
 
@@ -176,10 +190,18 @@ TEST_F(CryptoManagerTest, CorrectInit) {
       security_manager::CLIENT, security_manager::TLSv1_1, kFordCipher);
   EXPECT_TRUE(crypto_manager_->Init());
 
+  SetInitialValues(
+      security_manager::CLIENT, security_manager::DTLSv1, kFordCipher);
+  EXPECT_TRUE(crypto_manager_->Init());
+
   // Cipher value
   SetInitialValues(
       security_manager::SERVER, security_manager::TLSv1_2, kAllCiphers);
   EXPECT_TRUE(crypto_manager_->Init());
+
+  SetInitialValues(
+      security_manager::SERVER, security_manager::DTLSv1, kAllCiphers);
+  EXPECT_TRUE(crypto_manager_->Init());
 }
 // #endif  // __QNX__
 
@@ -198,7 +220,6 @@ TEST_F(CryptoManagerTest, CreateReleaseSSLContext) {
   EXPECT_CALL(*mock_security_manager_settings_, maximum_payload_size())
       .Times(1)
       .WillRepeatedly(Return(max_payload_size));
-
   security_manager::SSLContext* context = crypto_manager_->CreateSSLContext();
   EXPECT_TRUE(context);
   EXPECT_NO_THROW(crypto_manager_->ReleaseSSLContext(context));
@@ -210,7 +231,10 @@ TEST_F(CryptoManagerTest, OnCertificateUpdated) {
 }
 
 TEST_F(CryptoManagerTest, OnCertificateUpdated_UpdateNotRequired) {
+  time_t system_time = 0;
+  time_t certificates_time = 1;
   size_t updates_before = 0;
+
   SetInitialValues(
       security_manager::CLIENT, security_manager::TLSv1_2, kAllCiphers);
   ASSERT_TRUE(crypto_manager_->Init());
@@ -218,7 +242,8 @@ TEST_F(CryptoManagerTest, OnCertificateUpdated_UpdateNotRequired) {
   EXPECT_CALL(*mock_security_manager_settings_, update_before_hours())
       .WillOnce(Return(updates_before));
 
-  EXPECT_FALSE(crypto_manager_->IsCertificateUpdateRequired());
+  EXPECT_FALSE(crypto_manager_->IsCertificateUpdateRequired(system_time,
+                                                            certificates_time));
 
   size_t max_updates_ = std::numeric_limits<size_t>::max();
   SetInitialValues(
@@ -227,7 +252,8 @@ TEST_F(CryptoManagerTest, OnCertificateUpdated_UpdateNotRequired) {
       .WillOnce(Return(max_updates_));
   ASSERT_TRUE(crypto_manager_->Init());
 
-  EXPECT_TRUE(crypto_manager_->IsCertificateUpdateRequired());
+  EXPECT_TRUE(crypto_manager_->IsCertificateUpdateRequired(system_time,
+                                                           certificates_time));
 }
 
 TEST_F(CryptoManagerTest, OnCertificateUpdated_NotInitialized) {