public void DropTableTest()
{
// Verifies it is possible to perform operations following drop table
ISampleRepository sampleRepository = RepositoryContext.SampleRepository;
Assert.NotNull(sampleRepository);
var comparisonItem = _singleOperationsTestData;
// Create (insert) operation (before drop table)
sampleRepository.InsertItemAsync(_singleOperationsTestData).GetAwaiter().GetResult();
// Read (get) operation
var item = sampleRepository.GetItemAsync(_singleOperationsTestData.Id).Result;
ValidateSampleModelOperation(item, comparisonItem, nameof(sampleRepository.InsertItemAsync));
// Perform Drop Table operation
sampleRepository.DropTableAsync().GetAwaiter().GetResult();
// Create (insert) operation (after drop table)
sampleRepository.InsertItemAsync(_singleOperationsTestData).GetAwaiter().GetResult();
// Read (get) operation
item = sampleRepository.GetItemAsync(_singleOperationsTestData.Id).Result;
ValidateSampleModelOperation(item, comparisonItem, nameof(sampleRepository.InsertItemAsync));
}
public static async Task InsertAsync(ILogger logger, ISampleRepository repository, int count)
{
logger.LogInformation("Before measure");
var data = SampleEntity.CreateList(count);
using var tx = new TransactionScope(TransactionScopeOption.Required, TransactionScopeAsyncFlowOption.Enabled);
var sw = new Stopwatch();
sw.Start();
await repository.AddAsync(data);
sw.Stop();
tx.Complete();
logger.LogMetric("InsertPerformance", sw.ElapsedMilliseconds, new Dictionary <string, object>
{
{ "Repository", repository.GetType().Name },
{ "Count", count }
});
logger.LogInformation("After measure");
}
public ProductService(IUnitOfWork unitOfWork, ISampleRepository repository,
IContainer container, IEventBus eventBus, IMessagePublisher messagePublisher)
: base(unitOfWork, repository, container)
{
_eventBus = eventBus;
_messagePublisher = messagePublisher;
}
public HomeController(ISampleRepository repository)
{
_repository = repository;
//default intro message
IntroMessage = "Hello World";
}
public SampleOptionsService(ISampleRepository repository, IUnitOfWork unitOfWork, IMapper mapper, ISampleService sampleService)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_sampleService = sampleService ?? throw new ArgumentNullException(nameof(sampleService));
}
public void SingleUpdatePerformanceTest(int itemsToUpdate)
{
ISampleRepository sampleRepository = RepositoryContext.SampleRepository;
var testData = TestData.GenerateBulkOperationsTestData(itemsToUpdate);
// Insert initial data
sampleRepository.InsertAsync(testData).GetAwaiter().GetResult();
// Get persisted data
var persistedItems = sampleRepository.GetAsync().GetAwaiter().GetResult();
// Update local copies of persisted data
UpdateItems(ref persistedItems);
// Perform and measure update operations
var executionTime = ExecutionTimeInMilliseconds(() =>
{
foreach (var item in persistedItems)
{
sampleRepository.UpdateItemAsync(item).GetAwaiter().GetResult();
}
});
Assert.Pass($"{itemsToUpdate} records updated: {executionTime} ms");
}
public SampleMoreController(ISampleRepository rep, ISampleApplicationService app, ILoggerFactory logger, EnviromentInfo env)
{
this._rep = rep;
this._app = app;
this._logger = logger.CreateLogger <SampleMoreController>();
this._env = env;
}
public SampleService(ISampleRepository sampleRepository, ISampleArchRepository sampleArchRepository)
: base(sampleRepository)
{
// _unitOfWork = unitOfWork;
_sampleRepository = sampleRepository;
_sampleArchRepository = sampleArchRepository;
}
public HomeController(ISampleRepository repository)
{
_repository = repository;
//default intro message
IntroMessage = "Hello World";
}
public SampleFrontendSvcController(ISampleRepository repository, IPublishEndpoint publishEndpoint, /*IMapper mapper,*/ ILogger logger, IConfiguration config)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_publishEndpoint = publishEndpoint ?? throw new ArgumentNullException(nameof(publishEndpoint));
_logger = logger;
_config = config;
}
public MyCommandHandler(IEventBus eventBus, ISampleRepository repositroy, IUnitOfWork uow, IMessageContext commandContext)
{
_commandContext = commandContext;
_repository = repositroy;
_eventBus = eventBus;
_unitOfWork = uow;
}
public SampleServiceBase(ISampleRepository rep, IValidatorSpecification <Sample> validation, IWarningSpecification <Sample> warning, ICache cache, CurrentUser user)
: base(cache)
{
this._rep = rep;
this._user = user;
this._validation = validation;
this._warning = warning;
}
public SampleSingleDbContextUnitOfWork(ISampleDatabaseDbContext dbContext
, ISampleRepository sampleRepository, ISampleRepository2 sampleRepository2)
: base(dbContext, sampleRepository, sampleRepository2)
{
DbContext = dbContext;
SampleRepository = sampleRepository;
SampleRepository2 = sampleRepository2;
}
public SamplesController(ISampleRepository sampleRepository
, IMapper mapper)
{
_sampleRepository = sampleRepository ??
throw new ArgumentNullException(nameof(sampleRepository));
_mapper = mapper ??
throw new ArgumentNullException(nameof(mapper));
}
public DeleteHandler(IEventPublisher eventPublisher,
ISampleRepository sampleRepository,
IUnitOfWork unitOfWork,
ILogger <DeleteRequest> logger) : base(eventPublisher, logger)
{
_sampleRepository = sampleRepository;
_unitOfWork = unitOfWork;
}
public AccountService(IMapper mapper, ISampleRepository sampleRepository, UserManager <ApiUser> userManager, SignInManager <ApiUser> signInManager, IEmailSender emailSender)
{
_mapper = mapper;
_sampleRepository = sampleRepository;
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
}
public OrdersController(ISampleRepository repository,
ILogger <OrdersController> logger,
IMapper mapper)
{
this.repository = repository;
this.logger = logger;
this.mapper = mapper;
}
public SampleController(ISampleRepository sampleRepository,
IUserProfileRepository userProfileRepository,
IReportRepository reportRepository)
{
_sampleRepository = sampleRepository;
_userProfileRepository = userProfileRepository;
_reportRepository = reportRepository;
}
public ProductService(IProductRepository ProductsRepository, IProductCategoryRepository productCategoryRepository, IUnitOfWork unitOfWork, IProductSampleRepository productSampleRepository, ISampleRepository sampleRepository)
{
this._productsRepository = ProductsRepository;
this._productCategoryRepository = productCategoryRepository;
this._productSampleRepository = productSampleRepository;
this._sampleRepository = sampleRepository;
this.unitOfWork = unitOfWork;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
repo = null;
}
base.Dispose(disposing);
}
public InsertHandler(IEventPublisher eventPublisher,
ISampleRepository sampleRepository,
IUnitOfWork unitOfWork,
ISampleService sampleService,
ILogger <InsertRequest> logger) : base(eventPublisher, logger)
{
_sampleRepository = sampleRepository;
_unitOfWork = unitOfWork;
_sampleService = sampleService;
}
public void SQLSampleRepository_Get_Sample_By_Id()
{
ISampleRepository sut = GetInMemorySampleRepository();
List <SampleModel> samples = sampleInMemoryDb();
SampleModel savedSample1 = sut.Add(samples[0]);
sut.GetSample(savedSample1.Id);
Assert.Equal(123, savedSample1.Donor_Count);
}
public SampleMoreController(ISampleRepository rep, ISampleApplicationService app, ILoggerFactory logger, EnviromentInfo env, CurrentUser user, ICache cache)
{
this._rep = rep;
this._app = app;
this._logger = logger.CreateLogger <SampleMoreController>();
this._env = env;
this._user = user;
this._cache = cache;
this._cacheHelper = new CacheHelper(this._cache);
}
public UpdateHandler(IEventPublisher eventPublisher,
ISampleRepository sampleRepository,
IUnitOfWork unitOfWork,
ISampleAdapter sampleAdapter,
ILogger <UpdateRequest> logger) : base(eventPublisher, logger)
{
_sampleRepository = sampleRepository;
_unitOfWork = unitOfWork;
_sampleAdapter = sampleAdapter;
}
public void BulkInsertOperationsPerformanceTest(int insertionsToTest)
{
ISampleRepository sampleRepository = RepositoryContext.SampleRepository;
var testData = TestData.GenerateBulkOperationsTestData(insertionsToTest);
// Perform and measure insert operations
var executionTime = ExecutionTimeInMilliseconds(() => sampleRepository.InsertAsync(testData).GetAwaiter().GetResult());
Assert.Pass($"{insertionsToTest} records inserted: {executionTime} ms");
}
public SampleModel(ISampleRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
this.repository = repository;
Trace.WriteLine("Instantiating SampleModel..");
Trace.WriteLine("HashCode: " + GetHashCode());
}
public void SQLSampleRepository_Should_Delete_Sample()
{
ISampleRepository sut = GetInMemorySampleRepository();
List <SampleModel> samples = sampleInMemoryDb();
sut.Add(samples[0]);
Assert.Single(sut.GetAllSamples());
sut.Delete(samples[0].Id);
Assert.Empty(sut.GetAllSamples());
}
public void BulkReadPerformanceTest(int itemsToRead)
{
ISampleRepository sampleRepository = RepositoryContext.SampleRepository;
var testData = TestData.GenerateBulkOperationsTestData(itemsToRead);
// Insert initial data
sampleRepository.InsertAsync(testData).GetAwaiter().GetResult();
// Perform and measure read operations
var executionTime = ExecutionTimeInMilliseconds(() => sampleRepository.GetAsync().GetAwaiter().GetResult());
Assert.Pass($"{itemsToRead} records read: {executionTime} ms");
}
public SampleApi(ISampleRepository sampleRepository,
ISampleViewModelService sampleViewModelService,
IMapper mapper,
ITemplateCosmosRepository templateCosmosRepository,
IBlobStorageService blobStorageService
)
{
_sampleRepository = sampleRepository;
_sampleViewModelService = sampleViewModelService;
_mapper = mapper;
_templateCosmosRepository = templateCosmosRepository;
_blobStorageService = blobStorageService;
}
public void SQLSampleRepository_Should_Update_Sample()
{
ISampleRepository sut = GetInMemorySampleRepository();
List <SampleModel> samples = sampleInMemoryDb();
sut.Add(samples[0]);
Assert.Equal("28/09/2020", samples[0].Last_Updated);
samples[0].Last_Updated = "14/10/2020";
sut.Update(samples[0]);
Assert.Equal("14/10/2020", samples[0].Last_Updated);
}
public void SQLSpampleRepository_Should_Get_All_Samples()
{
ISampleRepository sut = GetInMemorySampleRepository();
List <SampleModel> samples = sampleInMemoryDb();
SampleModel savedSample1 = sut.Add(samples[0]);
SampleModel savedSample2 = sut.Add(samples[1]);
sut.GetAllSamples();
Assert.Equal(2, samples.Count);
Assert.Equal(123, savedSample1.Donor_Count);
Assert.Equal(5592, savedSample2.Donor_Count);
}
public SampleController(ISampleRepository sampleRepository)
{
this.sampleRepository = sampleRepository;
}
// ReSharper restore UnusedParameter.Local
public SampleService(ISampleRepository repo)
{
Repository = repo;
}
public SampleService(ISampleRepository sampleRepository, IUnitOfWork unitOfWork)
{
this.sampleRepository = sampleRepository;
this.unitOfWork = unitOfWork;
}
public SampleService(ISampleRepository sampleRepository)
{
this.SampleRepository = sampleRepository;
}
public SampleService(ISampleRepository repository)
{
_repository = repository;
}
public SampleController(ISampleRepository repository)
{
Repository = repository;
}
public SampleService(string b, ISampleRepository repo, string c)
{
}
public FooService(ISampleRepository sampleRepository)
{
this.sampleRepository = sampleRepository;
}
// ReSharper disable UnusedParameter.Local
public SampleService(ISampleRepository repo1, string b, ISampleRepository repo2)
{
B = b;
}
