blob: ddfe288ede3fb0d0de9756aeddca84f54a18f925 [file] [log] [blame]
/*
* Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
* Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
*
* Written by Václav Kubernát <kubervac@fit.cvut.cz>
*
*/
#include "trompeloeil_doctest.hpp"
#include <sysrepo-cpp/Session.hpp>
#include "proxy_datastore.hpp"
#include "yang_schema.hpp"
#ifdef sysrepo_BACKEND
#include "sysrepo_access.hpp"
using OnInvalidSchemaPathCreate = DatastoreException;
using OnInvalidSchemaPathDelete = DatastoreException;
using OnInvalidSchemaPathMove = sysrepo::sysrepo_exception;
using OnInvalidRpcPath = sysrepo::sysrepo_exception;
using OnKeyNotFound = void;
using OnExec = void;
#elif defined(netconf_BACKEND)
using OnInvalidSchemaPathCreate = std::runtime_error;
using OnInvalidSchemaPathDelete = std::runtime_error;
using OnInvalidSchemaPathMove = std::runtime_error;
using OnInvalidRpcPath = std::runtime_error;
using OnKeyNotFound = std::runtime_error;
using OnExec = void;
#include "netconf_access.hpp"
#elif defined(yang_BACKEND)
#include <fstream>
#include "yang_access.hpp"
#include "yang_access_test_vars.hpp"
using OnInvalidSchemaPathCreate = DatastoreException;
using OnInvalidSchemaPathDelete = DatastoreException;
using OnInvalidSchemaPathMove = DatastoreException;
using OnInvalidRpcPath = DatastoreException;
using OnKeyNotFound = DatastoreException;
using OnExec = std::logic_error;
#else
#error "Unknown backend"
#endif
#include "pretty_printers.hpp"
#include "sysrepo_subscription.hpp"
#include "utils.hpp"
using namespace std::literals::string_literals;
class MockRecorder : public trompeloeil::mock_interface<Recorder> {
public:
IMPLEMENT_MOCK3(write);
};
class MockDataSupplier : public trompeloeil::mock_interface<DataSupplier> {
public:
IMPLEMENT_CONST_MOCK1(get_data);
};
namespace {
template <class ...> constexpr std::false_type always_false [[maybe_unused]] {};
template <class Exception, typename Callable> void catching(const Callable& what) {
if constexpr (std::is_same_v<Exception, void>) {
what();
} else if constexpr (std::is_same<Exception, std::runtime_error>()) {
// cannot use REQUIRE_THROWS_AS(..., Exception) directly because that one
// needs an extra `typename` deep in the bowels of doctest
REQUIRE_THROWS_AS(what(), std::runtime_error);
} else if constexpr (std::is_same<Exception, std::logic_error>()) {
REQUIRE_THROWS_AS(what(), std::logic_error);
} else if constexpr (std::is_same<Exception, DatastoreException>()) {
REQUIRE_THROWS_AS(what(), DatastoreException);
} else if constexpr (std::is_same<Exception, sysrepo::sysrepo_exception>()) {
REQUIRE_THROWS_AS(what(), sysrepo::sysrepo_exception);
} else {
static_assert(always_false<Exception>); // https://stackoverflow.com/a/53945549/2245623
}
}
}
#if defined(yang_BACKEND)
class TestYangAccess : public YangAccess {
public:
void commitChanges() override
{
YangAccess::commitChanges();
dumpToSysrepo();
}
void copyConfig(const Datastore source, const Datastore destination) override
{
YangAccess::copyConfig(source, destination);
dumpToSysrepo();
}
private:
void dumpToSysrepo()
{
{
std::ofstream of(testConfigFile);
of << dump(DataFormat::Xml);
}
auto command = std::string(sysrepocfgExecutable) + " --import=" + testConfigFile + " --format=xml --datastore=running --module=example-schema -w";
REQUIRE(std::system(command.c_str()) == 0);
}
};
#endif
TEST_CASE("setting/getting values")
{
sr_log_stderr(SR_LL_DBG);
trompeloeil::sequence seq1;
MockRecorder mock;
{
auto conn = std::make_shared<sysrepo::Connection>();
auto sess = std::make_shared<sysrepo::Session>(conn);
sess->copy_config(SR_DS_STARTUP, "example-schema", 1000, true);
}
SysrepoSubscription subscription("example-schema", &mock);
#ifdef sysrepo_BACKEND
SysrepoAccess datastore(Datastore::Running);
#elif defined(netconf_BACKEND)
const auto NETOPEER_SOCKET = getenv("NETOPEER_SOCKET");
NetconfAccess datastore(NETOPEER_SOCKET);
#elif defined(yang_BACKEND)
TestYangAccess datastore;
datastore.addSchemaDir(schemaDir);
datastore.addSchemaFile(exampleSchemaFile);
#else
#error "Unknown backend"
#endif
SECTION("set leafInt8 to -128")
{
REQUIRE_CALL(mock, write("/example-schema:leafInt8", std::nullopt, "-128"s));
datastore.setLeaf("/example-schema:leafInt8", int8_t{-128});
datastore.commitChanges();
}
SECTION("set leafInt16 to -32768")
{
REQUIRE_CALL(mock, write("/example-schema:leafInt16", std::nullopt, "-32768"s));
datastore.setLeaf("/example-schema:leafInt16", int16_t{-32768});
datastore.commitChanges();
}
SECTION("set leafInt32 to -2147483648")
{
REQUIRE_CALL(mock, write("/example-schema:leafInt32", std::nullopt, "-2147483648"s));
datastore.setLeaf("/example-schema:leafInt32", int32_t{-2147483648});
datastore.commitChanges();
}
SECTION("set leafInt64 to -50000000000")
{
REQUIRE_CALL(mock, write("/example-schema:leafInt64", std::nullopt, "-50000000000"s));
datastore.setLeaf("/example-schema:leafInt64", int64_t{-50000000000});
datastore.commitChanges();
}
SECTION("set leafUInt8 to 255")
{
REQUIRE_CALL(mock, write("/example-schema:leafUInt8", std::nullopt, "255"s));
datastore.setLeaf("/example-schema:leafUInt8", uint8_t{255});
datastore.commitChanges();
}
SECTION("set leafUInt16 to 65535")
{
REQUIRE_CALL(mock, write("/example-schema:leafUInt16", std::nullopt, "65535"s));
datastore.setLeaf("/example-schema:leafUInt16", uint16_t{65535});
datastore.commitChanges();
}
SECTION("set leafUInt32 to 4294967295")
{
REQUIRE_CALL(mock, write("/example-schema:leafUInt32", std::nullopt, "4294967295"s));
datastore.setLeaf("/example-schema:leafUInt32", uint32_t{4294967295});
datastore.commitChanges();
}
SECTION("set leafUInt64 to 50000000000")
{
REQUIRE_CALL(mock, write("/example-schema:leafUInt64", std::nullopt, "50000000000"s));
datastore.setLeaf("/example-schema:leafUInt64", uint64_t{50000000000});
datastore.commitChanges();
}
SECTION("set leafEnum to coze")
{
REQUIRE_CALL(mock, write("/example-schema:leafEnum", std::nullopt, "coze"s));
datastore.setLeaf("/example-schema:leafEnum", enum_{"coze"});
datastore.commitChanges();
}
SECTION("set leafDecimal to 123.544")
{
REQUIRE_CALL(mock, write("/example-schema:leafDecimal", std::nullopt, "123.544"s));
datastore.setLeaf("/example-schema:leafDecimal", 123.544);
datastore.commitChanges();
}
SECTION("set a string, then delete it")
{
REQUIRE_CALL(mock, write("/example-schema:leafString", std::nullopt, "blah"s));
datastore.setLeaf("/example-schema:leafString", "blah"s);
datastore.commitChanges();
DatastoreAccess::Tree expected{{"/example-schema:leafString", "blah"s}};
REQUIRE(datastore.getItems("/example-schema:leafString") == expected);
REQUIRE_CALL(mock, write("/example-schema:leafString", "blah"s, std::nullopt));
datastore.deleteItem("/example-schema:leafString");
datastore.commitChanges();
expected.clear();
REQUIRE(datastore.getItems("/example-schema:leafString") == expected);
}
SECTION("set a non-existing leaf")
{
catching<OnInvalidSchemaPathCreate>([&] {
datastore.setLeaf("/example-schema:non-existing", "what"s);
});
}
SECTION("create presence container")
{
REQUIRE(datastore.dump(DataFormat::Json).find("example-schema:pContainer") == std::string::npos);
REQUIRE_CALL(mock, write("/example-schema:pContainer", std::nullopt, ""s));
datastore.createItem("/example-schema:pContainer");
datastore.commitChanges();
REQUIRE(datastore.dump(DataFormat::Json).find("example-schema:pContainer") != std::string::npos);
}
SECTION("create/delete a list instance")
{
{
REQUIRE_CALL(mock, write("/example-schema:person[name='Nguyen']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Nguyen']/name", std::nullopt, "Nguyen"s));
datastore.createItem("/example-schema:person[name='Nguyen']");
datastore.commitChanges();
}
{
REQUIRE_CALL(mock, write("/example-schema:person[name='Nguyen']", ""s, std::nullopt));
REQUIRE_CALL(mock, write("/example-schema:person[name='Nguyen']/name", "Nguyen"s, std::nullopt));
datastore.deleteItem("/example-schema:person[name='Nguyen']");
datastore.commitChanges();
}
}
SECTION("deleting non-existing list keys")
{
catching<OnKeyNotFound>([&] {
datastore.deleteItem("/example-schema:person[name='non existing']");
datastore.commitChanges();
});
}
SECTION("accessing non-existing schema nodes as a list")
{
catching<OnInvalidSchemaPathCreate>([&] {
datastore.createItem("/example-schema:non-existing-list[xxx='blah']");
datastore.commitChanges();
});
catching<OnInvalidSchemaPathDelete>([&] {
datastore.deleteItem("/example-schema:non-existing-list[xxx='non existing']");
datastore.commitChanges();
});
}
SECTION("leafref pointing to a key of a list")
{
{
REQUIRE_CALL(mock, write("/example-schema:person[name='Dan']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Dan']/name", std::nullopt, "Dan"s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Elfi']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Elfi']/name", std::nullopt, "Elfi"s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Kolafa']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Kolafa']/name", std::nullopt, "Kolafa"s));
datastore.createItem("/example-schema:person[name='Dan']");
datastore.createItem("/example-schema:person[name='Elfi']");
datastore.createItem("/example-schema:person[name='Kolafa']");
datastore.commitChanges();
}
std::string value;
SECTION("Dan")
{
value = "Dan";
}
SECTION("Elfi")
{
value = "Elfi";
}
SECTION("Kolafa")
{
value = "Kolafa";
}
datastore.setLeaf("/example-schema:bossPerson", value);
{
REQUIRE_CALL(mock, write("/example-schema:bossPerson", std::nullopt, value));
datastore.commitChanges();
}
REQUIRE(datastore.getItems("/example-schema:bossPerson") == DatastoreAccess::Tree{{"/example-schema:bossPerson", value}});
}
SECTION("bool values get correctly represented as bools")
{
{
REQUIRE_CALL(mock, write("/example-schema:down", std::nullopt, "true"s));
datastore.setLeaf("/example-schema:down", bool{true});
datastore.commitChanges();
}
DatastoreAccess::Tree expected{{"/example-schema:down", bool{true}}};
REQUIRE(datastore.getItems("/example-schema:down") == expected);
}
SECTION("getting items from the whole module")
{
{
REQUIRE_CALL(mock, write("/example-schema:up", std::nullopt, "true"s));
REQUIRE_CALL(mock, write("/example-schema:down", std::nullopt, "false"s));
datastore.setLeaf("/example-schema:up", bool{true});
datastore.setLeaf("/example-schema:down", bool{false});
datastore.commitChanges();
}
DatastoreAccess::Tree expected{
{"/example-schema:up", bool{true}},
{"/example-schema:down", bool{false}}
};
REQUIRE(datastore.getItems("/example-schema:*") == expected);
}
SECTION("getItems returns correct datatypes")
{
{
REQUIRE_CALL(mock, write("/example-schema:leafEnum", std::nullopt, "lol"s));
datastore.setLeaf("/example-schema:leafEnum", enum_{"lol"});
datastore.commitChanges();
}
DatastoreAccess::Tree expected{{"/example-schema:leafEnum", enum_{"lol"}}};
REQUIRE(datastore.getItems("/example-schema:leafEnum") == expected);
}
SECTION("getItems on a list")
{
{
REQUIRE_CALL(mock, write("/example-schema:person[name='Jan']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Jan']/name", std::nullopt, "Jan"s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Michal']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Michal']/name", std::nullopt, "Michal"s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Petr']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:person[name='Petr']/name", std::nullopt, "Petr"s));
datastore.createItem("/example-schema:person[name='Jan']");
datastore.createItem("/example-schema:person[name='Michal']");
datastore.createItem("/example-schema:person[name='Petr']");
datastore.commitChanges();
}
DatastoreAccess::Tree expected{
{"/example-schema:person[name='Jan']", special_{SpecialValue::List}},
{"/example-schema:person[name='Jan']/name", std::string{"Jan"}},
{"/example-schema:person[name='Michal']", special_{SpecialValue::List}},
{"/example-schema:person[name='Michal']/name", std::string{"Michal"}},
{"/example-schema:person[name='Petr']", special_{SpecialValue::List}},
{"/example-schema:person[name='Petr']/name", std::string{"Petr"}}
};
REQUIRE(datastore.getItems("/example-schema:person") == expected);
}
SECTION("presence containers")
{
DatastoreAccess::Tree expected;
// Make sure it's not there before we create it
REQUIRE(datastore.getItems("/example-schema:pContainer") == expected);
{
REQUIRE_CALL(mock, write("/example-schema:pContainer", std::nullopt, ""s));
datastore.createItem("/example-schema:pContainer");
datastore.commitChanges();
}
expected = {
{"/example-schema:pContainer", special_{SpecialValue::PresenceContainer}}
};
REQUIRE(datastore.getItems("/example-schema:pContainer") == expected);
// Make sure it's not there after we delete it
{
REQUIRE_CALL(mock, write("/example-schema:pContainer", ""s, std::nullopt));
datastore.deleteItem("/example-schema:pContainer");
datastore.commitChanges();
}
expected = {};
REQUIRE(datastore.getItems("/example-schema:pContainer") == expected);
}
SECTION("creating a non-existing schema node as a container")
{
catching<OnInvalidSchemaPathCreate>([&] {
datastore.createItem("/example-schema:non-existing-presence-container");
datastore.commitChanges();
});
}
SECTION("deleting a non-existing schema node as a container or leaf")
{
catching<OnInvalidSchemaPathDelete>([&] {
datastore.deleteItem("/example-schema:non-existing-presence-container");
datastore.commitChanges();
});
}
SECTION("nested presence container")
{
DatastoreAccess::Tree expected;
// Make sure it's not there before we create it
REQUIRE(datastore.getItems("/example-schema:inventory/stuff") == expected);
{
REQUIRE_CALL(mock, write("/example-schema:inventory/stuff", std::nullopt, ""s));
datastore.createItem("/example-schema:inventory/stuff");
datastore.commitChanges();
}
expected = {
{"/example-schema:inventory/stuff", special_{SpecialValue::PresenceContainer}}
};
REQUIRE(datastore.getItems("/example-schema:inventory/stuff") == expected);
{
REQUIRE_CALL(mock, write("/example-schema:inventory/stuff", ""s, std::nullopt));
datastore.deleteItem("/example-schema:inventory/stuff");
datastore.commitChanges();
}
expected = {};
REQUIRE(datastore.getItems("/example-schema:inventory/stuff") == expected);
}
SECTION("floats")
{
datastore.setLeaf("/example-schema:leafDecimal", 123.4);
REQUIRE_CALL(mock, write("/example-schema:leafDecimal", std::nullopt, "123.4"s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:leafDecimal", 123.4},
};
REQUIRE(datastore.getItems("/example-schema:leafDecimal") == expected);
}
SECTION("unions")
{
datastore.setLeaf("/example-schema:unionIntString", int32_t{10});
REQUIRE_CALL(mock, write("/example-schema:unionIntString", std::nullopt, "10"s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:unionIntString", int32_t{10}},
};
REQUIRE(datastore.getItems("/example-schema:unionIntString") == expected);
}
SECTION("identityref")
{
datastore.setLeaf("/example-schema:beast", identityRef_{"example-schema", "Mammal"});
REQUIRE_CALL(mock, write("/example-schema:beast", std::nullopt, "example-schema:Mammal"s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:beast", identityRef_{"example-schema", "Mammal"}},
};
REQUIRE(datastore.getItems("/example-schema:beast") == expected);
datastore.setLeaf("/example-schema:beast", identityRef_{"Whale"});
REQUIRE_CALL(mock, write("/example-schema:beast", "example-schema:Mammal", "example-schema:Whale"s));
datastore.commitChanges();
expected = {
{"/example-schema:beast", identityRef_{"example-schema", "Whale"}},
};
REQUIRE(datastore.getItems("/example-schema:beast") == expected);
}
SECTION("binary")
{
datastore.setLeaf("/example-schema:blob", binary_{"cHduegByIQ=="s});
REQUIRE_CALL(mock, write("/example-schema:blob", std::nullopt, "cHduegByIQ=="s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:blob", binary_{"cHduegByIQ=="s}},
};
REQUIRE(datastore.getItems("/example-schema:blob") == expected);
}
SECTION("empty")
{
datastore.setLeaf("/example-schema:dummy", empty_{});
REQUIRE_CALL(mock, write("/example-schema:dummy", std::nullopt, ""s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:dummy", empty_{}},
};
REQUIRE(datastore.getItems("/example-schema:dummy") == expected);
}
SECTION("bits")
{
datastore.setLeaf("/example-schema:flags", bits_{{"sign", "carry"}});
REQUIRE_CALL(mock, write("/example-schema:flags", std::nullopt, "carry sign"s));
datastore.commitChanges();
DatastoreAccess::Tree expected{
{"/example-schema:flags", bits_{{"carry", "sign"}}},
};
REQUIRE(datastore.getItems("/example-schema:flags") == expected);
}
#if not defined(yang_BACKEND)
SECTION("operational data")
{
MockDataSupplier mockOpsData;
OperationalDataSubscription opsDataSub("example-schema", "/example-schema:temperature", mockOpsData);
OperationalDataSubscription opsDataSub2("example-schema", "/example-schema:users", mockOpsData);
DatastoreAccess::Tree expected;
std::string xpath;
SECTION("temperature")
{
expected = {{"/example-schema:temperature", int32_t{22}}};
xpath = "/example-schema:temperature";
}
SECTION("key-less lists")
{
expected = {
{"/example-schema:users/userList[1]", special_{SpecialValue::List}},
{"/example-schema:users/userList[1]/name", std::string{"John"}},
{"/example-schema:users/userList[1]/otherfield", std::string{"LOL"}},
{"/example-schema:users/userList[2]", special_{SpecialValue::List}},
{"/example-schema:users/userList[2]/name", std::string{"Foo"}},
{"/example-schema:users/userList[2]/otherfield", std::string{"Bar"}},
};
xpath = "/example-schema:users";
}
REQUIRE_CALL(mockOpsData, get_data(xpath)).RETURN(expected);
REQUIRE(datastore.getItems(xpath) == expected);
}
#endif
SECTION("leaf list")
{
DatastoreAccess::Tree expected;
REQUIRE_CALL(mock, write("/example-schema:addresses", std::nullopt, "0.0.0.0"s));
REQUIRE_CALL(mock, write("/example-schema:addresses", std::nullopt, "127.0.0.1"s));
datastore.createItem("/example-schema:addresses[.='0.0.0.0']");
datastore.createItem("/example-schema:addresses[.='127.0.0.1']");
datastore.commitChanges();
expected = {
{"/example-schema:addresses", special_{SpecialValue::LeafList}},
{"/example-schema:addresses[.='0.0.0.0']", "0.0.0.0"s},
{"/example-schema:addresses[.='127.0.0.1']", "127.0.0.1"s},
};
REQUIRE(datastore.getItems("/example-schema:addresses") == expected);
REQUIRE_CALL(mock, write("/example-schema:addresses", "0.0.0.0"s, std::nullopt));
datastore.deleteItem("/example-schema:addresses[.='0.0.0.0']");
datastore.commitChanges();
expected = {
{"/example-schema:addresses", special_{SpecialValue::LeafList}},
{"/example-schema:addresses[.='127.0.0.1']", "127.0.0.1"s},
};
REQUIRE(datastore.getItems("/example-schema:addresses") == expected);
REQUIRE_CALL(mock, write("/example-schema:addresses", "127.0.0.1"s, std::nullopt));
datastore.deleteItem("/example-schema:addresses[.='127.0.0.1']");
datastore.commitChanges();
expected = {};
REQUIRE(datastore.getItems("/example-schema:addresses") == expected);
}
SECTION("deleting a non-existing leaf-list")
{
catching<OnKeyNotFound>([&] {
datastore.deleteItem("/example-schema:addresses[.='non-existing']");
datastore.commitChanges();
});
}
SECTION("accessing a non-existing schema node as a leaf-list")
{
catching<OnInvalidSchemaPathCreate>([&] {
datastore.createItem("/example-schema:non-existing[.='non-existing']");
datastore.commitChanges();
});
catching<OnInvalidSchemaPathDelete>([&] {
datastore.deleteItem("/example-schema:non-existing[.='non-existing']");
datastore.commitChanges();
});
}
SECTION("copying data from startup refreshes the data")
{
{
REQUIRE(datastore.getItems("/example-schema:leafInt16") == DatastoreAccess::Tree{});
REQUIRE_CALL(mock, write("/example-schema:leafInt16", std::nullopt, "123"s));
datastore.setLeaf("/example-schema:leafInt16", int16_t{123});
datastore.commitChanges();
}
REQUIRE(datastore.getItems("/example-schema:leafInt16") == DatastoreAccess::Tree{{"/example-schema:leafInt16", int16_t{123}}});
REQUIRE_CALL(mock, write("/example-schema:leafInt16", "123"s, std::nullopt));
datastore.copyConfig(Datastore::Startup, Datastore::Running);
REQUIRE(datastore.getItems("/example-schema:leafInt16") == DatastoreAccess::Tree{});
}
SECTION("moving leaflist instances")
{
DatastoreAccess::Tree expected;
{
REQUIRE_CALL(mock, write("/example-schema:protocols", std::nullopt, "http"s));
// FIXME: Why no notifications for these??
// ... possibly because my subscription doesn't extract it properly?
// REQUIRE_CALL(mock, write("/example-schema:protocols", std::nullopt, "ftp"s));
// REQUIRE_CALL(mock, write("/example-schema:protocols", std::nullopt, "pop3"s));
REQUIRE_CALL(mock, write("/example-schema:protocols", "http"s, "ftp"s));
REQUIRE_CALL(mock, write("/example-schema:protocols", "ftp"s, "pop3"s));
datastore.createItem("/example-schema:protocols[.='http']");
datastore.createItem("/example-schema:protocols[.='ftp']");
datastore.createItem("/example-schema:protocols[.='pop3']");
datastore.commitChanges();
expected = {
{"/example-schema:protocols", special_{SpecialValue::LeafList}},
{"/example-schema:protocols[.='http']", "http"s},
{"/example-schema:protocols[.='ftp']", "ftp"s},
{"/example-schema:protocols[.='pop3']", "pop3"s},
};
REQUIRE(datastore.getItems("/example-schema:protocols") == expected);
}
std::string sourcePath;
SECTION("begin")
{
REQUIRE_CALL(mock, write("/example-schema:protocols", std::nullopt, "pop3"s));
sourcePath = "/example-schema:protocols[.='pop3']";
datastore.moveItem(sourcePath, yang::move::Absolute::Begin);
datastore.commitChanges();
expected = {
{"/example-schema:protocols", special_{SpecialValue::LeafList}},
{"/example-schema:protocols[.='pop3']", "pop3"s},
{"/example-schema:protocols[.='http']", "http"s},
{"/example-schema:protocols[.='ftp']", "ftp"s},
};
REQUIRE(datastore.getItems("/example-schema:protocols") == expected);
}
SECTION("end")
{
sourcePath = "/example-schema:protocols[.='http']";
REQUIRE_CALL(mock, write("/example-schema:protocols", "pop3"s, "http"s));
datastore.moveItem(sourcePath, yang::move::Absolute::End);
datastore.commitChanges();
expected = {
{"/example-schema:protocols", special_{SpecialValue::LeafList}},
{"/example-schema:protocols[.='ftp']", "ftp"s},
{"/example-schema:protocols[.='pop3']", "pop3"s},
{"/example-schema:protocols[.='http']", "http"s},
};
REQUIRE(datastore.getItems("/example-schema:protocols") == expected);
}
SECTION("after")
{
sourcePath = "/example-schema:protocols[.='http']";
REQUIRE_CALL(mock, write("/example-schema:protocols", "ftp"s, "http"s));
datastore.moveItem(sourcePath, yang::move::Relative{yang::move::Relative::Position::After, {{".", "ftp"s}}});
datastore.commitChanges();
expected = {
{"/example-schema:protocols", special_{SpecialValue::LeafList}},
{"/example-schema:protocols[.='ftp']", "ftp"s},
{"/example-schema:protocols[.='http']", "http"s},
{"/example-schema:protocols[.='pop3']", "pop3"s},
};
REQUIRE(datastore.getItems("/example-schema:protocols") == expected);
}
SECTION("before")
{
sourcePath = "/example-schema:protocols[.='http']";
REQUIRE_CALL(mock, write("/example-schema:protocols", "ftp"s, "http"s));
datastore.moveItem(sourcePath, yang::move::Relative{yang::move::Relative::Position::Before, {{".", "pop3"s}}});
datastore.commitChanges();
expected = {
{"/example-schema:protocols", special_{SpecialValue::LeafList}},
{"/example-schema:protocols[.='ftp']", "ftp"s},
{"/example-schema:protocols[.='http']", "http"s},
{"/example-schema:protocols[.='pop3']", "pop3"s},
};
REQUIRE(datastore.getItems("/example-schema:protocols") == expected);
}
}
SECTION("moving non-existing schema nodes")
{
catching<OnInvalidSchemaPathMove>([&] {
datastore.moveItem("/example-schema:non-existing", yang::move::Absolute::Begin);
datastore.commitChanges();
});
}
SECTION("moving list instances")
{
DatastoreAccess::Tree expected;
{
REQUIRE_CALL(mock, write("/example-schema:players[name='John']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:players[name='John']/name", std::nullopt, "John"s));
REQUIRE_CALL(mock, write("/example-schema:players[name='Eve']", ""s, ""s));
REQUIRE_CALL(mock, write("/example-schema:players[name='Eve']/name", std::nullopt, "Eve"s));
REQUIRE_CALL(mock, write("/example-schema:players[name='Adam']", ""s, ""s));
REQUIRE_CALL(mock, write("/example-schema:players[name='Adam']/name", std::nullopt, "Adam"s));
datastore.createItem("/example-schema:players[name='John']");
datastore.createItem("/example-schema:players[name='Eve']");
datastore.createItem("/example-schema:players[name='Adam']");
datastore.commitChanges();
expected = {
{"/example-schema:players[name='John']", special_{SpecialValue::List}},
{"/example-schema:players[name='John']/name", "John"s},
{"/example-schema:players[name='Eve']", special_{SpecialValue::List}},
{"/example-schema:players[name='Eve']/name", "Eve"s},
{"/example-schema:players[name='Adam']", special_{SpecialValue::List}},
{"/example-schema:players[name='Adam']/name", "Adam"s},
};
REQUIRE(datastore.getItems("/example-schema:players") == expected);
}
std::string sourcePath;
SECTION("begin")
{
sourcePath = "/example-schema:players[name='Adam']";
REQUIRE_CALL(mock, write("/example-schema:players[name='Adam']", std::nullopt, ""s));
datastore.moveItem(sourcePath, yang::move::Absolute::Begin);
datastore.commitChanges();
expected = {
{"/example-schema:players[name='Adam']", special_{SpecialValue::List}},
{"/example-schema:players[name='Adam']/name", "Adam"s},
{"/example-schema:players[name='John']", special_{SpecialValue::List}},
{"/example-schema:players[name='John']/name", "John"s},
{"/example-schema:players[name='Eve']", special_{SpecialValue::List}},
{"/example-schema:players[name='Eve']/name", "Eve"s},
};
REQUIRE(datastore.getItems("/example-schema:players") == expected);
}
SECTION("end")
{
sourcePath = "/example-schema:players[name='John']";
REQUIRE_CALL(mock, write("/example-schema:players[name='John']", ""s, ""s));
datastore.moveItem(sourcePath, yang::move::Absolute::End);
datastore.commitChanges();
expected = {
{"/example-schema:players[name='Eve']", special_{SpecialValue::List}},
{"/example-schema:players[name='Eve']/name", "Eve"s},
{"/example-schema:players[name='Adam']", special_{SpecialValue::List}},
{"/example-schema:players[name='Adam']/name", "Adam"s},
{"/example-schema:players[name='John']", special_{SpecialValue::List}},
{"/example-schema:players[name='John']/name", "John"s},
};
REQUIRE(datastore.getItems("/example-schema:players") == expected);
}
SECTION("after")
{
sourcePath = "/example-schema:players[name='John']";
REQUIRE_CALL(mock, write("/example-schema:players[name='John']", ""s, ""s));
datastore.moveItem(sourcePath, yang::move::Relative{yang::move::Relative::Position::After, {{"name", "Eve"s}}});
datastore.commitChanges();
expected = {
{"/example-schema:players[name='Eve']", special_{SpecialValue::List}},
{"/example-schema:players[name='Eve']/name", "Eve"s},
{"/example-schema:players[name='John']", special_{SpecialValue::List}},
{"/example-schema:players[name='John']/name", "John"s},
{"/example-schema:players[name='Adam']", special_{SpecialValue::List}},
{"/example-schema:players[name='Adam']/name", "Adam"s},
};
REQUIRE(datastore.getItems("/example-schema:players") == expected);
}
SECTION("before")
{
sourcePath = "/example-schema:players[name='John']";
REQUIRE_CALL(mock, write("/example-schema:players[name='John']", ""s, ""s));
datastore.moveItem(sourcePath, yang::move::Relative{yang::move::Relative::Position::Before, {{"name", "Adam"s}}});
datastore.commitChanges();
expected = {
{"/example-schema:players[name='Eve']", special_{SpecialValue::List}},
{"/example-schema:players[name='Eve']/name", "Eve"s},
{"/example-schema:players[name='John']", special_{SpecialValue::List}},
{"/example-schema:players[name='John']/name", "John"s},
{"/example-schema:players[name='Adam']", special_{SpecialValue::List}},
{"/example-schema:players[name='Adam']/name", "Adam"s},
};
REQUIRE(datastore.getItems("/example-schema:players") == expected);
}
}
SECTION("getting /")
{
{
REQUIRE_CALL(mock, write("/example-schema:leafInt32", std::nullopt, "64"s));
datastore.setLeaf("/example-schema:leafInt32", 64);
datastore.commitChanges();
}
DatastoreAccess::Tree expected{
{"/example-schema:leafInt32", 64}
};
// This tests if we at least get the data WE added.
REQUIRE(std::all_of(expected.begin(), expected.end(), [items = datastore.getItems("/")] (const auto& item) {
return std::find(items.begin(), items.end(), item) != items.end();
}));
}
SECTION("setting and removing without commit")
{
datastore.setLeaf("/example-schema:leafInt32", 64);
datastore.deleteItem("/example-schema:leafInt32");
}
SECTION("two key lists")
{
REQUIRE_CALL(mock, write("/example-schema:point[x='12'][y='10']", std::nullopt, ""s));
REQUIRE_CALL(mock, write("/example-schema:point[x='12'][y='10']/x", std::nullopt, "12"s));
REQUIRE_CALL(mock, write("/example-schema:point[x='12'][y='10']/y", std::nullopt, "10"s));
datastore.createItem("/example-schema:point[x='12'][y='10']");
datastore.commitChanges();
REQUIRE(datastore.dump(DataFormat::Json).find("example-schema:point") != std::string::npos);
}
waitForCompletionAndBitMore(seq1);
}
struct ActionCb {
int operator()(sysrepo::S_Session session,
const char* xpath,
[[maybe_unused]] const sysrepo::S_Vals input,
[[maybe_unused]] sr_event_t event,
[[maybe_unused]] uint32_t request_id,
sysrepo::S_Vals_Holder output)
{
if (session->get_context()->get_node(nullptr, xpath)->path(LYS_PATH_FIRST_PREFIX) == "/example-schema:ports/shutdown") {
auto buf = output->allocate(1);
buf->val(0)->set(joinPaths(xpath, "success").c_str(), true);
return SR_ERR_OK;
}
throw std::runtime_error("unrecognized RPC");
}
};
struct RpcCb {
int operator()([[maybe_unused]] sysrepo::S_Session session,
const char* xpath,
const sysrepo::S_Vals input,
[[maybe_unused]] sr_event_t event,
[[maybe_unused]] uint32_t request_id,
sysrepo::S_Vals_Holder output)
{
const auto nukes = "/example-schema:launch-nukes"s;
if (xpath == "/example-schema:noop"s || xpath == "/example-schema:fire"s) {
return SR_ERR_OK;
}
if (xpath == nukes) {
uint64_t kilotons = 0;
bool hasCities = false;
for (size_t i = 0; i < input->val_cnt(); ++i) {
const auto& val = input->val(i);
if (val->xpath() == nukes + "/payload") {
continue; // ignore, container
}
if (val->xpath() == nukes + "/description") {
continue; // unused
}
if (val->xpath() == nukes + "/payload/kilotons") {
kilotons = val->data()->get_uint64();
} else if (std::string_view{val->xpath()}.find(nukes + "/cities") == 0) {
hasCities = true;
} else {
throw std::runtime_error("RPC launch-nukes: unexpected input "s + val->xpath());
}
}
if (kilotons == 333'666) {
// magic, just do not generate any output. This is important because the NETCONF RPC returns just <ok/>.
return SR_ERR_OK;
}
auto buf = output->allocate(2);
size_t i = 0;
buf->val(i++)->set((nukes + "/blast-radius").c_str(), uint32_t{33'666});
buf->val(i++)->set((nukes + "/actual-yield").c_str(), static_cast<uint64_t>(1.33 * kilotons));
if (hasCities) {
buf = output->reallocate(output->val_cnt() + 2);
buf->val(i++)->set((nukes + "/damaged-places/targets[city='London']/city").c_str(), "London");
buf->val(i++)->set((nukes + "/damaged-places/targets[city='Berlin']/city").c_str(), "Berlin");
}
return SR_ERR_OK;
}
throw std::runtime_error("unrecognized RPC");
}
};
TEST_CASE("rpc/action")
{
trompeloeil::sequence seq1;
#ifdef sysrepo_BACKEND
auto datastore = std::make_shared<SysrepoAccess>(Datastore::Running);
#elif defined(netconf_BACKEND)
const auto NETOPEER_SOCKET = getenv("NETOPEER_SOCKET");
auto datastore = std::make_shared<NetconfAccess>(NETOPEER_SOCKET);
#elif defined(yang_BACKEND)
auto datastore = std::make_shared<YangAccess>();
datastore->addSchemaDir(schemaDir);
datastore->addSchemaFile(exampleSchemaFile);
#else
#error "Unknown backend"
#endif
auto srConn = std::make_shared<sysrepo::Connection>();
auto srSession = std::make_shared<sysrepo::Session>(srConn);
auto srSubscription = std::make_shared<sysrepo::Subscribe>(srSession);
auto rpcCb = std::make_shared<RpcCb>();
auto actionCb = std::make_shared<ActionCb>();
sysrepo::Logs{}.set_stderr(SR_LL_INF);
SysrepoSubscription subscription("example-schema", nullptr);
// careful here, sysrepo insists on module_change CBs being registered before RPC CBs, otherwise there's a memleak
srSubscription->rpc_subscribe("/example-schema:noop", RpcCb{}, 0, SR_SUBSCR_CTX_REUSE);
srSubscription->rpc_subscribe("/example-schema:launch-nukes", RpcCb{}, 0, SR_SUBSCR_CTX_REUSE);
srSubscription->rpc_subscribe("/example-schema:fire", RpcCb{}, 0, SR_SUBSCR_CTX_REUSE);
srSubscription->rpc_subscribe("/example-schema:ports/shutdown", ActionCb{}, 0, SR_SUBSCR_CTX_REUSE);
SECTION("rpc")
{
auto createTemporaryDatastore = [](const std::shared_ptr<DatastoreAccess>& datastore) {
return std::make_shared<YangAccess>(std::static_pointer_cast<YangSchema>(datastore->schema()));
};
ProxyDatastore proxyDatastore(datastore, createTemporaryDatastore);
// ProxyDatastore cannot easily read DatastoreAccess::Tree, so we need to set the input via create/setLeaf/etc.
SECTION("valid")
{
std::string rpc;
DatastoreAccess::Tree input, output;
SECTION("noop")
{
rpc = "/example-schema:noop";
proxyDatastore.initiate(rpc);
}
SECTION("small nuke")
{
rpc = "/example-schema:launch-nukes";
input = {
{"description", "dummy"s},
{"payload/kilotons", uint64_t{333'666}},
};
proxyDatastore.initiate(rpc);
proxyDatastore.setLeaf("/example-schema:launch-nukes/example-schema:payload/example-schema:kilotons", uint64_t{333'666});
// no data are returned
}
SECTION("small nuke")
{
rpc = "/example-schema:launch-nukes";
input = {
{"description", "dummy"s},
{"payload/kilotons", uint64_t{4}},
};
proxyDatastore.initiate(rpc);
proxyDatastore.setLeaf("/example-schema:launch-nukes/example-schema:payload/example-schema:kilotons", uint64_t{4});
output = {
{"blast-radius", uint32_t{33'666}},
{"actual-yield", uint64_t{5}},
};
}
SECTION("with lists")
{
rpc = "/example-schema:launch-nukes";
input = {
{"payload/kilotons", uint64_t{6}},
{"cities/targets[city='Prague']/city", "Prague"s},
};
proxyDatastore.initiate(rpc);
proxyDatastore.setLeaf("/example-schema:launch-nukes/example-schema:payload/example-schema:kilotons", uint64_t{6});
proxyDatastore.createItem("/example-schema:launch-nukes/example-schema:cities/example-schema:targets[city='Prague']");
output = {
{"blast-radius", uint32_t{33'666}},
{"actual-yield", uint64_t{7}},
{"damaged-places", special_{SpecialValue::PresenceContainer}},
{"damaged-places/targets[city='London']", special_{SpecialValue::List}},
{"damaged-places/targets[city='London']/city", "London"s},
{"damaged-places/targets[city='Berlin']", special_{SpecialValue::List}},
{"damaged-places/targets[city='Berlin']/city", "Berlin"s},
};
}
SECTION("with leafref")
{
datastore->createItem("/example-schema:person[name='Colton']");
datastore->commitChanges();
rpc = "/example-schema:fire";
input = {
{"whom", "Colton"s}
};
proxyDatastore.initiate(rpc);
proxyDatastore.setLeaf("/example-schema:fire/example-schema:whom", "Colton"s);
}
catching<OnExec>([&] { REQUIRE(datastore->execute(rpc, input) == output); });
catching<OnExec>([&] { REQUIRE(proxyDatastore.execute() == output); });
}
SECTION("non-existing RPC")
{
catching<OnInvalidRpcPath>([&] { datastore->execute("/example-schema:non-existing", DatastoreAccess::Tree{}); });
}
}
SECTION("action")
{
std::string path;
DatastoreAccess::Tree input, output;
output = {
#ifdef netconf_BACKEND
{"/example-schema:ports[name='A']", special_{SpecialValue::List}},
{"/example-schema:ports[name='A']/name", enum_{"A"}},
#endif
{"success", true}
};
datastore->createItem("/example-schema:ports[name='A']");
datastore->commitChanges();
SECTION("shutdown")
{
path = "/example-schema:ports[name='A']/shutdown";
}
catching<OnExec>([&] { REQUIRE(datastore->execute(path, input) == output); });
}
waitForCompletionAndBitMore(seq1);
}