diff --git a/packages/cpp/ArmoniK.Api.Client/header/events/EventsClient.h b/packages/cpp/ArmoniK.Api.Client/header/events/EventsClient.h new file mode 100644 index 000000000..adfcaf9a1 --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/header/events/EventsClient.h @@ -0,0 +1,21 @@ +#pragma once + +#include "events_common.pb.h" +#include "events_service.grpc.pb.h" + +namespace armonik { +namespace api { +namespace client { +class EventsClient { +public: + explicit EventsClient(std::unique_ptr stub) + : stub(std::move(stub)) {} + + void wait_for_result_availability(std::string session_id, std::vector result_ids); + +private: + std::unique_ptr stub; +}; +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Client/header/partitions/PartitionsClient.h b/packages/cpp/ArmoniK.Api.Client/header/partitions/PartitionsClient.h new file mode 100644 index 000000000..48c990879 --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/header/partitions/PartitionsClient.h @@ -0,0 +1,27 @@ +#pragma once + +#include "partitions_common.pb.h" +#include "partitions_service.grpc.pb.h" + +namespace armonik { +namespace api { +namespace client { + +class PartitionsClient { +public: + explicit PartitionsClient(std::unique_ptr stub) + : stub(std::move(stub)){}; + std::vector + list_partitions(armonik::api::grpc::v1::partitions::Filters filters, int32_t &total, int32_t page = -1, + int32_t page_size = 500, + armonik::api::grpc::v1::partitions::ListPartitionsRequest::Sort sort = default_sort()); + + armonik::api::grpc::v1::partitions::PartitionRaw get_partition(std::string partition_id); + +private: + std::unique_ptr stub; + static armonik::api::grpc::v1::partitions::ListPartitionsRequest::Sort default_sort(); +}; +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Client/header/sessions/SessionsClient.h b/packages/cpp/ArmoniK.Api.Client/header/sessions/SessionsClient.h index 349748160..24c3da906 100644 --- a/packages/cpp/ArmoniK.Api.Client/header/sessions/SessionsClient.h +++ b/packages/cpp/ArmoniK.Api.Client/header/sessions/SessionsClient.h @@ -57,6 +57,57 @@ class SessionsClient { int32_t page_size = 500, armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort sort = default_sort); + /** + * Pause a session + * + * @param session_id Session Id + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw pause_session(std::string session_id); + + /** + * Resume a session + * + * @param session_id Session Id + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw resume_session(std::string session_id); + + /** + * Purge a session + * + * @param session_id Session Id + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw purge_session(std::string session_id); + + /** + * Delete a session + * + * @param session_id Session Id + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw delete_session(std::string session_id); + + /** + * Stop a new tasks submission in a session + * + * @param session_id Session Id + * @param client boolean to stop client's task submission + * @param worker boolean to stop worker's task submissions + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw stop_submission_session(std::string session_id, bool client = true, + bool worker = true); + + /** + * Resume a session + * + * @param session_id Session Id + * @return SessionRaw object containing information about the session + */ + armonik::api::grpc::v1::sessions::SessionRaw close_session(std::string session_id); + private: std::unique_ptr stub; static const armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort default_sort; diff --git a/packages/cpp/ArmoniK.Api.Client/header/versions/VersionsClient.h b/packages/cpp/ArmoniK.Api.Client/header/versions/VersionsClient.h new file mode 100644 index 000000000..8e771cb3c --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/header/versions/VersionsClient.h @@ -0,0 +1,39 @@ +#pragma once + +#include "versions_common.pb.h" +#include "versions_service.grpc.pb.h" + +namespace armonik { +namespace api { +namespace client { + +/** + * @brief Data structure for components version + * @param api ArmoniK API version + * @param core ArmoniK CORE version + */ +struct versions_info { + std::string api; + std::string core; +}; + +/** + * Versions Client wrapper + */ +class VersionsClient { +public: + explicit VersionsClient(std::unique_ptr stub) + : stub(std::move(stub)){}; + + /** + * Get versions of ArmoniK components + * @return Mapping between component names and their versions + */ + versions_info list_versions(); + +private: + std::unique_ptr stub; +}; +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Client/source/events/EventsClient.cpp b/packages/cpp/ArmoniK.Api.Client/source/events/EventsClient.cpp new file mode 100644 index 000000000..84ffe4e81 --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/source/events/EventsClient.cpp @@ -0,0 +1,82 @@ +#include "events/EventsClient.h" +#include "events_common.pb.h" +#include "events_service.grpc.pb.h" +#include "exceptions/ArmoniKApiException.h" +#include "objects.pb.h" + +using armonik::api::grpc::v1::events::EventSubscriptionRequest; +using armonik::api::grpc::v1::events::EventSubscriptionResponse; +using armonik::api::grpc::v1::result_status::ResultStatus; +using namespace armonik::api::grpc::v1::events; + +namespace armonik { +namespace api { +namespace client { + +void EventsClient::wait_for_result_availability(std::string session_id, std::vector result_ids) { + + ::grpc::ClientContext context; + EventSubscriptionRequest request; + + EventSubscriptionResponse response; + + armonik::api::grpc::v1::results::Filters filters; + armonik::api::grpc::v1::results::FilterField filter_field; + filter_field.mutable_field()->mutable_result_raw_field()->set_field( + armonik::api::grpc::v1::results::RESULT_RAW_ENUM_FIELD_RESULT_ID); + filter_field.mutable_filter_string()->set_operator_(grpc::v1::FILTER_STRING_OPERATOR_EQUAL); + for (auto &&result_id : result_ids) { + filter_field.mutable_filter_string()->set_value(result_id); + *filters.mutable_or_()->Add()->mutable_and_()->Add() = filter_field; + } + + *request.mutable_session_id() = std::move(session_id); + *request.mutable_results_filters() = filters; + request.add_returned_events(static_cast(EventSubscriptionResponse::UpdateCase::kResultStatusUpdate)); + request.add_returned_events(static_cast(EventSubscriptionResponse::UpdateCase::kNewResult)); + + auto stream = stub->GetEvents(&context, request); + if (!stream) { + throw armonik::api::common::exceptions::ArmoniKApiException("Result has been aborted"); + } + + while (stream->Read(&response)) { + std::string update_or_new; + switch (response.update_case()) { + case EventSubscriptionResponse::UpdateCase::kResultStatusUpdate: + switch (response.mutable_result_status_update()->status()) { + case ResultStatus::RESULT_STATUS_COMPLETED: + update_or_new = response.mutable_result_status_update()->result_id(); + break; + case ResultStatus::RESULT_STATUS_ABORTED: + throw armonik::api::common::exceptions::ArmoniKApiException("Result has been aborted"); + default: + break; + } + break; + case EventSubscriptionResponse::UpdateCase::kNewResult: + switch (response.mutable_new_result()->status()) { + case ResultStatus::RESULT_STATUS_COMPLETED: + update_or_new = response.mutable_new_result()->result_id(); + break; + case ResultStatus::RESULT_STATUS_ABORTED: + throw armonik::api::common::exceptions::ArmoniKApiException("Result has been aborted"); + default: + break; + } + break; + default: + break; + } + if (!update_or_new.empty()) { + result_ids.erase(std::remove(result_ids.begin(), result_ids.end(), update_or_new), result_ids.end()); + if (result_ids.empty()) { + break; + } + } + } +} + +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Client/source/partitions/PartitionsClient.cpp b/packages/cpp/ArmoniK.Api.Client/source/partitions/PartitionsClient.cpp new file mode 100644 index 000000000..3c8e05609 --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/source/partitions/PartitionsClient.cpp @@ -0,0 +1,83 @@ +#include + +#include "exceptions/ArmoniKApiException.h" +#include "partitions/PartitionsClient.h" + +using namespace armonik::api::grpc::v1::partitions; + +namespace armonik { +namespace api { +namespace client { + +std::vector PartitionsClient::list_partitions(Filters filters, int32_t &total, int32_t page, + int32_t page_size, ListPartitionsRequest::Sort sort) { + ::grpc::ClientContext context; + ListPartitionsRequest request; + ListPartitionsResponse response; + + *request.mutable_filters() = std::move(filters); + *request.mutable_sort() = std::move(sort); + request.set_page_size(page_size); + + if (page >= 0) { + request.set_page(page); + ::grpc::ClientContext context; + auto status = stub->ListPartitions(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Unable to list partitions " + + status.error_message()); + } + total = response.total(); + return {std::make_move_iterator(response.partitions().begin()), + std::make_move_iterator(response.partitions().end())}; + } else { + std::vector rawPartitions; + int current_page = 0; + do { + request.set_page(current_page); + ::grpc::ClientContext context; + auto status = stub->ListPartitions(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Unable to list partitions " + + status.error_message()); + } + rawPartitions.insert(rawPartitions.end(), std::make_move_iterator(response.partitions().begin()), + std::make_move_iterator(response.partitions().end())); + if (response.partitions_size() >= page_size) { + current_page++; + } + + response.clear_partitions(); + } while ((int32_t)rawPartitions.size() < response.total()); + + total = response.total(); + + return rawPartitions; + } +} + +PartitionRaw PartitionsClient::get_partition(std::string partition_id) { + ::grpc::ClientContext context; + GetPartitionRequest request; + GetPartitionResponse response; + + *request.mutable_id() = std::move(partition_id); + auto status = stub->GetPartition(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not get partition : " + status.error_message()); + } + + return std::move(*response.mutable_partition()); +} + +ListPartitionsRequest::Sort PartitionsClient::default_sort() { + ListPartitionsRequest::Sort sort; + sort.set_direction(grpc::v1::sort_direction::SORT_DIRECTION_ASC); + sort.mutable_field()->mutable_partition_raw_field()->set_field( + grpc::v1::partitions::PARTITION_RAW_ENUM_FIELD_PRIORITY); + return sort; +} + +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Client/source/sessions/SessionsClient.cpp b/packages/cpp/ArmoniK.Api.Client/source/sessions/SessionsClient.cpp index 7780b2f18..31cce4d07 100644 --- a/packages/cpp/ArmoniK.Api.Client/source/sessions/SessionsClient.cpp +++ b/packages/cpp/ArmoniK.Api.Client/source/sessions/SessionsClient.cpp @@ -1,24 +1,26 @@ +#include "sessions/SessionsClient.h" +#include "exceptions/ArmoniKApiException.h" +#include "sessions_common.pb.h" +#include "sessions_service.grpc.pb.h" #include -#include "exceptions/ArmoniKApiException.h" -#include "sessions/SessionsClient.h" +using namespace armonik::api::grpc::v1::sessions; -static armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort get_default_sort() { - armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort sort; +static ListSessionsRequest::Sort get_default_sort() { + ListSessionsRequest::Sort sort; sort.mutable_field()->mutable_session_raw_field()->set_field( armonik::api::grpc::v1::sessions::SESSION_RAW_ENUM_FIELD_CREATED_AT); sort.set_direction(armonik::api::grpc::v1::sort_direction::SORT_DIRECTION_ASC); return sort; } -const armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort armonik::api::client::SessionsClient::default_sort = - get_default_sort(); +const ListSessionsRequest::Sort armonik::api::client::SessionsClient::default_sort = get_default_sort(); std::string armonik::api::client::SessionsClient::create_session(armonik::api::grpc::v1::TaskOptions default_task_options, const std::vector &partitions) { ::grpc::ClientContext context; - armonik::api::grpc::v1::sessions::CreateSessionRequest request; - armonik::api::grpc::v1::sessions::CreateSessionReply response; + CreateSessionRequest request; + CreateSessionReply response; *request.mutable_default_task_option() = std::move(default_task_options); request.mutable_partition_ids()->Add(partitions.begin(), partitions.end()); @@ -30,10 +32,10 @@ armonik::api::client::SessionsClient::create_session(armonik::api::grpc::v1::Tas return std::move(*response.mutable_session_id()); } -armonik::api::grpc::v1::sessions::SessionRaw armonik::api::client::SessionsClient::get_session(std::string session_id) { +SessionRaw armonik::api::client::SessionsClient::get_session(std::string session_id) { ::grpc::ClientContext context; - armonik::api::grpc::v1::sessions::GetSessionRequest request; - armonik::api::grpc::v1::sessions::GetSessionResponse response; + GetSessionRequest request; + GetSessionResponse response; request.set_session_id(std::move(session_id)); @@ -44,11 +46,10 @@ armonik::api::grpc::v1::sessions::SessionRaw armonik::api::client::SessionsClien return std::move(*response.mutable_session()); } -armonik::api::grpc::v1::sessions::SessionRaw -armonik::api::client::SessionsClient::cancel_session(std::string session_id) { +SessionRaw armonik::api::client::SessionsClient::cancel_session(std::string session_id) { ::grpc::ClientContext context; - armonik::api::grpc::v1::sessions::CancelSessionRequest request; - armonik::api::grpc::v1::sessions::CancelSessionResponse response; + CancelSessionRequest request; + CancelSessionResponse response; request.set_session_id(std::move(session_id)); auto status = stub->CancelSession(&context, request, &response); @@ -62,8 +63,8 @@ std::vector armonik::api::client::SessionsClient::list_sessions(armonik::api::grpc::v1::sessions::Filters filters, int32_t &total, int32_t page, int32_t page_size, armonik::api::grpc::v1::sessions::ListSessionsRequest::Sort sort) { - armonik::api::grpc::v1::sessions::ListSessionsRequest request; - armonik::api::grpc::v1::sessions::ListSessionsResponse response; + ListSessionsRequest request; + ListSessionsResponse response; *request.mutable_filters() = std::move(filters); *request.mutable_sort() = std::move(sort); @@ -80,7 +81,7 @@ armonik::api::client::SessionsClient::list_sessions(armonik::api::grpc::v1::sess total = response.total(); return {response.sessions().begin(), response.sessions().end()}; } else { - std::vector rawSessions; + std::vector rawSessions; int current_page = 0; do { request.set_page(current_page); @@ -106,3 +107,92 @@ armonik::api::client::SessionsClient::list_sessions(armonik::api::grpc::v1::sess return rawSessions; } } + +SessionRaw armonik::api::client::SessionsClient::pause_session(std::string session_id) { + ::grpc::ClientContext context; + PauseSessionRequest request; + PauseSessionResponse response; + + request.set_session_id(std::move(session_id)); + auto status = stub->PauseSession(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not pause session : " + status.error_message()); + } + + return std::move(*response.mutable_session()); +} + +armonik::api::grpc::v1::sessions::SessionRaw +armonik::api::client::SessionsClient::resume_session(std::string session_id) { + ::grpc::ClientContext context; + ResumeSessionRequest request; + ResumeSessionResponse response; + + request.set_session_id(std::move(session_id)); + auto status = stub->ResumeSession(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not resume session : " + status.error_message()); + } + + return std::move(*response.mutable_session()); +} + +SessionRaw armonik::api::client::SessionsClient::purge_session(std::string session_id) { + ::grpc::ClientContext context; + PurgeSessionRequest request; + PurgeSessionResponse response; + + request.set_session_id(std::move(session_id)); + auto status = stub->PurgeSession(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not purge session : " + status.error_message()); + } + + return std::move(*response.mutable_session()); +} + +SessionRaw armonik::api::client::SessionsClient::delete_session(std::string session_id) { + ::grpc::ClientContext context; + DeleteSessionRequest request; + DeleteSessionResponse response; + + request.set_session_id(std::move(session_id)); + auto status = stub->DeleteSession(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not delete session : " + status.error_message()); + } + + return std::move(*response.mutable_session()); +} + +SessionRaw armonik::api::client::SessionsClient::stop_submission_session(std::string session_id, bool client, + bool worker) { + ::grpc::ClientContext context; + StopSubmissionRequest request; + StopSubmissionResponse response; + + request.set_session_id(std::move(session_id)); + request.set_client(client); + request.set_worker(worker); + auto status = stub->StopSubmission(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not stop submission session : " + + status.error_message()); + } + + return std::move(*response.mutable_session()); +} + +SessionRaw armonik::api::client::SessionsClient::close_session(std::string session_id) { + ::grpc::ClientContext context; + CloseSessionRequest request; + CloseSessionResponse response; + + request.set_session_id(std::move(session_id)); + auto status = stub->CloseSession(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not close session : " + status.error_message()); + } + + return std::move(*response.mutable_session()); +} diff --git a/packages/cpp/ArmoniK.Api.Client/source/versions/VersionsClient.cpp b/packages/cpp/ArmoniK.Api.Client/source/versions/VersionsClient.cpp new file mode 100644 index 000000000..088c67e5a --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Client/source/versions/VersionsClient.cpp @@ -0,0 +1,29 @@ +#include "versions/VersionsClient.h" +#include "exceptions/ArmoniKApiException.h" + +using armonik::api::grpc::v1::versions::ListVersionsRequest; +using armonik::api::grpc::v1::versions::ListVersionsResponse; +using namespace armonik::api::grpc::v1::versions; + +namespace armonik { +namespace api { +namespace client { + +versions_info VersionsClient::list_versions() { + ::grpc::ClientContext context; + ListVersionsRequest request; + ListVersionsResponse response; + + auto status = stub->ListVersions(&context, request, &response); + if (!status.ok()) { + throw armonik::api::common::exceptions::ArmoniKApiException("Could not get list versions : " + + status.error_message()); + } + + versions_info mapping = {response.api(), response.core()}; + + return mapping; +} +} // namespace client +} // namespace api +} // namespace armonik diff --git a/packages/cpp/ArmoniK.Api.Tests/source/EventsClientTest.cpp b/packages/cpp/ArmoniK.Api.Tests/source/EventsClientTest.cpp new file mode 100644 index 000000000..6a998f49a --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Tests/source/EventsClientTest.cpp @@ -0,0 +1,34 @@ +#include + +#include "common.h" +#include "logger/formatter.h" +#include "logger/logger.h" +#include "logger/writer.h" + +#include "events/EventsClient.h" +#include "results/ResultsClient.h" +#include "results_service.grpc.pb.h" +#include "sessions/SessionsClient.h" + +using Logger = armonik::api::common::logger::Logger; + +TEST(Events, getEvents) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::EventsClient client(armonik::api::grpc::v1::events::Events::NewStub(channel)); + + auto session_id = armonik::api::client::SessionsClient(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)) + .create_session(task_options); + + auto result_client = armonik::api::client::ResultsClient(armonik::api::grpc::v1::results::Results::NewStub(channel)); + auto payload_id = result_client.create_results( + session_id, std::vector>{{"name", "payload"}})["name"]; + auto result_id = result_client.create_results_metadata(session_id, {"result"})["result"]; + + ASSERT_NO_THROW(result_client.upload_result_data(session_id, result_id, "name")); + ASSERT_NO_THROW(client.wait_for_result_availability(session_id, {result_id, payload_id})); + ASSERT_EQ(result_client.download_result_data(session_id, result_id), "name"); +} diff --git a/packages/cpp/ArmoniK.Api.Tests/source/PartitionsClientTest.cpp b/packages/cpp/ArmoniK.Api.Tests/source/PartitionsClientTest.cpp new file mode 100644 index 000000000..f5ea9eca2 --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Tests/source/PartitionsClientTest.cpp @@ -0,0 +1,56 @@ +#include + +#include "common.h" +#include "logger/formatter.h" +#include "logger/logger.h" +#include "logger/writer.h" + +#include "partitions/PartitionsClient.h" +#include "sessions/SessionsClient.h" + +using Logger = armonik::api::common::logger::Logger; + +TEST(Partitions, can_get_partition) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + task_options.set_partition_id("default"); + + armonik::api::client::PartitionsClient client(armonik::api::grpc::v1::partitions::Partitions::NewStub(channel)); + + armonik::api::grpc::v1::partitions::PartitionRaw partition; + ASSERT_NO_THROW(partition = client.get_partition(task_options.partition_id())); + ASSERT_EQ(partition.id(), task_options.partition_id()); + ASSERT_EQ(partition.pod_max(), 100); + ASSERT_EQ(partition.pod_reserved(), 1); + ASSERT_EQ(partition.priority(), 1); +} + +TEST(Partitions, can_list_partitions) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + task_options.set_partition_id("default"); + + armonik::api::client::PartitionsClient client(armonik::api::grpc::v1::partitions::Partitions::NewStub(channel)); + + armonik::api::grpc::v1::partitions::Filters filters; + armonik::api::grpc::v1::partitions::FilterField filter_field; + filter_field.mutable_field()->mutable_partition_raw_field()->set_field( + armonik::api::grpc::v1::partitions::PARTITION_RAW_ENUM_FIELD_ID); + filter_field.mutable_filter_string()->set_value(task_options.partition_id()); + filter_field.mutable_filter_string()->set_operator_(armonik::api::grpc::v1::FILTER_STRING_OPERATOR_EQUAL); + *filters.mutable_or_()->Add()->mutable_and_()->Add() = filter_field; + + int total; + + std::vector partitions = client.list_partitions(filters, total); + for (auto &&partition : partitions) { + std::cout << *partition.mutable_id() << std::endl; + } + ASSERT_TRUE(!partitions.empty()); + ASSERT_EQ(partitions.size(), 1); + ASSERT_EQ(partitions.size(), total); +} diff --git a/packages/cpp/ArmoniK.Api.Tests/source/SessionClientTest.cpp b/packages/cpp/ArmoniK.Api.Tests/source/SessionClientTest.cpp index 39616eb33..a48ba9829 100644 --- a/packages/cpp/ArmoniK.Api.Tests/source/SessionClientTest.cpp +++ b/packages/cpp/ArmoniK.Api.Tests/source/SessionClientTest.cpp @@ -101,3 +101,97 @@ TEST(Sessions, can_list_sessions_small_page) { ASSERT_GE(list.size(), expected_n_sessions); ASSERT_GE(total, expected_n_sessions); } + +TEST(Sessions, can_pause_session) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.pause_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} + +TEST(Sessions, can_resume_session) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + ASSERT_NO_THROW(client.pause_session(session_id)); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.resume_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} + +TEST(Sessions, can_purge_session) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + ASSERT_NO_THROW(client.close_session(session_id)); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.purge_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} + +TEST(Sessions, can_delete_session) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.delete_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} + +TEST(Sessions, can_stop_submission) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.stop_submission_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} + +TEST(Sessions, can_close_session) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::SessionsClient client(armonik::api::grpc::v1::sessions::Sessions::NewStub(channel)); + + std::string session_id = client.create_session(task_options); + + armonik::api::grpc::v1::sessions::SessionRaw response; + ASSERT_NO_THROW(response = client.close_session(session_id)); + ASSERT_EQ(response.session_id(), session_id); +} diff --git a/packages/cpp/ArmoniK.Api.Tests/source/VersionsClientTest.cpp b/packages/cpp/ArmoniK.Api.Tests/source/VersionsClientTest.cpp new file mode 100644 index 000000000..5d98832cc --- /dev/null +++ b/packages/cpp/ArmoniK.Api.Tests/source/VersionsClientTest.cpp @@ -0,0 +1,28 @@ +#include + +#include "common.h" +#include "logger/formatter.h" +#include "logger/logger.h" +#include "logger/writer.h" + +#include "versions/VersionsClient.h" + +using Logger = armonik::api::common::logger::Logger; + +TEST(Versions, can_list_versions) { + Logger log{armonik::api::common::logger::writer_console(), armonik::api::common::logger::formatter_plain(true)}; + std::shared_ptr<::grpc::Channel> channel; + armonik::api::grpc::v1::TaskOptions task_options; + init(channel, task_options, log); + + armonik::api::client::VersionsClient client(armonik::api::grpc::v1::versions::Versions::NewStub(channel)); + + armonik::api::client::versions_info versions; + ASSERT_NO_THROW(versions = client.list_versions()); + + std::cout << "API version: " << versions.api << "\n" + << "Core version: " << versions.core << std::endl; + + ASSERT_NE(versions.api, "Unknown"); + ASSERT_NE(versions.core, "Unknown"); +}