1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 #include "test/rbd_mirror/test_mock_fixture.h"
5 #include "include/rbd/librbd.hpp"
6 #include "librbd/ImageCtx.h"
7 #include "librbd/ImageState.h"
8 #include "librbd/Operations.h"
9 #include "librbd/journal/TypeTraits.h"
10 #include "test/journal/mock/MockJournaler.h"
11 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
12 #include "test/librbd/mock/MockImageCtx.h"
13 #include "tools/rbd_mirror/image_sync/ImageCopyRequest.h"
14 #include "tools/rbd_mirror/image_sync/ObjectCopyRequest.h"
15 #include "tools/rbd_mirror/Threads.h"
16 #include <boost/scope_exit.hpp>
22 struct MockTestImageCtx : public librbd::MockImageCtx {
23 MockTestImageCtx(librbd::ImageCtx &image_ctx)
24 : librbd::MockImageCtx(image_ctx) {
28 } // anonymous namespace
33 struct TypeTraits<librbd::MockTestImageCtx> {
34 typedef ::journal::MockJournaler Journaler;
37 } // namespace journal
42 namespace image_sync {
45 struct ObjectCopyRequest<librbd::MockTestImageCtx> {
46 static ObjectCopyRequest* s_instance;
47 static ObjectCopyRequest* create(librbd::MockTestImageCtx *local_image_ctx,
48 librbd::MockTestImageCtx *remote_image_ctx,
49 const ImageCopyRequest<librbd::MockTestImageCtx>::SnapMap *snap_map,
50 uint64_t object_number, Context *on_finish) {
51 assert(s_instance != nullptr);
52 Mutex::Locker locker(s_instance->lock);
53 s_instance->snap_map = snap_map;
54 s_instance->object_contexts[object_number] = on_finish;
55 s_instance->cond.Signal();
59 MOCK_METHOD0(send, void());
64 const ImageCopyRequest<librbd::MockTestImageCtx>::SnapMap *snap_map = nullptr;
65 std::map<uint64_t, Context *> object_contexts;
67 ObjectCopyRequest() : lock("lock") {
72 ObjectCopyRequest<librbd::MockTestImageCtx>* ObjectCopyRequest<librbd::MockTestImageCtx>::s_instance = nullptr;
74 } // namespace image_sync
78 // template definitions
79 #include "tools/rbd_mirror/image_sync/ImageCopyRequest.cc"
80 template class rbd::mirror::image_sync::ImageCopyRequest<librbd::MockTestImageCtx>;
84 namespace image_sync {
87 using ::testing::InSequence;
88 using ::testing::Invoke;
89 using ::testing::Return;
90 using ::testing::WithArg;
91 using ::testing::InvokeWithoutArgs;
93 class TestMockImageSyncImageCopyRequest : public TestMockFixture {
95 typedef ImageCopyRequest<librbd::MockTestImageCtx> MockImageCopyRequest;
96 typedef ObjectCopyRequest<librbd::MockTestImageCtx> MockObjectCopyRequest;
98 void SetUp() override {
99 TestMockFixture::SetUp();
102 ASSERT_EQ(0, create_image(rbd, m_remote_io_ctx, m_image_name, m_image_size));
103 ASSERT_EQ(0, open_image(m_remote_io_ctx, m_image_name, &m_remote_image_ctx));
105 ASSERT_EQ(0, create_image(rbd, m_local_io_ctx, m_image_name, m_image_size));
106 ASSERT_EQ(0, open_image(m_local_io_ctx, m_image_name, &m_local_image_ctx));
109 void expect_get_snap_id(librbd::MockTestImageCtx &mock_image_ctx) {
110 EXPECT_CALL(mock_image_ctx, get_snap_id(_, _))
111 .WillRepeatedly(Invoke([&mock_image_ctx](cls::rbd::SnapshotNamespace snap_namespace,
112 std::string snap_name) {
113 assert(mock_image_ctx.image_ctx->snap_lock.is_locked());
114 return mock_image_ctx.image_ctx->get_snap_id(snap_namespace, snap_name);
118 void expect_get_object_count(librbd::MockTestImageCtx &mock_image_ctx,
120 EXPECT_CALL(mock_image_ctx, get_object_count(_))
121 .WillOnce(Return(count)).RetiresOnSaturation();
124 void expect_update_client(journal::MockJournaler &mock_journaler, int r) {
125 EXPECT_CALL(mock_journaler, update_client(_, _))
126 .WillOnce(WithArg<1>(CompleteContext(r)));
129 void expect_object_copy_send(MockObjectCopyRequest &mock_object_copy_request) {
130 EXPECT_CALL(mock_object_copy_request, send());
133 bool complete_object_copy(MockObjectCopyRequest &mock_object_copy_request,
134 uint64_t object_num, int r,
135 std::function<void()> fn = []() {}) {
136 Mutex::Locker locker(mock_object_copy_request.lock);
137 while (mock_object_copy_request.object_contexts.count(object_num) == 0) {
138 if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
139 utime_t(10, 0)) != 0) {
144 FunctionContext *wrapper_ctx = new FunctionContext(
145 [&mock_object_copy_request, object_num, fn] (int r) {
147 mock_object_copy_request.object_contexts[object_num]->complete(r);
149 m_threads->work_queue->queue(wrapper_ctx, r);
153 MockImageCopyRequest::SnapMap wait_for_snap_map(MockObjectCopyRequest &mock_object_copy_request) {
154 Mutex::Locker locker(mock_object_copy_request.lock);
155 while (mock_object_copy_request.snap_map == nullptr) {
156 if (mock_object_copy_request.cond.WaitInterval(mock_object_copy_request.lock,
157 utime_t(10, 0)) != 0) {
158 return MockImageCopyRequest::SnapMap();
161 return *mock_object_copy_request.snap_map;
164 MockImageCopyRequest *create_request(librbd::MockTestImageCtx &mock_remote_image_ctx,
165 librbd::MockTestImageCtx &mock_local_image_ctx,
166 journal::MockJournaler &mock_journaler,
167 librbd::journal::MirrorPeerSyncPoint &sync_point,
169 return new MockImageCopyRequest(&mock_local_image_ctx,
170 &mock_remote_image_ctx,
171 m_threads->timer, &m_threads->timer_lock,
172 &mock_journaler, &m_client_meta,
176 using TestFixture::create_snap;
177 int create_snap(const char* snap_name) {
178 librados::snap_t remote_snap_id;
179 int r = create_snap(m_remote_image_ctx, snap_name, &remote_snap_id);
184 librados::snap_t local_snap_id;
185 r = create_snap(m_local_image_ctx, snap_name, &local_snap_id);
190 // collection of all existing snaps in local image
191 MockImageCopyRequest::SnapIds local_snap_ids({local_snap_id});
192 if (!m_snap_map.empty()) {
193 local_snap_ids.insert(local_snap_ids.end(),
194 m_snap_map.rbegin()->second.begin(),
195 m_snap_map.rbegin()->second.end());
197 m_snap_map[remote_snap_id] = local_snap_ids;
198 m_client_meta.snap_seqs[remote_snap_id] = local_snap_id;
202 librbd::ImageCtx *m_remote_image_ctx;
203 librbd::ImageCtx *m_local_image_ctx;
204 librbd::journal::MirrorPeerClientMeta m_client_meta;
205 MockImageCopyRequest::SnapMap m_snap_map;
208 TEST_F(TestMockImageSyncImageCopyRequest, SimpleImage) {
209 ASSERT_EQ(0, create_snap("snap1"));
210 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
214 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
215 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
216 journal::MockJournaler mock_journaler;
217 MockObjectCopyRequest mock_object_copy_request;
219 expect_get_snap_id(mock_remote_image_ctx);
222 expect_get_object_count(mock_remote_image_ctx, 1);
223 expect_get_object_count(mock_remote_image_ctx, 0);
224 expect_update_client(mock_journaler, 0);
225 expect_object_copy_send(mock_object_copy_request);
226 expect_update_client(mock_journaler, 0);
229 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
230 mock_local_image_ctx,
232 m_client_meta.sync_points.front(),
236 ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
237 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
238 ASSERT_EQ(0, ctx.wait());
241 TEST_F(TestMockImageSyncImageCopyRequest, Throttled) {
242 ASSERT_EQ(0, create_snap("snap1"));
243 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
247 std::string update_sync_age;;
248 ASSERT_EQ(0, _rados->conf_get("rbd_mirror_sync_point_update_age", update_sync_age));
249 ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", "1"));
250 BOOST_SCOPE_EXIT( (update_sync_age) ) {
251 ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", update_sync_age.c_str()));
252 } BOOST_SCOPE_EXIT_END;
255 std::string max_ops_str;
256 ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
257 int max_ops = std::stoi(max_ops_str);
259 uint64_t object_count = 55;
261 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
262 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
263 journal::MockJournaler mock_journaler;
264 MockObjectCopyRequest mock_object_copy_request;
266 expect_get_snap_id(mock_remote_image_ctx);
268 expect_get_object_count(mock_remote_image_ctx, object_count);
269 expect_get_object_count(mock_remote_image_ctx, 0);
271 EXPECT_CALL(mock_object_copy_request, send()).Times(object_count);
273 boost::optional<uint64_t> expected_object_number(boost::none);
274 EXPECT_CALL(mock_journaler, update_client(_, _))
276 Invoke([&expected_object_number, max_ops, object_count, this]
277 (bufferlist data, Context *ctx) {
278 ASSERT_EQ(expected_object_number,
279 m_client_meta.sync_points.front().object_number);
280 if (!expected_object_number) {
281 expected_object_number = (max_ops - 1);
283 expected_object_number = expected_object_number.get() + max_ops;
286 if (expected_object_number.get() > (object_count - 1)) {
287 expected_object_number = (object_count - 1);
290 m_threads->work_queue->queue(ctx, 0);
295 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
296 mock_local_image_ctx,
298 m_client_meta.sync_points.front(),
302 std::function<void()> sleep_fn = [request]() {
306 ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
307 for (uint64_t i = 0; i < object_count; ++i) {
309 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, i, 0, sleep_fn));
311 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, i, 0));
314 ASSERT_EQ(0, ctx.wait());
317 TEST_F(TestMockImageSyncImageCopyRequest, SnapshotSubset) {
318 ASSERT_EQ(0, create_snap("snap1"));
319 ASSERT_EQ(0, create_snap("snap2"));
320 ASSERT_EQ(0, create_snap("snap3"));
321 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
322 "snap3", "snap2", boost::none}};
324 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
325 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
326 journal::MockJournaler mock_journaler;
327 MockObjectCopyRequest mock_object_copy_request;
329 expect_get_snap_id(mock_remote_image_ctx);
332 expect_get_object_count(mock_remote_image_ctx, 1);
333 expect_get_object_count(mock_remote_image_ctx, 0);
334 expect_get_object_count(mock_remote_image_ctx, 1);
335 expect_get_object_count(mock_remote_image_ctx, 1);
336 expect_update_client(mock_journaler, 0);
337 expect_object_copy_send(mock_object_copy_request);
338 expect_update_client(mock_journaler, 0);
341 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
342 mock_local_image_ctx,
344 m_client_meta.sync_points.front(),
348 MockImageCopyRequest::SnapMap snap_map(m_snap_map);
349 snap_map.erase(snap_map.begin());
350 ASSERT_EQ(snap_map, wait_for_snap_map(mock_object_copy_request));
352 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
353 ASSERT_EQ(0, ctx.wait());
356 TEST_F(TestMockImageSyncImageCopyRequest, RestartCatchup) {
357 ASSERT_EQ(0, create_snap("snap1"));
358 ASSERT_EQ(0, create_snap("snap2"));
359 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none},
360 {cls::rbd::UserSnapshotNamespace(), "snap2", "snap1", boost::none}};
362 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
363 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
364 journal::MockJournaler mock_journaler;
365 MockObjectCopyRequest mock_object_copy_request;
367 expect_get_snap_id(mock_remote_image_ctx);
370 expect_get_object_count(mock_remote_image_ctx, 1);
371 expect_get_object_count(mock_remote_image_ctx, 0);
372 expect_get_object_count(mock_remote_image_ctx, 0);
373 expect_update_client(mock_journaler, 0);
374 expect_object_copy_send(mock_object_copy_request);
375 expect_update_client(mock_journaler, 0);
378 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
379 mock_local_image_ctx,
381 m_client_meta.sync_points.back(),
385 ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
386 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
387 ASSERT_EQ(0, ctx.wait());
390 TEST_F(TestMockImageSyncImageCopyRequest, RestartPartialSync) {
391 ASSERT_EQ(0, create_snap("snap1"));
392 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
394 librbd::journal::MirrorPeerSyncPoint::ObjectNumber{0U}}};
396 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
397 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
398 journal::MockJournaler mock_journaler;
399 MockObjectCopyRequest mock_object_copy_request;
401 expect_get_snap_id(mock_remote_image_ctx);
404 expect_get_object_count(mock_remote_image_ctx, 1);
405 expect_get_object_count(mock_remote_image_ctx, 2);
406 expect_update_client(mock_journaler, 0);
407 expect_object_copy_send(mock_object_copy_request);
408 expect_update_client(mock_journaler, 0);
411 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
412 mock_local_image_ctx,
414 m_client_meta.sync_points.front(),
418 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 1, 0));
419 ASSERT_EQ(0, ctx.wait());
422 TEST_F(TestMockImageSyncImageCopyRequest, Cancel) {
423 std::string max_ops_str;
424 ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
425 ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", "1"));
426 BOOST_SCOPE_EXIT( (max_ops_str) ) {
427 ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", max_ops_str.c_str()));
428 } BOOST_SCOPE_EXIT_END;
430 ASSERT_EQ(0, create_snap("snap1"));
431 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
433 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
434 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
435 journal::MockJournaler mock_journaler;
436 MockObjectCopyRequest mock_object_copy_request;
438 expect_get_snap_id(mock_remote_image_ctx);
441 expect_get_object_count(mock_remote_image_ctx, 2);
442 expect_get_object_count(mock_remote_image_ctx, 2);
443 expect_update_client(mock_journaler, 0);
444 expect_object_copy_send(mock_object_copy_request);
447 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
448 mock_local_image_ctx,
450 m_client_meta.sync_points.front(),
454 ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
457 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
458 ASSERT_EQ(-ECANCELED, ctx.wait());
461 TEST_F(TestMockImageSyncImageCopyRequest, Cancel_Inflight_Sync) {
462 std::string update_sync_age;;
463 ASSERT_EQ(0, _rados->conf_get("rbd_mirror_sync_point_update_age", update_sync_age));
464 ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", "1"));
465 BOOST_SCOPE_EXIT( (update_sync_age) ) {
466 ASSERT_EQ(0, _rados->conf_set("rbd_mirror_sync_point_update_age", update_sync_age.c_str()));
467 } BOOST_SCOPE_EXIT_END;
469 std::string max_ops_str;
470 ASSERT_EQ(0, _rados->conf_get("rbd_concurrent_management_ops", max_ops_str));
471 ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", "3"));
472 BOOST_SCOPE_EXIT( (max_ops_str) ) {
473 ASSERT_EQ(0, _rados->conf_set("rbd_concurrent_management_ops", max_ops_str.c_str()));
474 } BOOST_SCOPE_EXIT_END;
476 ASSERT_EQ(0, create_snap("snap1"));
477 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
479 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
480 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
481 journal::MockJournaler mock_journaler;
482 MockObjectCopyRequest mock_object_copy_request;
484 expect_get_snap_id(mock_remote_image_ctx);
486 expect_get_object_count(mock_remote_image_ctx, 10);
487 expect_get_object_count(mock_remote_image_ctx, 0);
489 EXPECT_CALL(mock_object_copy_request, send()).Times(6);
491 EXPECT_CALL(mock_journaler, update_client(_, _))
492 .WillRepeatedly(Invoke([this] (bufferlist data, Context *ctx) {
493 m_threads->work_queue->queue(ctx, 0);
498 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
499 mock_local_image_ctx,
501 m_client_meta.sync_points.front(),
505 ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
507 std::function<void()> cancel_fn = [request]() {
512 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 0, 0));
513 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 1, 0));
514 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 2, 0));
515 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 3, 0, cancel_fn));
516 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 4, 0));
517 ASSERT_TRUE(complete_object_copy(mock_object_copy_request, 5, 0));
519 ASSERT_EQ(-ECANCELED, ctx.wait());
520 ASSERT_EQ(5u, m_client_meta.sync_points.front().object_number.get());
523 TEST_F(TestMockImageSyncImageCopyRequest, Cancel1) {
524 ASSERT_EQ(0, create_snap("snap1"));
525 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}};
527 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
528 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
529 journal::MockJournaler mock_journaler;
530 MockObjectCopyRequest mock_object_copy_request;
533 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
534 mock_local_image_ctx,
536 m_client_meta.sync_points.front(),
539 expect_get_snap_id(mock_remote_image_ctx);
542 expect_get_object_count(mock_remote_image_ctx, 1);
543 expect_get_object_count(mock_remote_image_ctx, 0);
544 EXPECT_CALL(mock_journaler, update_client(_, _))
545 .WillOnce(DoAll(InvokeWithoutArgs([request]() {
548 WithArg<1>(CompleteContext(0))));
551 ASSERT_EQ(-ECANCELED, ctx.wait());
554 TEST_F(TestMockImageSyncImageCopyRequest, MissingSnap) {
555 ASSERT_EQ(0, create_snap("snap1"));
556 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "missing-snap", boost::none}};
558 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
559 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
560 journal::MockJournaler mock_journaler;
562 expect_get_snap_id(mock_remote_image_ctx);
565 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
566 mock_local_image_ctx,
568 m_client_meta.sync_points.front(),
571 ASSERT_EQ(-ENOENT, ctx.wait());
574 TEST_F(TestMockImageSyncImageCopyRequest, MissingFromSnap) {
575 ASSERT_EQ(0, create_snap("snap1"));
576 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
581 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
582 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
583 journal::MockJournaler mock_journaler;
585 expect_get_snap_id(mock_remote_image_ctx);
588 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
589 mock_local_image_ctx,
591 m_client_meta.sync_points.front(),
594 ASSERT_EQ(-ENOENT, ctx.wait());
597 TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapMap) {
598 ASSERT_EQ(0, create_snap("snap1"));
599 ASSERT_EQ(0, create_snap("snap2"));
600 m_client_meta.snap_seqs = {{0, 0}};
601 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
606 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
607 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
608 journal::MockJournaler mock_journaler;
610 expect_get_snap_id(mock_remote_image_ctx);
613 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
614 mock_local_image_ctx,
616 m_client_meta.sync_points.front(),
619 ASSERT_EQ(-EINVAL, ctx.wait());
622 TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapSeqs) {
623 ASSERT_EQ(0, create_snap("snap1"));
624 ASSERT_EQ(0, create_snap("snap2"));
625 m_client_meta.snap_seqs = {};
626 m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(),
631 librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx);
632 librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx);
633 journal::MockJournaler mock_journaler;
635 expect_get_snap_id(mock_remote_image_ctx);
638 MockImageCopyRequest *request = create_request(mock_remote_image_ctx,
639 mock_local_image_ctx,
641 m_client_meta.sync_points.front(),
644 ASSERT_EQ(-EINVAL, ctx.wait());
647 } // namespace image_sync
648 } // namespace mirror