diff --git a/include/caosdb/configuration.h b/include/caosdb/configuration.h
index 4e4de9a4d7cdfc29f15346b1803e45236235dcbc..5a4640078226de5181ab0adcc2ca6c273c7a072b 100644
--- a/include/caosdb/configuration.h
+++ b/include/caosdb/configuration.h
@@ -29,9 +29,9 @@
 #include "boost/json/value.hpp"            // for value
 #include "boost/json/value_ref.hpp"        // for array, object
 #include "caosdb/authentication.h"         // for Authenticator, PlainPassw...
-#include "caosdb/connection.h"             // for ConnectionConfig, Certifi...
-#include "caosdb/exceptions.h"             // for ConfigurationError
-#include "caosdb/utility.h"                // for load_json_file
+#include "caosdb/connection.h" // for ConnectionConfiguration, Certifi...
+#include "caosdb/exceptions.h" // for ConfigurationError
+#include "caosdb/utility.h"    // for load_json_file
 
 namespace caosdb::configuration {
 using boost::filesystem::exists;
@@ -42,11 +42,11 @@ using boost::json::value;
 using caosdb::authentication::Authenticator;
 using caosdb::authentication::PlainPasswordAuthenticator;
 using caosdb::connection::CertificateProvider;
-using caosdb::connection::ConnectionConfig;
+using caosdb::connection::ConnectionConfiguration;
 using caosdb::connection::ConnectionManager;
-using caosdb::connection::InsecureConnectionConfig;
+using caosdb::connection::InsecureConnectionConfiguration;
 using caosdb::connection::PemFileCertificateProvider;
-using caosdb::connection::TlsConnectionConfig;
+using caosdb::connection::TlsConnectionConfiguration;
 using caosdb::exceptions::ConfigurationError;
 using caosdb::utility::load_json_file;
 
@@ -55,7 +55,7 @@ using caosdb::utility::load_json_file;
  * the ConfigurationManager to construct Connection instances from the stored
  * configuration.
  */
-class ConnectionConfigurationHelper {
+class ConnectionConfigurationurationHelper {
 public:
   friend class ConfigurationManager;
 
@@ -75,12 +75,11 @@ private:
   /**
    * @param from - a single connection configuration.
    */
-  auto
-  CreateConnectionConfiguration(const bool tls, const std::string &host,
-                                const int port,
-                                const CertificateProvider *certificate_provider,
-                                const Authenticator *authenticator) const
-    -> std::unique_ptr<ConnectionConfig>;
+  auto CreateConnectionConfigurationuration(
+    const bool tls, const std::string &host, const int port,
+    const CertificateProvider *certificate_provider,
+    const Authenticator *authenticator) const
+    -> std::unique_ptr<ConnectionConfiguration>;
 
   /**
    * @param from - a single connection configuration.
@@ -90,8 +89,8 @@ private:
   /**
    * @param from - a single connection configuration.
    */
-  auto CreateConnectionConfiguration(const object &from) const
-    -> std::unique_ptr<ConnectionConfig>;
+  auto CreateConnectionConfigurationuration(const object &from) const
+    -> std::unique_ptr<ConnectionConfiguration>;
 };
 
 /**
@@ -126,19 +125,19 @@ public:
   }
 
   /**
-   * See mGetConnectionConfiguration.
+   * See mGetConnectionConfigurationuration.
    */
-  inline static auto GetConnectionConfiguration(const std::string &name)
-    -> std::unique_ptr<ConnectionConfig> {
-    return GetInstance().mGetConnectionConfiguration(name);
+  inline static auto GetConnectionConfigurationuration(const std::string &name)
+    -> std::unique_ptr<ConnectionConfiguration> {
+    return GetInstance().mGetConnectionConfigurationuration(name);
   }
 
   /**
-   * Return the ConnectionConfig for the default connection.
+   * Return the ConnectionConfiguration for the default connection.
    */
-  inline static auto GetDefaultConnectionConfiguration()
-    -> std::unique_ptr<ConnectionConfig> {
-    return GetInstance().mGetConnectionConfiguration(
+  inline static auto GetDefaultConnectionConfigurationuration()
+    -> std::unique_ptr<ConnectionConfiguration> {
+    return GetInstance().mGetConnectionConfigurationuration(
       GetInstance().mGetDefaultConnectionName());
   }
 
@@ -154,7 +153,7 @@ public:
 
 private:
   value json_configuration;
-  ConnectionConfigurationHelper connection_configuration_helper;
+  ConnectionConfigurationurationHelper connection_configuration_helper;
   inline ConfigurationManager() { InitializeDefaults(); };
 
   /**
@@ -206,13 +205,13 @@ private:
   auto mLoadSingleJSONConfiguration(const path &json_file) -> void;
 
   /**
-   * Return the ConnectionConfig for the connection of the given name.
+   * Return the ConnectionConfiguration for the connection of the given name.
    */
-  auto mGetConnectionConfiguration(const std::string &name) const
-    -> std::unique_ptr<ConnectionConfig>;
+  auto mGetConnectionConfigurationuration(const std::string &name) const
+    -> std::unique_ptr<ConnectionConfiguration>;
 
   /**
-   * Return the ConnectionConfig for the default connection.
+   * Return the ConnectionConfiguration for the default connection.
    */
   auto mGetDefaultConnectionName() const -> std::string;
 };
diff --git a/include/caosdb/connection.h b/include/caosdb/connection.h
index 137066d390d7d7d0ba5e51e998a6477f09c552ac..2ae989538f3490505fe258971f6352d7d0fd75f8 100644
--- a/include/caosdb/connection.h
+++ b/include/caosdb/connection.h
@@ -74,15 +74,16 @@ public:
 /**
  * @brief Configuration of the CaosDB connection.
  */
-class ConnectionConfig {
+class ConnectionConfiguration {
 private:
   std::string host;
   int port;
 
 public:
-  ConnectionConfig(const std::string &host, int port);
-  virtual ~ConnectionConfig() = default;
-  friend auto operator<<(std::ostream &out, const ConnectionConfig &config)
+  ConnectionConfiguration(const std::string &host, int port);
+  virtual ~ConnectionConfiguration() = default;
+  friend auto operator<<(std::ostream &out,
+                         const ConnectionConfiguration &config)
     -> std::ostream &;
 
   [[nodiscard]] auto virtual ToString() const -> std::string = 0;
@@ -92,31 +93,31 @@ public:
     -> std::shared_ptr<ChannelCredentials> = 0;
 };
 
-class InsecureConnectionConfig : public ConnectionConfig {
+class InsecureConnectionConfiguration : public ConnectionConfiguration {
 private:
   std::shared_ptr<ChannelCredentials> credentials;
 
 public:
-  InsecureConnectionConfig(const std::string &host, int port);
+  InsecureConnectionConfiguration(const std::string &host, int port);
   [[nodiscard]] auto GetChannelCredentials() const
     -> std::shared_ptr<ChannelCredentials> override;
   [[nodiscard]] auto ToString() const -> std::string override;
 };
 
-class TlsConnectionConfig : public ConnectionConfig {
+class TlsConnectionConfiguration : public ConnectionConfiguration {
 private:
   std::shared_ptr<ChannelCredentials> credentials;
   std::string certificate_provider;
 
 public:
-  TlsConnectionConfig(const std::string &host, int port);
-  TlsConnectionConfig(const std::string &host, int port,
-                      const Authenticator &authenticator);
-  TlsConnectionConfig(const std::string &host, int port,
-                      const CertificateProvider &certificate_provider);
-  TlsConnectionConfig(const std::string &host, int port,
-                      const CertificateProvider &certificate_provider,
-                      const Authenticator &authenticator);
+  TlsConnectionConfiguration(const std::string &host, int port);
+  TlsConnectionConfiguration(const std::string &host, int port,
+                             const Authenticator &authenticator);
+  TlsConnectionConfiguration(const std::string &host, int port,
+                             const CertificateProvider &certificate_provider);
+  TlsConnectionConfiguration(const std::string &host, int port,
+                             const CertificateProvider &certificate_provider,
+                             const Authenticator &authenticator);
   [[nodiscard]] auto GetChannelCredentials() const
     -> std::shared_ptr<ChannelCredentials> override;
   [[nodiscard]] auto ToString() const -> std::string override;
@@ -131,7 +132,7 @@ class Connection {
   std::shared_ptr<EntityTransactionService::Stub> entity_transaction_service;
 
 public:
-  explicit Connection(const ConnectionConfig &config);
+  explicit Connection(const ConnectionConfiguration &config);
   friend auto operator<<(std::ostream &out, const Connection &connection)
     -> std::ostream &;
   [[nodiscard]] auto GetVersionInfo() const -> std::unique_ptr<VersionInfo>;
diff --git a/include/ccaosdb.h b/include/ccaosdb.h
index fdd23ba7c05b34a8534ac29a6d39bfe6ab40a439..d303394c0f70ad5bb5c6b0d5e437ba9826d3f7bd 100644
--- a/include/ccaosdb.h
+++ b/include/ccaosdb.h
@@ -45,7 +45,7 @@ typedef struct {
 } caosdb_connection_connection;
 
 /**
- * A wrapper of the C++ ConnectionConfig class.
+ * A wrapper of the C++ ConnectionConfiguration class.
  *
  * We use a wrapper for future extensibility and in order to have a minimal
  * capability for type checking in C even though the C++ class
diff --git a/src/caosdb/configuration.cpp b/src/caosdb/configuration.cpp
index 454f6c74369e2bc755009f1bd67bf299d888db19..c40340aa51148a525dad65fe66a158d70c417550 100644
--- a/src/caosdb/configuration.cpp
+++ b/src/caosdb/configuration.cpp
@@ -27,7 +27,7 @@
 #include "boost/json/string.hpp"              // for string
 #include "boost/json/string_view.hpp"         // for string_view
 #include "caosdb/authentication.h"            // for PlainPasswordAuthentic...
-#include "caosdb/connection.h"                // for TlsConnectionConfig
+#include "caosdb/connection.h"                // for TlsConnectionConfiguration
 #include "caosdb/constants.h"                 // for LIBCAOSDB_CONFIGURATIO...
 #include "caosdb/exceptions.h"                // for ConfigurationError
 
@@ -39,15 +39,15 @@ using boost::json::value;
 using caosdb::authentication::Authenticator;
 using caosdb::authentication::PlainPasswordAuthenticator;
 using caosdb::connection::CertificateProvider;
-using caosdb::connection::ConnectionConfig;
-using caosdb::connection::InsecureConnectionConfig;
+using caosdb::connection::ConnectionConfiguration;
+using caosdb::connection::InsecureConnectionConfiguration;
 using caosdb::connection::PemFileCertificateProvider;
-using caosdb::connection::TlsConnectionConfig;
+using caosdb::connection::TlsConnectionConfiguration;
 using caosdb::exceptions::ConfigurationError;
 using caosdb::utility::get_home_directory;
 using caosdb::utility::load_json_file;
 
-auto ConnectionConfigurationHelper::CreateCertificateProvider(
+auto ConnectionConfigurationurationHelper::CreateCertificateProvider(
   const object &from) const -> std::unique_ptr<CertificateProvider> {
   std::unique_ptr<CertificateProvider> certificate_provider;
   if (from.contains("server_certificate_path")) {
@@ -59,7 +59,7 @@ auto ConnectionConfigurationHelper::CreateCertificateProvider(
   return certificate_provider;
 };
 
-auto ConnectionConfigurationHelper::CreateAuthenticator(
+auto ConnectionConfigurationurationHelper::CreateAuthenticator(
   const object &from) const -> std::unique_ptr<Authenticator> {
   std::unique_ptr<Authenticator> authenticator;
   if (from.contains("authentication")) {
@@ -89,32 +89,34 @@ auto ConnectionConfigurationHelper::CreateAuthenticator(
   return authenticator;
 };
 
-auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
+auto ConnectionConfigurationurationHelper::CreateConnectionConfigurationuration(
   const bool tls, const std::string &host, const int port,
   const CertificateProvider *certificate_provider,
   const Authenticator *authenticator) const
-  -> std::unique_ptr<ConnectionConfig> {
+  -> std::unique_ptr<ConnectionConfiguration> {
   if (tls) {
     if (certificate_provider != nullptr && authenticator != nullptr) {
       // authenticated and special certificate
-      return std::make_unique<TlsConnectionConfig>(
+      return std::make_unique<TlsConnectionConfiguration>(
         host, port, *certificate_provider, *authenticator);
     } else if (certificate_provider != nullptr) {
       // unauthenticated, special certificate
-      return std::make_unique<TlsConnectionConfig>(host, port,
-                                                   *certificate_provider);
+      return std::make_unique<TlsConnectionConfiguration>(
+        host, port, *certificate_provider);
     } else if (authenticator != nullptr) {
       // authenticated, no special certificate
-      return std::make_unique<TlsConnectionConfig>(host, port, *authenticator);
+      return std::make_unique<TlsConnectionConfiguration>(host, port,
+                                                          *authenticator);
     }
     // unauthenticated, no special certificate
-    return std::make_unique<TlsConnectionConfig>(host, port);
+    return std::make_unique<TlsConnectionConfiguration>(host, port);
   } else {
-    return std::make_unique<InsecureConnectionConfig>(host, port);
+    return std::make_unique<InsecureConnectionConfiguration>(host, port);
   }
 };
 
-auto ConnectionConfigurationHelper::IsTls(const object &from) const -> bool {
+auto ConnectionConfigurationurationHelper::IsTls(const object &from) const
+  -> bool {
   bool tls = true;
   if (from.contains("tls")) {
     auto tls_switch = from.at("tls");
@@ -124,8 +126,8 @@ auto ConnectionConfigurationHelper::IsTls(const object &from) const -> bool {
   return tls;
 };
 
-auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
-  const object &from) const -> std::unique_ptr<ConnectionConfig> {
+auto ConnectionConfigurationurationHelper::CreateConnectionConfigurationuration(
+  const object &from) const -> std::unique_ptr<ConnectionConfiguration> {
   assert(from.contains("host"));
   const auto &host = from.at("host");
   assert(host.is_string());
@@ -140,7 +142,7 @@ auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
 
   auto authenticator = CreateAuthenticator(from);
 
-  return CreateConnectionConfiguration(
+  return CreateConnectionConfigurationuration(
     tls, std::string(host.as_string().c_str()),
     static_cast<int>(port.as_int64()), certificate_provider.get(),
     authenticator.get());
@@ -169,10 +171,10 @@ auto ConfigurationManager::mLoadSingleJSONConfiguration(const path &json_file)
   // TODO(far future) validate against json-schema
 };
 
-auto ConfigurationManager::mGetConnectionConfiguration(
-  const std::string &name) const -> std::unique_ptr<ConnectionConfig> {
+auto ConfigurationManager::mGetConnectionConfigurationuration(
+  const std::string &name) const -> std::unique_ptr<ConnectionConfiguration> {
   auto connection_json = GetConnection(name);
-  return connection_configuration_helper.CreateConnectionConfiguration(
+  return connection_configuration_helper.CreateConnectionConfigurationuration(
     connection_json);
 };
 
diff --git a/src/caosdb/connection.cpp b/src/caosdb/connection.cpp
index 376ffbbfdef7b7a001e8041f1314bc3050359e5a..ed4fd2b0c929b20dd67c20672c4428065c29acf2 100644
--- a/src/caosdb/connection.cpp
+++ b/src/caosdb/connection.cpp
@@ -72,66 +72,70 @@ auto PemCertificateProvider::GetCertificatePem() const -> std::string {
   return this->certificate_provider;
 }
 
-ConnectionConfig::ConnectionConfig(const std::string &host, int port) {
+ConnectionConfiguration::ConnectionConfiguration(const std::string &host,
+                                                 int port) {
   this->host = host;
   this->port = port;
 }
 
-auto ConnectionConfig::GetHost() const -> std::string { return this->host; }
+auto ConnectionConfiguration::GetHost() const -> std::string {
+  return this->host;
+}
 
-auto ConnectionConfig::GetPort() const -> int { return this->port; }
+auto ConnectionConfiguration::GetPort() const -> int { return this->port; }
 
-auto operator<<(std::ostream &out, const ConnectionConfig &config)
+auto operator<<(std::ostream &out, const ConnectionConfiguration &config)
   -> std::ostream & {
   out << config.ToString();
   return out;
 }
 
-InsecureConnectionConfig::InsecureConnectionConfig(const std::string &host,
-                                                   int port)
-  : ConnectionConfig(host, port) {
+InsecureConnectionConfiguration::InsecureConnectionConfiguration(
+  const std::string &host, int port)
+  : ConnectionConfiguration(host, port) {
   this->credentials = InsecureChannelCredentials();
 }
 
-auto InsecureConnectionConfig::GetChannelCredentials() const
+auto InsecureConnectionConfiguration::GetChannelCredentials() const
   -> std::shared_ptr<ChannelCredentials> {
   return this->credentials;
 }
 
-auto InsecureConnectionConfig::ToString() const -> std::string {
-  return "InsecureConnectionConfig(" + this->GetHost() + "," +
+auto InsecureConnectionConfiguration::ToString() const -> std::string {
+  return "InsecureConnectionConfiguration(" + this->GetHost() + "," +
          std::to_string(this->GetPort()) + ")";
 }
 
-TlsConnectionConfig::TlsConnectionConfig(const std::string &host, int port)
-  : ConnectionConfig(host, port) {
+TlsConnectionConfiguration::TlsConnectionConfiguration(const std::string &host,
+                                                       int port)
+  : ConnectionConfiguration(host, port) {
   SslCredentialsOptions options;
   this->credentials = SslCredentials(options);
 }
 
-TlsConnectionConfig::TlsConnectionConfig(
+TlsConnectionConfiguration::TlsConnectionConfiguration(
   const std::string &host, int port,
   const CertificateProvider &certificate_provider)
-  : ConnectionConfig(host, port) {
+  : ConnectionConfiguration(host, port) {
   SslCredentialsOptions options;
   options.pem_root_certs = certificate_provider.GetCertificatePem();
   this->credentials = SslCredentials(options);
 }
 
-TlsConnectionConfig::TlsConnectionConfig(const std::string &host, int port,
-                                         const Authenticator &authenticator)
-  : ConnectionConfig(host, port) {
+TlsConnectionConfiguration::TlsConnectionConfiguration(
+  const std::string &host, int port, const Authenticator &authenticator)
+  : ConnectionConfiguration(host, port) {
 
   SslCredentialsOptions options;
   this->credentials = grpc::CompositeChannelCredentials(
     SslCredentials(options), authenticator.GetCallCredentials());
 }
 
-TlsConnectionConfig::TlsConnectionConfig(
+TlsConnectionConfiguration::TlsConnectionConfiguration(
   const std::string &host, int port,
   const CertificateProvider &certificate_provider,
   const Authenticator &authenticator)
-  : ConnectionConfig(host, port) {
+  : ConnectionConfiguration(host, port) {
 
   SslCredentialsOptions options;
   options.pem_root_certs = certificate_provider.GetCertificatePem();
@@ -139,18 +143,18 @@ TlsConnectionConfig::TlsConnectionConfig(
     SslCredentials(options), authenticator.GetCallCredentials());
 }
 
-auto TlsConnectionConfig::GetChannelCredentials() const
+auto TlsConnectionConfiguration::GetChannelCredentials() const
   -> std::shared_ptr<ChannelCredentials> {
   return this->credentials;
 }
 
-auto TlsConnectionConfig::ToString() const -> std::string {
-  return "TlsConnectionConfig(" + this->GetHost() + "," +
+auto TlsConnectionConfiguration::ToString() const -> std::string {
+  return "TlsConnectionConfiguration(" + this->GetHost() + "," +
          std::to_string(this->GetPort()) + "," + this->certificate_provider +
          ")";
 }
 
-Connection::Connection(const ConnectionConfig &config) {
+Connection::Connection(const ConnectionConfiguration &config) {
   const std::string target =
     config.GetHost() + ":" + std::to_string(config.GetPort());
   this->channel = grpc::CreateChannel(target, config.GetChannelCredentials());
@@ -203,7 +207,8 @@ auto ConnectionManager::mGetConnection(const std::string &name) const
   -> const std::shared_ptr<Connection> & {
   if (!HasConnection(name)) {
     try {
-      auto connection = ConfigurationManager::GetConnectionConfiguration(name);
+      auto connection =
+        ConfigurationManager::GetConnectionConfigurationuration(name);
       connections[name] = std::make_shared<Connection>(*connection.release());
     } catch (const caosdb::exceptions::ConfigurationError &exc) {
       throw caosdb::exceptions::UnknownConnectionError("No connection named '" +
@@ -218,7 +223,7 @@ auto ConnectionManager::mGetDefaultConnection() const
   if (!HasConnection(default_connection_name)) {
     default_connection_name = ConfigurationManager::GetDefaultConnectionName();
     auto default_connection =
-      ConfigurationManager::GetDefaultConnectionConfiguration();
+      ConfigurationManager::GetDefaultConnectionConfigurationuration();
     connections[default_connection_name] =
       std::make_shared<Connection>(*default_connection.release());
   }
diff --git a/src/ccaosdb.cpp b/src/ccaosdb.cpp
index da07682656b49af20b82a7cc0c26d89c986b9055..2c9539af8036de10d36bb41b6ce188070cb21bcc 100644
--- a/src/ccaosdb.cpp
+++ b/src/ccaosdb.cpp
@@ -86,25 +86,25 @@ int caosdb_connection_create_tls_connection_configuration(
       static_cast<caosdb::authentication::Authenticator *>(
         authenticator->wrapped_authenticator);
     out->wrapped_connection_configuration =
-      new caosdb::connection::TlsConnectionConfig(
+      new caosdb::connection::TlsConnectionConfiguration(
         host_str, port, *wrapped_provider, *wrapped_authenticator);
   } else if (authenticator != nullptr) {
     auto wrapped_authenticator =
       static_cast<caosdb::authentication::Authenticator *>(
         authenticator->wrapped_authenticator);
     out->wrapped_connection_configuration =
-      new caosdb::connection::TlsConnectionConfig(host_str, port,
-                                                  *wrapped_authenticator);
+      new caosdb::connection::TlsConnectionConfiguration(
+        host_str, port, *wrapped_authenticator);
   } else if (provider != nullptr) {
     auto wrapped_provider =
       static_cast<caosdb::connection::CertificateProvider *>(
         provider->wrapped_certificate_provider);
     out->wrapped_connection_configuration =
-      new caosdb::connection::TlsConnectionConfig(host_str, port,
-                                                  *wrapped_provider);
+      new caosdb::connection::TlsConnectionConfiguration(host_str, port,
+                                                         *wrapped_provider);
   } else {
     out->wrapped_connection_configuration =
-      new caosdb::connection::TlsConnectionConfig(host_str, port);
+      new caosdb::connection::TlsConnectionConfiguration(host_str, port);
   }
   return 0;
 }
@@ -113,13 +113,13 @@ int caosdb_connection_create_insecure_connection_configuration(
   caosdb_connection_connection_configuration *out, const char *host,
   const int port) {
   out->wrapped_connection_configuration =
-    new caosdb::connection::InsecureConnectionConfig(host, port);
+    new caosdb::connection::InsecureConnectionConfiguration(host, port);
   return 0;
 }
 
 int caosdb_connection_delete_connection_configuration(
   caosdb_connection_connection_configuration *configuration) {
-  delete static_cast<caosdb::connection::ConnectionConfig *>(
+  delete static_cast<caosdb::connection::ConnectionConfiguration *>(
     configuration->wrapped_connection_configuration);
   return 0;
 }
@@ -127,8 +127,8 @@ int caosdb_connection_delete_connection_configuration(
 int caosdb_connection_create_connection(
   caosdb_connection_connection *out,
   const caosdb_connection_connection_configuration *configuration) {
-  caosdb::connection::ConnectionConfig *config =
-    static_cast<caosdb::connection::ConnectionConfig *>(
+  caosdb::connection::ConnectionConfiguration *config =
+    static_cast<caosdb::connection::ConnectionConfiguration *>(
       configuration->wrapped_connection_configuration);
   out->wrapped_connection = new caosdb::connection::Connection(*config);
   return 0;
diff --git a/test/test_connection.cpp b/test/test_connection.cpp
index b9e967f29d4a382fe78b78dd784bc856c3ded0a5..db3ff01a3e74a5a1991d3697261a19a93bf96472 100644
--- a/test/test_connection.cpp
+++ b/test/test_connection.cpp
@@ -44,7 +44,7 @@ protected:
 };
 
 TEST_F(test_connection, configure_insecure_localhost_8080) {
-  InsecureConnectionConfig config("localhost", 8000);
+  InsecureConnectionConfiguration config("localhost", 8000);
 
   EXPECT_EQ("localhost", config.GetHost());
   EXPECT_EQ(8000, config.GetPort());
@@ -54,7 +54,7 @@ TEST_F(test_connection, configure_insecure_localhost_8080) {
 
 TEST_F(test_connection, configure_ssl_localhost_8080) {
   auto cacert = PemCertificateProvider("ca chain");
-  TlsConnectionConfig config("localhost", 44300, cacert);
+  TlsConnectionConfiguration config("localhost", 44300, cacert);
 
   EXPECT_EQ("localhost", config.GetHost());
   EXPECT_EQ(44300, config.GetPort());
diff --git a/test/test_transaction.cpp b/test/test_transaction.cpp
index ca4ab51f860c24a744a446533f1b49943cf4b0d9..5b0915f2d73739107b8c9ba065f97950dccc78ea 100644
--- a/test/test_transaction.cpp
+++ b/test/test_transaction.cpp
@@ -33,14 +33,14 @@
 
 namespace caosdb::transaction {
 using caosdb::connection::Connection;
-using caosdb::connection::InsecureConnectionConfig;
+using caosdb::connection::InsecureConnectionConfiguration;
 using caosdb::exceptions::ConnectionError;
 using caosdb::transaction::UniqueResult;
 using ProtoEntity = caosdb::entity::v1alpha1::Entity;
 
 TEST(test_transaction, create_transaction) {
   const auto *host = "localhost";
-  auto config = InsecureConnectionConfig(host, 8000);
+  auto config = InsecureConnectionConfiguration(host, 8000);
   Connection connection(config);
   auto transaction = connection.CreateTransaction();