ceph/src/test/rbd_mirror/image_replayer/test_mock_PrepareRemoteImageRequest.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "test/rbd_mirror/test_mock_fixture.h"
   5 #include "cls/rbd/cls_rbd_types.h"
   6 #include "librbd/journal/TypeTraits.h"
   7 #include "tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.h"
   8 #include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
   9 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
  10 #include "test/librbd/mock/MockImageCtx.h"
  11
  12 namespace librbd {
  13
  14 namespace {
  15
  16 struct MockTestImageCtx : public librbd::MockImageCtx {
  17   MockTestImageCtx(librbd::ImageCtx &image_ctx)
  18     : librbd::MockImageCtx(image_ctx) {
  19   }
  20 };
  21
  22 } // anonymous namespace
  23 } // namespace librbd
  24
  25 namespace rbd {
  26 namespace mirror {
  27 namespace image_replayer {
  28
  29 template <>
  30 struct GetMirrorImageIdRequest<librbd::MockTestImageCtx> {
  31   static GetMirrorImageIdRequest* s_instance;
  32   std::string* image_id = nullptr;
  33   Context* on_finish = nullptr;
  34
  35   static GetMirrorImageIdRequest* create(librados::IoCtx& io_ctx,
  36                                          const std::string& global_image_id,
  37                                          std::string* image_id,
  38                                          Context* on_finish) {
  39     assert(s_instance != nullptr);
  40     s_instance->image_id = image_id;
  41     s_instance->on_finish = on_finish;
  42     return s_instance;
  43   }
  44
  45   GetMirrorImageIdRequest() {
  46     s_instance = this;
  47   }
  48
  49   MOCK_METHOD0(send, void());
  50 };
  51
  52 GetMirrorImageIdRequest<librbd::MockTestImageCtx>* GetMirrorImageIdRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
  53
  54 } // namespace image_replayer
  55 } // namespace mirror
  56 } // namespace rbd
  57
  58 // template definitions
  59 #include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc"
  60
  61 namespace rbd {
  62 namespace mirror {
  63 namespace image_replayer {
  64
  65 using ::testing::_;
  66 using ::testing::DoAll;
  67 using ::testing::InSequence;
  68 using ::testing::Invoke;
  69 using ::testing::Return;
  70 using ::testing::StrEq;
  71 using ::testing::WithArg;
  72
  73 class TestMockImageReplayerPrepareRemoteImageRequest : public TestMockFixture {
  74 public:
  75   typedef PrepareRemoteImageRequest<librbd::MockTestImageCtx> MockPrepareRemoteImageRequest;
  76   typedef GetMirrorImageIdRequest<librbd::MockTestImageCtx> MockGetMirrorImageIdRequest;
  77
  78   void expect_get_mirror_image_id(MockGetMirrorImageIdRequest& mock_get_mirror_image_id_request,
  79                                   const std::string& image_id, int r) {
  80     EXPECT_CALL(mock_get_mirror_image_id_request, send())
  81       .WillOnce(Invoke([&mock_get_mirror_image_id_request, image_id, r]() {
  82                   *mock_get_mirror_image_id_request.image_id = image_id;
  83                   mock_get_mirror_image_id_request.on_finish->complete(r);
  84                 }));
  85   }
  86
  87   void expect_mirror_uuid_get(librados::IoCtx &io_ctx,
  88                               const std::string &mirror_uuid, int r) {
  89     bufferlist bl;
  90     ::encode(mirror_uuid, bl);
  91
  92     EXPECT_CALL(get_mock_io_ctx(io_ctx),
  93                 exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_uuid_get"), _, _, _))
  94       .WillOnce(DoAll(WithArg<5>(Invoke([bl](bufferlist *out_bl) {
  95                                           *out_bl = bl;
  96                                         })),
  97                       Return(r)));
  98   }
  99 };
 100
 101 TEST_F(TestMockImageReplayerPrepareRemoteImageRequest, Success) {
 102   InSequence seq;
 103   expect_mirror_uuid_get(m_remote_io_ctx, "remote mirror uuid", 0);
 104   MockGetMirrorImageIdRequest mock_get_mirror_image_id_request;
 105   expect_get_mirror_image_id(mock_get_mirror_image_id_request,
 106                              "remote image id", 0);
 107
 108   std::string remote_mirror_uuid;
 109   std::string remote_image_id;
 110   C_SaferCond ctx;
 111   auto req = MockPrepareRemoteImageRequest::create(m_remote_io_ctx,
 112                                                    "global image id",
 113                                                    &remote_mirror_uuid,
 114                                                    &remote_image_id,
 115                                                    &ctx);
 116   req->send();
 117
 118   ASSERT_EQ(0, ctx.wait());
 119   ASSERT_EQ(std::string("remote mirror uuid"), remote_mirror_uuid);
 120   ASSERT_EQ(std::string("remote image id"), remote_image_id);
 121 }
 122
 123 TEST_F(TestMockImageReplayerPrepareRemoteImageRequest, MirrorUuidError) {
 124   InSequence seq;
 125   expect_mirror_uuid_get(m_remote_io_ctx, "", -EINVAL);
 126
 127   std::string remote_mirror_uuid;
 128   std::string remote_image_id;
 129   C_SaferCond ctx;
 130   auto req = MockPrepareRemoteImageRequest::create(m_remote_io_ctx,
 131                                                    "global image id",
 132                                                    &remote_mirror_uuid,
 133                                                    &remote_image_id,
 134                                                    &ctx);
 135   req->send();
 136
 137   ASSERT_EQ(-EINVAL, ctx.wait());
 138   ASSERT_EQ(std::string(""), remote_mirror_uuid);
 139 }
 140
 141 TEST_F(TestMockImageReplayerPrepareRemoteImageRequest, MirrorImageIdError) {
 142   InSequence seq;
 143   expect_mirror_uuid_get(m_remote_io_ctx, "remote mirror uuid", 0);
 144   MockGetMirrorImageIdRequest mock_get_mirror_image_id_request;
 145   expect_get_mirror_image_id(mock_get_mirror_image_id_request, "", -EINVAL);
 146
 147   std::string remote_mirror_uuid;
 148   std::string remote_image_id;
 149   C_SaferCond ctx;
 150   auto req = MockPrepareRemoteImageRequest::create(m_remote_io_ctx,
 151                                                    "global image id",
 152                                                    &remote_mirror_uuid,
 153                                                    &remote_image_id,
 154                                                    &ctx);
 155   req->send();
 156
 157   ASSERT_EQ(-EINVAL, ctx.wait());
 158   ASSERT_EQ(std::string("remote mirror uuid"), remote_mirror_uuid);
 159 }
 160
 161 } // namespace image_replayer
 162 } // namespace mirror
 163 } // namespace rbd