@thelacanians/vue-native-cli 0.4.15 → 0.6.0

package/native/ios/VueNativeCore/Tests/VueNativeCoreTests/EventThrottleTests.swift

@@ -0,0 +1,161 @@
+#if canImport(UIKit)
+import XCTest
+import UIKit
+@testable import VueNativeCore
+
+@MainActor
+final class EventThrottleTests: XCTestCase {
+
+    // MARK: - Initialization
+
+    func testInitializationWithDefaultInterval() {
+        let throttle = EventThrottle { _ in }
+        XCTAssertEqual(throttle.interval, 0.016, accuracy: 0.001, "Default interval should be ~16ms")
+    }
+
+    func testInitializationWithCustomInterval() {
+        let throttle = EventThrottle(interval: 0.1) { _ in }
+        XCTAssertEqual(throttle.interval, 0.1, accuracy: 0.001, "Custom interval should be 0.1s")
+    }
+
+    // MARK: - First Event Fires Immediately
+
+    func testFirstEventFiresImmediately() {
+        var firedPayload: Any?
+        var fireCount = 0
+
+        let throttle = EventThrottle(interval: 1.0) { payload in
+            firedPayload = payload
+            fireCount += 1
+        }
+
+        throttle.fire("hello")
+
+        XCTAssertEqual(fireCount, 1, "First event should fire immediately")
+        XCTAssertEqual(firedPayload as? String, "hello", "Payload should be passed through")
+    }
+
+    // MARK: - Events Within Throttle Window Are Suppressed
+
+    func testEventsWithinWindowAreSuppressed() {
+        var fireCount = 0
+
+        let throttle = EventThrottle(interval: 10.0) { _ in
+            fireCount += 1
+        }
+
+        // First fire — immediate
+        throttle.fire("first")
+        XCTAssertEqual(fireCount, 1, "First event should fire immediately")
+
+        // Rapid fires within the throttle window — should NOT fire immediately
+        throttle.fire("second")
+        throttle.fire("third")
+
+        // Only the first call fires synchronously; the rest schedule trailing calls
+        XCTAssertEqual(fireCount, 1, "Subsequent events within the throttle window should be suppressed synchronously")
+    }
+
+    // MARK: - Events After Window Expires Fire
+
+    func testEventsAfterWindowExpireFire() {
+        let expectation = self.expectation(description: "Throttled event fires after window")
+        var fireCount = 0
+
+        let throttle = EventThrottle(interval: 0.05) { _ in
+            fireCount += 1
+            if fireCount == 2 {
+                expectation.fulfill()
+            }
+        }
+
+        // First fire — immediate
+        throttle.fire("first")
+        XCTAssertEqual(fireCount, 1, "First event should fire immediately")
+
+        // Wait for the throttle window to expire, then fire again
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+            throttle.fire("second")
+        }
+
+        waitForExpectations(timeout: 1.0)
+        XCTAssertEqual(fireCount, 2, "Event after window expiry should fire")
+    }
+
+    // MARK: - Trailing Call Delivers Latest Payload
+
+    func testTrailingCallDeliversLatestPayload() {
+        let expectation = self.expectation(description: "Trailing call fires")
+        var payloads: [String] = []
+
+        let throttle = EventThrottle(interval: 0.05) { payload in
+            if let str = payload as? String {
+                payloads.append(str)
+            }
+            if payloads.count == 2 {
+                expectation.fulfill()
+            }
+        }
+
+        // First fire — immediate
+        throttle.fire("first")
+
+        // Rapid fires — only the latest should be delivered as trailing
+        throttle.fire("second")
+        throttle.fire("third")
+        throttle.fire("fourth")
+
+        waitForExpectations(timeout: 1.0)
+
+        XCTAssertEqual(payloads.first, "first", "First payload should be 'first'")
+        XCTAssertEqual(payloads.last, "fourth", "Trailing call should deliver the latest payload")
+    }
+
+    // MARK: - Multiple Throttle Instances Are Independent
+
+    func testMultipleThrottleInstancesAreIndependent() {
+        var countA = 0
+        var countB = 0
+
+        let throttleA = EventThrottle(interval: 10.0) { _ in countA += 1 }
+        let throttleB = EventThrottle(interval: 10.0) { _ in countB += 1 }
+
+        throttleA.fire(nil)
+        throttleB.fire(nil)
+
+        XCTAssertEqual(countA, 1, "Throttle A should fire independently")
+        XCTAssertEqual(countB, 1, "Throttle B should fire independently")
+    }
+
+    // MARK: - Nil Payload Is Supported
+
+    func testNilPayloadIsSupported() {
+        var fired = false
+
+        let throttle = EventThrottle(interval: 0.016) { payload in
+            XCTAssertNil(payload, "Nil payload should be passed through")
+            fired = true
+        }
+
+        throttle.fire(nil)
+        XCTAssertTrue(fired, "Handler should fire with nil payload")
+    }
+
+    // MARK: - Dictionary Payload Is Supported
+
+    func testDictionaryPayloadIsSupported() {
+        var receivedPayload: [String: Any]?
+
+        let throttle = EventThrottle(interval: 0.016) { payload in
+            receivedPayload = payload as? [String: Any]
+        }
+
+        let payload: [String: Any] = ["x": 10.0, "y": 20.0]
+        throttle.fire(payload)
+
+        XCTAssertNotNil(receivedPayload, "Dictionary payload should be received")
+        XCTAssertEqual(receivedPayload?["x"] as? Double, 10.0, "x should be 10.0")
+        XCTAssertEqual(receivedPayload?["y"] as? Double, 20.0, "y should be 20.0")
+    }
+}
+#endif

package/native/ios/VueNativeCore/Tests/VueNativeCoreTests/HotReloadManagerTests.swift

@@ -0,0 +1,88 @@
+#if canImport(UIKit)
+import XCTest
+import UIKit
+@testable import VueNativeCore
+
+@MainActor
+final class HotReloadManagerTests: XCTestCase {
+
+    // MARK: - Properties
+
+    private var manager: HotReloadManager!
+
+    // MARK: - Setup / Teardown
+
+    override func setUp() {
+        super.setUp()
+        manager = HotReloadManager.shared
+    }
+
+    override func tearDown() {
+        manager.disconnect()
+        manager = nil
+        super.tearDown()
+    }
+
+    // MARK: - Singleton Tests
+
+    func testSharedInstanceIsSingleton() {
+        let instance1 = HotReloadManager.shared
+        let instance2 = HotReloadManager.shared
+        XCTAssertTrue(instance1 === instance2, "HotReloadManager.shared should always return the same instance")
+    }
+
+    // MARK: - Initialization Tests
+
+    func testInitializationWithURL() {
+        let url = URL(string: "ws://localhost:8174")!
+        // connect should not crash
+        manager.connect(to: url)
+        // Just verify it doesn't crash — we can't easily test the WebSocket connection
+    }
+
+    // MARK: - Disconnect Tests
+
+    func testDisconnectDoesNotCrash() {
+        // Disconnect without connecting first — should be safe
+        manager.disconnect()
+    }
+
+    func testDisconnectAfterConnectDoesNotCrash() {
+        let url = URL(string: "ws://localhost:9999")!
+        manager.connect(to: url)
+        manager.disconnect()
+        // Should not crash
+    }
+
+    // MARK: - Multiple Connect Calls
+
+    func testMultipleConnectCallsDoNotCrash() {
+        let url1 = URL(string: "ws://localhost:8174")!
+        let url2 = URL(string: "ws://localhost:8175")!
+
+        manager.connect(to: url1)
+        manager.connect(to: url2)
+        manager.disconnect()
+    }
+
+    // MARK: - URLSessionWebSocketDelegate Conformance
+
+    func testConformsToURLSessionWebSocketDelegate() {
+        // Verify HotReloadManager conforms to the delegate protocol
+        XCTAssertTrue(manager is URLSessionWebSocketDelegate,
+                      "HotReloadManager should conform to URLSessionWebSocketDelegate")
+    }
+
+    // MARK: - Connect/Disconnect Cycle
+
+    func testConnectDisconnectCycleDoesNotCrash() {
+        let url = URL(string: "ws://localhost:8174")!
+
+        for _ in 0..<5 {
+            manager.connect(to: url)
+            manager.disconnect()
+        }
+        // Multiple cycles should not crash
+    }
+}
+#endif

package/native/ios/VueNativeCore/Tests/VueNativeCoreTests/JSPolyfillsTests.swift

@@ -0,0 +1,319 @@
+#if canImport(UIKit)
+import XCTest
+import JavaScriptCore
+import UIKit
+@testable import VueNativeCore
+
+@MainActor
+final class JSPolyfillsTests: XCTestCase {
+
+    // MARK: - Properties
+
+    private var runtime: JSRuntime!
+
+    // MARK: - Setup / Teardown
+
+    override func setUp() {
+        super.setUp()
+        runtime = JSRuntime.shared
+        let initExpectation = expectation(description: "JSRuntime initialized")
+        runtime.initialize {
+            initExpectation.fulfill()
+        }
+        waitForExpectations(timeout: 5.0)
+    }
+
+    override func tearDown() {
+        runtime = nil
+        super.tearDown()
+    }
+
+    // MARK: - Helper
+
+    /// Evaluate a script synchronously and return the result.
+    private func evalSync(_ script: String) -> JSValue? {
+        let exp = expectation(description: "eval")
+        var result: JSValue?
+        runtime.evaluateScript(script) { value in
+            result = value
+            exp.fulfill()
+        }
+        waitForExpectations(timeout: 5.0)
+        return result
+    }
+
+    // MARK: - console Tests
+
+    func testConsoleLogDoesNotCrash() {
+        // console.log should not throw or crash
+        let result = evalSync("console.log('test message'); true")
+        XCTAssertNotNil(result, "console.log should not crash")
+        XCTAssertTrue(result?.toBool() == true, "Script should evaluate to true")
+    }
+
+    func testConsoleWarnDoesNotCrash() {
+        let result = evalSync("console.warn('warning message'); true")
+        XCTAssertNotNil(result, "console.warn should not crash")
+        XCTAssertTrue(result?.toBool() == true, "Script should evaluate to true")
+    }
+
+    func testConsoleErrorDoesNotCrash() {
+        let result = evalSync("console.error('error message'); true")
+        XCTAssertNotNil(result, "console.error should not crash")
+        XCTAssertTrue(result?.toBool() == true, "Script should evaluate to true")
+    }
+
+    func testConsoleDebugDoesNotCrash() {
+        let result = evalSync("console.debug('debug message'); true")
+        XCTAssertNotNil(result, "console.debug should not crash")
+    }
+
+    func testConsoleInfoDoesNotCrash() {
+        let result = evalSync("console.info('info message'); true")
+        XCTAssertNotNil(result, "console.info should not crash")
+    }
+
+    // MARK: - performance.now() Tests
+
+    func testPerformanceNowReturnsNumber() {
+        let result = evalSync("typeof performance.now()")
+        XCTAssertEqual(result?.toString(), "number", "performance.now() should return a number")
+    }
+
+    func testPerformanceNowReturnsPositiveValue() {
+        let result = evalSync("performance.now() > 0")
+        XCTAssertTrue(result?.toBool() == true, "performance.now() should return a positive number")
+    }
+
+    func testPerformanceNowIncreases() {
+        let result = evalSync("""
+            var a = performance.now();
+            var i = 0; while(i < 10000) { i++; }
+            var b = performance.now();
+            b >= a;
+        """)
+        XCTAssertTrue(result?.toBool() == true, "performance.now() should be non-decreasing")
+    }
+
+    // MARK: - queueMicrotask Tests
+
+    func testQueueMicrotaskExists() {
+        let result = evalSync("typeof queueMicrotask")
+        XCTAssertEqual(result?.toString(), "function", "queueMicrotask should be a function")
+    }
+
+    func testQueueMicrotaskCallbackRuns() {
+        let result = evalSync("""
+            var microtaskRan = false;
+            queueMicrotask(function() { microtaskRan = true; });
+            // Microtask should execute after the current task via Promise.resolve().then()
+            microtaskRan;
+        """)
+        // Note: the microtask may not have fired yet since it's Promise-based.
+        // But after the evaluateScript drain, it should have run.
+        XCTAssertNotNil(result, "queueMicrotask should not crash")
+    }
+
+    // MARK: - setTimeout Tests
+
+    func testSetTimeoutExists() {
+        let result = evalSync("typeof setTimeout")
+        XCTAssertEqual(result?.toString(), "function", "setTimeout should be a function")
+    }
+
+    func testSetTimeoutReturnsTimerId() {
+        let result = evalSync("var id = setTimeout(function(){}, 1000); typeof id !== 'undefined'")
+        XCTAssertTrue(result?.toBool() == true, "setTimeout should return a timer ID")
+    }
+
+    func testSetTimeoutFiresCallback() {
+        let exp = expectation(description: "setTimeout fires")
+
+        runtime.evaluateScript("""
+            globalThis.__testTimeoutFired = false;
+            setTimeout(function() {
+                globalThis.__testTimeoutFired = true;
+            }, 50);
+        """)
+
+        // Check after a delay — use evaluateScript directly to avoid
+        // nested waitForExpectations (XCTest API violation).
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+            self?.runtime.evaluateScript("globalThis.__testTimeoutFired") { value in
+                XCTAssertTrue(value?.toBool() == true, "setTimeout callback should have fired")
+                exp.fulfill()
+            }
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - clearTimeout Tests
+
+    func testClearTimeoutExists() {
+        let result = evalSync("typeof clearTimeout")
+        XCTAssertEqual(result?.toString(), "function", "clearTimeout should be a function")
+    }
+
+    func testClearTimeoutCancelsPendingCallback() {
+        // Verify clearTimeout is callable and does not crash.
+        // We cannot reliably test cancellation timing in the simulator
+        // because JSC timer scheduling depends on the native run loop.
+        let result = evalSync("""
+            var __clearTestFired = false;
+            var tid = setTimeout(function() { __clearTestFired = true; }, 100000);
+            clearTimeout(tid);
+            typeof tid !== 'undefined';
+        """)
+        XCTAssertTrue(result?.toBool() == true, "clearTimeout should accept a timer ID")
+    }
+
+    // MARK: - setInterval Tests
+
+    func testSetIntervalExists() {
+        let result = evalSync("typeof setInterval")
+        XCTAssertEqual(result?.toString(), "function", "setInterval should be a function")
+    }
+
+    func testSetIntervalReturnsTimerId() {
+        let result = evalSync("""
+            var iid = setInterval(function(){}, 1000);
+            clearInterval(iid);
+            typeof iid !== 'undefined';
+        """)
+        XCTAssertTrue(result?.toBool() == true, "setInterval should return a timer ID")
+    }
+
+    // MARK: - clearInterval Tests
+
+    func testClearIntervalExists() {
+        let result = evalSync("typeof clearInterval")
+        XCTAssertEqual(result?.toString(), "function", "clearInterval should be a function")
+    }
+
+    // MARK: - globalThis Tests
+
+    func testGlobalThisExists() {
+        let result = evalSync("typeof globalThis !== 'undefined'")
+        XCTAssertTrue(result?.toBool() == true, "globalThis should be defined")
+    }
+
+    func testGlobalThisIsGlobalObject() {
+        let result = evalSync("globalThis === this")
+        // In JSC, `this` at the top level is the global object
+        XCTAssertNotNil(result, "globalThis should reference the global object")
+    }
+
+    // MARK: - requestAnimationFrame Tests
+
+    func testRequestAnimationFrameExists() {
+        let result = evalSync("typeof requestAnimationFrame")
+        XCTAssertEqual(result?.toString(), "function", "requestAnimationFrame should be a function")
+    }
+
+    func testCancelAnimationFrameExists() {
+        let result = evalSync("typeof cancelAnimationFrame")
+        XCTAssertEqual(result?.toString(), "function", "cancelAnimationFrame should be a function")
+    }
+
+    // MARK: - fetch Tests
+
+    func testFetchExists() {
+        let result = evalSync("typeof fetch")
+        XCTAssertEqual(result?.toString(), "function", "fetch should be a function")
+    }
+
+    // MARK: - atob / btoa Tests
+
+    func testBtoaEncodes() {
+        let result = evalSync("btoa('hello')")
+        XCTAssertEqual(result?.toString(), "aGVsbG8=", "btoa('hello') should return 'aGVsbG8='")
+    }
+
+    func testAtobDecodes() {
+        let result = evalSync("atob('aGVsbG8=')")
+        XCTAssertEqual(result?.toString(), "hello", "atob('aGVsbG8=') should return 'hello'")
+    }
+
+    func testBtoaAtobRoundTrip() {
+        let result = evalSync("atob(btoa('Vue Native!'))")
+        XCTAssertEqual(result?.toString(), "Vue Native!", "btoa/atob round-trip should preserve the string")
+    }
+
+    // MARK: - TextEncoder / TextDecoder Tests
+
+    func testTextEncoderExists() {
+        let result = evalSync("typeof TextEncoder")
+        XCTAssertEqual(result?.toString(), "function", "TextEncoder should be defined")
+    }
+
+    func testTextDecoderExists() {
+        let result = evalSync("typeof TextDecoder")
+        XCTAssertEqual(result?.toString(), "function", "TextDecoder should be defined")
+    }
+
+    func testTextEncoderDecoderRoundTrip() {
+        let result = evalSync("""
+            var enc = new TextEncoder();
+            var dec = new TextDecoder();
+            var encoded = enc.encode('hello');
+            dec.decode(encoded);
+        """)
+        XCTAssertEqual(result?.toString(), "hello", "TextEncoder/TextDecoder round-trip should work")
+    }
+
+    // MARK: - URL Tests
+
+    func testURLConstructorExists() {
+        let result = evalSync("typeof URL")
+        XCTAssertEqual(result?.toString(), "function", "URL constructor should be defined")
+    }
+
+    func testURLParsingBasic() {
+        let result = evalSync("new URL('https://example.com:8080/path?q=1#hash').hostname")
+        XCTAssertEqual(result?.toString(), "example.com", "URL should parse hostname")
+    }
+
+    func testURLSearchParamsExists() {
+        let result = evalSync("typeof URLSearchParams")
+        XCTAssertEqual(result?.toString(), "function", "URLSearchParams should be defined")
+    }
+
+    // MARK: - crypto.getRandomValues Tests
+
+    func testCryptoGetRandomValuesExists() {
+        let result = evalSync("typeof crypto.getRandomValues")
+        XCTAssertEqual(result?.toString(), "function", "crypto.getRandomValues should be defined")
+    }
+
+    func testCryptoGetRandomValuesProducesBytes() {
+        let result = evalSync("""
+            var arr = new Uint8Array(4);
+            crypto.getRandomValues(arr);
+            arr.length;
+        """)
+        XCTAssertEqual(result?.toInt32(), 4, "getRandomValues should fill a 4-byte array")
+    }
+
+    // MARK: - Bridge Stubs Tests
+
+    func testBridgeStubsExist() {
+        let result = evalSync("""
+            typeof __VN_handleGlobalEvent === 'function' &&
+            typeof __VN_handleEvent === 'function' &&
+            typeof __VN_resolveCallback === 'function';
+        """)
+        XCTAssertTrue(result?.toBool() == true, "Bridge stubs should be defined as functions")
+    }
+
+    func testBridgeStubsDoNotCrash() {
+        let result = evalSync("""
+            __VN_handleGlobalEvent();
+            __VN_handleEvent();
+            __VN_resolveCallback();
+            true;
+        """)
+        XCTAssertTrue(result?.toBool() == true, "Bridge stubs should be callable without crashing")
+    }
+}
+#endif