Mobee 1075: Testing updates

Package.swift

@@ -0,0 +1,31 @@
+// swift-tools-version:5.5
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "WiseMock",
+    platforms: [
+          .macOS(.v10_10), .iOS(.v12)
+        ],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "WiseMock",
+            targets: ["WiseMock"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/Quick/Nimble.git", from: "9.2.1"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "WiseMock",
+            dependencies: [
+                .product(name: "Nimble", package: "Nimble",
+                                         condition: .when(platforms: [.macOS, .iOS])),
+            ]
+        )
+    ]
+)

README

@@ -1,34 +0,0 @@
-This framework provides:
-    - iOS Mocker
-    - WebRequest
-        - HTTP MultiPart
-        - HTTP Methods (ex. GET/POST/PUT/etc)
-        - HTTP-Redirection
-    - Mock WebRequest
-    - Util Functions
-        - DataFromHexString
-        - SplitString
-
-IMPORTANT:
-    This project contains two frameworks, one for development and another for production.
-        The production version is portable to the Apple App Store, but is incompatible with iOS-Simulators.
-        The development version is compatible with both iOS-Devices and the iOS-Simulators, but is NOT compatible with the Apple App Store.
-
-
-Build:
-    Development (Non App Store):
-        1. Select the "SwiftLibsFramework" project from the target-menu.
-        2. Select any non-generic simulator from the build-target. (i.e. "iPhone 5s")
-        3. Copy the built framework from bin/development into your project's directory.
-        4. Add the framework as an embedded-binary into your application.
-    Production (App Store):
-        1. Select the "SwiftLibsFrameworkProduction" project from the target-menu.
-        2. Select any the generic simulator from the build-target. (i.e. "Generic iOS Device")
-        3. Copy the built framework from bin/production into your project's directory.
-        4. Add the framework as an embedded-binary into your application.
-
-
-Pre-Built Binaries:
-    Located:
-        ./release/<version>/
-

Sources/WiseMock/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

SwiftLibsFramework/Info.plist → Sources/WiseMock/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.5</string>
+	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

Sources/WiseMock/Mockable.swift

@@ -0,0 +1,55 @@
+import Foundation
+
+public protocol Mockable {
+    associatedtype MockedMethod: RawRepresentable where MockedMethod.RawValue == String
+
+    var mocker: Mocker { get set }
+
+    func record(invocation: MockedMethod, with parameters: Any?...)
+    func invocationCount(for name: MockedMethod) -> Int
+    func parameters(for name: MockedMethod, at index: Int) -> [Any]
+    func parameter<T>(for name: MockedMethod, at index: Int, andInvocation invocation: Int) -> T?
+    func setReturnValue(for name: MockedMethod, with value: Any?, index: Int)
+    func returnValue<T>(for name: MockedMethod) -> T?
+    func reset()
+}
+
+public extension Mockable {
+
+    func record(invocation name: MockedMethod, with parameters: Any?...) {
+        mocker.recordInvocation(name.rawValue, paramList: parameters as [Any?])
+    }
+
+    func invocationCount(for name: MockedMethod) -> Int {
+        return mocker.getInvocationCountFor(name.rawValue)
+    }
+
+    func parameters(for name: MockedMethod, at index: Int = 0) -> [Any] {
+        return mocker.getParametersFor(name.rawValue, n: index) ?? []
+    }
+
+    func parameter<T>(for name: MockedMethod, at index: Int, andInvocation invocation: Int = 0) -> T? {
+        return parameters(for: name, at: invocation).value(at: index) as? T
+    }
+
+    func setReturnValue(for name: MockedMethod, with value: Any?, index: Int = -1) {
+        mocker.setReturnValueFor(name.rawValue, returnValue: value, n: index)
+    }
+
+    func returnValue<T>(for name: MockedMethod) -> T? {
+        return mocker.getReturnValueFor(name.rawValue) as? T
+    }
+
+    func reset() {
+        mocker.reset()
+    }
+}
+
+private extension Array {
+    func value(at index: Int) -> Element? {
+        guard index >= 0 && index < endIndex else {
+            return nil
+        }
+        return self[index]
+    }
+}

Sources/WiseMock/Mocker.swift

@@ -0,0 +1,82 @@
+import UIKit
+protocol iMocker {
+    associatedtype MethodName_t = String
+    associatedtype ParamList_t = Array<Any>
+    associatedtype ReturnType_t = Any
+    func setReturnValueFor(_ methodName : MethodName_t, returnValue : ReturnType_t?, n : Int)
+    func getReturnValueFor(_ methodName : MethodName_t) -> ReturnType_t?
+    func getParametersFor(_ methodName : MethodName_t, n : Int) -> ParamList_t?
+    func getInvocationCountFor(_ methodName : MethodName_t) -> Int
+    func recordInvocation(_ methodName : MethodName_t, paramList : ParamList_t?)
+    func reset()
+}
+
+private extension Array {
+    func get(at i: Index) -> Element? {
+        var count = 0
+        for item in self {
+            if count == i {
+                return item
+            }
+            count += 1
+        }
+        return nil
+    }
+}
+open class Mocker : NSObject, iMocker {
+    public typealias MethodName_t = String
+    public typealias ParamList_t = Array<Any>
+    public typealias ReturnType_t = Any
+
+    var invocationParameterArray = Dictionary<MethodName_t, Array<ParamList_t?>>()
+    var definedReturnValues = Dictionary<MethodName_t, Array<ReturnType_t?>>()
+    var definedReturnValueRequestCount = Dictionary<MethodName_t, Int>()
+    // If unspecified (or negative), n will append the returnValue to the queue of returnValues
+    // If specified, n will override the already-specified returnValue
+    open func setReturnValueFor(_ methodName : MethodName_t, returnValue : ReturnType_t?, n : Int = -1) {
+        if (definedReturnValues[methodName] == nil) {
+            definedReturnValues[methodName] = Array<ReturnType_t?>()
+            definedReturnValueRequestCount[methodName] = 0
+        }
+        if (n < 0) {
+            definedReturnValues[methodName]!.append(returnValue)
+        }
+        else {
+            definedReturnValues[methodName]![n] = returnValue
+        }
+    }
+    open func getReturnValueFor(_ methodName : MethodName_t) -> ReturnType_t? {
+        guard let requestCount = definedReturnValueRequestCount[methodName],
+            let returnValues = definedReturnValues[methodName] else {
+            return nil
+        }
+        definedReturnValueRequestCount[methodName] = requestCount + 1
+        assert(returnValues.count > 0, "Could not return \(requestCount)th value for \(methodName); no return values were set.")
+        if requestCount < returnValues.count {
+            return returnValues[requestCount]
+        }
+        else {
+            return returnValues[returnValues.count - 1]
+        }
+    }
+    open func getParametersFor(_ methodName : MethodName_t, n : Int = 0) -> ParamList_t? {
+        guard let methodName = invocationParameterArray[methodName] else { return nil }
+        let parametersForAllInvocations : Array<ParamList_t?> = methodName
+        return parametersForAllInvocations.get(at: n) ?? nil
+    }
+    open func getInvocationCountFor(_ methodName : MethodName_t) -> Int {
+        let parametersForAllInvocations : Array<ParamList_t?>? = invocationParameterArray[methodName]
+        return ( (parametersForAllInvocations == nil) ? 0 : parametersForAllInvocations!.count )
+    }
+    open func recordInvocation(_ methodName : MethodName_t, paramList : ParamList_t? = []) {
+        if (invocationParameterArray[methodName] == nil) {
+            invocationParameterArray[methodName] = Array<ParamList_t?>()
+        }
+        invocationParameterArray[methodName]!.append(paramList)
+    }
+    open func reset() {
+        invocationParameterArray.removeAll(keepingCapacity: false)
+        definedReturnValues.removeAll(keepingCapacity: false)
+        definedReturnValueRequestCount.removeAll(keepingCapacity: false)
+    }
+}

Sources/WiseMock/NimbleMatchers.swift

@@ -0,0 +1,83 @@
+import Foundation
+import Nimble
+
+///Invocation Count
+public func invoke<T: Mockable>(_ name: T.MockedMethod, times: Int = 1) -> Predicate<T> {
+
+    return Predicate<T>.define { actualExpression in
+        var expectationMessage: ExpectationMessage!
+        var status: PredicateStatus!
+
+        if let mockable = try? actualExpression.evaluate() {
+            let failureExpectationMessage = "invoke \(name) \(times) times"
+            let actualMessage = "\(mockable.invocationCount(for: name)) invocations"
+            status = PredicateStatus(bool: mockable.invocationCount(for: name) == times)
+            expectationMessage = .expectedCustomValueTo(failureExpectationMessage, actual: actualMessage)
+        } else {
+            status = .fail
+            expectationMessage = .fail("something else happened")
+        }
+        return PredicateResult(status: status, message: expectationMessage)
+    }
+
+}
+
+///Equality
+public func invoke<T: Mockable, E: Equatable>(_ name: T.MockedMethod, atInvocation invocationIndex: Int = 0, withParameter parameter: E?, at parameterIndex: Int = 0) -> Predicate<T> {
+    return Predicate<T>.define { actualExpression in
+        var expectationMessage: ExpectationMessage!
+        var status: PredicateStatus!
+
+        if let mockable = try? actualExpression.evaluate() {
+            let actualParameter: E? = mockable.parameter(for: name, at: parameterIndex, andInvocation: invocationIndex)
+            let actualMessage = String(describing: actualParameter)
+
+            expectationMessage = .expectedActualValueTo(actualMessage)
+            status = PredicateStatus(bool: actualParameter == parameter)
+        } else {
+            status = .fail
+            expectationMessage = .fail("something else happened")
+        }
+        return PredicateResult(status: status, message: expectationMessage)
+    }
+
+}
+
+///Identity
+public func invoke<T: Mockable, E: AnyObject>(_ name: T.MockedMethod, atInvocation invocationIndex: Int = 0, withIdenticalParameter parameter: E?, at parameterIndex: Int = 0) -> Predicate<T> {
+    return Predicate<T>.define { actualExpression in
+        var expectationMessage: ExpectationMessage!
+        var status: PredicateStatus!
+
+        if let mockable = try? actualExpression.evaluate() {
+            let actualParameter: E? = mockable.parameter(for: name, at: parameterIndex, andInvocation: invocationIndex)
+            let actualMessage = String(describing: actualParameter)
+
+            expectationMessage = .expectedActualValueTo(actualMessage)
+            status = PredicateStatus(bool: actualParameter === parameter)
+        } else {
+            status = .fail
+            expectationMessage = .fail("something else happened")
+        }
+        return PredicateResult(status: status, message: expectationMessage)
+    }
+}
+
+/// Closure Matcher
+public func invoke<T: Mockable, U>(_ name: T.MockedMethod, atInvocation invocationIndex: Int = 0, atParameterIndex parameterIndex: Int = 0, withMatcher matcher: @escaping ((U?) -> Bool)) -> Predicate<T> {
+    return Predicate<T>.define { actualExpression in
+        var expectationMessage: ExpectationMessage!
+        var status: PredicateStatus!
+
+        if let mockable = try? actualExpression.evaluate() {
+            let actualParameter: U? = mockable.parameter(for: name, at: parameterIndex, andInvocation: invocationIndex)
+
+            expectationMessage = .fail("parameter as \(String(describing: actualParameter)) does not match")
+            status = PredicateStatus(bool: matcher(actualParameter))
+        } else {
+            status = .fail
+            expectationMessage = .fail("something else happened")
+        }
+        return PredicateResult(status: status, message: expectationMessage)
+    }
+}

Sources/WiseMock/README.md

@@ -0,0 +1,3 @@
+# WiseMock
+
+A description of this package.