GetEtagAsync (#6577)

 Add GetEtagAsync.

Author: cristinamanum

src/NuGetGallery.Core/Services/CloudBlobCoreFileStorageService.cs

@@ -426,6 +426,27 @@ public async Task SetMetadataAsync(
             }
         }
 
+        public async Task<string> GetETagOrNullAsync(
+            string folderName,
+            string fileName)
+        {
+            folderName = folderName ?? throw new ArgumentNullException(nameof(folderName));
+            fileName = fileName ?? throw new ArgumentNullException(nameof(fileName));
+
+            var container = await GetContainerAsync(folderName);
+            var blob = container.GetBlobReference(fileName);
+            try
+            {
+                await blob.FetchAttributesAsync();
+                return blob.ETag;
+            }
+            // In case that the blob does not exist return null.
+            catch (StorageException)
+            {
+                return null;
+            }
+        }
+
         private static SharedAccessBlobPermissions MapFileUriPermissions(FileUriPermissions permissions)
         {
             return (SharedAccessBlobPermissions)permissions;

src/NuGetGallery.Core/Services/ICoreFileStorageService.cs

@@ -120,5 +120,15 @@ Task SetMetadataAsync(
             string folderName,
             string fileName,
             Func<Lazy<Task<Stream>>, IDictionary<string, string>, Task<bool>> updateMetadataAsync);
+
+        /// <summary>
+        /// Returns the etag value for the specified blob. If the blob does not exists it will return null.
+        /// </summary>
+        /// <param name="folderName">The folder name.</param>
+        /// <param name="fileName">The file name.</param>
+        /// <returns>The etag of the specified file.</returns>
+        Task<string> GetETagOrNullAsync(
+            string folderName,
+            string fileName);
     }
 }

src/NuGetGallery/Services/FileSystemFileStorageService.cs

@@ -273,6 +273,13 @@ public static string ResolvePath(string fileStorageDirectory)
             return fileStorageDirectory;
         }
 
+        public Task<string> GetETagOrNullAsync(
+           string folderName,
+           string fileName)
+        {
+            throw new NotImplementedException(nameof(GetETagOrNullAsync));
+        }
+
         private static string GetContentType(string folderName)
         {
             switch (folderName)

tests/NuGetGallery.Core.Facts/Services/CloudBlobCoreFileStorageServiceFacts.cs

@@ -1410,5 +1410,61 @@ await _service.SetMetadataAsync(
                 _blobClient.VerifyAll();
             }
         }
+
+        public class TheGetETagMethod
+        {
+            private const string _etag = "dummy_etag";
+
+            private readonly Mock<ICloudBlobClient> _blobClient;
+            private readonly Mock<ICloudBlobContainer> _blobContainer;
+            private readonly Mock<ISimpleCloudBlob> _blob;
+            private readonly CloudBlobCoreFileStorageService _service;
+
+            public TheGetETagMethod()
+            {
+                _blobClient = new Mock<ICloudBlobClient>();
+                _blobContainer = new Mock<ICloudBlobContainer>();
+                _blob = new Mock<ISimpleCloudBlob>();
+
+                _blobClient.Setup(x => x.GetContainerReference(It.IsAny<string>()))
+                    .Returns(_blobContainer.Object);
+                _blobContainer.Setup(x => x.CreateIfNotExistAsync())
+                    .Returns(Task.FromResult(0));
+                _blobContainer.Setup(x => x.SetPermissionsAsync(It.IsAny<BlobContainerPermissions>()))
+                    .Returns(Task.FromResult(0));
+                _blobContainer.Setup(x => x.GetBlobReference(It.IsAny<string>()))
+                    .Returns(_blob.Object);
+
+                _service = CreateService(fakeBlobClient: _blobClient);
+            }
+
+            [Fact]
+            public async Task VerifyTheETagValue()
+            {
+                // Arrange
+                _blob.SetupGet(x => x.ETag).Returns(_etag);
+
+                // Act 
+                var etagValue = await _service.GetETagOrNullAsync(folderName: CoreConstants.PackagesFolderName, fileName: "a");
+
+                // Assert 
+                Assert.Equal(_etag, etagValue);
+            }
+
+
+            [Fact]
+            public async Task VerifyETagIsNullWhenBlobDoesNotExist()
+            {
+                // Arrange
+                _blob.Setup(x => x.FetchAttributesAsync()).ThrowsAsync(new StorageException("Boo"));
+
+                // Act 
+                var etagValue = await _service.GetETagOrNullAsync(folderName: CoreConstants.PackagesFolderName, fileName: "a");
+
+                // Assert 
+                Assert.Null(etagValue);
+            }
+        }
+
     }
 }