diff --git a/libs/client/CMakeLists.txt b/libs/client/CMakeLists.txt
index 94e6f956fb591e8f4582154b23e9baba58d5da6a..776b35e6013e297a40c9fead5ee9c12c75cedc32 100644
--- a/libs/client/CMakeLists.txt
+++ b/libs/client/CMakeLists.txt
@@ -2,7 +2,6 @@ cmake_minimum_required (VERSION 2.6)
 
 set (CLIENT_LIB_SRC_FILES
   ArchiveJob.cpp
-  ClientAPI.cpp
   DirectoryEntry.cpp
   DirectoryIterator.cpp
   Exception.cpp
@@ -12,10 +11,11 @@ set (CLIENT_LIB_SRC_FILES
   FileSystemStorageClass.cpp
   FileSystemStorageClasses.cpp
   LogicalLibrary.cpp
+  MiddleTierAdmin.cpp
   MigrationRoute.cpp
   MigrationRouteId.cpp
   MigrationRoutes.cpp
-  MockClientAPI.cpp
+  MockMiddleTierAdmin.cpp
   SecurityIdentity.cpp
   StorageClass.cpp
   TapePool.cpp
diff --git a/libs/client/ClientAPI.cpp b/libs/client/MiddleTierAdmin.cpp
similarity index 68%
rename from libs/client/ClientAPI.cpp
rename to libs/client/MiddleTierAdmin.cpp
index 0c026b2d9c711bc85ff9a73a0ad8b97497ee57fc..2d62bf66bfbe73cf76510cadf60888406fcaa235 100644
--- a/libs/client/ClientAPI.cpp
+++ b/libs/client/MiddleTierAdmin.cpp
@@ -1,7 +1,7 @@
-#include "ClientAPI.hpp"
+#include "MiddleTierAdmin.hpp"
 
 //------------------------------------------------------------------------------
 // destructor
 //------------------------------------------------------------------------------
-cta::ClientAPI::~ClientAPI() throw() {
+cta::MiddleTierAdmin::~MiddleTierAdmin() throw() {
 }
diff --git a/libs/client/ClientAPI.hpp b/libs/client/MiddleTierAdmin.hpp
similarity index 98%
rename from libs/client/ClientAPI.hpp
rename to libs/client/MiddleTierAdmin.hpp
index cbaf752e56bcd73703767862c9d4812a78637d16..52ba09872940ed4c92b856dea1df89ae389f75a4 100644
--- a/libs/client/ClientAPI.hpp
+++ b/libs/client/MiddleTierAdmin.hpp
@@ -16,16 +16,15 @@
 namespace cta {
 
 /**
- * Abstract class that specifies the client API of the CERN Tape Archive
- * project.
+ * Abstract class that defines the administration API of the the middle-tier.
  */
-class ClientAPI {
+class MiddleTierAdmin {
 public:
 
   /**
    * Destructor.
    */
-  virtual ~ClientAPI() throw() = 0;
+  virtual ~MiddleTierAdmin() throw() = 0;
 
   /**
    * Creates the specified administrator.
@@ -344,6 +343,6 @@ public:
     const SecurityIdentity &requester,
     const std::string &tapePoolName) = 0;
 
-}; // class ClientAPI
+}; // class MiddleTierAdmin
 
 } // namespace cta
diff --git a/libs/client/MockClientAPITest.cpp b/libs/client/MockClientAPITest.cpp
index b1bbfb98c7061e5d997be386b8c13438718165b8..d57a60d3de8b58d70ea66c3d82b47f79a8240ed9 100644
--- a/libs/client/MockClientAPITest.cpp
+++ b/libs/client/MockClientAPITest.cpp
@@ -1,10 +1,10 @@
-#include "TestingMockClientAPI.hpp"
+#include "TestingMockMiddleTierAdmin.hpp"
 
 #include <gtest/gtest.h>
 
 namespace unitTests {
 
-class cta_client_MockClientAPITest: public ::testing::Test {
+class cta_client_MockMiddleTierAdminTest: public ::testing::Test {
 protected:
 
   virtual void SetUp() {
@@ -14,10 +14,10 @@ protected:
   }
 };
 
-TEST_F(cta_client_MockClientAPITest, createAdminUser_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createAdminUser_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -41,10 +41,10 @@ TEST_F(cta_client_MockClientAPITest, createAdminUser_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createAdminUser_already_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createAdminUser_already_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -76,10 +76,10 @@ TEST_F(cta_client_MockClientAPITest, createAdminUser_already_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteAdminUser_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteAdminUser_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -110,10 +110,10 @@ TEST_F(cta_client_MockClientAPITest, deleteAdminUser_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteAdminUser_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteAdminUser_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -134,10 +134,10 @@ TEST_F(cta_client_MockClientAPITest, deleteAdminUser_non_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createAdminHost_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createAdminHost_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -158,10 +158,10 @@ TEST_F(cta_client_MockClientAPITest, createAdminHost_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteAdminHost_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteAdminHost_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -190,10 +190,10 @@ TEST_F(cta_client_MockClientAPITest, deleteAdminHost_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteAdminHost_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteAdminHost_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   
   {
@@ -212,10 +212,10 @@ TEST_F(cta_client_MockClientAPITest, deleteAdminHost_non_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createStorageClass_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createStorageClass_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -241,10 +241,11 @@ TEST_F(cta_client_MockClientAPITest, createStorageClass_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createStorageClass_already_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createStorageClass_already_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -273,10 +274,11 @@ TEST_F(cta_client_MockClientAPITest, createStorageClass_already_existing) {
     std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createStorageClass_lexicographical_order) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createStorageClass_lexicographical_order) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -305,10 +307,10 @@ TEST_F(cta_client_MockClientAPITest, createStorageClass_lexicographical_order) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteStorageClass_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteStorageClass_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -342,10 +344,11 @@ TEST_F(cta_client_MockClientAPITest, deleteStorageClass_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteStorageClass_in_use_by_directory) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  deleteStorageClass_in_use_by_directory) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -399,10 +402,10 @@ TEST_F(cta_client_MockClientAPITest, deleteStorageClass_in_use_by_directory) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteStorageClass_in_use_by_route) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteStorageClass_in_use_by_route) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -492,10 +495,10 @@ TEST_F(cta_client_MockClientAPITest, deleteStorageClass_in_use_by_route) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteStorageClass_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteStorageClass_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -514,10 +517,10 @@ TEST_F(cta_client_MockClientAPITest, deleteStorageClass_non_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createTapePool_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createTapePool_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -545,10 +548,10 @@ TEST_F(cta_client_MockClientAPITest, createTapePool_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createTapePool_already_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createTapePool_already_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -579,10 +582,10 @@ TEST_F(cta_client_MockClientAPITest, createTapePool_already_existing) {
     nbPartialTapes, comment), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createTapePool_lexicographical_order) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createTapePool_lexicographical_order) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -618,10 +621,10 @@ TEST_F(cta_client_MockClientAPITest, createTapePool_lexicographical_order) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteTapePool_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteTapePool_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -657,10 +660,10 @@ TEST_F(cta_client_MockClientAPITest, deleteTapePool_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteTapePool_in_use) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteTapePool_in_use) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -714,10 +717,10 @@ TEST_F(cta_client_MockClientAPITest, deleteTapePool_in_use) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteTapePool_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteTapePool_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -736,10 +739,10 @@ TEST_F(cta_client_MockClientAPITest, deleteTapePool_non_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createMigrationRoute_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createMigrationRoute_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -779,10 +782,11 @@ TEST_F(cta_client_MockClientAPITest, createMigrationRoute_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createMigrationRoute_already_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createMigrationRoute_already_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -825,10 +829,10 @@ TEST_F(cta_client_MockClientAPITest, createMigrationRoute_already_existing) {
     copyNb, tapePoolName, comment), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteMigrationRoute_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteMigrationRoute_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -877,10 +881,10 @@ TEST_F(cta_client_MockClientAPITest, deleteMigrationRoute_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteMigrationRoute_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteMigrationRoute_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -908,10 +912,11 @@ TEST_F(cta_client_MockClientAPITest, deleteMigrationRoute_non_existing) {
     std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, getDirectoryContents_root_dir_is_empty) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  getDirectoryContents_root_dir_is_empty) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/";
 
@@ -920,40 +925,41 @@ TEST_F(cta_client_MockClientAPITest, getDirectoryContents_root_dir_is_empty) {
   ASSERT_FALSE(itor.hasMore());
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_empty_string) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createDirectory_empty_string) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "";
 
   ASSERT_THROW(api.createDirectory(requester, dirPath), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_consecutive_slashes) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createDirectory_consecutive_slashes) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "//";
 
   ASSERT_THROW(api.createDirectory(requester, dirPath), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_invalid_chars) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createDirectory_invalid_chars) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/grandparent/?parent";
   
   ASSERT_THROW(api.createDirectory(requester, dirPath), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createDirectory_top_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/grandparent";
   
@@ -972,10 +978,10 @@ TEST_F(cta_client_MockClientAPITest, createDirectory_top_level) {
   ASSERT_EQ(std::string("grandparent"), entry.getName());
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_second_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createDirectory_second_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   ASSERT_TRUE(api.getDirectoryStorageClass(requester, "/").empty());
@@ -1036,13 +1042,15 @@ TEST_F(cta_client_MockClientAPITest, createDirectory_second_level) {
     ASSERT_EQ(std::string("parent"), entry.getName());
   }
 
-  ASSERT_TRUE(api.getDirectoryStorageClass(requester, "/grandparent/parent").empty());
+  ASSERT_TRUE(api.getDirectoryStorageClass(requester,
+    "/grandparent/parent").empty());
 }
 
-TEST_F(cta_client_MockClientAPITest, createDirectory_inherit_storage_class) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createDirectory_inherit_storage_class) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   ASSERT_TRUE(api.getDirectoryStorageClass(requester, "/").empty());
@@ -1120,20 +1128,20 @@ TEST_F(cta_client_MockClientAPITest, createDirectory_inherit_storage_class) {
     api.getDirectoryStorageClass(requester, "/grandparent/parent"));
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteDirectory_root) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteDirectory_root) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/";
 
   ASSERT_THROW(api.deleteDirectory(requester, "/"), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteDirectory_existing_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteDirectory_existing_top_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/grandparent";
   
@@ -1164,10 +1172,11 @@ TEST_F(cta_client_MockClientAPITest, deleteDirectory_existing_top_level) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteDirectory_non_empty_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  deleteDirectory_non_empty_top_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -1237,19 +1246,20 @@ TEST_F(cta_client_MockClientAPITest, deleteDirectory_non_empty_top_level) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteDirectory_non_existing_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  deleteDirectory_non_existing_top_level) {
   using namespace cta;
   
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   ASSERT_THROW(api.deleteDirectory(requester, "/grandparent"), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, setDirectoryStorageClass_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest, setDirectoryStorageClass_top_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/grandparent";
 
@@ -1289,10 +1299,11 @@ TEST_F(cta_client_MockClientAPITest, setDirectoryStorageClass_top_level) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, clearDirectoryStorageClass_top_level) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  clearDirectoryStorageClass_top_level) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
   const std::string dirPath = "/grandparent";
 
@@ -1345,91 +1356,93 @@ TEST_F(cta_client_MockClientAPITest, clearDirectoryStorageClass_top_level) {
   ASSERT_NO_THROW(api.deleteStorageClass(requester, storageClassName));
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_emptyString) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_emptyString) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s;
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(s, trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_noSlashes) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_noSlashes) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("NO_SLASHES");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(s, trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_oneLeftSlash) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_oneLeftSlash) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("/VALUE");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_twoLeftSlashes) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_twoLeftSlashes) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("//VALUE");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_oneRightSlash) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_oneRightSlash) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("VALUE/");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_twoRightSlashes) {
+TEST_F(cta_client_MockMiddleTierAdminTest, trimSlashes_twoRightSlashes) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("VALUE//");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_oneLeftAndOneRightSlash) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  trimSlashes_oneLeftAndOneRightSlash) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("/VALUE/");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, trimSlashes_twoLeftAndTwoRightSlashes) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  trimSlashes_twoLeftAndTwoRightSlashes) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string s("//VALUE//");
   const std::string trimmedString = api.trimSlashes(s);
   ASSERT_EQ(std::string("VALUE"), trimmedString);
 }
 
-TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_empty_string) {
+TEST_F(cta_client_MockMiddleTierAdminTest, getEnclosingDirPath_empty_string) {
   using namespace cta;
     
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string dirPath = "";
 
   ASSERT_THROW(api.getEnclosingDirPath(dirPath), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_root) {
+TEST_F(cta_client_MockMiddleTierAdminTest, getEnclosingDirPath_root) {
   using namespace cta;
     
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string dirPath = "/";
 
   std::string enclosingDirPath;
@@ -1437,10 +1450,10 @@ TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_root) {
     std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent) {
+TEST_F(cta_client_MockMiddleTierAdminTest, getEnclosingDirPath_grandparent) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string dirPath = "/grandparent";
     
   std::string enclosingDirPath;
@@ -1448,10 +1461,11 @@ TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent) {
   ASSERT_EQ(std::string("/"), enclosingDirPath);
 }
 
-TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent_parent) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  getEnclosingDirPath_grandparent_parent) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string dirPath = "/grandparent/parent";
 
   std::string enclosingDirPath;
@@ -1459,10 +1473,11 @@ TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent_parent) {
   ASSERT_EQ(std::string("/grandparent/"), enclosingDirPath);
 }
 
-TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent_parent_child) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  getEnclosingDirPath_grandparent_parent_child) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const std::string dirPath = "/grandparent/parent/child";
 
   std::string enclosingDirPath;
@@ -1470,12 +1485,12 @@ TEST_F(cta_client_MockClientAPITest, getEnclosingDirPath_grandparent_parent_chil
   ASSERT_EQ(std::string("/grandparent/parent/"), enclosingDirPath);
 }
 
-TEST_F(cta_client_MockClientAPITest, splitString_goodDay) {
+TEST_F(cta_client_MockMiddleTierAdminTest, splitString_goodDay) {
   using namespace cta;
   const std::string line("col0 col1 col2 col3 col4 col5 col6 col7");
   std::vector<std::string> columns;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
 
   ASSERT_NO_THROW(api.splitString(line, ' ', columns));
   ASSERT_EQ((std::vector<std::string>::size_type)8, columns.size());
@@ -1489,34 +1504,34 @@ TEST_F(cta_client_MockClientAPITest, splitString_goodDay) {
   ASSERT_EQ(std::string("col7"), columns[7]);
 }
 
-TEST_F(cta_client_MockClientAPITest, splitString_emptyString) {
+TEST_F(cta_client_MockMiddleTierAdminTest, splitString_emptyString) {
   using namespace cta;
   const std::string emptyString;
   std::vector<std::string> columns;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
 
   ASSERT_NO_THROW(api.splitString(emptyString, ' ', columns));
   ASSERT_EQ((std::vector<std::string>::size_type)0, columns.size());
 }
 
-TEST_F(cta_client_MockClientAPITest, splitString_noSeparatorInString) {
+TEST_F(cta_client_MockMiddleTierAdminTest, splitString_noSeparatorInString) {
   using namespace cta;
   const std::string stringContainingNoSeparator =
     "stringContainingNoSeparator";
   std::vector<std::string> columns;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
 
   ASSERT_NO_THROW(api.splitString(stringContainingNoSeparator, ' ', columns));
   ASSERT_EQ((std::vector<std::string>::size_type)1, columns.size());
   ASSERT_EQ(stringContainingNoSeparator, columns[0]);
 }
 
-TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_new) {
+TEST_F(cta_client_MockMiddleTierAdminTest, createLogicalLibrary_new) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -1542,10 +1557,11 @@ TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_new) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_already_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createLogicalLibrary_already_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -1574,10 +1590,11 @@ TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_already_existing) {
     libraryComment), std::exception);
 }
 
-TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_lexicographical_order) {
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createLogicalLibrary_lexicographical_order) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -1606,10 +1623,10 @@ TEST_F(cta_client_MockClientAPITest, createLogicalLibrary_lexicographical_order)
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteLogicalLibrary_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteLogicalLibrary_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
@@ -1643,10 +1660,10 @@ TEST_F(cta_client_MockClientAPITest, deleteLogicalLibrary_existing) {
   }
 }
 
-TEST_F(cta_client_MockClientAPITest, deleteLogicalLibrary_non_existing) {
+TEST_F(cta_client_MockMiddleTierAdminTest, deleteLogicalLibrary_non_existing) {
   using namespace cta;
 
-  TestingMockClientAPI api;
+  TestingMockMiddleTierAdmin api;
   const SecurityIdentity requester;
 
   {
diff --git a/libs/client/MockClientAPI.cpp b/libs/client/MockMiddleTierAdmin.cpp
similarity index 87%
rename from libs/client/MockClientAPI.cpp
rename to libs/client/MockMiddleTierAdmin.cpp
index 2bcc95a08453a152ddd7f8f702cfbc0040da9ae0..f66d7a4ac3e7751efec8923890828d974d47dceb 100644
--- a/libs/client/MockClientAPI.cpp
+++ b/libs/client/MockMiddleTierAdmin.cpp
@@ -1,5 +1,5 @@
 #include "Exception.hpp"
-#include "MockClientAPI.hpp"
+#include "MockMiddleTierAdmin.hpp"
 
 #include <iostream>
 #include <memory>
@@ -8,7 +8,7 @@
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::MockClientAPI::MockClientAPI():
+cta::MockMiddleTierAdmin::MockMiddleTierAdmin():
   m_fileSystemRoot(m_storageClasses,
     DirectoryEntry(DirectoryEntry::ENTRYTYPE_DIRECTORY, "/", "")) {
 }
@@ -16,13 +16,13 @@ cta::MockClientAPI::MockClientAPI():
 //------------------------------------------------------------------------------
 // destructor
 //------------------------------------------------------------------------------
-cta::MockClientAPI::~MockClientAPI() throw() {
+cta::MockMiddleTierAdmin::~MockMiddleTierAdmin() throw() {
 }
 
 //------------------------------------------------------------------------------
 // createAdminUser
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createAdminUser(
+void cta::MockMiddleTierAdmin::createAdminUser(
   const SecurityIdentity &requester,
   const UserIdentity &adminUser) {
   checkAdminUserDoesNotAlreadyExist(adminUser);
@@ -32,7 +32,7 @@ void cta::MockClientAPI::createAdminUser(
 //------------------------------------------------------------------------------
 // checkAdminUserDoesNotAlreadyExist
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkAdminUserDoesNotAlreadyExist(
+void cta::MockMiddleTierAdmin::checkAdminUserDoesNotAlreadyExist(
   const UserIdentity &adminUser) {
   for(std::list<UserIdentity>::const_iterator itor = m_adminUsers.begin();
     itor != m_adminUsers.end(); itor++) {
@@ -48,7 +48,7 @@ void cta::MockClientAPI::checkAdminUserDoesNotAlreadyExist(
 //------------------------------------------------------------------------------
 // deleteAdminUser
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteAdminUser(
+void cta::MockMiddleTierAdmin::deleteAdminUser(
   const SecurityIdentity &requester,
   const UserIdentity &adminUser) {
   for(std::list<UserIdentity>::iterator itor = m_adminUsers.begin();
@@ -68,7 +68,7 @@ void cta::MockClientAPI::deleteAdminUser(
 //------------------------------------------------------------------------------
 // getAdminUsers
 //------------------------------------------------------------------------------
-std::list<cta::UserIdentity> cta::MockClientAPI::getAdminUsers(
+std::list<cta::UserIdentity> cta::MockMiddleTierAdmin::getAdminUsers(
   const SecurityIdentity &requester) const {
   return m_adminUsers;
 }
@@ -76,7 +76,7 @@ std::list<cta::UserIdentity> cta::MockClientAPI::getAdminUsers(
 //------------------------------------------------------------------------------
 // createAdminHost
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createAdminHost(
+void cta::MockMiddleTierAdmin::createAdminHost(
   const SecurityIdentity &requester,
   const std::string &adminHost) {
   checkAdminHostDoesNotAlreadyExist(adminHost);
@@ -86,7 +86,7 @@ void cta::MockClientAPI::createAdminHost(
 //------------------------------------------------------------------------------
 // checkAdminHostDoesNotAlreadyExist
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkAdminHostDoesNotAlreadyExist(
+void cta::MockMiddleTierAdmin::checkAdminHostDoesNotAlreadyExist(
   const std::string &adminHost) {
   for(std::list<std::string>::const_iterator itor = m_adminHosts.begin();
     itor != m_adminHosts.end(); itor++) {
@@ -101,7 +101,7 @@ void cta::MockClientAPI::checkAdminHostDoesNotAlreadyExist(
 //------------------------------------------------------------------------------
 // deleteAdminHost
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteAdminHost(
+void cta::MockMiddleTierAdmin::deleteAdminHost(
   const SecurityIdentity &requester,
   const std::string &adminHost) {
   for(std::list<std::string>::iterator itor = m_adminHosts.begin();
@@ -122,7 +122,7 @@ void cta::MockClientAPI::deleteAdminHost(
 //------------------------------------------------------------------------------
 // getAdminHosts
 //------------------------------------------------------------------------------
-std::list<std::string> cta::MockClientAPI::getAdminHosts(
+std::list<std::string> cta::MockMiddleTierAdmin::getAdminHosts(
   const SecurityIdentity &requester) const {
   return m_adminHosts;
 }
@@ -130,7 +130,7 @@ std::list<std::string> cta::MockClientAPI::getAdminHosts(
 //------------------------------------------------------------------------------
 // createStorageClass
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createStorageClass(const SecurityIdentity &requester,
+void cta::MockMiddleTierAdmin::createStorageClass(const SecurityIdentity &requester,
   const std::string &name, const uint8_t nbCopies, const std::string &comment) {
   m_storageClasses.createStorageClass(name, nbCopies, requester.user, comment);
 }
@@ -138,7 +138,7 @@ void cta::MockClientAPI::createStorageClass(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // deleteStorageClass
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteStorageClass(const SecurityIdentity &requester,
+void cta::MockMiddleTierAdmin::deleteStorageClass(const SecurityIdentity &requester,
   const std::string &name) {
   checkStorageClassIsNotInAMigrationRoute(name);
   m_storageClasses.deleteStorageClass(name);
@@ -147,7 +147,7 @@ void cta::MockClientAPI::deleteStorageClass(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // checkStorageClassIsNotInAMigrationRoute
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkStorageClassIsNotInAMigrationRoute(
+void cta::MockMiddleTierAdmin::checkStorageClassIsNotInAMigrationRoute(
   const std::string &name) const {
   if(m_migrationRoutes.storageClassIsInAMigrationRoute(name)) {
     std::ostringstream message;
@@ -159,7 +159,7 @@ void cta::MockClientAPI::checkStorageClassIsNotInAMigrationRoute(
 //------------------------------------------------------------------------------
 // getStorageClasses
 //------------------------------------------------------------------------------
-std::list<cta::StorageClass> cta::MockClientAPI::getStorageClasses(
+std::list<cta::StorageClass> cta::MockMiddleTierAdmin::getStorageClasses(
   const SecurityIdentity &requester) const {
   return m_storageClasses.getStorageClasses();
 }
@@ -167,7 +167,7 @@ std::list<cta::StorageClass> cta::MockClientAPI::getStorageClasses(
 //------------------------------------------------------------------------------
 // createTapePool
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createTapePool(
+void cta::MockMiddleTierAdmin::createTapePool(
   const SecurityIdentity &requester,
   const std::string &name,
   const uint16_t nbDrives,
@@ -181,7 +181,7 @@ void cta::MockClientAPI::createTapePool(
 //------------------------------------------------------------------------------
 // checkTapePoolDoesNotAlreadyExist
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkTapePoolDoesNotAlreadyExist(
+void cta::MockMiddleTierAdmin::checkTapePoolDoesNotAlreadyExist(
   const std::string &name) const {
   std::map<std::string, TapePool>::const_iterator itor = m_tapePools.find(name);
   if(itor != m_tapePools.end()) {
@@ -194,7 +194,7 @@ void cta::MockClientAPI::checkTapePoolDoesNotAlreadyExist(
 //------------------------------------------------------------------------------
 // deleteTapePool
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteTapePool(const SecurityIdentity &requester,
+void cta::MockMiddleTierAdmin::deleteTapePool(const SecurityIdentity &requester,
   const std::string &name) {
   std::map<std::string, TapePool>::iterator itor = m_tapePools.find(name);
   if(itor == m_tapePools.end()) {
@@ -209,7 +209,7 @@ void cta::MockClientAPI::deleteTapePool(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // checkTapePoolIsNotInUse
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkTapePoolIsNotInUse(const std::string &name)
+void cta::MockMiddleTierAdmin::checkTapePoolIsNotInUse(const std::string &name)
   const {
   if(m_migrationRoutes.tapePoolIsInAMigrationRoute(name)) {
     std::ostringstream message;
@@ -221,7 +221,7 @@ void cta::MockClientAPI::checkTapePoolIsNotInUse(const std::string &name)
 //------------------------------------------------------------------------------
 // getTapePools
 //------------------------------------------------------------------------------
-std::list<cta::TapePool> cta::MockClientAPI::getTapePools(
+std::list<cta::TapePool> cta::MockMiddleTierAdmin::getTapePools(
   const SecurityIdentity &requester) const {
   std::list<cta::TapePool> tapePools;
 
@@ -235,7 +235,7 @@ std::list<cta::TapePool> cta::MockClientAPI::getTapePools(
 //------------------------------------------------------------------------------
 // createMigrationRoute
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createMigrationRoute(
+void cta::MockMiddleTierAdmin::createMigrationRoute(
   const SecurityIdentity &requester,
   const std::string &storageClassName,
   const uint8_t copyNb,
@@ -252,7 +252,7 @@ void cta::MockClientAPI::createMigrationRoute(
 //------------------------------------------------------------------------------
 // deleteMigrationRoute
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteMigrationRoute(
+void cta::MockMiddleTierAdmin::deleteMigrationRoute(
   const SecurityIdentity &requester,
   const std::string &storageClassName,
   const uint8_t copyNb) {
@@ -262,7 +262,7 @@ void cta::MockClientAPI::deleteMigrationRoute(
 //------------------------------------------------------------------------------
 // getMigrationRoutes
 //------------------------------------------------------------------------------
-std::list<cta::MigrationRoute> cta::MockClientAPI::getMigrationRoutes(
+std::list<cta::MigrationRoute> cta::MockMiddleTierAdmin::getMigrationRoutes(
   const SecurityIdentity &requester) const {
   return m_migrationRoutes.getMigrationRoutes();
 }
@@ -270,7 +270,7 @@ std::list<cta::MigrationRoute> cta::MockClientAPI::getMigrationRoutes(
 //------------------------------------------------------------------------------
 // createDirectory
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createDirectory(const SecurityIdentity &requester,
+void cta::MockMiddleTierAdmin::createDirectory(const SecurityIdentity &requester,
   const std::string &dirPath) {
   checkAbsolutePathSyntax(dirPath);
 
@@ -304,7 +304,7 @@ void cta::MockClientAPI::createDirectory(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // checkAbsolutePathSyntax
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkAbsolutePathSyntax(const std::string &path)
+void cta::MockMiddleTierAdmin::checkAbsolutePathSyntax(const std::string &path)
   const {
   try {
     checkPathStartsWithASlash(path);
@@ -321,7 +321,7 @@ void cta::MockClientAPI::checkAbsolutePathSyntax(const std::string &path)
 //------------------------------------------------------------------------------
 // checkPathStartsWithASlash
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkPathStartsWithASlash(const std::string &path)
+void cta::MockMiddleTierAdmin::checkPathStartsWithASlash(const std::string &path)
   const {
   if(path.empty()) {
     throw Exception("Path is an empty string");
@@ -335,7 +335,7 @@ void cta::MockClientAPI::checkPathStartsWithASlash(const std::string &path)
 //------------------------------------------------------------------------------
 // checkPathContainsValidChars
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkPathContainsValidChars(const std::string &path)
+void cta::MockMiddleTierAdmin::checkPathContainsValidChars(const std::string &path)
   const {
   for(std::string::const_iterator itor = path.begin(); itor != path.end();
     itor++) {
@@ -346,7 +346,7 @@ void cta::MockClientAPI::checkPathContainsValidChars(const std::string &path)
 //------------------------------------------------------------------------------
 // checkValidPathChar
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkValidPathChar(const char c) const {
+void cta::MockMiddleTierAdmin::checkValidPathChar(const char c) const {
   if(!isValidPathChar(c)) {
     std::ostringstream message;
     message << "The '" << c << "' character cannot be used within a path";
@@ -357,7 +357,7 @@ void cta::MockClientAPI::checkValidPathChar(const char c) const {
 //------------------------------------------------------------------------------
 // isValidPathChar
 //------------------------------------------------------------------------------
-bool cta::MockClientAPI::isValidPathChar(const char c) const {
+bool cta::MockMiddleTierAdmin::isValidPathChar(const char c) const {
   return ('0' <= c && c <= '9') ||
          ('A' <= c && c <= 'Z') ||
          ('a' <= c && c <= 'z') ||
@@ -368,7 +368,7 @@ bool cta::MockClientAPI::isValidPathChar(const char c) const {
 //------------------------------------------------------------------------------
 // checkPathDoesContainConsecutiveSlashes
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkPathDoesContainConsecutiveSlashes(
+void cta::MockMiddleTierAdmin::checkPathDoesContainConsecutiveSlashes(
   const std::string &path) const {
   char previousChar = '\0';
 
@@ -385,7 +385,7 @@ void cta::MockClientAPI::checkPathDoesContainConsecutiveSlashes(
 //------------------------------------------------------------------------------
 // getEnclosingDirPath
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::getEnclosingDirPath(const std::string &path)
+std::string cta::MockMiddleTierAdmin::getEnclosingDirPath(const std::string &path)
   const {
   if(path == "/") {
     throw Exception("Root directory does not have a parent");
@@ -401,7 +401,7 @@ std::string cta::MockClientAPI::getEnclosingDirPath(const std::string &path)
 //------------------------------------------------------------------------------
 // getEnclosedName
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::getEnclosedName(const std::string &path) const {
+std::string cta::MockMiddleTierAdmin::getEnclosedName(const std::string &path) const {
   const std::string::size_type last_slash_idx = path.find_last_of('/');
   if(std::string::npos == last_slash_idx) {
     return path;
@@ -417,7 +417,7 @@ std::string cta::MockClientAPI::getEnclosedName(const std::string &path) const {
 //------------------------------------------------------------------------------
 // getFileSystemNode
 //------------------------------------------------------------------------------
-cta::FileSystemNode &cta::MockClientAPI::getFileSystemNode(
+cta::FileSystemNode &cta::MockMiddleTierAdmin::getFileSystemNode(
   const std::string &path) {
   FileSystemNode *node = &m_fileSystemRoot;
 
@@ -439,7 +439,7 @@ cta::FileSystemNode &cta::MockClientAPI::getFileSystemNode(
 //------------------------------------------------------------------------------
 // getFileSystemNode
 //------------------------------------------------------------------------------
-const cta::FileSystemNode &cta::MockClientAPI::getFileSystemNode(
+const cta::FileSystemNode &cta::MockMiddleTierAdmin::getFileSystemNode(
   const std::string &path) const {
   const FileSystemNode *node = &m_fileSystemRoot;
 
@@ -461,7 +461,7 @@ const cta::FileSystemNode &cta::MockClientAPI::getFileSystemNode(
 //------------------------------------------------------------------------------
 // deleteDirectory
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteDirectory(const SecurityIdentity &requester,
+void cta::MockMiddleTierAdmin::deleteDirectory(const SecurityIdentity &requester,
   const std::string &dirPath) {
   checkAbsolutePathSyntax(dirPath);
 
@@ -489,7 +489,7 @@ void cta::MockClientAPI::deleteDirectory(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // getDirectoryContents
 //------------------------------------------------------------------------------
-cta::DirectoryIterator cta::MockClientAPI::getDirectoryContents(
+cta::DirectoryIterator cta::MockMiddleTierAdmin::getDirectoryContents(
   const SecurityIdentity &requester, const std::string &dirPath) const {
   checkAbsolutePathSyntax(dirPath);
 
@@ -512,7 +512,7 @@ cta::DirectoryIterator cta::MockClientAPI::getDirectoryContents(
 //-----------------------------------------------------------------------------
 // trimSlashes
 //-----------------------------------------------------------------------------
-std::string cta::MockClientAPI::trimSlashes(const std::string &s)
+std::string cta::MockMiddleTierAdmin::trimSlashes(const std::string &s)
   const throw() {
   // Find first non slash character
   size_t beginpos = s.find_first_not_of("/");
@@ -538,7 +538,7 @@ std::string cta::MockClientAPI::trimSlashes(const std::string &s)
 //-----------------------------------------------------------------------------
 // splitString
 //-----------------------------------------------------------------------------
-void cta::MockClientAPI::splitString(const std::string &str,
+void cta::MockMiddleTierAdmin::splitString(const std::string &str,
   const char separator, std::vector<std::string> &result) const throw() {
 
   if(str.empty()) {
@@ -564,7 +564,7 @@ void cta::MockClientAPI::splitString(const std::string &str,
 //------------------------------------------------------------------------------
 // setDirectoryStorageClass
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::setDirectoryStorageClass(
+void cta::MockMiddleTierAdmin::setDirectoryStorageClass(
   const SecurityIdentity &requester,
   const std::string &dirPath,
   const std::string &storageClassName) {
@@ -584,7 +584,7 @@ void cta::MockClientAPI::setDirectoryStorageClass(
 //------------------------------------------------------------------------------
 // clearDirectoryStorageClass
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::clearDirectoryStorageClass(
+void cta::MockMiddleTierAdmin::clearDirectoryStorageClass(
   const SecurityIdentity &requester,
   const std::string &dirPath) {
   FileSystemNode &dirNode = getFileSystemNode(dirPath);
@@ -601,7 +601,7 @@ void cta::MockClientAPI::clearDirectoryStorageClass(
 //------------------------------------------------------------------------------
 // getDirectoryStorageClass
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::getDirectoryStorageClass(
+std::string cta::MockMiddleTierAdmin::getDirectoryStorageClass(
   const SecurityIdentity &requester,
   const std::string &dirPath) const {
   const FileSystemNode &dirNode = getFileSystemNode(dirPath);
@@ -618,7 +618,7 @@ std::string cta::MockClientAPI::getDirectoryStorageClass(
 //------------------------------------------------------------------------------
 // createLogicalLibrary
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::createLogicalLibrary(
+void cta::MockMiddleTierAdmin::createLogicalLibrary(
   const SecurityIdentity &requester,
   const std::string &name,
   const std::string &comment) {
@@ -627,7 +627,7 @@ void cta::MockClientAPI::createLogicalLibrary(
 //------------------------------------------------------------------------------
 // deleteLogicalLibrary
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::deleteLogicalLibrary(
+void cta::MockMiddleTierAdmin::deleteLogicalLibrary(
   const SecurityIdentity &requester,
   const std::string &name) {
 }
@@ -635,7 +635,7 @@ void cta::MockClientAPI::deleteLogicalLibrary(
 //------------------------------------------------------------------------------
 // getLogicalLibraries
 //------------------------------------------------------------------------------
-std::list<cta::LogicalLibrary> cta::MockClientAPI::getLogicalLibraries(
+std::list<cta::LogicalLibrary> cta::MockMiddleTierAdmin::getLogicalLibraries(
   const SecurityIdentity &requester) const {
   std::list<LogicalLibrary> libraries;
   return libraries;
@@ -644,7 +644,7 @@ std::list<cta::LogicalLibrary> cta::MockClientAPI::getLogicalLibraries(
 //------------------------------------------------------------------------------
 // archive
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::archive(const SecurityIdentity &requester,
+std::string cta::MockMiddleTierAdmin::archive(const SecurityIdentity &requester,
   const std::list<std::string> &srcUrls, const std::string &dst) {
   checkAbsolutePathSyntax(dst);
   if(isAnExistingDirectory(dst)) {
@@ -657,7 +657,7 @@ std::string cta::MockClientAPI::archive(const SecurityIdentity &requester,
 //------------------------------------------------------------------------------
 // isAnExistingDirectory
 //------------------------------------------------------------------------------
-bool cta::MockClientAPI::isAnExistingDirectory(const std::string &path)
+bool cta::MockMiddleTierAdmin::isAnExistingDirectory(const std::string &path)
   const throw() {
   try {
     const FileSystemNode &node = getFileSystemNode(path);
@@ -673,7 +673,7 @@ bool cta::MockClientAPI::isAnExistingDirectory(const std::string &path)
 //------------------------------------------------------------------------------
 // archiveToDirectory
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::archiveToDirectory(
+std::string cta::MockMiddleTierAdmin::archiveToDirectory(
   const SecurityIdentity &requester,
   const std::list<std::string> &srcUrls,
   const std::string &dstDir) {
@@ -689,7 +689,7 @@ std::string cta::MockClientAPI::archiveToDirectory(
 //------------------------------------------------------------------------------
 // archiveToFile
 //------------------------------------------------------------------------------
-std::string cta::MockClientAPI::archiveToFile(
+std::string cta::MockMiddleTierAdmin::archiveToFile(
   const SecurityIdentity &requester,
   const std::list<std::string> &srcUrls,
   const std::string &dstFile) {
@@ -706,7 +706,7 @@ std::string cta::MockClientAPI::archiveToFile(
 //------------------------------------------------------------------------------
 // checkUserIsAuthorisedToArchive
 //------------------------------------------------------------------------------
-void cta::MockClientAPI::checkUserIsAuthorisedToArchive(
+void cta::MockMiddleTierAdmin::checkUserIsAuthorisedToArchive(
   const SecurityIdentity &user,
   const FileSystemNode &dstDir) {
   // TO BE DONE
@@ -715,7 +715,7 @@ void cta::MockClientAPI::checkUserIsAuthorisedToArchive(
 //------------------------------------------------------------------------------
 // getArchiveJobs
 //------------------------------------------------------------------------------
-std::list<cta::ArchiveJob> cta::MockClientAPI::getArchiveJobs(
+std::list<cta::ArchiveJob> cta::MockMiddleTierAdmin::getArchiveJobs(
   const SecurityIdentity &requester,
   const std::string &tapePoolName) {
   std::list<cta::ArchiveJob> jobs;
diff --git a/libs/client/MockClientAPI.hpp b/libs/client/MockMiddleTierAdmin.hpp
similarity index 98%
rename from libs/client/MockClientAPI.hpp
rename to libs/client/MockMiddleTierAdmin.hpp
index b9040b2df4cd2234b0c0191d8909c8db149e66a6..35aba0713d9be743c832d234f271b124ced6cb1f 100644
--- a/libs/client/MockClientAPI.hpp
+++ b/libs/client/MockMiddleTierAdmin.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "ClientAPI.hpp"
 #include "FileSystemNode.hpp"
 #include "FileSystemStorageClasses.hpp"
+#include "MiddleTierAdmin.hpp"
 #include "MigrationRoutes.hpp"
 #include "StorageClass.hpp"
 
@@ -11,9 +11,9 @@
 namespace cta {
 
 /**
- * A mock entry point to the client ClientAPI of the CERN Tape Archive project.
+ * A mock administration API for the CERN Tape Archive project.
  */
-class MockClientAPI: public ClientAPI {
+class MockMiddleTierAdmin: public MiddleTierAdmin {
 public:
 
   /**
@@ -22,12 +22,12 @@ public:
    * Creates the root directory "/" owned by user root and with no file
    * attributes or permissions.
    */
-  MockClientAPI();
+  MockMiddleTierAdmin();
 
   /**
    * Destructor.
    */
-  ~MockClientAPI() throw();
+  ~MockMiddleTierAdmin() throw();
 
   /**
    * Creates the specified administrator.
@@ -577,6 +577,6 @@ protected:
     const SecurityIdentity &user,
     const FileSystemNode &dstDir);
 
-}; // class MockClientAPI
+}; // class MockMiddleTierAdmin
 
 } // namespace cta
diff --git a/libs/client/TestingMockClientAPI.hpp b/libs/client/TestingMockClientAPI.hpp
deleted file mode 100644
index 4f3e424ee0a914c0cf88868e246e5172d11f3259..0000000000000000000000000000000000000000
--- a/libs/client/TestingMockClientAPI.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "MockClientAPI.hpp"
-
-namespace cta {
-
-/**
- * Facilitates the unit testing of the MockClientAPI class.
- */
-class TestingMockClientAPI: public MockClientAPI {
-public:
-
-  using MockClientAPI::getEnclosingDirPath;
-  using MockClientAPI::splitString;
-  using MockClientAPI::trimSlashes;
-
-}; // class TestingMockClientAPI
-
-} // namespace cta
-
diff --git a/libs/client/TestingMockMiddleTierAdmin.hpp b/libs/client/TestingMockMiddleTierAdmin.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4271c83dd36b1a16cdf4fea1cf970bf44f50f2d6
--- /dev/null
+++ b/libs/client/TestingMockMiddleTierAdmin.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "MockMiddleTierAdmin.hpp"
+
+namespace cta {
+
+/**
+ * Facilitates the unit testing of the MockMiddleTierAdmin class.
+ */
+class TestingMockMiddleTierAdmin: public MockMiddleTierAdmin {
+public:
+
+  using MockMiddleTierAdmin::getEnclosingDirPath;
+  using MockMiddleTierAdmin::splitString;
+  using MockMiddleTierAdmin::trimSlashes;
+
+}; // class TestingMockMiddleTierAdmin
+
+} // namespace cta
+
diff --git a/xroot_plugins/XrdProFilesystem.cpp b/xroot_plugins/XrdProFilesystem.cpp
index 9ee4b34b24c154a1164b0ef89b5ddfcd9e9243be..e99e22b756cdb655ac6c6c3953ed148b71df5524 100644
--- a/xroot_plugins/XrdProFilesystem.cpp
+++ b/xroot_plugins/XrdProFilesystem.cpp
@@ -1176,7 +1176,7 @@ void XrdProFilesystem::EnvInfo(XrdOucEnv *envP)
 // constructor
 //------------------------------------------------------------------------------
 XrdProFilesystem::XrdProFilesystem() {
-  m_clientAPI = new cta::MockClientAPI();
+  m_clientAPI = new cta::MockMiddleTierAdmin();
 }
 
 //------------------------------------------------------------------------------
diff --git a/xroot_plugins/XrdProFilesystem.hpp b/xroot_plugins/XrdProFilesystem.hpp
index a8559faabc24d3e9e8c27c95cdd2ddf0e596d62e..5808a3c2eaf445c5c7cd266c0a3284e7575ecbfe 100644
--- a/xroot_plugins/XrdProFilesystem.hpp
+++ b/xroot_plugins/XrdProFilesystem.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "libs/client/MockClientAPI.hpp"
+#include "libs/client/MockMiddleTierAdmin.hpp"
 #include "XrdSfs/XrdSfsInterface.hh"
 
 #include "ParsedRequest.hpp"
@@ -34,7 +34,7 @@ protected:
   /**
    * Pointer to the client API object
    */
-  cta::ClientAPI *m_clientAPI;
+  cta::MiddleTierAdmin *m_clientAPI;
     
   /**
    * Parses the query into the request structure