121 lines
4.5 KiB
C++
121 lines
4.5 KiB
C++
// Copyright 2022 Memgraph Ltd.
|
|
//
|
|
// Use of this software is governed by the Business Source License
|
|
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
|
// License, and you may not use this file except in compliance with the Business Source License.
|
|
//
|
|
// As of the Change Date specified in that file, in accordance with
|
|
// the Business Source License, use of this software will be governed
|
|
// by the Apache License, Version 2.0, included in the file
|
|
// licenses/APL.txt.
|
|
|
|
#include "common.hpp"
|
|
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <optional>
|
|
#include <thread>
|
|
|
|
#include <fmt/format.h>
|
|
#include <gflags/gflags.h>
|
|
#include "utils/logging.hpp"
|
|
#include "utils/timer.hpp"
|
|
|
|
DEFINE_uint64(bolt_port, 7687, "Bolt port");
|
|
|
|
std::unique_ptr<mg::Client> ConnectWithUser(const std::string_view username) {
|
|
auto client = mg::Client::Connect({.host = "127.0.0.1",
|
|
.port = static_cast<uint16_t>(FLAGS_bolt_port),
|
|
.username = std::string{username},
|
|
.use_ssl = false});
|
|
MG_ASSERT(client, "Failed to connect!");
|
|
return client;
|
|
}
|
|
|
|
std::unique_ptr<mg::Client> Connect() { return ConnectWithUser(""); }
|
|
|
|
void CreateVertex(mg::Client &client, int vertex_id) {
|
|
mg::Map parameters{
|
|
{"id", mg::Value{vertex_id}},
|
|
};
|
|
client.Execute(fmt::format("CREATE (n: {} {{ id: $id }})", kVertexLabel), mg::ConstMap{parameters.ptr()});
|
|
client.DiscardAll();
|
|
}
|
|
|
|
void CreateEdge(mg::Client &client, int from_vertex, int to_vertex, int edge_id) {
|
|
mg::Map parameters{
|
|
{"from", mg::Value{from_vertex}},
|
|
{"to", mg::Value{to_vertex}},
|
|
{"id", mg::Value{edge_id}},
|
|
};
|
|
client.Execute(fmt::format("MATCH (from: {} {{ id: $from }}), (to: {} {{id: $to }}) "
|
|
"CREATE (from)-[r: {} {{id: $id}}]->(to)",
|
|
kVertexLabel, kVertexLabel, kEdgeLabel),
|
|
mg::ConstMap{parameters.ptr()});
|
|
client.DiscardAll();
|
|
}
|
|
|
|
int GetNumberOfAllVertices(mg::Client &client) {
|
|
client.Execute("MATCH (n) RETURN COUNT(*)");
|
|
const auto value = client.FetchOne();
|
|
MG_ASSERT(value, "Unexpected error");
|
|
MG_ASSERT(value->size() == 1, "Unexpected number of columns!");
|
|
client.FetchAll();
|
|
MG_ASSERT(value->at(0).type() == mg::Value::Type::Int, "Unexpected type!");
|
|
return value->at(0).ValueInt();
|
|
}
|
|
|
|
void WaitForNumberOfAllVertices(mg::Client &client, int number_of_vertices) {
|
|
using namespace std::chrono_literals;
|
|
memgraph::utils::Timer timer{};
|
|
while ((timer.Elapsed().count() <= 0.5) && GetNumberOfAllVertices(client) != number_of_vertices) {
|
|
}
|
|
CheckNumberOfAllVertices(client, number_of_vertices);
|
|
std::this_thread::sleep_for(100ms);
|
|
}
|
|
|
|
void CheckNumberOfAllVertices(mg::Client &client, int expected_number_of_vertices) {
|
|
const auto number_of_vertices = GetNumberOfAllVertices(client);
|
|
MG_ASSERT(number_of_vertices == expected_number_of_vertices, "There are {} vertices, expected {}!",
|
|
number_of_vertices, expected_number_of_vertices);
|
|
}
|
|
|
|
std::optional<mg::Value> GetVertex(mg::Client &client, std::string_view label, int vertex_id) {
|
|
mg::Map parameters{
|
|
{"id", mg::Value{vertex_id}},
|
|
};
|
|
|
|
client.Execute(fmt::format("MATCH (n: {} {{id: $id}}) RETURN n", label), mg::ConstMap{parameters.ptr()});
|
|
const auto result = client.FetchAll();
|
|
MG_ASSERT(result, "Vertex with label {} and id {} cannot be found!", label, vertex_id);
|
|
const auto &rows = *result;
|
|
MG_ASSERT(rows.size() <= 1, "Unexpected number of vertices with label {} and id {}, found {} vertices", label,
|
|
vertex_id, rows.size());
|
|
if (rows.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
return rows[0][0];
|
|
}
|
|
|
|
bool VertexExists(mg::Client &client, std::string_view label, int vertex_id) {
|
|
return GetVertex(client, label, vertex_id).has_value();
|
|
}
|
|
|
|
void CheckVertexMissing(mg::Client &client, std::string_view label, int vertex_id) {
|
|
MG_ASSERT(!VertexExists(client, label, vertex_id), "Not expected vertex exist with label {} and id {}!", label,
|
|
vertex_id);
|
|
}
|
|
|
|
void CheckVertexExists(mg::Client &client, std::string_view label, int vertex_id) {
|
|
MG_ASSERT(VertexExists(client, label, vertex_id), "Expected vertex doesn't exist with label {} and id {}!", label,
|
|
vertex_id);
|
|
}
|
|
|
|
void ExecuteCreateVertex(mg::Client &client, int id) {
|
|
client.Execute(fmt::format("CALL write.create_vertex({}) YIELD v RETURN v", id));
|
|
const auto v1 = client.FetchAll();
|
|
MG_ASSERT(v1);
|
|
MG_ASSERT(v1->size() == 1);
|
|
}
|