ceph/src/test/librbd/image/test_mock_AttachParentRequest.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/librbd/mock/MockContextWQ.h"
   8 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
   9 #include "librbd/image/AttachParentRequest.h"
  10 #include "gmock/gmock.h"
  11 #include "gtest/gtest.h"
  12
  13 namespace librbd {
  14 namespace {
  15
  16 struct MockTestImageCtx : public MockImageCtx {
  17   MockTestImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) {
  18   }
  19 };
  20
  21 } // anonymous namespace
  22 } // namespace librbd
  23
  24 // template definitions
  25 #include "librbd/image/AttachParentRequest.cc"
  26
  27 namespace librbd {
  28 namespace image {
  29
  30 using ::testing::_;
  31 using ::testing::InSequence;
  32 using ::testing::Return;
  33 using ::testing::StrEq;
  34
  35 class TestMockImageAttachParentRequest : public TestMockFixture {
  36 public:
  37   typedef AttachParentRequest<MockTestImageCtx> MockAttachParentRequest;
  38
  39   void SetUp() override {
  40     TestMockFixture::SetUp();
  41
  42     ASSERT_EQ(0, open_image(m_image_name, &image_ctx));
  43   }
  44
  45   void expect_parent_attach(MockImageCtx &mock_image_ctx, int r) {
  46     EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
  47                 exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
  48                      StrEq("parent_attach"), _, _, _, _))
  49       .WillOnce(Return(r));
  50   }
  51
  52   void expect_set_parent(MockImageCtx &mock_image_ctx, int r) {
  53     EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
  54                 exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
  55                      StrEq("set_parent"), _, _, _, _))
  56       .WillOnce(Return(r));
  57   }
  58
  59   librbd::ImageCtx *image_ctx;
  60 };
  61
  62 TEST_F(TestMockImageAttachParentRequest, ParentAttachSuccess) {
  63   REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
  64
  65   MockTestImageCtx mock_image_ctx(*image_ctx);
  66
  67   InSequence seq;
  68   expect_parent_attach(mock_image_ctx, 0);
  69
  70   cls::rbd::ParentImageSpec parent_image_spec{
  71     1, "ns", "image id", 123};
  72
  73   C_SaferCond ctx;
  74   auto req = MockAttachParentRequest::create(mock_image_ctx, parent_image_spec,
  75                                              234, false, &ctx);
  76   req->send();
  77   ASSERT_EQ(0, ctx.wait());
  78 }
  79
  80 TEST_F(TestMockImageAttachParentRequest, SetParentSuccess) {
  81   REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
  82
  83   MockTestImageCtx mock_image_ctx(*image_ctx);
  84
  85   InSequence seq;
  86   expect_parent_attach(mock_image_ctx, -EOPNOTSUPP);
  87   expect_set_parent(mock_image_ctx, 0);
  88
  89   cls::rbd::ParentImageSpec parent_image_spec{
  90     1, "", "image id", 123};
  91
  92   C_SaferCond ctx;
  93   auto req = MockAttachParentRequest::create(mock_image_ctx, parent_image_spec,
  94                                              234, false, &ctx);
  95   req->send();
  96   ASSERT_EQ(0, ctx.wait());
  97 }
  98
  99 TEST_F(TestMockImageAttachParentRequest, ParentAttachError) {
 100   REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
 101
 102   MockTestImageCtx mock_image_ctx(*image_ctx);
 103
 104   InSequence seq;
 105   expect_parent_attach(mock_image_ctx, -EPERM);
 106
 107   cls::rbd::ParentImageSpec parent_image_spec{
 108     1, "", "image id", 123};
 109
 110   C_SaferCond ctx;
 111   auto req = MockAttachParentRequest::create(mock_image_ctx, parent_image_spec,
 112                                              234, false, &ctx);
 113   req->send();
 114   ASSERT_EQ(-EPERM, ctx.wait());
 115 }
 116
 117 TEST_F(TestMockImageAttachParentRequest, SetParentError) {
 118   REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
 119
 120   MockTestImageCtx mock_image_ctx(*image_ctx);
 121
 122   InSequence seq;
 123   expect_parent_attach(mock_image_ctx, -EOPNOTSUPP);
 124   expect_set_parent(mock_image_ctx, -EINVAL);
 125
 126   cls::rbd::ParentImageSpec parent_image_spec{
 127     1, "", "image id", 123};
 128
 129   C_SaferCond ctx;
 130   auto req = MockAttachParentRequest::create(mock_image_ctx, parent_image_spec,
 131                                              234, false, &ctx);
 132   req->send();
 133   ASSERT_EQ(-EINVAL, ctx.wait());
 134 }
 135
 136 TEST_F(TestMockImageAttachParentRequest, NamespaceUnsupported) {
 137   REQUIRE_FEATURE(RBD_FEATURE_LAYERING);
 138
 139   MockTestImageCtx mock_image_ctx(*image_ctx);
 140
 141   InSequence seq;
 142   expect_parent_attach(mock_image_ctx, -EOPNOTSUPP);
 143
 144   cls::rbd::ParentImageSpec parent_image_spec{
 145     1, "ns", "image id", 123};
 146
 147   C_SaferCond ctx;
 148   auto req = MockAttachParentRequest::create(mock_image_ctx, parent_image_spec,
 149                                              234, false, &ctx);
 150   req->send();
 151   ASSERT_EQ(-EXDEV, ctx.wait());
 152 }
 153
 154 } // namespace image
 155 } // namespace librbd