init push

unittest/storage/replayengine/mock_partition_service.h

@@ -0,0 +1,803 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#ifndef OCEANBASE_UNITTEST_MOCK_PARTITION_SERVICE_H_
+#define OCEANBASE_UNITTEST_MOCK_PARTITION_SERVICE_H_
+
+//#include "storage/ob_i_partition.h"
+//#include "storage/ob_partition_service.h"
+#include "storage/ob_replay_status.h"
+#include "storage/ob_safe_ref.h"
+#include "clog/ob_log_define.h"
+#include "../mockcontainer/mock_ob_partition_service.h"
+#include "../mockcontainer/mock_ob_partition.h"
+
+namespace oceanbase {
+using namespace common;
+using namespace storage;
+namespace storage {
+class ObIPartitionComponentFactory;
+class ObBaseStorage;
+}  // namespace storage
+namespace unittest {
+class MockPartition : public storage::MockObIPartitionGroup {
+  public:
+  MockPartition() : tenant_id_(1001)
+  {
+    partition_key_.init(1, 1, 1);
+  }
+  virtual ~MockPartition()
+  {}
+
+  public:
+  void reset()
+  {
+    replay_status_.reset();
+  }
+  virtual bool is_valid() const
+  {
+    return true;
+  }
+  int set_replay_engine(replayengine::ObLogReplayEngine* rp_eg)
+  {
+    replay_status_.enable(partition_key_);
+    storage::SafeRef2 ref;
+    return replay_status_.init(tenant_id_, rp_eg, ref);
+  }
+  virtual storage::ObReplayStatus* get_replay_status()
+  {
+    return &replay_status_;
+  }
+  virtual const common::ObPartitionKey& get_partition_key() const
+  {
+    return partition_key_;
+  }
+  virtual int init(const common::ObPartitionKey& key, ObIPartitionComponentFactory* cp_fty,
+      share::schema::ObMultiVersionSchemaService* schema_service, ObBaseStorage* base_storage,
+      clog::ObIPartitionLogService* pls, transaction::ObTransService* txs)
+  {
+    UNUSED(key);
+    UNUSED(cp_fty);
+    UNUSED(base_storage);
+    UNUSED(pls);
+    UNUSED(schema_service);
+    UNUSED(txs);
+    return common::OB_SUCCESS;
+  }
+  virtual void destroy()
+  {
+    return;
+  }
+  virtual int replay_base_storage_log(
+      const int64_t log_seq_num, const int64_t subcmd, const char* buf, const int64_t len, int64_t& pos)
+  {
+    UNUSED(log_seq_num);
+    UNUSED(subcmd);
+    UNUSED(buf);
+    UNUSED(len);
+    UNUSED(pos);
+    return common::OB_SUCCESS;
+  }
+  // get partition log service
+  virtual const clog::ObIPartitionLogService* get_log_service() const
+  {
+    return NULL;
+  }
+  virtual clog::ObIPartitionLogService* get_log_service()
+  {
+    return NULL;
+  }
+  virtual int get_table_store_cnt(int64_t& table_cnt) const
+  {
+    table_cnt = 0;
+    return OB_SUCCESS;
+  }
+  virtual int get_log_archive_status(clog::ObPGLogArchiveStatus& status)
+  {
+    UNUSED(status);
+    return common::OB_SUCCESS;
+  }
+  // get partition storage
+  virtual ObIPartitionStorage* get_storage()
+  {
+    return NULL;
+  }
+
+  virtual int table_scan(const ObStoreCtx& ctx, ObTableScanParam& param, common::ObNewRowIterator*& result)
+  {
+    UNUSED(ctx);
+    UNUSED(param);
+    UNUSED(result);
+    return common::OB_SUCCESS;
+  }
+  virtual int revert_scan_iter(common::ObNewRowIterator* iter)
+  {
+    UNUSED(iter);
+    return common::OB_SUCCESS;
+  }
+  virtual int delete_rows(const ObStoreCtx& ctx, const int64_t timeout, const common::ObIArray<uint64_t>& column_ids,
+      common::ObNewRowIterator* row_iter, int64_t& affected_rows)
+  {
+    UNUSED(ctx);
+    UNUSED(timeout);
+    UNUSED(column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int insert_rows(const ObStoreCtx& ctx, const int64_t timeout, const common::ObIArray<uint64_t>& column_ids,
+      common::ObNewRowIterator* row_iter, int64_t& affected_rows)
+  {
+    UNUSED(ctx);
+    UNUSED(timeout);
+    UNUSED(column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int update_rows(const ObStoreCtx& ctx, const int64_t timeout, const common::ObIArray<uint64_t>& column_ids,
+      const common::ObIArray<uint64_t>& updated_column_ids, common::ObNewRowIterator* row_iter, int64_t& affected_rows)
+  {
+    UNUSED(ctx);
+    UNUSED(timeout);
+    UNUSED(column_ids);
+    UNUSED(updated_column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int lock_rows(const ObStoreCtx& ctx, const int64_t timeout, common::ObNewRowIterator* row_iter,
+      const ObLockFlag lock_flag, int64_t& affected_rows)
+  {
+    UNUSED(ctx);
+    UNUSED(timeout);
+    UNUSED(row_iter);
+    UNUSED(lock_flag);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int lock_rows(
+      const ObStoreCtx& ctx, const int64_t timeout, const common::ObNewRow& row, const ObLockFlag lock_flag)
+  {
+    UNUSED(ctx);
+    UNUSED(timeout);
+    UNUSED(row);
+    UNUSED(lock_flag);
+    return common::OB_SUCCESS;
+  }
+  virtual void set_valid(bool valid)
+  {
+    UNUSED(valid);
+    return;
+  }
+  virtual int rdlock()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int wrlock()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int try_rdlock()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int try_wrlock()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int unlock()
+  {
+    return common::OB_SUCCESS;
+  }
+
+  virtual int save_base_storage_info(const common::ObBaseStorageInfo& info)
+  {
+    UNUSED(info);
+    return common::OB_SUCCESS;
+  }
+  virtual int save_frozen_storage_info(const common::ObBaseStorageInfo& info)
+  {
+    UNUSED(info);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_base_storage_info(common::ObBaseStorageInfo& info)
+  {
+    UNUSED(info);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_frozen_storage_info(common::ObBaseStorageInfo& info)
+  {
+    UNUSED(info);
+    return common::OB_SUCCESS;
+  }
+
+  virtual common::ObRole get_role() const
+  {
+    return common::LEADER;
+  }
+
+  // write ssstore objects @version tree to data file , used by write_check_point
+  virtual int serialize(char* buf, const int64_t buf_len, int64_t& pos) const
+  {
+    UNUSED(buf);
+    UNUSED(buf_len);
+    UNUSED(pos);
+    return common::OB_SUCCESS;
+  }
+  // read ssstore objects from data file to construct partition storage's version tree.
+  virtual int deserialize(const char* buf, const int64_t buf_len, int64_t& pos)
+  {
+    UNUSED(buf);
+    UNUSED(buf_len);
+    UNUSED(pos);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_serialize_size()
+  {
+    return 0;
+  }
+  virtual int init(const common::ObPartitionKey& key, ObIPartitionComponentFactory* cp_fty,
+      share::schema::ObMultiVersionSchemaService* schema_service, ObBaseStorage* base_storage,
+      clog::ObIPartitionLogService* pls)
+  {
+    UNUSED(key);
+    UNUSED(cp_fty);
+    UNUSED(schema_service);
+    UNUSED(base_storage);
+    UNUSED(pls);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_saved_storage_info(ObSavedStorageInfo& info)
+  {
+    UNUSED(info);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_role(oceanbase::common::ObRole& role) const
+  {
+    UNUSED(role);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_leader_curr_member_list(oceanbase::common::ObMemberList& list) const
+  {
+    UNUSED(list);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_leader(oceanbase::common::ObAddr& leader) const
+  {
+    UNUSED(leader);
+    return common::OB_SUCCESS;
+  }
+  virtual int set_frozen_version(int64_t a, int64_t b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int set_freeze_status(int64_t a, int64_t b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int64_t get_frozen_version() const
+  {
+    return 0;
+  }
+  virtual int64_t get_frozen_timestamp() const
+  {
+    return 0;
+  }
+  virtual int64_t get_freeze_status() const
+  {
+    return 0;
+  }
+  virtual int get_merge_priority_info(oceanbase::memtable::ObMergePriorityInfo& a) const
+  {
+    UNUSED(a);
+    return common::OB_SUCCESS;
+  }
+
+  private:
+  uint64_t tenant_id_;
+  ObReplayStatus replay_status_;
+  common::ObPartitionKey partition_key_;
+};
+
+class MockPartitionService : public storage::MockObIPartitionService {
+  public:
+  MockPartitionService()
+  {}
+  virtual ~MockPartitionService()
+  {}
+
+  public:
+  void reset()
+  {
+    mock_partition_.reset();
+  }
+
+  virtual int get_partition(const common::ObPartitionKey& partition_key, storage::ObIPartitionGroup*& partition)
+  {
+    int ret = common::OB_SUCCESS;
+    if (partition_key == mock_partition_.get_partition_key()) {
+      partition = &mock_partition_;
+    } else {
+      ret = common::OB_ENTRY_NOT_EXIST;
+    }
+    return ret;
+  }
+
+  virtual int get_partition(const common::ObPartitionKey& pkey, ObIPartitionGroupGuard& guard) const
+  {
+    int ret = common::OB_SUCCESS;
+    storage::ObIPartitionGroup* partition = NULL;
+    if (pkey == mock_partition_.get_partition_key()) {
+      partition = const_cast<MockPartition*>(&mock_partition_);
+      guard.set_partition_group(this->get_pg_mgr(), *partition);
+    } else {
+      ret = common::OB_ENTRY_NOT_EXIST;
+    }
+    return ret;
+  }
+
+  virtual void revert_replay_status(ObReplayStatus* replay_status) const
+  {
+    UNUSED(replay_status);
+  }
+  virtual int init(const blocksstable::ObStorageEnv& env, const common::ObAddr& self_addr,
+      ObIPartitionComponentFactory* cp_fty, share::schema::ObMultiVersionSchemaService* schema_service,
+      share::ObIPartitionLocationCache* location_cache, oceanbase::share::ObRsMgr* rs_mgr, ObIPartitionReport* rs_cb,
+      rpc::frame::ObReqTransport* req_transport)
+  {
+    UNUSED(env);
+    UNUSED(self_addr);
+    UNUSED(cp_fty);
+    UNUSED(schema_service);
+    UNUSED(location_cache);
+    UNUSED(rs_mgr);
+    UNUSED(rs_cb);
+    UNUSED(req_transport);
+    return common::OB_SUCCESS;
+  }
+  int init_partition(replayengine::ObLogReplayEngine* rp_eg)
+  {
+    return mock_partition_.set_replay_engine(rp_eg);
+  }
+  virtual bool is_empty() const
+  {
+    return true;
+  }
+  virtual transaction::ObTransService* get_trans_service()
+  {
+    return NULL;
+  }
+  virtual clog::ObICLogMgr* get_clog_mgr()
+  {
+    return NULL;
+  }
+  virtual int start()
+  {
+    // share::ObThreadPool::start();
+    return common::OB_SUCCESS;
+  }
+  virtual int destroy()
+  {
+    // share::ObThreadPool::stop();
+    return common::OB_SUCCESS;
+  }
+  //
+  virtual int load_partition(const char* buf, const int64_t buf_len, int64_t& pos)
+  {
+    UNUSED(buf);
+    UNUSED(buf_len);
+    UNUSED(pos);
+    return common::OB_SUCCESS;
+  }
+  virtual int replay_base_storage_log(
+      const int64_t log_seq_num, const int64_t subcmd, const char* buf, const int64_t len, int64_t& pos)
+  {
+    UNUSED(log_seq_num);
+    UNUSED(subcmd);
+    UNUSED(buf);
+    UNUSED(len);
+    UNUSED(pos);
+    return common::OB_SUCCESS;
+  }
+  virtual bool is_take_over_done(const common::ObPartitionKey& pkey) const
+  {
+    UNUSED(pkey);
+    return true;
+  }
+  virtual int create_partition(const common::ObPartitionKey& key, const common::ObVersion data_version,
+      const int64_t replica_num, const common::ObMemberList& mem_list)
+  {
+    UNUSED(key);
+    UNUSED(data_version);
+    UNUSED(replica_num);
+    UNUSED(mem_list);
+    return common::OB_SUCCESS;
+  }
+  virtual int migrate_partition(const common::ObPartitionKey& key, const common::ObAddr& src, const common::ObAddr& dst,
+      const bool keep_src, const int64_t offline_ts)
+  {
+    UNUSED(key);
+    UNUSED(src);
+    UNUSED(dst);
+    UNUSED(keep_src);
+    UNUSED(offline_ts);
+    return OB_SUCCESS;
+  }
+  virtual int online_partition()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int offline_partition(const common::ObPartitionKey& leader_key, const common::ObAddr& server)
+  {
+    UNUSED(leader_key);
+    UNUSED(server);
+    return common::OB_SUCCESS;
+  }
+  virtual int remove_partition(const common::ObPartitionKey& key)
+  {
+    UNUSED(key);
+    return common::OB_SUCCESS;
+  }
+  virtual int remove_orphans()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int freeze()
+  {
+    return common::OB_SUCCESS;
+  }
+  virtual int on_leader_revoke(const common::ObPartitionKey& partition_key)
+  {
+    UNUSED(partition_key);
+    return common::OB_SUCCESS;
+  }
+  virtual int on_leader_takeover(const common::ObPartitionKey& partition_key)
+  {
+    UNUSED(partition_key);
+    return common::OB_SUCCESS;
+  }
+  virtual int on_member_change_success(const oceanbase::common::ObPartitionKey& a, int64_t b,
+      const oceanbase::common::ObMemberList& c, const oceanbase::common::ObMemberList& d)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    return common::OB_SUCCESS;
+  }
+  virtual int64_t get_min_using_file_id() const
+  {
+    return 0;
+  }
+
+  // ==========================================================================
+  // replay engin interfaces
+  virtual int start_replay(const common::ObPartitionKey& partition_key)
+  {
+    UNUSED(partition_key);
+    return common::OB_SUCCESS;
+  }
+  virtual int submit_replay_task(
+      const common::ObPartitionKey& partition_key, const char* log_buf, const int64_t buf_len)
+  {
+    UNUSED(partition_key);
+    UNUSED(log_buf);
+    UNUSED(buf_len);
+    return common::OB_SUCCESS;
+  }
+  virtual int finish_replay(const common::ObPartitionKey& partition_key)
+  {
+    UNUSED(partition_key);
+    return common::OB_SUCCESS;
+  }
+
+  // ==========================================================================
+  virtual int table_scan(ObTableScanParam& param, common::ObNewRowIterator*& result)
+  {
+    UNUSED(param);
+    UNUSED(result);
+    return common::OB_SUCCESS;
+  }
+  virtual int revert_scan_iter(common::ObNewRowIterator* iter)
+  {
+    UNUSED(iter);
+    return common::OB_SUCCESS;
+  }
+  virtual int delete_rows(const transaction::ObTransDesc& trans_desc, const int64_t timeout, const uint64_t table_id,
+      const int32_t partition_idx, const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter,
+      int64_t& affected_rows)
+  {
+    UNUSED(trans_desc);
+    UNUSED(timeout);
+    UNUSED(table_id);
+    UNUSED(partition_idx);
+    UNUSED(column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int insert_rows(const transaction::ObTransDesc& trans_desc, const int64_t timeout, const uint64_t table_id,
+      const int32_t partition_idx, const common::ObIArray<uint64_t>& column_ids, common::ObNewRowIterator* row_iter,
+      int64_t& affected_rows)
+  {
+    UNUSED(trans_desc);
+    UNUSED(timeout);
+    UNUSED(table_id);
+    UNUSED(partition_idx);
+    UNUSED(column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+  virtual int update_rows(const transaction::ObTransDesc& trans_desc, const int64_t timeout, const uint64_t table_id,
+      const int32_t partition_idx, const common::ObIArray<uint64_t>& column_ids,
+      const common::ObIArray<uint64_t>& updated_column_ids, common::ObNewRowIterator* row_iter, int64_t& affected_rows)
+  {
+    UNUSED(trans_desc);
+    UNUSED(timeout);
+    UNUSED(table_id);
+    UNUSED(partition_idx);
+    UNUSED(column_ids);
+    UNUSED(updated_column_ids);
+    UNUSED(row_iter);
+    UNUSED(affected_rows);
+    return common::OB_SUCCESS;
+  }
+
+  // ==========================================================================
+  // partition manager interfaces
+  virtual int get_all_partitions(common::ObIArray<ObIPartitionGroup*>& partition_list)
+  {
+    UNUSED(partition_list);
+    return common::OB_SUCCESS;
+  }
+
+  // ==========================================================================
+  // replay interfaces
+  virtual int replay(
+      const common::ObPartitionKey& partition_key, const ObStoreCtx& ctx, const char* data, const int64_t data_len)
+  {
+    UNUSED(partition_key);
+    UNUSED(ctx);
+    UNUSED(data);
+    UNUSED(data_len);
+    return common::OB_SUCCESS;
+  }
+  virtual int lock(const common::ObPartitionKey& partition_key, const ObStoreCtx& ctx)
+  {
+    UNUSED(partition_key);
+    UNUSED(ctx);
+    return common::OB_SUCCESS;
+  }
+  virtual int init(const blocksstable::ObStorageEnv& env, ObIPartitionComponentFactory* cp_fty,
+      share::schema::ObMultiVersionSchemaService* schema_service)
+  {
+    UNUSED(env);
+    UNUSED(cp_fty);
+    UNUSED(schema_service);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_role(const oceanbase::common::ObPartitionKey& key, oceanbase::common::ObRole& role) const
+  {
+    UNUSED(key);
+    UNUSED(role);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_leader_curr_member_list(
+      const oceanbase::common::ObPartitionKey& key, oceanbase::common::ObMemberList& list) const
+  {
+    UNUSED(key);
+    UNUSED(list);
+    return common::OB_SUCCESS;
+  }
+  virtual int delete_rows(const oceanbase::transaction::ObTransDesc& a, int64_t b,
+      const oceanbase::common::ObPartitionKey& c, const oceanbase::common::ObIArray<long unsigned int>& d,
+      oceanbase::common::ObNewRowIterator* e, int64_t& f)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    UNUSED(e);
+    UNUSED(f);
+    return common::OB_SUCCESS;
+  }
+  virtual int insert_rows(const oceanbase::transaction::ObTransDesc& a, int64_t b,
+      const oceanbase::common::ObPartitionKey& c, const oceanbase::common::ObIArray<long unsigned int>& d,
+      oceanbase::common::ObNewRowIterator* e, int64_t& f)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    UNUSED(e);
+    UNUSED(f);
+    return common::OB_SUCCESS;
+  }
+  virtual int update_rows(const oceanbase::transaction::ObTransDesc& a, int64_t b,
+      const oceanbase::common::ObPartitionKey& c, const oceanbase::common::ObIArray<long unsigned int>& d,
+      const oceanbase::common::ObIArray<long unsigned int>& e, oceanbase::common::ObNewRowIterator* f, int64_t& g)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    UNUSED(e);
+    UNUSED(f);
+    UNUSED(g);
+    return common::OB_SUCCESS;
+  }
+  virtual int lock_rows(const oceanbase::transaction::ObTransDesc& a, int64_t b,
+      const oceanbase::common::ObPartitionKey& c, oceanbase::common::ObNewRowIterator* d,
+      oceanbase::storage::ObLockFlag e, int64_t& f)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    UNUSED(e);
+    UNUSED(f);
+    return common::OB_SUCCESS;
+  }
+  virtual int lock_rows(const oceanbase::transaction::ObTransDesc& a, int64_t b,
+      const oceanbase::common::ObPartitionKey& c, const oceanbase::common::ObNewRow& d,
+      oceanbase::storage::ObLockFlag e)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    UNUSED(e);
+    return common::OB_SUCCESS;
+  }
+  virtual int replay_redo_log(const oceanbase::common::ObPartitionKey& a, const oceanbase::storage::ObStoreCtx& b,
+      const int64_t ts, const char* c, int64_t d)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(ts);
+    UNUSED(c);
+    UNUSED(d);
+    return common::OB_SUCCESS;
+  }
+  virtual int prepare_freeze(const oceanbase::obrpc::ObPartitionList& a, int64_t b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int commit_freeze(const oceanbase::obrpc::ObPartitionList& a, int64_t b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int abort_freeze(const oceanbase::obrpc::ObPartitionList& a, int64_t b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int set_freeze_status(const oceanbase::common::ObPartitionKey& a, int64_t b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_freeze_status(const oceanbase::common::ObPartitionKey& a, int64_t& b, int64_t& c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_freeze_status(const oceanbase::common::ObPartitionKey& a, int64_t& b, int64_t& c, int64_t& d)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+    UNUSED(d);
+    return common::OB_SUCCESS;
+  }
+
+  void run1()
+  {
+    while (true) {
+      REPLAY_LOG(INFO, "partition service run");
+      usleep(10000);
+    }
+  }
+
+  virtual int replay(const oceanbase::common::ObPartitionKey& a, const char* b, int64_t c)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    UNUSED(c);
+
+    int64_t log_type_val = -1;
+    ObStorageLogType log_type;
+    int64_t pos = 0;
+    serialization::decode_i64(b, 1024, pos, &log_type_val);
+    log_type = static_cast<ObStorageLogType>(log_type_val);
+    REPLAY_LOG(INFO, "partition service replaying", K(log_type));
+    switch (log_type) {
+      case OB_LOG_MAJOR_FREEZE: {
+        // FIXME set frozen_version later
+        break;
+      }
+      default:
+        OB_ASSERT(false);
+    }
+    return common::OB_SUCCESS;
+  }
+  virtual int leader_freeze_success(const oceanbase::common::ObPartitionKey& a, int64_t b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int leader_freeze_fail(const oceanbase::common::ObPartitionKey& a, int64_t b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int follower_freeze_success(const oceanbase::common::ObPartitionKey& a, int64_t b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int follower_freeze_fail(const oceanbase::common::ObPartitionKey& a, int64_t b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int submit_freeze_log_success(int64_t a, const oceanbase::common::ObPartitionKey& b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+  virtual int get_active_memtable_version(const oceanbase::common::ObPartitionKey& a, int64_t& b)
+  {
+    UNUSED(a);
+    UNUSED(b);
+    return common::OB_SUCCESS;
+  }
+
+  virtual int get_status(const common::ObPartitionKey& partition, int64_t& status)
+  {
+    UNUSED(partition);
+    UNUSED(status);
+    return OB_SUCCESS;
+  }
+
+  private:
+  MockPartition mock_partition_;
+};
+
+}  // namespace unittest
+}  // namespace oceanbase
+
+#endif  // OCEANBASE_UNITTEST_MOCK_PARTITION_SERVICE_H_