expo-modules-core 0.9.2 → 0.10.0

package/ios/Tests/FunctionSpec.swift

@@ -4,173 +4,222 @@ import ExpoModulesTestCore
 
 class FunctionSpec: ExpoSpec {
   override func spec() {
-    let appContext = AppContext()
+    let appContext = AppContext.create()
     let functionName = "test function name"
 
-    func testFunctionReturning<T: Equatable>(value returnValue: T) {
-      waitUntil { done in
-        mockModuleHolder(appContext) {
-          AsyncFunction(functionName) {
-            return returnValue
+    context("native") {
+      func testFunctionReturning<T: Equatable>(value returnValue: T) {
+        waitUntil { done in
+          mockModuleHolder(appContext) {
+            AsyncFunction(functionName) {
+              return returnValue
+            }
+          }
+          .call(function: functionName, args: []) { result in
+            let value = try! result.get()
+
+            expect(value).notTo(beNil())
+            expect(value).to(beAKindOf(T.self))
+            expect(value as? T).to(equal(returnValue))
+            done()
           }
-        }
-        .call(function: functionName, args: []) { value, _ in
-          expect(value).notTo(beNil())
-          expect(value).to(beAKindOf(T.self))
-          expect(value as? T).to(equal(returnValue))
-          done()
         }
       }
-    }
 
-    it("is called") {
-      waitUntil { done in
-        mockModuleHolder(appContext) {
-          AsyncFunction(functionName) {
-            done()
+      it("is called") {
+        waitUntil { done in
+          mockModuleHolder(appContext) {
+            AsyncFunction(functionName) {
+              done()
+            }
           }
+          .call(function: functionName, args: [])
         }
-        .call(function: functionName, args: [])
       }
-    }
 
-    it("returns bool values") {
-      testFunctionReturning(value: true)
-      testFunctionReturning(value: false)
-      testFunctionReturning(value: [true, false])
-    }
+      it("returns bool values") {
+        testFunctionReturning(value: true)
+        testFunctionReturning(value: false)
+        testFunctionReturning(value: [true, false])
+      }
 
-    it("returns int values") {
-      testFunctionReturning(value: 1_234)
-      testFunctionReturning(value: [2, 1, 3, 7])
-    }
+      it("returns int values") {
+        testFunctionReturning(value: 1_234)
+        testFunctionReturning(value: [2, 1, 3, 7])
+      }
 
-    it("returns double values") {
-      testFunctionReturning(value: 3.14)
-      testFunctionReturning(value: [0, 1.1, 2.2])
-    }
+      it("returns double values") {
+        testFunctionReturning(value: 3.14)
+        testFunctionReturning(value: [0, 1.1, 2.2])
+      }
 
-    it("returns string values") {
-      testFunctionReturning(value: "a string")
-      testFunctionReturning(value: ["expo", "modules", "core"])
-    }
+      it("returns string values") {
+        testFunctionReturning(value: "a string")
+        testFunctionReturning(value: ["expo", "modules", "core"])
+      }
 
-    it("is called with nil value") {
-      let str: String? = nil
+      it("is called with nil value") {
+        let str: String? = nil
 
-      mockModuleHolder(appContext) {
-        AsyncFunction(functionName) { (a: String?) in
-          expect(a == nil) == true
+        mockModuleHolder(appContext) {
+          AsyncFunction(functionName) { (a: String?) in
+            expect(a == nil) == true
+          }
         }
+        .callSync(function: functionName, args: [str as Any])
       }
-      .callSync(function: functionName, args: [str as Any])
-    }
 
-    it("is called with an array of arrays") {
-      let array: [[String]] = [["expo"]]
+      it("is called with an array of arrays") {
+        let array: [[String]] = [["expo"]]
 
-      mockModuleHolder(appContext) {
-        AsyncFunction(functionName) { (a: [[String]]) in
-          expect(a.first!.first) == array.first!.first
+        mockModuleHolder(appContext) {
+          AsyncFunction(functionName) { (a: [[String]]) in
+            expect(a.first!.first) == array.first!.first
+          }
         }
+        .callSync(function: functionName, args: [array])
       }
-      .callSync(function: functionName, args: [array])
-    }
 
-    describe("converting dicts to records") {
-      struct TestRecord: Record {
-        @Field var property: String = "expo"
-        @Field var optionalProperty: Int?
-        @Field("propertyWithCustomKey") var customKeyProperty: String = "expo"
-      }
-      let dict = [
-        "property": "Hello",
-        "propertyWithCustomKey": "Expo!"
-      ]
+      describe("converting dicts to records") {
+        struct TestRecord: Record {
+          @Field var property: String = "expo"
+          @Field var optionalProperty: Int?
+          @Field("propertyWithCustomKey") var customKeyProperty: String = "expo"
+        }
+        let dict = [
+          "property": "Hello",
+          "propertyWithCustomKey": "Expo!"
+        ]
+
+        it("converts to simple record when passed as an argument") {
+          waitUntil { done in
+            mockModuleHolder(appContext) {
+              AsyncFunction(functionName) { (a: TestRecord) in
+                return a.property
+              }
+            }
+            .call(function: functionName, args: [dict]) { result in
+              let value = try! result.get()
 
-      it("converts to simple record when passed as an argument") {
-        waitUntil { done in
-          mockModuleHolder(appContext) {
-            AsyncFunction(functionName) { (a: TestRecord) in
-              return a.property
+              expect(value).notTo(beNil())
+              expect(value).to(beAKindOf(String.self))
+              expect(value).to(be(dict["property"]))
+              done()
             }
           }
-          .call(function: functionName, args: [dict]) { value, _ in
-            expect(value).notTo(beNil())
-            expect(value).to(beAKindOf(String.self))
-            expect(value).to(be(dict["property"]))
-            done()
+        }
+
+        it("converts to record with custom key") {
+          waitUntil { done in
+            mockModuleHolder(appContext) {
+              AsyncFunction(functionName) { (a: TestRecord) in
+                return a.customKeyProperty
+              }
+            }
+            .call(function: functionName, args: [dict]) { result in
+              let value = try! result.get()
+              expect(value).notTo(beNil())
+              expect(value).to(beAKindOf(String.self))
+              expect(value).to(be(dict["propertyWithCustomKey"]))
+              done()
+            }
+          }
+        }
+
+        it("returns the record back") {
+          waitUntil { done in
+            mockModuleHolder(appContext) {
+              AsyncFunction(functionName) { (a: TestRecord) in
+                return a.toDictionary()
+              }
+            }
+            .call(function: functionName, args: [dict]) { result in
+              let value = try! result.get()
+
+              expect(value).notTo(beNil())
+              expect(value).to(beAKindOf(Record.Dict.self))
+
+              let valueAsDict = value as! Record.Dict
+
+              expect(valueAsDict["property"] as? String).to(equal(dict["property"]))
+              expect(valueAsDict["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
+              done()
+            }
           }
         }
       }
 
-      it("converts to record with custom key") {
+      it("throws when called with more arguments than expected") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            AsyncFunction(functionName) { (a: TestRecord) in
-              return a.customKeyProperty
+            AsyncFunction(functionName) { (_: Int) in
+              return "something"
             }
           }
-          .call(function: functionName, args: [dict]) { value, _ in
-            expect(value).notTo(beNil())
-            expect(value).to(beAKindOf(String.self))
-            expect(value).to(be(dict["propertyWithCustomKey"]))
+          // Function expects one argument, let's give it more.
+          .call(function: functionName, args: [1, 2]) { result in
+            switch result {
+            case .failure(let error):
+              expect(error).notTo(beNil())
+              expect(error).to(beAKindOf(InvalidArgsNumberException.self))
+            case .success(_):
+              fail()
+            }
             done()
           }
         }
       }
 
-      it("returns the record back") {
+      it("throws when called with arguments of incompatible types") {
         waitUntil { done in
           mockModuleHolder(appContext) {
-            AsyncFunction(functionName) { (a: TestRecord) in
-              return a.toDictionary()
+            AsyncFunction(functionName) { (_: String) in
+              return "something"
             }
           }
-          .call(function: functionName, args: [dict]) { value, _ in
-            expect(value).notTo(beNil())
-            expect(value).to(beAKindOf(Record.Dict.self))
-
-            let valueAsDict = value as! Record.Dict
-
-            expect(valueAsDict["property"] as? String).to(equal(dict["property"]))
-            expect(valueAsDict["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
+          // Function expects a string, let's give it a number.
+          .call(function: functionName, args: [1]) { result in
+            switch result {
+            case .failure(let error):
+              expect(error).notTo(beNil())
+              expect(error).to(beAKindOf(ArgumentCastException.self))
+              expect(error.isCausedBy(Conversions.CastingException<String>.self)) == true
+            case .success(_):
+              fail()
+            }
             done()
           }
         }
       }
     }
-
-    it("throws when called with more arguments than expected") {
-      waitUntil { done in
-        mockModuleHolder(appContext) {
-          AsyncFunction(functionName) { (_: Int) in
-            return "something"
+    
+    context("JavaScript") {
+      let runtime = appContext.runtime
+      
+      beforeSuite {
+        appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
+          Name("TestModule")
+
+          Function("returnPi") { Double.pi }
+          
+          Function("returnNull") { () -> Double? in
+            return nil
           }
-        }
-        // Function expects one argument, let's give it more.
-        .call(function: functionName, args: [1, 2]) { _, error in
-          expect(error).notTo(beNil())
-          expect(error).to(beAKindOf(InvalidArgsNumberException.self))
-          done()
-        }
-      }
-    }
-
-    it("throws when called with arguments of incompatible types") {
-      waitUntil { done in
-        mockModuleHolder(appContext) {
-          AsyncFunction(functionName) { (_: String) in
-            return "something"
+          
+          Function("isArgNull") { (arg: Double?) -> Bool in
+            return arg == nil
           }
-        }
-        // 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(ArgumentCastException.self))
-          expect((error as! Exception).isCausedBy(Conversions.CastingException<String>.self)) == true
-          done()
-        }
+        })
+      }
+      
+      it("returns values") {
+        expect(try runtime?.eval("ExpoModules.TestModule.returnPi()").asDouble()) == Double.pi
+        expect(try runtime?.eval("ExpoModules.TestModule.returnNull()").isNull()) == true
+      }
+      
+      it("accepts optional arguments") {
+        expect(try runtime?.eval("ExpoModules.TestModule.isArgNull(3.14)").asBool()) == false
+        expect(try runtime?.eval("ExpoModules.TestModule.isArgNull(null)").asBool()) == true
       }
     }
   }

package/ios/Tests/Mocks/ModuleMocks.swift

@@ -8,7 +8,7 @@ class NamedModule: Module {
   static let namedModuleName = "MyModule"
 
   func definition() -> ModuleDefinition {
-    name(Self.namedModuleName)
+    Name(Self.namedModuleName)
   }
 }
 

package/ios/Tests/PropertyComponentSpec.swift

@@ -0,0 +1,95 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+class PropertyComponentSpec: ExpoSpec {
+  override func spec() {
+    describe("property") {
+      it("gets the value") {
+        let property = Property("test") { return "expo" }
+        expect(property.getValue()) == "expo"
+      }
+
+      it("sets the value") {
+        var value = Int.random(in: 0..<100)
+        let property = Property("test")
+          .get { value }
+          .set { (newValue: Int) in
+            value = newValue
+          }
+
+        let newValue = Int.random(in: 0..<100)
+        property.setValue(newValue)
+
+        expect(property.getValue()) == value
+        expect(value) == newValue
+      }
+    }
+
+    describe("module property") {
+      let appContext = AppContext.create()
+      let runtime = appContext.runtime
+
+      beforeSuite {
+        class PropertyTestModule: Module {
+          func definition() -> ModuleDefinition {
+            Name("PropertyTest")
+
+            Property("readOnly") {
+              return "foo"
+            }
+
+            var writablePropertyValue = 444
+            Property("writable")
+              .get {
+                return writablePropertyValue
+              }
+              .set { value in
+                writablePropertyValue = value
+              }
+
+            Property("withCaller") { (caller: JavaScriptObject) -> String in
+              // Here, the caller is a JS object of the module.
+              // Return another property of itself.
+              return caller.getProperty("readOnly").getString()
+            }
+
+            Property("undefined")
+          }
+        }
+        appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
+      }
+
+      it("gets read-only property") {
+        let value = try runtime?.eval("ExpoModules.PropertyTest.readOnly")
+        expect(value?.getString()) == "foo"
+      }
+
+      it("gets writable property") {
+        let value = try runtime?.eval("ExpoModules.PropertyTest.writable")
+        expect(value?.getInt()) == 444
+      }
+
+      it("sets writable property") {
+        try runtime?.eval("ExpoModules.PropertyTest.writable = 777")
+        let value = try runtime?.eval("ExpoModules.PropertyTest.writable")
+        expect(value?.getInt()) == 777
+      }
+
+      it("is enumerable") {
+        let keys = try runtime?.eval("Object.keys(ExpoModules.PropertyTest)").getArray().map { $0.getString() } ?? []
+        expect(keys).to(contain("readOnly", "writable", "withCaller", "undefined"))
+      }
+
+      it("is called with the caller") {
+        let value = try runtime?.eval("ExpoModules.PropertyTest.withCaller")
+        expect(value?.getString()) == "foo"
+      }
+
+      it("returns undefined when getter is not specified") {
+        let value = try runtime?.eval("ExpoModules.PropertyTest.undefined")
+        expect(value?.isUndefined()) == true
+      }
+    }
+  }
+}

package/ios/Tests/SharedObjectRegistrySpec.swift

@@ -0,0 +1,109 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class SharedObjectRegistrySpec: ExpoSpec {
+  override func spec() {
+    let appContext = AppContext.create()
+    let runtime = appContext.runtime
+
+    describe("pullNextId") {
+      it("returns nextId") {
+        let id = SharedObjectRegistry.nextId
+        expect(SharedObjectRegistry.pullNextId()) == id
+      }
+      it("increments nextId") {
+        let id = SharedObjectRegistry.nextId
+        SharedObjectRegistry.pullNextId()
+        expect(SharedObjectRegistry.nextId) == id + 1
+      }
+      it("is not increasing size") {
+        let size = SharedObjectRegistry.size
+        SharedObjectRegistry.pullNextId()
+        expect(SharedObjectRegistry.size) == size
+      }
+    }
+
+    describe("add") {
+      it("adds using nextId") {
+        let nextId = SharedObjectRegistry.nextId
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        expect(nextId) == id
+      }
+      it("is increasing size") {
+        let size = SharedObjectRegistry.size
+        SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        expect(SharedObjectRegistry.size) == size + 1
+      }
+      it("assigns id on native object") {
+        let nativeObject = TestSharedObject()
+        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime!.createObject())
+        expect(nativeObject.sharedObjectId) == id
+      }
+      it("assigns id on JS object") {
+        let jsObject = runtime!.createObject()
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
+        expect(jsObject.hasProperty(sharedObjectIdPropertyName)) == true
+        expect(try! jsObject.getProperty(sharedObjectIdPropertyName).asInt()) == id
+      }
+      it("saves objects pair") {
+        let nativeObject = TestSharedObject()
+        let jsObject = runtime!.createObject()
+        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        let pair = SharedObjectRegistry.get(id)
+        expect(pair?.native) === nativeObject
+        expect(pair?.javaScript.lock()) == jsObject
+      }
+    }
+
+    describe("delete") {
+      it("deletes objects pair") {
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime!.createObject())
+        SharedObjectRegistry.delete(id)
+        expect(SharedObjectRegistry.get(id)).to(beNil())
+      }
+      it("resets id on native object") {
+        let nativeObject = TestSharedObject()
+        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime!.createObject())
+        SharedObjectRegistry.delete(id)
+        expect(nativeObject.sharedObjectId) == 0
+      }
+      it("resets id on JS object") {
+        let jsObject = runtime!.createObject()
+        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
+        SharedObjectRegistry.delete(id)
+        expect(try! jsObject.getProperty(sharedObjectIdPropertyName).asInt()) == 0
+      }
+    }
+
+    describe("toNativeObject") {
+      it("returns native object") {
+        let nativeObject = TestSharedObject()
+        let jsObject = runtime!.createObject()
+        SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        expect(SharedObjectRegistry.toNativeObject(jsObject)) === nativeObject
+      }
+      it("returns nil") {
+        let jsObject = runtime!.createObject()
+        expect(SharedObjectRegistry.toNativeObject(jsObject)).to(beNil())
+      }
+    }
+
+    describe("toJavaScriptObject") {
+      it("returns JS object") {
+        let nativeObject = TestSharedObject()
+        let jsObject = runtime!.createObject()
+        SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        expect(SharedObjectRegistry.toJavaScriptObject(nativeObject)) == jsObject
+      }
+      it("returns nil") {
+        let nativeObject = TestSharedObject()
+        expect(SharedObjectRegistry.toJavaScriptObject(nativeObject)).to(beNil())
+      }
+    }
+  }
+}
+
+fileprivate final class TestSharedObject: SharedObject {}