Example #1
0
        public async Task OnPublishIntegrityCheck_SmokeTestsSucceeds()
        {
            OnPublishIntegrityCheck onPublishIntegrityCheck = new OnPublishIntegrityCheck(_logger,
                                                                                          _publishIntegrityCheckService,
                                                                                          Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                          _userProfileProvider,
                                                                                          IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.PublishIntegrityCheck,
                                                        async(Message smokeResponse) => await onPublishIntegrityCheck.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #2
0
        public async Task OnRunSqlImport_SmokeTestSucceeds()
        {
            OnRunSqlImport onRunSqlImport = new OnRunSqlImport(_logger,
                                                               _sqlImportService,
                                                               Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                               _userProfileProvider,
                                                               IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.PublishingRunSqlImport,
                                                        async(Message smokeResponse) => await onRunSqlImport.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnTestExecution_SmokeTestSucceeds()
        {
            OnTestExecution onTestExecution = new OnTestExecution(_logger,
                                                                  _testEngineService,
                                                                  Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                  _userProfileProvider,
                                                                  IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.TestEngineExecuteTests,
                                                        async(Message smokeResponse) => await onTestExecution.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
Example #4
0
        public async Task OnCalcsInstructAllocationResults_SmokeTestSucceeds()
        {
            OnCalcsInstructAllocationResults onCalcsInstructAllocationResults = new OnCalcsInstructAllocationResults(_logger,
                                                                                                                     _buildProjectsService,
                                                                                                                     Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                     _userProfileProvider,
                                                                                                                     IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.CalculationJobInitialiser,
                                                        async(Message smokeResponse) => await onCalcsInstructAllocationResults.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #5
0
        public async Task CalcsAddRelationshipToBuildProject_SmokeTestSucceeds()
        {
            CalcsAddRelationshipToBuildProject calcsAddRelationshipToBuildProject = new CalcsAddRelationshipToBuildProject(_logger,
                                                                                                                           _buildProjectsService,
                                                                                                                           Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                           _userProfileProvider,
                                                                                                                           IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.UpdateBuildProjectRelationships,
                                                        async(Message smokeResponse) => await calcsAddRelationshipToBuildProject.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
Example #6
0
        public async Task OnApproveBatchProviderFunding_SmokeTestSucceeds()
        {
            OnApproveBatchProviderFunding onApproveProviderFunding = new OnApproveBatchProviderFunding(_logger,
                                                                                                       _approveService,
                                                                                                       Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                       _userProfileProvider,
                                                                                                       IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.PublishingApproveBatchProviderFunding,
                                                        async(Message smokeResponse) => await onApproveProviderFunding.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #7
0
        public async Task OnDatasetValidationEventFired_SmokeTestSucceeds()
        {
            OnDatasetValidationEvent onDatasetValidationEvent = new OnDatasetValidationEvent(_logger,
                                                                                             _datasetService,
                                                                                             Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                             _userProfileProvider,
                                                                                             IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.ValidateDataset,
                                                        async(Message smokeResponse) => await onDatasetValidationEvent.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnReIndexTemplates_SmokeTestSucceeds()
        {
            OnReIndexTemplates onReIndexTemplates = new OnReIndexTemplates(_logger,
                                                                           _templatesReIndexerService,
                                                                           Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                           _userProfileProvider,
                                                                           IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.PolicyReIndexTemplates,
                                                        async(Message smokeResponse) => await onReIndexTemplates.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnReIndexSpecification_SmokeTestSucceeds()
        {
            OnReIndexSpecification onReIndexSpecifications = new OnReIndexSpecification(_logger,
                                                                                        _specificationIndexerService,
                                                                                        Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                        _userProfileProvider,
                                                                                        IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.ReIndexSingleSpecification,
                                                        async(Message smokeResponse) => await onReIndexSpecifications.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnMergeSpecificationInformationForProviderWithResults_SmokeTestSucceeds()
        {
            OnMergeSpecificationInformationForProviderWithResults onReIndexCalculationResults = new OnMergeSpecificationInformationForProviderWithResults(_logger,
                                                                                                                                                          _providerResultsService,
                                                                                                                                                          Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                                                          _userProfileProvider,
                                                                                                                                                          IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.MergeSpecificationInformationForProvider,
                                                        async(Message smokeResponse) => await onReIndexCalculationResults.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnCalculationResultsCsvGeneration_SmokeTestSucceeds()
        {
            OnCalculationResultsCsvGeneration onCalculationResultsCsvGeneration = new OnCalculationResultsCsvGeneration(_logger,
                                                                                                                        _providerResultsCsvGeneratorService,
                                                                                                                        Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                        _userProfileProvider,
                                                                                                                        IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.CalculationResultsCsvGeneration,
                                                        async(Message smokeResponse) => await onCalculationResultsCsvGeneration.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnAddRelationshipEvent_SmokeTestSucceeds()
        {
            OnAddRelationshipEvent onAddRelationshipEvent = new OnAddRelationshipEvent(_logger,
                                                                                       _specificationsService,
                                                                                       Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                       _userProfileProvider,
                                                                                       IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.AddDefinitionRelationshipToSpecification,
                                                        async(Message smokeResponse) => await onAddRelationshipEvent.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnDeleteSpecifications_SmokeTestSucceeds()
        {
            OnDeleteSpecifications onDeleteSpecifications = new OnDeleteSpecifications(_logger,
                                                                                       _specificationsService,
                                                                                       Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                       _userProfileProvider,
                                                                                       IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.DeleteSpecifications,
                                                        async(Message smokeResponse) => await onDeleteSpecifications.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
Example #14
0
        public async Task OnProviderSnapshotDataLoadEvent_SmokeTestSucceeds()
        {
            OnProviderSnapshotDataLoadEventTrigger onProviderSnapshotDataLoadEventTrigger = new OnProviderSnapshotDataLoadEventTrigger(_logger,
                                                                                                                                       Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                                       _userProfileProvider,
                                                                                                                                       _providerSnapshotDataLoadService,
                                                                                                                                       IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.ProviderSnapshotDataLoad,
                                                        async(Message smokeResponse) => await onProviderSnapshotDataLoadEventTrigger.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #15
0
        public async Task OnApplyTemplateCalculations_SmokeTestSucceeds()
        {
            OnApplyTemplateCalculations onApplyTemplateCalculations = new OnApplyTemplateCalculations(_logger,
                                                                                                      _applyTemplateCalculationsService,
                                                                                                      Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                      _userProfileProvider,
                                                                                                      IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.ApplyTemplateCalculations,
                                                        async(Message smokeResponse) => await onApplyTemplateCalculations.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #16
0
        public async Task OnPopulateScopedProvidersEvent_SmokeTestSucceeds()
        {
            OnPopulateScopedProvidersEventTrigger onPopulateScopedProvidersEventTrigger = new OnPopulateScopedProvidersEventTrigger(_logger,
                                                                                                                                    _scopedProvidersService,
                                                                                                                                    Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                                    _userProfileProvider,
                                                                                                                                    IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.PopulateScopedProviders,
                                                        async(Message smokeResponse) => await onPopulateScopedProvidersEventTrigger.Run(smokeResponse));

            response
            .Should()
            .NotBeNull();
        }
Example #17
0
        public async Task OnMapFdzDatasetsEventFired_SmokeTestSucceeds()
        {
            OnMapFdzDatasetsEventFired onMapFdzDatasetsEventFired = new OnMapFdzDatasetsEventFired(_logger,
                                                                                                   _processDatasetService,
                                                                                                   Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                   _userProfileProvider,
                                                                                                   IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.QueueNames.MapFdzDatasets,
                                                        async(Message smokeResponse) => await onMapFdzDatasetsEventFired.Run(smokeResponse), useSession : true);

            response
            .Should()
            .NotBeNull();
        }
Example #18
0
        public async Task OnCalculationAggregationsJobCompleted_SmokeTestSucceeds()
        {
            OnCalculationAggregationsJobCompleted onCalculationAggregationsJobCompleted = new OnCalculationAggregationsJobCompleted(_logger,
                                                                                                                                    _jobService,
                                                                                                                                    Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                                    _userProfileProvider,
                                                                                                                                    IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.CreateInstructAllocationsJob,
                                                        async(Message smokeResponse) => await onCalculationAggregationsJobCompleted.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.JobNotifications);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnProviderResultsSpecificationCleanup_SmokeTestSucceeds()
        {
            OnProviderResultsSpecificationCleanup onProviderResultsSpecificationCleanup = new OnProviderResultsSpecificationCleanup(_logger,
                                                                                                                                    _resultsService,
                                                                                                                                    Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                                                    _userProfileProvider,
                                                                                                                                    IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.CleanupCalculationResultsForSpecificationProviders,
                                                        async(Message smokeResponse) => await onProviderResultsSpecificationCleanup.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.ProviderSourceDatasetCleanup);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnNotoficationEventTriggered_SmokeTestSucceeds()
        {
            OnNotificationEventTrigger onNotificationEventTrigger = new OnNotificationEventTrigger(_logger,
                                                                                                   _notificationService,
                                                                                                   Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                   _userProfileProvider,
                                                                                                   IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.JobNotificationsToSignalR,
                                                        async(Message smokeResponse) => await onNotificationEventTrigger.Run(smokeResponse, null),
                                                        ServiceBusConstants.TopicNames.JobNotifications);

            response
            .Should()
            .NotBeNull();
        }
Example #21
0
        public async Task OnScaleUpCosmosDbCollection_SmokeTestSucceeds()
        {
            OnScaleUpCosmosDbCollection onScaleUpCosmosDbCollection = new OnScaleUpCosmosDbCollection(_logger,
                                                                                                      _cosmosDbScalingService,
                                                                                                      Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                                      _userProfileProvider,
                                                                                                      IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.ScaleUpCosmosdbCollection,
                                                        async(Message smokeResponse) => await onScaleUpCosmosDbCollection.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.JobNotifications);

            response
            .Should()
            .NotBeNull();
        }
Example #22
0
        public async Task OnDataDefinitionChanges_SmokeTestSucceeds()
        {
            OnDataDefinitionChanges onDataDefinitionChanges = new OnDataDefinitionChanges(_logger,
                                                                                          _datasetDefinitionChangesProcessor,
                                                                                          Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                          _userProfileProvider,
                                                                                          IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.UpdateDataDefinitionName,
                                                        async(Message smokeResponse) => await onDataDefinitionChanges.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.DataDefinitionChanges);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnJobNotification_SmokeTestSucceeds()
        {
            OnJobNotification onJobNotification = new OnJobNotification(_logger,
                                                                        _jobManagementService,
                                                                        Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                        _userProfileProvider,
                                                                        IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.UpdateJobsOnCompletion,
                                                        async(Message smokeResponse) => await onJobNotification.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.JobNotifications);

            response
            .Should()
            .NotBeNull();
        }
        public async Task OnEditSpecificationEvent_SmokeTestSucceeds()
        {
            OnEditSpecificationEvent onEditSpecificationEvent = new OnEditSpecificationEvent(_logger,
                                                                                             _fundingStreamPermissionService,
                                                                                             Services.BuildServiceProvider().GetRequiredService <IMessengerService>(),
                                                                                             _userProfileProvider,
                                                                                             IsDevelopment);

            SmokeResponse response = await RunSmokeTest(ServiceBusConstants.TopicSubscribers.UpdateUsersForEditSpecification,
                                                        async(Message smokeResponse) => await onEditSpecificationEvent.Run(smokeResponse),
                                                        ServiceBusConstants.TopicNames.EditSpecification);

            response
            .Should()
            .NotBeNull();
        }