expo-modules-core 0.6.5 → 0.9.0

package/ios/Tests/ExpoModulesSpec.swift

@@ -0,0 +1,75 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class ExpoModulesSpec: ExpoSpec {
+  override func spec() {
+    let appContext = AppContext.create()
+    let interopBridge = SwiftInteropBridge(appContext: appContext)
+    let runtime = appContext.runtime
+    let testModuleName = "TestModule"
+    let testFunctionName = "testFunction"
+    let constantsDict: [String: Any] = [
+      "expo": "is cool",
+      "sdk": 45,
+    ]
+
+    beforeSuite {
+      try! appContext.installExpoModulesHostObject(interopBridge)
+
+      appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
+        Name(testModuleName)
+
+        Constants(constantsDict)
+
+        Function(testFunctionName) { Double.pi }
+      })
+    }
+
+    describe("host object") {
+      it("is defined") {
+        expect(try! runtime?.eval("'ExpoModules' in this").asBool()) === true
+      }
+
+      it("has native module defined") {
+        expect(try! runtime?.eval("'\(testModuleName)' in ExpoModules").asBool()) === true
+      }
+
+      it("can access native module") {
+        let nativeModule = try! runtime?.eval("ExpoModules.\(testModuleName)")
+        expect(nativeModule?.isUndefined()) == false
+        expect(nativeModule?.isObject()) == true
+        expect(nativeModule?.getRaw()).notTo(beNil())
+      }
+
+      it("has keys for registered modules") {
+        let registeredModuleNames = appContext.moduleRegistry.getModuleNames()
+        let keys = try! runtime?.eval("Object.keys(ExpoModules)").asArray().compactMap {
+          return try! $0?.asString()
+        }
+        expect(keys).to(contain(registeredModuleNames))
+      }
+    }
+
+    describe("module") {
+      it("exposes constants") {
+        let dict = try! runtime!.eval("ExpoModules.TestModule").asDict()
+
+        dict.forEach { (key: String, value: Any) in
+          expect(value) === dict[key]!
+        }
+      }
+
+      it("has function") {
+        expect(try! runtime?.eval("typeof ExpoModules.TestModule.\(testFunctionName)").asString()) == "function"
+        expect(try! runtime?.eval("ExpoModules.TestModule.\(testFunctionName)").isFunction()) == true
+      }
+
+      it("calls function") {
+        expect(try! runtime?.eval("ExpoModules.TestModule.\(testFunctionName)()").asDouble()) == Double.pi
+      }
+    }
+  }
+}

package/ios/Tests/FunctionSpec.swift

@@ -1,9 +1,8 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class FunctionSpec: QuickSpec {
+class FunctionSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
     let functionName = "test function name"
@@ -11,11 +10,11 @@ class FunctionSpec: QuickSpec {
     func testFunctionReturning<T: Equatable>(value returnValue: T) {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) {
+          AsyncFunction(functionName) {
             return returnValue
           }
         }
-        .call(function: functionName, args: []) { value, error in
+        .call(function: functionName, args: []) { value, _ in
           expect(value).notTo(beNil())
           expect(value).to(beAKindOf(T.self))
           expect(value as? T).to(equal(returnValue))
@@ -27,7 +26,7 @@ class FunctionSpec: QuickSpec {
     it("is called") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) {
+          AsyncFunction(functionName) {
             done()
           }
         }
@@ -42,7 +41,7 @@ class FunctionSpec: QuickSpec {
     }
 
     it("returns int values") {
-      testFunctionReturning(value: 1234)
+      testFunctionReturning(value: 1_234)
       testFunctionReturning(value: [2, 1, 3, 7])
     }
 
@@ -60,7 +59,7 @@ class FunctionSpec: QuickSpec {
       let str: String? = nil
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (a: String?) in
+        AsyncFunction(functionName) { (a: String?) in
           expect(a == nil) == true
         }
       }
@@ -71,7 +70,7 @@ class FunctionSpec: QuickSpec {
       let array: [[String]] = [["expo"]]
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (a: [[String]]) in
+        AsyncFunction(functionName) { (a: [[String]]) in
           expect(a.first!.first) == array.first!.first
         }
       }
@@ -81,7 +80,7 @@ class FunctionSpec: QuickSpec {
     describe("converting dicts to records") {
       struct TestRecord: Record {
         @Field var property: String = "expo"
-        @Field var optionalProperty: Int? = nil
+        @Field var optionalProperty: Int?
         @Field("propertyWithCustomKey") var customKeyProperty: String = "expo"
       }
       let dict = [
@@ -92,11 +91,11 @@ class FunctionSpec: QuickSpec {
       it("converts to simple record when passed as an argument") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.property
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["property"]))
@@ -108,11 +107,11 @@ class FunctionSpec: QuickSpec {
       it("converts to record with custom key") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.customKeyProperty
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(String.self))
             expect(value).to(be(dict["propertyWithCustomKey"]))
@@ -124,11 +123,11 @@ class FunctionSpec: QuickSpec {
       it("returns the record back") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            $0.function(functionName) { (a: TestRecord) in
+            AsyncFunction(functionName) { (a: TestRecord) in
               return a.toDictionary()
             }
           }
-          .call(function: functionName, args: [dict]) { value, error in
+          .call(function: functionName, args: [dict]) { value, _ in
             expect(value).notTo(beNil())
             expect(value).to(beAKindOf(Record.Dict.self))
 
@@ -145,16 +144,14 @@ class FunctionSpec: QuickSpec {
     it("throws when called with more arguments than expected") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) { (a: Int) in
+          AsyncFunction(functionName) { (_: Int) in
             return "something"
           }
         }
         // Function expects one argument, let's give it more.
-        .call(function: functionName, args: [1, 2]) { value, error in
+        .call(function: functionName, args: [1, 2]) { _, error in
           expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(InvalidArgsNumberError.self))
-          expect(error?.code).to(equal("ERR_INVALID_ARGS_NUMBER"))
-          expect(error?.description).to(equal(InvalidArgsNumberError(received: 2, expected: 1).description))
+          expect(error).to(beAKindOf(InvalidArgsNumberException.self))
           done()
         }
       }
@@ -163,16 +160,15 @@ class FunctionSpec: QuickSpec {
     it("throws when called with arguments of incompatible types") {
       waitUntil { done in
         mockModuleHolder(appContext) {
-          $0.function(functionName) { (a: String) in
+          AsyncFunction(functionName) { (_: String) in
             return "something"
           }
         }
         // Function expects a string, let's give it a number.
         .call(function: functionName, args: [1]) { value, error in
           expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(Conversions.CastingError<String>.self))
-          expect(error?.code).to(equal("ERR_CASTING_FAILED"))
-          expect(error?.description).to(equal(Conversions.CastingError<String>(value: 1).description))
+          expect(error).to(beAKindOf(ArgumentCastException.self))
+          expect((error as! Exception).isCausedBy(Conversions.CastingException<String>.self)) == true
           done()
         }
       }

package/ios/Tests/FunctionWithConvertiblesSpec.swift

@@ -1,12 +1,11 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 import CoreGraphics
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class FunctionWithConvertiblesSpec: QuickSpec {
+class FunctionWithConvertiblesSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
     let functionName = "function"
@@ -18,7 +17,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       let height = 592.1
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
+        AsyncFunction(functionName) { (point: CGPoint, size: CGSize, vector: CGVector, rect: CGRect) in
           expect(point.x) == x
           expect(point.y) == y
           expect(size.width) == width
@@ -48,7 +47,7 @@ class FunctionWithConvertiblesSpec: QuickSpec {
       }
 
       mockModuleHolder(appContext) {
-        $0.function(functionName) { (color1: CGColor, color2: CGColor, color3: CGColor, color4: CGColor) in
+        AsyncFunction(functionName) { (color1: CGColor, color2: CGColor, color3: CGColor, color4: CGColor) in
           testColorComponents(color1, 0x2A, 0x4B, 0x5D, 0xFF)
           testColorComponents(color2, 0x11, 0xFF, 0x00, 0xDD)
           testColorComponents(color3, 0x66, 0x00, 0xCC, 0xAA)

package/ios/Tests/JavaScriptObjectSpec.swift

@@ -0,0 +1,97 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class JavaScriptObjectSpec: ExpoSpec {
+  override func spec() {
+    let runtime = JavaScriptRuntime()
+    var object: JavaScriptObject?
+
+    let key = "expo"
+    let value1 = "💙"
+    let value2 = "💛"
+
+    beforeEach {
+      object = runtime.createObject()
+    }
+
+    describe("hasProperty") {
+      it("returns false when the property is missing") {
+        expect(object?.hasProperty(key)) == false
+      }
+
+      it("returns true when the property exists") {
+        object?.setProperty(key, value: value1)
+        expect(object?.hasProperty(key)) == true
+      }
+
+      it("returns true when the property is explicitly set to undefined") {
+        object?.setProperty(key, value: nil)
+        expect(object?.hasProperty(key)) == true
+        expect(object?.getProperty(key).isUndefined()) == true
+      }
+    }
+
+    describe("getProperty") {
+      it("returns correct value") {
+        object?.setProperty(key, value: value1)
+        expect(try! object?.getProperty(key).asString()) == value1
+      }
+
+      it("returns undefined") {
+        expect(object?.getProperty("bar").isUndefined()) == true
+      }
+    }
+
+    describe("setProperty") {
+      it("sets") {
+        object?.setProperty(key, value: value1)
+        expect(try! object?.getProperty(key).asString()) == value1
+      }
+
+      it("overrides") {
+        object?.setProperty(key, value: value1)
+        object?.setProperty(key, value: value2)
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+
+      it("unsets") {
+        object?.setProperty(key, value: nil)
+        expect(object?.getProperty(key).isUndefined()) == true
+      }
+    }
+
+    describe("defineProperty") {
+      it("defines non-enumerable property") {
+        object?.defineProperty(key, value: value1, options: [])
+        expect(try! object?.getProperty(key).asString()) == value1
+        expect(object?.getPropertyNames()).notTo(contain(key))
+      }
+
+      it("defines enumerable property") {
+        // When the property is enumerable, it is listed in the property names
+        object?.defineProperty(key, value: value1, options: .enumerable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        expect(object?.getPropertyNames()).to(contain(key))
+      }
+
+      it("defines configurable property") {
+        // Configurable allows to redefine the property
+        object?.defineProperty(key, value: value1, options: .configurable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        object?.defineProperty(key, value: value2, options: [])
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+
+      it("defines writable property") {
+        // Writable allows changing the property
+        object?.defineProperty(key, value: value1, options: .writable)
+        expect(try! object?.getProperty(key).asString()) == value1
+        object?.setProperty(key, value: value2)
+        expect(try! object?.getProperty(key).asString()) == value2
+      }
+    }
+  }
+}

package/ios/Tests/JavaScriptRuntimeSpec.swift

@@ -0,0 +1,94 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class JavaScriptRuntimeSpec: ExpoSpec {
+  override func spec() {
+    let runtime = JavaScriptRuntime()
+
+    it("has global object accessible") {
+      expect(runtime.global) !== nil
+    }
+
+    describe("eval") {
+      it("returns undefined") {
+        let undefined = try! runtime.eval("undefined")
+        expect(undefined.isUndefined()) == true
+        expect(undefined.kind) == .undefined
+        expect(undefined.isNull()) == false
+        expect(undefined.getRaw()).to(beNil())
+      }
+
+      it("returns null") {
+        let null = try! runtime.eval("null")
+        expect(null.isNull()) == true
+        expect(null.kind) == .null
+        expect(null.getRaw()).to(beNil())
+      }
+
+      it("returns bool") {
+        let boolTrue = try! runtime.eval("true")
+        let boolFalse = try! runtime.eval("false")
+        expect(boolTrue.isBool()) == true
+        expect(boolFalse.isBool()) == true
+        expect(boolTrue.kind) == .bool
+        expect(boolFalse.kind) == .bool
+        expect(try! boolTrue.asBool()) == true
+        expect(try! boolFalse.asBool()) == false
+      }
+
+      it("returns number") {
+        let number = try! runtime.eval("1.23")
+        expect(number.isNumber()) == true
+        expect(number.kind) == .number
+        expect(try! number.asInt()) == 1
+        expect(try! number.asDouble()) == 1.23
+      }
+
+      it("returns string") {
+        let string = try! runtime.eval("'foobar'")
+        expect(string.isString()) == true
+        expect(string.kind) == .string
+        expect(try! string.asString()) == "foobar"
+      }
+
+      it("returns array") {
+        let array = try! runtime.eval("(['foo', 'bar'])")
+        expect(array.isObject()) == true
+        expect(array.kind) == .object
+        expect(try! array.asArray().map { try $0?.asString() }) == ["foo", "bar"]
+      }
+
+      it("returns dict") {
+        let dict1 = try! runtime.eval("({ 'foo': 123 })")
+        let dict2 = try! runtime.eval("({ 'foo': 'bar' })")
+        expect(dict1.isObject()) == true
+        expect(dict2.isObject()) == true
+        expect(dict1.kind) == .object
+        expect(dict2.kind) == .object
+        expect(try! dict1.asDict() as? [String: Int]) == ["foo": 123]
+        expect(try! dict2.asDict() as? [String: String]) == ["foo": "bar"]
+      }
+
+      it("returns function") {
+        let function = try! runtime.eval("(function() {})")
+        expect(function.isObject()) == true
+        expect(function.isFunction()) == true
+        expect(function.kind) == .function
+      }
+
+      it("returns symbol") {
+        let symbol = try! runtime.eval("Symbol('foo')")
+        expect(symbol.isSymbol()) == true
+        expect(symbol.kind) == .symbol
+      }
+
+      it("throws evaluation exception") {
+        expect({ try runtime.eval("foo") }).to(throwError { error in
+          expect(error).to(beAKindOf(JavaScriptEvalException.self))
+          expect((error as! JavaScriptEvalException).reason).to(contain("Can't find variable: foo"))
+        })
+      }
+    }
+  }
+}

package/ios/Tests/Mocks/ModuleMocks.swift

@@ -32,7 +32,7 @@ class CustomModule: Module {
 typealias MockedDefinitionFunc = (CustomModule) -> ModuleDefinition
 
 func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping () -> ModuleDefinition) -> ModuleHolder {
-  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { module in definitionBody() }))
+  return ModuleHolder(appContext: appContext, module: CustomModule(appContext: appContext, { _ in definitionBody() }))
 }
 
 func mockModuleHolder(_ appContext: AppContext, @ModuleDefinitionBuilder _ definitionBody: @escaping (CustomModule) -> ModuleDefinition) -> ModuleHolder {

package/ios/Tests/Mocks/ModulesProviderMock.swift

@@ -3,7 +3,6 @@ import ExpoModulesCore
 public class ModulesProviderMock: ModulesProvider {
   public override func getModuleClasses() -> [AnyModule.Type] {
     return [
-
     ]
   }
 }

package/ios/Tests/ModuleEventListenersSpec.swift

@@ -1,5 +1,4 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
@@ -11,7 +10,7 @@ import Nimble
 
  NOTE: Each test registers the module because only registered modules can capture events.
  */
-class ModuleEventListenersSpec: QuickSpec {
+class ModuleEventListenersSpec: ExpoSpec {
   override func spec() {
     var appContext: AppContext!
 
@@ -19,22 +18,22 @@ class ModuleEventListenersSpec: QuickSpec {
       appContext = AppContext()
     }
 
-    it("calls onCreate once the module instance is created") {
+    it("calls OnCreate once the module instance is created") {
       waitUntil { done in
-        let _ = mockModuleHolder(appContext) {
-          $0.onCreate {
+        _ = mockModuleHolder(appContext) {
+          OnCreate {
             done()
           }
         }
       }
     }
 
-    it("calls onDestroy once the module is about to be deallocated") {
+    it("calls OnDestroy once the module is about to be deallocated") {
       waitUntil { done in
         let moduleName = "mockedModule"
         let holder = mockModuleHolder(appContext) {
-          $0.name(moduleName)
-          $0.onDestroy {
+          Name(moduleName)
+          OnDestroy {
             done()
           }
         }
@@ -45,10 +44,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppContextDestroys once the context destroys") {
+    it("calls OnAppContextDestroys once the context destroys") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppContextDestroys {
+          OnAppContextDestroys {
             done()
           }
         }
@@ -70,10 +69,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppEntersForeground when system's willEnterForegroundNotification is sent") {
+    it("calls OnAppEntersForeground when system's willEnterForegroundNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppEntersForeground {
+          OnAppEntersForeground {
             done()
           }
         }
@@ -82,10 +81,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppBecomesActive when system's didBecomeActiveNotification is sent") {
+    it("calls OnAppBecomesActive when system's didBecomeActiveNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppBecomesActive {
+          OnAppBecomesActive {
             done()
           }
         }
@@ -94,10 +93,10 @@ class ModuleEventListenersSpec: QuickSpec {
       }
     }
 
-    it("calls onAppEntersBackground when system's didEnterBackgroundNotification is sent") {
+    it("calls OnAppEntersBackground when system's didEnterBackgroundNotification is sent") {
       waitUntil { done in
         let holder = mockModuleHolder(appContext) {
-          $0.onAppEntersBackground {
+          OnAppEntersBackground {
             done()
           }
         }

package/ios/Tests/ModuleRegistrySpec.swift

@@ -1,9 +1,8 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class ModuleRegistrySpec: QuickSpec {
+class ModuleRegistrySpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext()
 

package/ios/Tests/RecordSpec.swift

@@ -1,13 +1,12 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
 @testable import ExpoModulesCore
 
-class RecordSpec: QuickSpec {
+class RecordSpec: ExpoSpec {
   override func spec() {
     it("initializes with empty dictionary") {
       struct TestRecord: Record { }
-      let _ = try TestRecord(from: [:])
+      _ = try TestRecord(from: [:])
     }
 
     it("works back and forth with a field") {
@@ -37,14 +36,9 @@ class RecordSpec: QuickSpec {
         @Field(.required) var a: Int
       }
 
-      do {
-        let _ = try TestRecord(from: [:])
-        fail()
-      } catch let error as CodedError {
-        expect(error).to(beAKindOf(FieldRequiredError.self))
-        expect(error.code).to(equal("ERR_FIELD_REQUIRED"))
-        expect(error.description).to(equal(FieldRequiredError(fieldKey: "a").description))
-      }
+      expect { try TestRecord(from: [:]) }.to(throwError { error in
+        expect(error).to(beAKindOf(FieldRequiredException.self))
+      })
     }
 
     it("throws when casting is not possible") {
@@ -53,14 +47,9 @@ class RecordSpec: QuickSpec {
       }
       let dict = ["a": "try with String instead of Int"]
 
-      do {
-        let _ = try TestRecord(from: dict)
-        fail()
-      } catch let error as CodedError {
-        expect(error).to(beAKindOf(FieldInvalidTypeError.self))
-        expect(error.code).to(equal("ERR_FIELD_INVALID_TYPE"))
-        expect(error.description).to(equal(FieldInvalidTypeError(fieldKey: "a", value: dict["a"], desiredType: Int.self).description))
-      }
+      expect { try TestRecord(from: dict) }.to(throwError { error in
+        expect(error).to(beAKindOf(FieldInvalidTypeException.self))
+      })
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.6.5",
+  "version": "0.9.0",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -30,7 +30,7 @@
   },
   "author": "650 Industries, Inc.",
   "license": "MIT",
-  "homepage": "https://github.com/expo/expo/tree/master/packages/expo-modules-core",
+  "homepage": "https://github.com/expo/expo/tree/main/packages/expo-modules-core",
   "jest": {
     "preset": "expo-module-scripts"
   },
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^2.0.0"
   },
-  "gitHead": "ba24eba18bf4f4d4b0d54828992d81a2bb18246a"
+  "gitHead": "0f796e10a2b2f258c40f9d56aa141c372cd63fc1"
 }