Disable report download if using a broker but there is no broker data for last 30 days

src/Particular.LicensingComponent.Contracts/UserIndicator.cs

@@ -7,8 +7,7 @@ public enum UserIndicator
 {
     NServiceBusEndpoint,
     NotNServiceBusEndpoint,
-    NServiceBusEndpointSendOnly,
+    SendOnlyOrTransactionSessionEndpoint,
     NServiceBusEndpointNoLongerInUse,
-    TransactionSessionEndpoint,
     PlannedToDecommission
-}
+}

src/Particular.LicensingComponent.UnitTests/Infrastructure/ThroughputCollectorTestFixture.cs

@@ -1,6 +1,7 @@
 namespace Particular.LicensingComponent.UnitTests.Infrastructure
 {
     using System;
+    using System.Linq;
     using System.Threading.Tasks;
     using Contracts;
     using Microsoft.Extensions.DependencyInjection;
@@ -16,21 +17,24 @@ abstract class ThroughputCollectorTestFixture
         [SetUp]
         public virtual Task Setup()
         {
-            configuration = new ThroughputTestsConfiguration();
+            var testMethod = GetType().GetMethod(TestContext.CurrentContext.Test.MethodName);
+            var attribute = testMethod?.GetCustomAttributes(typeof(UseNonBrokerTransportAttribute), false).FirstOrDefault();
 
-            return configuration.Configure(SetThroughputSettings, SetExtraDependencies);
+            return configuration.Configure(SetThroughputSettings, SetExtraDependencies, attribute is not UseNonBrokerTransportAttribute);
         }
 
         [TearDown]
-        public virtual Task Cleanup()
-        {
-            return configuration?.Cleanup();
-        }
+        public virtual Task Cleanup() => configuration?.Cleanup();
 
         protected ILicensingDataStore DataStore => configuration.LicensingDataStore;
 
         protected IThroughputCollector ThroughputCollector => configuration.ThroughputCollector;
 
-        protected ThroughputTestsConfiguration configuration;
+        protected ThroughputTestsConfiguration configuration = new();
+
+        [AttributeUsage(AttributeTargets.Method)]
+        public class UseNonBrokerTransportAttribute : Attribute
+        {
+        }
     }
 }

src/Particular.LicensingComponent.UnitTests/Infrastructure/ThroughputTestsConfiguration.cs

@@ -19,8 +19,10 @@ class ThroughputTestsConfiguration
     public IAuditQuery AuditQuery { get; protected set; }
     public MonitoringService MonitoringService { get; protected set; }
 
-    public Task Configure(Action<ThroughputSettings> setThroughputSettings,
-        Action<ServiceCollection> setExtraDependencies)
+    public Task Configure(
+        Action<ThroughputSettings> setThroughputSettings,
+        Action<ServiceCollection> setExtraDependencies,
+        bool useBrokerTransport)
     {
         var throughputSettings = new ThroughputSettings("Particular.ServiceControl", "error", "Learning",
             "TestCustomer", "5.0.1");
@@ -39,7 +41,12 @@ public Task Configure(Action<ThroughputSettings> setThroughputSettings,
         serviceCollection.AddSingleton<IAuditCountApi, FakeAuditCountApi>();
         serviceCollection.AddSingleton<IConfigurationApi, FakeConfigurationApi>();
         serviceCollection.AddSingleton<IThroughputCollector, ThroughputCollector>();
-        serviceCollection.AddSingleton<IBrokerThroughputQuery, FakeBrokerThroughputQuery>();
+
+        if (useBrokerTransport)
+        {
+            serviceCollection.AddSingleton<IBrokerThroughputQuery, FakeBrokerThroughputQuery>();
+        }
+
         serviceCollection.AddSingleton<IAuditQuery, AuditQuery>();
         serviceCollection.AddSingleton<MonitoringService>();
 

src/Particular.LicensingComponent.UnitTests/ThroughputCollector/ThroughputCollector_GenerationStatus_Tests.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using Particular.LicensingComponent.Contracts;
 using Particular.LicensingComponent.UnitTests.Infrastructure;
 
 [TestFixture]
@@ -15,30 +16,29 @@ public override Task Setup()
         return base.Setup();
     }
 
-    [Test]
-    public async Task Should_return_ReportCanBeGenerated_false_when_no_throughput_for_last_30_days()
+    [Test, UseNonBrokerTransport]
+    public async Task Should_return_ReportCanBeGenerated_true_when_not_using_broker_and_no_broker_throughput_for_last_30_days()
     {
         // Arrange
         await DataStore.CreateBuilder()
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-32), days: 2)
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-32), days: 2)
+            .AddEndpoint(sources: [ThroughputSource.Audit]).WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-2), days: 2)
             .Build();
 
         // Act
         var reportGenerationState = await ThroughputCollector.GetReportGenerationState(default);
 
         // Assert
-        Assert.That(reportGenerationState.ReportCanBeGenerated, Is.False);
-        Assert.That(reportGenerationState.Reason.Contains("24"), Is.True);
+        Assert.That(reportGenerationState.ReportCanBeGenerated, Is.True);
+        Assert.That(reportGenerationState.Reason, Is.EqualTo(""));
     }
 
+
     [Test]
-    public async Task Should_return_ReportCanBeGenerated_true_when_there_is_throughput_for_last_30_days()
+    public async Task Should_return_ReportCanBeGenerated_true_when_using_broker_and_there_is_broker_throughput_for_last_30_days()
     {
         // Arrange
         await DataStore.CreateBuilder()
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-2), days: 2)
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-2), days: 2)
+            .AddEndpoint().WithThroughput(source: ThroughputSource.Broker, startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-2), days: 2)
             .Build();
 
         // Act
@@ -50,18 +50,39 @@ await DataStore.CreateBuilder()
     }
 
     [Test]
-    public async Task Should_return_ReportCanBeGenerated_false_when_throughput_exists_only_for_today()
+    public async Task Should_return_ReportCanBeGenerated_false_when_using_broker_and_no_broker_throughput_for_last_30_days()
     {
         // Arrange
         await DataStore.CreateBuilder()
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow))
-            .AddEndpoint().WithThroughput(startDate: DateOnly.FromDateTime(DateTime.UtcNow))
+            .AddEndpoint()
+            .WithThroughput(source: ThroughputSource.Broker, startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-32), days: 2)
+            .WithThroughput(source: ThroughputSource.Audit, startDate: DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-2), days: 2)
+            .Build();
+
+        // Act
+        var reportGenerationState = await ThroughputCollector.GetReportGenerationState(default);
+
+        // Assert
+        Assert.That(reportGenerationState.ReportCanBeGenerated, Is.False);
+        Assert.That(reportGenerationState.Reason.Contains("one day"), Is.True, "Report generation failure reason does not contain 'one day'");
+        Assert.That(reportGenerationState.Reason.Contains("broker"), Is.True, "Report generation failure reason does not contain 'broker'");
+    }
+
+    [Test]
+    public async Task Should_return_ReportCanBeGenerated_false_when_throughput_exists_only_for_today()
+    {
+        // Arrange
+        await DataStore.CreateBuilder().AddEndpoint()
+            .WithThroughput(source: ThroughputSource.Broker, startDate: DateOnly.FromDateTime(DateTime.UtcNow))
+            .WithThroughput(source: ThroughputSource.Audit, startDate: DateOnly.FromDateTime(DateTime.UtcNow))
             .Build();
 
         // Act
         var reportGenerationState = await ThroughputCollector.GetReportGenerationState(default);
 
         // Assert
         Assert.That(reportGenerationState.ReportCanBeGenerated, Is.False);
+        Assert.That(reportGenerationState.Reason.Contains("one day"), Is.True, "Report generation failure reason does not contain 'one day'");
+        Assert.That(reportGenerationState.Reason.Contains("broker"), Is.True, "Report generation failure reason does not contain 'broker'");
     }
 }

src/Particular.LicensingComponent.UnitTests/ThroughputCollector/ThroughputCollector_Report_Indicator_Tests.cs

@@ -47,7 +47,7 @@ public async Task Should_return_correct_user_indicators_when_multiple_throughput
         await DataStore.CreateBuilder()
             .AddEndpoint("Endpoint1", sources: [ThroughputSource.Broker, ThroughputSource.Monitoring])
             .ConfigureEndpoint(ThroughputSource.Broker,
-                endpoint => endpoint.UserIndicator = UserIndicator.TransactionSessionEndpoint.ToString())
+                endpoint => endpoint.UserIndicator = UserIndicator.SendOnlyOrTransactionSessionEndpoint.ToString())
             .WithThroughput(ThroughputSource.Broker, days: 2)
             .WithThroughput(ThroughputSource.Monitoring, days: 2)
             .Build();
@@ -60,6 +60,6 @@ await DataStore.CreateBuilder()
         Assert.That(report.ReportData.Queues.Length, Is.EqualTo(1));
 
         Assert.That(report.ReportData.Queues[0].UserIndicator,
-            Is.EqualTo(UserIndicator.TransactionSessionEndpoint.ToString()));
+            Is.EqualTo(UserIndicator.SendOnlyOrTransactionSessionEndpoint.ToString()));
     }
 }

src/Particular.LicensingComponent.UnitTests/ThroughputCollector/ThroughputCollector_Report_Throughput_Tests.cs

@@ -60,7 +60,7 @@ await DataStore.CreateBuilder()
             .WithThroughput(days: 2)
             .AddEndpoint("Endpoint3", sources: [ThroughputSource.Broker])
             .ConfigureEndpoint(
-                endpoint => endpoint.UserIndicator = UserIndicator.NServiceBusEndpointSendOnly.ToString())
+                endpoint => endpoint.UserIndicator = UserIndicator.SendOnlyOrTransactionSessionEndpoint.ToString())
             .WithThroughput(days: 2)
             .AddEndpoint("Endpoint4", sources: [ThroughputSource.Broker])
             .ConfigureEndpoint(endpoint => endpoint.UserIndicator = UserIndicator.PlannedToDecommission.ToString())

src/Particular.LicensingComponent/ThroughputCollector.cs

@@ -89,19 +89,33 @@ public async Task<List<EndpointThroughputSummary>> GetThroughputSummary(Cancella
         return endpointSummaries;
     }
 
-    public async Task<ReportGenerationState> GetReportGenerationState(CancellationToken cancellationToken)
+    public async Task<ReportGenerationState> GetReportGenerationState(CancellationToken cancellationToken) =>
+        throughputQuery == null ?
+            await GetReportGenerationStateForNonBroker(cancellationToken) :
+            await GetReportGenerationStateForBroker(cancellationToken);
+
+    async Task<ReportGenerationState> GetReportGenerationStateForBroker(CancellationToken cancellationToken)
     {
-        var reportGenerationState = new ReportGenerationState(transport)
+        var reportCanBeGenerated = await dataStore.IsThereThroughputForLastXDaysForSource(30, ThroughputSource.Broker, false, cancellationToken);
+        var reason = reportCanBeGenerated ? string.Empty : "Need at least one day of usage data in the last 30 days from the configured broker.";
+
+        return new ReportGenerationState(transport)
         {
-            ReportCanBeGenerated = await dataStore.IsThereThroughputForLastXDays(30, cancellationToken)
+            ReportCanBeGenerated = reportCanBeGenerated,
+            Reason = reason
         };
+    }
 
-        if (!reportGenerationState.ReportCanBeGenerated)
-        {
-            reportGenerationState.Reason = "24 hours worth of data needs to exist in the last 30 days.";
-        }
+    async Task<ReportGenerationState> GetReportGenerationStateForNonBroker(CancellationToken cancellationToken)
+    {
+        var reportCanBeGenerated = await dataStore.IsThereThroughputForLastXDays(30, cancellationToken);
+        var reason = reportCanBeGenerated ? string.Empty : $"Need at least one day of usage data in the last 30 days.";
 
-        return reportGenerationState;
+        return new ReportGenerationState(transport)
+        {
+            ReportCanBeGenerated = reportCanBeGenerated,
+            Reason = reason
+        };
     }
 
     public async Task<SignedReport> GenerateThroughputReport(string spVersion, DateTime? reportEndDate, CancellationToken cancellationToken)