expo-modules-core 1.11.13 → 1.12.1

package/ios/Tests/EventEmitterSpec.swift

@@ -0,0 +1,274 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class EventEmitterSpec: ExpoSpec {
+  override class func spec() {
+    let appContext = AppContext.create()
+    let runtime = try! appContext.runtime
+
+    describe("JS class") {
+      it("exists") {
+        let eventEmitterClass = try runtime.eval("expo.EventEmitter")
+        expect(eventEmitterClass.kind) == .function
+      }
+
+      it("has functions in prototype") {
+        let prototype = try runtime.eval("expo.EventEmitter.prototype").asObject()
+        let addListener = prototype.getProperty("addListener")
+        let removeListener = prototype.getProperty("removeListener")
+        let removeAllListeners = prototype.getProperty("removeAllListeners")
+        let emit = prototype.getProperty("emit")
+
+        expect(addListener.kind) == .function
+        expect(removeListener.kind) == .function
+        expect(removeAllListeners.kind) == .function
+        expect(emit.kind) == .function
+      }
+
+      it("creates an instance") {
+        let eventEmitter = try runtime.eval("new expo.EventEmitter()")
+        expect(eventEmitter.kind) == .object
+      }
+
+      it("calls a listener") {
+        let result = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "result = null",
+          "emitter.addListener('test', payload => { result = payload })",
+          "emitter.emit('test', 'it\\'s a payload')",
+          "result"
+        ])
+        expect(result.kind) == .string
+        expect(try result.asString()) == "it's a payload"
+      }
+
+      it("removes a listener") {
+        let result = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "result = null",
+          "listener = () => { result = 1 }",
+          "emitter.addListener('test', listener)",
+          "emitter.removeListener('test', listener)",
+          "emitter.emit('test')",
+          "result"
+        ])
+        expect(result.kind) == .null
+      }
+
+      it("removes all listeners") {
+        let result = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "result = null",
+          "emitter.addListener('test', () => { result = 1 })",
+          "emitter.addListener('test', () => { result = 2 })",
+          "emitter.removeAllListeners('test')",
+          "emitter.emit('test')",
+          "result"
+        ])
+        expect(result.kind) == .null
+      }
+
+      it("emits with multiple arguments") {
+        let args = try runtime
+          .eval([
+            "emitter = new expo.EventEmitter()",
+            "result = null",
+            "emitter.addListener('test', (a, b, c) => { result = [a, b, c] })",
+            "emitter.emit('test', 14, 2, 24)",
+            "result"
+          ])
+          .asArray()
+          .compactMap({ try $0?.asInt() })
+
+        expect(args.count) == 3
+        expect(args[0]) == 14
+        expect(args[1]) == 2
+        expect(args[2]) == 24
+      }
+
+      it("returns listener count with listeners added") {
+        let listenerCount = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "emitter.addListener('test', () => {})",
+          "emitter.addListener('test', () => {})",
+          "emitter.listenerCount('test')"
+        ])
+        expect(listenerCount.kind) == .number
+        expect(try listenerCount.asInt()) == 2
+      }
+
+      it("returns listener count without any listeners") {
+        let listenerCount = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "emitter.listenerCount('test')"
+        ])
+        expect(listenerCount.kind) == .number
+        expect(try listenerCount.asInt()) == 0
+      }
+
+      it("returns listener count for the proper event") {
+        let listenerCount = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "emitter.addListener('test1', () => {})",
+          "emitter.addListener('test1', () => {})",
+          "emitter.addListener('test2', () => {})",
+          "emitter.listenerCount('test2')"
+        ])
+        expect(listenerCount.kind) == .number
+        expect(try listenerCount.asInt()) == 1
+      }
+
+      it("calls startObserving on addListener") {
+        var calls: Int = 0
+        let eventName = "testEvent"
+        let listenerA = runtime.createSyncFunction("listenerA") { _, _ in }
+        let listenerB = runtime.createSyncFunction("listenerB") { _, _ in }
+        let observer = try setupEventObserver(runtime: runtime, functionName: "startObserving") { arguments in
+          expect(try arguments.first?.asString()) == eventName
+          calls = calls + 1
+        }
+
+        observer.addListener.call(withArguments: [eventName, listenerA], thisObject: observer.emitter, asConstructor: false)
+        observer.addListener.call(withArguments: [eventName, listenerB], thisObject: observer.emitter, asConstructor: false)
+
+        expect(calls) == 1
+      }
+
+      it("calls stopObserving on removeListener") {
+        var calls: Int = 0
+        let eventName = "testEvent"
+        let listener = runtime.createSyncFunction("listener") { _, _ in }
+        let observer = try setupEventObserver(runtime: runtime, functionName: "stopObserving") { arguments in
+          expect(try arguments.first?.asString()) == eventName
+          calls = calls + 1
+        }
+
+        observer.addListener.call(withArguments: [eventName, listener], thisObject: observer.emitter, asConstructor: false)
+        observer.removeListener.call(withArguments: [eventName, listener], thisObject: observer.emitter, asConstructor: false)
+        observer.removeListener.call(withArguments: [eventName, listener], thisObject: observer.emitter, asConstructor: false)
+
+        expect(calls) == 1
+      }
+
+      it("calls stopObserving on removeAllListeners") {
+        var calls: Int = 0
+        let eventName = "testEvent"
+        let listener = runtime.createSyncFunction("listener") { _, _ in }
+        let observer = try setupEventObserver(runtime: runtime, functionName: "stopObserving") { arguments in
+          expect(try arguments.first?.asString()) == eventName
+          calls = calls + 1
+        }
+
+        observer.addListener.call(withArguments: [eventName, listener], thisObject: observer.emitter, asConstructor: false)
+        observer.removeAllListeners.call(withArguments: [eventName], thisObject: observer.emitter, asConstructor: false)
+        observer.removeAllListeners.call(withArguments: [eventName], thisObject: observer.emitter, asConstructor: false)
+
+        expect(calls) == 1
+      }
+
+      it("returns a subscription") {
+        let subscription = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "subscription = emitter.addListener('test', () => {})"
+        ])
+
+        expect(try subscription.asObject().getPropertyNames()).to(contain("remove"))
+        expect(try subscription.asObject().getProperty("remove").kind) == .function
+      }
+
+      it("removes a listener from subscription") {
+        let wasCalled = try runtime.eval([
+          "wasCalled = false",
+          "emitter = new expo.EventEmitter()",
+          "subscription = emitter.addListener('test', () => { wasCalled = true })",
+          "subscription.remove()",
+          "emitter.emit('test')",
+          "wasCalled"
+        ])
+
+        expect(try wasCalled.asBool()) == false
+      }
+
+      it("removes only related listener") {
+        let counter = try runtime.eval([
+          "counter = 0",
+          "emitter = new expo.EventEmitter()",
+          "subscription1 = emitter.addListener('test', () => { counter |= 1 })",
+          "subscription2 = emitter.addListener('test', () => { counter |= 2 })",
+          "subscription1.remove()",
+          "emitter.emit('test')",
+          "counter"
+        ])
+
+        expect(try counter.asInt()) == 2
+      }
+
+      it("provides backwards compatibility for the legacy wrapper") {
+        let emittersAreEqual = try runtime.eval([
+          "emitterA = new expo.EventEmitter()",
+          "emitterB = new expo.EventEmitter(emitterA)",
+          "emitterA === emitterB"
+        ])
+        expect(try emittersAreEqual.asBool()) == true
+      }
+
+      it("calls all listeners even if removed by a listener") {
+        // The third listener should be called even though it was already removed by the second listener.
+        let result = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "result = 0",
+          "listener = () => emitter.removeAllListeners('test')",
+          "emitter.addListener('test', () => result |= 1)",
+          "emitter.addListener('test', listener)",
+          "emitter.addListener('test', () => result |= 2)",
+          "emitter.emit('test')",
+          "result"
+        ])
+        expect(try result.asInt()) == 3
+      }
+
+      it("calls only existing listeners even if a listener adds more") {
+        // The listener added in the second listener shouldn't be called.
+        let result = try runtime.eval([
+          "emitter = new expo.EventEmitter()",
+          "result = 0",
+          "emitter.addListener('test', () => result |= 1)",
+          "emitter.addListener('test', () => emitter.addListener('test', () => result |= 2))",
+          "emitter.addListener('test', () => result |= 4)",
+          "emitter.emit('test')",
+          "result"
+        ])
+        expect(try result.asInt()) == 5
+      }
+    }
+  }
+}
+
+private typealias EventObserver = (
+  emitter: JavaScriptObject,
+  addListener: RawJavaScriptFunction,
+  removeListener: RawJavaScriptFunction,
+  removeAllListeners: RawJavaScriptFunction
+)
+
+private func setupEventObserver(
+  runtime: ExpoRuntime,
+  functionName: String,
+  callback: @escaping (_ arguments: [JavaScriptValue]) throws -> Void
+) throws -> EventObserver {
+  let emitter = try! runtime.eval("new expo.EventEmitter()").asObject()
+  let observingFunction = runtime.createSyncFunction(functionName) { [callback] this, arguments in
+    try callback(arguments)
+    return Optional<Any>.none as Any
+  }
+
+  emitter.setProperty(functionName, value: observingFunction)
+
+  return (
+    emitter,
+    addListener: try emitter.getProperty("addListener").asFunction(),
+    removeListener: try emitter.getProperty("removeListener").asFunction(),
+    removeAllListeners: try emitter.getProperty("removeAllListeners").asFunction()
+  )
+}

package/ios/Tests/ExceptionsSpec.swift

@@ -6,74 +6,126 @@ import ExpoModulesTestCore
 
 final class ExceptionsSpec: ExpoSpec {
   override class func spec() {
-    it("has name") {
-      let error = TestException()
-      expect(error.name) == "TestException"
-    }
-
-    it("has code") {
-      let error = TestException()
-      expect(error.code) == "ERR_TEST"
-    }
-
-    it("has reason") {
-      let error = TestException()
-      expect(error.reason) == "This is the test exception"
-    }
+    let appContext = AppContext.create()
 
-    it("can be chained once") {
-      func throwable() throws {
-        do {
-          throw TestExceptionCause()
-        } catch {
-          throw TestException().causedBy(error)
-        }
+    context("native") {
+      it("has name") {
+        let error = TestException()
+        expect(error.name) == "TestException"
       }
-      expect { try throwable() }.to(throwError { error in
-        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self])
-      })
-    }
-
-    it("can be chained twice") {
-      func throwable() throws {
-        do {
+      
+      it("has code") {
+        let error = TestException()
+        expect(error.code) == "ERR_TEST"
+      }
+      
+      it("has reason") {
+        let error = TestException()
+        expect(error.reason) == "This is the test exception"
+      }
+      
+      it("can be chained once") {
+        func throwable() throws {
           do {
             throw TestExceptionCause()
           } catch {
-            throw TestExceptionCause().causedBy(error)
+            throw TestException().causedBy(error)
           }
-        } catch {
-          throw TestException().causedBy(error)
         }
+        expect { try throwable() }.to(throwError { error in
+          testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self])
+        })
       }
-      expect { try throwable() }.to(throwError { error in
-        testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self, TestExceptionCause.self])
-      })
-    }
-
-    it("includes cause description") {
-      func throwable() throws {
-        do {
-          throw TestExceptionCause()
-        } catch {
-          throw TestException().causedBy(error)
+      
+      it("can be chained twice") {
+        func throwable() throws {
+          do {
+            do {
+              throw TestExceptionCause()
+            } catch {
+              throw TestExceptionCause().causedBy(error)
+            }
+          } catch {
+            throw TestException().causedBy(error)
+          }
         }
+        expect { try throwable() }.to(throwError { error in
+          testChainedExceptionTypes(error: error, types: [TestException.self, TestExceptionCause.self, TestExceptionCause.self])
+        })
       }
-      expect { try throwable() }.to(throwError { error in
-        if let error = error as? TestException, let cause = error.cause as? TestExceptionCause {
-          expect(error.description).to(contain(cause.description))
-        } else {
-          fail("Error and its cause are not of expected types.")
+      
+      it("includes cause description") {
+        func throwable() throws {
+          do {
+            throw TestExceptionCause()
+          } catch {
+            throw TestException().causedBy(error)
+          }
         }
-      })
+        expect { try throwable() }.to(throwError { error in
+          if let error = error as? TestException, let cause = error.cause as? TestExceptionCause {
+            expect(error.description).to(contain(cause.description))
+          } else {
+            fail("Error and its cause are not of expected types.")
+          }
+        })
+      }
+      
+      it("has root cause") {
+        let a = TestException()
+        let b = TestException().causedBy(a)
+        let c = TestException().causedBy(b)
+        
+        expect(c.rootCause as! TestException) === a
+      }
     }
 
-    it("has root cause") {
-      let a = TestException()
-      let b = TestException().causedBy(a)
-      let c = TestException().causedBy(b)
+    context("JavaScript") {
+      let runtime = try! appContext.runtime
+
+      beforeSuite {
+        appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
+          Name("TestModule")
+
+          Function("codedException") {
+            throw TestCodedException()
+          }
+
+          AsyncFunction("codedExceptionThrowAsync") { () in
+            throw TestCodedException()
+          }
+
+          AsyncFunction("codedExceptionRejectAsync") { (promise: Promise) in
+            promise.reject(TestCodedException())
+          }
 
-      expect(c.rootCause as! TestException) === a
+          AsyncFunction("codedExceptionConcurrentAsync") { () async throws in
+            throw TestCodedException()
+          }
+        })
+      }
+
+      it("sync function throw") {
+        let error = try runtime.eval("try { expo.modules.TestModule.codedException() } catch (error) { error }").asObject()
+        expect(error.getProperty("message").getString()).to(contain("FunctionCallException: Calling the 'codedException' function has failed"))
+        expect(error.getProperty("code").getString()).to(equal("E_TEST_CODE"))
+      }
+
+      // TODO: Find a way to evaluate async code
+//      it("async function throw") {
+//        let error = try runtime.eval("try { await expo.modules.TestModule.codedExceptionThrowAsync() } catch (error) { error }").asObject()
+//        expect(error.getProperty("code").getString()).to(equal("E_TEST_CODE"))
+//      }
+
+//      it("async function reject") {
+//        let error = try runtime.eval("try { await expo.modules.TestModule.codedExceptionRejectAsync() } catch (error) { error }").asObject()
+//        expect(error.getProperty("code").getString()).to(equal("E_TEST_CODE"))
+//      }
+
+//      it("async/concurrent function throw") {
+//        let error = try runtime.eval("try { await expo.modules.TestModule.codedExceptionConcurrentAsync() } catch (error) { error }").asObject()
+//        expect(error.getProperty("code").getString()).to(equal("E_TEST_CODE"))
+//      }
     }
   }
 }
@@ -90,6 +142,14 @@ class TestExceptionCause: Exception {
   }
 }
 
+class TestCodedException: Exception {
+  init() {
+    super.init(name: "TestException",
+               description: "This is a test Exception with a code",
+               code: "E_TEST_CODE")
+  }
+}
+
 /**
  Tests whether the exception chain matches given types and their order.
  */

package/ios/Tests/ExpoModulesSpec.swift

@@ -33,11 +33,12 @@ class ExpoModulesSpec: ExpoSpec {
 
     describe("host object") {
       it("is defined") {
-        expect(try! runtime.eval("'ExpoModules' in this").asBool()).to(beTrue())
+        expect(try! runtime.eval("'expo' in this").asBool()).to(beTrue())
+        expect(try! runtime.eval("'modules' in expo").asBool()).to(beTrue())
       }
 
       it("has native module defined") {
-        expect(try! runtime.eval("'\(testModuleName)' in ExpoModules").asBool()).to(beTrue())
+        expect(try! runtime.eval("'\(testModuleName)' in expo.modules").asBool()).to(beTrue())
       }
 
       it("can access native module") {
@@ -49,7 +50,7 @@ class ExpoModulesSpec: ExpoSpec {
 
       it("has keys for registered modules") {
         let registeredModuleNames = appContext.moduleRegistry.getModuleNames()
-        let keys = try runtime.eval("Object.keys(ExpoModules)").asArray().compactMap {
+        let keys = try runtime.eval("Object.keys(expo.modules)").asArray().compactMap {
           return try! $0?.asString()
         }
         expect(keys).to(contain(registeredModuleNames))

package/ios/Tests/LoggerSpec.swift

@@ -0,0 +1,80 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class LoggerSpec: ExpoSpec {
+  class TestLogHandler : LogHandler {
+    struct TestLogHandlerLogEntry : Equatable {
+      let type: LogType
+      let message: String
+
+      static func == (lhs: TestLogHandlerLogEntry, rhs: TestLogHandlerLogEntry) -> Bool {
+        // slightly-fuzzy matching for testing only due to prepending emoji to message
+        return lhs.type == rhs.type && (lhs.message.contains(rhs.message) || rhs.message.contains(lhs.message))
+      }
+    }
+
+    var logEntries: [TestLogHandlerLogEntry] = []
+
+    func clear() {
+      logEntries = []
+    }
+
+    func log(type: ExpoModulesCore.LogType, _ message: String) {
+      logEntries.append(TestLogHandlerLogEntry(type: type, message: message))
+    }
+  }
+
+  override class func spec() {
+    it("should log various levels") {
+      let loggerHandler = TestLogHandler()
+      let logger = Logger(logHandlers: [loggerHandler])
+
+      logger.trace("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .trace, message: "hello")
+      loggerHandler.clear()
+
+      logger.debug("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .debug, message: "hello")
+      loggerHandler.clear()
+
+      logger.info("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .info, message: "hello")
+      loggerHandler.clear()
+
+      logger.warn("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .warn, message: "hello")
+      loggerHandler.clear()
+
+      logger.error("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .error, message: "hello")
+      loggerHandler.clear()
+
+      logger.fatal("hello")
+      expect(loggerHandler.logEntries.first) == TestLogHandler.TestLogHandlerLogEntry(type: .fatal, message: "hello")
+      loggerHandler.clear()
+    }
+
+    it("should run a timer") {
+      let loggerHandler = TestLogHandler()
+      let logger = Logger(logHandlers: [loggerHandler])
+
+      let timer = logger.startTimer { duration in
+        return "\(duration)"
+      }
+      RunLoop.current.run(until: Date().addingTimeInterval(0.3))
+      timer.stop()
+
+      let entry = loggerHandler.logEntries.first!
+      expect(entry.type) == .timer
+
+      // remove emoji prefix
+      let index = entry.message.index(entry.message.startIndex, offsetBy: 2)
+      expect(Double(entry.message[index...])) > 300
+
+      loggerHandler.clear()
+    }
+  }
+}

package/ios/Tests/{PropertyComponentSpec.swift → PropertyDefinitionSpec.swift}

@@ -2,7 +2,7 @@ import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class PropertyComponentSpec: ExpoSpec {
+class PropertyDefinitionSpec: ExpoSpec {
   override class func spec() {
     describe("property") {
       let appContext = AppContext.create()