protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_accountCodeRepository != null)
{
_accountCodeRepository.Dispose();
_accountCodeRepository = null;
}
if (_customerDynamicsRepository != null)
{
_customerDynamicsRepository.Dispose();
_customerDynamicsRepository = null;
}
if (_bucketRepository != null)
{
_bucketRepository.Dispose();
_bucketRepository = null;
}
}
base.Dispose(disposing);
}
public async Task ShouldUpdateTheNewBucketsRemoteIdIfNoExistingBucketWithRemoteId(
string remoteId,
Bucket bucket,
Bucket existingBucket,
[Frozen] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
bucket.RemoteId = null;
bucket.Endpoints = (long)ChannelEndpoint.CreateMessage;
bucket.ApiCategory = 'c';
existingBucket.Endpoints = (long)ChannelEndpoint.DeleteMessage;
existingBucket.ApiCategory = 'c';
var httpResponse = new HttpResponseMessage();
httpResponse.Headers.Add("x-ratelimit-bucket", new[] { remoteId });
repository.FindByRemoteIdAndMajorParameters(Any <string>(), Any <MajorParameters>(), Any <CancellationToken>()).Returns((Bucket)null !);
var result = await service.MergeBucketIds(bucket, httpResponse, cancellationToken);
result.Should().Be(bucket);
result.RemoteId.Should().Be(remoteId);
await repository.Received().FindByRemoteIdAndMajorParameters(Is(remoteId), Is(bucket.MajorParameters), Is(cancellationToken));
}
public GetBucketUnitTests()
{
BucketContext context = new BucketContext(new DbContextOptionsBuilder <BucketContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
this.repository = new BucketRepository(context);
}
public BucketUploader(IBucketRepository bucketRepository, IOptions <AppConfig> config, IFileRepository fileRepository, IFileProcessor fileProcessor)
{
_bucketRepository = bucketRepository;
_fileRepository = fileRepository;
_fileProcessor = fileProcessor;
_httpClient = new HttpClient();
_config = config.Value;
}
public AccountCodeController(IAccountCodeRepository accountCodeRepository,
ICustomerDynamicsRepository customerDynamicsRepository,
IBucketRepository bucketRepository)
{
_accountCodeRepository = accountCodeRepository;
_customerDynamicsRepository = customerDynamicsRepository;
_bucketRepository = bucketRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultBucketService" /> class.
/// </summary>
/// <param name="repository">Repository to search for buckets in.</param>
/// <param name="timerFactory">Factory to create timers and delays with.</param>
/// <param name="logger">Logger used to log info to some destination(s).</param>
public DefaultBucketService(
IBucketRepository repository,
ITimerFactory timerFactory,
ILogger <DefaultBucketService> logger
)
{
this.repository = repository;
this.timerFactory = timerFactory;
this.logger = logger;
}
public FileController(IBucketRepository bucketRepository,
IOptions <AwsBucketConfig> awsSetting, IServiceProvider serviceProvider,
IWebHostEnvironment webHostEnvironment, ILogger <FileController> logger)
{
_logger = logger;
_bucketRepository = bucketRepository;
_awsSetting = awsSetting.Value;
_serviceProvider = serviceProvider;
_webHostEnvironment = webHostEnvironment;
}
public static async Task <Bucket> GetOrFailAsync(this IBucketRepository repository, string name)
{
var bucket = await repository.GetAsync(name);
if (bucket == null)
{
throw new CuboException("bucket_not_found", $"Bucket: '{name}' was not found.");
}
return(bucket);
}
public static async Task <Bucket> GetAsyncOrFail(this IBucketRepository repository, string bucketName)
{
var bucket = await repository.GetAsync(bucketName);
if (bucket == null)
{
throw new CuboException("bucket_not_found", $"Bucket {bucketName} could not be found.");
}
return(bucket);
}
public async Task ShouldFetchBucketFromTheRepository(
Request request,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
await service.GetBucketAndWaitForAvailability(request, cancellationToken);
await repository.Received().FindByEndpointAndMajorParameters(Is(request.Endpoint), Is((MajorParameters)request.Parameters), Is(cancellationToken));
}
/*------------------------ FIELDS REGION ------------------------*/
/*------------------------ METHODS REGION ------------------------*/
public static async Task <Bucket> GetOrFailAsync(this IBucketRepository repository,
string name)
{
Bucket bucket = await repository.GetAsync(name);
if (bucket == null)
{
throw new BucketNotFoundException();
}
return(bucket);
}
public async Task ShouldReturnTheBucket(
Request request,
[Frozen] Bucket bucket,
[Frozen, Substitute] ITimerFactory timerFactory,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
var result = await service.GetBucketAndWaitForAvailability(request, cancellationToken);
result.Should().Be(bucket);
}
public async Task ShouldNotDelayIfHitsRemainingIsNotZero(
Request request,
[Frozen] Bucket bucket,
[Frozen, Substitute] ITimerFactory timerFactory,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
bucket.HitsRemaining = 1;
await service.GetBucketAndWaitForAvailability(request, cancellationToken);
await timerFactory.DidNotReceive().CreateDelay(Is((int)Math.Ceiling((bucket.ResetAfter - DateTimeOffset.Now).TotalMilliseconds)), Is(cancellationToken));
}
public async Task ShouldNotDecreaseTheNumberOfHitsByOneIfHitsRemainingIsZero(
Request request,
[Frozen] Bucket bucket,
[Frozen, Substitute] ITimerFactory timerFactory,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
bucket.HitsRemaining = 0;
var result = await service.GetBucketAndWaitForAvailability(request, cancellationToken);
result.HitsRemaining.Should().Be(0);
}
public CsvDownloaderJob(IBucketUploader bucketUploader,
IElectionConfigurationSource electionConfigurationSource,
IResultsRepository resultsRepository,
IBucketRepository bucketRepository,
IVoterTurnoutAggregator voterTurnoutAggregator,
IOptions <AppConfig> config)
{
_bucketUploader = bucketUploader;
_electionConfigurationSource = electionConfigurationSource;
_resultsRepository = resultsRepository;
_bucketRepository = bucketRepository;
_voterTurnoutAggregator = voterTurnoutAggregator;
_config = config.Value;
Log.LogInformation($"Interval is set to: {_config.IntervalInSeconds} seconds");
}
public async Task ShouldDelayUntilResetAfterIsReachedIfHitsRemainingIsZero(
int secondsToWait,
Request request,
[Frozen] Bucket bucket,
[Frozen, Substitute] ITimerFactory timerFactory,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
bucket.HitsRemaining = 0;
bucket.ResetAfter = DateTimeOffset.Now + TimeSpan.FromSeconds(secondsToWait);
await service.GetBucketAndWaitForAvailability(request, cancellationToken);
await timerFactory.Received().CreateDelay(Is <int>(ms => ms >= (secondsToWait * 1000) - 20), Is(cancellationToken));
}
public BucketService(
ILogger <IBucketRepository> logger,
IBucketRepository bucketRepository,
IApiBucketRequestModelValidator bucketModelValidator,
IBOLBucketMapper bolbucketMapper,
IDALBucketMapper dalbucketMapper,
IBOLFileMapper bolFileMapper,
IDALFileMapper dalFileMapper)
: base(logger,
bucketRepository,
bucketModelValidator,
bolbucketMapper,
dalbucketMapper,
bolFileMapper,
dalFileMapper)
{
}
public CsvDownloaderJob(IBucketUploader bucketUploader,
IElectionConfigurationSource electionConfigurationSource,
IResultsRepository resultsRepository,
IBucketRepository bucketRepository,
IVoterTurnoutAggregator voterTurnoutAggregator,
ILogger <CsvDownloaderJob> logger,
IOptions <AppConfig> config)
{
_bucketUploader = bucketUploader;
_electionConfigurationSource = electionConfigurationSource;
_resultsRepository = resultsRepository;
_bucketRepository = bucketRepository;
_voterTurnoutAggregator = voterTurnoutAggregator;
_logger = logger;
_config = config.Value;
_logger.LogInformation($"JobTimer is set to: {_config.JobTimer}");
}
public BucketService(
ILogger <IBucketService> logger,
MediatR.IMediator mediator,
IBucketRepository bucketRepository,
IApiBucketServerRequestModelValidator bucketModelValidator,
IDALBucketMapper dalBucketMapper,
IDALFileMapper dalFileMapper)
: base()
{
this.BucketRepository = bucketRepository;
this.BucketModelValidator = bucketModelValidator;
this.DalBucketMapper = dalBucketMapper;
this.DalFileMapper = dalFileMapper;
this.logger = logger;
this.mediator = mediator;
}
public GetBucketsUnitTests()
{
BucketContext context = new BucketContext(new DbContextOptionsBuilder <BucketContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
this.repository = new BucketRepository(context);
this.testBuckets.Add(new Bucket {
Name = "B", Description = "1", Size = 3
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "3", Size = 9
});
this.testBuckets.Add(new Bucket {
Name = "B", Description = "1", Size = 7
});
this.testBuckets.Add(new Bucket {
Name = "B", Description = "3", Size = 10
});
this.testBuckets.Add(new Bucket {
Name = "B", Description = "3", Size = 4
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "3", Size = 6
});
this.testBuckets.Add(new Bucket {
Name = "B", Description = "2", Size = 1
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "2", Size = 11
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "1", Size = 5
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "2", Size = 12
});
this.testBuckets.Add(new Bucket {
Name = "B", Description = "2", Size = 2
});
this.testBuckets.Add(new Bucket {
Name = "A", Description = "1", Size = 8
});
}
public AbstractBucketService(
ILogger logger,
IBucketRepository bucketRepository,
IApiBucketRequestModelValidator bucketModelValidator,
IBOLBucketMapper bolBucketMapper,
IDALBucketMapper dalBucketMapper,
IBOLFileMapper bolFileMapper,
IDALFileMapper dalFileMapper)
: base()
{
this.bucketRepository = bucketRepository;
this.bucketModelValidator = bucketModelValidator;
this.bolBucketMapper = bolBucketMapper;
this.dalBucketMapper = dalBucketMapper;
this.bolFileMapper = bolFileMapper;
this.dalFileMapper = dalFileMapper;
this.logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRequestInvoker" /> class.
/// </summary>
/// <param name="client">Client used to send/recieve http messages.</param>
/// <param name="urlBuilder">Builder used to build URLs from requests.</param>
/// <param name="relay">Service used to relay messages back and forth between SQS.</param>
/// <param name="bucketService">Service used to manage buckets.</param>
/// <param name="bucketRepository">Repository to manage buckets.</param>
/// <param name="reporter">Service used to report metrics.</param>
/// <param name="logger">Logger used to log info to some destination(s).</param>
public DefaultRequestInvoker(
HttpMessageInvoker client,
IUrlBuilder urlBuilder,
IRequestMessageRelay relay,
IBucketService bucketService,
IBucketRepository bucketRepository,
IMetricReporter reporter,
ILogger <DefaultRequestInvoker> logger
)
{
this.client = client;
this.urlBuilder = urlBuilder;
this.relay = relay;
this.bucketService = bucketService;
this.bucketRepository = bucketRepository;
this.reporter = reporter;
this.logger = logger;
}
public async Task ShouldNotCreateNewBucketIfOneWasFound(
Request request,
[Frozen] Bucket bucket,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
await service.GetBucketAndWaitForAvailability(request, cancellationToken);
await repository.DidNotReceive().Add(
Is <Bucket>(bucket =>
bucket.Endpoints == Convert.ToUInt64(request.Endpoint.Value) &&
bucket.ApiCategory == request.Endpoint.Category &&
bucket.MajorParameters == request.Parameters &&
bucket.HitsRemaining == 1
),
Is(cancellationToken)
);
}
public async Task ShouldSaveChangesToTheBucket(
string response,
RequestMessage request,
[Frozen] HttpStatusCode statusCode,
[Frozen] Bucket bucket,
[Frozen] HttpResponseMessage httpResponse,
[Frozen, Substitute] HttpMessageInvoker client,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultRequestInvoker invoker,
CancellationToken cancellationToken
)
{
httpResponse.Content = new StringContent(response);
request.RequestDetails = new Request(ChannelEndpoint.CreateMessage)
{
RequestBody = null
};
await invoker.Invoke(request, cancellationToken);
await repository.Received().Save(Is(bucket), Is(cancellationToken));
}
public async Task ShouldCreateNewBucketIfOneWasntFound(
Request request,
[Frozen, Substitute] IBucketRepository repository,
[Target] DefaultBucketService service,
CancellationToken cancellationToken
)
{
var resetAfter = DateTimeOffset.Now;
repository.FindByEndpointAndMajorParameters(Any <Endpoint>(), Any <MajorParameters>(), Any <CancellationToken>()).Returns((Bucket?)null);
await service.GetBucketAndWaitForAvailability(request, cancellationToken);
await repository.Received().Add(
Is <Bucket>(bucket =>
bucket.Endpoints == Convert.ToUInt64(request.Endpoint.Value) &&
bucket.ApiCategory == request.Endpoint.Category &&
bucket.MajorParameters == request.Parameters &&
bucket.HitsRemaining == 1 &&
bucket.ResetAfter >= resetAfter
),
Is(cancellationToken)
);
}
public BucketService(IBucketRepository bucketRepository, IMapper mapper)
{
_bucketRepository = bucketRepository;
_mapper = mapper;
}
public Handler(IBucketRepository repository)
{
this.repository = repository;
}
public BucketController(IBucketRepository bucketRepository)
{
_bucketRepository = bucketRepository;
}
public BucketsController(IBucketRepository bucketRepository)
{
this.bucketRepository = bucketRepository;
}
public BucketController(IBucketRepository bucketRepository, ILogger <BucketController> logger)
{
_bucketRepository = bucketRepository;
_logger = logger;
}
public BucketService(IBucketRepository repository, IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
public BucketService(IBucketRepository bucketRepository)
{
_bucketRepository = bucketRepository;
}
