diff --git a/catalogue/Catalogue.hpp b/catalogue/Catalogue.hpp
index 62ab397314dd90346548f49894bbe395d00fd80e..18fcda4079dd6fa2e0b8bcc98e276849c6ad06bd 100644
--- a/catalogue/Catalogue.hpp
+++ b/catalogue/Catalogue.hpp
@@ -19,6 +19,7 @@
 #pragma once
 
 #include "catalogue/ArchiveFileItor.hpp"
+#include "catalogue/CreateTapeAttributes.hpp"
 #include "catalogue/MediaType.hpp"
 #include "catalogue/MediaTypeWithLogs.hpp"
 #include "catalogue/TapeFileSearchCriteria.hpp"
@@ -500,12 +501,14 @@ public:
   virtual void setLogicalLibraryDisabled(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const bool disabledValue) = 0;
 
   /**
-   * Creates a tape which is assumed to have logical block protection (LBP)
-   * enabled and isFromCastor disabled.
+   * Creates a tape which is assumed to have isFromCastor disabled.
+   *
+   * @param admin The administrator.
+   * @param tape The attributes of the tape to be created.
    */
   virtual void createTape(
     const common::dataStructures::SecurityIdentity &admin,
-    const common::dataStructures::Tape & tape) = 0;
+    const CreateTapeAttributes &tape) = 0;
 
   virtual void deleteTape(const std::string &vid) = 0;
 
diff --git a/catalogue/CatalogueRetryWrapper.hpp b/catalogue/CatalogueRetryWrapper.hpp
index ddc166f987657d9dfc3dc9b58f0a1ad42a0f2104..3ae01d1ba503e0d64b4b652b3e9a4bdec368186c 100644
--- a/catalogue/CatalogueRetryWrapper.hpp
+++ b/catalogue/CatalogueRetryWrapper.hpp
@@ -296,7 +296,7 @@ public:
     return retryOnLostConnection(m_log, [&]{return m_catalogue->setLogicalLibraryDisabled(admin, name, disabledValue);}, m_maxTriesToConnect);
   }
 
-  void createTape(const common::dataStructures::SecurityIdentity &admin, const common::dataStructures::Tape & tape) override {
+  void createTape( const common::dataStructures::SecurityIdentity &admin, const CreateTapeAttributes & tape) override {
     return retryOnLostConnection(m_log, [&]{return m_catalogue->createTape(admin, tape);}, m_maxTriesToConnect);
   }
 
diff --git a/catalogue/CatalogueTest.cpp b/catalogue/CatalogueTest.cpp
index 91540b1d5e4c41054b5461f27957883e38c99e71..fb01b1a7dd1f09bfd4543e03a262d0c4d75e2160 100644
--- a/catalogue/CatalogueTest.cpp
+++ b/catalogue/CatalogueTest.cpp
@@ -48,14 +48,30 @@ const uint32_t NON_EXISTENT_DISK_FILE_OWNER_UID = 9755;
 const uint32_t NON_EXISTENT_DISK_FILE_GID = 9756;
 
 namespace {
-  cta::common::dataStructures::Tape getTape1() {
-    cta::common::dataStructures::Tape tape;
+  cta::catalogue::MediaType getMediaType() {
+    cta::catalogue::MediaType mediaType;
+    mediaType.name = "media_type";
+    mediaType.capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
+    mediaType.cartridge = "cartridge";
+    mediaType.comment = "comment";
+    mediaType.maxLPos = 100;
+    mediaType.minLPos = 1;
+    mediaType.nbWraps = 500;
+    mediaType.primaryDensityCode = 50;
+    mediaType.secondaryDensityCode = 50;
+
+    return mediaType;
+  }
+
+  cta::catalogue::CreateTapeAttributes getTape1() {
+    const auto mediaType = getMediaType();
+
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = "VIDONE";
-    tape.mediaType = "media_type";
+    tape.mediaType = mediaType.name;
     tape.vendor = "vendor";
     tape.logicalLibraryName = "logical_library";
     tape.tapePoolName = "tape_pool";
-    tape.capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
     tape.full = false;
     tape.disabled = false;
     tape.readOnly = false;
@@ -64,9 +80,9 @@ namespace {
     return tape;
   }
 
-  cta::common::dataStructures::Tape getTape2() {
+  cta::catalogue::CreateTapeAttributes getTape2() {
     // Tape 2 is an exact copy of tape 1 except for its VID and comment
-    cta::common::dataStructures::Tape tape = getTape1();
+    auto tape = getTape1();
     tape.vid = "VIDTWO";
     tape.comment = "Creation of tape two";
 
@@ -79,6 +95,7 @@ namespace {
 //------------------------------------------------------------------------------
 cta_catalogue_CatalogueTest::cta_catalogue_CatalogueTest():
   m_dummyLog("dummy", "dummy"),
+  m_mediaType(getMediaType()),
   m_tape1(getTape1()),
   m_tape2(getTape2()) {
   m_localAdmin.username = "local_admin_user";
@@ -373,22 +390,6 @@ void cta_catalogue_CatalogueTest::createVo(const std::string &voName){
   m_catalogue->createVirtualOrganization(m_admin,vo);
 }
 
-void cta_catalogue_CatalogueTest::createMediaType(const std::string& mediaTypeName, const uint64_t capacityInBytes) {
-  using namespace cta;
-  catalogue::MediaType mt;
-  mt.name = mediaTypeName;
-  mt.capacityInBytes = capacityInBytes;
-  mt.cartridge = "cartridge";
-  mt.comment = "comment";
-  mt.maxLPos = 100;
-  mt.minLPos = 1;
-  mt.nbWraps = 500;
-  mt.primaryDensityCode = 50;
-  mt.secondaryDensityCode = 50;
-  m_catalogue->createMediaType(m_admin,mt);
-}
-
-
 TEST_P(cta_catalogue_CatalogueTest, createAdminUser) {
   using namespace cta;
 
@@ -1226,7 +1227,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteMediaType_usedByTapes) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -2171,7 +2172,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteTapePool_notEmpty) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
 
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
@@ -2205,7 +2206,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteTapePool_notEmpty) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -2231,7 +2232,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteTapePool_notEmpty) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -3875,7 +3876,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteLogicalLibrary_non_empty) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
 
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
@@ -3894,7 +3895,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteLogicalLibrary_non_empty) {
   ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
   ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
   ASSERT_EQ(vo, tape.vo);
-  ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+  ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
   ASSERT_EQ(m_tape1.disabled, tape.disabled);
   ASSERT_EQ(m_tape1.full, tape.full);
   ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4090,7 +4091,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
@@ -4124,7 +4125,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4150,7 +4151,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -4169,7 +4170,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringVid) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -4187,7 +4188,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringVid) {
   }
 
   {
-    common::dataStructures::Tape tape = m_tape1;
+    auto tape = m_tape1;
     tape.vid = "";
     ASSERT_THROW(m_catalogue->createTape(m_admin, tape), catalogue::UserSpecifiedAnEmptyStringVid);
   }
@@ -4220,7 +4221,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringMediaType) {
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
 
-  common::dataStructures::Tape tape = m_tape1;
+  auto tape = m_tape1;
   tape.mediaType = "";
   ASSERT_THROW(m_catalogue->createTape(m_admin, tape), catalogue::UserSpecifiedAnEmptyStringMediaType);
 }
@@ -4237,7 +4238,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringVendor) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
 
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -4271,7 +4272,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringLogicalLibraryName) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -4303,7 +4304,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_emptyStringTapePoolName) {
   const bool logicalLibraryIsDisabled= false;
   const std::string vo = "vo";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
@@ -4322,7 +4323,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_non_existent_logical_library) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
   ASSERT_THROW(m_catalogue->createTape(m_admin, m_tape1), exception::UserError);
@@ -4335,7 +4336,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_non_existent_tape_pool) {
 
   const bool logicalLibraryIsDisabled= false;
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   ASSERT_THROW(m_catalogue->createTape(m_admin, m_tape1), exception::UserError);
 }
@@ -4351,7 +4352,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_9_exabytes_capacity) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType, m_tape1.capacityInBytes);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -4384,7 +4385,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_9_exabytes_capacity) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4410,7 +4411,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_9_exabytes_capacity) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -4425,7 +4426,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_same_twice) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -4453,7 +4454,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_same_twice) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -4468,7 +4469,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_same_twice) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -4483,7 +4484,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   ASSERT_TRUE(m_catalogue->getLogicalLibraries().empty());
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
@@ -4523,7 +4524,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
       ASSERT_EQ(m_tape1.tapePoolName, pool.name);
       ASSERT_EQ(vo, pool.vo.name);
       ASSERT_EQ(i, pool.nbTapes);
-      ASSERT_EQ(i * m_tape1.capacityInBytes, pool.capacityBytes);
+      ASSERT_EQ(i * m_mediaType.capacityInBytes, pool.capacityBytes);
       ASSERT_EQ(0, pool.dataBytes);
       ASSERT_EQ(0, pool.nbPhysicalFiles);
     }
@@ -4549,7 +4550,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4673,12 +4674,12 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
 
   {
     catalogue::TapeSearchCriteria searchCriteria;
-    searchCriteria.capacityInBytes = m_tape1.capacityInBytes;
+    searchCriteria.capacityInBytes = m_mediaType.capacityInBytes;
     const std::list<common::dataStructures::Tape> tapes = m_catalogue->getTapes(searchCriteria);
     ASSERT_EQ(nbTapes, tapes.size());
     const std::map<std::string, common::dataStructures::Tape> vidToTape = tapeListToMap(tapes);
     ASSERT_EQ(nbTapes, vidToTape.size());
-    ASSERT_EQ(m_tape1.capacityInBytes, vidToTape.begin()->second.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, vidToTape.begin()->second.capacityInBytes);
   }
 
   {
@@ -4722,7 +4723,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
     searchCriteria.vid = "vid1";
     searchCriteria.logicalLibrary = m_tape1.logicalLibraryName;
     searchCriteria.tapePool = m_tape1.tapePoolName;
-    searchCriteria.capacityInBytes = m_tape1.capacityInBytes;
+    searchCriteria.capacityInBytes = m_mediaType.capacityInBytes;
     searchCriteria.disabled = m_tape1.disabled;
     searchCriteria.full = m_tape1.full;
     const std::list<common::dataStructures::Tape> tapes = m_catalogue->getTapes(searchCriteria);
@@ -4732,7 +4733,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
     ASSERT_EQ("vid1", vidToTape.begin()->second.vid);
     ASSERT_EQ(m_tape1.logicalLibraryName, vidToTape.begin()->second.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, vidToTape.begin()->second.tapePoolName);
-    ASSERT_EQ(m_tape1.capacityInBytes, vidToTape.begin()->second.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, vidToTape.begin()->second.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, vidToTape.begin()->second.disabled);
     ASSERT_EQ(m_tape1.full, vidToTape.begin()->second.full);
   }
@@ -4762,7 +4763,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_many_tapes) {
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4805,7 +4806,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
 
@@ -4838,7 +4839,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -4864,7 +4865,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -4913,7 +4914,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(fileSize, pool.dataBytes);
     ASSERT_EQ(1, pool.nbPhysicalFiles);
   }
@@ -4934,7 +4935,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
     ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_TRUE(m_tape2.disabled == tape.disabled);
     ASSERT_TRUE(m_tape2.full == tape.full);
     ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -4960,7 +4961,7 @@ TEST_P(cta_catalogue_CatalogueTest, createTape_1_tape_with_write_log_1_tape_with
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(vo, pool.vo.name);
     ASSERT_EQ(2, pool.nbTapes);
-    ASSERT_EQ(2*m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(2*m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(fileSize, pool.dataBytes);
     ASSERT_EQ(1, pool.nbPhysicalFiles);
   }
@@ -4977,7 +4978,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteTape) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -4995,7 +4996,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteTape) {
   ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
   ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
   ASSERT_EQ(vo, tape.vo);
-  ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+  ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
   ASSERT_EQ(m_tape1.disabled, tape.disabled);
   ASSERT_EQ(m_tape1.full, tape.full);
   ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5038,7 +5039,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteNonEmptyTape) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
 
@@ -5056,7 +5057,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteNonEmptyTape) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(0, tape.dataOnTapeInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
@@ -5110,7 +5111,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteNonEmptyTape) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(fileSize, tape.dataOnTapeInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
@@ -5145,15 +5146,19 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeMediaType) {
 
   ASSERT_TRUE(m_catalogue->getTapes().empty());
 
-  const std::string anotherMediaType = "another_media_type";
   const bool logicalLibraryIsDisabled= false;
   const std::string vo = "vo";
   const uint64_t nbPartialTapes = 2;
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
-  createMediaType(anotherMediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
+
+  auto anotherMediaType = m_mediaType;
+  anotherMediaType.name = "another_media_type";
+
+  m_catalogue->createMediaType(m_admin, anotherMediaType);
+
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -5172,7 +5177,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeMediaType) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5190,7 +5195,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeMediaType) {
     ASSERT_EQ(creationLog, lastModificationLog);
   }
 
-  m_catalogue->modifyTapeMediaType(m_admin, m_tape1.vid, anotherMediaType);
+  m_catalogue->modifyTapeMediaType(m_admin, m_tape1.vid, anotherMediaType.name);
 
   {
     const std::list<common::dataStructures::Tape> tapes = m_catalogue->getTapes();
@@ -5199,11 +5204,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeMediaType) {
 
     const common::dataStructures::Tape tape = tapes.front();
     ASSERT_EQ(m_tape1.vid, tape.vid);
-    ASSERT_EQ(anotherMediaType, tape.mediaType);
+    ASSERT_EQ(anotherMediaType.name, tape.mediaType);
     ASSERT_EQ(m_tape1.vendor, tape.vendor);
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5233,7 +5238,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeVendor) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5253,7 +5258,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeVendor) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5285,7 +5290,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeVendor) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5313,7 +5318,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeLogicalLibraryName) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   m_catalogue->createLogicalLibrary(m_admin, anotherLogicalLibraryName, logicalLibraryIsDisabled,
     "Create another logical library");
@@ -5335,7 +5340,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeLogicalLibraryName) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5367,7 +5372,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeLogicalLibraryName) {
     ASSERT_EQ(anotherLogicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5407,7 +5412,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeTapePoolName) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string anotherTapePoolName = "another_tape_pool_name";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5428,7 +5433,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeTapePoolName) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5460,7 +5465,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeTapePoolName) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(anotherTapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5505,7 +5510,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5525,7 +5530,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5559,7 +5564,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName) {
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
     ASSERT_EQ(modifiedEncryptionKeyName, tape.encryptionKeyName);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5586,7 +5591,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName_emptyStringEncry
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5606,7 +5611,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName_emptyStringEncry
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5640,7 +5645,7 @@ TEST_P(cta_catalogue_CatalogueTest, modifyTapeEncryptionKeyName_emptyStringEncry
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
     ASSERT_FALSE((bool)tape.encryptionKeyName);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5677,7 +5682,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeLabelled) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5697,7 +5702,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeLabelled) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5730,7 +5735,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeLabelled) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5768,7 +5773,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForArchive) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5788,7 +5793,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForArchive) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5823,7 +5828,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForArchive) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5857,7 +5862,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForArchive) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5897,7 +5902,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForRetrieve) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -5917,7 +5922,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForRetrieve) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5952,7 +5957,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForRetrieve) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -5986,7 +5991,7 @@ TEST_P(cta_catalogue_CatalogueTest, tapeMountedForRetrieve) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6026,7 +6031,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeFull) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6046,7 +6051,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeFull) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6078,7 +6083,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeFull) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_TRUE(tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6114,7 +6119,7 @@ TEST_P(cta_catalogue_CatalogueTest, noSpaceLeftOnTape) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6134,7 +6139,7 @@ TEST_P(cta_catalogue_CatalogueTest, noSpaceLeftOnTape) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6166,7 +6171,7 @@ TEST_P(cta_catalogue_CatalogueTest, noSpaceLeftOnTape) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_TRUE(tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6202,7 +6207,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnly) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6222,7 +6227,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnly) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6254,7 +6259,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnly) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_TRUE(tape.readOnly);
@@ -6283,7 +6288,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnly) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_FALSE(tape.readOnly);
@@ -6319,7 +6324,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnlyOnError) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6339,7 +6344,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnlyOnError) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6371,7 +6376,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeReadOnlyOnError) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_TRUE(tape.readOnly);
@@ -6407,7 +6412,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeDisabled) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6427,7 +6432,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeDisabled) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6459,7 +6464,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeDisabled) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_TRUE(tape.disabled);
     ASSERT_FALSE(tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6486,7 +6491,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeIsFromCastorInUnitTests) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -6506,7 +6511,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeIsFromCastorInUnitTests) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6538,7 +6543,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeIsFromCastorInUnitTests) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6568,7 +6573,7 @@ TEST_P(cta_catalogue_CatalogueTest, setTapeIsFromCastorInUnitTests) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -6613,7 +6618,7 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -6633,7 +6638,7 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting) {
   ASSERT_EQ(m_tape1.tapePoolName, tape.tapePool);
   ASSERT_EQ(vo, tape.vo);
   ASSERT_EQ(0, tape.lastFSeq);
-  ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+  ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
   ASSERT_EQ(0, tape.dataOnTapeInBytes);
 }
 
@@ -6648,7 +6653,7 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting_disabled_tape) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -6679,7 +6684,7 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting_full_tape) {
   auto tape1 = m_tape1;
   tape1.full = true;
 
-  createMediaType(tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
 
   m_catalogue->createLogicalLibrary(m_admin, tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
@@ -6708,7 +6713,7 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting_read_only_tape) {
   auto tape1 = m_tape1;
   tape1.readOnly = true;
 
-  createMediaType(tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -6722,39 +6727,6 @@ TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting_read_only_tape) {
   ASSERT_EQ(0, tapes.size());
 }
 
-TEST_P(cta_catalogue_CatalogueTest, getTapesForWriting_is_from_castor_tape) {
-  using namespace cta;
-
-  ASSERT_TRUE(m_catalogue->getTapes().empty());
-
-  const bool logicalLibraryIsDisabled= false;
-  const std::string vo = "vo";
-  const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
-  const cta::optional<std::string> supply("value for the supply pool mechanism");
-
-  createMediaType(m_tape1.mediaType);
-  m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
-  createVo(vo);
-  m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-
-  auto tape1 = m_tape1;
-  tape1.isFromCastor = true;
-
-  m_catalogue->createTape(m_admin, tape1);
-
-  m_catalogue->tapeLabelled(tape1.vid, "tape_drive");
-  {
-    const std::list<catalogue::TapeForWriting> tapes = m_catalogue->getTapesForWriting(tape1.logicalLibraryName);
-    ASSERT_EQ(1, tapes.size());
-  }
-  {
-    m_catalogue->setTapeIsFromCastorInUnitTests(tape1.vid);
-    const std::list<catalogue::TapeForWriting> tapes = m_catalogue->getTapesForWriting(tape1.logicalLibraryName);
-    ASSERT_EQ(0, tapes.size());
-  }
-}
-
 TEST_P(cta_catalogue_CatalogueTest, DISABLED_getTapesForWriting_no_labelled_tapes) {
   using namespace cta;
 
@@ -6766,7 +6738,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_getTapesForWriting_no_labelled_tape
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -8826,7 +8798,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -8846,7 +8818,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -8874,7 +8846,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId) {
     ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape2.disabled, tape.disabled);
     ASSERT_EQ(m_tape2.full, tape.full);
     ASSERT_EQ(m_tape2.readOnly, tape.readOnly);
@@ -9067,7 +9039,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId_disa
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -9087,7 +9059,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId_disa
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -9115,7 +9087,7 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId_disa
     ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape2.disabled, tape.disabled);
     ASSERT_EQ(m_tape2.full, tape.full);
     ASSERT_EQ(m_tape2.readOnly, tape.readOnly);
@@ -9507,7 +9479,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -9560,7 +9532,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
 
     ASSERT_EQ(tapePoolName1, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(m_tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -9580,7 +9552,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
 
     ASSERT_EQ(tapePoolName2, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -9601,7 +9573,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
       ASSERT_EQ(tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(tapePoolName1, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(tape1.disabled == tape.disabled);
       ASSERT_TRUE(tape1.full == tape.full);
       ASSERT_TRUE(tape1.readOnly == tape.readOnly);
@@ -9630,7 +9602,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
       ASSERT_EQ(tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(tape2.disabled == tape.disabled);
       ASSERT_TRUE(tape2.full == tape.full);
       ASSERT_TRUE(tape2.readOnly == tape.readOnly);
@@ -9699,7 +9671,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
 
     ASSERT_EQ(tapePoolName1, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(nbArchiveFiles * archiveFileSize, pool.dataBytes);
     ASSERT_EQ(nbArchiveFiles, pool.nbPhysicalFiles);
   }
@@ -9758,7 +9730,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_many_archive_files) {
 
     ASSERT_EQ(tapePoolName2, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(nbArchiveFiles * archiveFileSize, pool.dataBytes);
     ASSERT_EQ(nbArchiveFiles, pool.nbPhysicalFiles);
   }
@@ -10429,7 +10401,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -10482,7 +10454,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
 
     ASSERT_EQ(tapePoolName1, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -10502,7 +10474,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
 
     ASSERT_EQ(tapePoolName2, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape2.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
@@ -10523,7 +10495,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
       ASSERT_EQ(tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(tapePoolName1, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(tape1.disabled == tape.disabled);
       ASSERT_TRUE(tape1.full == tape.full);
       ASSERT_TRUE(tape1.readOnly == tape.readOnly);
@@ -10537,8 +10509,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
       ASSERT_EQ(m_admin.username, creationLog.username);
       ASSERT_EQ(m_admin.host, creationLog.host);
 
-      const common::dataStructures::EntryLog lastModificationLog =
-        tape.lastModificationLog;
+      const common::dataStructures::EntryLog lastModificationLog = tape.lastModificationLog;
       ASSERT_EQ(creationLog, lastModificationLog);
     }
     {
@@ -10551,7 +10522,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
       ASSERT_EQ(tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(tapePoolName2, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(tape2.disabled == tape.disabled);
       ASSERT_TRUE(tape2.full == tape.full);
       ASSERT_TRUE(tape2.readOnly == tape.readOnly);
@@ -10612,7 +10583,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
 
     ASSERT_EQ(tapePoolName1, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape1.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(nbArchiveFiles * archiveFileSize, pool.dataBytes);
     ASSERT_EQ(nbArchiveFiles, pool.nbPhysicalFiles);
   }
@@ -10646,7 +10617,7 @@ TEST_P(cta_catalogue_CatalogueTest, DISABLED_concurrent_filesWrittenToTape_many_
 
     ASSERT_EQ(tapePoolName2, pool.name);
     ASSERT_EQ(1, pool.nbTapes);
-    ASSERT_EQ(tape2.capacityInBytes, pool.capacityBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, pool.capacityBytes);
     ASSERT_EQ(nbArchiveFiles * archiveFileSize, pool.dataBytes);
     ASSERT_EQ(nbArchiveFiles, pool.nbPhysicalFiles);
   }
@@ -11210,7 +11181,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_1_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -11232,7 +11203,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_1_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -11335,7 +11306,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_1_tape_cop
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -11357,7 +11328,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_1_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -11465,7 +11436,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -11488,7 +11459,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -11517,7 +11488,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(m_tape2.disabled == tape.disabled);
       ASSERT_TRUE(m_tape2.full == tape.full);
       ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -11685,7 +11656,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_sintance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -11708,7 +11679,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -11735,7 +11706,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(m_tape2.disabled == tape.disabled);
       ASSERT_TRUE(m_tape2.full == tape.full);
       ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -11900,7 +11871,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -11922,7 +11893,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12089,7 +12060,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -12111,7 +12082,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12234,7 +12205,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -12257,7 +12228,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12285,7 +12256,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(m_tape2.disabled == tape.disabled);
       ASSERT_TRUE(m_tape2.full == tape.full);
       ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -12408,7 +12379,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -12431,7 +12402,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12459,7 +12430,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(m_tape2.disabled == tape.disabled);
       ASSERT_TRUE(m_tape2.full == tape.full);
       ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -12581,7 +12552,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -12604,7 +12575,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12631,7 +12602,7 @@ TEST_P(cta_catalogue_CatalogueTest, filesWrittenToTape_1_archive_file_2_tape_cop
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_TRUE(m_tape2.disabled == tape.disabled);
       ASSERT_TRUE(m_tape2.full == tape.full);
       ASSERT_TRUE(m_tape2.readOnly == tape.readOnly);
@@ -12753,7 +12724,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -12776,7 +12747,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile) {
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -12805,7 +12776,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile) {
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape2.disabled, tape.disabled);
       ASSERT_EQ(m_tape2.full, tape.full);
       ASSERT_EQ(m_tape2.readOnly, tape.readOnly);
@@ -13050,7 +13021,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile_by_archive_file_id_of_anot
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -13073,7 +13044,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile_by_archive_file_id_of_anot
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -13099,7 +13070,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteArchiveFile_by_archive_file_id_of_anot
       ASSERT_EQ(m_tape2.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape2.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape2.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape2.disabled, tape.disabled);
       ASSERT_EQ(m_tape2.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -13373,7 +13344,7 @@ TEST_P(cta_catalogue_CatalogueTest, getAllTapes_many_tapes) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -13407,7 +13378,7 @@ TEST_P(cta_catalogue_CatalogueTest, getAllTapes_many_tapes) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tapeItor->second.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tapeItor->second.tapePoolName);
     ASSERT_EQ(vo, tapeItor->second.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tapeItor->second.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tapeItor->second.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tapeItor->second.disabled);
     ASSERT_EQ(m_tape1.full, tapeItor->second.full);
     ASSERT_EQ(m_tape1.readOnly, tapeItor->second.readOnly);
@@ -14347,7 +14318,7 @@ TEST_P(cta_catalogue_CatalogueTest, getNbFilesOnTape_no_tape_files) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14367,7 +14338,7 @@ TEST_P(cta_catalogue_CatalogueTest, getNbFilesOnTape_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14401,7 +14372,7 @@ TEST_P(cta_catalogue_CatalogueTest, getNbFilesOnTape_one_tape_file) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14421,7 +14392,7 @@ TEST_P(cta_catalogue_CatalogueTest, getNbFilesOnTape_one_tape_file) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14513,7 +14484,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_no_tape_files) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14533,7 +14504,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14567,7 +14538,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14587,7 +14558,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14681,7 +14652,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file_reclaimed_ta
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14701,7 +14672,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file_reclaimed_ta
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14803,7 +14774,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file_superseded)
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -14826,7 +14797,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file_superseded)
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -14923,7 +14894,7 @@ TEST_P(cta_catalogue_CatalogueTest, checkTapeForLabel_one_tape_file_superseded)
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15010,7 +14981,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_0_no_tape_files) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -15030,7 +15001,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_0_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15065,7 +15036,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_0_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_FALSE(tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15093,7 +15064,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_not_full_lastFSeq_0_no_tape_file
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -15114,7 +15085,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_not_full_lastFSeq_0_no_tape_file
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15148,7 +15119,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -15170,7 +15141,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15262,7 +15233,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15299,7 +15270,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15335,7 +15306,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15366,7 +15337,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file) {
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -15388,7 +15359,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15481,7 +15452,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file) {
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15519,7 +15490,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file_su
   const bool isEncrypted = true;
   const cta::optional<std::string> supply("value for the supply pool mechanism");
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -15543,7 +15514,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file_su
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15640,7 +15611,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file_su
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_EQ(m_tape1.full, tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -15705,7 +15676,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTape_full_lastFSeq_1_one_tape_file_su
     ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
     ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
     ASSERT_EQ(vo, tape.vo);
-    ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+    ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
     ASSERT_EQ(m_tape1.disabled, tape.disabled);
     ASSERT_FALSE(tape.full);
     ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -16008,7 +15979,7 @@ TEST_P(cta_catalogue_CatalogueTest, updateDiskFileId) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
   createVo(vo);
   m_catalogue->createTapePool(m_admin, m_tape1.tapePoolName, vo, nbPartialTapes, isEncrypted, supply, "Create tape pool");
@@ -16030,7 +16001,7 @@ TEST_P(cta_catalogue_CatalogueTest, updateDiskFileId) {
       ASSERT_EQ(m_tape1.logicalLibraryName, tape.logicalLibraryName);
       ASSERT_EQ(m_tape1.tapePoolName, tape.tapePoolName);
       ASSERT_EQ(vo, tape.vo);
-      ASSERT_EQ(m_tape1.capacityInBytes, tape.capacityInBytes);
+      ASSERT_EQ(m_mediaType.capacityInBytes, tape.capacityInBytes);
       ASSERT_EQ(m_tape1.disabled, tape.disabled);
       ASSERT_EQ(m_tape1.full, tape.full);
       ASSERT_EQ(m_tape1.readOnly, tape.readOnly);
@@ -16163,7 +16134,7 @@ TEST_P(cta_catalogue_CatalogueTest, moveFilesToRecycleBin) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
@@ -16304,7 +16275,7 @@ TEST_P(cta_catalogue_CatalogueTest, reclaimTapeRemovesFilesFromRecycleBin) {
   const cta::optional<std::string> supply("value for the supply pool mechanism");
   const std::string diskInstance = "disk_instance";
 
-  createMediaType(m_tape1.mediaType);
+  m_catalogue->createMediaType(m_admin, m_mediaType);
   m_catalogue->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, "Create logical library");
 
   createVo(vo);
diff --git a/catalogue/CatalogueTest.hpp b/catalogue/CatalogueTest.hpp
index bbfcd101ad6a55265e192bc6f36553c81fd413b8..ce03c8da2b1d39642dd328f052a99b0751ecd557 100644
--- a/catalogue/CatalogueTest.hpp
+++ b/catalogue/CatalogueTest.hpp
@@ -20,6 +20,7 @@
 
 #include "catalogue/ArchiveFileRow.hpp"
 #include "catalogue/CatalogueFactory.hpp"
+#include "catalogue/CreateTapeAttributes.hpp"
 #include "common/exception/Exception.hpp"
 #include "common/log/DummyLogger.hpp"
 
@@ -41,9 +42,9 @@ protected:
   std::unique_ptr<cta::catalogue::Catalogue> m_catalogue;
   cta::common::dataStructures::SecurityIdentity m_localAdmin;
   cta::common::dataStructures::SecurityIdentity m_admin;
-
-  const cta::common::dataStructures::Tape m_tape1;
-  const cta::common::dataStructures::Tape m_tape2;
+  const cta::catalogue::MediaType m_mediaType;
+  const cta::catalogue::CreateTapeAttributes m_tape1;
+  const cta::catalogue::CreateTapeAttributes m_tape2;
 
   virtual void SetUp();
 
@@ -114,12 +115,6 @@ protected:
    * @param voName the vo to create
    */
   void createVo(const std::string &voName);
-  
-  /**
-   * Creates a media type in the catalogue
-   * @param mediaTypeName
-   */
-  void createMediaType(const std::string & mediaTypeName, const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000);
 }; // cta_catalogue_CatalogueTest
 
 } // namespace unitTests
diff --git a/catalogue/CreateTapeAttributes.hpp b/catalogue/CreateTapeAttributes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b1d81cbe1ea71c2d5414181c110e4731e209718f
--- /dev/null
+++ b/catalogue/CreateTapeAttributes.hpp
@@ -0,0 +1,91 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2015  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/optional.hpp"
+
+#include <string>
+
+namespace cta {
+namespace catalogue {
+
+/**
+ * The tape attributes required to create a new tape entry in the CTA catalogue.
+ */
+struct CreateTapeAttributes {
+
+  /**
+   * The volume identifier of the tape.
+   */
+  std::string vid;
+
+  /**
+   * The media type of the tape.
+   */
+  std::string mediaType;
+
+  /**
+   * The vendor of the tape.
+   */
+  std::string vendor;
+
+  /**
+   * The logical library in which the tape is located.
+   */
+  std::string logicalLibraryName;
+
+  /**
+   * The tape pool to which the tape belongs.
+   */
+  std::string tapePoolName;
+
+  /**
+   * True if the tape is full.
+   */
+  bool full;
+
+  /**
+   * True if the tape is disabled.
+   */
+  bool disabled;
+
+  /**
+   * True if the tape is read-only.
+   */
+  bool readOnly;
+
+  /**
+   * Optional comment about the tape.
+   */
+  optional<std::string> comment;
+
+  /**
+   * Constructor.
+   *
+   * Sets the value of all boolean member-variables to false.
+   */
+  CreateTapeAttributes():
+    full(false),
+    disabled(false),
+    readOnly(false) {
+  }
+}; // struct CreateTapeAttributes
+
+} // namespace catalogue
+} // namespace cta
diff --git a/catalogue/DummyCatalogue.hpp b/catalogue/DummyCatalogue.hpp
index b851fc3e6136038f15dcd34eba17a440845a3334..595303a77f36bca20f156ffb75eec300277a834c 100644
--- a/catalogue/DummyCatalogue.hpp
+++ b/catalogue/DummyCatalogue.hpp
@@ -42,7 +42,7 @@ public:
   void createRequesterGroupMountRule(const common::dataStructures::SecurityIdentity& admin, const std::string& mountPolicyName, const std::string& diskInstanceName, const std::string& requesterGroupName, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createRequesterMountRule(const common::dataStructures::SecurityIdentity& admin, const std::string& mountPolicyName, const std::string& diskInstance, const std::string& requesterName, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createStorageClass(const common::dataStructures::SecurityIdentity& admin, const common::dataStructures::StorageClass& storageClass) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
-  void createTape(const common::dataStructures::SecurityIdentity& admin, const common::dataStructures::Tape & tape) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
+  void createTape(const common::dataStructures::SecurityIdentity &admin, const CreateTapeAttributes & tape) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createMediaType(const common::dataStructures::SecurityIdentity &admin, const MediaType &mediaType) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void deleteMediaType(const std::string &name) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   std::list<MediaTypeWithLogs> getMediaTypes() const override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
diff --git a/catalogue/RdbmsCatalogue.cpp b/catalogue/RdbmsCatalogue.cpp
index 8570368a429fc5eae40e31dea94ef0b8c808a6dd..fc7097c718a71db8b73c346245a6a7cbc313a999 100644
--- a/catalogue/RdbmsCatalogue.cpp
+++ b/catalogue/RdbmsCatalogue.cpp
@@ -2921,7 +2921,7 @@ void RdbmsCatalogue::setLogicalLibraryDisabled(const common::dataStructures::Sec
 //------------------------------------------------------------------------------
 void RdbmsCatalogue::createTape(
   const common::dataStructures::SecurityIdentity &admin,
-  const common::dataStructures::Tape & tape) {
+  const CreateTapeAttributes &tape) {
   // CTA hard code this field to FALSE
   const bool isFromCastor = false;
   try {
@@ -2930,10 +2930,11 @@ void RdbmsCatalogue::createTape(
     std::string vendor = tape.vendor;
     std::string logicalLibraryName = tape.logicalLibraryName;
     std::string tapePoolName = tape.tapePoolName;
-    std::string comment = tape.comment;
     bool disabled = tape.disabled;
     bool full = tape.full;
     bool readOnly = tape.readOnly;
+    // Translate an empty comment string to a NULL database value
+    const optional<std::string> tapeComment = tape.comment && tape.comment->empty() ? nullopt : tape.comment;
     
     if(vid.empty()) {
       throw UserSpecifiedAnEmptyStringVid("Cannot create tape because the VID is an empty string");
@@ -2955,7 +2956,7 @@ void RdbmsCatalogue::createTape(
     if(tapePoolName.empty()) {
       throw UserSpecifiedAnEmptyStringTapePoolName("Cannot create tape because the tape pool name is an empty string");
     }
-    
+
     auto conn = m_connPool.getConn();
     if(tapeExists(conn, vid)) {
       throw exception::UserError(std::string("Cannot create tape ") + vid +
@@ -3038,9 +3039,7 @@ void RdbmsCatalogue::createTape(
     stmt.bindBool(":IS_READ_ONLY", readOnly);
     stmt.bindBool(":IS_FROM_CASTOR", isFromCastor);
 
-    cta::optional<std::string> optionalComment;
-    if(!comment.empty()) optionalComment = comment;
-    stmt.bindString(":USER_COMMENT", optionalComment);
+    stmt.bindString(":USER_COMMENT", tapeComment);
 
     stmt.bindString(":CREATION_LOG_USER_NAME", admin.username);
     stmt.bindString(":CREATION_LOG_HOST_NAME", admin.host);
@@ -3063,7 +3062,7 @@ void RdbmsCatalogue::createTape(
        .add("isFull", full ? 1 : 0)
        .add("isReadOnly", readOnly ? 1 : 0)
        .add("isFromCastor", isFromCastor ? 1 : 0)
-       .add("userComment", comment)
+       .add("userComment", tape.comment ? tape.comment.value() : "")
        .add("creationLogUserName", admin.username)
        .add("creationLogHostName", admin.host)
        .add("creationLogTime", now);
diff --git a/catalogue/RdbmsCatalogue.hpp b/catalogue/RdbmsCatalogue.hpp
index 36cbd57507b893ee0b2dcdc4e33621083f54dd27..917edae50c1fd129cfcaf814ccd604dcf8b99df3 100644
--- a/catalogue/RdbmsCatalogue.hpp
+++ b/catalogue/RdbmsCatalogue.hpp
@@ -451,12 +451,14 @@ public:
   virtual void setLogicalLibraryDisabled(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const bool disabledValue) override;
 
   /**
-   * Creates a tape which is assumed to have logical block protection (LBP)
-   * enabled and isFromCastor disabled.
+   * Creates a tape which is assumed to have isFromCastor disabled.
+   *
+   * @param admin The administrator.
+   * @param tape The attributes of the tape to be created.
    */
   void createTape(
     const common::dataStructures::SecurityIdentity &admin,
-    const common::dataStructures::Tape & tape) override;
+    const CreateTapeAttributes & tape) override;
   
   void deleteTape(const std::string &vid) override;
 
diff --git a/common/dataStructures/Tape.cpp b/common/dataStructures/Tape.cpp
index 9e5ef2fdcb756125ee9e5916dec52cb0591f12fe..44c9957758b03a2a555e7494cfb2d795c31679ec 100644
--- a/common/dataStructures/Tape.cpp
+++ b/common/dataStructures/Tape.cpp
@@ -90,21 +90,6 @@ std::ostream &operator<<(std::ostream &os, const Tape &obj) {
   return os;
       }
 
-common::dataStructures::Tape Tape::TapeFactory::createTape(const std::string& vid, const std::string& mediaType, const std::string& vendor, const std::string& logicalLibraryName, const std::string& tapePoolName, bool disabledValue, bool fullValue, bool readOnlyValue, const std::string& comment) {
-  cta::common::dataStructures::Tape tape;
-  tape.vid = vid;
-  tape.mediaType = mediaType;
-  tape.vendor = vendor;
-  tape.logicalLibraryName = logicalLibraryName;
-  tape.tapePoolName = tapePoolName;
-  tape.disabled = disabledValue;
-  tape.full = fullValue;
-  tape.readOnly = readOnlyValue;
-  tape.comment = comment;
-  return tape;
-}
-
-
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
diff --git a/common/dataStructures/Tape.hpp b/common/dataStructures/Tape.hpp
index b8e05367eb30284ade0b2e388d9d5c0fd8367c62..c377fb12371cc26f47f10d26bb6393366fbb7427 100644
--- a/common/dataStructures/Tape.hpp
+++ b/common/dataStructures/Tape.hpp
@@ -76,13 +76,6 @@ struct Tape {
   optional<TapeLog> lastWriteLog;
   optional<TapeLog> lastReadLog;
   
-  struct TapeFactory {
-    static common::dataStructures::Tape createTape(const std::string & vid, const std::string & mediaType,
-                                               const std::string & vendor, const std::string & logicalLibraryName, 
-                                               const std::string & tapePoolName, bool disabledValue, bool fullValue,
-                                               bool readOnlyValue, const std::string & comment);
-  };
-
 }; // struct Tape
 
 std::ostream &operator<<(std::ostream &os, const Tape &obj);
diff --git a/scheduler/SchedulerTest.cpp b/scheduler/SchedulerTest.cpp
index 5ace69c3bb53e0f82c0db54f6bfc862097c2a951..fc97f3dc2c5ae6f4c76431a7e5327e1fae70d606 100644
--- a/scheduler/SchedulerTest.cpp
+++ b/scheduler/SchedulerTest.cpp
@@ -460,20 +460,18 @@ TEST_P(SchedulerTest, archive_report_and_retrieve_new_file) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -678,20 +676,18 @@ TEST_P(SchedulerTest, archive_and_retrieve_failure) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -942,20 +938,18 @@ TEST_P(SchedulerTest, archive_and_retrieve_report_failure) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1200,20 +1194,18 @@ TEST_P(SchedulerTest, retry_archive_until_max_reached) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1349,13 +1341,12 @@ TEST_P(SchedulerTest, repack) {
   const bool notReadOnly = false; 
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = tape1;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = 500;
     tape.full = false;
     tape.disabled = false;
     tape.readOnly = false;
@@ -1383,13 +1374,12 @@ TEST_P(SchedulerTest, repack) {
   // Recreate a repack and get it moved to ToExpand
   std::string tape2 = "Tape2";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = tape2;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = 500;
     tape.full = true;
     tape.disabled = false;
     tape.readOnly = notReadOnly;
@@ -1436,13 +1426,12 @@ TEST_P(SchedulerTest, getNextRepackRequestToExpand) {
   const bool notReadOnly = false;
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = tape1;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = 500;
     tape.full = true;
     tape.disabled = false;
     tape.readOnly = notReadOnly;
@@ -1456,13 +1445,12 @@ TEST_P(SchedulerTest, getNextRepackRequestToExpand) {
   std::string tape2 = "Tape2";
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = tape2;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = 500;
     tape.full = true;
     tape.disabled = false;
     tape.readOnly = notReadOnly;
@@ -1525,7 +1513,6 @@ TEST_P(SchedulerTest, expandRepackRequest) {
   std::unique_ptr<objectstore::AgentReference> agentReference(new objectstore::AgentReference(agentReferenceName, dl));
  
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -1550,13 +1537,12 @@ TEST_P(SchedulerTest, expandRepackRequest) {
     std::string vid = ossVid.str();
     allVid.push_back(vid);
 
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -1854,7 +1840,6 @@ TEST_P(SchedulerTest, expandRepackRequestRetrieveFailed) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -1872,13 +1857,12 @@ TEST_P(SchedulerTest, expandRepackRequestRetrieveFailed) {
   std::string vid = ossVid.str();
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2101,7 +2085,6 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveSuccess) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -2119,13 +2102,12 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveSuccess) {
   std::string vid = ossVid.str();
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2137,13 +2119,12 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveSuccess) {
   std::string vidDestination = "vidDestination";
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2375,7 +2356,6 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveFailed) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -2393,13 +2373,12 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveFailed) {
   std::string vid = ossVid.str();
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2410,13 +2389,12 @@ TEST_P(SchedulerTest, expandRepackRequestArchiveFailed) {
   //Create a repack destination tape
   std::string vidDestinationRepack = "vidDestinationRepack";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestinationRepack;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2698,7 +2676,6 @@ TEST_P(SchedulerTest, expandRepackRequestExpansionTimeLimitReached) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -2715,13 +2692,12 @@ TEST_P(SchedulerTest, expandRepackRequestExpansionTimeLimitReached) {
   ossVid << s_vid << "_" << 1;
   std::string vid = ossVid.str();
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2824,7 +2800,6 @@ TEST_P(SchedulerTest, expandRepackRequestDisabledTape) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = true;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -2842,13 +2817,12 @@ TEST_P(SchedulerTest, expandRepackRequestDisabledTape) {
   std::string vid = ossVid.str();
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -2965,7 +2939,6 @@ TEST_P(SchedulerTest, noMountIsTriggeredWhenTapeIsDisabled) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -2983,13 +2956,12 @@ TEST_P(SchedulerTest, noMountIsTriggeredWhenTapeIsDisabled) {
   std::string vid = ossVid.str();
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3173,20 +3145,18 @@ TEST_P(SchedulerTest, archiveReportMultipleAndQueueRetrievesWithActivities) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
   const std::string driveName = "tape_drive";
   for (auto i:fileRange) {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid + std::to_string(i);
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -3374,7 +3344,6 @@ TEST_P(SchedulerTest, expandRepackRequestAddCopiesOnly) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -3390,13 +3359,12 @@ TEST_P(SchedulerTest, expandRepackRequestAddCopiesOnly) {
   //Create the source tape
   std::string vid = "vidSource";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3426,13 +3394,12 @@ TEST_P(SchedulerTest, expandRepackRequestAddCopiesOnly) {
   //Create two other destinationTape
   std::string vidDestination1 = "vidDestination1";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination1;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = tapepool2Name;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3442,13 +3409,12 @@ TEST_P(SchedulerTest, expandRepackRequestAddCopiesOnly) {
   
   std::string vidDestination2 = "vidDestination2";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination2;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = tapepool3Name;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3651,7 +3617,6 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
   agent.setTimeout_us(100);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -3667,13 +3632,12 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
   //Create the source tape
   std::string vid = "vidSource";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3703,13 +3667,12 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
   //Create two other destinationTape and one for the move workflow
   std::string vidDestination1 = "vidDestination1";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination1;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = tapepool2Name;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3719,13 +3682,12 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
 
   std::string vidDestination2 = "vidDestination2";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination2;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = tapepool3Name;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3735,13 +3697,12 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
   
   std::string vidMove = "vidMove";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidMove;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue; 
@@ -3963,7 +3924,6 @@ TEST_P(SchedulerTest, cancelRepackRequest) {
   agent.setTimeout_us(0);
   agent.insertAndRegisterSelf(lc);
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -3980,13 +3940,12 @@ TEST_P(SchedulerTest, cancelRepackRequest) {
   ossVid << s_vid << "_" << 1;
   std::string vid = ossVid.str();
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -3996,13 +3955,12 @@ TEST_P(SchedulerTest, cancelRepackRequest) {
   //Create a repack destination tape
   std::string vidDestination = "vidDestination";
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = vidDestination;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = false;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
@@ -4226,13 +4184,12 @@ TEST_P(SchedulerTest, getNextMountEmptyArchiveForRepackIfNbFilesQueuedIsLessThan
     libraryIsDisabled, libraryComment);
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = 12345678;
     tape.full = false;
     tape.disabled = false;
     tape.readOnly = false;
@@ -4342,7 +4299,6 @@ TEST_P(SchedulerTest, repackRetrieveRequestsFailToFetchDiskSystem){
   std::unique_ptr<objectstore::AgentReference> agentReference(new objectstore::AgentReference(agentReferenceName, dl));
  
   
-  const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
   const bool disabledValue = false;
   const bool fullValue = true;
   const bool readOnlyValue = false;
@@ -4356,13 +4312,12 @@ TEST_P(SchedulerTest, repackRetrieveRequestsFailToFetchDiskSystem){
   catalogue.createLogicalLibrary(admin, s_libraryName, libraryIsDisabled, "Create logical library");
 
   {
-    common::dataStructures::Tape tape;
+    catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = fullValue;
     tape.disabled = disabledValue;
     tape.readOnly = readOnlyValue;
diff --git a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
index 2f7b1fd43c37a531c30e1ce45ecccdd62379dded..99b8e5e428b108480f9771b47a475956c6aaf21c 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
@@ -399,20 +399,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionGooddayRecall) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -596,20 +594,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionWrongRecall) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -803,20 +799,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionRAORecall) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1034,20 +1028,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionNoSuchDrive) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1197,20 +1189,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionFailtoMount) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1370,20 +1360,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionGooddayMigration) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1531,20 +1519,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionMissingFilesMigration) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1706,20 +1692,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionTapeFullMigration) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
@@ -1881,20 +1865,18 @@ TEST_P(DataTransferSessionTest, DataTransferSessionTapeFullOnFlushMigration) {
     ASSERT_EQ(s_libraryName, libraries.front().name);
     ASSERT_EQ(libraryComment, libraries.front().comment);
   }
-  const uint64_t capacityInBytes = 12345678;
   const std::string tapeComment = "Tape comment";
   bool notDisabled = false;
   bool notFull = false;
   bool notReadOnly = false;
 
   {
-    cta::common::dataStructures::Tape tape;
+    cta::catalogue::CreateTapeAttributes tape;
     tape.vid = s_vid;
     tape.mediaType = s_mediaType;
     tape.vendor = s_vendor;
     tape.logicalLibraryName = s_libraryName;
     tape.tapePoolName = s_tapePoolName;
-    tape.capacityInBytes = capacityInBytes;
     tape.full = notFull;
     tape.disabled = notDisabled;
     tape.readOnly = notReadOnly;
diff --git a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
index e20b39d971556a630bab59256ffa8afd49aa2906..972e73a669a810d5de2cee4b81bf70202477aa58 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
@@ -131,7 +131,6 @@ const uint32_t TEST_GROUP_2 = 9754;
     const bool logicalLibraryIsDisabled = false;
     const std::string tapePoolName = "tape_pool_name";
     const cta::optional<std::string> supply("value for the supply pool mechanism");
-    const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
     const bool disabledValue = true;
     const bool fullValue = false;
     const bool readOnlyValue = false;
@@ -148,13 +147,12 @@ const uint32_t TEST_GROUP_2 = 9754;
     createMediaType(mediaType);
 
     {
-      cta::common::dataStructures::Tape tape;
+      cta::catalogue::CreateTapeAttributes tape;
       tape.vid = vid1;
       tape.mediaType = mediaType;
       tape.vendor = vendor;
       tape.logicalLibraryName = logicalLibraryName;
       tape.tapePoolName = tapePoolName;
-      tape.capacityInBytes = capacityInBytes;
       tape.full = fullValue;
       tape.disabled = disabledValue;
       tape.readOnly = readOnlyValue;
@@ -297,7 +295,6 @@ const uint32_t TEST_GROUP_2 = 9754;
     const uint64_t nbPartialTapes = 2;
     const bool isEncrypted = true;
     const cta::optional<std::string> supply("value for the supply pool mechanism");
-    const uint64_t capacityInBytes = (uint64_t)10 * 1000 * 1000 * 1000 * 1000;
     const bool disabledValue = true;
     const bool fullValue = false;
     const bool readOnlyValue = false;
@@ -315,13 +312,12 @@ const uint32_t TEST_GROUP_2 = 9754;
     createMediaType(mediaType);
 
     {
-      cta::common::dataStructures::Tape tape;
+      cta::catalogue::CreateTapeAttributes tape;
       tape.vid = vid1;
       tape.mediaType = mediaType;
       tape.vendor = vendor;
       tape.logicalLibraryName = logicalLibraryName;
       tape.tapePoolName = tapePoolName;
-      tape.capacityInBytes = capacityInBytes;
       tape.full = fullValue;
       tape.disabled = disabledValue;
       tape.readOnly = readOnlyValue;
diff --git a/xroot_plugins/XrdSsiCtaRequestMessage.cpp b/xroot_plugins/XrdSsiCtaRequestMessage.cpp
index a3c01fa2eb13bd1810b3b85bec464b1a83b536ad..89679044c80886a646f6e3e097a32de5f7114ca6 100644
--- a/xroot_plugins/XrdSsiCtaRequestMessage.cpp
+++ b/xroot_plugins/XrdSsiCtaRequestMessage.cpp
@@ -1693,10 +1693,17 @@ void RequestMessage::processTape_Add(cta::xrd::Response &response)
    auto &full           = getRequired(OptionBoolean::FULL);
    auto &readOnly       = getRequired(OptionBoolean::READ_ONLY);
    auto  comment        = getOptional(OptionString::COMMENT);
-   
-   auto tape = common::dataStructures::Tape::TapeFactory::createTape(vid,mediaType,vendor,logicallibrary,tapepool,
-     disabled,full,readOnly,comment ? comment.value() : "");
-   
+
+   cta::catalogue::CreateTapeAttributes tape;
+   tape.vid = vid;
+   tape.mediaType = mediaType;
+   tape.vendor = vendor;
+   tape.logicalLibraryName = logicallibrary;
+   tape.tapePoolName = tapepool;
+   tape.full = full;
+   tape.disabled = disabled;
+   tape.readOnly = readOnly;
+   tape.comment = comment ? comment.value() : "";
    m_catalogue.createTape(m_cliIdentity, tape);
 
    response.set_type(cta::xrd::Response::RSP_SUCCESS);