public void ConcurrencyTest()
{
string connectionString = DbTest.CreateEmptyDatabase();
DbMigrations.Run(connectionString);
Order o;
OrderContext ctx = new OrderContext(connectionString);
OrderContext ctx2 = new OrderContext(connectionString);
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
IOrderRepository orderRepository2 = new OrderRepository(ctx2, new FakeBus());
o = new OrderFactory(new TestNumberGenerator(), new TestBus()).Create("12", "client123");
o.AddProduct(TestSeeding.ProductId);
orderRepository.Save(o);
Order concurrencyOrder1 = orderRepository.Get(o.Id);
Order concurrencyOrder2 = orderRepository2.Get(o.Id);
concurrencyOrder1.AddProduct(TestSeeding.Product2Id);
concurrencyOrder2.AddProduct(TestSeeding.Product3Id);
orderRepository.Save(concurrencyOrder1);
Assert.Throws <DbUpdateConcurrencyException>(() => orderRepository2.Save(concurrencyOrder2));
}
public void MappingTest()
{
string connectionString = DbTest.CreateEmptyDatabase();
DbMigrations.Run(connectionString);
Order o;
using (OrderContext ctx = new OrderContext(connectionString))
{
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
o = new OrderFactory(new TestNumberGenerator(), new TestBus()).Create("12", "client123");
o.AddProduct(TestSeeding.ProductId);
orderRepository.Save(o);
}
using (OrderContext ctx = new OrderContext(connectionString))
{
IOrderRepository orderRepository = new OrderRepository(ctx, new FakeBus());
Order o2 = orderRepository.Get(o.Id);
Assert.True(o2.SameAs(o));
}
}
public void UnitTest_Should_BeTrue()
{
// Arrange, Act
_ = new DbTest();
// Assert
Assert.True(DatabaseBase.UnitTests);
}
public void Instance_Should_BeTheExpectedType()
{
// Arrange and Act
_ = new DbTest();
// Assert
_ = Assert.IsAssignableFrom <DatabaseBase>(DatabaseBase.Instance);
}
private TestView ViewModelFromDataModel(DbTest dbScenario)
{
return(new TestView
{
Id = dbScenario.Id,
Name = dbScenario.Name
});
}
public string DbGet([FromBody] DbTest req)
{
var param = DbParamHelper.Generate(req.Param);
var result = _testDb.GetAll <object>(req.Query, param, CommandType.Text);
return(JsonConvert.SerializeObject(result));
}
private DbTest DataModelFromViewModel(TestView testView, DbTest existingDbModel = null)
{
DbTest dbTest = existingDbModel;
if (testView.Id == 0)
{
dbTest = DbTest.BuildNew();
}
dbTest.Name = testView.Name;
return(dbTest);
}
public string DbTest([FromBody] DbTest req)
{
var param = new DynamicParameters();
//param.Add("ThirdPartyCode", null, DbType.String);
param.AddDynamicParams(new { ThirdPartyCode = default(string) });
var result = _testDb.C_Test("[Back].[s_ThirdParty_Get]", param, CommandType.StoredProcedure);
return(JsonConvert.SerializeObject(result));
}
public async Task <DbTest> EditTestAsync(DbTest test)
{
var oldTest = await _context.Tests
.Where(c => c.Id == test.Id)
.SingleOrDefaultAsync();
if (oldTest == null)
{
return(null);
}
var testCategory = await _context.Tests
.Where(t => t.CourseId == test.CourseId &&
t.Category == test.Category &&
t.Level == test.Level &&
t.Id != test.Id)
.SingleOrDefaultAsync();
if (testCategory != null)
{
return(null);
}
if (oldTest.Category != test.Category)
{
oldTest.Category = test.Category;
}
if (oldTest.Level != test.Level)
{
oldTest.Level = test.Level;
}
if (oldTest.MaxPoints != test.MaxPoints)
{
oldTest.MaxPoints = test.MaxPoints;
}
try
{
_context.Tests.Update(oldTest);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
return(test);
}
public void Setup()
{
string connectionString = DbTest.CreateEmptyDatabase();
DbMigrations.Run(connectionString);
_smtpClient = new SmtpTestClient();
Bootstrap.Run(new string[0], builder =>
{
builder.RegisterInstance(_smtpClient).AsImplementedInterfaces();
}, connectionString);
_clientId = "aaa111";
}
private void Write(out int newId)
{
var dbProvider = _serviceProvider.GetRequiredService <IDbProvider>();
var uow = dbProvider.GetUnitOfWork <TestDbContext>("AlasTestDb");
var repoDbTest = uow.GetRepository <DbTest, int>();
var obj = new DbTest {
Name = "123", Date = DateTime.Now.Date
};
repoDbTest.Insert(obj);
uow.SaveChanges();
uow.DbContext.AsDbContext().Entry(obj);
newId = obj.Id;
}
public async Task <DbTest> CreateTestAsync(DbTest test)
{
if (test == null || test.Id != 0)
{
return(null);
}
var testCategory = await _context.Tests
.Where(t => t.CourseId == test.CourseId &&
t.Category == test.Category &&
t.Level == test.Level)
.SingleOrDefaultAsync();
if (testCategory != null)
{
return(null);
}
_context.Tests.Add(test);
await _context.SaveChangesAsync();
return(test);
}
public async Task <IActionResult> CreateTest([FromBody] TestCreate testToCreate)
{
if (testToCreate == null)
{
throw new ArgumentNullException(nameof(testToCreate));
}
if (!Authorize(testToCreate))
{
return(Unauthorized());
}
var tests = await _context.Platforms.Where(x => x.PlatformName == testToCreate.PlatformName).Select(x => new { x.Tests, x.DbPlatformId }).FirstOrDefaultAsync();
if (tests == null)
{
return(BadRequest("Platform does not exist"));
}
if (tests.Tests.Select(x => x.TestName).Contains(testToCreate.TestName))
{
return(Ok());
}
var newTest = new DbTest
{
TestName = testToCreate.TestName,
DbPlatformId = tests.DbPlatformId
};
_context.Tests.Add(newTest);
await _context.SaveChangesAsync();
return(Ok());
}
public void sanity_check()
{
var dbTest = new DbTest();
dbTest.TestConnection();
}
