xref: /openbmc/estoraged/src/test/estoraged_test.cpp (revision c0d66eb78bdeaf8e9689b1ed07f819a5984aecf0)
1  #include "estoraged_test.hpp"
2  
3  #include "estoraged.hpp"
4  #include "estoraged_conf.hpp"
5  
6  #include <unistd.h>
7  
8  #include <boost/asio/io_context.hpp>
9  #include <sdbusplus/asio/connection.hpp>
10  #include <sdbusplus/asio/object_server.hpp>
11  #include <xyz/openbmc_project/Common/error.hpp>
12  #include <xyz/openbmc_project/Inventory/Item/Volume/server.hpp>
13  
14  #include <exception>
15  #include <filesystem>
16  #include <fstream>
17  #include <iterator>
18  #include <memory>
19  #include <string>
20  #include <vector>
21  
22  #include <gmock/gmock.h>
23  #include <gtest/gtest.h>
24  
25  namespace estoraged_test
26  {
27  
28  using sdbusplus::server::xyz::openbmc_project::inventory::item::Volume;
29  using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
30  using sdbusplus::xyz::openbmc_project::Common::Error::ResourceNotFound;
31  using std::filesystem::path;
32  using ::testing::_;
33  using ::testing::Return;
34  using ::testing::StrEq;
35  
36  class EStoragedTest : public testing::Test
37  {
38    public:
39      const char* testFileName = "testfile";
40      const char* testLuksDevName = "testfile_luksDev";
41      const char* testCryptDir = "/tmp";
42      const std::string testConfigPath =
43          "/xyz/openbmc_project/inventory/system/board/test_board/test_emmc";
44      const uint64_t testSize = 24;
45      const uint8_t testLifeTime = 25;
46      const std::string testPartNumber = "12345678";
47      const std::string testSerialNumber = "ABCDEF1234";
48      const std::string testLocationCode = "U102020";
49      const std::string testDriveType = "SSD";
50      const std::string testDriveProtocol = "eMMC";
51      std::ofstream testFile;
52      std::string passwordString;
53      std::vector<uint8_t> password;
54      MockCryptsetupInterface* mockCryptIface{};
55      MockFilesystemInterface* mockFsIface{};
56      boost::asio::io_context io;
57      std::shared_ptr<sdbusplus::asio::connection> conn;
58      std::unique_ptr<sdbusplus::asio::object_server> objectServer;
59      std::unique_ptr<estoraged::EStoraged> esObject;
60  
EStoragedTest()61      EStoragedTest() :
62          passwordString("password"),
63          password(passwordString.begin(), passwordString.end())
64      {}
65  
SetUp()66      void SetUp() override
67      {
68          /* Create an empty file that we'll pretend is a 'storage device'. */
69          testFile.open(testFileName,
70                        std::ios::out | std::ios::binary | std::ios::trunc);
71          testFile.close();
72          if (testFile.fail())
73          {
74              throw std::runtime_error("Failed to open test file");
75          }
76  
77          std::unique_ptr<MockCryptsetupInterface> cryptIface =
78              std::make_unique<MockCryptsetupInterface>();
79          mockCryptIface = cryptIface.get();
80          std::unique_ptr<MockFilesystemInterface> fsIface =
81              std::make_unique<MockFilesystemInterface>();
82          mockFsIface = fsIface.get();
83  
84          /* Set up location of dummy mapped crypt file. */
85          EXPECT_CALL(*cryptIface, cryptGetDir).WillOnce(Return(testCryptDir));
86  
87          conn = std::make_shared<sdbusplus::asio::connection>(io);
88          // request D-Bus server name.
89          conn->request_name("xyz.openbmc_project.eStoraged.test");
90          objectServer = std::make_unique<sdbusplus::asio::object_server>(conn);
91  
92          esObject = std::make_unique<estoraged::EStoraged>(
93              *objectServer, testConfigPath, testFileName, testLuksDevName,
94              testSize, testLifeTime, testPartNumber, testSerialNumber,
95              testLocationCode, ERASE_MAX_GEOMETRY, ERASE_MIN_GEOMETRY,
96              testDriveType, testDriveProtocol, std::move(cryptIface),
97              std::move(fsIface));
98      }
99  
TearDown()100      void TearDown() override
101      {
102          EXPECT_EQ(0, unlink(testFileName));
103      }
104  };
105  
106  const char* mappedDevicePath = "/tmp/testfile_luksDev";
107  std::ofstream mappedDevice;
108  
createMappedDev()109  int createMappedDev()
110  {
111      mappedDevice.open(mappedDevicePath,
112                        std::ios::out | std::ios::binary | std::ios::trunc);
113      mappedDevice.close();
114      if (mappedDevice.fail())
115      {
116          throw std::runtime_error("Failed to open test mapped device");
117      }
118  
119      return 0;
120  }
121  
removeMappedDev()122  int removeMappedDev()
123  {
124      EXPECT_EQ(0, unlink(mappedDevicePath));
125  
126      return 0;
127  }
128  
129  /* Test case to format and then lock the LUKS device. */
TEST_F(EStoragedTest,FormatPass)130  TEST_F(EStoragedTest, FormatPass)
131  {
132      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
133  
134      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
135          .Times(1);
136  
137      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
138  
139      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
140          .WillOnce(&createMappedDev);
141  
142      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
143          .WillOnce(Return(0));
144  
145      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
146          .WillOnce(Return(false));
147  
148      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
149          .WillOnce(Return(true));
150  
151      EXPECT_CALL(*mockFsIface,
152                  doMount(StrEq(esObject->getCryptDevicePath()),
153                          StrEq(esObject->getMountPoint()), _, _, _))
154          .WillOnce(Return(0));
155  
156      EXPECT_CALL(*mockFsIface, doUnmount(StrEq(esObject->getMountPoint())))
157          .WillOnce(Return(0));
158  
159      EXPECT_CALL(*mockFsIface, removeDirectory(path(esObject->getMountPoint())))
160          .WillOnce(Return(true));
161  
162      EXPECT_CALL(*mockCryptIface, cryptDeactivate(_, _))
163          .WillOnce(&removeMappedDev);
164  
165      /* Format the encrypted device. */
166      esObject->formatLuks(password, Volume::FilesystemType::ext4);
167      EXPECT_FALSE(esObject->isLocked());
168  
169      esObject->lock();
170      EXPECT_TRUE(esObject->isLocked());
171  }
172  
173  /*
174   * Test case where the mount point directory already exists, so it shouldn't
175   * try to create it.
176   */
TEST_F(EStoragedTest,MountPointExistsPass)177  TEST_F(EStoragedTest, MountPointExistsPass)
178  {
179      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
180  
181      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
182          .Times(1);
183  
184      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
185  
186      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
187          .WillOnce(&createMappedDev);
188  
189      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
190          .WillOnce(Return(0));
191  
192      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
193          .WillOnce(Return(true));
194  
195      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
196          .Times(0);
197  
198      EXPECT_CALL(*mockFsIface,
199                  doMount(StrEq(esObject->getCryptDevicePath()),
200                          StrEq(esObject->getMountPoint()), _, _, _))
201          .WillOnce(Return(0));
202  
203      EXPECT_CALL(*mockFsIface, doUnmount(StrEq(esObject->getMountPoint())))
204          .WillOnce(Return(0));
205  
206      EXPECT_CALL(*mockFsIface, removeDirectory(path(esObject->getMountPoint())))
207          .WillOnce(Return(true));
208  
209      EXPECT_CALL(*mockCryptIface, cryptDeactivate(_, _))
210          .WillOnce(&removeMappedDev);
211  
212      /* Format the encrypted device. */
213      esObject->formatLuks(password, Volume::FilesystemType::ext4);
214      EXPECT_FALSE(esObject->isLocked());
215  
216      esObject->lock();
217      EXPECT_TRUE(esObject->isLocked());
218  }
219  
220  /* Test case where the device/file doesn't exist. */
TEST_F(EStoragedTest,FormatNoDeviceFail)221  TEST_F(EStoragedTest, FormatNoDeviceFail)
222  {
223      /* Delete the test file. */
224      EXPECT_EQ(0, unlink(testFileName));
225  
226      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
227                   ResourceNotFound);
228      EXPECT_TRUE(esObject->isLocked());
229  
230      /* Create the test file again, so that the TearDown function works. */
231      testFile.open(testFileName,
232                    std::ios::out | std::ios::binary | std::ios::trunc);
233      testFile.close();
234  }
235  
236  /* Test case where we fail to format the LUKS device. */
TEST_F(EStoragedTest,FormatFail)237  TEST_F(EStoragedTest, FormatFail)
238  {
239      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _))
240          .WillOnce(Return(-1));
241  
242      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
243                   InternalFailure);
244      EXPECT_TRUE(esObject->isLocked());
245  }
246  
247  /* Test case where we fail to set the password for the LUKS device. */
TEST_F(EStoragedTest,AddKeyslotFail)248  TEST_F(EStoragedTest, AddKeyslotFail)
249  {
250      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
251  
252      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
253          .WillOnce(Return(-1));
254  
255      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
256                   InternalFailure);
257      EXPECT_TRUE(esObject->isLocked());
258  }
259  
260  /* Test case where we fail to load the LUKS header. */
TEST_F(EStoragedTest,LoadLuksHeaderFail)261  TEST_F(EStoragedTest, LoadLuksHeaderFail)
262  {
263      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
264  
265      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
266          .Times(1);
267  
268      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).WillOnce(Return(-1));
269  
270      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
271                   InternalFailure);
272      EXPECT_TRUE(esObject->isLocked());
273  }
274  
275  /* Test case where we fail to activate the LUKS device. */
TEST_F(EStoragedTest,ActivateFail)276  TEST_F(EStoragedTest, ActivateFail)
277  {
278      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
279  
280      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
281          .Times(1);
282  
283      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
284  
285      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
286          .WillOnce(Return(-1));
287  
288      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
289                   InternalFailure);
290      EXPECT_TRUE(esObject->isLocked());
291  }
292  
293  /* Test case where we fail to create the filesystem. */
TEST_F(EStoragedTest,CreateFilesystemFail)294  TEST_F(EStoragedTest, CreateFilesystemFail)
295  {
296      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
297  
298      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
299          .Times(1);
300  
301      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
302  
303      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
304          .WillOnce(&createMappedDev);
305  
306      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
307          .WillOnce(Return(-1));
308  
309      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
310                   InternalFailure);
311      EXPECT_FALSE(esObject->isLocked());
312  
313      EXPECT_EQ(0, removeMappedDev());
314  }
315  
316  /* Test case where we fail to create the mount point. */
TEST_F(EStoragedTest,CreateMountPointFail)317  TEST_F(EStoragedTest, CreateMountPointFail)
318  {
319      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
320  
321      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
322          .Times(1);
323  
324      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
325  
326      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
327          .WillOnce(&createMappedDev);
328  
329      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
330          .WillOnce(Return(0));
331  
332      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
333          .WillOnce(Return(false));
334  
335      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
336          .WillOnce(Return(false));
337  
338      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
339                   InternalFailure);
340      EXPECT_FALSE(esObject->isLocked());
341  
342      EXPECT_EQ(0, removeMappedDev());
343  }
344  
345  /* Test case where we fail to mount the filesystem. */
TEST_F(EStoragedTest,MountFail)346  TEST_F(EStoragedTest, MountFail)
347  {
348      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
349  
350      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
351          .Times(1);
352  
353      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
354  
355      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
356          .WillOnce(&createMappedDev);
357  
358      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
359          .WillOnce(Return(0));
360  
361      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
362          .WillOnce(Return(false));
363  
364      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
365          .WillOnce(Return(true));
366  
367      EXPECT_CALL(*mockFsIface,
368                  doMount(StrEq(esObject->getCryptDevicePath()),
369                          StrEq(esObject->getMountPoint()), _, _, _))
370          .WillOnce(Return(-1));
371  
372      EXPECT_CALL(*mockFsIface, removeDirectory(path(esObject->getMountPoint())))
373          .WillOnce(Return(true));
374  
375      EXPECT_THROW(esObject->formatLuks(password, Volume::FilesystemType::ext4),
376                   InternalFailure);
377      EXPECT_FALSE(esObject->isLocked());
378  
379      EXPECT_EQ(0, removeMappedDev());
380  }
381  
382  /* Test case where we fail to unmount the filesystem. */
TEST_F(EStoragedTest,UnmountFail)383  TEST_F(EStoragedTest, UnmountFail)
384  {
385      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
386  
387      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
388          .Times(1);
389  
390      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
391  
392      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
393          .WillOnce(&createMappedDev);
394  
395      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
396          .WillOnce(Return(0));
397  
398      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
399          .WillOnce(Return(false));
400  
401      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
402          .WillOnce(Return(true));
403  
404      EXPECT_CALL(*mockFsIface,
405                  doMount(StrEq(esObject->getCryptDevicePath()),
406                          StrEq(esObject->getMountPoint()), _, _, _))
407          .WillOnce(Return(0));
408  
409      EXPECT_CALL(*mockFsIface, doUnmount(StrEq(esObject->getMountPoint())))
410          .WillOnce(Return(-1));
411  
412      esObject->formatLuks(password, Volume::FilesystemType::ext4);
413      EXPECT_FALSE(esObject->isLocked());
414  
415      EXPECT_THROW(esObject->lock(), InternalFailure);
416      EXPECT_FALSE(esObject->isLocked());
417  
418      EXPECT_EQ(0, removeMappedDev());
419  }
420  
421  /* Test case where we fail to remove the mount point. */
TEST_F(EStoragedTest,RemoveMountPointFail)422  TEST_F(EStoragedTest, RemoveMountPointFail)
423  {
424      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
425  
426      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
427          .Times(1);
428  
429      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
430  
431      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
432          .WillOnce(&createMappedDev);
433  
434      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
435          .WillOnce(Return(0));
436  
437      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
438          .WillOnce(Return(false));
439  
440      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
441          .WillOnce(Return(true));
442  
443      EXPECT_CALL(*mockFsIface,
444                  doMount(StrEq(esObject->getCryptDevicePath()),
445                          StrEq(esObject->getMountPoint()), _, _, _))
446          .WillOnce(Return(0));
447  
448      EXPECT_CALL(*mockFsIface, doUnmount(StrEq(esObject->getMountPoint())))
449          .WillOnce(Return(0));
450  
451      EXPECT_CALL(*mockFsIface, removeDirectory(path(esObject->getMountPoint())))
452          .WillOnce(Return(false));
453  
454      esObject->formatLuks(password, Volume::FilesystemType::ext4);
455      EXPECT_FALSE(esObject->isLocked());
456  
457      /* This will fail to remove the mount point. */
458      EXPECT_THROW(esObject->lock(), InternalFailure);
459      EXPECT_FALSE(esObject->isLocked());
460  
461      EXPECT_EQ(0, removeMappedDev());
462  }
463  
464  /* Test case where we fail to deactivate the LUKS device. */
TEST_F(EStoragedTest,DeactivateFail)465  TEST_F(EStoragedTest, DeactivateFail)
466  {
467      EXPECT_CALL(*mockCryptIface, cryptFormat(_, _, _, _, _, _, _, _)).Times(1);
468  
469      EXPECT_CALL(*mockCryptIface, cryptKeyslotAddByVolumeKey(_, _, _, _, _, _))
470          .Times(1);
471  
472      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
473  
474      EXPECT_CALL(*mockCryptIface, cryptActivateByPassphrase(_, _, _, _, _, _))
475          .WillOnce(&createMappedDev);
476  
477      EXPECT_CALL(*mockFsIface, runMkfs(StrEq(esObject->getCryptDevicePath())))
478          .WillOnce(Return(0));
479  
480      EXPECT_CALL(*mockFsIface, directoryExists(path(esObject->getMountPoint())))
481          .WillOnce(Return(false));
482  
483      EXPECT_CALL(*mockFsIface, createDirectory(path(esObject->getMountPoint())))
484          .WillOnce(Return(true));
485  
486      EXPECT_CALL(*mockFsIface,
487                  doMount(StrEq(esObject->getCryptDevicePath()),
488                          StrEq(esObject->getMountPoint()), _, _, _))
489          .WillOnce(Return(0));
490  
491      EXPECT_CALL(*mockFsIface, doUnmount(StrEq(esObject->getMountPoint())))
492          .WillOnce(Return(0));
493  
494      EXPECT_CALL(*mockFsIface, removeDirectory(path(esObject->getMountPoint())))
495          .WillOnce(Return(true));
496  
497      EXPECT_CALL(*mockCryptIface, cryptDeactivate(_, _)).WillOnce(Return(-1));
498  
499      /* Format the encrypted device. */
500      esObject->formatLuks(password, Volume::FilesystemType::ext4);
501      EXPECT_FALSE(esObject->isLocked());
502  
503      EXPECT_THROW(esObject->lock(), InternalFailure);
504      EXPECT_FALSE(esObject->isLocked());
505  
506      EXPECT_EQ(0, removeMappedDev());
507  }
508  
509  /* Test case where we successfully change the password. */
TEST_F(EStoragedTest,ChangePasswordSuccess)510  TEST_F(EStoragedTest, ChangePasswordSuccess)
511  {
512      std::string newPasswordString("newPassword");
513      std::vector<uint8_t> newPassword(newPasswordString.begin(),
514                                       newPasswordString.end());
515  
516      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
517  
518      EXPECT_CALL(*mockCryptIface,
519                  cryptKeyslotChangeByPassphrase(
520                      _, _, _, reinterpret_cast<const char*>(password.data()),
521                      password.size(),
522                      reinterpret_cast<const char*>(newPassword.data()),
523                      newPassword.size()))
524          .WillOnce(Return(0));
525  
526      /* Change the password for the LUKS-encrypted device. */
527      esObject->changePassword(password, newPassword);
528  }
529  
530  /* Test case where we fail to change the password. */
TEST_F(EStoragedTest,ChangePasswordFail)531  TEST_F(EStoragedTest, ChangePasswordFail)
532  {
533      std::string newPasswordString("newPassword");
534      std::vector<uint8_t> newPassword(newPasswordString.begin(),
535                                       newPasswordString.end());
536  
537      EXPECT_CALL(*mockCryptIface, cryptLoad(_, _, _)).Times(1);
538  
539      EXPECT_CALL(*mockCryptIface,
540                  cryptKeyslotChangeByPassphrase(
541                      _, _, _, reinterpret_cast<const char*>(password.data()),
542                      password.size(),
543                      reinterpret_cast<const char*>(newPassword.data()),
544                      newPassword.size()))
545          .WillOnce(Return(-1));
546  
547      EXPECT_THROW(esObject->changePassword(password, newPassword),
548                   InternalFailure);
549  }
550  
551  } // namespace estoraged_test
552