tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify Mocks and test

Browse Source
This commit is contained in:
Kostas Kyrimis 2022-12-12 19:15:49 +02:00
parent 2e4e975102
commit f04ed3c137
3 changed files with 73 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/query/v2/plan/operator.cpp
View File

@ -2468,7 +2468,7 @@ class DistributedCreateExpandCursor : public Cursor {
std::vector<msgs::NewExpand> ExpandCreationInfoToRequests(MultiFrame &multi_frame, ExecutionContext &context) const { std::vector<msgs::NewExpand> ExpandCreationInfoToRequests(MultiFrame &multi_frame, ExecutionContext &context) const {
std::vector<msgs::NewExpand> edge_requests; std::vector<msgs::NewExpand> edge_requests;
auto reader = multi_frame.GetValidFramesConsumer(); auto reader = multi_frame.GetValidFramesModifier();
for (auto &frame : reader) { for (auto &frame : reader) {
const auto &edge_info = self_.edge_info_; const auto &edge_info = self_.edge_info_;

89
tests/unit/mock_helpers.hpp
View File

@ -13,51 +13,70 @@
#include <gmock/gmock.h> #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "query/v2/common.hpp"
#include "query/v2/context.hpp"
#include "query/v2/plan/operator.hpp" #include "query/v2/plan/operator.hpp"
#include "query/v2/request_router.hpp" #include "query/v2/request_router.hpp"
namespace memgraph { namespace memgraph::query::v2 {
class MockedRequestRouter : public query::v2::RequestRouterInterface { class MockedRequestRouter : public RequestRouterInterface {
public: public:
MOCK_METHOD1(ScanVertices, std::vector<VertexAccessor>(std::optional<std::string> label)); MOCK_METHOD(std::vector<VertexAccessor>, ScanVertices, (std::optional<std::string> label));
MOCK_METHOD1(CreateVertices, std::vector<msgs::CreateVerticesResponse>(std::vector<msgs::NewVertex>)); MOCK_METHOD(std::vector<msgs::CreateVerticesResponse>, CreateVertices, (std::vector<msgs::NewVertex>));
MOCK_METHOD1(ExpandOne, std::vector<msgs::ExpandOneResultRow>(msgs::ExpandOneRequest)); MOCK_METHOD(std::vector<msgs::ExpandOneResultRow>, ExpandOne, (msgs::ExpandOneRequest));
MOCK_METHOD1(CreateExpand, std::vector<msgs::CreateExpandResponse>(std::vector<msgs::NewExpand>)); MOCK_METHOD(std::vector<msgs::CreateExpandResponse>, CreateExpand, (std::vector<msgs::NewExpand>));
MOCK_METHOD1(GetProperties, std::vector<msgs::GetPropertiesResultRow>(msgs::GetPropertiesRequest)); MOCK_METHOD(std::vector<msgs::GetPropertiesResultRow>, GetProperties, (msgs::GetPropertiesRequest));
MOCK_METHOD0(StartTransaction, void()); MOCK_METHOD(void, StartTransaction, ());
MOCK_METHOD0(Commit, void()); MOCK_METHOD(void, Commit, ());
MOCK_CONST_METHOD1(NameToEdgeType, storage::v3::EdgeTypeId(const std::string &)); MOCK_METHOD(storage::v3::EdgeTypeId, NameToEdgeType, (const std::string &), (const));
MOCK_CONST_METHOD1(NameToProperty, storage::v3::PropertyId(const std::string &)); MOCK_METHOD(storage::v3::PropertyId, NameToProperty, (const std::string &), (const));
MOCK_CONST_METHOD1(NameToLabel, storage::v3::LabelId(const std::string &)); MOCK_METHOD(storage::v3::LabelId, NameToLabel, (const std::string &), (const));
MOCK_CONST_METHOD1(LabelToName, storage::v3::LabelId(const std::string &)); MOCK_METHOD(storage::v3::LabelId, LabelToName, (const std::string &), (const));
MOCK_CONST_METHOD1(PropertyToName, const std::string &(storage::v3::PropertyId)); MOCK_METHOD(const std::string &, PropertyToName, (storage::v3::PropertyId), (const));
MOCK_CONST_METHOD1(LabelToName, const std::string &(storage::v3::LabelId label)); MOCK_METHOD(const std::string &, LabelToName, (storage::v3::LabelId label), (const));
MOCK_CONST_METHOD1(EdgeTypeToName, const std::string &(storage::v3::EdgeTypeId type)); MOCK_METHOD(const std::string &, EdgeTypeToName, (storage::v3::EdgeTypeId type), (const));
MOCK_CONST_METHOD1(MaybeNameToProperty, std::optional<storage::v3::PropertyId>(const std::string &)); MOCK_METHOD(std::optional<storage::v3::PropertyId>, MaybeNameToProperty, (const std::string &), (const));
MOCK_CONST_METHOD1(MaybeNameToEdgeType, std::optional<storage::v3::EdgeTypeId>(const std::string &)); MOCK_METHOD(std::optional<storage::v3::EdgeTypeId>, MaybeNameToEdgeType, (const std::string &), (const));
MOCK_CONST_METHOD1(MaybeNameToLabel, std::optional<storage::v3::LabelId>(const std::string &)); MOCK_METHOD(std::optional<storage::v3::LabelId>, MaybeNameToLabel, (const std::string &), (const));
MOCK_CONST_METHOD1(IsPrimaryLabel, bool(storage::v3::LabelId)); MOCK_METHOD(bool, IsPrimaryLabel, (storage::v3::LabelId), (const));
MOCK_CONST_METHOD2(IsPrimaryKey, bool(storage::v3::LabelId, storage::v3::PropertyId)); MOCK_METHOD(bool, IsPrimaryKey, (storage::v3::LabelId, storage::v3::PropertyId), (const));
}; };
class MockedLogicalOperator : query::v2::plan::LogicalOperator { class MockedLogicalOperator : public plan::LogicalOperator {
public: public:
MOCK_CONST_METHOD1(MakeCursor, query::v2::plan::UniqueCursorPtr(utils::MemoryResource *)); MOCK_METHOD(plan::UniqueCursorPtr, MakeCursor, (utils::MemoryResource *), (const));
MOCK_CONST_METHOD1(OutputSymbols, std::vector<expr::Symbol>(const expr::SymbolTable &)); MOCK_METHOD(std::vector<expr::Symbol>, ModifiedSymbols, (const expr::SymbolTable &), (const));
MOCK_CONST_METHOD1(ModifiedSymbols, std::vector<expr::Symbol>(const expr::SymbolTable &)); MOCK_METHOD(bool, HasSingleInput, (), (const));
MOCK_CONST_METHOD0(HasSingleInput, bool()); MOCK_METHOD(std::shared_ptr<LogicalOperator>, input, (), (const));
MOCK_CONST_METHOD0(input, std::shared_ptr<LogicalOperator>()); MOCK_METHOD(void, set_input, (std::shared_ptr<LogicalOperator>));
MOCK_METHOD1(set_input, void(std::shared_ptr<LogicalOperator>)); MOCK_METHOD(std::unique_ptr<LogicalOperator>, Clone, (AstStorage * storage), (const));
MOCK_CONST_METHOD1(Clone, std::unique_ptr<LogicalOperator>(query::v2::AstStorage *storage)); MOCK_METHOD(bool, Accept, (plan::HierarchicalLogicalOperatorVisitor & visitor));
}; };
class MockedCursor : memgraph::query::v2::plan::Cursor { class MockedCursor : public plan::Cursor {
public: public:
MOCK_METHOD2(Pull, bool(query::v2::Frame &, expr::ExecutionContext &)); MOCK_METHOD(bool, Pull, (Frame &, expr::ExecutionContext &));
MOCK_METHOD2(PullMultiple, void(query::v2::MultiFrame &, expr::ExecutionContext &)); MOCK_METHOD(void, PullMultiple, (MultiFrame &, expr::ExecutionContext &));
MOCK_METHOD0(Reset, void()); MOCK_METHOD(void, Reset, ());
MOCK_METHOD0(Shutdown, void()); MOCK_METHOD(void, Shutdown, ());
}; };
} // namespace memgraph inline expr::ExecutionContext MakeContext(const expr::AstStorage &storage, const expr::SymbolTable &symbol_table,
RequestRouterInterface *router, IdAllocator *id_alloc) {
expr::ExecutionContext context;
context.symbol_table = symbol_table;
context.evaluation_context.properties = NamesToProperties(storage.properties_, router);
context.evaluation_context.labels = NamesToLabels(storage.labels_, router);
context.edge_ids_alloc = id_alloc;
context.request_router = router;
return context;
}
inline MockedLogicalOperator &BaseToMock(plan::LogicalOperator *op) {
return *static_cast<MockedLogicalOperator *>(op);
}
inline MockedCursor &BaseToMock(plan::Cursor *cursor) { return *static_cast<MockedCursor *>(cursor); }
} // namespace memgraph::query::v2

45
tests/unit/query_v2_create_expand_multiframe.cpp
View File

@ -9,6 +9,7 @@
// by the Apache License, Version 2.0, included in the file // by the Apache License, Version 2.0, included in the file
// licenses/APL.txt. // licenses/APL.txt.
#include <memory>
#include "mock_helpers.hpp" #include "mock_helpers.hpp"
#include "query/v2/bindings/frame.hpp" #include "query/v2/bindings/frame.hpp"
@ -22,24 +23,7 @@
#include "utils/logging.hpp" #include "utils/logging.hpp"
#include "utils/memory.hpp" #include "utils/memory.hpp"
using namespace memgraph::query::v2; namespace memgraph::query::v2 {
using namespace memgraph::query::v2::plan;
namespace memgraph {
class TestTemplate : public testing::Test {
protected:
void SetUp() override {}
};
ExecutionContext MakeContext(const AstStorage &storage, const SymbolTable &symbol_table, RequestRouterInterface *router,
IdAllocator *id_alloc) {
ExecutionContext context;
context.symbol_table = symbol_table;
context.evaluation_context.properties = NamesToProperties(storage.properties_, router);
context.evaluation_context.labels = NamesToLabels(storage.labels_, router);
context.edge_ids_alloc = id_alloc;
context.request_router = router;
return context;
}
MultiFrame CreateMultiFrame(const size_t max_pos, const Symbol &src, const Symbol &dst, MockedRequestRouter *router) { MultiFrame CreateMultiFrame(const size_t max_pos, const Symbol &src, const Symbol &dst, MockedRequestRouter *router) {
static constexpr size_t frame_size = 100; static constexpr size_t frame_size = 100;
@ -60,14 +44,15 @@ MultiFrame CreateMultiFrame(const size_t max_pos, const Symbol &src, const Symbo
return multi_frame; return multi_frame;
} }
TEST_F(TestTemplate, CreateExpand) { TEST(CreateExpandTest, Cursor) {
MockedRequestRouter router; using testing::_;
using testing::Return;
AstStorage ast; AstStorage ast;
SymbolTable symbol_table; SymbolTable symbol_table;
query::v2::plan::NodeCreationInfo node; plan::NodeCreationInfo node;
query::v2::plan::EdgeCreationInfo edge; plan::EdgeCreationInfo edge;
edge.edge_type = msgs::EdgeTypeId::FromUint(1); edge.edge_type = msgs::EdgeTypeId::FromUint(1);
edge.direction = EdgeAtom::Direction::IN; edge.direction = EdgeAtom::Direction::IN;
auto id_alloc = IdAllocator(0, 100); auto id_alloc = IdAllocator(0, 100);
@ -75,14 +60,20 @@ TEST_F(TestTemplate, CreateExpand) {
const auto &src = symbol_table.CreateSymbol("n", true); const auto &src = symbol_table.CreateSymbol("n", true);
node.symbol = symbol_table.CreateSymbol("u", true); node.symbol = symbol_table.CreateSymbol("u", true);
auto create_expand = query::v2::plan::CreateExpand(node, edge, nullptr, src, true); auto once_cur = plan::MakeUniqueCursorPtr<MockedCursor>(utils::NewDeleteResource());
EXPECT_CALL(BaseToMock(once_cur.get()), PullMultiple(_, _)).Times(1);
std::shared_ptr<plan::LogicalOperator> once_op = std::make_shared<MockedLogicalOperator>();
EXPECT_CALL(BaseToMock(once_op.get()), MakeCursor(_)).Times(1).WillOnce(Return(std::move(once_cur)));
auto create_expand = plan::CreateExpand(node, edge, once_op, src, true);
auto cursor = create_expand.MakeCursor(utils::NewDeleteResource()); auto cursor = create_expand.MakeCursor(utils::NewDeleteResource());
EXPECT_CALL(router, CreateExpand(testing::_)) MockedRequestRouter router;
.Times(1) EXPECT_CALL(router, CreateExpand(_)).Times(1).WillOnce(Return(std::vector<msgs::CreateExpandResponse>{}));
.WillOnce(::testing::Return(std::vector<msgs::CreateExpandResponse>{}));
auto context = MakeContext(ast, symbol_table, &router, &id_alloc); auto context = MakeContext(ast, symbol_table, &router, &id_alloc);
auto multi_frame = CreateMultiFrame(context.symbol_table.max_position(), src, node.symbol, &router); auto multi_frame = CreateMultiFrame(context.symbol_table.max_position(), src, node.symbol, &router);
cursor->PullMultiple(multi_frame, context); cursor->PullMultiple(multi_frame, context);
} }
} // namespace memgraph
} // namespace memgraph::query::v2