src/ceph/src/test/librbd/managed_lock/test_mock_ReacquireRequest.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/librados_test_stub/MockTestMemIoCtxImpl.h"
   7 #include "test/librados_test_stub/MockTestMemRadosClient.h"
   8 #include "cls/lock/cls_lock_ops.h"
   9 #include "librbd/managed_lock/ReacquireRequest.h"
  10 #include "gmock/gmock.h"
  11 #include "gtest/gtest.h"
  12 #include <arpa/inet.h>
  13 #include <list>
  14
  15 // template definitions
  16 #include "librbd/managed_lock/ReacquireRequest.cc"
  17 template class librbd::managed_lock::ReacquireRequest<librbd::MockImageCtx>;
  18
  19 namespace {
  20
  21 MATCHER_P(IsLockType, exclusive, "") {
  22   cls_lock_set_cookie_op op;
  23   bufferlist bl;
  24   bl.share(arg);
  25   bufferlist::iterator iter = bl.begin();
  26   ::decode(op, iter);
  27   return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
  28 }
  29
  30 } // anonymous namespace
  31
  32 namespace librbd {
  33 namespace managed_lock {
  34
  35 using ::testing::_;
  36 using ::testing::InSequence;
  37 using ::testing::Return;
  38 using ::testing::StrEq;
  39
  40
  41 class TestMockManagedLockReacquireRequest : public TestMockFixture {
  42 public:
  43   typedef ReacquireRequest<MockImageCtx> MockReacquireRequest;
  44
  45   void expect_set_cookie(MockImageCtx &mock_image_ctx, int r,
  46                          bool exclusive = true) {
  47     EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
  48                 exec(mock_image_ctx.header_oid, _, StrEq("lock"),
  49                      StrEq("set_cookie"), IsLockType(exclusive), _, _))
  50                   .WillOnce(Return(r));
  51   }
  52 };
  53
  54 TEST_F(TestMockManagedLockReacquireRequest, SuccessExclusive) {
  55   librbd::ImageCtx *ictx;
  56   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  57
  58   MockImageCtx mock_image_ctx(*ictx);
  59
  60   InSequence seq;
  61   expect_set_cookie(mock_image_ctx, 0);
  62
  63   C_SaferCond ctx;
  64   MockReacquireRequest *req = MockReacquireRequest::create(
  65       mock_image_ctx.md_ctx, mock_image_ctx.header_oid, "old_cookie",
  66       "new_cookie", true, &ctx);
  67   req->send();
  68   ASSERT_EQ(0, ctx.wait());
  69 }
  70
  71 TEST_F(TestMockManagedLockReacquireRequest, SuccessShared) {
  72   librbd::ImageCtx *ictx;
  73   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  74
  75   MockImageCtx mock_image_ctx(*ictx);
  76
  77   InSequence seq;
  78   expect_set_cookie(mock_image_ctx, 0, false);
  79
  80   C_SaferCond ctx;
  81   MockReacquireRequest *req = MockReacquireRequest::create(
  82       mock_image_ctx.md_ctx, mock_image_ctx.header_oid, "old_cookie",
  83       "new_cookie", false, &ctx);
  84   req->send();
  85   ASSERT_EQ(0, ctx.wait());
  86 }
  87
  88 TEST_F(TestMockManagedLockReacquireRequest, NotSupported) {
  89   librbd::ImageCtx *ictx;
  90   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  91
  92   MockImageCtx mock_image_ctx(*ictx);
  93
  94   InSequence seq;
  95   expect_set_cookie(mock_image_ctx, -EOPNOTSUPP);
  96
  97   C_SaferCond ctx;
  98   MockReacquireRequest *req = MockReacquireRequest::create(
  99       mock_image_ctx.md_ctx, mock_image_ctx.header_oid, "old_cookie",
 100       "new_cookie", true, &ctx);
 101   req->send();
 102   ASSERT_EQ(-EOPNOTSUPP, ctx.wait());
 103 }
 104
 105 TEST_F(TestMockManagedLockReacquireRequest, Error) {
 106   librbd::ImageCtx *ictx;
 107   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 108
 109   MockImageCtx mock_image_ctx(*ictx);
 110
 111   InSequence seq;
 112   expect_set_cookie(mock_image_ctx, -EBUSY);
 113
 114   C_SaferCond ctx;
 115   MockReacquireRequest *req = MockReacquireRequest::create(
 116       mock_image_ctx.md_ctx, mock_image_ctx.header_oid, "old_cookie",
 117       "new_cookie", true, &ctx);
 118   req->send();
 119   ASSERT_EQ(-EBUSY, ctx.wait());
 120 }
 121
 122 } // namespace managed_lock
 123 } // namespace librbd