ceph/src/test/librbd/journal/test_mock_OpenRequest.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/librbd/test_mock_fixture.h"
   5 #include "test/librbd/test_support.h"
   6 #include "test/librbd/mock/MockImageCtx.h"
   7 #include "test/journal/mock/MockJournaler.h"
   8 #include "common/ceph_mutex.h"
   9 #include "cls/journal/cls_journal_types.h"
  10 #include "librbd/journal/OpenRequest.h"
  11 #include "librbd/journal/Types.h"
  12
  13 namespace librbd {
  14
  15 namespace {
  16
  17 struct MockTestImageCtx : public MockImageCtx {
  18   explicit MockTestImageCtx(librbd::ImageCtx& image_ctx) : MockImageCtx(image_ctx) {
  19   }
  20 };
  21
  22 } // anonymous namespace
  23
  24 namespace journal {
  25
  26 template <>
  27 struct TypeTraits<MockTestImageCtx> {
  28   typedef ::journal::MockJournaler Journaler;
  29 };
  30
  31 } // namespace journal
  32 } // namespace librbd
  33
  34 // template definitions
  35 #include "librbd/journal/OpenRequest.cc"
  36 template class librbd::journal::OpenRequest<librbd::MockTestImageCtx>;
  37
  38 namespace librbd {
  39 namespace journal {
  40
  41 using ::testing::_;
  42 using ::testing::DoAll;
  43 using ::testing::InSequence;
  44 using ::testing::Return;
  45 using ::testing::SetArgPointee;
  46 using ::testing::WithArg;
  47
  48 class TestMockJournalOpenRequest : public TestMockFixture {
  49 public:
  50   typedef OpenRequest<MockTestImageCtx> MockOpenRequest;
  51
  52   TestMockJournalOpenRequest() = default;
  53
  54   void expect_init_journaler(::journal::MockJournaler &mock_journaler, int r) {
  55     EXPECT_CALL(mock_journaler, init(_))
  56                   .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
  57   }
  58
  59   void expect_get_journaler_cached_client(::journal::MockJournaler &mock_journaler,
  60                                           int r) {
  61     journal::ImageClientMeta image_client_meta;
  62     image_client_meta.tag_class = 345;
  63
  64     journal::ClientData client_data;
  65     client_data.client_meta = image_client_meta;
  66
  67     cls::journal::Client client;
  68     encode(client_data, client.data);
  69
  70     EXPECT_CALL(mock_journaler, get_cached_client("", _))
  71                   .WillOnce(DoAll(SetArgPointee<1>(client),
  72                                   Return(r)));
  73   }
  74
  75   void expect_get_journaler_tags(MockImageCtx &mock_image_ctx,
  76                                  ::journal::MockJournaler &mock_journaler,
  77                                  int r) {
  78     journal::TagData tag_data;
  79     tag_data.mirror_uuid = "remote mirror";
  80
  81     bufferlist tag_data_bl;
  82     encode(tag_data, tag_data_bl);
  83
  84     ::journal::Journaler::Tags tags = {{0, 345, {}}, {1, 345, tag_data_bl}};
  85     EXPECT_CALL(mock_journaler, get_tags(345, _, _))
  86                   .WillOnce(DoAll(SetArgPointee<1>(tags),
  87                                   WithArg<2>(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))));
  88   }
  89
  90   ceph::mutex m_lock = ceph::make_mutex("m_lock");
  91   ImageClientMeta m_client_meta;
  92   uint64_t m_tag_tid = 0;
  93   TagData m_tag_data;
  94 };
  95
  96 TEST_F(TestMockJournalOpenRequest, Success) {
  97   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
  98
  99   librbd::ImageCtx *ictx;
 100   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 101
 102   MockTestImageCtx mock_image_ctx(*ictx);
 103   ::journal::MockJournaler mock_journaler;
 104
 105   expect_op_work_queue(mock_image_ctx);
 106
 107   InSequence seq;
 108   expect_init_journaler(mock_journaler, 0);
 109   expect_get_journaler_cached_client(mock_journaler, 0);
 110   expect_get_journaler_tags(mock_image_ctx, mock_journaler, 0);
 111
 112   C_SaferCond ctx;
 113   auto req = MockOpenRequest::create(&mock_image_ctx, &mock_journaler,
 114                                      &m_lock, &m_client_meta, &m_tag_tid,
 115                                      &m_tag_data, &ctx);
 116   req->send();
 117   ASSERT_EQ(0, ctx.wait());
 118   ASSERT_EQ(345U, m_client_meta.tag_class);
 119   ASSERT_EQ(1U, m_tag_tid);
 120   ASSERT_EQ("remote mirror", m_tag_data.mirror_uuid);
 121 }
 122
 123 TEST_F(TestMockJournalOpenRequest, InitError) {
 124   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
 125
 126   librbd::ImageCtx *ictx;
 127   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 128
 129   MockTestImageCtx mock_image_ctx(*ictx);
 130   ::journal::MockJournaler mock_journaler;
 131
 132   expect_op_work_queue(mock_image_ctx);
 133
 134   InSequence seq;
 135   expect_init_journaler(mock_journaler, -ENOENT);
 136
 137   C_SaferCond ctx;
 138   auto req = MockOpenRequest::create(&mock_image_ctx, &mock_journaler,
 139                                      &m_lock, &m_client_meta, &m_tag_tid,
 140                                      &m_tag_data, &ctx);
 141   req->send();
 142   ASSERT_EQ(-ENOENT, ctx.wait());
 143 }
 144
 145 TEST_F(TestMockJournalOpenRequest, GetCachedClientError) {
 146   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
 147
 148   librbd::ImageCtx *ictx;
 149   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 150
 151   MockTestImageCtx mock_image_ctx(*ictx);
 152   ::journal::MockJournaler mock_journaler;
 153
 154   expect_op_work_queue(mock_image_ctx);
 155
 156   InSequence seq;
 157   expect_init_journaler(mock_journaler, 0);
 158   expect_get_journaler_cached_client(mock_journaler, -EINVAL);
 159
 160   C_SaferCond ctx;
 161   auto req = MockOpenRequest::create(&mock_image_ctx, &mock_journaler,
 162                                      &m_lock, &m_client_meta, &m_tag_tid,
 163                                      &m_tag_data, &ctx);
 164   req->send();
 165   ASSERT_EQ(-EINVAL, ctx.wait());
 166 }
 167
 168 TEST_F(TestMockJournalOpenRequest, GetTagsError) {
 169   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
 170
 171   librbd::ImageCtx *ictx;
 172   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 173
 174   MockTestImageCtx mock_image_ctx(*ictx);
 175   ::journal::MockJournaler mock_journaler;
 176
 177   expect_op_work_queue(mock_image_ctx);
 178
 179   InSequence seq;
 180   expect_init_journaler(mock_journaler, 0);
 181   expect_get_journaler_cached_client(mock_journaler, 0);
 182   expect_get_journaler_tags(mock_image_ctx, mock_journaler, -EBADMSG);
 183
 184   C_SaferCond ctx;
 185   auto req = MockOpenRequest::create(&mock_image_ctx, &mock_journaler,
 186                                      &m_lock, &m_client_meta, &m_tag_tid,
 187                                      &m_tag_data, &ctx);
 188   req->send();
 189   ASSERT_EQ(-EBADMSG, ctx.wait());
 190 }
 191
 192 } // namespace journal
 193 } // namespace librbd