diff --git a/libs/middletier/MockArchivalJobTable.cpp b/libs/middletier/MockArchivalJobTable.cpp
index 32a1f9b5ebf645156992c95a68afe410bb12b97b..b2abcf7fc82b8c343246b911fea2b3c8b279ec15 100644
--- a/libs/middletier/MockArchivalJobTable.cpp
+++ b/libs/middletier/MockArchivalJobTable.cpp
@@ -1,6 +1,7 @@
 #include "Exception.hpp"
 #include "MockArchivalJobTable.hpp"
 
+#include <iostream>
 #include <sstream>
 
 //------------------------------------------------------------------------------
@@ -16,15 +17,16 @@ void cta::MockArchivalJobTable::createArchivalJob(
   ArchivalJob job(ArchivalJobState::PENDING, srcUrl, dstPath, requester.user,
     time(NULL));
 
-  std::map<std::string, std::map<time_t, ArchivalJob> >::iterator poolItor =
+  std::map<std::string, std::list<ArchivalJob> >::iterator poolItor =
     m_jobsTree.find(tapePoolName);
 
   if(poolItor == m_jobsTree.end()) {
-    std::map<time_t, ArchivalJob> jobs;
-    jobs[job.getCreationTime()] = job;
+    std::list<ArchivalJob> jobs;
+    jobs.push_back(job);
     m_jobsTree[tapePoolName] = jobs;
   } else {
-    poolItor->second[job.getCreationTime()] = job;
+    std::list<ArchivalJob> &jobs = poolItor->second;
+    jobs.push_back(job);
   }
 }
 
@@ -33,12 +35,12 @@ void cta::MockArchivalJobTable::createArchivalJob(
 //------------------------------------------------------------------------------
 void cta::MockArchivalJobTable::checkArchivalJobDoesNotAlreadyExist(
   const std::string &dstPath) const {
-  for(std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+  for(std::map<std::string, std::list<ArchivalJob> >::const_iterator
     poolItor = m_jobsTree.begin(); poolItor != m_jobsTree.end(); poolItor++) {
-    const std::map<time_t, ArchivalJob> &jobs = poolItor->second;
-    for(std::map<time_t, ArchivalJob>::const_iterator jobItor =
-      jobs.begin(); jobItor != jobs.end(); jobItor++) {
-      const ArchivalJob &job = jobItor->second;
+    const std::list<ArchivalJob> &jobs = poolItor->second;
+    for(std::list<ArchivalJob>::const_iterator jobItor = jobs.begin();
+      jobItor != jobs.end(); jobItor++) {
+      const ArchivalJob &job = *jobItor;
       if(dstPath == job.getDstPath()) {
         std::ostringstream message;
         message << "An archival job for destination path " << dstPath <<
@@ -55,12 +57,12 @@ void cta::MockArchivalJobTable::checkArchivalJobDoesNotAlreadyExist(
 void cta::MockArchivalJobTable::deleteArchivalJob(
   const SecurityIdentity &requester,
   const std::string &dstPath) {
-  for(std::map<std::string, std::map<time_t, ArchivalJob> >::iterator
+  for(std::map<std::string, std::list<ArchivalJob> >::iterator
     poolItor = m_jobsTree.begin(); poolItor != m_jobsTree.end(); poolItor++) {
-    std::map<time_t, ArchivalJob> &jobs = poolItor->second;
-    for(std::map<time_t, ArchivalJob>::iterator jobItor =
-      jobs.begin(); jobItor != jobs.end(); jobItor++) {
-      const ArchivalJob &job = jobItor->second;
+    std::list<ArchivalJob> &jobs = poolItor->second;
+    for(std::list<ArchivalJob>::iterator jobItor = jobs.begin();
+      jobItor != jobs.end(); jobItor++) {
+      const ArchivalJob &job = *jobItor;
       if(dstPath == job.getDstPath()) {
         jobs.erase(jobItor);
         if(jobs.empty()) {
@@ -80,7 +82,7 @@ void cta::MockArchivalJobTable::deleteArchivalJob(
 //------------------------------------------------------------------------------
 // getArchivalJobs
 //------------------------------------------------------------------------------
-const std::map<std::string, std::map<time_t, cta::ArchivalJob> >
+const std::map<std::string, std::list<cta::ArchivalJob> >
   &cta::MockArchivalJobTable::getArchivalJobs(
   const SecurityIdentity &requester) const {
   return m_jobsTree;
@@ -92,17 +94,7 @@ const std::map<std::string, std::map<time_t, cta::ArchivalJob> >
 std::list<cta::ArchivalJob> cta::MockArchivalJobTable::getArchivalJobs(
   const SecurityIdentity &requester,
   const std::string &tapePoolName) const {
-  std::list<cta::ArchivalJob> jobs;
-  const std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+  const std::map<std::string, std::list<ArchivalJob> >::const_iterator
     poolItor = m_jobsTree.find(tapePoolName);
-
-  if(poolItor != m_jobsTree.end()) {
-    const std::map<time_t, ArchivalJob> &jobMap = poolItor->second;
-    for(std::map<time_t, ArchivalJob>::const_iterator jobItor =
-      jobMap.begin(); jobItor != jobMap.end(); jobItor++) {
-      jobs.push_back(jobItor->second);
-    }
-  }
-
-  return jobs;
+  return poolItor->second;
 }
diff --git a/libs/middletier/MockArchivalJobTable.hpp b/libs/middletier/MockArchivalJobTable.hpp
index 37ef36a512fac5ea065ce62f3a1344405d61f2f9..da0671f6215c2d7d41f1cc1a8f3402d7546fca27 100644
--- a/libs/middletier/MockArchivalJobTable.hpp
+++ b/libs/middletier/MockArchivalJobTable.hpp
@@ -57,7 +57,7 @@ public:
    * @return All of the existing archival jobs grouped by tape pool and then
    * sorted by creation time in ascending order (oldest first).
    */
-  const std::map<std::string, std::map<time_t, ArchivalJob> >
+  const std::map<std::string, std::list<ArchivalJob> >
     &getArchivalJobs(const SecurityIdentity &requester) const;
 
   /**
@@ -79,7 +79,7 @@ private:
    * All of the existing archival jobs grouped by tape pool name and then
    * sorted by creation time in ascending order (oldest first).
    */
-  std::map<std::string, std::map<time_t, ArchivalJob> > m_jobsTree;
+  std::map<std::string, std::list<ArchivalJob> > m_jobsTree;
 
 }; // class MockArchivalJobTable
 
diff --git a/libs/middletier/MockArchivalJobTableTest.cpp b/libs/middletier/MockArchivalJobTableTest.cpp
index 29db8ce663a19d4d3c9bca5916565f2021b72bf5..6a601646e80693803cca872a7c8dda7ff7d62063 100644
--- a/libs/middletier/MockArchivalJobTableTest.cpp
+++ b/libs/middletier/MockArchivalJobTableTest.cpp
@@ -21,7 +21,7 @@ TEST_F(cta_client_MockArchivalJobTableTest, createArchivalJob_new) {
   const SecurityIdentity requester;
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_TRUE(pools.empty());
   }
@@ -33,17 +33,15 @@ TEST_F(cta_client_MockArchivalJobTableTest, createArchivalJob_new) {
     dstPath));
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_EQ(1, pools.size());
-    std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+    std::map<std::string, std::list<ArchivalJob> >::const_iterator
       poolItor = pools.find(tapePoolName);
     ASSERT_FALSE(poolItor == pools.end());
-    const std::map<time_t, ArchivalJob> &jobs = poolItor->second;
+    const std::list<ArchivalJob> &jobs = poolItor->second;
     ASSERT_EQ(1, jobs.size());
-    const std::map<time_t, ArchivalJob>::const_iterator jobItor = jobs.begin();
-    ASSERT_FALSE(jobItor == jobs.end());
-    const ArchivalJob &job = jobItor->second;
+    const ArchivalJob &job = jobs.front();
     ASSERT_EQ(srcUrl, job.getSrcUrl());
     ASSERT_EQ(dstPath, job.getDstPath());
   }
@@ -65,7 +63,7 @@ TEST_F(cta_client_MockArchivalJobTableTest, createArchivalJob_already_existing)
   const SecurityIdentity requester;
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_TRUE(pools.empty());
   }
@@ -77,17 +75,15 @@ TEST_F(cta_client_MockArchivalJobTableTest, createArchivalJob_already_existing)
     dstPath));
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_EQ(1, pools.size());
-    std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+    std::map<std::string, std::list<ArchivalJob> >::const_iterator
       poolItor = pools.find(tapePoolName);
     ASSERT_FALSE(poolItor == pools.end());
-    const std::map<time_t, ArchivalJob> &jobs = poolItor->second;
+    const std::list<ArchivalJob> &jobs = poolItor->second;
     ASSERT_EQ(1, jobs.size());
-    const std::map<time_t, ArchivalJob>::const_iterator jobItor = jobs.begin();
-    ASSERT_FALSE(jobItor == jobs.end());
-    const ArchivalJob &job = jobItor->second;
+    const ArchivalJob &job = jobs.front();
     ASSERT_EQ(srcUrl, job.getSrcUrl());
     ASSERT_EQ(dstPath, job.getDstPath());
   }     
@@ -112,7 +108,7 @@ TEST_F(cta_client_MockArchivalJobTableTest, deleteTape_existing) {
   const SecurityIdentity requester;
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_TRUE(pools.empty());
   }
@@ -124,17 +120,15 @@ TEST_F(cta_client_MockArchivalJobTableTest, deleteTape_existing) {
     dstPath));
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_EQ(1, pools.size());
-    std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+    std::map<std::string, std::list<ArchivalJob> >::const_iterator
       poolItor = pools.find(tapePoolName);
     ASSERT_FALSE(poolItor == pools.end());
-    const std::map<time_t, ArchivalJob> &jobs = poolItor->second;
+    const std::list<ArchivalJob> &jobs = poolItor->second;
     ASSERT_EQ(1, jobs.size());
-    const std::map<time_t, ArchivalJob>::const_iterator jobItor = jobs.begin();
-    ASSERT_FALSE(jobItor == jobs.end());
-    const ArchivalJob &job = jobItor->second;
+    const ArchivalJob &job = jobs.front();
     ASSERT_EQ(srcUrl, job.getSrcUrl());
     ASSERT_EQ(dstPath, job.getDstPath());
   }     
@@ -151,7 +145,7 @@ TEST_F(cta_client_MockArchivalJobTableTest, deleteTape_existing) {
   ASSERT_NO_THROW(table.deleteArchivalJob(requester, dstPath));
 
   {
-    std::map<std::string, std::map<time_t, ArchivalJob> > pools;
+    std::map<std::string, std::list<ArchivalJob> > pools;
     ASSERT_NO_THROW(pools = table.getArchivalJobs(requester));
     ASSERT_TRUE(pools.empty());
   }
diff --git a/libs/middletier/MockMiddleTierUser.cpp b/libs/middletier/MockMiddleTierUser.cpp
index 5358a8b489a1168c8fa9b91effa0b02f1d5c6c96..9905f167b676d9f8c55d392c43aff2ec9368490b 100644
--- a/libs/middletier/MockMiddleTierUser.cpp
+++ b/libs/middletier/MockMiddleTierUser.cpp
@@ -281,11 +281,13 @@ void cta::MockMiddleTierUser::archiveToDirectory(
   checkDirNodeDoesNotContainFiles(dstDir, dstDirNode, dstFileNames);
 
   std::list<std::string>::const_iterator srcItor = srcUrls.begin();
+  const bool dstPathEndsWithASlash = dstDir.rfind('/') == dstDir.size() - 1;
   for(std::list<std::string>::const_iterator dstItor = dstFileNames.begin();
     dstItor != dstFileNames.end(); srcItor++, dstItor++) {
     const std::string &srcUrl = *srcItor;
     const std::string &dstFileName = *dstItor;
-    const std::string dstPath = dstDir + dstFileName;
+    const std::string dstPath = dstPathEndsWithASlash ? dstDir + dstFileName :
+      dstDir + "/" + dstFileName;
 
     for(uint16_t copyNb = 1; copyNb <= storageClass.getNbCopies(); copyNb++) {
       const ArchiveRoute &route = m_db.archiveRoutes.getArchiveRoute(
@@ -401,24 +403,19 @@ void cta::MockMiddleTierUser::checkUserIsAuthorisedToArchive(
 std::map<cta::TapePool, std::list<cta::ArchivalJob> >
   cta::MockMiddleTierUser::getArchivalJobs(
   const SecurityIdentity &requester) const {
-  const std::map<std::string, std::map<time_t, ArchivalJob> >
-   jobsByPoolName = m_db.archivalJobs.getArchivalJobs(requester);
+  const std::map<std::string, std::list<ArchivalJob> > jobsByPoolName =
+    m_db.archivalJobs.getArchivalJobs(requester);
 
   std::map<TapePool, std::list<ArchivalJob> > allJobs;
 
-  for(std::map<std::string, std::map<time_t, ArchivalJob> >::const_iterator
+  for(std::map<std::string, std::list<ArchivalJob> >::const_iterator
     poolItor = jobsByPoolName.begin();
     poolItor != jobsByPoolName.end();
     poolItor++) {
     const std::string &tapePoolName = poolItor->first;
-    const std::map<time_t, ArchivalJob> &timeToJobMap = poolItor->second;
-    if(!timeToJobMap.empty()) {
+    const std::list<ArchivalJob> &poolJobs = poolItor->second;
+    if(!poolJobs.empty()) {
       const TapePool tapePool = m_db.tapePools.getTapePool(tapePoolName);
-      std::list<cta::ArchivalJob> poolJobs;
-      for(std::map<time_t, ArchivalJob>::const_iterator jobItor =
-        timeToJobMap.begin(); jobItor != timeToJobMap.end(); jobItor++) {
-        poolJobs.push_back(jobItor->second);
-      }
       allJobs[tapePool] = poolJobs;
     }
   }