expo-modules-core 1.2.7 → 1.3.0

package/ios/Tests/DynamicTypeSpec.swift

@@ -7,6 +7,8 @@ import ExpoModulesTestCore
 
 final class DynamicTypeSpec: ExpoSpec {
   override func spec() {
+    let appContext = AppContext.create()
+
     // MARK: - DynamicRawType
 
     describe("DynamicRawType") {
@@ -17,20 +19,20 @@ final class DynamicTypeSpec: ExpoSpec {
       }
       describe("casts") {
         it("succeeds") {
-          expect(try (~String.self).cast("expo") as? String) == "expo"
-          expect(try (~Double.self).cast(2.1) as? Double) == 2.1
-          expect(try (~Bool.self).cast(false) as? Bool) == false
+          expect(try (~String.self).cast("expo", appContext: appContext) as? String) == "expo"
+          expect(try (~Double.self).cast(2.1, appContext: appContext) as? Double) == 2.1
+          expect(try (~Bool.self).cast(false, appContext: appContext) as? Bool) == false
         }
         it("throws NullCastException") {
           let value: Double? = nil
           let anyValue = value as Any
 
-          expect { try (~Double.self).cast(anyValue) }.to(
+          expect { try (~Double.self).cast(anyValue, appContext: appContext) }.to(
             throwError(errorType: Conversions.NullCastException<Double>.self)
           )
         }
         it("throws CastingException") {
-          expect { try (~String.self).cast(true) }.to(
+          expect { try (~String.self).cast(true, appContext: appContext) }.to(
             throwError(errorType: Conversions.CastingException<String>.self)
           )
         }
@@ -72,13 +74,13 @@ final class DynamicTypeSpec: ExpoSpec {
       }
       describe("casts") {
         it("succeeds") {
-          expect(try (~[Double].self).cast([1.2, 3.4]) as? [Double]) == [1.2, 3.4]
-          expect(try (~[[String]].self).cast([["hello", "expo"]]) as? [[String]]) == [["hello", "expo"]]
+          expect(try (~[Double].self).cast([1.2, 3.4], appContext: appContext) as? [Double]) == [1.2, 3.4]
+          expect(try (~[[String]].self).cast([["hello", "expo"]], appContext: appContext) as? [[String]]) == [["hello", "expo"]]
         }
         it("casts arrays") {
           let value = 9.9
           let anyValue = [value] as [Any]
-          let result = try (~[Double].self).cast(anyValue) as! [Any]
+          let result = try (~[Double].self).cast(anyValue, appContext: appContext) as! [Any]
 
           expect(result).to(beAKindOf([Double].self))
           expect(result as? [Double]) == [value]
@@ -86,11 +88,11 @@ final class DynamicTypeSpec: ExpoSpec {
         it("arrayizes single element") {
           // The dynamic array type can arrayize the single element
           // if only the array element's dynamic type can cast it.
-          expect(try (~[Int].self).cast(50) as? [Int]) == [50]
-          expect(try (~[String].self).cast("not an array") as? [String]) == ["not an array"]
+          expect(try (~[Int].self).cast(50, appContext: appContext) as? [Int]) == [50]
+          expect(try (~[String].self).cast("not an array", appContext: appContext) as? [String]) == ["not an array"]
         }
         it("throws CastingException") {
-          expect { try (~[String].self).cast(84) }.to(
+          expect { try (~[String].self).cast(84, appContext: appContext) }.to(
             throwError(errorType: Conversions.CastingException<String>.self)
           )
         }
@@ -131,12 +133,12 @@ final class DynamicTypeSpec: ExpoSpec {
       }
       describe("casts") {
         it("succeeds") {
-          expect(try (~CGPoint.self).cast([2.1, 3.7]) as? CGPoint) == CGPoint(x: 2.1, y: 3.7)
-          expect(try (~CGVector.self).cast(["dx": 0.8, "dy": 4.1]) as? CGVector) == CGVector(dx: 0.8, dy: 4.1)
-          expect(try (~URL.self).cast("/test/path") as? URL) == URL(fileURLWithPath: "/test/path")
+          expect(try (~CGPoint.self).cast([2.1, 3.7], appContext: appContext) as? CGPoint) == CGPoint(x: 2.1, y: 3.7)
+          expect(try (~CGVector.self).cast(["dx": 0.8, "dy": 4.1], appContext: appContext) as? CGVector) == CGVector(dx: 0.8, dy: 4.1)
+          expect(try (~URL.self).cast("/test/path", appContext: appContext) as? URL) == URL(fileURLWithPath: "/test/path")
         }
         it("throws ConvertingException") {
-          expect { try (~CGRect.self).cast("not a rect") as? CGRect }.to(
+          expect { try (~CGRect.self).cast("not a rect", appContext: appContext) as? CGRect }.to(
             throwError(errorType: Conversions.ConvertingException<CGRect>.self)
           )
         }
@@ -185,16 +187,16 @@ final class DynamicTypeSpec: ExpoSpec {
       }
       describe("casts") {
         it("succeeds") {
-          expect(try (~StringTestEnum.self).cast("expo") as? StringTestEnum) == .expo
-          expect(try (~IntTestEnum.self).cast(1) as? IntTestEnum) == .positive
+          expect(try (~StringTestEnum.self).cast("expo", appContext: appContext) as? StringTestEnum) == .expo
+          expect(try (~IntTestEnum.self).cast(1, appContext: appContext) as? IntTestEnum) == .positive
         }
         it("throws EnumNoSuchValueException") {
-          expect { try (~StringTestEnum.self).cast("react native") as? StringTestEnum }.to(
+          expect { try (~StringTestEnum.self).cast("react native", appContext: appContext) as? StringTestEnum }.to(
             throwError(errorType: EnumNoSuchValueException.self)
           )
         }
         it("throws EnumCastingException") {
-          expect { try (~IntTestEnum.self).cast(true) as? StringTestEnum }.to(
+          expect { try (~IntTestEnum.self).cast(true, appContext: appContext) as? StringTestEnum }.to(
             throwError(errorType: EnumCastingException.self)
           )
         }
@@ -234,12 +236,12 @@ final class DynamicTypeSpec: ExpoSpec {
       }
       describe("casts") {
         it("succeeds") {
-          expect(try (~String?.self).cast("expo") as? String) == "expo"
-          expect(try (~Bool?.self).cast(false) as? Bool) == false
+          expect(try (~String?.self).cast("expo", appContext: appContext) as? String) == "expo"
+          expect(try (~Bool?.self).cast(false, appContext: appContext) as? Bool) == false
         }
         it("succeeds with nil") {
           let value: Double? = nil
-          let result = try (~Double?.self).cast(value as Any)
+          let result = try (~Double?.self).cast(value as Any, appContext: appContext)
 
           expect(result).to(beAKindOf(Double?.self))
 
@@ -249,12 +251,12 @@ final class DynamicTypeSpec: ExpoSpec {
         }
         it("succeeds with NSNull") {
           let value = NSNull()
-          let result = try (~Double?.self).cast(value as Any)
+          let result = try (~Double?.self).cast(value as Any, appContext: appContext)
           expect(result).to(beAKindOf(Double?.self))
           expect(Optional.isNil(result)) == true
         }
         it("throws CastingException") {
-          expect { try (~Double?.self).cast("a string") as? Double }.to(
+          expect { try (~Double?.self).cast("a string", appContext: appContext) as? Double }.to(
             throwError(errorType: Conversions.CastingException<Double>.self)
           )
         }
@@ -296,16 +298,16 @@ final class DynamicTypeSpec: ExpoSpec {
         it("succeeds") {
           let appContext = AppContext.create()
           let nativeObject = TestSharedObject()
-          let jsObjectValue = try appContext.runtime!.eval("({})")
+          let jsObjectValue = try appContext.runtime.eval("({})")
 
           SharedObjectRegistry.add(native: nativeObject, javaScript: try jsObjectValue.asObject())
 
           // `DynamicSharedObjectType` only supports casting
           // from `JavaScriptValue`, but not from `JavaScriptObject`.
-          expect(try (~TestSharedObject.self).cast(jsObjectValue) as? TestSharedObject) === nativeObject
+          expect(try (~TestSharedObject.self).cast(jsValue: jsObjectValue, appContext: appContext) as? TestSharedObject) === nativeObject
         }
         it("throws NativeSharedObjectNotFoundException") {
-          expect { try (~TestSharedObject.self).cast("a string") as? TestSharedObject }.to(
+          expect { try (~TestSharedObject.self).cast("a string", appContext: appContext) as? TestSharedObject }.to(
             throwError(errorType: NativeSharedObjectNotFoundException.self)
           )
         }

package/ios/Tests/EitherSpec.swift

@@ -6,6 +6,8 @@ import ExpoModulesTestCore
 
 final class EitherSpec: ExpoSpec {
   override func spec() {
+    let appContext = AppContext.create()
+
     describe("Either") {
       it("is the first type") {
         let either = Either<String, Int>("string")
@@ -33,16 +35,16 @@ final class EitherSpec: ExpoSpec {
         expect(value).notTo(beNil())
       }
       it("converts as convertible") {
-        let either = try Either<String, Int>.convert(from: 123)
+        let either = try Either<String, Int>.convert(from: 123, appContext: appContext)
         expect(either.is(String.self)) == false
         expect(either.is(Int.self)) == true
       }
       it("throws when converting from neither type") {
-        expect({ try Either<String, Int>.convert(from: true) }).to(throwError(errorType: NeitherTypeException.self))
+        expect({ try Either<String, Int>.convert(from: true, appContext: appContext) }).to(throwError(errorType: NeitherTypeException.self))
       }
 
       it("supports arrays") {
-        let either = try Either<String, [String]>.convert(from: ["foo"])
+        let either = try Either<String, [String]>.convert(from: ["foo"], appContext: appContext)
         let value: [String]? = either.get()
 
         expect(either.is([String].self)) == true
@@ -50,7 +52,7 @@ final class EitherSpec: ExpoSpec {
       }
 
       it("supports convertibles (UIColor)") {
-        let either = try Either<Int, UIColor>.convert(from: "blue")
+        let either = try Either<Int, UIColor>.convert(from: "blue", appContext: appContext)
         let color: UIColor? = either.get()
 
         expect(either.is(UIColor.self)) == true
@@ -62,7 +64,7 @@ final class EitherSpec: ExpoSpec {
           @Field
           var foo: String
         }
-        let either = try Either<String, TestRecord>.convert(from: ["foo": "bar"])
+        let either = try Either<String, TestRecord>.convert(from: ["foo": "bar"], appContext: appContext)
         let record: TestRecord? = either.get()
 
         expect(either.is(TestRecord.self)) == true
@@ -88,7 +90,7 @@ final class EitherSpec: ExpoSpec {
         expect(value).notTo(beNil())
       }
       it("throws when converting from neither type") {
-        expect({ try EitherOfThree<String, Int, Double>.convert(from: false) }).to(throwError(errorType: NeitherTypeException.self))
+        expect({ try EitherOfThree<String, Int, Double>.convert(from: false, appContext: appContext) }).to(throwError(errorType: NeitherTypeException.self))
       }
     }
     describe("EitherOfFour") {
@@ -112,7 +114,7 @@ final class EitherSpec: ExpoSpec {
         expect(value).notTo(beNil())
       }
       it("throws when converting from neither type") {
-        expect({ try EitherOfFour<String, Int, Double, Bool>.convert(from: [1, 2]) }).to(throwError(errorType: NeitherTypeException.self))
+        expect({ try EitherOfFour<String, Int, Double, Bool>.convert(from: [1, 2], appContext: appContext) }).to(throwError(errorType: NeitherTypeException.self))
       }
     }
   }

package/ios/Tests/ExpoModulesSpec.swift

@@ -7,7 +7,7 @@ import ExpoModulesTestCore
 class ExpoModulesSpec: ExpoSpec {
   override func spec() {
     let appContext = AppContext.create()
-    let runtime = appContext.runtime
+    let runtime = try! appContext.runtime
     let testModuleName = "TestModule"
     let testFunctionName = "testFunction"
     let throwingFunctionName = "throwingFunction"
@@ -33,23 +33,23 @@ class ExpoModulesSpec: ExpoSpec {
 
     describe("host object") {
       it("is defined") {
-        expect(try! runtime?.eval("'ExpoModules' in this").asBool()) === true
+        expect(try! runtime.eval("'ExpoModules' in this").asBool()) === true
       }
 
       it("has native module defined") {
-        expect(try! runtime?.eval("'\(testModuleName)' in ExpoModules").asBool()) === true
+        expect(try! runtime.eval("'\(testModuleName)' in ExpoModules").asBool()) === true
       }
 
       it("can access native module") {
-        let nativeModule = try! runtime?.eval("expo.modules.\(testModuleName)")
-        expect(nativeModule?.isUndefined()) == false
-        expect(nativeModule?.isObject()) == true
-        expect(nativeModule?.getRaw()).notTo(beNil())
+        let nativeModule = try runtime.eval("expo.modules.\(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 {
+        let keys = try runtime.eval("Object.keys(ExpoModules)").asArray().compactMap {
           return try! $0?.asString()
         }
         expect(keys).to(contain(registeredModuleNames))
@@ -58,7 +58,7 @@ class ExpoModulesSpec: ExpoSpec {
 
     describe("module") {
       it("exposes constants") {
-        let dict = try! runtime!.eval("expo.modules.TestModule").asDict()
+        let dict = try runtime.eval("expo.modules.TestModule").asDict()
 
         dict.forEach { (key: String, value: Any) in
           expect(value) === dict[key]!
@@ -66,17 +66,17 @@ class ExpoModulesSpec: ExpoSpec {
       }
 
       it("has function") {
-        expect(try! runtime?.eval("typeof expo.modules.TestModule.\(testFunctionName)").asString()) == "function"
-        expect(try! runtime?.eval("expo.modules.TestModule.\(testFunctionName)").isFunction()) == true
+        expect(try runtime.eval("typeof expo.modules.TestModule.\(testFunctionName)").asString()) == "function"
+        expect(try runtime.eval("expo.modules.TestModule.\(testFunctionName)").isFunction()) == true
       }
 
       it("calls function") {
-        expect(try! runtime?.eval("expo.modules.TestModule.\(testFunctionName)()").asDouble()) == Double.pi
+        expect(try runtime.eval("expo.modules.TestModule.\(testFunctionName)()").asDouble()) == Double.pi
       }
 
       it("throws from sync function") {
         // Invoke the throwing function and return the error (eval shouldn't rethrow here)
-        let error = try! runtime!.eval("try { expo.modules.TestModule.\(throwingFunctionName)() } catch (error) { error }").asObject()
+        let error = try runtime.eval("try { expo.modules.TestModule.\(throwingFunctionName)() } catch (error) { error }").asObject()
 
         // We just check if it contains the description — they won't be equal for the following reasons:
         // - the `exceptionToThrow` is just the root cause, in fact it returns `FunctionCallException`

package/ios/Tests/FunctionSpec.swift

@@ -128,11 +128,15 @@ class FunctionSpec: ExpoSpec {
 
         it("returns the record back (sync)") {
           let result = try Function(functionName) { (record: TestRecord) in record }
-            .call(by: nil, withArguments: [dict]) as? TestRecord.Dict
+            .call(by: nil, withArguments: [dict], appContext: appContext) as? TestRecord
+
+          guard let result = Conversions.convertFunctionResult(result, appContext: appContext) as? TestRecord.Dict else {
+            return fail()
+          }
 
           expect(result).notTo(beNil())
-          expect(result?["property"] as? String).to(equal(dict["property"]))
-          expect(result?["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
+          expect(result["property"] as? String).to(equal(dict["property"]))
+          expect(result["propertyWithCustomKey"] as? String).to(equal(dict["propertyWithCustomKey"]))
         }
 
         it("returns the record back (async)") {
@@ -186,11 +190,11 @@ class FunctionSpec: ExpoSpec {
           return returnedValue
         }
 
-        expect({ try fn.call(by: nil, withArguments: ["test"]) })
+        expect({ try fn.call(by: nil, withArguments: ["test"], appContext: appContext) })
           .notTo(throwError())
           .to(be(returnedValue))
 
-        expect({ try fn.call(by: nil, withArguments: ["test", 3]) })
+        expect({ try fn.call(by: nil, withArguments: ["test", 3], appContext: appContext) })
           .notTo(throwError())
           .to(be(returnedValue))
       }
@@ -200,7 +204,7 @@ class FunctionSpec: ExpoSpec {
           return "something"
         }
 
-        expect({ try fn.call(by: nil, withArguments: []) })
+        expect({ try fn.call(by: nil, withArguments: [], appContext: appContext) })
           .to(throwError(errorType: FunctionCallException.self) { error in
             expect(error.rootCause).to(beAKindOf(InvalidArgsNumberException.self))
             let exception = error.rootCause as! InvalidArgsNumberException
@@ -222,7 +226,8 @@ class FunctionSpec: ExpoSpec {
             switch result {
             case .failure(let error):
               expect(error).notTo(beNil())
-              expect(error).to(beAKindOf(ArgumentCastException.self))
+              expect(error).to(beAKindOf(FunctionCallException.self))
+              expect(error.isCausedBy(ArgumentCastException.self)) == true
               expect(error.isCausedBy(Conversions.CastingException<String>.self)) == true
             case .success(_):
               fail()
@@ -232,20 +237,20 @@ class FunctionSpec: ExpoSpec {
         }
       }
     }
-    
+
     context("JavaScript") {
-      let runtime = appContext.runtime
-      
+      let runtime = try! appContext.runtime
+
       beforeSuite {
         appContext.moduleRegistry.register(holder: mockModuleHolder(appContext) {
           Name("TestModule")
 
           Function("returnPi") { Double.pi }
-          
+
           Function("returnNull") { () -> Double? in
             return nil
           }
-          
+
           Function("isArgNull") { (arg: Double?) -> Bool in
             return arg == nil
           }
@@ -260,30 +265,41 @@ class FunctionSpec: ExpoSpec {
               }
             }
           }
+
+          Function("withFunction") { (fn: JavaScriptFunction<String>) -> String in
+            return try fn.call("foo", "bar")
+          }
         })
       }
 
       it("returns values") {
-        expect(try runtime?.eval("expo.modules.TestModule.returnPi()").asDouble()) == Double.pi
-        expect(try runtime?.eval("expo.modules.TestModule.returnNull()").isNull()) == true
+        expect(try runtime.eval("expo.modules.TestModule.returnPi()").asDouble()) == Double.pi
+        expect(try runtime.eval("expo.modules.TestModule.returnNull()").isNull()) == true
       }
 
       it("accepts optional arguments") {
-        expect(try runtime?.eval("expo.modules.TestModule.isArgNull(3.14)").asBool()) == false
-        expect(try runtime?.eval("expo.modules.TestModule.isArgNull(null)").asBool()) == true
+        expect(try runtime.eval("expo.modules.TestModule.isArgNull(3.14)").asBool()) == false
+        expect(try runtime.eval("expo.modules.TestModule.isArgNull(null)").asBool()) == true
       }
 
       it("returns object made from definition") {
         let initialValue = Int.random(in: 1..<100)
-        let object = try runtime?.eval("object = expo.modules.TestModule.returnObjectDefinition(\(initialValue))")
+        let object = try runtime.eval("object = expo.modules.TestModule.returnObjectDefinition(\(initialValue))")
+
+        expect(object.kind) == .object
+        expect(object.getObject().hasProperty("increment")) == true
 
-        expect(object?.kind) == .object
-        expect(object?.getObject().hasProperty("increment")) == true
+        let result = try runtime.eval("object.increment()")
+
+        expect(result.kind) == .number
+        expect(result.getInt()) == initialValue + 1
+      }
 
-        let result = try runtime?.eval("object.increment()")
+      it("takes JavaScriptFunction argument") {
+        let value = try runtime.eval("expo.modules.TestModule.withFunction((a, b) => a + b)")
 
-        expect(result?.kind) == .number
-        expect(result?.getInt()) == initialValue + 1
+        expect(value.kind) == .string
+        expect(value.getString()) == "foobar"
       }
     }
   }

package/ios/Tests/JavaScriptRuntimeSpec.swift

@@ -86,7 +86,11 @@ class JavaScriptRuntimeSpec: ExpoSpec {
       it("throws evaluation exception") {
         expect({ try runtime.eval("foo") }).to(throwError { error in
           expect(error).to(beAKindOf(JavaScriptEvalException.self))
+          #if canImport(reacthermes)
+          expect((error as! JavaScriptEvalException).reason).to(contain("Property 'foo' doesn't exist"))
+          #else
           expect((error as! JavaScriptEvalException).reason).to(contain("Can't find variable: foo"))
+          #endif
         })
       }
     }

package/ios/Tests/PropertyComponentSpec.swift

@@ -5,9 +5,12 @@ import ExpoModulesTestCore
 class PropertyComponentSpec: ExpoSpec {
   override func spec() {
     describe("property") {
+      let appContext = AppContext.create()
+      let runtime = try! appContext.runtime
+
       it("gets the value") {
         let property = Property("test") { return "expo" }
-        expect(try property.getValue()) == "expo"
+        expect(try property.getValue(appContext: appContext)) == "expo"
       }
 
       it("sets the value") {
@@ -19,39 +22,39 @@ class PropertyComponentSpec: ExpoSpec {
           }
 
         let newValue = Int.random(in: 0..<100)
-        property.setValue(newValue)
+        property.setValue(newValue, appContext: appContext)
 
-        expect(try property.getValue()) == value
+        expect(try property.getValue(appContext: appContext)) == value
         expect(value) == newValue
       }
     }
 
     describe("module property") {
       let appContext = AppContext.create()
-      let runtime = appContext.runtime
+      let runtime = try! appContext.runtime
 
       beforeSuite {
         appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
       }
 
       it("gets read-only property") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.readOnly")
-        expect(value?.getString()) == "foo"
+        let value = try runtime.eval("expo.modules.PropertyTest.readOnly")
+        expect(value.getString()) == "foo"
       }
 
       it("gets writable property") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.writable")
-        expect(value?.getInt()) == 444
+        let value = try runtime.eval("expo.modules.PropertyTest.writable")
+        expect(value.getInt()) == 444
       }
 
       it("sets writable property") {
-        try runtime?.eval("expo.modules.PropertyTest.writable = 777")
-        let value = try runtime?.eval("expo.modules.PropertyTest.writable")
-        expect(value?.getInt()) == 777
+        try runtime.eval("expo.modules.PropertyTest.writable = 777")
+        let value = try runtime.eval("expo.modules.PropertyTest.writable")
+        expect(value.getInt()) == 777
       }
 
       it("is enumerable") {
-        let keys = try runtime?.eval("Object.keys(expo.modules.PropertyTest)").getArray().map { $0.getString() } ?? []
+        let keys = try runtime.eval("Object.keys(expo.modules.PropertyTest)").getArray().map { $0.getString() } ?? []
         expect(keys).to(contain("readOnly", "writable", "undefined"))
       }
 
@@ -62,73 +65,73 @@ class PropertyComponentSpec: ExpoSpec {
 //      }
 
       it("returns undefined when getter is not specified") {
-        let value = try runtime?.eval("expo.modules.PropertyTest.undefined")
-        expect(value?.isUndefined()) == true
+        let value = try runtime.eval("expo.modules.PropertyTest.undefined")
+        expect(value.isUndefined()) == true
       }
     }
 
     describe("class property") {
       let appContext = AppContext.create()
-      let runtime = appContext.runtime
+      let runtime = try! appContext.runtime
 
       beforeSuite {
         appContext.moduleRegistry.register(moduleType: PropertyTestModule.self)
       }
 
       it("gets the value") {
-        let value = try runtime?.eval("new expo.modules.PropertyTest.TestClass().someValue")
+        let value = try runtime.eval("new expo.modules.PropertyTest.TestClass().someValue")
 
-        expect(value?.kind) == .number
-        expect(value?.getInt()) == TestClass.constantValue
+        expect(value.kind) == .number
+        expect(value.getInt()) == TestClass.constantValue
       }
 
       it("sets the value") {
         let newValue = Int.random(in: 1..<100)
-        let value = try runtime?.eval([
+        let value = try runtime.eval([
           "object = new expo.modules.PropertyTest.TestClass()",
           "object.someValue = \(newValue)",
           "object.someValue"
         ])
 
-        expect(value?.kind) == .number
-        expect(value?.getInt()) == newValue
+        expect(value.kind) == .number
+        expect(value.getInt()) == newValue
       }
 
       // Tests for accessing shared object properties through KeyPath and ReferenceWritableKeyPath
       describe("key path") {
         it("gets immutable property") {
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.immutableKeyPathProperty"
           ])
 
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == TestClass.constantValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == TestClass.constantValue
         }
 
         it("cannot set immutable property") {
           let newValue = Int.random(in: 100..<200)
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.immutableKeyPathProperty = \(newValue)",
             "object.immutableKeyPathProperty"
           ])
 
           // Returned value didn't change, it doesn't equal to `newValue`
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == TestClass.constantValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == TestClass.constantValue
         }
 
         it("sets mutable property") {
           let newValue = Int.random(in: 100..<200)
-          let value = try runtime?.eval([
+          let value = try runtime.eval([
             "object = new expo.modules.PropertyTest.TestClass()",
             "object.mutableKeyPathProperty = \(newValue)",
             "object.mutableKeyPathProperty"
           ])
 
-          expect(value?.kind) == .number
-          expect(value?.getInt()) == newValue
+          expect(value.kind) == .number
+          expect(value.getInt()) == newValue
         }
       }
     }

package/ios/Tests/RecordSpec.swift

@@ -4,9 +4,11 @@ import ExpoModulesTestCore
 
 class RecordSpec: ExpoSpec {
   override func spec() {
+    let appContext = AppContext.create()
+
     it("initializes with empty dictionary") {
       struct TestRecord: Record { }
-      _ = try TestRecord(from: [:])
+      _ = try TestRecord(from: [:], appContext: appContext)
     }
 
     it("works back and forth with a field") {
@@ -14,7 +16,7 @@ class RecordSpec: ExpoSpec {
         @Field var a: String?
       }
       let dict = ["a": "b"]
-      let record = try TestRecord(from: dict)
+      let record = try TestRecord(from: dict, appContext: appContext)
 
       expect(record.a).to(be(dict["a"]))
       expect(record.toDictionary()["a"]).to(be(dict["a"]))
@@ -25,7 +27,7 @@ class RecordSpec: ExpoSpec {
         @Field("key") var a: String?
       }
       let dict = ["key": "b"]
-      let record = try TestRecord(from: dict)
+      let record = try TestRecord(from: dict, appContext: appContext)
 
       expect(record.a).to(be(dict["key"]))
       expect(record.toDictionary()["key"]).to(be(dict["key"]))
@@ -36,7 +38,7 @@ class RecordSpec: ExpoSpec {
         @Field(.required) var a: Int
       }
 
-      expect { try TestRecord(from: [:]) }.to(throwError { error in
+      expect { try TestRecord(from: [:], appContext: appContext) }.to(throwError { error in
         expect(error).to(beAKindOf(FieldRequiredException.self))
       })
     }
@@ -47,7 +49,7 @@ class RecordSpec: ExpoSpec {
       }
       let dict = ["a": "try with String instead of Int"]
 
-      expect { try TestRecord(from: dict) }.to(throwError { error in
+      expect { try TestRecord(from: dict, appContext: appContext) }.to(throwError { error in
         expect(error).to(beAKindOf(FieldInvalidTypeException.self))
       })
     }