[SAS Token] Create get only uri methods for files. (#8424)

* support for returning only file uri and refactor of GetBlobForUriAsync.

* GetPackageUriAsync test cases.

* nit.

Author: Daniel Jacinto

src/NuGetGallery.Core/Services/CloudBlobCoreFileStorageService.cs

@@ -368,13 +368,25 @@ public async Task SaveFileAsync(string folderName, string fileName, Stream file,
             await blob.SetPropertiesAsync();
         }
 
+        public async Task<Uri> GetFileUriAsync(string folderName, string fileName)
+        {
+            var blob = await GetBlobForUriAsync(folderName, fileName);
+
+            return blob.Uri;
+        }
+
         public async Task<Uri> GetPriviledgedFileUriAsync(
             string folderName,
             string fileName,
             FileUriPermissions permissions,
             DateTimeOffset endOfAccess)
         {
-            var blob = await GetBlobForUriAsync(folderName, fileName, endOfAccess);
+            if (endOfAccess < DateTimeOffset.UtcNow)
+            {
+                throw new ArgumentOutOfRangeException(nameof(endOfAccess), $"{nameof(endOfAccess)} is in the past");
+            }
+
+            var blob = await GetBlobForUriAsync(folderName, fileName);
 
             return new Uri(
                 blob.Uri,
@@ -383,13 +395,23 @@ public async Task<Uri> GetPriviledgedFileUriAsync(
 
         public async Task<Uri> GetFileReadUriAsync(string folderName, string fileName, DateTimeOffset? endOfAccess)
         {
-            var blob = await GetBlobForUriAsync(folderName, fileName, endOfAccess);
+            var blob = await GetBlobForUriAsync(folderName, fileName);
 
             if (IsPublicContainer(folderName))
             {
                 return blob.Uri;
             }
 
+            if (!endOfAccess.HasValue)
+            {
+                throw new ArgumentNullException(nameof(endOfAccess), $"{nameof(endOfAccess)} must not be null for non-public containers");
+            }
+
+            if (endOfAccess < DateTimeOffset.UtcNow)
+            {
+                throw new ArgumentOutOfRangeException(nameof(endOfAccess), $"{nameof(endOfAccess)} is in the past");
+            }
+
             return new Uri(
                 blob.Uri,
                 blob.GetSharedAccessSignature(SharedAccessBlobPermissions.Read, endOfAccess));
@@ -519,20 +541,11 @@ private static SharedAccessBlobPermissions MapFileUriPermissions(FileUriPermissi
             return (SharedAccessBlobPermissions)permissions;
         }
 
-        private async Task<ISimpleCloudBlob> GetBlobForUriAsync(string folderName, string fileName, DateTimeOffset? endOfAccess)
+        private async Task<ISimpleCloudBlob> GetBlobForUriAsync(string folderName, string fileName)
         {
             folderName = folderName ?? throw new ArgumentNullException(nameof(folderName));
             fileName = fileName ?? throw new ArgumentNullException(nameof(fileName));
-            if (endOfAccess.HasValue && endOfAccess < DateTimeOffset.UtcNow)
-            {
-                throw new ArgumentOutOfRangeException(nameof(endOfAccess), $"{nameof(endOfAccess)} is in the past");
-            }
-
-            if (!IsPublicContainer(folderName) && endOfAccess == null)
-            {
-                throw new ArgumentNullException(nameof(endOfAccess), $"{nameof(endOfAccess)} must not be null for non-public containers");
-            }
-
+            
             ICloudBlobContainer container = await GetContainerAsync(folderName);
 
             return container.GetBlobReference(fileName);

src/NuGetGallery.Core/Services/CorePackageFileService.cs

@@ -44,6 +44,12 @@ public Task<Stream> DownloadPackageFileAsync(Package package)
             return _fileStorageService.GetFileAsync(_metadata.FileFolderName, fileName);
         }
 
+        public Task<Uri> GetPackageUriAsync(Package package)
+        {
+            var fileName = FileNameHelper.BuildFileName(package, _metadata.FileSavePathTemplate, _metadata.FileExtension);
+            return _fileStorageService.GetFileUriAsync(_metadata.FileFolderName, fileName);
+        }
+
         public Task<Uri> GetPackageReadUriAsync(Package package)
         {
             var fileName = FileNameHelper.BuildFileName(package, _metadata.FileSavePathTemplate, _metadata.FileExtension);

src/NuGetGallery.Core/Services/ICoreFileStorageService.cs

@@ -25,6 +25,14 @@ public interface ICoreFileStorageService
         /// <param name="ifNoneMatch">The <see cref="IFileReference.ContentId"/> value to use in an If-None-Match request</param>
         /// <returns>A <see cref="IFileReference"/> representing the file reference</returns>
         Task<IFileReference> GetFileReferenceAsync(string folderName, string fileName, string ifNoneMatch = null);
+        
+        /// <summary>
+        /// Gets a file URI.
+        /// </summary>
+        /// <param name="folderName">The folder containing the file.</param>
+        /// <param name="fileName">The file within the <paramref name="folderName"/>.</param>
+        /// <returns>A <see cref="Uri"/> for the specified file.</returns>
+        Task<Uri> GetFileUriAsync(string folderName, string fileName);
 
         /// <summary>
         /// Generates the storage file URI (which is optionally time limited)

src/NuGetGallery.Core/Services/ICorePackageFileService.cs

@@ -25,6 +25,13 @@ public interface ICorePackageFileService
         /// </summary>
         Task<Stream> DownloadPackageFileAsync(Package package);
 
+        /// <summary>
+        /// Generates the URL for the specified package.
+        /// </summary>
+        /// <param name="package">The package metadata.</param>
+        /// <returns>Package URL</returns>
+        Task<Uri> GetPackageUriAsync(Package package);
+
         /// <summary>
         /// Generates the URL for the specified package in the public container for available packages.
         /// </summary>

src/NuGetGallery/Services/FileSystemFileStorageService.cs

@@ -237,6 +237,12 @@ public Task<bool> IsAvailableAsync()
             return Task.FromResult(Directory.Exists(_configuration.FileStorageDirectory));
         }
 
+        public Task<Uri> GetFileUriAsync(string folderName, string fileName)
+        {
+            /// Not implemented for the same reason as <see cref="GetFileReadUriAsync(string, string, DateTimeOffset?)"/>.
+            throw new NotImplementedException();
+        }
+
         public Task<Uri> GetFileReadUriAsync(string folderName, string fileName, DateTimeOffset? endOfAccess)
         {
             // technically, we would be able to generate the file:/// url here, but we don't need it right now

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

@@ -673,6 +673,64 @@ public async Task WillSetTheBlobContentType(string folderName)
             }
         }
 
+        public class TheGetFileUriAsyncMethod
+        {
+            private const string folderName = "theFolderName";
+            private const string fileName = "theFileName";
+
+            [Fact]
+            public async Task WillThrowIfFolderIsNull()
+            {
+                var service = CreateService();
+
+                var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetFileUriAsync(null, fileName));
+                Assert.Equal("folderName", ex.ParamName);
+            }
+
+            [Fact]
+            public async Task WillThrowIfFilenameIsNull()
+            {
+                var service = CreateService();
+
+                var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetFileUriAsync(folderName, null));
+                Assert.Equal("fileName", ex.ParamName);
+            }
+
+            [Fact]
+            public async Task WillAlwaysReturnValidUri()
+            {
+                var containerName = CoreConstants.Folders.ValidationFolderName;
+                var expectedUri = $"http://example.com/{CoreConstants.Folders.ValidationFolderName}/{fileName}";
+
+                var setupResult = Setup(containerName, fileName);
+                var fakeBlobClient = setupResult.Item1;
+
+                var service = CreateService(fakeBlobClient);
+
+                var uri = await service.GetFileUriAsync(containerName, fileName);
+
+                Assert.Equal(expectedUri, uri.AbsoluteUri);
+            }
+
+            private static Tuple<Mock<ICloudBlobClient>, Mock<ISimpleCloudBlob>, Uri> Setup(string folderName, string fileName)
+            {
+                var fakeBlobClient = new Mock<ICloudBlobClient>();
+                var fakeContainer = new Mock<ICloudBlobContainer>();
+                fakeBlobClient
+                    .Setup(bc => bc.GetContainerReference(folderName))
+                    .Returns(fakeContainer.Object)
+                    .Callback(() => { int i = 0; i = i + 1; });
+                var fakeBlob = new Mock<ISimpleCloudBlob>();
+                fakeContainer.Setup(c => c.GetBlobReference(fileName)).Returns(fakeBlob.Object);
+
+                var blobUri = new Uri($"http://example.com/{folderName}/{fileName}");
+
+                fakeBlob.SetupGet(b => b.Uri).Returns(blobUri);
+
+                return Tuple.Create(fakeBlobClient, fakeBlob, blobUri);
+            }
+        }
+
         public class TheGetPriviledgedFileUriAsyncMethod
         {
             private const string folderName = "theFolderName";
@@ -824,12 +882,18 @@ public async Task WillThrowIfFilenameIsNull()
             }
 
             [Fact]
-            public async Task WillThrowIfEndOfAccessIsInThePast()
+            public async Task WillThrowIfEndOfAccessIsInThePastForNonPublicContainer()
             {
-                var service = CreateService();
-
+                var setupResult = Setup(folderName, fileName);
+                var fakeFolderInformationProvider = new Mock<ICloudBlobContainerInformationProvider>();
+                fakeFolderInformationProvider
+                    .Setup(fip => fip.IsPublicContainer(It.IsAny<string>()))
+                    .Returns(false);
+                var service = CreateService(setupResult.Item1, fakeFolderInformationProvider);
                 DateTimeOffset inThePast = DateTimeOffset.UtcNow.AddSeconds(-1);
+                
                 var ex = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => service.GetFileReadUriAsync(folderName, fileName, inThePast));
+                
                 Assert.Equal("endOfAccess", ex.ParamName);
             }
 
@@ -863,11 +927,12 @@ public async Task WillUseSasTokenDependingOnContainerAvailability(bool isPublicC
             [Fact]
             public async Task WillThrowIfNoEndOfAccessSpecifiedForNonPublicContainer()
             {
+                var setupResult = Setup(CoreConstants.Folders.ValidationFolderName, fileName);
                 var fakeFolderInformationProvider = new Mock<ICloudBlobContainerInformationProvider>();
                 fakeFolderInformationProvider
                     .Setup(fip => fip.IsPublicContainer(It.IsAny<string>()))
                     .Returns(false);
-                var service = CreateService(fakeFolderInformationProvider: fakeFolderInformationProvider);
+                var service = CreateService(setupResult.Item1, fakeFolderInformationProvider);
 
                 var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetFileReadUriAsync(CoreConstants.Folders.ValidationFolderName, fileName, null));
                 Assert.Equal("endOfAccess", ex.ParamName);
@@ -1596,6 +1661,5 @@ public async Task VerifyETagIsNullWhenBlobDoesNotExist()
                 Assert.Null(etagValue);
             }
         }
-
     }
 }

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

@@ -419,6 +419,31 @@ public async Task WillUseTheFileStorageService()
             }
         }
 
+        public class TheGetPackageUriMethod : FactsBase
+        {
+            [Fact]
+            public async Task WillThrowIfPackageIsNull()
+            {
+                var ex = await Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetPackageUriAsync(null));
+                Assert.Equal("package", ex.ParamName);
+            }
+
+            [Fact]
+            public async Task WillUseFileStorageService()
+            {
+                await _service.GetPackageUriAsync(_package);
+
+                string filename = BuildFileName(_package.PackageRegistration.Id, _package.NormalizedVersion, CoreConstants.NuGetPackageFileExtension, CoreConstants.PackageFileSavePathTemplate);
+
+                _fileStorageService.Verify(
+                    x => x.GetFileUriAsync(PackagesFolderName, filename),
+                    Times.Once());
+                _fileStorageService.Verify(
+                    x => x.GetFileUriAsync(It.IsAny<string>(), It.IsAny<string>()),
+                    Times.Once());
+            }
+        }
+
         public class TheGetPackageReadUriMethod : FactsBase
         {
             [Fact]