TEST_F(ExtensionsTest, test_manager_runnable) {
// Start a testing extension manager.
auto status = startExtensionManager(socket_path);
EXPECT_TRUE(status.ok());
// Call success if the Unix socket was created.
EXPECT_TRUE(socketExists(socket_path));
}
TEST_F(ExtensionsTest, test_extension_start) {
auto status = startExtensionManager(socket_path);
EXPECT_TRUE(status.ok());
EXPECT_TRUE(socketExistsLocal(socket_path));
// Now allow duplicates (for testing, since EM/E are the same).
Registry::allowDuplicates(true);
status = startExtension(socket_path, "test", "0.1", "0.0.0", "9.9.9");
// This will not be false since we are allowing deplicate items.
// Otherwise, starting an extension and extensionManager would fatal.
ASSERT_TRUE(status.ok());
// Checks for version comparisons (also used by packs).
ASSERT_FALSE(versionAtLeast("1.1.1", "0.0.1"));
ASSERT_TRUE(versionAtLeast("1.1.1", "1.1.1"));
ASSERT_TRUE(versionAtLeast("1.1.1", "1.1.2"));
// The `startExtension` internal call (exposed for testing) returns the
// uuid of the extension in the success status.
RouteUUID uuid = (RouteUUID)stoi(status.getMessage(), nullptr, 0);
// We can test-wait for the extensions's socket to open.
EXPECT_TRUE(socketExistsLocal(socket_path + "." + std::to_string(uuid)));
// Then clean up the registry modifications.
Registry::removeBroadcast(uuid);
Registry::allowDuplicates(false);
}
TEST_F(ExtensionsTest, test_extension_runnable) {
auto status = startExtensionManager(socket_path);
EXPECT_TRUE(status.ok());
// Wait for the extension manager to start.
EXPECT_TRUE(socketExists(socket_path));
// Test the extension manager API 'ping' call.
EXPECT_TRUE(ping());
}
TEST_F(ExtensionsTest, test_extension_broadcast) {
auto status = startExtensionManager(socket_path);
EXPECT_TRUE(status.ok());
EXPECT_TRUE(socketExists(socket_path));
// This time we're going to add a plugin to the extension_test registry.
Registry::add<TestExtensionPlugin>("extension_test", "test_item");
// Now we create a registry alias that will be broadcasted but NOT used for
// internal call lookups. Aliasing was introduced for testing such that an
// EM/E could exist in the same process (the same registry) without having
// duplicate registry items in the internal registry list AND extension
// registry route table.
Registry::addAlias("extension_test", "test_item", "test_alias");
Registry::allowDuplicates(true);
// Before registering the extension there is NO route to "test_alias" since
// alias resolutions are performed by the EM.
EXPECT_TRUE(Registry::exists("extension_test", "test_item"));
EXPECT_FALSE(Registry::exists("extension_test", "test_alias"));
status = startExtension(socket_path, "test", "0.1", "0.0.0", "0.0.1");
EXPECT_TRUE(status.ok());
RouteUUID uuid;
try {
uuid = (RouteUUID)stoi(status.getMessage(), nullptr, 0);
} catch (const std::exception& e) {
EXPECT_TRUE(false);
return;
}
auto ext_socket = socket_path + "." + std::to_string(uuid);
EXPECT_TRUE(socketExists(ext_socket));
// Make sure the EM registered the extension (called in start extension).
auto extensions = registeredExtensions();
// Expect two, since `getExtensions` includes the core.
ASSERT_EQ(extensions.size(), 2U);
EXPECT_EQ(extensions.count(uuid), 1U);
EXPECT_EQ(extensions.at(uuid).name, "test");
EXPECT_EQ(extensions.at(uuid).version, "0.1");
EXPECT_EQ(extensions.at(uuid).sdk_version, "0.0.1");
// We are broadcasting to our own registry in the test, which internally has
// a "test_item" aliased to "test_alias", "test_item" is internally callable
// but "test_alias" can only be resolved by an EM call.
EXPECT_TRUE(Registry::exists("extension_test", "test_item"));
// Now "test_alias" exists since it is in the extensions route table.
EXPECT_TRUE(Registry::exists("extension_test", "test_alias"));
PluginResponse response;
// This registry call will fail, since "test_alias" cannot be resolved using
// a local registry call.
status = Registry::call("extension_test", "test_alias", {{}}, response);
EXPECT_FALSE(status.ok());
// The following will be the result of a:
// Registry::call("extension_test", "test_alias", {{}}, response);
status = callExtension(ext_socket,
"extension_test",
"test_alias",
{{"test_key", "test_value"}},
response);
EXPECT_TRUE(status.ok());
EXPECT_EQ(response.size(), 1U);
EXPECT_EQ(response[0]["test_key"], "test_value");
Registry::removeBroadcast(uuid);
Registry::allowDuplicates(false);
}
