expo-modules-core 0.9.2 → 0.10.0

package/ios/Tests/DynamicTypeSpec.swift

@@ -0,0 +1,336 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import CoreGraphics
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class DynamicTypeSpec: ExpoSpec {
+  override func spec() {
+    // MARK: - DynamicRawType
+
+    describe("DynamicRawType") {
+      it("is created") {
+        expect(~String.self).to(beAKindOf(DynamicRawType<String>.self))
+        expect(~Bool.self).to(beAKindOf(DynamicRawType<Bool>.self))
+        expect(~ExpoSpec.self).to(beAKindOf(DynamicRawType<ExpoSpec>.self))
+      }
+      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
+        }
+        it("throws NullCastException") {
+          let value: Double? = nil
+          let anyValue = value as Any
+
+          expect { try (~Double.self).cast(anyValue) }.to(
+            throwError(errorType: Conversions.NullCastException<Double>.self)
+          )
+        }
+        it("throws CastingException") {
+          expect { try (~String.self).cast(true) }.to(
+            throwError(errorType: Conversions.CastingException<String>.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~Double.self ~> Double.self) == true
+          expect(~Bool.self ~> Bool.self) == true
+          expect(~DynamicTypeSpec.self ~> DynamicTypeSpec.self) == true
+        }
+        it("is false") {
+          expect(~Double.self !~> Bool.self) == true
+          expect(~Bool.self !~> Double.self) == true
+          expect(~DynamicTypeSpec.self !~> ExpoSpec.self) == true
+        }
+      }
+      describe("equals") {
+        it("is true") {
+          expect(~Int.self == ~Int.self) == true
+          expect(~Double.self == ~Double.self) == true
+          expect(~Bool.self == ~Bool.self) == true
+          expect(~ExpoSpec.self == ~ExpoSpec.self) == true
+        }
+        it("is false") {
+          expect(~Int.self != ~String.self) == true
+          expect(~String.self != ~CGSize.self) == true
+          expect(~Bool.self != ~Promise.self) == true
+        }
+      }
+    }
+
+    // MARK: - DynamicArrayType
+
+    describe("DynamicArrayType") {
+      it("is created") {
+        expect(~[Double].self).to(beAKindOf(DynamicArrayType.self))
+        expect(~[String?].self).to(beAKindOf(DynamicArrayType.self))
+        expect(~[[Int]].self).to(beAKindOf(DynamicArrayType.self))
+      }
+      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"]]
+        }
+        it("casts arrays") {
+          let value = 9.9
+          let anyValue = [value] as [Any]
+          let result = try (~[Double].self).cast(anyValue) as! [Any]
+
+          expect(result).to(beAKindOf([Double].self))
+          expect(result as? [Double]) == [value]
+        }
+        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"]
+        }
+        it("throws CastingException") {
+          expect { try (~[String].self).cast(84) }.to(
+            throwError(errorType: Conversions.CastingException<String>.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~[Double].self ~> [Double].self) == true
+          expect(~[[String]].self ~> [[String]].self) == true
+          expect(~[CGPoint].self ~> [CGPoint].self) == true
+        }
+        it("is false") {
+          expect(~[String].self !~> [Int].self) == true
+          expect(~[Promise].self !~> Promise.self) == true
+        }
+      }
+      describe("equals") {
+        it("is true") {
+          expect(~[String].self == ~[String].self) == true
+          expect(~[CGSize].self == ~[CGSize].self) == true
+          expect(~[[[Double]]].self == ~[[[Double]]].self) == true
+        }
+        it("is false") {
+          expect(~[Int].self != ~[Double].self) == true
+          expect(~[[String]].self != ~[String].self) == true
+          expect(~[URL].self != ~[String].self) == true
+        }
+      }
+    }
+
+    // MARK: - DynamicConvertibleType
+
+    describe("DynamicConvertibleType") {
+      it("is created") {
+        expect(~CGPoint.self).to(beAKindOf(DynamicConvertibleType.self))
+        expect(~CGRect.self).to(beAKindOf(DynamicConvertibleType.self))
+        expect(~CGColor.self).to(beAKindOf(DynamicConvertibleType.self))
+        expect(~URL.self).to(beAKindOf(DynamicConvertibleType.self))
+      }
+      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")
+        }
+        it("throws ConvertingException") {
+          expect { try (~CGRect.self).cast("not a rect") as? CGRect }.to(
+            throwError(errorType: Conversions.ConvertingException<CGRect>.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~CGRect.self ~> CGRect.self) == true
+          expect(~CGColor.self ~> CGColor.self) == true
+          expect(~URL.self ~> URL.self) == true
+        }
+        it("is false") {
+          expect(~CGRect.self !~> Double.self) == true
+          expect(~CGColor.self !~> CGRect.self) == true
+          expect(~URL.self !~> String.self) == true
+        }
+      }
+      describe("equals") {
+        it("is true") {
+          expect(~CGSize.self == ~CGSize.self) == true
+          expect(~URL.self == ~URL.self) == true
+          expect(~UIColor.self == ~UIColor.self) == true
+        }
+        it("is false") {
+          expect(~CGSize.self != ~CGRect.self) == true
+          expect(~CGPoint.self != ~CGVector.self) == true
+          expect(~URL.self != ~String.self) == true
+        }
+      }
+    }
+
+    // MARK: - DynamicEnumType
+
+    describe("DynamicEnumType") {
+      enum StringTestEnum: String, EnumArgument {
+        case hello
+        case expo
+      }
+      enum IntTestEnum: Int, EnumArgument {
+        case negative = -1
+        case positive = 1
+      }
+
+      it("is created") {
+        expect(~StringTestEnum.self).to(beAKindOf(DynamicEnumType.self))
+        expect(~IntTestEnum.self).to(beAKindOf(DynamicEnumType.self))
+      }
+      describe("casts") {
+        it("succeeds") {
+          expect(try (~StringTestEnum.self).cast("expo") as? StringTestEnum) == .expo
+          expect(try (~IntTestEnum.self).cast(1) as? IntTestEnum) == .positive
+        }
+        it("throws EnumNoSuchValueException") {
+          expect { try (~StringTestEnum.self).cast("react native") as? StringTestEnum }.to(
+            throwError(errorType: EnumNoSuchValueException.self)
+          )
+        }
+        it("throws EnumCastingException") {
+          expect { try (~IntTestEnum.self).cast(true) as? StringTestEnum }.to(
+            throwError(errorType: EnumCastingException.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~StringTestEnum.self ~> StringTestEnum.self) == true
+          expect(~IntTestEnum.self ~> IntTestEnum.self) == true
+        }
+        it("is false") {
+          expect(~StringTestEnum.self !~> IntTestEnum.self) == true
+          expect(~IntTestEnum.self !~> StringTestEnum.self) == true
+        }
+      }
+
+      describe("equals") {
+        it("is true") {
+          expect(~StringTestEnum.self == ~StringTestEnum.self) == true
+          expect(~IntTestEnum.self == ~IntTestEnum.self) == true
+        }
+        it("is false") {
+          expect(~StringTestEnum.self != ~IntTestEnum.self) == true
+          expect(~IntTestEnum.self != ~StringTestEnum.self) == true
+          expect(~StringTestEnum.self != ~Double.self) == true
+          expect(~IntTestEnum.self != ~Int.self) == true
+        }
+      }
+    }
+
+    // MARK: - DynamicOptionalType
+
+    describe("DynamicOptionalType") {
+      it("is created") {
+        expect(~String?.self).to(beAKindOf(DynamicOptionalType.self))
+        expect(~[Double]?.self).to(beAKindOf(DynamicOptionalType.self))
+        expect(~[Int?]?.self).to(beAKindOf(DynamicOptionalType.self))
+      }
+      describe("casts") {
+        it("succeeds") {
+          expect(try (~String?.self).cast("expo") as? String) == "expo"
+          expect(try (~Bool?.self).cast(false) as? Bool) == false
+        }
+        it("succeeds with nil") {
+          let value: Double? = nil
+          let result = try (~Double?.self).cast(value as Any)
+
+          expect(result).to(beAKindOf(Double?.self))
+
+          // Since this `nil` is in fact of non-optional `Any` type, under the hood it's described as `Optional` enum.
+          // Simply checking `result == nil` does NOT work here, see `Optional.isNil` extension implementation.
+          expect(Optional.isNil(result)) == true
+        }
+        it("succeeds with NSNull") {
+          let value = NSNull()
+          let result = try (~Double?.self).cast(value as Any)
+          expect(result).to(beAKindOf(Double?.self))
+          expect(Optional.isNil(result)) == true
+        }
+        it("throws CastingException") {
+          expect { try (~Double?.self).cast("a string") as? Double }.to(
+            throwError(errorType: Conversions.CastingException<Double>.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~Double?.self ~> Double?.self) == true
+          expect(~String?.self ~> String?.self) == true
+          expect(~URL?.self ~> URL?.self) == true
+        }
+        it("is false") {
+          expect(~Double?.self !~> Double.self) == true
+          expect(~[URL]?.self !~> URL.self) == true
+          expect(~[String]?.self !~> [String?].self) == true
+        }
+      }
+      describe("equals") {
+        it("is true") {
+          expect(~Int?.self == ~Int?.self) == true
+          expect(~ExpoSpec.self == ~ExpoSpec.self) == true
+        }
+        it("is false") {
+          expect(~Double?.self != ~Double.self) == true
+          expect(~Int?.self != ~Double?.self) == true
+          expect(~[Bool]?.self != ~[Bool].self) == true
+        }
+      }
+    }
+
+    // MARK: - DynamicSharedObjectType
+
+    describe("DynamicSharedObjectType") {
+      class TestSharedObject: SharedObject {}
+
+      it("is created") {
+        expect(~TestSharedObject.self).to(beAKindOf(DynamicSharedObjectType.self))
+      }
+      describe("casts") {
+        it("succeeds") {
+          let appContext = AppContext.create()
+          let nativeObject = TestSharedObject()
+          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
+        }
+        it("throws NativeSharedObjectNotFoundException") {
+          expect { try (~TestSharedObject.self).cast("a string") as? TestSharedObject }.to(
+            throwError(errorType: NativeSharedObjectNotFoundException.self)
+          )
+        }
+      }
+      describe("wraps") {
+        it("is true") {
+          expect(~TestSharedObject.self ~> TestSharedObject.self) == true
+        }
+        it("is false") {
+          expect(~TestSharedObject.self !~> SharedObject.self) == true
+          expect(~TestSharedObject.self !~> String?.self) == true
+        }
+      }
+      describe("equals") {
+        it("is true") {
+          expect(~TestSharedObject.self == ~TestSharedObject.self) == true
+          expect(~TestSharedObject?.self == ~TestSharedObject?.self) == true
+          expect(~[TestSharedObject].self == ~[TestSharedObject].self) == true
+        }
+        it("is false") {
+          expect(~TestSharedObject.self != ~TestSharedObject?.self) == true
+          expect(~TestSharedObject.self != ~[String: Any].self) == true
+          expect(~TestSharedObject.self != ~[TestSharedObject].self) == true
+        }
+      }
+    }
+  }
+}

package/ios/Tests/EnumArgumentSpec.swift

@@ -0,0 +1,48 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class EnumArgumentSpec: ExpoSpec {
+  override func spec() {
+    describe("static createFromRawValue") {
+      it("succeeds") {
+        expect(try Position.create(fromRawValue: "top")) == .top
+        expect(try Position.create(fromRawValue: "right")) == .right
+      }
+      it("throws EnumNoSuchValueException") {
+        expect { try Position.create(fromRawValue: "top-right") }.to(
+          throwError(errorType: EnumNoSuchValueException.self)
+        )
+      }
+      it("throws EnumCastingException") {
+        expect { try Position.create(fromRawValue: 4729) }.to(
+          throwError(errorType: EnumCastingException.self)
+        )
+        expect { try Position.create(fromRawValue: ["left"]) }.to(
+          throwError(errorType: EnumCastingException.self)
+        )
+      }
+    }
+
+    describe("anyRawValue") {
+      it("returns type-erased raw value") {
+        expect(Position.left.anyRawValue as? String) == Position.left.rawValue
+      }
+    }
+
+    describe("allRawValues") {
+      it("returns all raw values") {
+        expect(Position.allRawValues as? [String]) == ["top", "right", "bottom", "left"]
+      }
+    }
+  }
+}
+
+fileprivate enum Position: String, EnumArgument {
+  case top
+  case right
+  case bottom
+  case left
+}

package/ios/Tests/ExpoModulesSpec.swift

@@ -7,24 +7,27 @@ import ExpoModulesTestCore
 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 throwingFunctionName = "throwingFunction"
+    let exceptionToThrow = Exception(name: "Some exception", description: "Exception description")
     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 }
+
+        Function(throwingFunctionName) {
+          throw exceptionToThrow
+        }
       })
     }
 
@@ -70,6 +73,17 @@ class ExpoModulesSpec: ExpoSpec {
       it("calls function") {
         expect(try! runtime?.eval("ExpoModules.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 { ExpoModules.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`
+        // - the debug description contains the file and line number, so it's hard to mock the `FunctionCallException`
+        // Ideally if we have a better way (error codes/names) to identify them w/o relying on the description that may change over time.
+        expect(error.getProperty("message").getString()).to(contain(exceptionToThrow.debugDescription))
+      }
     }
   }
 }