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 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_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 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 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 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 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);
}
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 HeapAsyncTests()
{
_repository = new UserHeapRepository();
}
