public void Insert_PostInsertHasEvent_IsInvoked(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
UserHeapEntity?postInsertEntity = null;
repository.PostInsert += (tmpEntity) =>
{
postInsertEntity = tmpEntity;
};
// Act
var insertedEntity = repository.Insert(entity);
// Assert
try
{
Assert.Equal(insertedEntity, postInsertEntity);
Assert.Same(insertedEntity, postInsertEntity);
}
finally
{
repository.Delete(insertedEntity);
}
}
public void Get_ValuesNotInDatabase_ReturnsNull(UserHeapEntity entity)
{
// Act
var gotten = _repository.Get(entity);
// Assert
Assert.Null(gotten);
}
public async Task Get_ValuesNotInDatabase_ReturnsNull(UserHeapEntity entity)
{
// Act
var gotten = await _repository.GetAsync(entity);
// Assert
Assert.Null(gotten);
}
public async Task Insert_MissingColumns_Throws()
{
// Arrange
var entity = new UserHeapEntity {
Username = "******"
};
// Act && Assert
await Assert.ThrowsAsync <MySqlException>(async() => await _repository.InsertAsync(entity));
}
public void Insert_MissingColumns_Throws()
{
// Arrange
var entity = new UserHeapEntity {
Username = "******"
};
// Act && Assert
Assert.Throws <MySqlException>(() => _repository.Insert(entity));
}
public void Delete_HasAllColumns_Valid(UserHeapEntity entity)
{
// Arrange
_repository.Insert(entity);
// Act
var deletedEntity = _repository.Delete(entity);
// Assert
Assert.Equal(entity.Username, deletedEntity?.Username);
Assert.Equal(entity.Password, deletedEntity?.Password);
}
public async Task GetAll_HaveRows_Valid(UserHeapEntity entity)
{
// Arrange
await _repository.InsertAsync(entity);
// Act
var deletedEntity = await _repository.DeleteAsync(entity);
// Assert
Assert.Equal(entity.Username, deletedEntity?.Username);
Assert.Equal(entity.Password, deletedEntity?.Password);
}
public void Delete_MissingColumns_ReturnsNull()
{
// Arrange
var entity = new UserHeapEntity {
Username = "******"
};
// Act
var deleted = _repository.Delete(entity);
// Assert
Assert.Null(deleted);
}
public async Task Delete_MissingColumns_ReturnsNull()
{
// Arrange
var entity = new UserHeapEntity {
Username = "******"
};
// Act
var deleted = await _repository.DeleteAsync(entity);
// Assert
Assert.Null(deleted);
}
public void Delete_MultipleRowsWithSameValues_DeletesBoth(UserHeapEntity entity)
{
// Arrange
_repository.Insert(entity);
_repository.Insert(entity);
// Act
var deletedEntity = _repository.Delete(entity);
// Assert
var gotten = _repository.Get(entity);
Assert.Null(gotten);
}
public async Task Delete_MultipleRowsWithSameValues_DeletesBoth(UserHeapEntity entity)
{
// Arrange
await _repository.InsertAsync(entity);
await _repository.InsertAsync(entity);
// Act
var deletedEntity = await _repository.DeleteAsync(entity);
// Assert
var gotten = await _repository.GetAsync(entity);
Assert.Null(gotten);
}
public void Delete_PreInsertHasEvent_IsInvoked(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
var insertedEntity = repository.Insert(entity);
repository.PreDelete += (inputEntity, cancelArgs) =>
{
// Assert
Assert.Equal(entity, inputEntity);
};
// Act
repository.Delete(insertedEntity);
}
public void Insert_HasAllColumns_Valid(UserHeapEntity entity)
{
// Act
var insertedEntity = _repository.Insert(entity);
try
{
// Assert
Assert.Equal(entity.Username, insertedEntity.Username);
Assert.Equal(entity.Password, insertedEntity.Password);
}
finally
{
_repository.Delete(insertedEntity);
}
}
public async Task Insert_HasAllColumns_Valid(UserHeapEntity entity)
{
// Act
var insertedEntity = await _repository.InsertAsync(entity);
try
{
// Assert
Assert.Equal(entity.Username, insertedEntity.Username);
Assert.Equal(entity.Password, insertedEntity.Password);
}
finally
{
await _repository.DeleteAsync(insertedEntity);
}
}
public void Insert_PreInsertCancels_IsCancelled(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
repository.PreInsert += (preInsertEntity, cancelArgs) =>
{
cancelArgs.Cancel = true;
};
// Act && Assert
Assert.Throws <CanceledException>(() => repository.Insert(entity));
var gotten = repository.Get(entity);
Assert.Null(gotten);
}
public void Insert_InsertSameValuesTwice_BothAreCreated(UserHeapEntity entity)
{
// Act
_repository.Insert(entity);
_repository.Insert(entity);
try
{
// Assert
var count = _repository.GetAll()
.Where(found => found.Username == entity.Username && found.Password == entity.Password)
.Count();
Assert.True(count > 1);
}
finally
{
_repository.Delete(entity);
}
}
public void GetAll_HaveRows_Valid(UserHeapEntity entity, UserHeapEntity entity2)
{
// Arrange
_repository.Insert(entity);
_repository.Insert(entity2);
// Act
var all = _repository.GetAll();
try
{
Assert.True(all.Count() >= 2);
}
finally
{
_repository.Delete(entity);
_repository.Delete(entity2);
}
}
public void Delete_PostDeleteHasEvent_IsInvoked(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
var insertedEntity = repository.Insert(entity);
UserHeapEntity?deletedEntity = null;
repository.PostDelete += (tmpEntity) =>
{
deletedEntity = tmpEntity;
};
// Act
var result = repository.Delete(insertedEntity);
// Assert
Assert.Equal(result, deletedEntity);
Assert.Same(result, deletedEntity);
}
public void Get_MultipleRowsWithSameValues_Valid(UserHeapEntity entity)
{
// Arrange
_repository.Insert(entity);
_repository.Insert(entity);
// Act
var gotten = _repository.Get(entity);
try
{
// Assert
Assert.Equal(entity.Username, gotten?.Username);
Assert.Equal(entity.Password, gotten?.Password);
}
finally
{
_repository.Delete(entity);
}
}
public void Delete_PostDeleteThrows_IsDeleted(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
var insertedEntity = repository.Insert(entity);
repository.PostDelete += (tmpEntity) =>
{
throw new InvalidOperationException();
};
// Act
var result = repository.Delete(insertedEntity);
// Assert
Assert.Equal(insertedEntity, result);
var gotten = repository.Get(result !);
Assert.Null(gotten);
}
public async Task Get_MultipleRowsWithSameValues_Valid(UserHeapEntity entity)
{
// Arrange
await _repository.InsertAsync(entity);
await _repository.InsertAsync(entity);
// Act
var gotten = await _repository.GetAsync(entity);
try
{
// Assert
Assert.Equal(entity.Username, gotten?.Username);
Assert.Equal(entity.Password, gotten?.Password);
}
finally
{
await _repository.DeleteAsync(entity);
}
}
public void Delete_PreInsertThrows_IsDeleted(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
var insertedEntity = repository.Insert(entity);
repository.PreDelete += (inputEntity, cancelArgs) =>
{
throw new InvalidOperationException();
};
// Act
var deletedEntity = repository.Delete(insertedEntity);
// Assert
Assert.Equal(insertedEntity, deletedEntity);
var gotten = repository.Get(deletedEntity !);
Assert.Null(gotten);
Assert.NotSame(insertedEntity, deletedEntity); // Ensure we're not just handed the inputEntity back
}
public void Insert_PostInsertThrows_IsInserted(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
repository.PostInsert += (tmpEntity) =>
{
throw new InvalidOperationException();
};
// Act
var insertedEntity = repository.Insert(entity);
// Assert
try
{
Assert.Equal(insertedEntity, repository.Get(entity));
}
finally
{
repository.Delete(insertedEntity);
}
}
public void Delete_PreInsertCancels_IsCanceled(UserHeapEntity entity)
{
// Arrange
var repository = new UserHeapRepository();
var insertedEntity = repository.Insert(entity);
var shouldCancel = true;
repository.PreDelete += (inputEntity, cancelArgs) =>
{
cancelArgs.Cancel = shouldCancel;
};
// Act && Assert
Assert.Throws <CanceledException>(() => repository.Delete(insertedEntity));
// Assert
Assert.NotNull(repository.Get(insertedEntity));
// Cleanup
shouldCancel = false;
repository.Delete(insertedEntity);
}
