@capgo/capacitor-native-audio 8.4.3

package/ios/Tests/NativeAudioPluginTests/PluginTests.swift

@@ -0,0 +1,648 @@
+import XCTest
+import Capacitor
+import AVFoundation
+@testable import NativeAudioPlugin
+
+// swiftlint:disable file_length
+class PluginTests: XCTestCase {
+
+    var plugin = NativeAudio()
+    var tempFileURL = URL(fileURLWithPath: NSTemporaryDirectory().appending("testAudio.wav"))
+    var testAssetId = "testAssetId"
+    var testRemoteAssetId = "testRemoteAssetId"
+
+    override func setUp() {
+        super.setUp()
+        plugin = NativeAudio()
+        plugin.isRunningTests = true
+
+        // Create a temporary audio file for testing
+        let audioFilePath = NSTemporaryDirectory().appending("testAudio.wav")
+        tempFileURL = URL(fileURLWithPath: audioFilePath)
+
+        // Create a simple test audio file if needed
+        if !FileManager.default.fileExists(atPath: audioFilePath) {
+            createTestAudioFile(at: audioFilePath)
+        }
+    }
+
+    override func tearDown() {
+        // Clean up any audio assets
+        plugin.executeOnAudioQueue {
+            if let asset = self.plugin.audioList[self.testAssetId] as? AudioAsset {
+                asset.unload()
+            }
+            if let asset = self.plugin.audioList[self.testRemoteAssetId] as? RemoteAudioAsset {
+                asset.unload()
+            }
+            self.plugin.audioList.removeAll()
+        }
+
+        // Try to delete the temporary file
+        try? FileManager.default.removeItem(at: tempFileURL)
+
+        plugin = nil
+        super.tearDown()
+    }
+
+    // Helper method to create a simple test audio file
+    private func createTestAudioFile(at path: String) {
+        // This is a placeholder for a real implementation
+        // In a real scenario, you would create a small audio file for testing
+        // For now, we'll just create an empty file
+        FileManager.default.createFile(atPath: path, contents: Data(), attributes: nil)
+    }
+
+    private func makeCall(callbackId: String, options: [String: Any], onErrorMessage: String) -> CAPPluginCall {
+        guard let call = CAPPluginCall(callbackId: callbackId, options: options, success: { _, _ in }, error: { _ in }) else {
+            XCTFail("Failed to create CAPPluginCall: \(onErrorMessage)")
+            fatalError("Failed to create CAPPluginCall")
+        }
+        return call
+    }
+
+}
+
+extension PluginTests {
+
+    func testAudioAssetInitialization() {
+        let expectation = XCTestExpectation(description: "Initialize AudioAsset")
+
+        plugin.executeOnAudioQueue {
+            // Create an audio asset
+            let asset = AudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testAssetId,
+                withPath: self.tempFileURL.path,
+                withChannels: 1,
+                withVolume: 0.5
+            )
+
+            // Add it to the plugin's audio list
+            self.plugin.audioList[self.testAssetId] = asset
+
+            // Verify initial values
+            XCTAssertEqual(asset.assetId, self.testAssetId)
+            XCTAssertEqual(asset.initialVolume, 0.5)
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    func testAudioAssetVolumeControl() {
+        let expectation = XCTestExpectation(description: "Test volume control")
+
+        plugin.executeOnAudioQueue {
+            // Create an audio asset
+            let asset = AudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testAssetId,
+                withPath: self.tempFileURL.path,
+                withChannels: 1,
+                withVolume: 1.0
+            )
+
+            // Add it to the plugin's audio list
+            self.plugin.audioList[self.testAssetId] = asset
+
+            // Test setting volume
+            let testVolume: Float = 0.7
+            asset.setVolume(volume: NSNumber(value: testVolume), fadeDuration: 0)
+
+            // We can't directly check player.volume as it may take time to set
+            // So we'll just verify the method doesn't crash
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    func testRemoteAudioAssetInitialization() {
+        let expectation = XCTestExpectation(description: "Initialize RemoteAudioAsset")
+
+        // Use a publicly accessible test audio URL
+        let testURL = "https://file-examples.com/storage/fe5947fd2362a2f06a86851/2017/11/file_example_MP3_700KB.mp3"
+
+        plugin.executeOnAudioQueue {
+            // Create a remote audio asset
+            let asset = RemoteAudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testRemoteAssetId,
+                withPath: testURL,
+                withChannels: 1,
+                withVolume: 0.6,
+                withHeaders: nil
+            )
+
+            // Add it to the plugin's audio list
+            self.plugin.audioList[self.testRemoteAssetId] = asset
+
+            // Verify initial values
+            XCTAssertEqual(asset.assetId, self.testRemoteAssetId)
+            XCTAssertEqual(asset.initialVolume, 0.6)
+            XCTAssertNotNil(asset.asset, "AVURLAsset should be created")
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    func testPluginPreloadMethod() {
+        // Create a plugin call to test the preload method
+        let call = makeCall(callbackId: "test", options: [
+            "assetId": testAssetId,
+            "assetPath": tempFileURL.path,
+            "volume": 0.8,
+            "audioChannelNum": 2
+        ], onErrorMessage: "Preload call creation")
+
+        // Call the plugin method
+        plugin.preload(call)
+
+        // Verify the asset was loaded by checking if it exists in the audioList
+        plugin.executeOnAudioQueue {
+            XCTAssertNotNil(self.plugin.audioList[self.testAssetId])
+            if let asset = self.plugin.audioList[self.testAssetId] as? AudioAsset {
+                XCTAssertEqual(asset.assetId, self.testAssetId)
+                XCTAssertEqual(asset.initialVolume, 0.8)
+            } else {
+                XCTFail("Asset should be of type AudioAsset")
+            }
+        }
+    }
+
+    func testFadeEffects() {
+        let expectation = XCTestExpectation(description: "Test fade effects")
+
+        plugin.executeOnAudioQueue {
+            // Create an audio asset
+            let asset = AudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testAssetId,
+                withPath: self.tempFileURL.path,
+                withChannels: 1,
+                withVolume: 1.0
+            )
+
+            // Test fade functionality (just make sure it doesn't crash)
+            asset.playWithFade(time: 0)
+
+            // Wait a short time for fade to start
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                // Then test stop with fade
+                asset.stopWithFade()
+
+                // Wait for fade to complete
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    // Test the ClearCache functionality
+    func testClearCache() {
+        // This is mostly a method call test to ensure it doesn't crash
+        RemoteAudioAsset.clearCache()
+
+        // We can't easily verify the cache was cleared without complex setup,
+        // but we can ensure the method completes without errors
+        XCTAssertTrue(true)
+    }
+
+    // Test notification observer pattern in RemoteAudioAsset
+    func testNotificationObserverPattern() {
+        let expectation = XCTestExpectation(description: "Test notification observer")
+
+        // Use a publicly accessible test audio URL
+        let testURL = "https://file-examples.com/storage/fe5947fd2362a2f06a86851/2017/11/file_example_MP3_700KB.mp3"
+
+        plugin.executeOnAudioQueue {
+            // Create a remote audio asset
+            let asset = RemoteAudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testRemoteAssetId,
+                withPath: testURL,
+                withChannels: 1,
+                withVolume: 0.6,
+                withHeaders: nil
+            )
+
+            // Add it to the plugin's audio list
+            self.plugin.audioList[self.testRemoteAssetId] = asset
+
+            // Verify initial values
+            XCTAssertEqual(asset.notificationObservers.count, 0, "Should start with zero notification observers")
+
+            // Test the resume method which sets up a notification observer
+            asset.resume()
+
+            // Check that a notification observer was added
+            XCTAssertGreaterThan(asset.notificationObservers.count, 0, "Should have added notification observers")
+
+            // Now test cleanup
+            asset.cleanupNotificationObservers()
+            XCTAssertEqual(asset.notificationObservers.count, 0, "Should have removed all notification observers")
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    // Test the fade timer functionality, which was a key part of our fixes
+    func testFadeTimerFunctionality() {
+        let expectation = XCTestExpectation(description: "Test fade timer")
+
+        plugin.executeOnAudioQueue {
+            // Create an audio asset
+            let asset = AudioAsset(
+                owner: self.plugin,
+                withAssetId: self.testAssetId,
+                withPath: self.tempFileURL.path,
+                withChannels: 1,
+                withVolume: 1.0
+            )
+
+            // Ensure the fade timer is nil initially
+            XCTAssertNil(asset.fadeTimer, "Fade timer should be nil initially")
+
+            // Access the private method using reflection
+            // (this is a test-only approach to access private methods)
+            let selector = NSSelectorFromString("startVolumeRamp:to:player:")
+            if asset.responds(to: selector) {
+                // Create a test mock for AVAudioPlayer
+                guard let player = asset.channels.first else {
+                    XCTFail("No audio player available")
+                    expectation.fulfill()
+                    return
+                }
+
+                // Set initial volume
+                player.volume = 1.0
+
+                // Invoke using performSelector - Note: perform only supports up to 2 'with:' parameters
+                // This test is disabled as the selector requires 3 parameters
+                // asset.perform(selector, with: NSNumber(value: 1.0), with: NSNumber(value: 0.0))
+
+                // Check that the fade timer was created
+                XCTAssertNotNil(asset.fadeTimer, "Fade timer should be created")
+
+                // Wait for fade to complete
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                    // Fade should be complete, timer should be nil again
+                    XCTAssertNil(asset.fadeTimer, "Fade timer should be nil after completion")
+                    XCTAssertEqual(player.volume, 0.0, "Volume should be 0 after fade out")
+
+                    expectation.fulfill()
+                }
+            } else {
+                XCTFail("startVolumeRamp method not available")
+                expectation.fulfill()
+            }
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    // MARK: - PlayOnce Tests
+
+    func testPlayOnceWithAutoPlay() {
+        let expectation = XCTestExpectation(description: "PlayOnce with auto-play")
+        var returnedAssetId: String?
+
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": true
+        ], onErrorMessage: "playOnce auto-play call")
+        _ = returnedAssetId
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+
+            // Wait for async operations
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                // Verify asset was created and is in playOnceAssets
+                self.plugin.executeOnAudioQueue {
+                    let playOnceAssets = self.plugin.playOnceAssets
+                    XCTAssertTrue(playOnceAssets.count > 0, "Should have created a playOnce asset")
+
+                    // Verify the returned assetId matches an entry in playOnceAssets and audioList
+                    if let assetId = returnedAssetId {
+                        XCTAssertTrue(playOnceAssets.contains(assetId), "Returned assetId should be in playOnceAssets")
+                        XCTAssertNotNil(self.plugin.audioList[assetId], "Returned assetId should have corresponding AudioAsset")
+                    } else {
+                        XCTFail("Should have returned an assetId")
+                    }
+
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 3.0)
+    }
+
+    func testPlayOnceWithoutAutoPlay() {
+        let expectation = XCTestExpectation(description: "PlayOnce without auto-play")
+
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 0.8,
+            "isUrl": true,
+            "autoPlay": false
+        ], onErrorMessage: "playOnce no-autoplay call")
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+
+            // Wait for async operations
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                self.plugin.executeOnAudioQueue {
+                    // Asset should be created but not playing
+                    let playOnceAssets = self.plugin.playOnceAssets
+                    XCTAssertTrue(playOnceAssets.count > 0, "Should have created a playOnce asset")
+
+                    if let assetId = playOnceAssets.first,
+                       let asset = self.plugin.audioList[assetId] as? AudioAsset {
+                        // Verify asset exists but is not automatically playing
+                        XCTAssertFalse(asset.channels.isEmpty, "Asset should have channels")
+
+                        // Verify player is not playing when autoPlay is false
+                        if let player = asset.channels.first {
+                            XCTAssertFalse(player.isPlaying, "Player should not be playing when autoPlay is false")
+                        }
+                    }
+
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 3.0)
+    }
+
+    func testPlayOnceCleanupAfterCompletion() {
+        let expectation = XCTestExpectation(description: "PlayOnce cleanup after completion")
+
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": true
+        ], onErrorMessage: "playOnce cleanup call")
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+
+            // Get the asset ID
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                self.plugin.executeOnAudioQueue {
+                    guard let assetId = self.plugin.playOnceAssets.first else {
+                        XCTFail("No playOnce asset was created")
+                        expectation.fulfill()
+                        return
+                    }
+
+                    // Verify asset exists
+                    XCTAssertNotNil(self.plugin.audioList[assetId], "Asset should exist")
+
+                    // Simulate completion
+                    if let asset = self.plugin.audioList[assetId] as? AudioAsset {
+                        asset.onComplete?()
+                    }
+
+                    // Wait for cleanup
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        self.plugin.executeOnAudioQueue {
+                            // Verify cleanup occurred
+                            XCTAssertNil(self.plugin.audioList[assetId], "Asset should be removed after cleanup")
+                            XCTAssertFalse(self.plugin.playOnceAssets.contains(assetId), "AssetId should be removed from playOnceAssets")
+
+                            expectation.fulfill()
+                        }
+                    }
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+    func testPlayOnceWithDeleteAfterPlay() {
+        let expectation = XCTestExpectation(description: "PlayOnce with file deletion")
+
+        // Create a temporary file that can be deleted
+        let deletableFilePath = NSTemporaryDirectory().appending("deletableAudio.wav")
+        let deletableURL = URL(fileURLWithPath: deletableFilePath)
+
+        // Copy test file to deletable location
+        do {
+            // Remove existing file if present
+            if FileManager.default.fileExists(atPath: deletableFilePath) {
+                try FileManager.default.removeItem(at: deletableURL)
+            }
+            try FileManager.default.copyItem(at: tempFileURL, to: deletableURL)
+        } catch {
+            XCTFail("Failed to set up deletable file: \(error)")
+            expectation.fulfill()
+            return
+        }
+
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": deletableURL.absoluteString,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": true,
+            "deleteAfterPlay": true
+        ], onErrorMessage: "playOnce delete-after-play call")
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+
+            // Wait for asset creation
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                self.plugin.executeOnAudioQueue {
+                    guard let assetId = self.plugin.playOnceAssets.first else {
+                        XCTFail("No playOnce asset was created")
+                        expectation.fulfill()
+                        return
+                    }
+
+                    // Verify file exists before completion
+                    XCTAssertTrue(FileManager.default.fileExists(atPath: deletableFilePath), "File should exist before cleanup")
+
+                    // Simulate completion
+                    if let asset = self.plugin.audioList[assetId] as? AudioAsset {
+                        asset.onComplete?()
+                    }
+
+                    // Wait for cleanup and deletion
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        // File should be deleted after cleanup
+                        let fileExists = FileManager.default.fileExists(atPath: deletableFilePath)
+                        XCTAssertFalse(fileExists, "File should be deleted after playOnce completion")
+
+                        expectation.fulfill()
+                    }
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+
+}
+
+extension PluginTests {
+
+    func testPlayOnceWithNotificationMetadata() {
+        let expectation = XCTestExpectation(description: "PlayOnce with notification metadata")
+
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": false,
+            "notificationMetadata": [
+                "title": "Test Song",
+                "artist": "Test Artist",
+                "album": "Test Album",
+                "artworkUrl": "https://example.com/artwork.jpg"
+            ]
+        ], onErrorMessage: "playOnce metadata call")
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+
+            // Wait for async operations
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                self.plugin.executeOnAudioQueue {
+                    guard let assetId = self.plugin.playOnceAssets.first else {
+                        XCTFail("No playOnce asset was created")
+                        expectation.fulfill()
+                        return
+                    }
+
+                    // Verify notification metadata was stored
+                    if let metadata = self.plugin.notificationMetadataMap[assetId] {
+                        XCTAssertEqual(metadata["title"], "Test Song", "Title should be stored")
+                        XCTAssertEqual(metadata["artist"], "Test Artist", "Artist should be stored")
+                        XCTAssertEqual(metadata["album"], "Test Album", "Album should be stored")
+                        XCTAssertEqual(metadata["artworkUrl"], "https://example.com/artwork.jpg", "Artwork URL should be stored")
+                    } else {
+                        XCTFail("Notification metadata should be stored")
+                    }
+
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 3.0)
+    }
+
+    func testPlayOnceErrorHandlingAndCleanup() {
+        let expectation = XCTestExpectation(description: "PlayOnce error handling and cleanup")
+
+        // Use an invalid file path to trigger error
+        let call = makeCall(callbackId: "test", options: [
+            "assetPath": "/invalid/path/to/nonexistent.wav",
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": true
+        ], onErrorMessage: "playOnce error handling call")
+
+        plugin.playOnce(call)
+
+        plugin.executeOnAudioQueue {
+            // Capture any assetId that might have been created
+            let initialAssetIds = self.plugin.playOnceAssets
+
+            // Wait for error handling
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                self.plugin.executeOnAudioQueue {
+                    // Verify cleanup occurred even on failure
+                    // Any asset created should be cleaned up from audioList
+                    for assetId in initialAssetIds {
+                        XCTAssertNil(self.plugin.audioList[assetId], "Failed asset should be cleaned up from audioList")
+                    }
+
+                    // And no dangling playOnce IDs should remain
+                    XCTAssertTrue(self.plugin.playOnceAssets.isEmpty, "playOnce assets should be cleaned up on error")
+
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        wait(for: [expectation], timeout: 3.0)
+    }
+
+    func testPlayOnceReturnsUniqueAssetId() {
+        let expectation = XCTestExpectation(description: "PlayOnce returns unique asset ID")
+
+        var firstAssetId: String?
+        var secondAssetId: String?
+
+        let call1 = makeCall(callbackId: "test1", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": false
+        ], onErrorMessage: "playOnce unique call1")
+        _ = firstAssetId
+
+        plugin.playOnce(call1)
+
+        // Create second playOnce
+        let call2 = makeCall(callbackId: "test2", options: [
+            "assetPath": tempFileURL.path,
+            "volume": 1.0,
+            "isUrl": true,
+            "autoPlay": false
+        ], onErrorMessage: "playOnce unique call2")
+        _ = secondAssetId
+
+        plugin.playOnce(call2)
+
+        // Wait for both to complete
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            self.plugin.executeOnAudioQueue {
+                // Verify we got two distinct asset IDs from the public API
+                XCTAssertNotNil(firstAssetId, "First asset ID should exist")
+                XCTAssertNotNil(secondAssetId, "Second asset ID should exist")
+                XCTAssertNotEqual(firstAssetId, secondAssetId, "Asset IDs should be unique")
+
+                // Verify both have "playOnce_" prefix
+                XCTAssertTrue(firstAssetId?.hasPrefix("playOnce_") ?? false, "First asset ID should have playOnce prefix")
+                XCTAssertTrue(secondAssetId?.hasPrefix("playOnce_") ?? false, "Second asset ID should have playOnce prefix")
+
+                // Cross-check that both are present in playOnceAssets as internal consistency check
+                if let id1 = firstAssetId, let id2 = secondAssetId {
+                    XCTAssertTrue(self.plugin.playOnceAssets.contains(id1), "First assetId should be tracked internally")
+                    XCTAssertTrue(self.plugin.playOnceAssets.contains(id2), "Second assetId should be tracked internally")
+                    XCTAssertEqual(self.plugin.playOnceAssets.count, 2, "Should have two playOnce assets tracked")
+                }
+
+                expectation.fulfill()
+            }
+        }
+
+        wait(for: [expectation], timeout: 5.0)
+    }
+}
+// swiftlint:enable file_length

package/ios/Tests/README.md

@@ -0,0 +1,39 @@
+# Native Audio Plugin Tests
+
+This directory contains tests for the Capacitor Native Audio Plugin.
+
+## Running Tests
+
+The easiest way to run these tests is through Xcode:
+
+1. Open the `Plugin.xcworkspace` file in Xcode
+2. Select the "Plugin" scheme
+3. Go to Product > Test (or press ⌘+U)
+
+## Test Coverage
+
+The tests cover the following functionality:
+
+- Basic initialization of `AudioAsset` and `RemoteAudioAsset` classes
+- Volume control
+- Fade effects (fade in/out)
+- Notification observer pattern
+- Cache clearing
+- Plugin preloading
+
+## Notes for Test Development
+
+- The tests use a temporary audio file created at runtime
+- For remote audio tests, a publicly accessible MP3 file is used
+- Some tests use reflection to access private methods (for testing purposes only)
+- All tests run on the plugin's audio queue to maintain thread safety
+
+## Troubleshooting
+
+If tests fail:
+
+1. Make sure the iOS simulator is available
+2. Check that the audio session is properly configured
+3. For remote tests, ensure network connectivity is available
+
+To view detailed test logs, expand the test navigator in Xcode and click on the failing test.