kwallet_dbus_unittest.cc 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890
  1. // Copyright 2016 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/os_crypt/kwallet_dbus.h"
  5. #include <memory>
  6. #include <string>
  7. #include "base/nix/xdg_util.h"
  8. #include "dbus/message.h"
  9. #include "dbus/mock_bus.h"
  10. #include "dbus/mock_object_proxy.h"
  11. #include "dbus/object_path.h"
  12. #include "dbus/object_proxy.h"
  13. #include "testing/gmock/include/gmock/gmock.h"
  14. #include "testing/gtest/include/gtest/gtest.h"
  15. namespace {
  16. using testing::_;
  17. using testing::AllOf;
  18. using testing::ByMove;
  19. using testing::DoAll;
  20. using testing::ElementsAreArray;
  21. using testing::Invoke;
  22. using testing::Return;
  23. using testing::StrictMock;
  24. const char kKWalletInterface[] = "org.kde.KWallet";
  25. const char kKLauncherInterface[] = "org.kde.KLauncher";
  26. std::unique_ptr<dbus::Response> RespondBool(bool value) {
  27. std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  28. dbus::MessageWriter writer(response.get());
  29. writer.AppendBool(value);
  30. return response;
  31. }
  32. std::unique_ptr<dbus::Response> RespondString(const std::string& value) {
  33. std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  34. dbus::MessageWriter writer(response.get());
  35. writer.AppendString(value);
  36. return response;
  37. }
  38. std::unique_ptr<dbus::Response> RespondBytes(
  39. const std::vector<uint8_t>& bytes) {
  40. std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  41. dbus::MessageWriter writer(response.get());
  42. writer.AppendArrayOfBytes(bytes.data(), bytes.size());
  43. return response;
  44. }
  45. std::unique_ptr<dbus::Response> RespondArrayOfStrings(
  46. const std::vector<std::string>& strings) {
  47. std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  48. dbus::MessageWriter writer(response.get());
  49. writer.AppendArrayOfStrings(strings);
  50. return response;
  51. }
  52. std::unique_ptr<dbus::Response> RespondInt32(int value) {
  53. std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  54. dbus::MessageWriter writer(response.get());
  55. writer.AppendInt32(value);
  56. return response;
  57. }
  58. class KWalletDBusTest
  59. : public testing::TestWithParam<base::nix::DesktopEnvironment> {
  60. public:
  61. KWalletDBusTest() : desktop_env_(GetParam()), kwallet_dbus_(desktop_env_) {
  62. if (desktop_env_ == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
  63. dbus_service_name_ = "org.kde.kwalletd5";
  64. dbus_path_ = "/modules/kwalletd5";
  65. kwalletd_name_ = "kwalletd5";
  66. } else {
  67. dbus_service_name_ = "org.kde.kwalletd";
  68. dbus_path_ = "/modules/kwalletd";
  69. kwalletd_name_ = "kwalletd";
  70. }
  71. dbus::Bus::Options options;
  72. options.bus_type = dbus::Bus::SESSION;
  73. mock_session_bus_ = new dbus::MockBus(options);
  74. mock_klauncher_proxy_ = new StrictMock<dbus::MockObjectProxy>(
  75. mock_session_bus_.get(), "org.kde.klauncher",
  76. dbus::ObjectPath("/KLauncher"));
  77. mock_kwallet_proxy_ = new StrictMock<dbus::MockObjectProxy>(
  78. mock_session_bus_.get(), dbus_service_name_,
  79. dbus::ObjectPath(dbus_path_));
  80. // The kwallet proxy is acquired once, when preparing |kwallet_dbus_|
  81. EXPECT_CALL(
  82. *mock_session_bus_.get(),
  83. GetObjectProxy(dbus_service_name_, dbus::ObjectPath(dbus_path_)))
  84. .WillOnce(Return(mock_kwallet_proxy_.get()));
  85. kwallet_dbus_.SetSessionBus(mock_session_bus_);
  86. testing::Mock::VerifyAndClearExpectations(mock_session_bus_.get());
  87. }
  88. KWalletDBusTest(const KWalletDBusTest&) = delete;
  89. KWalletDBusTest& operator=(const KWalletDBusTest&) = delete;
  90. protected:
  91. const base::nix::DesktopEnvironment desktop_env_;
  92. scoped_refptr<dbus::MockBus> mock_session_bus_;
  93. scoped_refptr<dbus::MockObjectProxy> mock_klauncher_proxy_;
  94. scoped_refptr<dbus::MockObjectProxy> mock_kwallet_proxy_;
  95. KWalletDBus kwallet_dbus_;
  96. std::string dbus_service_name_;
  97. std::string dbus_path_;
  98. std::string kwalletd_name_;
  99. };
  100. INSTANTIATE_TEST_SUITE_P(
  101. All,
  102. KWalletDBusTest,
  103. ::testing::Values(base::nix::DESKTOP_ENVIRONMENT_KDE4,
  104. base::nix::DESKTOP_ENVIRONMENT_KDE5));
  105. // Matches a method call to the specified dbus target.
  106. MATCHER_P2(Calls, interface, member, "") {
  107. return arg->GetMember() == member && arg->GetInterface() == interface;
  108. }
  109. // Pops items from the dbus message and compares them to the expected values.
  110. MATCHER_P3(ArgumentsAreIntStringString, int_1, str_2, str_3, "") {
  111. dbus::MessageReader reader(arg);
  112. int i;
  113. EXPECT_TRUE(reader.PopInt32(&i));
  114. if (int_1 != i)
  115. return false;
  116. std::string str;
  117. EXPECT_TRUE(reader.PopString(&str));
  118. if (str_2 != str)
  119. return false;
  120. EXPECT_TRUE(reader.PopString(&str));
  121. if (str_3 != str)
  122. return false;
  123. return true;
  124. }
  125. // Pops items from the dbus message and compares them to the expected values.
  126. MATCHER_P4(ArgumentsAreIntStringStringString, int_1, str_2, str_3, str_4, "") {
  127. dbus::MessageReader reader(arg);
  128. int i;
  129. EXPECT_TRUE(reader.PopInt32(&i));
  130. if (int_1 != i)
  131. return false;
  132. std::string str;
  133. EXPECT_TRUE(reader.PopString(&str));
  134. if (str_2 != str)
  135. return false;
  136. EXPECT_TRUE(reader.PopString(&str));
  137. if (str_3 != str)
  138. return false;
  139. EXPECT_TRUE(reader.PopString(&str));
  140. if (str_4 != str)
  141. return false;
  142. return true;
  143. }
  144. // Pops items from the dbus message and compares them to the expected values.
  145. MATCHER_P5(ArgumentsAreIntStringStringBytesString,
  146. int_1,
  147. str_2,
  148. str_3,
  149. vec_4,
  150. str_5,
  151. "") {
  152. dbus::MessageReader reader(arg);
  153. int i;
  154. EXPECT_TRUE(reader.PopInt32(&i));
  155. if (int_1 != i)
  156. return false;
  157. std::string str;
  158. EXPECT_TRUE(reader.PopString(&str));
  159. if (str_2 != str)
  160. return false;
  161. EXPECT_TRUE(reader.PopString(&str));
  162. if (str_3 != str)
  163. return false;
  164. const uint8_t* bytes = nullptr;
  165. size_t length = 0;
  166. EXPECT_TRUE(reader.PopArrayOfBytes(&bytes, &length));
  167. std::vector<uint8_t> vec;
  168. vec.assign(bytes, bytes + length);
  169. if (vec_4 != vec)
  170. return false;
  171. EXPECT_TRUE(reader.PopString(&str));
  172. if (str_5 != str)
  173. return false;
  174. return true;
  175. }
  176. // Pops items from the dbus message and compares them to the expected values.
  177. MATCHER_P3(ArgumentsAreStringInt64String, str_1, int_2, str_3, "") {
  178. dbus::MessageReader reader(arg);
  179. std::string str;
  180. EXPECT_TRUE(reader.PopString(&str));
  181. if (str_1 != str)
  182. return false;
  183. int64_t i;
  184. EXPECT_TRUE(reader.PopInt64(&i));
  185. if (int_2 != i)
  186. return false;
  187. EXPECT_TRUE(reader.PopString(&str));
  188. if (str_3 != str)
  189. return false;
  190. return true;
  191. }
  192. // Pops items from the dbus message and compares them to the expected values.
  193. MATCHER_P5(ArgumentsAreStringStringsStringsStringBool,
  194. str_1,
  195. vec_2,
  196. vec_3,
  197. str_4,
  198. bool_5,
  199. "") {
  200. dbus::MessageReader reader(arg);
  201. std::string str;
  202. EXPECT_TRUE(reader.PopString(&str));
  203. if (str_1 != str)
  204. return false;
  205. std::vector<std::string> strings;
  206. EXPECT_TRUE(reader.PopArrayOfStrings(&strings));
  207. if (vec_2 != strings)
  208. return false;
  209. EXPECT_TRUE(reader.PopArrayOfStrings(&strings));
  210. if (vec_3 != strings)
  211. return false;
  212. EXPECT_TRUE(reader.PopString(&str));
  213. if (str_4 != str)
  214. return false;
  215. bool b;
  216. EXPECT_TRUE(reader.PopBool(&b));
  217. if (bool_5 != b)
  218. return false;
  219. return true;
  220. }
  221. MATCHER_P5(ArgumentsAreIntStringStringStringString,
  222. int_1,
  223. str_2,
  224. str_3,
  225. str_4,
  226. str_5,
  227. "") {
  228. dbus::MessageReader reader(arg);
  229. int32_t i;
  230. EXPECT_TRUE(reader.PopInt32(&i));
  231. if (int_1 != i)
  232. return false;
  233. std::string str;
  234. EXPECT_TRUE(reader.PopString(&str));
  235. if (str_2 != str)
  236. return false;
  237. EXPECT_TRUE(reader.PopString(&str));
  238. if (str_3 != str)
  239. return false;
  240. EXPECT_TRUE(reader.PopString(&str));
  241. if (str_4 != str)
  242. return false;
  243. EXPECT_TRUE(reader.PopString(&str));
  244. if (str_5 != str)
  245. return false;
  246. return true;
  247. }
  248. MATCHER_P3(ArgumentsAreIntBoolString, int_1, bool_2, str_3, "") {
  249. dbus::MessageReader reader(arg);
  250. int32_t i;
  251. EXPECT_TRUE(reader.PopInt32(&i));
  252. if (int_1 != i)
  253. return false;
  254. bool b;
  255. EXPECT_TRUE(reader.PopBool(&b));
  256. if (bool_2 != b)
  257. return false;
  258. std::string str;
  259. EXPECT_TRUE(reader.PopString(&str));
  260. if (str_3 != str)
  261. return false;
  262. return true;
  263. }
  264. TEST_P(KWalletDBusTest, StartWalletd) {
  265. EXPECT_CALL(
  266. *mock_session_bus_.get(),
  267. GetObjectProxy("org.kde.klauncher", dbus::ObjectPath("/KLauncher")))
  268. .WillOnce(Return(mock_klauncher_proxy_.get()));
  269. auto response = dbus::Response::CreateEmpty();
  270. dbus::MessageWriter writer(response.get());
  271. writer.AppendInt32(0); // return code
  272. writer.AppendString("dbus_name");
  273. writer.AppendString(std::string()); // error message
  274. writer.AppendInt32(100); // pid
  275. EXPECT_CALL(
  276. *mock_klauncher_proxy_.get(),
  277. CallMethodAndBlock(
  278. AllOf(Calls(kKLauncherInterface, "start_service_by_desktop_name"),
  279. ArgumentsAreStringStringsStringsStringBool(
  280. kwalletd_name_, std::vector<std::string>(),
  281. std::vector<std::string>(), std::string(), false)),
  282. _))
  283. .WillOnce(Return(ByMove(std::move(response))));
  284. EXPECT_TRUE(kwallet_dbus_.StartKWalletd());
  285. }
  286. TEST_P(KWalletDBusTest, StartWalletdErrorRead) {
  287. EXPECT_CALL(
  288. *mock_session_bus_.get(),
  289. GetObjectProxy("org.kde.klauncher", dbus::ObjectPath("/KLauncher")))
  290. .WillOnce(Return(mock_klauncher_proxy_.get()));
  291. EXPECT_CALL(
  292. *mock_klauncher_proxy_.get(),
  293. CallMethodAndBlock(
  294. Calls(kKLauncherInterface, "start_service_by_desktop_name"), _))
  295. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  296. EXPECT_FALSE(kwallet_dbus_.StartKWalletd());
  297. }
  298. TEST_P(KWalletDBusTest, StartWalletdErrorContact) {
  299. EXPECT_CALL(
  300. *mock_session_bus_.get(),
  301. GetObjectProxy("org.kde.klauncher", dbus::ObjectPath("/KLauncher")))
  302. .WillRepeatedly(Return(mock_klauncher_proxy_.get()));
  303. EXPECT_CALL(
  304. *mock_klauncher_proxy_.get(),
  305. CallMethodAndBlock(
  306. Calls(kKLauncherInterface, "start_service_by_desktop_name"), _))
  307. .WillOnce(Return(ByMove(nullptr)));
  308. EXPECT_FALSE(kwallet_dbus_.StartKWalletd());
  309. }
  310. TEST_P(KWalletDBusTest, IsEnabledTrue) {
  311. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  312. CallMethodAndBlock(Calls(kKWalletInterface, "isEnabled"), _))
  313. .WillOnce(Return(ByMove(RespondBool(true))));
  314. bool is_enabled = false;
  315. EXPECT_EQ(KWalletDBus::Error::SUCCESS, kwallet_dbus_.IsEnabled(&is_enabled));
  316. EXPECT_TRUE(is_enabled);
  317. }
  318. TEST_P(KWalletDBusTest, IsEnabledFalse) {
  319. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  320. CallMethodAndBlock(Calls(kKWalletInterface, "isEnabled"), _))
  321. .WillOnce(Return(ByMove(RespondBool(false))));
  322. bool is_enabled = true;
  323. EXPECT_EQ(KWalletDBus::Error::SUCCESS, kwallet_dbus_.IsEnabled(&is_enabled));
  324. EXPECT_FALSE(is_enabled);
  325. }
  326. TEST_P(KWalletDBusTest, IsEnabledErrorRead) {
  327. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  328. CallMethodAndBlock(Calls(kKWalletInterface, "isEnabled"), _))
  329. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  330. bool is_enabled = true;
  331. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  332. kwallet_dbus_.IsEnabled(&is_enabled));
  333. }
  334. TEST_P(KWalletDBusTest, IsEnabledErrorContact) {
  335. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  336. CallMethodAndBlock(Calls(kKWalletInterface, "isEnabled"), _))
  337. .WillOnce(Return(ByMove(nullptr)));
  338. bool is_enabled = true;
  339. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  340. kwallet_dbus_.IsEnabled(&is_enabled));
  341. }
  342. TEST_P(KWalletDBusTest, NetworkWallet) {
  343. EXPECT_CALL(
  344. *mock_kwallet_proxy_.get(),
  345. CallMethodAndBlock(Calls(kKWalletInterface, "networkWallet"), _))
  346. .WillOnce(Return(ByMove(RespondString("mock_wallet"))));
  347. std::string wallet;
  348. EXPECT_EQ(KWalletDBus::Error::SUCCESS, kwallet_dbus_.NetworkWallet(&wallet));
  349. EXPECT_EQ("mock_wallet", wallet);
  350. }
  351. TEST_P(KWalletDBusTest, NetworkWalletErrorRead) {
  352. EXPECT_CALL(
  353. *mock_kwallet_proxy_.get(),
  354. CallMethodAndBlock(Calls(kKWalletInterface, "networkWallet"), _))
  355. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  356. std::string wallet;
  357. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  358. kwallet_dbus_.NetworkWallet(&wallet));
  359. }
  360. TEST_P(KWalletDBusTest, NetworkWalletErrorContact) {
  361. EXPECT_CALL(
  362. *mock_kwallet_proxy_.get(),
  363. CallMethodAndBlock(Calls(kKWalletInterface, "networkWallet"), _))
  364. .WillOnce(Return(ByMove(nullptr)));
  365. std::string wallet;
  366. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  367. kwallet_dbus_.NetworkWallet(&wallet));
  368. }
  369. TEST_P(KWalletDBusTest, Open) {
  370. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  371. CallMethodAndBlock(
  372. AllOf(Calls(kKWalletInterface, "open"),
  373. ArgumentsAreStringInt64String("wallet", 0, "app")),
  374. _))
  375. .WillOnce(Return(ByMove(RespondInt32(1234))));
  376. int ret;
  377. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  378. kwallet_dbus_.Open("wallet", "app", &ret));
  379. EXPECT_EQ(1234, ret);
  380. }
  381. TEST_P(KWalletDBusTest, OpenErrorRead) {
  382. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  383. CallMethodAndBlock(Calls(kKWalletInterface, "open"), _))
  384. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  385. int ret;
  386. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  387. kwallet_dbus_.Open("wallet", "app", &ret));
  388. }
  389. TEST_P(KWalletDBusTest, OpenErrorContact) {
  390. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  391. CallMethodAndBlock(Calls(kKWalletInterface, "open"), _))
  392. .WillOnce(Return(ByMove(nullptr)));
  393. int ret;
  394. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  395. kwallet_dbus_.Open("wallet", "app", &ret));
  396. }
  397. TEST_P(KWalletDBusTest, HasEntry) {
  398. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  399. CallMethodAndBlock(AllOf(Calls(kKWalletInterface, "hasEntry"),
  400. ArgumentsAreIntStringStringString(
  401. 123, "folder", "realm", "app")),
  402. _))
  403. .WillOnce(Return(ByMove(RespondBool(true))));
  404. bool has_entry = false;
  405. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  406. kwallet_dbus_.HasEntry(123, "folder", "realm", "app", &has_entry));
  407. EXPECT_TRUE(has_entry);
  408. }
  409. TEST_P(KWalletDBusTest, HasEntryErrorRead) {
  410. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  411. CallMethodAndBlock(Calls(kKWalletInterface, "hasEntry"), _))
  412. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  413. bool has_entry = false;
  414. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  415. kwallet_dbus_.HasEntry(123, "folder", "realm", "app", &has_entry));
  416. }
  417. TEST_P(KWalletDBusTest, HasEntryErrorContact) {
  418. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  419. CallMethodAndBlock(Calls(kKWalletInterface, "hasEntry"), _))
  420. .WillOnce(Return(ByMove(nullptr)));
  421. bool has_entry = false;
  422. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  423. kwallet_dbus_.HasEntry(123, "folder", "realm", "app", &has_entry));
  424. }
  425. TEST_P(KWalletDBusTest, ReadEntry) {
  426. const std::vector<uint8_t> bytes_expected = {1, 2, 1, 2};
  427. EXPECT_CALL(
  428. *mock_kwallet_proxy_.get(),
  429. CallMethodAndBlock(AllOf(Calls(kKWalletInterface, "readEntry"),
  430. ArgumentsAreIntStringStringString(
  431. 123, "folder", "realm", "app")),
  432. _))
  433. .WillOnce(Return(ByMove(RespondBytes(bytes_expected))));
  434. std::vector<uint8_t> bytes;
  435. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  436. kwallet_dbus_.ReadEntry(123, "folder", "realm", "app", &bytes));
  437. EXPECT_EQ(bytes_expected, bytes);
  438. }
  439. TEST_P(KWalletDBusTest, ReadEntryErrorRead) {
  440. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  441. CallMethodAndBlock(Calls(kKWalletInterface, "readEntry"), _))
  442. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  443. std::vector<uint8_t> bytes;
  444. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  445. kwallet_dbus_.ReadEntry(123, "folder", "realm", "app", &bytes));
  446. }
  447. TEST_P(KWalletDBusTest, ReadEntryErrorContact) {
  448. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  449. CallMethodAndBlock(Calls(kKWalletInterface, "readEntry"), _))
  450. .WillOnce(Return(ByMove(nullptr)));
  451. std::vector<uint8_t> bytes;
  452. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  453. kwallet_dbus_.ReadEntry(123, "folder", "realm", "app", &bytes));
  454. }
  455. TEST_P(KWalletDBusTest, EntryList) {
  456. std::vector<std::string> strings_expected = {"one", "two"};
  457. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  458. CallMethodAndBlock(
  459. AllOf(Calls(kKWalletInterface, "entryList"),
  460. ArgumentsAreIntStringString(123, "folder", "app")),
  461. _))
  462. .WillOnce(Return(ByMove(RespondArrayOfStrings(strings_expected))));
  463. std::vector<std::string> strings;
  464. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  465. kwallet_dbus_.EntryList(123, "folder", "app", &strings));
  466. EXPECT_EQ(strings_expected, strings);
  467. }
  468. TEST_P(KWalletDBusTest, EntryListErrorRead) {
  469. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  470. CallMethodAndBlock(Calls(kKWalletInterface, "entryList"), _))
  471. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  472. std::vector<std::string> strings;
  473. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  474. kwallet_dbus_.EntryList(123, "folder", "app", &strings));
  475. }
  476. TEST_P(KWalletDBusTest, EntryListErrorContact) {
  477. std::vector<std::string> strings_expected = {"one", "two"};
  478. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  479. CallMethodAndBlock(Calls(kKWalletInterface, "entryList"), _))
  480. .WillOnce(Return(ByMove(nullptr)));
  481. std::vector<std::string> strings;
  482. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  483. kwallet_dbus_.EntryList(123, "folder", "app", &strings));
  484. }
  485. TEST_P(KWalletDBusTest, RemoveEntry) {
  486. EXPECT_CALL(
  487. *mock_kwallet_proxy_.get(),
  488. CallMethodAndBlock(AllOf(Calls(kKWalletInterface, "removeEntry"),
  489. ArgumentsAreIntStringStringString(
  490. 123, "folder", "realm", "app")),
  491. _))
  492. .WillOnce(Return(ByMove(RespondInt32(0))));
  493. int ret;
  494. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  495. kwallet_dbus_.RemoveEntry(123, "folder", "realm", "app", &ret));
  496. EXPECT_EQ(0, ret);
  497. }
  498. TEST_P(KWalletDBusTest, RemoveEntryErrorRead) {
  499. EXPECT_CALL(
  500. *mock_kwallet_proxy_.get(),
  501. CallMethodAndBlock(Calls(kKWalletInterface, "removeEntry"), _))
  502. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  503. int ret;
  504. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  505. kwallet_dbus_.RemoveEntry(123, "folder", "realm", "app", &ret));
  506. }
  507. TEST_P(KWalletDBusTest, RemoveEntryErrorContact) {
  508. EXPECT_CALL(
  509. *mock_kwallet_proxy_.get(),
  510. CallMethodAndBlock(Calls(kKWalletInterface, "removeEntry"), _))
  511. .WillOnce(Return(ByMove(nullptr)));
  512. int ret;
  513. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  514. kwallet_dbus_.RemoveEntry(123, "folder", "realm", "app", &ret));
  515. }
  516. TEST_P(KWalletDBusTest, WriteEntry) {
  517. std::vector<uint8_t> bytes = {1, 2, 3, 1};
  518. EXPECT_CALL(
  519. *mock_kwallet_proxy_.get(),
  520. CallMethodAndBlock(AllOf(Calls(kKWalletInterface, "writeEntry"),
  521. ArgumentsAreIntStringStringBytesString(
  522. 123, "folder", "realm", bytes, "app")),
  523. _))
  524. .WillOnce(Return(ByMove(RespondInt32(0))));
  525. int ret;
  526. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  527. kwallet_dbus_.WriteEntry(123, "folder", "realm", "app",
  528. bytes.data(), bytes.size(), &ret));
  529. EXPECT_EQ(0, ret);
  530. }
  531. TEST_P(KWalletDBusTest, WriteEntryErrorRead) {
  532. std::vector<uint8_t> bytes = {1, 2, 3, 1};
  533. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  534. CallMethodAndBlock(Calls(kKWalletInterface, "writeEntry"), _))
  535. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  536. int ret;
  537. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  538. kwallet_dbus_.WriteEntry(123, "folder", "realm", "app",
  539. bytes.data(), bytes.size(), &ret));
  540. }
  541. TEST_P(KWalletDBusTest, WriteEntryErrorContact) {
  542. std::vector<uint8_t> bytes = {1, 2, 3, 1};
  543. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  544. CallMethodAndBlock(Calls(kKWalletInterface, "writeEntry"), _))
  545. .WillOnce(Return(ByMove(nullptr)));
  546. int ret;
  547. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  548. kwallet_dbus_.WriteEntry(123, "folder", "realm", "app",
  549. bytes.data(), bytes.size(), &ret));
  550. }
  551. TEST_P(KWalletDBusTest, HasFolder) {
  552. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  553. CallMethodAndBlock(
  554. AllOf(Calls(kKWalletInterface, "hasFolder"),
  555. ArgumentsAreIntStringString(123, "wallet", "app")),
  556. _))
  557. .WillOnce(Return(ByMove(RespondBool(true))));
  558. bool has_folder = false;
  559. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  560. kwallet_dbus_.HasFolder(123, "wallet", "app", &has_folder));
  561. EXPECT_EQ(true, has_folder);
  562. }
  563. TEST_P(KWalletDBusTest, HasFolderErrorRead) {
  564. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  565. CallMethodAndBlock(Calls(kKWalletInterface, "hasFolder"), _))
  566. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  567. bool has_folder = false;
  568. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  569. kwallet_dbus_.HasFolder(123, "wallet", "app", &has_folder));
  570. }
  571. TEST_P(KWalletDBusTest, HasFolderErrorContact) {
  572. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  573. CallMethodAndBlock(Calls(kKWalletInterface, "hasFolder"), _))
  574. .WillOnce(Return(ByMove(nullptr)));
  575. bool has_folder = false;
  576. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  577. kwallet_dbus_.HasFolder(123, "wallet", "app", &has_folder));
  578. }
  579. TEST_P(KWalletDBusTest, CreateFolder) {
  580. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  581. CallMethodAndBlock(
  582. AllOf(Calls(kKWalletInterface, "createFolder"),
  583. ArgumentsAreIntStringString(123, "folder", "app")),
  584. _))
  585. .WillOnce(Return(ByMove(RespondBool(true))));
  586. bool created_folder = false;
  587. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  588. kwallet_dbus_.CreateFolder(123, "folder", "app", &created_folder));
  589. EXPECT_EQ(true, created_folder);
  590. }
  591. TEST_P(KWalletDBusTest, CreateFolderErrorRead) {
  592. EXPECT_CALL(
  593. *mock_kwallet_proxy_.get(),
  594. CallMethodAndBlock(Calls(kKWalletInterface, "createFolder"), _))
  595. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  596. bool created_folder = false;
  597. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  598. kwallet_dbus_.CreateFolder(123, "folder", "app", &created_folder));
  599. }
  600. TEST_P(KWalletDBusTest, CreateFolderErrorContact) {
  601. EXPECT_CALL(
  602. *mock_kwallet_proxy_.get(),
  603. CallMethodAndBlock(Calls(kKWalletInterface, "createFolder"), _))
  604. .WillOnce(Return(ByMove(nullptr)));
  605. bool created_folder = false;
  606. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  607. kwallet_dbus_.CreateFolder(123, "folder", "app", &created_folder));
  608. }
  609. TEST_P(KWalletDBusTest, WritePassword) {
  610. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  611. CallMethodAndBlock(
  612. AllOf(Calls(kKWalletInterface, "writePassword"),
  613. ArgumentsAreIntStringStringStringString(
  614. 123, "folder", "key", "password", "app")),
  615. _))
  616. .WillOnce(Return(ByMove(RespondInt32(0))));
  617. bool write_success = false;
  618. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  619. kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
  620. &write_success));
  621. EXPECT_TRUE(write_success);
  622. }
  623. TEST_P(KWalletDBusTest, WritePasswordRejected) {
  624. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  625. CallMethodAndBlock(
  626. AllOf(Calls(kKWalletInterface, "writePassword"),
  627. ArgumentsAreIntStringStringStringString(
  628. 123, "folder", "key", "password", "app")),
  629. _))
  630. .WillOnce(Return(ByMove(RespondInt32(-1))));
  631. bool write_success = true;
  632. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  633. kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
  634. &write_success));
  635. EXPECT_FALSE(write_success);
  636. }
  637. TEST_P(KWalletDBusTest, WritePasswordErrorRead) {
  638. EXPECT_CALL(
  639. *mock_kwallet_proxy_.get(),
  640. CallMethodAndBlock(Calls(kKWalletInterface, "writePassword"), _))
  641. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  642. bool write_success = false;
  643. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  644. kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
  645. &write_success));
  646. }
  647. TEST_P(KWalletDBusTest, WritePasswordErrorContact) {
  648. EXPECT_CALL(
  649. *mock_kwallet_proxy_.get(),
  650. CallMethodAndBlock(Calls(kKWalletInterface, "writePassword"), _))
  651. .WillOnce(Return(ByMove(nullptr)));
  652. bool write_success = false;
  653. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  654. kwallet_dbus_.WritePassword(123, "folder", "key", "password", "app",
  655. &write_success));
  656. }
  657. TEST_P(KWalletDBusTest, ReadPassword) {
  658. EXPECT_CALL(
  659. *mock_kwallet_proxy_.get(),
  660. CallMethodAndBlock(
  661. AllOf(Calls(kKWalletInterface, "readPassword"),
  662. ArgumentsAreIntStringStringString(123, "folder", "key", "app")),
  663. _))
  664. .WillOnce(Return(ByMove(RespondString("password"))));
  665. absl::optional<std::string> password;
  666. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  667. kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
  668. EXPECT_TRUE(password.has_value());
  669. EXPECT_EQ("password", password.value());
  670. }
  671. TEST_P(KWalletDBusTest, ReadPasswordErrorRead) {
  672. EXPECT_CALL(
  673. *mock_kwallet_proxy_.get(),
  674. CallMethodAndBlock(Calls(kKWalletInterface, "readPassword"), _))
  675. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  676. absl::optional<std::string> password;
  677. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  678. kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
  679. EXPECT_FALSE(password.has_value());
  680. }
  681. TEST_P(KWalletDBusTest, ReadPasswordErrorContact) {
  682. EXPECT_CALL(
  683. *mock_kwallet_proxy_.get(),
  684. CallMethodAndBlock(Calls(kKWalletInterface, "readPassword"), _))
  685. .WillOnce(Return(ByMove(nullptr)));
  686. absl::optional<std::string> password;
  687. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  688. kwallet_dbus_.ReadPassword(123, "folder", "key", "app", &password));
  689. EXPECT_FALSE(password.has_value());
  690. }
  691. TEST_P(KWalletDBusTest, CloseSuccess) {
  692. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  693. CallMethodAndBlock(
  694. AllOf(Calls(kKWalletInterface, "close"),
  695. ArgumentsAreIntBoolString(123, false, "app")),
  696. _))
  697. .WillOnce(Return(ByMove(RespondInt32(0))));
  698. bool success = false;
  699. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  700. kwallet_dbus_.Close(123, false, "app", &success));
  701. EXPECT_TRUE(success);
  702. }
  703. TEST_P(KWalletDBusTest, CloseUnsuccessful) {
  704. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  705. CallMethodAndBlock(
  706. AllOf(Calls(kKWalletInterface, "close"),
  707. ArgumentsAreIntBoolString(123, false, "app")),
  708. _))
  709. .WillOnce(Return(ByMove(RespondInt32(1))));
  710. bool success = true;
  711. EXPECT_EQ(KWalletDBus::Error::SUCCESS,
  712. kwallet_dbus_.Close(123, false, "app", &success));
  713. EXPECT_FALSE(success);
  714. }
  715. TEST_P(KWalletDBusTest, CloseErrorRead) {
  716. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  717. CallMethodAndBlock(Calls(kKWalletInterface, "close"), _))
  718. .WillOnce(Return(ByMove(dbus::Response::CreateEmpty())));
  719. bool success = true;
  720. EXPECT_EQ(KWalletDBus::Error::CANNOT_READ,
  721. kwallet_dbus_.Close(123, false, "app", &success));
  722. }
  723. TEST_P(KWalletDBusTest, CloseErrorContact) {
  724. EXPECT_CALL(*mock_kwallet_proxy_.get(),
  725. CallMethodAndBlock(Calls(kKWalletInterface, "close"), _))
  726. .WillOnce(Return(ByMove(nullptr)));
  727. bool success = true;
  728. EXPECT_EQ(KWalletDBus::Error::CANNOT_CONTACT,
  729. kwallet_dbus_.Close(123, false, "app", &success));
  730. }
  731. } // namespace