Merge pull request #32 from pemari-msft/master

Java Storage Client Library 2.0.0

Author: pemari-msft

BreakingChanges.txt

@@ -1,3 +1,20 @@
+Changes in 2.0.0
+
+BLOB
+ * Deprecated getSubDirectoryReference(). Use getDirectoryReference() instead. 
+
+TABLE
+ * Loses millisecond precision when reading Date values on Table Entities written using versions of this library prior to 2.0.0, unless TableRequestOptions.dateBackwardCompatibility is set to true.  See http://go.microsoft.com/fwlink/?LinkId=523753 for more details.
+
+FILE
+ * Deprecated getSubDirectoryReference(). Use getDirectoryReference() instead. 
+
+OTHER
+ * Changed maxResults arguments of List*Segmented() methods to type Integer instead of int
+ * Added validation to ensure that the maxResults arguments of List*Segmented() methods are positive when non-null
+ * Added PARAMETER_SHOULD_BE_GREATER_OR_EQUAL attribute to SR which is used by Utility.assertGreaterThanOrEqual()
+ * Deprecated AuthenticationScheme and its getter and setter. In the future only SharedKey will be used.
+
 Changes in 0.7.0
 
 BLOB

ChangeLog.txt

@@ -1,3 +1,10 @@
+2014.12.20 Version 2.0.0
+ * Deprecated getSubDirectoryReference() for blob directories and file directories. Use getDirectoryReference() instead. 
+ * Fixed a bug where maxResults was not verified to be positive for list operations.
+ * Fixed a bug where high precision Date values stored on Table Entites were forced to fit into milliseconds resulting in inaccuracies. Precision is limited to 1 millisecond by Java.util.Date. If greater precision is required, the String should be used directly.
+ * Added TableRequestOptions.dateBackwardCompatibility, which supports reading Date values on Table Entities written using versions of this library prior to 2.0.0. See http://go.microsoft.com/fwlink/?LinkId=523753 for more details.
+ * Deprecated AuthenticationScheme and its getter and setter. In the future only SharedKey will be used.
+
 2014.11.03 Version 1.3.1
  * Reverted timestamp bug fix from 1.3.0 for further consideration.
 

README.md

@@ -28,7 +28,7 @@ To get the binaries of this library as distributed by Microsoft, ready for use w
 <dependency>
 	<groupId>com.microsoft.azure</groupId>
 	<artifactId>azure-storage</artifactId>
-	<version>1.3.1</version>
+	<version>2.0.0</version>
 </dependency>
 ```
 

microsoft-azure-storage-samples/pom.xml

@@ -25,7 +25,7 @@
   <dependency>  
      <groupId>com.microsoft.azure</groupId>
      <artifactId>azure-storage</artifactId>
-     <version>1.3.1</version>
+     <version>2.0.0</version>
 </dependency>
 </dependencies>
 </project>

microsoft-azure-storage-test/src/com/microsoft/azure/storage/GenericTests.java

@@ -20,7 +20,10 @@
 import java.io.IOException;
 import java.net.HttpURLConnection;
 import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.UUID;
 
@@ -414,6 +417,128 @@ public void testMaximumExecutionTimeBlobByteArray() throws URISyntaxException, S
         }
     }
 
+    @Test
+    public void testDateStringParsingWithRounding() throws ParseException {
+        String fullDateString = "1999-12-31T23:59:45.1234567Z";
+        SimpleDateFormat testFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS Z");
+        Date milliDate = testFormat.parse("1999-12-31T23:59:45.123 -0000");
+        assertEquals(milliDate, Utility.parseDate(fullDateString));
+
+        fullDateString = "1999-04-30T23:59:55.9876Z";
+        long millisSinceEpoch = 925516795987L;
+
+        Date deciDate = Utility.parseDate(fullDateString.replace("876Z", "Z"));
+        assertEquals(deciDate.getTime(), (millisSinceEpoch / 100) * 100);
+
+        Date centiDate = Utility.parseDate(fullDateString.replace("76Z", "Z"));
+        assertEquals(centiDate.getTime(), (millisSinceEpoch / 10) * 10);
+
+        milliDate = Utility.parseDate(fullDateString);
+        assertEquals(milliDate.getTime(), millisSinceEpoch);
+    }
+    
+    @Test
+    public void testDateStringParsing() throws ParseException {
+        // 2014-12-07T09:15:12.123Z  from Java
+        testDate("2014-12-07T09:15:12.123Z", 1417943712123L, 0, false, false);
+
+        // 2015-01-14T14:53:32.800Z  from Java
+        testDate("2015-01-14T14:53:32.800Z", 1421247212800L, 0, false, false);
+
+        // 2014-11-29T22:55:21.9876543Z  from .Net
+        testDate("2014-11-29T22:55:21.9876543Z", 1417301721987L, 6543, false, false);
+
+        // 2015-02-14T03:11:13.0000229Z  from .Net
+        testDate("2015-02-14T03:11:13.0000229Z", 1423883473000L, 229, false, false);
+    }
+
+    @Test
+    public void testDateStringParsingCrossVersion() throws ParseException {
+        // 2014-12-07T09:15:12.123Z  from Java, milliseconds are incorrectly left-padded
+        testDate("2014-12-07T09:15:12.0000123Z", 1417943712123L, 0, true, false);
+
+        // 2015-01-14T14:53:32.800Z  from Java, milliseconds are incorrectly left-padded
+        testDate("2015-01-14T14:53:32.0000800Z", 1421247212800L, 0, true, false);
+
+        // 2014-11-29T22:55:21.9876543Z  from .Net
+        testDate("2014-11-29T22:55:21.9876543Z", 1417301721987L, 6543, true, false);
+
+        // 2015-02-14T03:11:13.0000229Z  from .Net
+        testDate("2015-02-14T03:11:13.0000229Z", 1423883473000L, 229, true, false);
+    }
+    
+    @Test
+    public void testDateStringParsingWithBackwardCompatibility() throws ParseException {
+        // 2014-12-07T09:15:12.123Z  from Java
+        testDate("2014-12-07T09:15:12.123Z", 1417943712123L, 0, false, true);
+
+        // 2015-01-14T14:53:32.800Z  from Java
+        testDate("2015-01-14T14:53:32.800Z", 1421247212800L, 0, false, true);
+
+        // 2014-11-29T22:55:21.9876543Z  from .Net
+        testDate("2014-11-29T22:55:21.9876543Z", 1417301721987L, 6543, false, true);
+
+        // 2015-02-14T03:11:13.0000229Z  from .Net
+        testDate("2015-02-14T03:11:13.0000229Z", 1423883473000L, 229, false, true);
+    }
+
+    @Test
+    public void testDateStringParsingCrossVersionWithBackwardCompatibility() throws ParseException {
+        // 2014-12-07T09:15:12.123Z  from Java, milliseconds are incorrectly left-padded
+        testDate("2014-12-07T09:15:12.0000123Z", 1417943712123L, 0, true, true);
+
+        // 2015-01-14T14:53:32.800Z  from Java, milliseconds are incorrectly left-padded
+        testDate("2015-01-14T14:53:32.0000800Z", 1421247212800L, 0, true, true);
+
+        // 2014-11-29T22:55:21.9876543Z  from .Net
+        testDate("2014-11-29T22:55:21.9876543Z", 1417301721987L, 6543, true, true);
+
+        // 2015-02-14T03:11:13.0000229Z  from .Net
+        testDate("2015-02-14T03:11:13.0000229Z", 1423883473000L, 229, true, true);
+    }
+
+    private static void testDate(final String dateString, final long intendedMilliseconds, final int ticks,
+            final boolean writtenPre2, final boolean dateBackwardCompatibility) {
+        assertTrue(ticks >= 0);     // ticks is non-negative
+        assertTrue(ticks <= 9999);  // ticks do not overflow into milliseconds
+        long expectedMilliseconds = intendedMilliseconds;
+        
+        if (dateBackwardCompatibility && (intendedMilliseconds % 1000 == 0) && (ticks < 1000)) {
+            // when no milliseconds are present dateBackwardCompatibility causes up to 3 digits of ticks
+            // to be read as milliseconds
+            expectedMilliseconds += ticks;
+        } else if (writtenPre2 && !dateBackwardCompatibility && (ticks == 0)) {
+            // without DateBackwardCompatibility, milliseconds stored by Java prior to 2.0.0 are lost
+            expectedMilliseconds -= expectedMilliseconds % 1000;
+        }
+        
+        assertEquals(expectedMilliseconds, Utility.parseDate(dateString, dateBackwardCompatibility).getTime());
+    }
+
+    @Test
+    public void testDateStringFormatting() {
+        String fullDateString = "2014-12-07T09:15:12.123Z";
+        String outDateString = Utility.getJavaISO8601Time(Utility.parseDate(fullDateString));
+        assertEquals(fullDateString, outDateString);
+        
+        fullDateString = "2015-01-14T14:53:32.800Z";
+        outDateString = Utility.getJavaISO8601Time(Utility.parseDate(fullDateString));
+        assertEquals(fullDateString, outDateString);
+        
+        // Ensure that trimming of trailing zeroes by the service does not affect this
+        fullDateString = "2015-01-14T14:53:32.8Z";
+        outDateString = Utility.getJavaISO8601Time(Utility.parseDate(fullDateString));
+        fullDateString = fullDateString.replace("Z", "00Z");
+        assertEquals(fullDateString, outDateString);
+        
+        // Ensure that trimming of trailing zeroes by the service does not affect this
+        // even with dateBackwardCompatibility
+        fullDateString = "2015-01-14T14:53:32.0000800Z";
+        outDateString = Utility.getJavaISO8601Time(Utility.parseDate(fullDateString, true));
+        fullDateString = "2015-01-14T14:53:32.800Z";
+        assertEquals(fullDateString, outDateString);
+    }
+
     private static String generateRandomContainerName() {
         String containerName = "container" + UUID.randomUUID().toString();
         return containerName.replace("-", "");

microsoft-azure-storage-test/src/com/microsoft/azure/storage/StorageUriTests.java

@@ -211,7 +211,7 @@ public void testBlobTypesWithStorageUri() throws StorageException, URISyntaxExce
         assertEquals(containerUri, directory.getContainer().getStorageUri());
         assertEquals(endpoint, directory.getServiceClient().getStorageUri());
 
-        CloudBlobDirectory subdirectory = directory.getSubDirectoryReference("subdirectory");
+        CloudBlobDirectory subdirectory = directory.getDirectoryReference("subdirectory");
         assertEquals(subdirectoryUri, subdirectory.getStorageUri());
         assertEquals(subdirectoryUri.getPrimaryUri(), subdirectory.getUri());
         assertEquals(directoryUri, subdirectory.getParent().getStorageUri());

microsoft-azure-storage-test/src/com/microsoft/azure/storage/TestHelper.java

@@ -46,28 +46,33 @@ public class TestHelper {
     private static StorageCredentialsAccountAndKey credentials;
     private static CloudStorageAccount account;
 
+    @SuppressWarnings("deprecation")
     private final static AuthenticationScheme defaultAuthenticationScheme = AuthenticationScheme.SHAREDKEYFULL;
     private final static boolean enableFiddler = true;
     private final static boolean requireSecondaryEndpoint = false;
 
+    @SuppressWarnings("deprecation")
     public static CloudBlobClient createCloudBlobClient() throws StorageException {
         CloudBlobClient client = getAccount().createCloudBlobClient();
         client.setAuthenticationScheme(defaultAuthenticationScheme);
         return client;
     }
 
+    @SuppressWarnings("deprecation")
     public static CloudFileClient createCloudFileClient() throws StorageException {
         CloudFileClient client = getAccount().createCloudFileClient();
         client.setAuthenticationScheme(defaultAuthenticationScheme);
         return client;
     }
 
+    @SuppressWarnings("deprecation")
     public static CloudQueueClient createCloudQueueClient() throws StorageException {
         CloudQueueClient client = getAccount().createCloudQueueClient();
         client.setAuthenticationScheme(defaultAuthenticationScheme);
         return client;
     }
 
+    @SuppressWarnings("deprecation")
     public static CloudTableClient createCloudTableClient() throws StorageException {
         CloudTableClient client = getAccount().createCloudTableClient();
         client.setAuthenticationScheme(defaultAuthenticationScheme);

microsoft-azure-storage-test/src/com/microsoft/azure/storage/blob/CloudBlobClientTests.java

@@ -35,6 +35,7 @@
 import com.microsoft.azure.storage.TestRunners.CloudTests;
 import com.microsoft.azure.storage.TestRunners.DevFabricTests;
 import com.microsoft.azure.storage.TestRunners.DevStoreTests;
+import com.microsoft.azure.storage.core.SR;
 
 /**
  * Blob Client Tests
@@ -47,7 +48,7 @@ public class CloudBlobClientTests {
      */
     @Test
     @Category({ DevFabricTests.class, DevStoreTests.class, CloudTests.class })
-    public void testListContainersTest() throws StorageException, URISyntaxException {
+    public void testListContainers() throws StorageException, URISyntaxException {
         CloudBlobClient bClient = BlobTestHelper.createCloudBlobClient();
         ArrayList<String> containerList = new ArrayList<String>();
         String prefix = UUID.randomUUID().toString();
@@ -80,6 +81,57 @@ public void testListContainersTest() throws StorageException, URISyntaxException
 
         assertEquals(0, containerList.size());
     }
+    
+    /**
+     * Try to list the containers to ensure maxResults validation is working.
+     * 
+     * @throws StorageException
+     * @throws URISyntaxException
+     */
+    @Test
+    @Category({ DevFabricTests.class, DevStoreTests.class, CloudTests.class })
+    public void testListContainersMaxResultsValidation()
+            throws StorageException, URISyntaxException {
+        CloudBlobClient bClient = BlobTestHelper.createCloudBlobClient();
+        String prefix = UUID.randomUUID().toString();
+
+        // Validation should cause each of these to fail.
+        for(int i = 0; i >= -2; i--) {
+            try {
+                bClient.listContainersSegmented(
+                        prefix, ContainerListingDetails.ALL, i, null, null, null);
+                fail();
+            }
+            catch (IllegalArgumentException e) {
+                assertTrue(String.format(SR.PARAMETER_SHOULD_BE_GREATER_OR_EQUAL, "maxResults", 1)
+                        .equals(e.getMessage()));
+            }
+        }
+        assertNotNull(bClient.listContainersSegmented("thereshouldntbeanycontainersswiththisprefix"));
+    }
+    
+    /**
+     * Fetch result segments and ensure pageSize is null when unspecified and will cap at 5000.
+     * 
+     * @throws StorageException
+     * @throws URISyntaxException
+     */
+    @Test
+    @Category({ DevFabricTests.class, DevStoreTests.class, CloudTests.class })
+    public void testListContainersResultSegment()
+            throws StorageException, URISyntaxException {
+        CloudBlobClient bClient = BlobTestHelper.createCloudBlobClient();
+
+        ResultSegment<CloudBlobContainer> segment1 = bClient.listContainersSegmented(); 
+        assertNotNull(segment1);
+        assertNull(segment1.getPageSize());
+        
+        ResultSegment<CloudBlobContainer> segment2 = bClient.listContainersSegmented(null,
+                ContainerListingDetails.ALL, 9001, null, null, null); 
+        assertNotNull(segment2);
+        assertNotNull(segment2.getPageSize());
+        assertEquals(5000, segment2.getPageSize().intValue());
+    }
 
     @Test
     @Category({ CloudTests.class })

microsoft-azure-storage-test/src/com/microsoft/azure/storage/blob/CloudBlobContainerTests.java

@@ -119,7 +119,7 @@ public void testCloudBlobContainerReference() throws StorageException, URISyntax
         CloudBlockBlob blockBlob = container.getBlockBlobReference("directory1/blob1");
         CloudPageBlob pageBlob = container.getPageBlobReference("directory2/blob2");
         CloudBlobDirectory directory = container.getDirectoryReference("directory3");
-        CloudBlobDirectory directory2 = directory.getSubDirectoryReference("directory4");
+        CloudBlobDirectory directory2 = directory.getDirectoryReference("directory4");
 
         assertEquals(container.getStorageUri().toString(), blockBlob.getContainer().getStorageUri().toString());
         assertEquals(container.getStorageUri().toString(), pageBlob.getContainer().getStorageUri().toString());
@@ -463,6 +463,34 @@ public void testCloudBlobContainerListBlobs() throws StorageException, IOExcepti
 
         assertTrue(blobNames.size() == 0);
     }
+    
+    /**
+     * Try to list the blobs in a container to ensure maxResults validation is working.
+     * 
+     * @throws URISyntaxException
+     * @throws StorageException
+     * @throws IOException
+     */
+    @Test
+    @Category({ DevFabricTests.class, DevStoreTests.class })
+    public void testCloudBlobContainerListBlobsMaxResultsValidation()
+            throws StorageException, IOException, URISyntaxException {
+        this.container.create();
+
+        // Validation should cause each of these to fail.
+        for (int i = 0; i >= -2; i--) {
+            try {
+                this.container.listBlobsSegmented(
+                        "bb", false, EnumSet.noneOf(BlobListingDetails.class), i, null, null, null);
+                fail();
+            }
+            catch (IllegalArgumentException e) {
+                assertTrue(String.format(SR.PARAMETER_SHOULD_BE_GREATER_OR_EQUAL, "maxResults", 1)
+                        .equals(e.getMessage()));
+            }
+        }
+        assertNotNull(this.container.listBlobsSegmented("thereshouldntbeanyblobswiththisprefix"));
+    }
 
     /**
      * List the blobs in a container