OSCrypt supports encryption with KWallet

components/os_crypt/kwallet_dbus_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/os_crypt/kwallet_dbus.h"
 
 #include <memory>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 254 matching lines @@
     return false;
 
   bool b;
   EXPECT_TRUE(reader.PopBool(&b));
   if (bool_5 != b)
     return false;
 
   return true;
 }
 
+MATCHER_P5(ArgumentsAreIntStringStringStringString,
+           int_1,
+           str_2,
+           str_3,
+           str_4,
+           str_5,
+           "") {
+  dbus::MessageReader reader(arg);
+
+  int32_t i;
+  EXPECT_TRUE(reader.PopInt32(&i));
+  if (i != int_1)

[Lei Zhang, 2016/07/20 01:08:26]

You put int_1 on the right side, but moved str_N to the left side below.

[cfroussios, 2016/07/20 15:22:47]

Done.

+    return false;
+
+  std::string str;
+  EXPECT_TRUE(reader.PopString(&str));
+  if (str_2 != str)
+    return false;
+
+  EXPECT_TRUE(reader.PopString(&str));
+  if (str_3 != str)
+    return false;
+
+  EXPECT_TRUE(reader.PopString(&str));
+  if (str_4 != str)
+    return false;
+
+  EXPECT_TRUE(reader.PopString(&str));
+  if (str_5 != str)
+    return false;
+
+  return true;
+}
+
+MATCHER_P3(ArgumentsAreIntBoolString, int_1, bool_2, str_3, "") {
+  dbus::MessageReader reader(arg);
+
+  int32_t i;
+  EXPECT_TRUE(reader.PopInt32(&i));
+  if (i != int_1)
+    return false;
+
+  bool b;
+  EXPECT_TRUE(reader.PopBool(&b));
+  if (b != bool_2)
+    return false;
+
+  std::string str;
+  EXPECT_TRUE(reader.PopString(&str));
+  if (str != str_3)
+    return false;
+
+  return true;
+}
+
 TEST_P(KWalletDBusTest, StartWalletd) {
   // The receiver of the message takes ownership of the response object.
   dbus::Response* response_success = RespondEmpty();
   dbus::MessageWriter writer(response_success);
   writer.AppendInt32(0);  // return code
   writer.AppendString("dbus_name");
   writer.AppendString(std::string());  // error message
   writer.AppendInt32(100);             // pid
 
   EXPECT_CALL(
@@ skipping 401 matching lines @@
   EXPECT_CALL(
       *mock_kwallet_proxy_.get(),
       MockCallMethodAndBlock(Calls(kKWalletInterface, "createFolder"), _))
       .WillOnce(Return(nullptr));
 
   bool created_folder = false;
   EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
             kwallet_dbus_.CreateFolder(123, "folder", "app", &created_folder));
 }
 
+TEST_P(KWalletDBusTest, WritePassword) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(
+                  AllOf(Calls(kKWalletInterface, "writePassword"),
+                        ArgumentsAreIntStringStringStringString(
+                            123, "folder", "key", "password", "app")),
+                  _))
+      .WillOnce(Return(RespondInt32(0)));
+
+  bool write_success = false;
+  EXPECT_EQ(KWalletDBus::Error::SUCCESS,
+            kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
+                                        &write_success));
+  EXPECT_TRUE(write_success);
+}
+
+TEST_P(KWalletDBusTest, WritePasswordRejected) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(
+                  AllOf(Calls(kKWalletInterface, "writePassword"),
+                        ArgumentsAreIntStringStringStringString(
+                            123, "folder", "key", "password", "app")),
+                  _))
+      .WillOnce(Return(RespondInt32(-1)));
+
+  bool write_success = true;
+  EXPECT_EQ(KWalletDBus::Error::SUCCESS,
+            kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
+                                        &write_success));
+  EXPECT_FALSE(write_success);
+}
+
+TEST_P(KWalletDBusTest, WritePasswordErrorRead) {
+  EXPECT_CALL(
+      *mock_kwallet_proxy_.get(),
+      MockCallMethodAndBlock(Calls(kKWalletInterface, "writePassword"), _))
+      .WillOnce(Return(RespondEmpty()));
+
+  bool write_success = false;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
+            kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
+                                        &write_success));
+}
+
+TEST_P(KWalletDBusTest, WritePasswordErrorContact) {
+  EXPECT_CALL(
+      *mock_kwallet_proxy_.get(),
+      MockCallMethodAndBlock(Calls(kKWalletInterface, "writePassword"), _))
+      .WillOnce(Return(nullptr));
+
+  bool write_success = false;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
+            kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
+                                        &write_success));
+}
+
+TEST_P(KWalletDBusTest, ReadPassword) {
+  EXPECT_CALL(
+      *mock_kwallet_proxy_.get(),
+      MockCallMethodAndBlock(
+          AllOf(Calls(kKWalletInterface, "readPassword"),
+                ArgumentsAreIntStringStringString(123, "folder", "key", "app")),
+          _))
+      .WillOnce(Return(RespondString("password")));
+
+  std::string password;
+  EXPECT_EQ(KWalletDBus::Error::SUCCESS,
+            kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
+  EXPECT_EQ("password", password);

[Lei Zhang, 2016/07/20 01:08:26]

Can you use EXPECT_STREQ() here?

[cfroussios, 2016/07/20 15:22:47]

EXPECT_STREQ is for C strings.

[Lei Zhang, 2016/07/20 19:15:07]

It is indeed, and this is shorter than EXPECT_STREQ("password",
password.c_str());

[cfroussios, 2016/07/21 11:49:46]

Acknowledged.

+}
+
+TEST_P(KWalletDBusTest, ReadPasswordErrorRead) {
+  EXPECT_CALL(
+      *mock_kwallet_proxy_.get(),
+      MockCallMethodAndBlock(Calls(kKWalletInterface, "readPassword"), _))
+      .WillOnce(Return(RespondEmpty()));
+
+  std::string password;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
+            kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
+}
+
+TEST_P(KWalletDBusTest, ReadPasswordErrorContact) {
+  EXPECT_CALL(
+      *mock_kwallet_proxy_.get(),
+      MockCallMethodAndBlock(Calls(kKWalletInterface, "readPassword"), _))
+      .WillOnce(Return(nullptr));
+
+  std::string password;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
+            kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
+}
+
+TEST_P(KWalletDBusTest, CloseSuccess) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(
+                  AllOf(Calls(kKWalletInterface, "close"),
+                        ArgumentsAreIntBoolString(123, false, "app")),
+                  _))
+      .WillOnce(Return(RespondInt32(0)));
+
+  bool success = false;
+  EXPECT_EQ(KWalletDBus::Error::SUCCESS,
+            kwallet_dbus_.Close(123, false, "app", &success));
+  EXPECT_EQ(true, success);

[Lei Zhang, 2016/07/20 01:08:26]

EXPECT_TRUE(success)

[cfroussios, 2016/07/20 15:22:47]

Done.

+}
+
+TEST_P(KWalletDBusTest, CloseUnsuccessful) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(
+                  AllOf(Calls(kKWalletInterface, "close"),
+                        ArgumentsAreIntBoolString(123, false, "app")),
+                  _))
+      .WillOnce(Return(RespondInt32(1)));
+
+  bool success = true;
+  EXPECT_EQ(KWalletDBus::Error::SUCCESS,
+            kwallet_dbus_.Close(123, false, "app", &success));
+  EXPECT_EQ(false, success);

[Lei Zhang, 2016/07/20 01:08:26]

EXPECT_FALSE

[cfroussios, 2016/07/20 15:22:47]

Done.

+}
+
+TEST_P(KWalletDBusTest, CloseErrorRead) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(Calls(kKWalletInterface, "close"), _))
+      .WillOnce(Return(RespondEmpty()));
+
+  bool success = true;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
+            kwallet_dbus_.Close(123, false, "app", &success));
+}
+
+TEST_P(KWalletDBusTest, CloseErrorContact) {
+  EXPECT_CALL(*mock_kwallet_proxy_.get(),
+              MockCallMethodAndBlock(Calls(kKWalletInterface, "close"), _))
+      .WillOnce(Return(nullptr));
+
+  bool success = true;
+  EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
+            kwallet_dbus_.Close(123, false, "app", &success));
+}
+
 }  // namespace