LMS-1995 new test

SVN: 19886

datastore_server/source/java/ch/systemsx/cisd/openbis/dss/generic/shared/utils/SegmentedStoreUtils.java

@@ -29,7 +29,6 @@ import java.util.Map;
 import java.util.regex.Pattern;
 
 import org.apache.commons.io.FileUtils;
-import org.apache.commons.lang.time.StopWatch;
 
 import ch.systemsx.cisd.base.utilities.OSUtilities;
 import ch.systemsx.cisd.common.exceptions.ConfigurationFailureException;
@@ -40,6 +39,8 @@ import ch.systemsx.cisd.common.filesystem.IFreeSpaceProvider;
 import ch.systemsx.cisd.common.filesystem.rsync.RsyncCopier;
 import ch.systemsx.cisd.common.logging.ISimpleLogger;
 import ch.systemsx.cisd.common.logging.LogLevel;
+import ch.systemsx.cisd.common.utilities.ITimeProvider;
+import ch.systemsx.cisd.common.utilities.SystemTimeProvider;
 import ch.systemsx.cisd.openbis.dss.generic.shared.IEncapsulatedOpenBISService;
 import ch.systemsx.cisd.openbis.generic.shared.basic.dto.ExternalData;
 import ch.systemsx.cisd.openbis.generic.shared.dto.SimpleDataSetInformationDTO;
@@ -146,6 +147,14 @@ public class SegmentedStoreUtils
     public static List<Share> getDataSetsPerShare(File storeRoot, String dataStoreCode,
             IFreeSpaceProvider freeSpaceProvider, IEncapsulatedOpenBISService service,
             ISimpleLogger log)
+    {
+        return getDataSetsPerShare(storeRoot, dataStoreCode, freeSpaceProvider, service, log,
+                SystemTimeProvider.SYSTEM_TIME_PROVIDER);
+    }
+
+    static List<Share> getDataSetsPerShare(File storeRoot, String dataStoreCode,
+            IFreeSpaceProvider freeSpaceProvider, IEncapsulatedOpenBISService service,
+            ISimpleLogger log, ITimeProvider timeProvider)
     {
         Map<String, Share> shares = new HashMap<String, Share>();
         for (File file : getImcomingShares(storeRoot))
@@ -165,13 +174,12 @@ public class SegmentedStoreUtils
                 {
                     if (dataSet.getDataSetSize() == null)
                     {
-                        StopWatch stopWatch = new StopWatch();
                         log.log(LogLevel.INFO, "Calculating size of " + dataSetInStore);
-                        stopWatch.start();
+                        long t0 = timeProvider.getTimeInMilliseconds();
                         long size = FileUtils.sizeOfDirectory(dataSetInStore);
-                        stopWatch.stop();
                         log.log(LogLevel.INFO, dataSetInStore + " contains " + size
-                                + " bytes (calculated in " + stopWatch.getTime() + " msec)");
+                                + " bytes (calculated in "
+                                + (timeProvider.getTimeInMilliseconds() - t0) + " msec)");
                         service.updateShareIdAndSize(dataSetCode, shareId, size);
                         dataSet.setDataSetSize(size);
                     }

datastore_server/sourceTest/java/ch/systemsx/cisd/openbis/dss/generic/shared/utils/SegmentedStoreUtilsTest.java

@@ -17,6 +17,7 @@
 package ch.systemsx.cisd.openbis.dss.generic.shared.utils;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -29,8 +30,15 @@ import org.testng.annotations.Test;
 
 import ch.systemsx.cisd.base.tests.AbstractFileSystemTestCase;
 import ch.systemsx.cisd.common.filesystem.FileUtilities;
+import ch.systemsx.cisd.common.filesystem.HostAwareFile;
+import ch.systemsx.cisd.common.filesystem.IFreeSpaceProvider;
+import ch.systemsx.cisd.common.logging.ISimpleLogger;
+import ch.systemsx.cisd.common.logging.LogLevel;
+import ch.systemsx.cisd.common.test.RecordingMatcher;
+import ch.systemsx.cisd.common.utilities.ITimeProvider;
 import ch.systemsx.cisd.openbis.dss.generic.shared.IEncapsulatedOpenBISService;
 import ch.systemsx.cisd.openbis.generic.shared.basic.dto.ExternalData;
+import ch.systemsx.cisd.openbis.generic.shared.dto.SimpleDataSetInformationDTO;
 
 /**
  * 
@@ -39,14 +47,51 @@ import ch.systemsx.cisd.openbis.generic.shared.basic.dto.ExternalData;
  */
 public class SegmentedStoreUtilsTest extends AbstractFileSystemTestCase
 {
+    private static final class MockLogger implements ISimpleLogger
+    {
+        private final StringBuilder builder = new StringBuilder();
+        
+        public void log(LogLevel level, String message)
+        {
+            builder.append(level).append(": ").append(message).append('\n');
+        }
+
+        @Override
+        public String toString()
+        {
+            return builder.toString();
+        }
+    }
+    
+    private static final String DATA_STORE_CODE = "ds-code";
+    
     private Mockery context;
     private IEncapsulatedOpenBISService service;
+    private ISimpleLogger log;
+    private IFreeSpaceProvider freeSpaceProvider;
+    private ITimeProvider timeProvider;
+
+    private File store;
     
     @BeforeMethod
     public void beforeMethod()
     {
         context = new Mockery();
         service = context.mock(IEncapsulatedOpenBISService.class);
+        freeSpaceProvider = context.mock(IFreeSpaceProvider.class);
+        timeProvider = context.mock(ITimeProvider.class);
+        context.checking(new Expectations()
+            {
+                {
+                    allowing(timeProvider).getTimeInMilliseconds();
+                    will(returnValue(0L));
+                }
+            });
+        log = new MockLogger();
+        store = new File(workingDirectory, "store");
+        store.mkdirs();
+        new File(store, "blabla").mkdirs();
+        new File(store, "error").mkdirs();
     }
 
     @AfterMethod
@@ -54,9 +99,83 @@ public class SegmentedStoreUtilsTest extends AbstractFileSystemTestCase
     {
         context.assertIsSatisfied();
     }
+    
+    @Test
+    public void testGetDataSetsPerShare()
+    {
+        final File ds1File = new File(store, "1/uuid/01/02/03/ds-1");
+        ds1File.mkdirs();
+        FileUtilities.writeToFile(new File(ds1File, "read.me"), "nice work!");
+        final SimpleDataSetInformationDTO ds1 = dataSet(ds1File, DATA_STORE_CODE, null);
+        File ds2File = new File(store, "1/uuid/01/02/04/ds-2");
+        ds2File.mkdirs();
+        FileUtilities.writeToFile(new File(ds2File, "hello.txt"), "hello world");
+        final SimpleDataSetInformationDTO ds2 = dataSet(ds2File, "blabla", null);
+        File ds3File = new File(store, "2/uuid/01/05/04/ds-3");
+        ds3File.mkdirs();
+        FileUtilities.writeToFile(new File(ds3File, "hi.txt"), "hi everybody");
+        final SimpleDataSetInformationDTO ds3 = dataSet(ds3File, DATA_STORE_CODE, 123456789L);
+        File ds4File = new File(store, "1/uuid/0a/02/03/ds-4");
+        ds4File.mkdirs();
+        FileUtilities.writeToFile(new File(ds4File, "hello.data"), "hello data");
+        final SimpleDataSetInformationDTO ds4 = dataSet(ds4File, DATA_STORE_CODE, 42L);
+        final SimpleDataSetInformationDTO ds5 = new SimpleDataSetInformationDTO();
+        ds5.setDataSetCode("ds5");
+        ds5.setDataSetShareId("2");
+        ds5.setDataSetLocation("blabla");
+        ds5.setDataStoreCode(DATA_STORE_CODE);
+        final RecordingMatcher<HostAwareFile> fileMatcher = new RecordingMatcher<HostAwareFile>();
+        context.checking(new Expectations()
+            {
+                {
+                    one(service).listDataSets();
+                    will(returnValue(Arrays.asList(ds1, ds2, ds3, ds4, ds5)));
+                    
+                    one(service).updateShareIdAndSize("ds-1", "1", 10L);
+                    
+                    try
+                    {
+                        one(freeSpaceProvider).freeSpaceKb(with(fileMatcher));
+                        will(returnValue(12345L));
+                    } catch (IOException ex)
+                    {
+                        ex.printStackTrace();
+                    }
+                }
+            });
+        
+        List<Share> shares =
+                SegmentedStoreUtils.getDataSetsPerShare(store, DATA_STORE_CODE, freeSpaceProvider,
+                        service, log, timeProvider);
+        Share share1 = shares.get(0);
+        long freeSpace = share1.calculateFreeSpace();
+        
+        assertEquals("INFO: Calculating size of " + ds1File + "\n" + "INFO: " + ds1File
+                + " contains 10 bytes (calculated in 0 msec)\n"
+                + "WARN: Data set ds5 no longer exists in share 2.\n", log.toString());
+        assertEquals(new File(store, "1"), fileMatcher.recordedObject().getFile());
+        assertEquals(12345L * 1024, freeSpace);
+        assertEquals(new File(store, "1").toString(), share1.getShare().toString());
+        assertEquals("1", share1.getShareId());
+        assertSame(ds4, share1.getDataSetsOrderedBySize().get(0));
+        assertEquals(42L, share1.getDataSetsOrderedBySize().get(0).getDataSetSize().longValue());
+        assertSame(ds1, share1.getDataSetsOrderedBySize().get(1));
+        assertEquals(10L, share1.getDataSetsOrderedBySize().get(1).getDataSetSize().longValue());
+        assertEquals(2, share1.getDataSetsOrderedBySize().size());
+        assertEquals(52L, share1.getTotalSizeOfDataSets());
+        assertEquals(new File(store, "2").toString(), shares.get(1).getShare().toString());
+        assertEquals("2", shares.get(1).getShareId());
+        assertSame(ds3, shares.get(1).getDataSetsOrderedBySize().get(0));
+        assertEquals(123456789L, shares.get(1).getDataSetsOrderedBySize().get(0).getDataSetSize().longValue());
+        assertEquals(1, shares.get(1).getDataSetsOrderedBySize().size());
+        assertEquals(123456789L, shares.get(1).getTotalSizeOfDataSets());
+        assertEquals(2, shares.size());
+        
+        context.assertIsSatisfied();
+    }
 
     @Test
-    public void test()
+    public void testMoveDataSetToAnotherShare()
     {
         File share1 = new File(workingDirectory, "store/1");
         File share1uuid01 = new File(share1, "uuid/01");
@@ -105,4 +224,17 @@ public class SegmentedStoreUtilsTest extends AbstractFileSystemTestCase
         }
         assertEquals(Arrays.asList(names).toString(), actualNames.toString());
     }
+    
+    private SimpleDataSetInformationDTO dataSet(File dataSetFile, String dataStoreCode, Long size)
+    {
+        SimpleDataSetInformationDTO dataSet = new SimpleDataSetInformationDTO();
+        dataSet.setDataSetCode(dataSetFile.getName());
+        dataSet.setDataStoreCode(dataStoreCode);
+        String path = FileUtilities.getRelativeFile(store, dataSetFile);
+        int indexOfFirstSeparator = path.indexOf(File.separatorChar);
+        dataSet.setDataSetShareId(path.substring(0, indexOfFirstSeparator));
+        dataSet.setDataSetLocation(path.substring(indexOfFirstSeparator + 1));
+        dataSet.setDataSetSize(size);
+        return dataSet;
+    }
 }