public async Task OverridesDownloadCounts()
            {
                DownloadSetComparer
                .Setup(c => c.Compare(It.IsAny <DownloadData>(), It.IsAny <DownloadData>()))
                .Returns <DownloadData, DownloadData>((oldData, newData) =>
                {
                    return(new SortedDictionary <string, long>(
                               newData.ToDictionary(d => d.Key, d => d.Value.Total),
                               StringComparer.OrdinalIgnoreCase));
                });

                NewDownloadData.SetDownloadCount("A", "1.0.0", 12);
                NewDownloadData.SetDownloadCount("A", "2.0.0", 34);

                NewDownloadData.SetDownloadCount("B", "3.0.0", 5);
                NewDownloadData.SetDownloadCount("B", "4.0.0", 4);

                NewDownloadData.SetDownloadCount("C", "5.0.0", 2);
                NewDownloadData.SetDownloadCount("C", "6.0.0", 3);

                DownloadOverrides["A"] = 55;
                DownloadOverrides["b"] = 66;

                await Target.ExecuteAsync();

                // Documents should have new data with overriden downloads.
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("A", SearchFilters.IncludePrereleaseAndSemVer2, 55),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("B", SearchFilters.IncludePrereleaseAndSemVer2, 66),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("C", SearchFilters.IncludePrereleaseAndSemVer2, 5),
                    Times.Once);

                // Downloads auxiliary file should have new data without overriden downloads.
                DownloadDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <DownloadData>(d =>
                                             d["A"].Total == 46 &&
                                             d["A"]["1.0.0"] == 12 &&
                                             d["A"]["2.0.0"] == 34 &&

                                             d["B"].Total == 9 &&
                                             d["B"]["3.0.0"] == 5 &&
                                             d["B"]["4.0.0"] == 4 &&

                                             d["C"].Total == 5 &&
                                             d["C"]["5.0.0"] == 2 &&
                                             d["C"]["6.0.0"] == 3),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);
            }
            public Facts(ITestOutputHelper output)
            {
                TelemetryService = new Mock <IAzureSearchTelemetryService>();
                Options          = new Mock <IOptionsSnapshot <Auxiliary2AzureSearchConfiguration> >();
                Logger           = output.GetLogger <DownloadSetComparer>();

                Config = new Auxiliary2AzureSearchConfiguration();
                Options.Setup(x => x.Value).Returns(() => Config);

                Target = new DownloadSetComparer(
                    TelemetryService.Object,
                    Options.Object,
                    Logger);
            }
Esempio n. 3
0
            public async Task FlagDisablesPopularityTransfers()
            {
                var downloadChanges = new SortedDictionary <string, long>(StringComparer.OrdinalIgnoreCase)
                {
                    { "Package1", 5 }
                };

                DownloadSetComparer
                .Setup(c => c.Compare(It.IsAny <DownloadData>(), It.IsAny <DownloadData>()))
                .Returns <DownloadData, DownloadData>((oldData, newData) =>
                {
                    return(downloadChanges);
                });

                OldTransfers.AddTransfer("Package1", "Package2");
                NewTransfers.AddTransfer("Package1", "Package2");

                FeatureFlags
                .Setup(x => x.IsPopularityTransferEnabled())
                .Returns(false);

                await Target.ExecuteAsync();

                PopularityTransferDataClient
                .Verify(
                    c => c.ReadLatestIndexedAsync(It.IsAny <IAccessCondition>(), It.IsAny <StringCache>()),
                    Times.Once);
                DatabaseFetcher
                .Verify(
                    d => d.GetPopularityTransfersAsync(),
                    Times.Never);

                // The popularity transfers should not be given to the download transferrer.
                DownloadTransferrer
                .Verify(
                    x => x.UpdateDownloadTransfers(
                        NewDownloadData,
                        downloadChanges,
                        OldTransfers,
                        It.Is <PopularityTransferData>(d => d.Count == 0)),
                    Times.Once);

                // Popularity transfers auxiliary file should be empty.
                PopularityTransferDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <PopularityTransferData>(d => d.Count == 0),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);
            }
            public async Task AlwaysAppliesDownloadOverrides()
            {
                DownloadSetComparer
                .Setup(c => c.Compare(It.IsAny <DownloadData>(), It.IsAny <DownloadData>()))
                .Returns <DownloadData, DownloadData>((oldData, newData) =>
                {
                    var config    = new Auxiliary2AzureSearchConfiguration();
                    var telemetry = Mock.Of <IAzureSearchTelemetryService>();
                    var logger    = Mock.Of <ILogger <DownloadSetComparer> >();
                    var options   = new Mock <IOptionsSnapshot <Auxiliary2AzureSearchConfiguration> >();

                    options.Setup(o => o.Value).Returns(config);

                    return(new DownloadSetComparer(telemetry, options.Object, logger)
                           .Compare(oldData, newData));
                });

                // Download override should be applied even if the package's downloads haven't changed.
                OldDownloadData.SetDownloadCount("A", "1.0.0", 1);
                NewDownloadData.SetDownloadCount("A", "1.0.0", 1);
                DownloadOverrides["A"] = 2;

                await Target.ExecuteAsync();

                // Documents should have new data with overriden downloads.
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("A", SearchFilters.IncludePrereleaseAndSemVer2, 2),
                    Times.Once);

                // Downloads auxiliary file should have new data without overriden downloads.
                DownloadDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <DownloadData>(d =>
                                             d["A"].Total == 1 &&
                                             d["A"]["1.0.0"] == 1),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);
            }
Esempio n. 5
0
            public async Task AppliesTransferChanges()
            {
                var downloadChanges = new SortedDictionary <string, long>(StringComparer.OrdinalIgnoreCase);

                DownloadSetComparer
                .Setup(c => c.Compare(It.IsAny <DownloadData>(), It.IsAny <DownloadData>()))
                .Returns <DownloadData, DownloadData>((oldData, newData) =>
                {
                    return(downloadChanges);
                });

                TransferChanges["Package1"] = 100;
                TransferChanges["Package2"] = 200;

                NewTransfers.AddTransfer("Package1", "Package2");

                await Target.ExecuteAsync();

                PopularityTransferDataClient
                .Verify(
                    c => c.ReadLatestIndexedAsync(
                        It.Is <IAccessCondition>(x => x.IfMatchETag == null && x.IfNoneMatchETag == null),
                        It.IsAny <StringCache>()),
                    Times.Once);
                DatabaseFetcher
                .Verify(
                    d => d.GetPopularityTransfersAsync(),
                    Times.Once);

                DownloadTransferrer
                .Verify(
                    x => x.UpdateDownloadTransfers(
                        NewDownloadData,
                        downloadChanges,
                        OldTransfers,
                        NewTransfers),
                    Times.Once);

                // Documents should be updated.
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("Package1", SearchFilters.IncludePrereleaseAndSemVer2, 100),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("Package2", SearchFilters.IncludePrereleaseAndSemVer2, 200),
                    Times.Once);

                // Downloads auxiliary file should not include transfer changes.
                DownloadDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <DownloadData>(d => d.Count == 0),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);

                // Popularity transfers auxiliary file should have new data.
                PopularityTransferDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <PopularityTransferData>(d =>
                                                       d.Count == 1 &&
                                                       d["Package1"].Count == 1 &&
                                                       d["Package1"].Contains("Package2")),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);
            }
            public async Task DoesNotOverrideIfDownloadsGreaterOrPackageHasNoDownloads()
            {
                DownloadSetComparer
                .Setup(c => c.Compare(It.IsAny <DownloadData>(), It.IsAny <DownloadData>()))
                .Returns <DownloadData, DownloadData>((oldData, newData) =>
                {
                    return(new SortedDictionary <string, long>(
                               newData.ToDictionary(d => d.Key, d => d.Value.Total),
                               StringComparer.OrdinalIgnoreCase));
                });

                NewDownloadData.SetDownloadCount("A", "1.0.0", 100);
                NewDownloadData.SetDownloadCount("A", "2.0.0", 200);

                NewDownloadData.SetDownloadCount("B", "3.0.0", 5);
                NewDownloadData.SetDownloadCount("B", "4.0.0", 4);

                NewDownloadData.SetDownloadCount("C", "5.0.0", 0);

                DownloadOverrides["A"] = 55;
                DownloadOverrides["C"] = 66;
                DownloadOverrides["D"] = 77;

                await Target.ExecuteAsync();

                // Documents should have new data with overriden downloads.
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("A", SearchFilters.IncludePrereleaseAndSemVer2, 300),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("B", SearchFilters.IncludePrereleaseAndSemVer2, 9),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("B", SearchFilters.IncludePrereleaseAndSemVer2, 9),
                    Times.Once);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("C", It.IsAny <SearchFilters>(), It.IsAny <long>()),
                    Times.Never);
                SearchDocumentBuilder
                .Verify(
                    b => b.UpdateDownloadCount("D", It.IsAny <SearchFilters>(), It.IsAny <long>()),
                    Times.Never);

                // Downloads auxiliary file should have new data without overriden downloads.
                DownloadDataClient.Verify(
                    c => c.ReplaceLatestIndexedAsync(
                        It.Is <DownloadData>(d =>
                                             d.Keys.Count() == 2 &&

                                             d["A"].Total == 300 &&
                                             d["A"]["1.0.0"] == 100 &&
                                             d["A"]["2.0.0"] == 200 &&

                                             d["B"].Total == 9 &&
                                             d["B"]["3.0.0"] == 5 &&
                                             d["B"]["4.0.0"] == 4),
                        It.IsAny <IAccessCondition>()),
                    Times.Once);
            }