src/ceph/src/test/librbd/watcher/test_mock_RewatchRequest.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 "include/rados/librados.hpp"
   6 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
   7 #include "test/librados_test_stub/MockTestMemRadosClient.h"
   8 #include "test/librbd/test_support.h"
   9 #include "test/librbd/mock/MockImageCtx.h"
  10 #include "librados/AioCompletionImpl.h"
  11 #include "librbd/watcher/RewatchRequest.h"
  12
  13 namespace librbd {
  14 namespace watcher {
  15
  16 using ::testing::_;
  17 using ::testing::DoAll;
  18 using ::testing::InSequence;
  19 using ::testing::Invoke;
  20 using ::testing::Return;
  21 using ::testing::WithArg;
  22
  23 struct TestMockWatcherRewatchRequest : public TestMockFixture {
  24   typedef RewatchRequest MockRewatchRequest;
  25
  26   TestMockWatcherRewatchRequest()
  27     : m_watch_lock("watch_lock") {
  28   }
  29
  30   void expect_aio_watch(MockImageCtx &mock_image_ctx, int r) {
  31     librados::MockTestMemIoCtxImpl &mock_io_ctx(get_mock_io_ctx(
  32       mock_image_ctx.md_ctx));
  33
  34     EXPECT_CALL(mock_io_ctx, aio_watch(mock_image_ctx.header_oid, _, _, _))
  35       .WillOnce(DoAll(WithArg<1>(Invoke([&mock_image_ctx, &mock_io_ctx, r](librados::AioCompletionImpl *c) {
  36                                    c->get();
  37                                    mock_image_ctx.image_ctx->op_work_queue->queue(new FunctionContext([&mock_io_ctx, c](int r) {
  38                                        mock_io_ctx.get_mock_rados_client()->finish_aio_completion(c, r);
  39                                      }), r);
  40                                    })),
  41                       Return(0)));
  42   }
  43
  44   void expect_aio_unwatch(MockImageCtx &mock_image_ctx, int r) {
  45     librados::MockTestMemIoCtxImpl &mock_io_ctx(get_mock_io_ctx(
  46       mock_image_ctx.md_ctx));
  47
  48     EXPECT_CALL(mock_io_ctx, aio_unwatch(m_watch_handle, _))
  49       .WillOnce(DoAll(Invoke([&mock_image_ctx, &mock_io_ctx, r](uint64_t handle,
  50                                                                 librados::AioCompletionImpl *c) {
  51                         c->get();
  52                         mock_image_ctx.image_ctx->op_work_queue->queue(new FunctionContext([&mock_io_ctx, c](int r) {
  53                             mock_io_ctx.get_mock_rados_client()->finish_aio_completion(c, r);
  54                           }), r);
  55                         }),
  56                       Return(0)));
  57   }
  58
  59   struct WatchCtx : public librados::WatchCtx2 {
  60     void handle_notify(uint64_t, uint64_t, uint64_t,
  61                                ceph::bufferlist&) override {
  62       assert(false);
  63     }
  64     void handle_error(uint64_t, int) override {
  65       assert(false);
  66     }
  67   };
  68
  69   RWLock m_watch_lock;
  70   WatchCtx m_watch_ctx;
  71   uint64_t m_watch_handle = 123;
  72 };
  73
  74 TEST_F(TestMockWatcherRewatchRequest, Success) {
  75   librbd::ImageCtx *ictx;
  76   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  77
  78   MockImageCtx mock_image_ctx(*ictx);
  79
  80   InSequence seq;
  81   expect_aio_unwatch(mock_image_ctx, 0);
  82   expect_aio_watch(mock_image_ctx, 0);
  83
  84   C_SaferCond ctx;
  85   MockRewatchRequest *req = MockRewatchRequest::create(mock_image_ctx.md_ctx,
  86                                                        mock_image_ctx.header_oid,
  87                                                        m_watch_lock,
  88                                                        &m_watch_ctx,
  89                                                        &m_watch_handle,
  90                                                        &ctx);
  91   {
  92     RWLock::WLocker watch_locker(m_watch_lock);
  93     req->send();
  94   }
  95   ASSERT_EQ(0, ctx.wait());
  96 }
  97
  98 TEST_F(TestMockWatcherRewatchRequest, UnwatchError) {
  99   librbd::ImageCtx *ictx;
 100   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 101
 102   MockImageCtx mock_image_ctx(*ictx);
 103
 104   InSequence seq;
 105   expect_aio_unwatch(mock_image_ctx, -EINVAL);
 106   expect_aio_watch(mock_image_ctx, 0);
 107
 108   C_SaferCond ctx;
 109   MockRewatchRequest *req = MockRewatchRequest::create(mock_image_ctx.md_ctx,
 110                                                        mock_image_ctx.header_oid,
 111                                                        m_watch_lock,
 112                                                        &m_watch_ctx,
 113                                                        &m_watch_handle,
 114                                                        &ctx);
 115   {
 116     RWLock::WLocker watch_locker(m_watch_lock);
 117     req->send();
 118   }
 119   ASSERT_EQ(0, ctx.wait());
 120 }
 121
 122 TEST_F(TestMockWatcherRewatchRequest, WatchBlacklist) {
 123   librbd::ImageCtx *ictx;
 124   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 125
 126   MockImageCtx mock_image_ctx(*ictx);
 127
 128   InSequence seq;
 129   expect_aio_unwatch(mock_image_ctx, 0);
 130   expect_aio_watch(mock_image_ctx, -EBLACKLISTED);
 131
 132   C_SaferCond ctx;
 133   MockRewatchRequest *req = MockRewatchRequest::create(mock_image_ctx.md_ctx,
 134                                                        mock_image_ctx.header_oid,
 135                                                        m_watch_lock,
 136                                                        &m_watch_ctx,
 137                                                        &m_watch_handle,
 138                                                        &ctx);
 139   {
 140     RWLock::WLocker watch_locker(m_watch_lock);
 141     req->send();
 142   }
 143   ASSERT_EQ(-EBLACKLISTED, ctx.wait());
 144 }
 145
 146 TEST_F(TestMockWatcherRewatchRequest, WatchDNE) {
 147   librbd::ImageCtx *ictx;
 148   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 149
 150   MockImageCtx mock_image_ctx(*ictx);
 151
 152   InSequence seq;
 153   expect_aio_unwatch(mock_image_ctx, 0);
 154   expect_aio_watch(mock_image_ctx, -ENOENT);
 155
 156   C_SaferCond ctx;
 157   MockRewatchRequest *req = MockRewatchRequest::create(mock_image_ctx.md_ctx,
 158                                                        mock_image_ctx.header_oid,
 159                                                        m_watch_lock,
 160                                                        &m_watch_ctx,
 161                                                        &m_watch_handle,
 162                                                        &ctx);
 163   {
 164     RWLock::WLocker watch_locker(m_watch_lock);
 165     req->send();
 166   }
 167   ASSERT_EQ(-ENOENT, ctx.wait());
 168 }
 169
 170 TEST_F(TestMockWatcherRewatchRequest, WatchError) {
 171   librbd::ImageCtx *ictx;
 172   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 173
 174   MockImageCtx mock_image_ctx(*ictx);
 175
 176   InSequence seq;
 177   expect_aio_unwatch(mock_image_ctx, 0);
 178   expect_aio_watch(mock_image_ctx, -EINVAL);
 179   expect_aio_watch(mock_image_ctx, 0);
 180
 181   C_SaferCond ctx;
 182   MockRewatchRequest *req = MockRewatchRequest::create(mock_image_ctx.md_ctx,
 183                                                        mock_image_ctx.header_oid,
 184                                                        m_watch_lock,
 185                                                        &m_watch_ctx,
 186                                                        &m_watch_handle,
 187                                                        &ctx);
 188   {
 189     RWLock::WLocker watch_locker(m_watch_lock);
 190     req->send();
 191   }
 192   ASSERT_EQ(0, ctx.wait());
 193 }
 194
 195 } // namespace watcher
 196 } // namespace librbd