Migrated test for multiple apply/revert calls

Author: lukaskubanek

Tests/InterposeKitTests/ClassHookTests.swift

@@ -3,70 +3,120 @@ import XCTest
 
 fileprivate class ExampleClass: NSObject {
     @objc dynamic func doSomething() {}
+    @objc dynamic var intValue = 1
 }
 
 fileprivate class ExampleSubclass: ExampleClass {}
 
 final class ClassHookTests: InterposeKitTestCase {
 
-    func testSuccess_applyHook() throws {
+    func testLifecycle_applyHook() throws {
         let hook = try Interpose.applyHook(
             on: ExampleClass.self,
-            for: #selector(ExampleClass.doSomething),
-            methodSignature: (@convention(c) (NSObject, Selector) -> Void).self,
-            hookSignature: (@convention(block) (NSObject) -> Void).self
+            for: #selector(getter: ExampleClass.intValue),
+            methodSignature: (@convention(c) (NSObject, Selector) -> Int).self,
+            hookSignature: (@convention(block) (NSObject) -> Int).self
         ) { hook in
-            return { `self` in }
+            return { `self` in
+                1 + hook.original(self, hook.selector)
+            }
         }
 
+        XCTAssertEqual(ExampleClass().intValue, 2)
         XCTAssertEqual(hook.state, .active)
         XCTAssertMatchesRegex(
             hook.debugDescription,
-            #"^Active hook for -\[ExampleClass doSomething\] \(originalIMP: 0x[0-9a-fA-F]+\)$"#
+            #"^Active hook for -\[ExampleClass intValue\] \(originalIMP: 0x[0-9a-fA-F]+\)$"#
         )
 
         try hook.revert()
 
+        XCTAssertEqual(ExampleClass().intValue, 1)
         XCTAssertEqual(hook.state, .pending)
         XCTAssertMatchesRegex(
             hook.debugDescription,
-            #"^Pending hook for -\[ExampleClass doSomething\]$"#
+            #"^Pending hook for -\[ExampleClass intValue\]$"#
         )
     }
 
-    func testSuccess_prepareHook() throws {
+    func testLifecycle_prepareHook() throws {
         let hook = try Interpose.prepareHook(
             on: ExampleClass.self,
-            for: #selector(ExampleClass.doSomething),
-            methodSignature: (@convention(c) (NSObject, Selector) -> Void).self,
-            hookSignature: (@convention(block) (NSObject) -> Void).self
+            for: #selector(getter: ExampleClass.intValue),
+            methodSignature: (@convention(c) (NSObject, Selector) -> Int).self,
+            hookSignature: (@convention(block) (NSObject) -> Int).self
         ) { hook in
-            return { `self` in }
+            return { `self` in
+                1 + hook.original(self, hook.selector)
+            }
         }
 
+        XCTAssertEqual(ExampleClass().intValue, 1)
         XCTAssertEqual(hook.state, .pending)
         XCTAssertMatchesRegex(
             hook.debugDescription,
-            #"^Pending hook for -\[ExampleClass doSomething\]$"#
+            #"^Pending hook for -\[ExampleClass intValue\]$"#
         )
 
         try hook.apply()
 
+        XCTAssertEqual(ExampleClass().intValue, 2)
         XCTAssertEqual(hook.state, .active)
         XCTAssertMatchesRegex(
             hook.debugDescription,
-            #"^Active hook for -\[ExampleClass doSomething\] \(originalIMP: 0x[0-9a-fA-F]+\)$"#
+            #"^Active hook for -\[ExampleClass intValue\] \(originalIMP: 0x[0-9a-fA-F]+\)$"#
         )
 
         try hook.revert()
 
+        XCTAssertEqual(ExampleClass().intValue, 1)
         XCTAssertEqual(hook.state, .pending)
         XCTAssertMatchesRegex(
             hook.debugDescription,
-            #"^Pending hook for -\[ExampleClass doSomething\]$"#
+            #"^Pending hook for -\[ExampleClass intValue\]$"#
         )
     }
 
+    func testLifecycle_idempotentApplyAndRevert() throws {
+        let object = ExampleClass()
+        
+        let hook = try Interpose.prepareHook(
+            on: ExampleClass.self,
+            for: #selector(getter: ExampleClass.intValue),
+            methodSignature: (@convention(c) (NSObject, Selector) -> Int).self,
+            hookSignature: (@convention(block) (NSObject) -> Int).self
+        ) { hook in
+            return { `self` in
+                1 + hook.original(self, hook.selector)
+            }
+        }
+        
+        XCTAssertEqual(object.intValue, 1)
+        XCTAssertEqual(hook.state, .pending)
+        
+        try hook.apply()
+        try hook.apply() // noop
+        
+        XCTAssertEqual(object.intValue, 2)
+        XCTAssertEqual(hook.state, .active)
+        
+        try hook.revert()
+        try hook.revert() // noop
+        
+        XCTAssertEqual(object.intValue, 1)
+        XCTAssertEqual(hook.state, .pending)
+        
+        try hook.apply()
+        
+        XCTAssertEqual(object.intValue, 2)
+        XCTAssertEqual(hook.state, .active)
+        
+        try hook.revert()
+        
+        XCTAssertEqual(object.intValue, 1)
+        XCTAssertEqual(hook.state, .pending)
+    }
+    
     func testValidationFailure_methodNotFound() throws {
         XCTAssertThrowsError(
             try Interpose.prepareHook(

Tests/InterposeKitTests/ToBePolished/InterposeKitTests.swift

@@ -3,41 +3,6 @@ import XCTest
 
 final class InterposeKitTests: InterposeKitTestCase {
 
-    func testClassOverrideAndRevert() throws {
-        let testObj = TestClass()
-        XCTAssertEqual(testObj.sayHi(), testClassHi)
-
-        // Functions need to be `@objc dynamic` to be hookable.
-        let hook = try Interpose.applyHook(
-            on: TestClass.self,
-            for: #selector(TestClass.sayHi),
-            methodSignature: (@convention(c) (NSObject, Selector) -> String).self,
-            hookSignature: (@convention(block) (NSObject) -> String).self) { store in { bSelf in
-                // You're free to skip calling the original implementation.
-                print("Before Interposing \(bSelf)")
-                let string = store.original(bSelf, store.selector)
-                print("After Interposing \(bSelf)")
-                
-                return string + testString
-            }
-            }
-        print(TestClass().sayHi())
-
-        // Test various apply/revert's
-        XCTAssertEqual(testObj.sayHi(), testClassHi + testString)
-        try hook.revert()
-        XCTAssertEqual(testObj.sayHi(), testClassHi)
-        try hook.apply()
-        XCTAssertEqual(testObj.sayHi(), testClassHi + testString)
-        try hook.apply() // noop
-        try hook.apply() // noop
-        try hook.revert()
-        try hook.revert() // noop
-        try hook.apply()
-        try hook.revert()
-        XCTAssertEqual(testObj.sayHi(), testClassHi)
-    }
-
     func testSubclassOverride() throws {
         let testObj = TestSubclass()
         XCTAssertEqual(testObj.sayHi(), testClassHi + testSubclass)