service.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/ugrpc/tests/service.hpp
/// @brief Base classes for testing and benchmarking ugrpc service
/// implementations in a simplified gRPC environment.
 
#include <memory>
#include <utility>
 
#include <userver/dynamic_config/snapshot.hpp>
#include <userver/dynamic_config/storage_mock.hpp>
#include <userver/dynamic_config/test_helpers.hpp>
#include <userver/utils/statistics/storage.hpp>
 
#include <userver/ugrpc/client/client_factory.hpp>
#include <userver/ugrpc/server/server.hpp>
#include <userver/ugrpc/server/service_base.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace ugrpc::server {
class GenericServiceBase;
}  // namespace ugrpc::server
 
/// userver gRPC testing facilities
namespace ugrpc::tests {
 
/// Sets up a mini gRPC server using the provided service implementations.
class ServiceBase {
 public:
  ServiceBase();
 
  explicit ServiceBase(server::ServerConfig&& server_config);
 
  ServiceBase(ServiceBase&&) = delete;
  ServiceBase& operator=(ServiceBase&&) = delete;
  virtual ~ServiceBase();
 
  /// Register a gRPC service implementation. The caller owns the service and
  /// should ensure that the services live at least until StopServer is called.
  void RegisterService(server::ServiceBase& service);
 
  /// @overload
  void RegisterService(server::GenericServiceBase& service);
 
  /// Starts the server and connects a grpc channel to it.
  /// Should be called after the services are registered.
  void StartServer(client::ClientFactorySettings&& settings = {});
 
  /// Should be called before the registered services are destroyed.
  /// Should typically be called in the destructor of your gtest fixture.
  void StopServer() noexcept;
 
  /// @returns a client for the specified gRPC service, connected to the server.
  template <typename Client>
  Client MakeClient() {
    return GetClientFactory().MakeClient<Client>("test", *endpoint_);
  }
 
  /// @returns the stored @ref server::Server for advanced tweaking.
  server::Server& GetServer() noexcept;
 
  /// Server middlewares can be modified before the first RegisterService call.
  void SetServerMiddlewares(server::Middlewares middlewares);
 
  /// Client middlewares can be modified before the first RegisterService call.
  void SetClientMiddlewareFactories(
      client::MiddlewareFactories middleware_factories);
 
  /// Modifies the internal dynamic configs storage. It is used by the server
  /// and clients, and is accessible through @ref GetConfigSource.
  /// Initially, the configs are filled with compile-time defaults.
  void ExtendDynamicConfig(const std::vector<dynamic_config::KeyValue>&);
 
  /// @returns the dynamic configs affected by @ref ExtendDynamicConfig.
  dynamic_config::Source GetConfigSource() const;
 
  /// @returns the statistics storage used by the server and clients.
  utils::statistics::Storage& GetStatisticsStorage();
 
  /// @cond
  // For internal use only.
  client::ClientFactory& GetClientFactory();
 
  // For internal use only.
  std::string GetEndpoint() const;
  /// @endcond
 
 private:
  server::ServiceConfig MakeServiceConfig();
 
  utils::statistics::Storage statistics_storage_;
  dynamic_config::StorageMock config_storage_;
  std::optional<std::string> unix_socket_path_;
  server::Server server_;
  server::Middlewares server_middlewares_;
  client::MiddlewareFactories client_middleware_factories_;
  bool middlewares_change_allowed_{true};
  testsuite::GrpcControl testsuite_;
  std::optional<std::string> endpoint_;
  ugrpc::impl::StatisticsStorage client_statistics_storage_;
  std::optional<client::ClientFactory> client_factory_;
};
 
/// @brief return list of default server middlewares for tests
server::Middlewares GetDefaultServerMiddlewares();
 
/// @brief return list of default client middleware factories for tests
client::MiddlewareFactories GetDefaultClientMiddlewareFactories();
 
/// @brief Sets up a mini gRPC server using a single service implementation.
/// @see @ref ugrpc::tests::ServiceBase
template <typename GrpcService>
class Service : public ServiceBase {
 public:
  /// Default-constructs the service.
  Service() : Service(std::in_place) {}
 
  /// Passes @a args to the service.
  template <typename... Args>
  explicit Service(std::in_place_t, Args&&... args)
      : Service(server::ServerConfig{}, std::in_place,
                std::forward<Args>(args)...) {}
 
  /// Passes @a args to the service.
  template <typename... Args>
  Service(server::ServerConfig&& server_config, std::in_place_t = std::in_place,
          Args&&... args)
      : ServiceBase(std::move(server_config)),
        service_(std::forward<Args>(args)...) {
    SetServerMiddlewares(GetDefaultServerMiddlewares());
    SetClientMiddlewareFactories(GetDefaultClientMiddlewareFactories());
    RegisterService(service_);
    StartServer();
  }
 
  ~Service() override { StopServer(); }
 
  /// @returns the stored service.
  GrpcService& GetService() { return service_; }
 
 private:
  GrpcService service_{};
};
 
}  // namespace ugrpc::tests
 
USERVER_NAMESPACE_END