public void Add_SomeEntity_EntityIsAdded()
{
_efCoreDbContext.GetDbSet <Person>().Add(new Person());
_dbContext.Persons.Local.Should().HaveCount(1);
_dbContext.Entry(_dbContext.Persons.Local.First()).State.Should().Be(EntityState.Added);
}
public void DetectChanges_PlainObject()
{
using (var db = new TestDbContext()) {
var customer = new Customer {
Address = new Address {
Street = "Street 1"
}
};
db.Add(customer);
db.SaveChanges();
// Note: changing tracking does not work without reloading. This might be an issue with EF Core itself?
db.Entry(customer).State = EntityState.Detached;
customer = db.Customers.Find(customer.Id);
Assert.AreEqual(EntityState.Unchanged, db.Entry(customer).State, "Precondition: entity is marked as unchanged");
customer.Address.Street = "Street 2";
db.ChangeTracker.DetectChanges();
Assert.AreEqual(EntityState.Modified, db.Entry(customer).State, "Entity is marked as modified");
Assert.IsTrue(db.Entry(customer).Property(m => m.Address).IsModified, "Property is marked as modified");
}
}
public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
public virtual void Delete(TEntity entityToDelete)
{
if (_context.Entry(entityToDelete).State == EntityState.Detached)
{
_context.Set <TEntity>().Attach(entityToDelete);
}
_context.Set <TEntity>().Remove(entityToDelete);
}
public async Task <IActionResult> PostProduct([FromBody] Product product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Entry(product).State = EntityState.Added;
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProduct", new { id = product.Id }, product));
}
/// <summary>
/// 更新一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <returns>bool</returns>
public bool Update(T entity)
{
try
{
db.Set <T>().Attach(entity);
db.Entry(entity).State = EntityState.Modified;
return(db.SaveChanges() > 0);
}
catch (Exception)
{
return(false);
}
}
public bool Create(PermissionType model)
{
try
{
_context.Entry(model).State = Microsoft.EntityFrameworkCore.EntityState.Added;
_context.SaveChanges();
}
catch (Exception ex)
{
return(false);
}
return(true);
}
public void HandleTenantNotSetWhenUpdating()
{
try
{
_connection.Open();
var tenant1 = new TenantContext("abc", "abc", "abc",
"DataSource=testdb.db", null, null);
// TenantNotSetMode.Throw
using (var db = new TestDbContext(tenant1, _options))
{
db.Database.EnsureDeleted();
db.Database.EnsureCreated();
var blog1 = new Blog {
Title = "abc"
};
db.Blogs.Add(blog1);
db.SaveChanges();
db.TenantNotSetMode = TenantNotSetMode.Throw;
db.Entry(blog1).Property("TenantId").CurrentValue = null;
var e = Assert.Throws <MultiTenantException>(() => db.SaveChanges());
}
// TenantNotSetMode.Overwrite
using (var db = new TestDbContext(tenant1, _options))
{
db.Database.EnsureDeleted();
db.Database.EnsureCreated();
var blog1 = new Blog {
Title = "abc12"
};
db.Blogs.Add(blog1);
db.SaveChanges();
db.TenantNotSetMode = TenantNotSetMode.Overwrite;
db.Entry(blog1).Property("TenantId").CurrentValue = null;
db.SaveChanges();
Assert.Equal(tenant1.Id, db.Entry(blog1).Property("TenantId").CurrentValue);
}
}
finally
{
_connection.Close();
}
}
public void CanCascade_UnmodifiedDifferentType()
{
using var dbContext = new TestDbContext();
var subject = CreateSubject();
var entity = new TestModel {
Property1 = 1
};
dbContext.Add(entity);
var previousTriggerContextDescriptor = new TriggerContextDescriptor(dbContext.Entry(entity), ChangeType.Added);
var result = subject.CanCascade(dbContext.Entry(entity), ChangeType.Modified, previousTriggerContextDescriptor);
Assert.Equal(CanCascadeUnmodifiedExpectedOutcome, result);
}
public void ShouldSupportNullValuesInTree()
{
var node1 = new TestNode
{
Title = "New Node",
OneToOneOwned = null
};
using (var context = new TestDbContext())
{
context.Nodes.Add(node1);
context.SaveChanges();
} // Simulate detach
using (var context = new TestDbContext())
{
// Setup mapping
node1 = context.UpdateGraph(node1, map => map
.OwnedEntity(p => p.OneToOneOwned, with =>
with.OwnedEntity(p => p.OneToOneOneToOneOwned)));
context.SaveChanges();
context.Entry(node1).Reload();
Assert.IsTrue(node1.OneToOneOwned == null);
}
}
public void ShouldSupportMultipleKeys()
{
var model = new MultiKeyModel
{
Title = "Hello",
Date = DateTime.Now,
KeyPart1 = "A123",
KeyPart2 = "A234"
};
using (var context = new TestDbContext())
{
context.MultiKeyModels.Add(model);
context.SaveChanges();
} // simulate detach
model.Date = DateTime.Parse("01/01/2010");
using (var context = new TestDbContext())
{
model = context.UpdateGraph(model);
context.SaveChanges();
context.Entry(model).Reload();
Assert.IsTrue(model.Date == DateTime.Parse("01/01/2010"));
}
}
public async Task <Product> Update(Product product)
{
_context.Entry(product).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(product);
}
public void ShouldSupportMultipleKeys()
{
var model = new MultiKeyModel
{
Title = "Hello",
Date = DateTime.Now,
KeyPart1 = "A123",
KeyPart2 = "A234"
};
using (var context = new TestDbContext())
{
context.MultiKeyModels.Add(model);
context.SaveChanges();
} // simulate detach
model.Date = DateTime.Parse("01/01/2010");
using (var context = new TestDbContext())
{
model = context.UpdateGraph(model);
context.SaveChanges();
context.Entry(model).Reload();
Assert.IsTrue(model.Date == DateTime.Parse("01/01/2010"));
}
}
public void ShouldSupportNullValuesInTree()
{
var node1 = new TestNode
{
Title = "New Node",
OneToOneOwned = null
};
using (var context = new TestDbContext())
{
context.Nodes.Add(node1);
context.SaveChanges();
} // Simulate detach
using (var context = new TestDbContext())
{
// Setup mapping
node1 = context.UpdateGraph(node1, map => map
.OwnedEntity(p => p.OneToOneOwned, with =>
with.OwnedEntity(p => p.OneToOneOneToOneOwned)));
context.SaveChanges();
context.Entry(node1).Reload();
Assert.IsTrue(node1.OneToOneOwned == null);
}
}
public async Task <IActionResult> PutConfirmationResponse(int id, ConfirmationResponse confirmationResponse)
{
if (id != confirmationResponse.Id)
{
return(BadRequest());
}
_context.Entry(confirmationResponse).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConfirmationResponseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEmployee(int id, Employee employee)
{
if (id != employee.EmployeeId)
{
return(BadRequest());
}
_context.Entry(employee).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <int> UpdateEmployee(Employee employee)
{
var _employee = _context.Employees.Where(e => e.Id == employee.Id).FirstOrDefaultAsync();
if (_employee != null)
{
_context.Entry(employee).State = EntityState.Detached;
}
else
{
return(0);
}
_context.Entry(employee).State = EntityState.Modified;
return(await _context.SaveChangesAsync());
}
public IHttpActionResult PutTestTable1(int id, TestTable1 testTable1)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != testTable1.Id)
{
return(BadRequest());
}
db.Entry(testTable1).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TestTable1Exists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutUsuarios(int id, Usuarios usuarios)
{
if (id != usuarios.Id)
{
return(BadRequest());
}
_context.Entry(usuarios).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuariosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutProduct(int id, Product product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != product.Id)
{
return(BadRequest());
}
db.Entry(product).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task Post(ResourceEditDto dto)
{
if (TryValidateModel(dto))
{
using (var db = new TestDbContext())
{
var model = await db.Resources.FirstOrDefaultAsync(x => x.Id == dto.Id);
if (model != null)
{
_mapper.Map(dto, model);
model.UpdatedOnUtc = DateTime.Now;
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
}
else
{
model = _mapper.Map <Resource>(dto);
model.CreatedOnUtc = DateTime.Now;
model.UpdatedOnUtc = DateTime.Now;
db.Resources.Add(model);
await db.SaveChangesAsync();
}
}
}
else
{
throw new Exception(String.Join(";", ModelState.Values.SelectMany(v => v.Errors).Select(x => x.ErrorMessage)));
}
}
public void Attached_OwnedCollectionRemove()
{
Models.Company company1;
using (var context = new TestDbContext(_connection))
{
company1 = context.Companies
.Include(p => p.Contacts.Select(m => m.Infos))
.Single(p => p.Id == 2);
//} // Simulate detach
//company1.Contacts.Remove(company1.Contacts.First());
context.Entry(company1.Contacts.First()).State = EntityState.Deleted;
//using (var context = new TestDbContext(_connection))
//{
// Setup mapping
//context.Entry(company1).State = EntityState.Modified;
context.UpdateGraph(company1, map => map
.OwnedCollection(p => p.Contacts, with => with
.OwnedCollection(p => p.Infos)));
context.SaveChanges();
Assert.IsTrue(context.Companies
.Include(p => p.Contacts.Select(m => m.Infos))
.Single(p => p.Id == 2)
.Contacts.Count == 0);
}
}
public async Task <IActionResult> Put([FromODataUri] int key, Supplier update)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (key != update.Id)
{
return(BadRequest());
}
db.Entry(update).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SupplierExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(update));
}
public async Task <IActionResult> PutProduct(int id, Product product)
{
if (id != product.Id)
{
return(BadRequest());
}
_context.Entry(product).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Type_IsNotEmpty()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel();
var subject = new TriggerContext <object>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues, ChangeType.Modified);
Assert.Equal(ChangeType.Modified, subject.ChangeType);
}
public void Entity_IsNeverEmpty()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel();
var subject = new TriggerContext <object>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues, default);
Assert.NotNull(subject.Entity);
}
public void UnmodifiedEntity_WhenTypeModified_IsNotEmpty()
{
using var dbContext = new TestDbContext();
var sample1 = new TestModel();
var subject = new TriggerContext <object>(dbContext.Entry(sample1).Entity, dbContext.Entry(sample1).OriginalValues, ChangeType.Modified, new());
Assert.NotNull(subject.UnmodifiedEntity);
}
public void delete(PlayList t)
{
using (TestDbContext context = new TestDbContext())
{
context.PlayLists.Attach(t);
context.Entry(t).State = EntityState.Deleted;
context.SaveChanges();
}
}
public void CaptureDiscoveredChangesAfterAdd_DetachedEntry_RemovesDiscoveredChange()
{
using var dbContext = new TestDbContext();
var subject = new TriggerContextTracker(dbContext.ChangeTracker, new EntityAndTypeCascadeStrategy());
var testModel = new TestModel();
dbContext.Entry(testModel).State = EntityState.Added;
var disoveredChanges = subject.DiscoverChanges();
Assert.Single(disoveredChanges);
Assert.Single(subject.DiscoveredChanges);
dbContext.Entry(testModel).State = EntityState.Detached;
subject.CaptureChanges();
Assert.Empty(subject.DiscoveredChanges);
}
public void Update(Person person)
{
using (TestDbContext context = new TestDbContext())
{
context.Person.Attach(person);
context.Entry(person).State = System.Data.EntityState.Modified;
context.SaveChanges();
}
}
public IActionResult Edit([Bind(include: "Id,Name,Password,Profile,Cv")] Test test)
{
if (ModelState.IsValid)
{
context.Entry(test).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
context.SaveChanges();
return(RedirectToAction("AddStudent"));
}
public void delete(UserMessage t)
{
using (TestDbContext context = new TestDbContext())
{
context.UserMessages.Attach(t);
context.Entry(t).State = EntityState.Deleted;
context.SaveChanges();
}
}
