Added tests for setting properties on AudioNodes.

KristofferStrube · KristofferStrube · commit 4f32ee06d004 · 2025-03-11T17:43:27.000+01:00
diff --git a/src/KristofferStrube.Blazor.WebAudio/AudioNodes/AudioNode.cs b/src/KristofferStrube.Blazor.WebAudio/AudioNodes/AudioNode.cs
@@ -32,10 +32,14 @@ public abstract class AudioNode : EventTarget
     /// <inheritdoc cref="IJSCreatable{AudioNode}.CreateAsync(IJSRuntime, IJSObjectReference, CreationOptions)"/>
     protected AudioNode(IJSRuntime jSRuntime, IJSObjectReference jSReference, CreationOptions options) : base(jSRuntime, jSReference, options)
     {
-        webAudioHelperTask = new(jSRuntime.GetHelperAsync);
         if (jSRuntime is not IJSInProcessRuntime || ErrorHandlingJSInterop.ErrorHandlingJSInteropHasBeenSetup)
         {
             errorHandlingJSReference = new ErrorHandlingJSObjectReference(jSRuntime, jSReference);
+            webAudioHelperTask = new(async () => await jSRuntime.GetErrorHandlingHelperAsync());
+        }
+        else
+        {
+            webAudioHelperTask = new(jSRuntime.GetHelperAsync);
         }
     }
 
@@ -264,6 +268,10 @@ public async Task<ChannelCountMode> GetChannelCountModeAsync()
     /// The default value is <see cref="ChannelCountMode.Max"/>.
     /// This attribute has no effect for nodes with no inputs.
     /// </summary>
+    /// <remarks>
+    /// Throws an <see cref="InvalidStateErrorException"/> if the audio node type does not support changing the channel count mode.<br />
+    /// Throws an <see cref="NotSupportedErrorException"/> if the channel count mode is not supported for the audio node type.<br />
+    /// </remarks>
     public async Task SetChannelCountModeAsync(ChannelCountMode value)
     {
         IJSObjectReference helper = await webAudioHelperTask.Value;
@@ -275,6 +283,9 @@ public async Task SetChannelCountModeAsync(ChannelCountMode value)
     /// The default value is <see cref="ChannelInterpretation.Speakers"/>.
     /// This attribute has no effect for nodes with no inputs.
     /// </summary>
+    /// <remarks>
+    /// Throws an <see cref="InvalidStateErrorException"/> if the audio node type does not support changing the channel interpretation.<br />
+    /// </remarks>
     public async Task<ChannelInterpretation> GetChannelInterpretationAsync()
     {
         IJSObjectReference helper = await webAudioHelperTask.Value;
diff --git a/src/KristofferStrube.Blazor.WebAudio/Options/MediaElementAudioSourceOptions.cs b/src/KristofferStrube.Blazor.WebAudio/Options/MediaElementAudioSourceOptions.cs
@@ -1,5 +1,19 @@
-﻿namespace KristofferStrube.Blazor.WebAudio.Options;
+﻿using Microsoft.JSInterop;
+using System.Text.Json.Serialization;
 
+namespace KristofferStrube.Blazor.WebAudio.Options;
+
+/// <summary>
+/// This specifies the options to use in constructing a <see cref="MediaElementAudioSourceNode"/>.
+/// </summary>
+/// <remarks>
+/// <see href="https://www.w3.org/TR/webaudio/#MediaElementAudioSourceOptions">See the API definition here</see>.
+/// </remarks>
 public class MediaElementAudioSourceOptions
 {
+    /// <summary>
+    /// The media element that will be re-routed.
+    /// </summary>
+    [JsonPropertyName("mediaElement")]
+    public required IJSObjectReference MediaElement { get; set; }
 }
diff --git a/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamAudioDestinationOptions.cs b/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamAudioDestinationOptions.cs
@@ -1,7 +1,7 @@
 ﻿namespace KristofferStrube.Blazor.WebAudio.Options;
 
 /// <summary>
-/// This specifies the options to use in constructing an <see cref="MediaStreamAudioDestinationNode"/>.
+/// This specifies the options to use in constructing a <see cref="MediaStreamAudioDestinationNode"/>.
 /// </summary>
 /// <remarks>
 /// This type doesn't exist in the specs, but the <see cref="MediaStreamAudioDestinationNode"/> has a non-standard value for the <see cref="AudioNodeOptions.ChannelCountMode"/> attribute which is why this type is added in this wrapper.<br />
diff --git a/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamAudioSourceOptions.cs b/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamAudioSourceOptions.cs
@@ -4,7 +4,7 @@
 namespace KristofferStrube.Blazor.WebAudio;
 
 /// <summary>
-/// This specifies the options to use in constructing an <see cref="MediaStreamAudioSourceNode"/>.
+/// This specifies the options to use in constructing a <see cref="MediaStreamAudioSourceNode"/>.
 /// </summary>
 /// <remarks><see href="https://www.w3.org/TR/webaudio/#MediaStreamAudioSourceOptions">See the API definition here</see>.</remarks>
 public class MediaStreamAudioSourceOptions
diff --git a/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamTrackAudioSourceOptions.cs b/src/KristofferStrube.Blazor.WebAudio/Options/MediaStreamTrackAudioSourceOptions.cs
@@ -4,7 +4,7 @@
 namespace KristofferStrube.Blazor.WebAudio;
 
 /// <summary>
-/// This specifies the options to use in constructing an <see cref="MediaStreamTrackAudioSourceNode"/>.
+/// This specifies the options to use in constructing a <see cref="MediaStreamTrackAudioSourceNode"/>.
 /// </summary>
 /// <remarks><see href="https://www.w3.org/TR/webaudio/#MediaStreamTrackAudioSourceOptions">See the API definition here</see>.</remarks>
 public class MediaStreamTrackAudioSourceOptions
diff --git a/tests/BlazorServer/Pages/Index.razor b/tests/BlazorServer/Pages/Index.razor
@@ -2,6 +2,15 @@
 
 <span data-testid="result">@result</span>
 
+<HeadContent>
+    <script>
+        function getAudioElement() {
+            let audioElement = document.createElement("audio");
+            return audioElement;
+        }
+    </script>
+</HeadContent>
+
 @code {
     string? result;
 
diff --git a/tests/IntegrationTests/AudioNodeTests/AudioNodeTest.cs b/tests/IntegrationTests/AudioNodeTests/AudioNodeTest.cs
@@ -7,6 +7,10 @@ public abstract class AudioNodeTest<TAudioNode> : AudioContextBlazorTest where T
 {
     public abstract Task<TAudioNode> GetDefaultInstanceAsync();
 
+    public virtual Dictionary<ChannelCountMode, Type> UnsupportedChannelCountModes => [];
+
+    public virtual Dictionary<ChannelInterpretation, Type> UnsupportedChannelInterpretations => [];
+
     [Test]
     public async Task CreateAsync_WithNoOptions_Succeeds()
     {
@@ -24,4 +28,67 @@ public async Task CreateAsync_WithNoOptions_Succeeds()
         _ = EvaluationContext.Result.Should().BeOfType<TAudioNode>();
     }
 
+    [TestCase(ChannelCountMode.Max)]
+    [TestCase(ChannelCountMode.Explicit)]
+    [TestCase(ChannelCountMode.ClampedMax)]
+    [Test]
+    public async Task SettingChannelCountMode_SetsChannelCountMode_ExceptForUnsupportedValues(ChannelCountMode mode)
+    {
+        // Arrange
+        AfterRenderAsync = async () =>
+        {
+            await using TAudioNode node = await GetDefaultInstanceAsync();
+
+            await node.SetChannelCountModeAsync(mode);
+
+            return await node.GetChannelCountModeAsync();
+        };
+
+        // Act
+        await OnAfterRerenderAsync();
+
+        // Assert
+        if (UnsupportedChannelCountModes.TryGetValue(mode, out Type? exceptionType))
+        {
+            _ = EvaluationContext.Result.Should().Be(null);
+            _ = EvaluationContext.Exception.Should().BeOfType(exceptionType);
+        }
+        else
+        {
+            _ = EvaluationContext.Exception.Should().BeNull();
+            _ = EvaluationContext.Result.Should().Be(mode);
+        }
+    }
+
+    [TestCase(ChannelInterpretation.Discrete)]
+    [TestCase(ChannelInterpretation.Speakers)]
+    [Test]
+    public async Task SettingChannelInterpretation_SetsInterpretation_ExceptForUnsupportedValues(ChannelInterpretation interpretation)
+    {
+        // Arrange
+        AfterRenderAsync = async () =>
+        {
+            await using TAudioNode node = await GetDefaultInstanceAsync();
+
+            await node.SetChannelInterpretationAsync(interpretation);
+
+            return await node.GetChannelInterpretationAsync();
+        };
+
+        // Act
+        await OnAfterRerenderAsync();
+
+        // Assert
+        if (UnsupportedChannelInterpretations.TryGetValue(interpretation, out Type? exceptionType))
+        {
+            _ = EvaluationContext.Result.Should().Be(null);
+            _ = EvaluationContext.Exception.Should().BeOfType(exceptionType);
+        }
+        else
+        {
+            _ = EvaluationContext.Exception.Should().BeNull();
+            _ = EvaluationContext.Result.Should().Be(interpretation);
+        }
+    }
+
 }
diff --git a/tests/IntegrationTests/AudioNodeTests/AudioNodeWithAudioNodeOptions.cs b/tests/IntegrationTests/AudioNodeTests/AudioNodeWithAudioNodeOptions.cs
@@ -12,8 +12,6 @@ public override async Task<TAudioNode> GetDefaultInstanceAsync()
         return await CreateAsync(EvaluationContext.JSRuntime, await EvaluationContext.GetAudioContext(), null);
     }
 
-    public virtual Dictionary<ChannelCountMode, Type> UnsupportedChannelCountModes => [];
-
     [Test]
     public async Task CreateAsync_WithEmptyOptions_Succeeds()
     {
@@ -83,7 +81,7 @@ public async Task CreateAsync_WithEmptyOptions_HasSameChannelInterpretationAsWhe
     [TestCase(ChannelCountMode.Explicit)]
     [TestCase(ChannelCountMode.ClampedMax)]
     [Test]
-    public async Task CreateAsync_WithDifferentChannelCountModes_SetsChannelCount_ExceptForUnsupportedValues(ChannelCountMode mode)
+    public async Task CreateAsync_WithDifferentChannelCountModes_SetsChannelCountMode_ExceptForUnsupportedValues(ChannelCountMode mode)
     {
         // Arrange
         AfterRenderAsync = async () =>
@@ -111,4 +109,36 @@ public async Task CreateAsync_WithDifferentChannelCountModes_SetsChannelCount_Ex
             _ = EvaluationContext.Result.Should().Be(mode);
         }
     }
+
+    [TestCase(ChannelInterpretation.Discrete)]
+    [TestCase(ChannelInterpretation.Speakers)]
+    [Test]
+    public async Task CreateAsync_WithDifferentChannelInterpretations_SetsChannelInterpretation_ExceptForUnsupportedValues(ChannelInterpretation interpretation)
+    {
+        // Arrange
+        AfterRenderAsync = async () =>
+        {
+            TAudioNodeOptions options = new();
+            options.ChannelInterpretation = interpretation;
+
+            await using TAudioNode node = await CreateAsync(EvaluationContext.JSRuntime, await EvaluationContext.GetAudioContext(), options);
+
+            return await node.GetChannelInterpretationAsync();
+        };
+
+        // Act
+        await OnAfterRerenderAsync();
+
+        // Assert
+        if (UnsupportedChannelInterpretations.TryGetValue(interpretation, out Type? exceptionType))
+        {
+            _ = EvaluationContext.Result.Should().Be(null);
+            _ = EvaluationContext.Exception.Should().BeOfType(exceptionType);
+        }
+        else
+        {
+            _ = EvaluationContext.Exception.Should().BeNull();
+            _ = EvaluationContext.Result.Should().Be(interpretation);
+        }
+    }
 }
diff --git a/tests/IntegrationTests/AudioNodeTests/ChannelSplitterNodeTest.cs b/tests/IntegrationTests/AudioNodeTests/ChannelSplitterNodeTest.cs
@@ -13,4 +13,9 @@ public override async Task<ChannelSplitterNode> CreateAsync(IJSRuntime jSRuntime
         [ChannelCountMode.Max] = typeof(InvalidStateErrorException),
         [ChannelCountMode.ClampedMax] = typeof(InvalidStateErrorException),
     };
+
+    public override Dictionary<ChannelInterpretation, Type> UnsupportedChannelInterpretations => new()
+    {
+        [ChannelInterpretation.Speakers] = typeof(InvalidStateErrorException),
+    };
 }
diff --git a/tests/IntegrationTests/AudioNodeTests/MediaElementAudioSourceNodeTest.cs b/tests/IntegrationTests/AudioNodeTests/MediaElementAudioSourceNodeTest.cs
@@ -0,0 +1,16 @@
+﻿using KristofferStrube.Blazor.WebAudio.Options;
+using Microsoft.JSInterop;
+
+namespace IntegrationTests.AudioNodeTests;
+
+public class MediaElementAudioSourceNodeTest : AudioNodeTest<MediaElementAudioSourceNode>
+{
+    public override async Task<MediaElementAudioSourceNode> GetDefaultInstanceAsync()
+    {
+        IJSObjectReference element = await EvaluationContext.GetAudioElementAyns();
+        return await MediaElementAudioSourceNode.CreateAsync(EvaluationContext.JSRuntime, await EvaluationContext.GetAudioContext(), new MediaElementAudioSourceOptions()
+        {
+            MediaElement = element
+        });
+    }
+}
diff --git a/tests/IntegrationTests/AudioNodeTests/MediaStreamAudioSourceNodeTest.cs b/tests/IntegrationTests/AudioNodeTests/MediaStreamAudioSourceNodeTest.cs
@@ -0,0 +1,12 @@
+﻿namespace IntegrationTests.AudioNodeTests;
+
+public class MediaStreamAudioSourceNodeTest : AudioNodeTest<MediaStreamAudioSourceNode>
+{
+    public override async Task<MediaStreamAudioSourceNode> GetDefaultInstanceAsync()
+    {
+        return await MediaStreamAudioSourceNode.CreateAsync(EvaluationContext.JSRuntime, await EvaluationContext.GetAudioContext(), new MediaStreamAudioSourceOptions()
+        {
+            MediaStream = await EvaluationContext.GetMediaStream()
+        });
+    }
+}
diff --git a/tests/IntegrationTests/Infrastructure/AudioContextEvaluationContext.cs b/tests/IntegrationTests/Infrastructure/AudioContextEvaluationContext.cs
@@ -1,23 +1,39 @@
 ﻿using BlazorServer;
+using KristofferStrube.Blazor.MediaCaptureStreams;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.JSInterop;
 
 namespace IntegrationTests.Infrastructure;
 
-public class AudioContextEvaluationContext(IJSRuntime jSRuntime) : EvaluationContext, IEvaluationContext<AudioContextEvaluationContext>
+public class AudioContextEvaluationContext(IJSRuntime jSRuntime, IMediaDevicesService mediaDevicesService) : EvaluationContext, IEvaluationContext<AudioContextEvaluationContext>
 {
     public IJSRuntime JSRuntime => jSRuntime;
 
+    public IMediaDevicesService MediaDevicesService => mediaDevicesService;
+
     public static AudioContextEvaluationContext Create(IServiceProvider provider)
     {
+        IMediaDevicesService mediaDevicesService = provider.GetRequiredService<IMediaDevicesService>();
         IJSRuntime jSRuntime = provider.GetRequiredService<IJSRuntime>();
 
-        return new AudioContextEvaluationContext(jSRuntime);
+        return new AudioContextEvaluationContext(jSRuntime, mediaDevicesService);
     }
 
     public async Task<AudioContext> GetAudioContext()
     {
         AudioContext audioContext = await AudioContext.CreateAsync(jSRuntime);
         return audioContext;
     }
+
+    public async Task<MediaStream> GetMediaStream()
+    {
+        await using MediaDevices mediaDevices = await mediaDevicesService.GetMediaDevicesAsync();
+        MediaStream mediaStream = await mediaDevices.GetUserMediaAsync(new() { Audio = true });
+        return mediaStream;
+    }
+
+    public async Task<IJSObjectReference> GetAudioElementAyns()
+    {
+        return await JSRuntime.InvokeAsync<IJSObjectReference>("getAudioElement");
+    }
 }
diff --git a/tests/IntegrationTests/Infrastructure/AudioMediaStreamBlazorTest.cs b/tests/IntegrationTests/Infrastructure/AudioMediaStreamBlazorTest.cs
diff --git a/tests/IntegrationTests/Infrastructure/AudioMediaStreamEvaluationContext.cs b/tests/IntegrationTests/Infrastructure/AudioMediaStreamEvaluationContext.cs

Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,14 @@ public abstract class AudioNode : EventTarget`
`32`	`32`	`/// <inheritdoc cref="IJSCreatable{AudioNode}.CreateAsync(IJSRuntime, IJSObjectReference, CreationOptions)"/>`
`33`	`33`	`protected AudioNode(IJSRuntime jSRuntime, IJSObjectReference jSReference, CreationOptions options) : base(jSRuntime, jSReference, options)`
`34`	`34`	`{`
`35`		`- webAudioHelperTask = new(jSRuntime.GetHelperAsync);`
`36`	`35`	`if (jSRuntime is not IJSInProcessRuntime \|\| ErrorHandlingJSInterop.ErrorHandlingJSInteropHasBeenSetup)`
`37`	`36`	`{`
`38`	`37`	`errorHandlingJSReference = new ErrorHandlingJSObjectReference(jSRuntime, jSReference);`
	`38`	`+ webAudioHelperTask = new(async () => await jSRuntime.GetErrorHandlingHelperAsync());`
	`39`	`+ }`
	`40`	`+ else`
	`41`	`+ {`
	`42`	`+ webAudioHelperTask = new(jSRuntime.GetHelperAsync);`
`39`	`43`	`}`
`40`	`44`	`}`
`41`	`45`
`@@ -264,6 +268,10 @@ public async Task<ChannelCountMode> GetChannelCountModeAsync()`
`264`	`268`	`/// The default value is <see cref="ChannelCountMode.Max"/>.`
`265`	`269`	`/// This attribute has no effect for nodes with no inputs.`
`266`	`270`	`/// </summary>`
	`271`	`+ /// <remarks>`
	`272`	`+ /// Throws an <see cref="InvalidStateErrorException"/> if the audio node type does not support changing the channel count mode.<br />`
	`273`	`+ /// Throws an <see cref="NotSupportedErrorException"/> if the channel count mode is not supported for the audio node type.<br />`
	`274`	`+ /// </remarks>`
`267`	`275`	`public async Task SetChannelCountModeAsync(ChannelCountMode value)`
`268`	`276`	`{`
`269`	`277`	`IJSObjectReference helper = await webAudioHelperTask.Value;`
`@@ -275,6 +283,9 @@ public async Task SetChannelCountModeAsync(ChannelCountMode value)`
`275`	`283`	`/// The default value is <see cref="ChannelInterpretation.Speakers"/>.`
`276`	`284`	`/// This attribute has no effect for nodes with no inputs.`
`277`	`285`	`/// </summary>`
	`286`	`+ /// <remarks>`
	`287`	`+ /// Throws an <see cref="InvalidStateErrorException"/> if the audio node type does not support changing the channel interpretation.<br />`
	`288`	`+ /// </remarks>`
`278`	`289`	`public async Task<ChannelInterpretation> GetChannelInterpretationAsync()`
`279`	`290`	`{`
`280`	`291`	`IJSObjectReference helper = await webAudioHelperTask.Value;`