ceph/src/test/librbd/test_MirroringWatcher.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_fixture.h"
   5 #include "test/librbd/test_support.h"
   6 #include "include/rbd_types.h"
   7 #include "librbd/MirroringWatcher.h"
   8 #include "gtest/gtest.h"
   9 #include "gmock/gmock.h"
  10 #include <list>
  11
  12 void register_test_mirroring_watcher() {
  13 }
  14
  15 namespace librbd {
  16
  17 namespace {
  18
  19 struct MockMirroringWatcher : public MirroringWatcher<> {
  20   std::string oid;
  21
  22   MockMirroringWatcher(ImageCtx &image_ctx)
  23     : MirroringWatcher<>(image_ctx.md_ctx, image_ctx.op_work_queue) {
  24   }
  25
  26   MOCK_METHOD1(handle_mode_updated, void(cls::rbd::MirrorMode));
  27   MOCK_METHOD3(handle_image_updated, void(cls::rbd::MirrorImageState,
  28                                           const std::string &,
  29                                           const std::string &));
  30 };
  31
  32 } // anonymous namespace
  33
  34 using ::testing::_;
  35 using ::testing::Invoke;
  36 using ::testing::StrEq;
  37 using ::testing::WithArg;
  38
  39 class TestMirroringWatcher : public TestFixture {
  40 public:
  41   void SetUp() override {
  42     TestFixture::SetUp();
  43
  44     bufferlist bl;
  45     ASSERT_EQ(0, m_ioctx.write_full(RBD_MIRRORING, bl));
  46
  47     librbd::ImageCtx *ictx;
  48     ASSERT_EQ(0, open_image(m_image_name, &ictx));
  49
  50     m_image_watcher = new MockMirroringWatcher(*ictx);
  51     C_SaferCond ctx;
  52     m_image_watcher->register_watch(&ctx);
  53     if (ctx.wait() != 0) {
  54       delete m_image_watcher;
  55       m_image_watcher = nullptr;
  56       FAIL();
  57     }
  58   }
  59
  60   void TearDown() override {
  61     if (m_image_watcher != nullptr) {
  62       C_SaferCond ctx;
  63       m_image_watcher->unregister_watch(&ctx);
  64       ASSERT_EQ(0, ctx.wait());
  65       delete m_image_watcher;
  66     }
  67
  68     TestFixture::TearDown();
  69   }
  70
  71   MockMirroringWatcher *m_image_watcher = nullptr;
  72 };
  73
  74 TEST_F(TestMirroringWatcher, ModeUpdated) {
  75   EXPECT_CALL(*m_image_watcher, handle_mode_updated(cls::rbd::MIRROR_MODE_DISABLED));
  76
  77   C_SaferCond ctx;
  78   MockMirroringWatcher::notify_mode_updated(m_ioctx, cls::rbd::MIRROR_MODE_DISABLED, &ctx);
  79   ASSERT_EQ(0, ctx.wait());
  80 }
  81
  82 TEST_F(TestMirroringWatcher, ImageStatusUpdated) {
  83   EXPECT_CALL(*m_image_watcher,
  84               handle_image_updated(cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
  85                                    StrEq("image id"),
  86                                    StrEq("global image id")));
  87
  88   C_SaferCond ctx;
  89   MockMirroringWatcher::notify_image_updated(m_ioctx,
  90                                              cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
  91                                              "image id", "global image id", &ctx);
  92   ASSERT_EQ(0, ctx.wait());
  93 }
  94
  95 } // namespace librbd