diff --git a/libs/middletier/MockAdminHostTableTest.cpp b/libs/middletier/MockAdminHostTableTest.cpp
index 445aa7a4fc0e207873949a8e65151bd5481955b7..1482bdfe0fc5232e3770e9b7789a189af3f5a687 100644
--- a/libs/middletier/MockAdminHostTableTest.cpp
+++ b/libs/middletier/MockAdminHostTableTest.cpp
@@ -17,22 +17,22 @@ protected:
 TEST_F(cta_client_MockAdminHostTableTest, createAdminHost_new) {
   using namespace cta;
 
-  MockAdminHostTable db;
+  MockAdminHostTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_TRUE(adminHosts.empty());
   }
 
   const std::string adminHost1 = "adminHost1";
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createAdminHost(requester, adminHost1, comment));
+  ASSERT_NO_THROW(table.createAdminHost(requester, adminHost1, comment));
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_EQ(1, adminHosts.size());
 
     ASSERT_EQ(adminHost1, adminHosts.front().getName());
@@ -43,33 +43,33 @@ TEST_F(cta_client_MockAdminHostTableTest, createAdminHost_new) {
 TEST_F(cta_client_MockAdminHostTableTest, deleteAdminHost_existing) {
   using namespace cta;
 
-  MockAdminHostTable db;
+  MockAdminHostTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_TRUE(adminHosts.empty());
   }
 
   const std::string adminHost1 = "adminHost1";
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createAdminHost(requester, adminHost1, comment));
+  ASSERT_NO_THROW(table.createAdminHost(requester, adminHost1, comment));
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_EQ(1, adminHosts.size());
 
     ASSERT_EQ(adminHost1, adminHosts.front().getName());
     ASSERT_EQ(comment, adminHosts.front().getComment());
   }
 
-  ASSERT_NO_THROW(db.deleteAdminHost(requester, adminHost1));
+  ASSERT_NO_THROW(table.deleteAdminHost(requester, adminHost1));
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_TRUE(adminHosts.empty());
   }
 }
@@ -77,21 +77,21 @@ TEST_F(cta_client_MockAdminHostTableTest, deleteAdminHost_existing) {
 TEST_F(cta_client_MockAdminHostTableTest, deleteAdminHost_non_existing) {
   using namespace cta;
 
-  MockAdminHostTable db;
+  MockAdminHostTable table;
   const SecurityIdentity requester;
   
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_TRUE(adminHosts.empty());
   }
 
   const std::string adminHost1 = "adminHost1";
-  ASSERT_THROW(db.deleteAdminHost(requester, adminHost1), std::exception);
+  ASSERT_THROW(table.deleteAdminHost(requester, adminHost1), std::exception);
 
   {
     std::list<AdminHost> adminHosts;
-    ASSERT_NO_THROW(adminHosts = db.getAdminHosts(requester));
+    ASSERT_NO_THROW(adminHosts = table.getAdminHosts(requester));
     ASSERT_TRUE(adminHosts.empty());
   }
 }
diff --git a/libs/middletier/MockAdminUserTableTest.cpp b/libs/middletier/MockAdminUserTableTest.cpp
index 5ef34359ec95be3259c5eb1ec12c226195eb863f..0ece18d2996e98cb2a3dcf054a0a6249ce70cba7 100644
--- a/libs/middletier/MockAdminUserTableTest.cpp
+++ b/libs/middletier/MockAdminUserTableTest.cpp
@@ -18,12 +18,12 @@ protected:
 TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_new) {
   using namespace cta;
 
-  MockAdminUserTable db;
+  MockAdminUserTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   }
 
@@ -31,11 +31,11 @@ TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_new) {
   const uint16_t adminUser1Gid = 5678;
   const UserIdentity adminUser1(adminUser1Uid, adminUser1Gid);
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createAdminUser(requester, adminUser1, comment));
+  ASSERT_NO_THROW(table.createAdminUser(requester, adminUser1, comment));
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_EQ(1, adminUsers.size());
 
     ASSERT_EQ(adminUser1Uid, adminUsers.front().getUser().getUid());
@@ -47,12 +47,12 @@ TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_new) {
 TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_already_existing) {
   using namespace cta;
 
-  MockAdminUserTable db;
+  MockAdminUserTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   }
 
@@ -60,11 +60,11 @@ TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_already_existing) {
   const uint16_t adminUser1Gid = 5678;
   const UserIdentity adminUser1(adminUser1Uid, adminUser1Gid);
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createAdminUser(requester, adminUser1, comment));
+  ASSERT_NO_THROW(table.createAdminUser(requester, adminUser1, comment));
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_EQ(1, adminUsers.size());
 
     ASSERT_EQ(adminUser1Uid, adminUsers.front().getUser().getUid());
@@ -72,12 +72,12 @@ TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_already_existing) {
     ASSERT_EQ(comment, adminUsers.front().getComment());
   }
 
-  ASSERT_THROW(db.createAdminUser(requester, adminUser1, comment),
+  ASSERT_THROW(table.createAdminUser(requester, adminUser1, comment),
     std::exception);
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_EQ(1, adminUsers.size());
   }
 }
@@ -85,12 +85,12 @@ TEST_F(cta_client_MockAdminUserTableTest, createAdminUser_already_existing) {
 TEST_F(cta_client_MockAdminUserTableTest, deleteAdminUser_existing) {
   using namespace cta;
 
-  MockAdminUserTable db;
+  MockAdminUserTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   }
 
@@ -98,11 +98,11 @@ TEST_F(cta_client_MockAdminUserTableTest, deleteAdminUser_existing) {
   const uint16_t adminUser1Gid = 5678;
   const UserIdentity adminUser1(adminUser1Uid, adminUser1Gid);
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createAdminUser(requester, adminUser1, comment));
+  ASSERT_NO_THROW(table.createAdminUser(requester, adminUser1, comment));
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_EQ(1, adminUsers.size());
 
     ASSERT_EQ(adminUser1Uid, adminUsers.front().getUser().getUid());
@@ -110,10 +110,10 @@ TEST_F(cta_client_MockAdminUserTableTest, deleteAdminUser_existing) {
     ASSERT_EQ(comment, adminUsers.front().getComment());
   }
 
-  ASSERT_NO_THROW(db.deleteAdminUser(requester, adminUser1));
+  ASSERT_NO_THROW(table.deleteAdminUser(requester, adminUser1));
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   }
 }
@@ -121,23 +121,23 @@ TEST_F(cta_client_MockAdminUserTableTest, deleteAdminUser_existing) {
 TEST_F(cta_client_MockAdminUserTableTest, deleteAdminUser_non_existing) {
   using namespace cta;
 
-  MockAdminUserTable db;
+  MockAdminUserTable table;
   const SecurityIdentity requester;
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   } 
   
   const uint16_t adminUser1Uid = 1234;
   const uint16_t adminUser1Gid = 5678;
   const UserIdentity adminUser1(adminUser1Uid, adminUser1Gid);
-  ASSERT_THROW(db.deleteAdminUser(requester, adminUser1), std::exception);
+  ASSERT_THROW(table.deleteAdminUser(requester, adminUser1), std::exception);
 
   {
     std::list<AdminUser> adminUsers;
-    ASSERT_NO_THROW(adminUsers = db.getAdminUsers(requester));
+    ASSERT_NO_THROW(adminUsers = table.getAdminUsers(requester));
     ASSERT_TRUE(adminUsers.empty());
   }
 }
diff --git a/libs/middletier/MockLogicalLibraryTableTest.cpp b/libs/middletier/MockLogicalLibraryTableTest.cpp
index 10eb1bea3230fab85805a56f47bba1bc44bb8d3d..077724d584ba53ab7fe5a05708cae8eb31bedc75 100644
--- a/libs/middletier/MockLogicalLibraryTableTest.cpp
+++ b/libs/middletier/MockLogicalLibraryTableTest.cpp
@@ -17,26 +17,26 @@ protected:
 TEST_F(cta_client_MockLogicalLibraryTableTest, createLogicalLibrary_new) {
   using namespace cta;
 
-  MockLogicalLibraryTable db;
+  MockLogicalLibraryTable table;
   const SecurityIdentity requester;
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 
   const std::string libraryName = "TestLogicalLibrary";
 
-  ASSERT_THROW(db.checkLogicalLibraryExists(libraryName), std::exception);
+  ASSERT_THROW(table.checkLogicalLibraryExists(libraryName), std::exception);
 
   const std::string libraryComment = "Comment";
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, libraryName,
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, libraryName,
     libraryComment));
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_EQ(1, libraries.size());
 
     LogicalLibrary logicalLibrary;
@@ -45,30 +45,30 @@ TEST_F(cta_client_MockLogicalLibraryTableTest, createLogicalLibrary_new) {
     ASSERT_EQ(libraryComment, logicalLibrary.getComment());
   }
 
-  ASSERT_NO_THROW(db.checkLogicalLibraryExists(libraryName));
+  ASSERT_NO_THROW(table.checkLogicalLibraryExists(libraryName));
 }
 
 TEST_F(cta_client_MockLogicalLibraryTableTest,
   createLogicalLibrary_already_existing) {
   using namespace cta;
 
-  MockLogicalLibraryTable db;
+  MockLogicalLibraryTable table;
   const SecurityIdentity requester;
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 
   const std::string libraryName = "TestLogicalLibrary";
   const std::string libraryComment = "Comment";
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, libraryName,
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, libraryName,
     libraryComment));
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_EQ(1, libraries.size());
 
     LogicalLibrary logicalLibrary;
@@ -77,7 +77,7 @@ TEST_F(cta_client_MockLogicalLibraryTableTest,
     ASSERT_EQ(libraryComment, logicalLibrary.getComment());
   }
   
-  ASSERT_THROW(db.createLogicalLibrary(requester, libraryName,
+  ASSERT_THROW(table.createLogicalLibrary(requester, libraryName,
     libraryComment), std::exception);
 }
 
@@ -85,23 +85,23 @@ TEST_F(cta_client_MockLogicalLibraryTableTest,
   createLogicalLibrary_lexicographical_order) {
   using namespace cta;
 
-  MockLogicalLibraryTable db;
+  MockLogicalLibraryTable table;
   const SecurityIdentity requester;
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, "d", "Comment d"));
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, "b", "Comment b"));
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, "a", "Comment a"));
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, "c", "Comment c"));
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, "d", "Comment d"));
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, "b", "Comment b"));
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, "a", "Comment a"));
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, "c", "Comment c"));
   
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_EQ(4, libraries.size());
 
     ASSERT_EQ(std::string("a"), libraries.front().getName());
@@ -117,23 +117,23 @@ TEST_F(cta_client_MockLogicalLibraryTableTest,
 TEST_F(cta_client_MockLogicalLibraryTableTest, deleteLogicalLibrary_existing) {
   using namespace cta;
 
-  MockLogicalLibraryTable db;
+  MockLogicalLibraryTable table;
   const SecurityIdentity requester;
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 
   const std::string libraryName = "TestLogicalLibrary";
   const std::string libraryComment = "Comment";
-  ASSERT_NO_THROW(db.createLogicalLibrary(requester, libraryName,
+  ASSERT_NO_THROW(table.createLogicalLibrary(requester, libraryName,
     libraryComment));
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_EQ(1, libraries.size());
   
     LogicalLibrary logicalLibrary;
@@ -141,12 +141,12 @@ TEST_F(cta_client_MockLogicalLibraryTableTest, deleteLogicalLibrary_existing) {
     ASSERT_EQ(libraryName, logicalLibrary.getName());
     ASSERT_EQ(libraryComment, logicalLibrary.getComment());
 
-    ASSERT_NO_THROW(db.deleteLogicalLibrary(requester, libraryName));
+    ASSERT_NO_THROW(table.deleteLogicalLibrary(requester, libraryName));
   }
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 }
@@ -155,22 +155,22 @@ TEST_F(cta_client_MockLogicalLibraryTableTest,
   deleteLogicalLibrary_non_existing) {
   using namespace cta;
 
-  MockLogicalLibraryTable db;
+  MockLogicalLibraryTable table;
   const SecurityIdentity requester;
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 
   const std::string libraryName = "TestLogicalLibrary";
-  ASSERT_THROW(db.deleteLogicalLibrary(requester, libraryName),
+  ASSERT_THROW(table.deleteLogicalLibrary(requester, libraryName),
     std::exception);
 
   {
     std::list<LogicalLibrary> libraries;
-    ASSERT_NO_THROW(libraries = db.getLogicalLibraries(requester));
+    ASSERT_NO_THROW(libraries = table.getLogicalLibraries(requester));
     ASSERT_TRUE(libraries.empty());
   }
 }
diff --git a/libs/middletier/MockMiddleTierAdmin.cpp b/libs/middletier/MockMiddleTierAdmin.cpp
index 9b32e2f555037e8ab5456efc7009cb7e9192df07..cf5eee5cb10845dd8e4e6dc8ee0853088c124ff8 100644
--- a/libs/middletier/MockMiddleTierAdmin.cpp
+++ b/libs/middletier/MockMiddleTierAdmin.cpp
@@ -225,6 +225,8 @@ void cta::MockMiddleTierAdmin::createTape(
   const std::string &tapePoolName,
   const uint64_t capacityInBytes,
   const std::string &comment) {
+  m_db.libraries.checkLogicalLibraryExists(logicalLibraryName);
+  m_db.tapePools.checkTapePoolExists(tapePoolName);
   m_db.tapes.createTape(requester, vid, logicalLibraryName, tapePoolName,
     capacityInBytes, comment);
 }
diff --git a/libs/middletier/MockMiddleTierAdminTest.cpp b/libs/middletier/MockMiddleTierAdminTest.cpp
index e69d094e1ffe6756a25769ce9a39399e9b915a85..0e496e5380a6bf0f96762f47c379caedb2602cba 100644
--- a/libs/middletier/MockMiddleTierAdminTest.cpp
+++ b/libs/middletier/MockMiddleTierAdminTest.cpp
@@ -31,7 +31,8 @@ TEST_F(cta_client_MockMiddleTierAdminTest, createStorageClass_new) {
   const std::string name = "TestStorageClass";
   const uint8_t nbCopies = 2;
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(adminApi.createStorageClass(requester, name, nbCopies, comment));
+  ASSERT_NO_THROW(adminApi.createStorageClass(requester, name, nbCopies,
+    comment));
 
   {
     std::list<StorageClass> storageClasses;
@@ -563,4 +564,183 @@ TEST_F(cta_client_MockMiddleTierAdminTest, deleteMigrationRoute_non_existing) {
     std::exception);
 }
 
+TEST_F(cta_client_MockMiddleTierAdminTest, createTape_new) {
+  using namespace cta;
+
+  MockDatabase db;
+  MockMiddleTierAdmin adminApi(db);
+  const SecurityIdentity requester;
+
+  {
+    std::list<LogicalLibrary> libraries;
+    ASSERT_NO_THROW(libraries = adminApi.getLogicalLibraries(requester));
+    ASSERT_TRUE(libraries.empty());
+  }
+
+  {
+    std::list<TapePool> pools;
+    ASSERT_NO_THROW(pools = adminApi.getTapePools(requester));
+    ASSERT_TRUE(pools.empty());
+  }
+
+  {
+    std::list<Tape> tapes;
+    ASSERT_NO_THROW(tapes = adminApi.getTapes(requester));
+    ASSERT_TRUE(tapes.empty());
+  }
+
+  const std::string libraryName = "TestLogicalLibrary";
+  const std::string libraryComment = "Library comment";
+  ASSERT_NO_THROW(adminApi.createLogicalLibrary(requester, libraryName,
+    libraryComment));
+  {
+    std::list<LogicalLibrary> libraries;
+    ASSERT_NO_THROW(libraries = adminApi.getLogicalLibraries(requester));
+    ASSERT_EQ(1, libraries.size());
+  
+    LogicalLibrary logicalLibrary;
+    ASSERT_NO_THROW(logicalLibrary = libraries.front());
+    ASSERT_EQ(libraryName, logicalLibrary.getName());
+    ASSERT_EQ(libraryComment, logicalLibrary.getComment());
+  }
+
+  const std::string tapePoolName = "TestTapePool";
+  const uint16_t nbDrives = 1;
+  const uint16_t nbPartialTapes = 1;
+  const std::string comment = "Tape pool omment";
+  ASSERT_NO_THROW(adminApi.createTapePool(requester, tapePoolName, nbDrives,
+    nbPartialTapes, comment));
+  {
+    std::list<TapePool> tapePools;
+    ASSERT_NO_THROW(tapePools = adminApi.getTapePools(requester));
+    ASSERT_EQ(1, tapePools.size());
+    
+    TapePool tapePool;
+    ASSERT_NO_THROW(tapePool = tapePools.front());
+    ASSERT_EQ(tapePoolName, tapePool.getName());
+    ASSERT_EQ(comment, tapePool.getComment());
+  } 
+
+  const std::string vid = "TestVid";
+  const uint64_t capacityInBytes = 12345678;
+  const std::string tapeComment = "Tape comment";
+  ASSERT_NO_THROW(adminApi.createTape(requester, vid, libraryName, tapePoolName,
+    capacityInBytes, tapeComment));
+  {
+    std::list<Tape> tapes;
+    ASSERT_NO_THROW(tapes = adminApi.getTapes(requester));
+    ASSERT_EQ(1, tapes.size()); 
+  
+    Tape tape;
+    ASSERT_NO_THROW(tape = tapes.front());
+    ASSERT_EQ(vid, tape.getVid());
+    ASSERT_EQ(libraryName, tape.getLogicalLibraryName());
+    ASSERT_EQ(tapePoolName, tape.getTapePoolName());
+    ASSERT_EQ(capacityInBytes, tape.getCapacityInBytes());
+    ASSERT_EQ(0, tape.getDataOnTapeInBytes());
+    ASSERT_EQ(tapeComment, tape.getComment());
+  } 
+}
+
+TEST_F(cta_client_MockMiddleTierAdminTest,
+  createTape_new_non_existing_library) {
+  using namespace cta;
+
+  MockDatabase db;
+  MockMiddleTierAdmin adminApi(db);
+  const SecurityIdentity requester;
+
+  {
+    std::list<LogicalLibrary> libraries;
+    ASSERT_NO_THROW(libraries = adminApi.getLogicalLibraries(requester));
+    ASSERT_TRUE(libraries.empty());
+  }
+
+  {
+    std::list<TapePool> pools;
+    ASSERT_NO_THROW(pools = adminApi.getTapePools(requester));
+    ASSERT_TRUE(pools.empty());
+  }
+
+  {
+    std::list<Tape> tapes;
+    ASSERT_NO_THROW(tapes = adminApi.getTapes(requester));
+    ASSERT_TRUE(tapes.empty());
+  }
+
+  const std::string libraryName = "TestLogicalLibrary";
+
+  const std::string tapePoolName = "TestTapePool";
+  const uint16_t nbDrives = 1;
+  const uint16_t nbPartialTapes = 1;
+  const std::string comment = "Tape pool omment";
+  ASSERT_NO_THROW(adminApi.createTapePool(requester, tapePoolName, nbDrives,
+    nbPartialTapes, comment));
+  {
+    std::list<TapePool> tapePools;
+    ASSERT_NO_THROW(tapePools = adminApi.getTapePools(requester));
+    ASSERT_EQ(1, tapePools.size());
+    
+    TapePool tapePool;
+    ASSERT_NO_THROW(tapePool = tapePools.front());
+    ASSERT_EQ(tapePoolName, tapePool.getName());
+    ASSERT_EQ(comment, tapePool.getComment());
+  } 
+
+  const std::string vid = "TestVid";
+  const uint64_t capacityInBytes = 12345678;
+  const std::string tapeComment = "Tape comment";
+  ASSERT_THROW(adminApi.createTape(requester, vid, libraryName, tapePoolName,
+    capacityInBytes, tapeComment), std::exception);
+}
+
+TEST_F(cta_client_MockMiddleTierAdminTest, createTape_new_non_existing_pool) {
+  using namespace cta;
+
+  MockDatabase db;
+  MockMiddleTierAdmin adminApi(db);
+  const SecurityIdentity requester;
+
+  {
+    std::list<LogicalLibrary> libraries;
+    ASSERT_NO_THROW(libraries = adminApi.getLogicalLibraries(requester));
+    ASSERT_TRUE(libraries.empty());
+  }
+
+  {
+    std::list<TapePool> pools;
+    ASSERT_NO_THROW(pools = adminApi.getTapePools(requester));
+    ASSERT_TRUE(pools.empty());
+  }
+
+  {
+    std::list<Tape> tapes;
+    ASSERT_NO_THROW(tapes = adminApi.getTapes(requester));
+    ASSERT_TRUE(tapes.empty());
+  }
+
+  const std::string libraryName = "TestLogicalLibrary";
+  const std::string libraryComment = "Library comment";
+  ASSERT_NO_THROW(adminApi.createLogicalLibrary(requester, libraryName,
+    libraryComment));
+  {
+    std::list<LogicalLibrary> libraries;
+    ASSERT_NO_THROW(libraries = adminApi.getLogicalLibraries(requester));
+    ASSERT_EQ(1, libraries.size());
+  
+    LogicalLibrary logicalLibrary;
+    ASSERT_NO_THROW(logicalLibrary = libraries.front());
+    ASSERT_EQ(libraryName, logicalLibrary.getName());
+    ASSERT_EQ(libraryComment, logicalLibrary.getComment());
+  }
+
+  const std::string tapePoolName = "TestTapePool";
+
+  const std::string vid = "TestVid";
+  const uint64_t capacityInBytes = 12345678;
+  const std::string tapeComment = "Tape comment";
+  ASSERT_THROW(adminApi.createTape(requester, vid, libraryName, tapePoolName,
+    capacityInBytes, tapeComment), std::exception);
+}
+
 } // namespace unitTests
diff --git a/libs/middletier/MockTapePoolTableTest.cpp b/libs/middletier/MockTapePoolTableTest.cpp
index db4c00ad0643a7564b270eee61fb0c4f2512f487..786cf1b9a24284dd2e6ac159c38eafb5609c23dc 100644
--- a/libs/middletier/MockTapePoolTableTest.cpp
+++ b/libs/middletier/MockTapePoolTableTest.cpp
@@ -17,28 +17,28 @@ protected:
 TEST_F(cta_client_MockTapePoolTableTest, createTapePool_new) {
   using namespace cta;
 
-  MockTapePoolTable db;
+  MockTapePoolTable table;
   const SecurityIdentity requester;
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 
   const std::string tapePoolName = "TestTapePool";
 
-  ASSERT_THROW(db.checkTapePoolExists(tapePoolName), std::exception);
+  ASSERT_THROW(table.checkTapePoolExists(tapePoolName), std::exception);
 
   const uint16_t nbDrives = 1;
   const uint16_t nbPartialTapes = 1;
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createTapePool(requester, tapePoolName, nbDrives, 
+  ASSERT_NO_THROW(table.createTapePool(requester, tapePoolName, nbDrives, 
     nbPartialTapes, comment));
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_EQ(1, tapePools.size());
 
     TapePool tapePool;
@@ -47,18 +47,18 @@ TEST_F(cta_client_MockTapePoolTableTest, createTapePool_new) {
     ASSERT_EQ(comment, tapePool.getComment());
   }
 
-  ASSERT_NO_THROW(db.checkTapePoolExists(tapePoolName));
+  ASSERT_NO_THROW(table.checkTapePoolExists(tapePoolName));
 }
 
 TEST_F(cta_client_MockTapePoolTableTest, createTapePool_already_existing) {
   using namespace cta;
 
-  MockTapePoolTable db;
+  MockTapePoolTable table;
   const SecurityIdentity requester;
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 
@@ -66,12 +66,12 @@ TEST_F(cta_client_MockTapePoolTableTest, createTapePool_already_existing) {
   const uint16_t nbDrives = 1;
   const uint16_t nbPartialTapes = 1;
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createTapePool(requester, tapePoolName, nbDrives, 
+  ASSERT_NO_THROW(table.createTapePool(requester, tapePoolName, nbDrives, 
     nbPartialTapes, comment));
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_EQ(1, tapePools.size());
 
     TapePool tapePool;
@@ -80,37 +80,37 @@ TEST_F(cta_client_MockTapePoolTableTest, createTapePool_already_existing) {
     ASSERT_EQ(comment, tapePool.getComment());
   }
   
-  ASSERT_THROW(db.createTapePool(requester, tapePoolName, nbDrives,
+  ASSERT_THROW(table.createTapePool(requester, tapePoolName, nbDrives,
     nbPartialTapes, comment), std::exception);
 }
 
 TEST_F(cta_client_MockTapePoolTableTest, createTapePool_lexicographical_order) {
   using namespace cta;
 
-  MockTapePoolTable db;
+  MockTapePoolTable table;
   const SecurityIdentity requester;
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 
   const uint16_t nbDrives = 1;
   const uint16_t nbPartialTapes = 1;
 
-  ASSERT_NO_THROW(db.createTapePool(requester, "d", nbDrives, nbPartialTapes,
+  ASSERT_NO_THROW(table.createTapePool(requester, "d", nbDrives, nbPartialTapes,
     "Comment d"));
-  ASSERT_NO_THROW(db.createTapePool(requester, "b", nbDrives, nbPartialTapes,
+  ASSERT_NO_THROW(table.createTapePool(requester, "b", nbDrives, nbPartialTapes,
     "Comment b"));
-  ASSERT_NO_THROW(db.createTapePool(requester, "a", nbDrives, nbPartialTapes,
+  ASSERT_NO_THROW(table.createTapePool(requester, "a", nbDrives, nbPartialTapes,
     "Comment a"));
-  ASSERT_NO_THROW(db.createTapePool(requester, "c", nbDrives, nbPartialTapes,
+  ASSERT_NO_THROW(table.createTapePool(requester, "c", nbDrives, nbPartialTapes,
     "Comment c"));
   
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_EQ(4, tapePools.size());
 
     ASSERT_EQ(std::string("a"), tapePools.front().getName());
@@ -126,12 +126,12 @@ TEST_F(cta_client_MockTapePoolTableTest, createTapePool_lexicographical_order) {
 TEST_F(cta_client_MockTapePoolTableTest, deleteTapePool_existing) {
   using namespace cta;
 
-  MockTapePoolTable db;
+  MockTapePoolTable table;
   const SecurityIdentity requester;
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 
@@ -139,12 +139,12 @@ TEST_F(cta_client_MockTapePoolTableTest, deleteTapePool_existing) {
   const uint16_t nbDrives = 1;
   const uint16_t nbPartialTapes = 1;
   const std::string comment = "Comment";
-  ASSERT_NO_THROW(db.createTapePool(requester, tapePoolName, nbDrives,
+  ASSERT_NO_THROW(table.createTapePool(requester, tapePoolName, nbDrives,
     nbPartialTapes, comment));
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_EQ(1, tapePools.size());
   
     TapePool tapePool;
@@ -152,12 +152,12 @@ TEST_F(cta_client_MockTapePoolTableTest, deleteTapePool_existing) {
     ASSERT_EQ(tapePoolName, tapePool.getName());
     ASSERT_EQ(comment, tapePool.getComment());
 
-    ASSERT_NO_THROW(db.deleteTapePool(requester, tapePoolName));
+    ASSERT_NO_THROW(table.deleteTapePool(requester, tapePoolName));
   }
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 }
@@ -165,21 +165,21 @@ TEST_F(cta_client_MockTapePoolTableTest, deleteTapePool_existing) {
 TEST_F(cta_client_MockTapePoolTableTest, deleteTapePool_non_existing) {
   using namespace cta;
 
-  MockTapePoolTable db;
+  MockTapePoolTable table;
   const SecurityIdentity requester;
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 
   const std::string name = "TestTapePool";
-  ASSERT_THROW(db.deleteTapePool(requester, name), std::exception);
+  ASSERT_THROW(table.deleteTapePool(requester, name), std::exception);
 
   {
     std::list<TapePool> tapePools;
-    ASSERT_NO_THROW(tapePools = db.getTapePools(requester));
+    ASSERT_NO_THROW(tapePools = table.getTapePools(requester));
     ASSERT_TRUE(tapePools.empty());
   }
 }
diff --git a/libs/middletier/MockTapeTableTest.cpp b/libs/middletier/MockTapeTableTest.cpp
index f4aaf2c6a704a91cae7a7e0181538d80750f7806..ac9734a8770becc6a2c7761da746a27cb1966f0a 100644
--- a/libs/middletier/MockTapeTableTest.cpp
+++ b/libs/middletier/MockTapeTableTest.cpp
@@ -17,12 +17,12 @@ protected:
 TEST_F(cta_client_MockTapeTableTest, createTape_new) {
   using namespace cta;
 
-  MockTapeTable db;
+  MockTapeTable table;
   const SecurityIdentity requester;
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 
@@ -31,12 +31,12 @@ TEST_F(cta_client_MockTapeTableTest, createTape_new) {
   const std::string vid = "TestVid";
   const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
-  ASSERT_NO_THROW(db.createTape(requester, vid, libraryName, poolName,
+  ASSERT_NO_THROW(table.createTape(requester, vid, libraryName, poolName,
     capacityInBytes, tapeComment));
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_EQ(1, tapes.size());
 
     Tape tape;
@@ -53,12 +53,12 @@ TEST_F(cta_client_MockTapeTableTest, createTape_new) {
 TEST_F(cta_client_MockTapeTableTest, createTape_already_existing) {
   using namespace cta;
 
-  MockTapeTable db;
+  MockTapeTable table;
   const SecurityIdentity requester;
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 
@@ -67,12 +67,12 @@ TEST_F(cta_client_MockTapeTableTest, createTape_already_existing) {
   const std::string vid = "TestVid";
   const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
-  ASSERT_NO_THROW(db.createTape(requester, vid, libraryName, poolName,
+  ASSERT_NO_THROW(table.createTape(requester, vid, libraryName, poolName,
     capacityInBytes, tapeComment));
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_EQ(1, tapes.size());
 
     Tape tape;
@@ -85,12 +85,12 @@ TEST_F(cta_client_MockTapeTableTest, createTape_already_existing) {
     ASSERT_EQ(tapeComment, tape.getComment());
   }
   
-  ASSERT_THROW(db.createTape(requester, vid, libraryName, poolName,
+  ASSERT_THROW(table.createTape(requester, vid, libraryName, poolName,
     capacityInBytes, tapeComment), std::exception);
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_EQ(1, tapes.size());
 
     Tape tape;
@@ -107,30 +107,30 @@ TEST_F(cta_client_MockTapeTableTest, createTape_already_existing) {
 TEST_F(cta_client_MockTapeTableTest, createTape_lexicographical_order) {
   using namespace cta;
 
-  MockTapeTable db;
+  MockTapeTable table;
   const SecurityIdentity requester;
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 
   const std::string libraryName = "TestLogicalLibrary";
   const std::string poolName = "TestTapePool";
   const uint64_t capacityInBytes = 12345678;
-  ASSERT_NO_THROW(db.createTape(requester, "d", libraryName, poolName, capacityInBytes,
+  ASSERT_NO_THROW(table.createTape(requester, "d", libraryName, poolName, capacityInBytes,
     "Comment d"));
-  ASSERT_NO_THROW(db.createTape(requester, "b", libraryName, poolName, capacityInBytes,
+  ASSERT_NO_THROW(table.createTape(requester, "b", libraryName, poolName, capacityInBytes,
     "Comment b"));
-  ASSERT_NO_THROW(db.createTape(requester, "a", libraryName, poolName, capacityInBytes,
+  ASSERT_NO_THROW(table.createTape(requester, "a", libraryName, poolName, capacityInBytes,
     "Comment a"));
-  ASSERT_NO_THROW(db.createTape(requester, "c", libraryName, poolName, capacityInBytes,
+  ASSERT_NO_THROW(table.createTape(requester, "c", libraryName, poolName, capacityInBytes,
     "Comment c"));
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_EQ(4, tapes.size());
 
     ASSERT_EQ(std::string("a"), tapes.front().getVid());
@@ -146,12 +146,12 @@ TEST_F(cta_client_MockTapeTableTest, createTape_lexicographical_order) {
 TEST_F(cta_client_MockTapeTableTest, deleteTape_existing) {
   using namespace cta;
 
-  MockTapeTable db;
+  MockTapeTable table;
   const SecurityIdentity requester;
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 
@@ -160,12 +160,12 @@ TEST_F(cta_client_MockTapeTableTest, deleteTape_existing) {
   const std::string vid = "TestVid";
   const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
-  ASSERT_NO_THROW(db.createTape(requester, vid, libraryName, poolName,
+  ASSERT_NO_THROW(table.createTape(requester, vid, libraryName, poolName,
     capacityInBytes, tapeComment));
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_EQ(1, tapes.size());
 
     Tape tape;
@@ -178,14 +178,14 @@ TEST_F(cta_client_MockTapeTableTest, deleteTape_existing) {
     ASSERT_EQ(tapeComment, tape.getComment());
   }
   
-  ASSERT_THROW(db.createTape(requester, vid, libraryName, poolName,
+  ASSERT_THROW(table.createTape(requester, vid, libraryName, poolName,
     capacityInBytes, tapeComment), std::exception);
 
-  ASSERT_NO_THROW(db.deleteTape(requester, vid));
+  ASSERT_NO_THROW(table.deleteTape(requester, vid));
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 }
@@ -193,21 +193,21 @@ TEST_F(cta_client_MockTapeTableTest, deleteTape_existing) {
 TEST_F(cta_client_MockTapeTableTest, deleteTape_non_existing) {
   using namespace cta;
 
-  MockTapeTable db;
+  MockTapeTable table;
   const SecurityIdentity requester;
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 
   const std::string vid = "TestVid";
-  ASSERT_THROW(db.deleteTape(requester, vid), std::exception);
+  ASSERT_THROW(table.deleteTape(requester, vid), std::exception);
 
   {
     std::list<Tape> tapes;
-    ASSERT_NO_THROW(tapes = db.getTapes(requester));
+    ASSERT_NO_THROW(tapes = table.getTapes(requester));
     ASSERT_TRUE(tapes.empty());
   }
 }