public void Sleep100ms(IMetricCollector collector)
{
using (collector.StartCollection())
{
Thread.Sleep(100);
}
}
public void ColdStartSandbox_100ms(IMetricCollector collector)
{
using (var sandbox = new ColdStartSandbox())
{
var testClass = sandbox.CreateInstance<ColdStartEnabledTests>();
testClass.Sleep100ms(collector);
}
}
public void Calibration_100ms_controlled(IMetricCollector collector)
{
Thread.Sleep(100);
using (collector.StartCollection())
{
Thread.Sleep(100);
}
}
public void OrderBy(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.ApplyTracking(tracking)
.OrderBy(p => p.Retail);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(1000, query.Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public void StoredProcedure(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.SqlQuery("EXECUTE dbo.SearchProducts @p0, @p1", 10, 14)
.ApplyTracking(tracking);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(500, query.Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public void SelectParameterized(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.SqlQuery("SELECT * FROM dbo.Products WHERE CurrentPrice >= @p0 AND CurrentPrice <= @p1", 10, 14)
.ApplyTracking(tracking);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(500, query.Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public void SelectAll(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.FromSql("SELECT * FROM dbo.Products")
.ApplyTracking(tracking);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(1000, query.Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public async Task Insert(IMetricCollector collector, bool disableBatching, bool async)
{
using (var context = _fixture.CreateContext(disableBatching))
{
using (context.Database.BeginTransaction())
{
var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: false);
context.Customers.AddRange(customers);
collector.StartCollection();
var records = async
? await context.SaveChangesAsync()
: context.SaveChanges();
collector.StopCollection();
Assert.Equal(1000, records);
}
}
}
public void LoadAll(IMetricCollector collector, bool tracking, bool caching, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.ApplyCaching(caching)
.ApplyTracking(tracking);
using (collector.StartCollection())
{
for (int i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(1000, query.Count());
Assert.False(tracking && queriesPerIteration != 1, "Multiple queries per iteration not valid for tracking queries");
}
}
public void AttachParents(IMetricCollector collector)
{
using (var context = _fixture.CreateContext())
{
var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true);
orders.ForEach(o => context.Orders.Attach(o));
Assert.All(customers, c => Assert.Null(c.Orders));
using (collector.StartCollection())
{
foreach (var customer in customers)
{
context.Customers.Attach(customer);
}
}
Assert.All(customers, c => Assert.Equal(1, c.Orders.Count));
}
}
public void AttachChildren(IMetricCollector collector)
{
using (var context = _fixture.CreateContext())
{
var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true);
customers.ForEach(c => context.Customers.Attach(c));
Assert.All(orders, o => Assert.Null(o.Customer));
using (collector.StartCollection())
{
foreach (var order in orders)
{
context.Orders.Attach(order);
}
}
Assert.All(orders, o => Assert.NotNull(o.Customer));
}
}
public void SkipTake(IMetricCollector collector, bool tracking, bool caching, int queriesPerIteration)
{
using (var context = _fixture.CreateContext(queryCachingEnabled: caching))
{
var query = context.Products
.ApplyTracking(tracking)
.OrderBy(p => p.ProductId)
.Skip(500).Take(500);
using (collector.StartCollection())
{
for (int i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(500, query.Count());
Assert.False(tracking && queriesPerIteration != 1, "Multiple queries per iteration not valid for tracking queries");
}
}
// NOTE: Composition is done on client, so there is no async version
public void SelectComposed(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products
.SqlQuery("SELECT * FROM dbo.Products")
.ApplyTracking(tracking)
.Where(p => p.CurrentPrice >= 10 && p.CurrentPrice <= 14)
.OrderBy(p => p.Name);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
Assert.Equal(500, query.Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public void Include(IMetricCollector collector, bool tracking, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Customers
.ApplyTracking(tracking)
.Include(c => c.Orders);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
query.ToList();
}
}
var result = query.ToList();
Assert.Equal(1000, result.Count);
Assert.Equal(2000, result.SelectMany(c => c.Orders).Count());
Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries");
}
}
public async Task Update(IMetricCollector collector, bool async)
{
using (var context = _fixture.CreateContext())
{
using (context.Database.BeginTransaction())
{
foreach (var customer in context.Customers)
{
customer.FirstName += " Modified";
}
collector.StartCollection();
var records = async
? await context.SaveChangesAsync()
: context.SaveChanges();
collector.StopCollection();
Assert.Equal(1000, records);
}
}
}
public void AttachParents(IMetricCollector collector, bool autoDetectChanges)
{
using (var context = _fixture.CreateContext())
{
context.Configuration.AutoDetectChangesEnabled = autoDetectChanges;
var customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 2, setPrimaryKeys: true);
orders.ForEach(o => context.Orders.Attach(o));
Assert.All(customers, c => Assert.Null(c.Orders));
using (collector.StartCollection())
{
foreach (var customer in customers)
{
context.Customers.Attach(customer);
}
}
Assert.All(customers, c => Assert.Equal(2, c.Orders.Count));
}
}
public void AddChildren(IMetricCollector collector, bool autoDetectChanges)
{
using (var context = _fixture.CreateContext())
{
context.Configuration.AutoDetectChangesEnabled = autoDetectChanges;
var customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 2, setPrimaryKeys: false);
customers.ForEach(c => context.Customers.Attach(c));
Assert.All(orders, o => Assert.Null(o.Customer));
using (collector.StartCollection())
{
foreach (var order in orders)
{
context.Orders.Add(order);
}
}
Assert.All(orders, o => Assert.NotNull(o.Customer));
}
}
public void AttachChildren(IMetricCollector collector, bool autoDetectChanges)
{
using (var context = _fixture.CreateContext())
{
context.ChangeTracker.AutoDetectChangesEnabled = autoDetectChanges;
var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true);
context.Customers.AttachRange(customers);
Assert.All(orders, o => Assert.Null(o.Customer));
using (collector.StartCollection())
{
foreach (var order in orders)
{
context.Orders.Attach(order);
}
}
Assert.All(orders, o => Assert.NotNull(o.Customer));
}
}
public void AddParents(IMetricCollector collector, bool autoDetectChanges)
{
using (var context = _fixture.CreateContext())
{
context.ChangeTracker.AutoDetectChangesEnabled = autoDetectChanges;
var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true);
var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: false);
context.Orders.AddRange(orders);
Assert.All(customers, c => Assert.Null(c.Orders));
using (collector.StartCollection())
{
foreach (var customer in customers)
{
context.Customers.Add(customer);
}
}
Assert.All(customers, c => Assert.Equal(1, c.Orders.Count));
}
}
public async Task Count(IMetricCollector collector, bool async, int queriesPerIteration)
{
using (var context = _fixture.CreateContext())
{
var query = context.Products;
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
if (async)
{
await query.CountAsync();
}
else
{
query.Count();
}
}
}
Assert.Equal(1000, query.Count());
}
}
public async Task PredicateAcrossOptionalNavigationFilteredResults(IMetricCollector collector, bool async, int queriesPerIteration)
{
using (var context = AdventureWorksFixture.CreateContext())
{
var query = context.Store.Where(s => s.SalesPerson.Bonus > 3000);
using (collector.StartCollection())
{
for (var i = 0; i < queriesPerIteration; i++)
{
if (async)
{
await query.ToListAsync();
}
else
{
query.ToList();
}
}
}
Assert.Equal(466, query.Count());
}
}
public BenchmarkTestInvoker(
ITest test,
IMetricCollector metricCollector,
IMessageBus messageBus,
Type testClass,
object[] constructorArguments,
MethodInfo testMethod,
object[] testMethodArguments,
IReadOnlyList <BeforeAfterTestAttribute> beforeAfterAttributes,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
: base(
test,
messageBus,
testClass,
constructorArguments,
testMethod,
testMethodArguments,
beforeAfterAttributes,
aggregator,
cancellationTokenSource)
{
_metricCollector = metricCollector;
}
public void AddMetricCollector(string alisa, IMetricCollector metric)
{
Metrics[alisa] = metric;
}
public Scope(IMetricCollector collector)
{
_collector = collector;
}
public void InitializeAndSaveChanges_AdventureWorks(IMetricCollector collector, bool cold, int count)
{
RunColdStartEnabledTest(cold, t => t.InitializeAndSaveChanges_AdventureWorks(collector, count));
}
public void InitializeAndQuery_AdventureWorks(IMetricCollector collector, bool cold, int count)
{
RunColdStartEnabledTest(cold, c => c.InitializeAndQuery_AdventureWorks(collector, count));
}
public void CreateAndDisposeUnusedContext(IMetricCollector collector, bool cold, int count)
{
RunColdStartEnabledTest(cold, c => c.CreateAndDisposeUnusedContext(collector, count));
}
public void Aggregate(RunSummary other, IMetricCollector collector)
{
Aggregate(other);
TimeElapsed = collector.TimeElapsed;
MemoryDelta = collector.MemoryDelta;
}
public Scope(IMetricCollector collector)
{
_collector = collector;
}
public void Aggregate(RunSummary other, IMetricCollector collector)
{
Aggregate(other);
TimeElapsed = collector.TimeElapsed;
MemoryDelta = collector.MemoryDelta;
}
public void Configure(IApplicationBuilder app, IMetricCollector collector)
{
collector.StopCollection();
}
public LoggingCommandExecutionAuditor(ILogger <LoggingCommandExecutionAuditor> logger,
IMetricCollector metricCollector)
{
_logger = logger;
_metricCollector = metricCollector;
}
public BenchmarkTestInvoker(
ITest test,
IMetricCollector metricCollector,
IMessageBus messageBus,
Type testClass,
object[] constructorArguments,
MethodInfo testMethod,
object[] testMethodArguments,
IReadOnlyList<BeforeAfterTestAttribute> beforeAfterAttributes,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
: base(
test,
messageBus,
testClass,
constructorArguments,
testMethod,
testMethodArguments,
beforeAfterAttributes,
aggregator,
cancellationTokenSource)
{
_metricCollector = metricCollector;
}
