public async Task GetAllVersionsAsync_ThrowIfCancelledAsync()
 {
     using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
     {
         await Assert.ThrowsAsync <OperationCanceledException>(
             () => test.Resource.GetAllVersionsAsync(
                 test.PackageIdentity.Id,
                 test.SourceCacheContext,
                 NullLogger.Instance,
                 new CancellationToken(canceled: true)));
     }
 }
        public async Task GetAllVersionsAsync_ReturnsEmptyEnumerableIfPackageIdNotFoundAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var versions = await test.Resource.GetAllVersionsAsync(
                    id : "b",
                    cacheContext : test.SourceCacheContext,
                    logger : NullLogger.Instance,
                    cancellationToken : CancellationToken.None);

                Assert.Empty(versions);
            }
        }
        public async Task GetPackageDownloaderAsync_ReturnsPackageDownloaderIfPackageFoundAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var downloader = await test.Resource.GetPackageDownloaderAsync(
                    test.PackageIdentity,
                    test.SourceCacheContext,
                    NullLogger.Instance,
                    CancellationToken.None);

                Assert.IsType <LocalPackageArchiveDownloader>(downloader);
            }
        }
        public async Task GetAllVersionsAsync_ReturnsAllVersionsAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var versions = await test.Resource.GetAllVersionsAsync(
                    test.PackageIdentity.Id,
                    test.SourceCacheContext,
                    NullLogger.Instance,
                    CancellationToken.None);

                Assert.Equal(new[] { NuGetVersion.Parse("1.0.0") }, versions);
            }
        }
        public async Task GetPackageDownloaderAsync_ReturnsNullIfPackageNotFoundAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var downloader = await test.Resource.GetPackageDownloaderAsync(
                    new PackageIdentity(id : "b", version : NuGetVersion.Parse("1.0.0")),
                    test.SourceCacheContext,
                    NullLogger.Instance,
                    CancellationToken.None);

                Assert.Null(downloader);
            }
        }
        public async Task GetAllVersionsAsync_ThrowsForNullLoggerAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentNullException>(
                    () => test.Resource.GetAllVersionsAsync(
                        test.PackageIdentity.Id,
                        test.SourceCacheContext,
                        logger: null,
                        cancellationToken: CancellationToken.None));

                Assert.Equal("logger", exception.ParamName);
            }
        }
        public async Task GetPackageDownloaderAsync_ThrowsForNullSourceCacheContextAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentNullException>(
                    () => test.Resource.GetPackageDownloaderAsync(
                        test.PackageIdentity,
                        cacheContext: null,
                        logger: NullLogger.Instance,
                        cancellationToken: CancellationToken.None));

                Assert.Equal("cacheContext", exception.ParamName);
            }
        }
        public async Task GetAllVersionsAsync_ThrowsForNullOrEmptyIdAsync(string id)
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentException>(
                    () => test.Resource.GetAllVersionsAsync(
                        id,
                        test.SourceCacheContext,
                        NullLogger.Instance,
                        CancellationToken.None));

                Assert.Equal("id", exception.ParamName);
            }
        }
        public async Task GetDependencyInfoAsync_ReturnsNullIfPackageNotFoundAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var dependencyInfo = await test.Resource.GetDependencyInfoAsync(
                    id : "b",
                    version : NuGetVersion.Parse("1.0.0"),
                    cacheContext : test.SourceCacheContext,
                    logger : NullLogger.Instance,
                    cancellationToken : CancellationToken.None);

                Assert.Null(dependencyInfo);
            }
        }
        public async Task GetDependencyInfoAsync_GetsOriginalIdentityAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var info = await test.Resource.GetDependencyInfoAsync(
                    test.PackageIdentity.Id.ToUpper(),
                    test.PackageIdentity.Version,
                    test.SourceCacheContext,
                    NullLogger.Instance,
                    CancellationToken.None);

                Assert.Equal(test.PackageIdentity.Id.ToLower(), info.PackageIdentity.Id);
                Assert.Equal(test.PackageIdentity.Version, info.PackageIdentity.Version);
            }
        }
        public async Task GetDependencyInfoAsync_ThrowsForNullVersionAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentNullException>(
                    () => test.Resource.GetDependencyInfoAsync(
                        test.PackageIdentity.Id,
                        version: null,
                        cacheContext: null,
                        logger: NullLogger.Instance,
                        cancellationToken: CancellationToken.None));

                Assert.Equal("version", exception.ParamName);
            }
        }
        public async Task CopyNupkgToStreamAsync_ThrowsForNullDestinationAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentNullException>(
                    () => test.Resource.CopyNupkgToStreamAsync(
                        test.PackageIdentity.Id,
                        test.PackageIdentity.Version,
                        destination: null,
                        cacheContext: test.SourceCacheContext,
                        logger: NullLogger.Instance,
                        cancellationToken: CancellationToken.None));

                Assert.Equal("destination", exception.ParamName);
            }
        }
        public async Task CopyNupkgToStreamAsync_ThrowsForNullIdAsync(string id)
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
            {
                var exception = await Assert.ThrowsAsync <ArgumentException>(
                    () => test.Resource.CopyNupkgToStreamAsync(
                        id,
                        NuGetVersion.Parse("1.0.0"),
                        Stream.Null,
                        test.SourceCacheContext,
                        NullLogger.Instance,
                        CancellationToken.None));

                Assert.Equal("id", exception.ParamName);
            }
        }
        public async Task CopyNupkgToStreamAsync_ReturnsTrueIfCopiedAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
                using (var stream = new MemoryStream())
                {
                    var wasCopied = await test.Resource.CopyNupkgToStreamAsync(
                        test.PackageIdentity.Id,
                        test.PackageIdentity.Version,
                        stream,
                        test.SourceCacheContext,
                        NullLogger.Instance,
                        CancellationToken.None);

                    Assert.True(wasCopied);
                    Assert.Equal(test.Package.Length, stream.Length);
                }
        }
        public async Task CopyNupkgToStreamAsync_ReturnsFalseIfNotCopiedAsync()
        {
            using (var test = await LocalV2FindPackageByIdResourceTest.CreateAsync())
                using (var stream = new MemoryStream())
                {
                    var wasCopied = await test.Resource.CopyNupkgToStreamAsync(
                        id : "b",
                        version : NuGetVersion.Parse("1.0.0"),
                        destination : stream,
                        cacheContext : test.SourceCacheContext,
                        logger : NullLogger.Instance,
                        cancellationToken : CancellationToken.None);

                    Assert.False(wasCopied);
                    Assert.Equal(0, stream.Length);
                }
        }