Add stage block and commit blocklist blob hooks (#51)

tomas-pajurek · web-flow · commit c651ecbf746d · 2025-05-01T15:14:23.000+02:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
     outputs:
       version: ${{ steps.resolve-version.outputs.version }}
       publish-nuget-org: ${{ startsWith(github.ref, 'refs/tags/v') }}
-      publish-github: ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
+      publish-github: ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'publish-artifacts') }}
     steps:
       - uses: actions/checkout@v4
         with:
diff --git a/docs/storage.md b/docs/storage.md
@@ -481,6 +481,8 @@ Following hooks are supported in both `Before` and `After` variants:
             -   `Upload`
             -   `OpenRead`
             -   `OpenWrite`
+            -   `StageBlock`
+            -   `CommitBlockList`
         -   All `Container` operations
             -   `Create` / `CreateIfNotExists`
     -   All `Table Service` operations
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/BlobOperations.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/BlobOperations.cs
@@ -8,5 +8,7 @@ public enum BlobOperations
     Upload = 2,
     OpenRead = 4,
     OpenWrite = 8,
-    All = Download | Upload | OpenRead | OpenWrite
+    StageBlock = 16,
+    CommitBlockList = 32,
+    All = Download | Upload | OpenRead | OpenWrite | StageBlock | CommitBlockList
 }
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/BlobServiceHookBuilder.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/BlobServiceHookBuilder.cs
@@ -86,6 +86,13 @@ internal BlobOperationsBuilder(BlobHookFilter filter)
 
         public StorageHook<BlobUploadAfterHookContext> AfterBlobUpload(HookFunc<BlobUploadAfterHookContext> hook) => new(hook, _filter);
 
+        public StorageHook<BlobStageBlockBeforeHookContext> BeforeStageBlock(HookFunc<BlobStageBlockBeforeHookContext> hook) => new(hook, _filter);
+
+        public StorageHook<BlobStageBlockAfterHookContext> AfterStageBlock(HookFunc<BlobStageBlockAfterHookContext> hook) => new(hook, _filter);
+
+        public StorageHook<BlobCommitBlockListBeforeHookContext> BeforeCommitBlockList(HookFunc<BlobCommitBlockListBeforeHookContext> hook) => new(hook, _filter);
+
+        public StorageHook<BlobCommitBlockListAfterHookContext> AfterCommitBlockList(HookFunc<BlobCommitBlockListAfterHookContext> hook) => new(hook, _filter);
 
     }
 
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobCommitBlocklistAfterHookContext.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobCommitBlocklistAfterHookContext.cs
@@ -0,0 +1,15 @@
+using Azure.Storage.Blobs.Models;
+
+namespace Spotflow.InMemory.Azure.Storage.Blobs.Hooks.Contexts;
+
+public class BlobCommitBlockListAfterHookContext : BlobAfterHookContext
+{
+    internal BlobCommitBlockListAfterHookContext(BlobCommitBlockListBeforeHookContext beforeContext, BlobContentInfo blobContentInfo) : base(beforeContext)
+    {
+        BeforeContext = beforeContext;
+        BlobContentInfo = blobContentInfo;
+    }
+
+    public BlobCommitBlockListBeforeHookContext BeforeContext { get; }
+    public BlobContentInfo BlobContentInfo { get; }
+}
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobCommitBlocklistBeforeHookContext.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobCommitBlocklistBeforeHookContext.cs
@@ -0,0 +1,9 @@
+using Azure.Storage.Blobs.Models;
+
+namespace Spotflow.InMemory.Azure.Storage.Blobs.Hooks.Contexts;
+
+public class BlobCommitBlockListBeforeHookContext(BlobScope scope, InMemoryStorageProvider provider, CancellationToken cancellationToken)
+    : BlobBeforeHookContext(scope, BlobOperations.CommitBlockList, provider, cancellationToken)
+{
+    public required CommitBlockListOptions? Options { get; init; }
+}
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobStageBlockAfterHookContext.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobStageBlockAfterHookContext.cs
@@ -0,0 +1,15 @@
+using Azure.Storage.Blobs.Models;
+
+namespace Spotflow.InMemory.Azure.Storage.Blobs.Hooks.Contexts;
+
+public class BlobStageBlockAfterHookContext : BlobAfterHookContext
+{
+    internal BlobStageBlockAfterHookContext(BlobStageBlockBeforeHookContext beforeContext, BlockInfo blockInfo) : base(beforeContext)
+    {
+        BeforeContext = beforeContext;
+        BlockInfo = blockInfo;
+    }
+
+    public BlobStageBlockBeforeHookContext BeforeContext { get; }
+    public BlockInfo BlockInfo { get; }
+}
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobStageBlockBeforeHookContext.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Hooks/Contexts/BlobStageBlockBeforeHookContext.cs
@@ -0,0 +1,9 @@
+using Azure.Storage.Blobs.Models;
+
+namespace Spotflow.InMemory.Azure.Storage.Blobs.Hooks.Contexts;
+
+public class BlobStageBlockBeforeHookContext(BlobScope scope, InMemoryStorageProvider provider, CancellationToken cancellationToken)
+    : BlobBeforeHookContext(scope, BlobOperations.StageBlock, provider, cancellationToken)
+{
+    public required BlockBlobStageBlockOptions? Options { get; init; }
+}
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/InMemoryBlockBlobClient.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/InMemoryBlockBlobClient.cs
@@ -103,30 +103,31 @@ public override async Task<Response<BlockList>> GetBlockListAsync(BlockListTypes
 
     public override Response<BlockInfo> StageBlock(string base64BlockId, Stream content, BlockBlobStageBlockOptions? options = null, CancellationToken cancellationToken = default)
     {
-        var blockInfo = _core.StageBlock(base64BlockId, BinaryData.FromStream(content), options, cancellationToken);
-        return InMemoryResponse.FromValue(blockInfo, 201);
+        return StageBlockAsync(base64BlockId, content, options, cancellationToken).EnsureCompleted();
     }
 
     public override Response<BlockInfo> StageBlock(string base64BlockId, Stream content, byte[] transactionalContentHash, BlobRequestConditions conditions, IProgress<long> progressHandler, CancellationToken cancellationToken)
     {
-        var options = new BlockBlobStageBlockOptions
-        {
-            Conditions = conditions
-        };
-
-        return StageBlock(base64BlockId, content, options, cancellationToken);
+        return StageBlockAsync(base64BlockId, content, transactionalContentHash, conditions, progressHandler, cancellationToken).EnsureCompleted();
     }
 
     public override async Task<Response<BlockInfo>> StageBlockAsync(string base64BlockId, Stream content, byte[] transactionalContentHash, BlobRequestConditions conditions, IProgress<long> progressHandler, CancellationToken cancellationToken)
     {
         await Task.Yield();
-        return StageBlock(base64BlockId, content, transactionalContentHash, conditions, progressHandler, cancellationToken);
+
+        var options = new BlockBlobStageBlockOptions
+        {
+            Conditions = conditions
+        };
+
+        return await StageBlockAsync(base64BlockId, content, options, cancellationToken);
     }
 
     public override async Task<Response<BlockInfo>> StageBlockAsync(string base64BlockId, Stream content, BlockBlobStageBlockOptions? options = null, CancellationToken cancellationToken = default)
     {
         await Task.Yield();
-        return StageBlock(base64BlockId, content, options, cancellationToken);
+        var blockInfo = await _core.StageBlockAsync(base64BlockId, BinaryData.FromStream(content), options, cancellationToken);
+        return InMemoryResponse.FromValue(blockInfo, 201);
     }
 
     #endregion
@@ -138,8 +139,7 @@ public override Response<BlobContentInfo> CommitBlockList(
         CommitBlockListOptions options,
         CancellationToken cancellationToken = default)
     {
-        var contentInfo = _core.CommitBlockList(base64BlockIds, options, cancellationToken);
-        return InMemoryResponse.FromValue(contentInfo, 201);
+        return CommitBlockListAsync(base64BlockIds, options, cancellationToken).EnsureCompleted();
     }
 
     public override Response<BlobContentInfo> CommitBlockList(
@@ -150,22 +150,29 @@ public override Response<BlobContentInfo> CommitBlockList(
       AccessTier? accessTier = null,
       CancellationToken cancellationToken = default)
     {
-        var options = new CommitBlockListOptions { HttpHeaders = httpHeaders, Metadata = metadata, Conditions = conditions, AccessTier = accessTier };
-
-        return CommitBlockList(base64BlockIds, options, cancellationToken);
+        return CommitBlockListAsync(base64BlockIds, httpHeaders, metadata, conditions, accessTier, cancellationToken).EnsureCompleted();
     }
 
     public override async Task<Response<BlobContentInfo>> CommitBlockListAsync(IEnumerable<string> base64BlockIds, CommitBlockListOptions options, CancellationToken cancellationToken = default)
     {
         await Task.Yield();
-        return CommitBlockList(base64BlockIds, options, cancellationToken);
-
+        var contentInfo = await _core.CommitBlockListAsync(base64BlockIds, options, cancellationToken);
+        return InMemoryResponse.FromValue(contentInfo, 201);
     }
 
     public override async Task<Response<BlobContentInfo>> CommitBlockListAsync(IEnumerable<string> base64BlockIds, BlobHttpHeaders? httpHeaders = null, IDictionary<string, string>? metadata = null, BlobRequestConditions? conditions = null, AccessTier? accessTier = null, CancellationToken cancellationToken = default)
     {
         await Task.Yield();
-        return CommitBlockList(base64BlockIds, httpHeaders, metadata, conditions, accessTier, cancellationToken);
+
+        var options = new CommitBlockListOptions
+        {
+            HttpHeaders = httpHeaders,
+            Metadata = metadata,
+            Conditions = conditions,
+            AccessTier = accessTier
+        };
+
+        return await CommitBlockListAsync(base64BlockIds, options, cancellationToken);
     }
 
     #endregion
@@ -491,31 +498,34 @@ public override Uri GenerateSasUri(BlobSasBuilder builder)
 
     public override Response<BlockInfo> StageBlockFromUri(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options = null, CancellationToken cancellationToken = default)
     {
-        var properties = _core.StageBlockFromUri(sourceUri, base64BlockId, options, cancellationToken);
-        return InMemoryResponse.FromValue(properties, 201);
+        return StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken).EnsureCompleted();
     }
 
     public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options = null, CancellationToken cancellationToken = default)
     {
         await Task.Yield();
-        return StageBlockFromUri(sourceUri, base64BlockId, options, cancellationToken);
+        var properties = await _core.StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken);
+        return InMemoryResponse.FromValue(properties, 201);
     }
 
     public override Response<BlockInfo> StageBlockFromUri(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)
     {
-        return StageBlockFromUri(sourceUri, base64BlockId, new StageBlockFromUriOptions()
+        return StageBlockFromUriAsync(sourceUri, base64BlockId, sourceRange, sourceContentHash, sourceConditions, conditions, cancellationToken).EnsureCompleted();
+    }
+
+    public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)
+    {
+        await Task.Yield();
+
+        var options = new StageBlockFromUriOptions()
         {
             SourceRange = sourceRange,
             SourceContentHash = sourceContentHash,
             SourceConditions = sourceConditions,
             DestinationConditions = conditions
-        }, cancellationToken);
-    }
+        };
 
-    public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)
-    {
-        await Task.Yield();
-        return StageBlockFromUri(sourceUri, base64BlockId, sourceRange, sourceContentHash, sourceConditions, conditions, cancellationToken);
+        return await StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken);
     }
 
     #endregion
diff --git a/src/Spotflow.InMemory.Azure.Storage/Blobs/Internals/BlobClientCore.cs b/src/Spotflow.InMemory.Azure.Storage/Blobs/Internals/BlobClientCore.cs
@@ -194,18 +194,38 @@ public async Task<BlobContentInfo> UploadAsync(BinaryData content, BlobUploadOpt
 
 
 
-    public BlobContentInfo CommitBlockList(IEnumerable<string> blockIds, CommitBlockListOptions? options, CancellationToken cancellationToken)
+    public async Task<BlobContentInfo> CommitBlockListAsync(IEnumerable<string> blockIds, CommitBlockListOptions? options, CancellationToken cancellationToken)
     {
+        var beforeContext = new BlobCommitBlockListBeforeHookContext(_scope, Provider, cancellationToken)
+        {
+            Options = options
+        };
+
+        await ExecuteBeforeHooksAsync(beforeContext);
+
         RequestConditions? conditions = options?.Conditions;
 
         using var blob = AcquireBlob(cancellationToken);
 
-        return CommitBlockListCoreUnsafe(blockIds, blob.Value, conditions, null, options?.HttpHeaders, options?.Metadata);
+        var info = CommitBlockListCoreUnsafe(blockIds, blob.Value, conditions, null, options?.HttpHeaders, options?.Metadata);
+
+        var afterContext = new BlobCommitBlockListAfterHookContext(beforeContext, info);
+
+        await ExecuteAfterHooksAsync(afterContext);
+
+        return info;
     }
 
 
-    public BlockInfo StageBlock(string blockId, BinaryData content, BlockBlobStageBlockOptions? options, CancellationToken cancellationToken)
+    public async Task<BlockInfo> StageBlockAsync(string blockId, BinaryData content, BlockBlobStageBlockOptions? options, CancellationToken cancellationToken)
     {
+        var beforeContext = new BlobStageBlockBeforeHookContext(_scope, Provider, cancellationToken)
+        {
+            Options = options
+        };
+
+        await ExecuteBeforeHooksAsync(beforeContext);
+
         RequestConditions? conditions = options?.Conditions;
 
         using var blob = AcquireBlob(cancellationToken);
@@ -215,7 +235,13 @@ public BlockInfo StageBlock(string blockId, BinaryData content, BlockBlobStageBl
             throw stageError.GetClientException();
         }
 
-        return block.GetInfo();
+        var info = block.GetInfo();
+
+        var afterContext = new BlobStageBlockAfterHookContext(beforeContext, info);
+
+        await ExecuteAfterHooksAsync(afterContext);
+
+        return info;
     }
 
     public async Task<Stream> OpenWriteAsync(bool overwrite, BlobOpenWriteOptions? options, CancellationToken cancellationToken)
@@ -332,7 +358,7 @@ public async Task<Stream> OpenReadAsync(BlobOpenReadOptions options, Cancellatio
         return stream;
     }
 
-    public BlockInfo StageBlockFromUri(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options, CancellationToken cancellationToken)
+    public async Task<BlockInfo> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options, CancellationToken cancellationToken)
     {
         var sourceUriBuilder = new BlobUriBuilder(sourceUri);
         var sourceClient = new BlobClientCore(sourceUriBuilder, Provider);
@@ -383,7 +409,7 @@ public BlockInfo StageBlockFromUri(Uri sourceUri, string base64BlockId, StageBlo
                 Conditions = options?.DestinationConditions ?? new BlobRequestConditions(),
             };
 
-            return StageBlock(base64BlockId, sourceContent, stageOptions, cancellationToken);
+            return await StageBlockAsync(base64BlockId, sourceContent, stageOptions, cancellationToken);
         }
     }
 
diff --git a/tests/Tests/Storage/Blobs/HooksTests.cs b/tests/Tests/Storage/Blobs/HooksTests.cs
@@ -200,6 +200,87 @@ public void Blob_OpenWrite_Hooks_With_Interceptor_Should_Execute()
 
     }
 
+
+    [TestMethod]
+    public void Blob_StageBlock_Hooks_Should_Execute()
+    {
+        StorageBeforeHookContext? capturedBeforeContextGeneric = null;
+        BlobStageBlockBeforeHookContext? capturedBeforeContextSpecific = null;
+        StorageAfterHookContext? capturedAfterContextGeneric = null;
+        BlobStageBlockAfterHookContext? capturedAfterContextSpecific = null;
+
+        var provider = new InMemoryStorageProvider();
+
+        provider.AddHook(hook => hook.Before(ctx => { capturedBeforeContextGeneric = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.ForBlobService().ForBlobOperations().BeforeStageBlock(ctx => { capturedBeforeContextSpecific = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.ForBlobService().ForBlobOperations().AfterStageBlock(ctx => { capturedAfterContextSpecific = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.After(ctx => { capturedAfterContextGeneric = ctx; return Task.CompletedTask; }));
+
+        var account = provider.AddAccount();
+
+        var containerClient = InMemoryBlobContainerClient.FromAccount(account, "test-container");
+
+        containerClient.Create();
+
+        var data = new BinaryData("test");
+
+        var blobName = "test-blob";
+
+        var blobClient = containerClient.GetBlockBlobClient(blobName);
+
+        blobClient.StageBlock(Convert.ToBase64String([0, 1, 2, 3]), data.ToStream());
+
+        capturedBeforeContextSpecific.Should().NotBeNull();
+        capturedBeforeContextGeneric.Should().BeOfType<BlobStageBlockBeforeHookContext>();
+
+        capturedAfterContextSpecific.Should().NotBeNull();
+        capturedAfterContextGeneric.Should()
+            .BeOfType<BlobStageBlockAfterHookContext>()
+            .Which.BlockInfo.Should().NotBeNull();
+    }
+
+
+    [TestMethod]
+    public void Blob_CommitBlockList_Hooks_Should_Execute()
+    {
+        StorageBeforeHookContext? capturedBeforeContextGeneric = null;
+        BlobCommitBlockListBeforeHookContext? capturedBeforeContextSpecific = null;
+        StorageAfterHookContext? capturedAfterContextGeneric = null;
+        BlobCommitBlockListAfterHookContext? capturedAfterContextSpecific = null;
+
+        var provider = new InMemoryStorageProvider();
+
+        provider.AddHook(hook => hook.Before(ctx => { capturedBeforeContextGeneric = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.ForBlobService().ForBlobOperations().BeforeCommitBlockList(ctx => { capturedBeforeContextSpecific = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.ForBlobService().ForBlobOperations().AfterCommitBlockList(ctx => { capturedAfterContextSpecific = ctx; return Task.CompletedTask; }));
+        provider.AddHook(hook => hook.After(ctx => { capturedAfterContextGeneric = ctx; return Task.CompletedTask; }));
+
+        var account = provider.AddAccount();
+
+        var containerClient = InMemoryBlobContainerClient.FromAccount(account, "test-container");
+
+        containerClient.Create();
+
+        var data = new BinaryData("test");
+
+        var blobName = "test-blob";
+
+        var blobClient = containerClient.GetBlockBlobClient(blobName);
+
+        var blockId = Convert.ToBase64String([0, 1, 2, 3]);
+
+        blobClient.StageBlock(blockId, data.ToStream());
+        blobClient.CommitBlockList([blockId]);
+
+        capturedBeforeContextSpecific.Should().NotBeNull();
+        capturedBeforeContextGeneric.Should().BeOfType<BlobCommitBlockListBeforeHookContext>();
+
+        capturedAfterContextSpecific.Should().NotBeNull();
+        capturedAfterContextGeneric.Should()
+            .BeOfType<BlobCommitBlockListAfterHookContext>()
+            .Which.BlobContentInfo.Should().NotBeNull();
+    }
+
     private class TestBlobWriteStreamInterceptor : IBlobWriteStreamInterceptor
     {
         public int DisposeCount { get; private set; }

Original file line number	Diff line number	Diff line change
`@@ -8,5 +8,7 @@ public enum BlobOperations`
`8`	`8`	`Upload = 2,`
`9`	`9`	`OpenRead = 4,`
`10`	`10`	`OpenWrite = 8,`
`11`		`- All = Download \| Upload \| OpenRead \| OpenWrite`
	`11`	`+ StageBlock = 16,`
	`12`	`+ CommitBlockList = 32,`
	`13`	`+ All = Download \| Upload \| OpenRead \| OpenWrite \| StageBlock \| CommitBlockList`
`12`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,30 +103,31 @@ public override async Task<Response<BlockList>> GetBlockListAsync(BlockListTypes`
`103`	`103`
`104`	`104`	`public override Response<BlockInfo> StageBlock(string base64BlockId, Stream content, BlockBlobStageBlockOptions? options = null, CancellationToken cancellationToken = default)`
`105`	`105`	`{`
`106`		`- var blockInfo = _core.StageBlock(base64BlockId, BinaryData.FromStream(content), options, cancellationToken);`
`107`		`- return InMemoryResponse.FromValue(blockInfo, 201);`
	`106`	`+ return StageBlockAsync(base64BlockId, content, options, cancellationToken).EnsureCompleted();`
`108`	`107`	`}`
`109`	`108`
`110`	`109`	`public override Response<BlockInfo> StageBlock(string base64BlockId, Stream content, byte[] transactionalContentHash, BlobRequestConditions conditions, IProgress<long> progressHandler, CancellationToken cancellationToken)`
`111`	`110`	`{`
`112`		`- var options = new BlockBlobStageBlockOptions`
`113`		`- {`
`114`		`- Conditions = conditions`
`115`		`- };`
`116`		`-`
`117`		`- return StageBlock(base64BlockId, content, options, cancellationToken);`
	`111`	`+ return StageBlockAsync(base64BlockId, content, transactionalContentHash, conditions, progressHandler, cancellationToken).EnsureCompleted();`
`118`	`112`	`}`
`119`	`113`
`120`	`114`	`public override async Task<Response<BlockInfo>> StageBlockAsync(string base64BlockId, Stream content, byte[] transactionalContentHash, BlobRequestConditions conditions, IProgress<long> progressHandler, CancellationToken cancellationToken)`
`121`	`115`	`{`
`122`	`116`	`await Task.Yield();`
`123`		`- return StageBlock(base64BlockId, content, transactionalContentHash, conditions, progressHandler, cancellationToken);`
	`117`	`+`
	`118`	`+ var options = new BlockBlobStageBlockOptions`
	`119`	`+ {`
	`120`	`+ Conditions = conditions`
	`121`	`+ };`
	`122`	`+`
	`123`	`+ return await StageBlockAsync(base64BlockId, content, options, cancellationToken);`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`public override async Task<Response<BlockInfo>> StageBlockAsync(string base64BlockId, Stream content, BlockBlobStageBlockOptions? options = null, CancellationToken cancellationToken = default)`
`127`	`127`	`{`
`128`	`128`	`await Task.Yield();`
`129`		`- return StageBlock(base64BlockId, content, options, cancellationToken);`
	`129`	`+ var blockInfo = await _core.StageBlockAsync(base64BlockId, BinaryData.FromStream(content), options, cancellationToken);`
	`130`	`+ return InMemoryResponse.FromValue(blockInfo, 201);`
`130`	`131`	`}`
`131`	`132`
`132`	`133`	`#endregion`
`@@ -138,8 +139,7 @@ public override Response<BlobContentInfo> CommitBlockList(`
`138`	`139`	`CommitBlockListOptions options,`
`139`	`140`	`CancellationToken cancellationToken = default)`
`140`	`141`	`{`
`141`		`- var contentInfo = _core.CommitBlockList(base64BlockIds, options, cancellationToken);`
`142`		`- return InMemoryResponse.FromValue(contentInfo, 201);`
	`142`	`+ return CommitBlockListAsync(base64BlockIds, options, cancellationToken).EnsureCompleted();`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`public override Response<BlobContentInfo> CommitBlockList(`
`@@ -150,22 +150,29 @@ public override Response<BlobContentInfo> CommitBlockList(`
`150`	`150`	`AccessTier? accessTier = null,`
`151`	`151`	`CancellationToken cancellationToken = default)`
`152`	`152`	`{`
`153`		`- var options = new CommitBlockListOptions { HttpHeaders = httpHeaders, Metadata = metadata, Conditions = conditions, AccessTier = accessTier };`
`154`		`-`
`155`		`- return CommitBlockList(base64BlockIds, options, cancellationToken);`
	`153`	`+ return CommitBlockListAsync(base64BlockIds, httpHeaders, metadata, conditions, accessTier, cancellationToken).EnsureCompleted();`
`156`	`154`	`}`
`157`	`155`
`158`	`156`	`public override async Task<Response<BlobContentInfo>> CommitBlockListAsync(IEnumerable<string> base64BlockIds, CommitBlockListOptions options, CancellationToken cancellationToken = default)`
`159`	`157`	`{`
`160`	`158`	`await Task.Yield();`
`161`		`- return CommitBlockList(base64BlockIds, options, cancellationToken);`
`162`		`-`
	`159`	`+ var contentInfo = await _core.CommitBlockListAsync(base64BlockIds, options, cancellationToken);`
	`160`	`+ return InMemoryResponse.FromValue(contentInfo, 201);`
`163`	`161`	`}`
`164`	`162`
`165`	`163`	`public override async Task<Response<BlobContentInfo>> CommitBlockListAsync(IEnumerable<string> base64BlockIds, BlobHttpHeaders? httpHeaders = null, IDictionary<string, string>? metadata = null, BlobRequestConditions? conditions = null, AccessTier? accessTier = null, CancellationToken cancellationToken = default)`
`166`	`164`	`{`
`167`	`165`	`await Task.Yield();`
`168`		`- return CommitBlockList(base64BlockIds, httpHeaders, metadata, conditions, accessTier, cancellationToken);`
	`166`	`+`
	`167`	`+ var options = new CommitBlockListOptions`
	`168`	`+ {`
	`169`	`+ HttpHeaders = httpHeaders,`
	`170`	`+ Metadata = metadata,`
	`171`	`+ Conditions = conditions,`
	`172`	`+ AccessTier = accessTier`
	`173`	`+ };`
	`174`	`+`
	`175`	`+ return await CommitBlockListAsync(base64BlockIds, options, cancellationToken);`
`169`	`176`	`}`
`170`	`177`
`171`	`178`	`#endregion`
`@@ -491,31 +498,34 @@ public override Uri GenerateSasUri(BlobSasBuilder builder)`
`491`	`498`
`492`	`499`	`public override Response<BlockInfo> StageBlockFromUri(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options = null, CancellationToken cancellationToken = default)`
`493`	`500`	`{`
`494`		`- var properties = _core.StageBlockFromUri(sourceUri, base64BlockId, options, cancellationToken);`
`495`		`- return InMemoryResponse.FromValue(properties, 201);`
	`501`	`+ return StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken).EnsureCompleted();`
`496`	`502`	`}`
`497`	`503`
`498`	`504`	`public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, StageBlockFromUriOptions? options = null, CancellationToken cancellationToken = default)`
`499`	`505`	`{`
`500`	`506`	`await Task.Yield();`
`501`		`- return StageBlockFromUri(sourceUri, base64BlockId, options, cancellationToken);`
	`507`	`+ var properties = await _core.StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken);`
	`508`	`+ return InMemoryResponse.FromValue(properties, 201);`
`502`	`509`	`}`
`503`	`510`
`504`	`511`	`public override Response<BlockInfo> StageBlockFromUri(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)`
`505`	`512`	`{`
`506`		`- return StageBlockFromUri(sourceUri, base64BlockId, new StageBlockFromUriOptions()`
	`513`	`+ return StageBlockFromUriAsync(sourceUri, base64BlockId, sourceRange, sourceContentHash, sourceConditions, conditions, cancellationToken).EnsureCompleted();`
	`514`	`+ }`
	`515`	`+`
	`516`	`+ public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)`
	`517`	`+ {`
	`518`	`+ await Task.Yield();`
	`519`	`+`
	`520`	`+ var options = new StageBlockFromUriOptions()`
`507`	`521`	`{`
`508`	`522`	`SourceRange = sourceRange,`
`509`	`523`	`SourceContentHash = sourceContentHash,`
`510`	`524`	`SourceConditions = sourceConditions,`
`511`	`525`	`DestinationConditions = conditions`
`512`		`- }, cancellationToken);`
`513`		`- }`
	`526`	`+ };`
`514`	`527`
`515`		`- public override async Task<Response<BlockInfo>> StageBlockFromUriAsync(Uri sourceUri, string base64BlockId, HttpRange sourceRange, byte[] sourceContentHash, RequestConditions sourceConditions, BlobRequestConditions conditions, CancellationToken cancellationToken)`
`516`		`- {`
`517`		`- await Task.Yield();`
`518`		`- return StageBlockFromUri(sourceUri, base64BlockId, sourceRange, sourceContentHash, sourceConditions, conditions, cancellationToken);`
	`528`	`+ return await StageBlockFromUriAsync(sourceUri, base64BlockId, options, cancellationToken);`
`519`	`529`	`}`
`520`	`530`
`521`	`531`	`#endregion`