assertSame instead of assertEquals (#199)

TavoNiievez · web-flow · commit d82b6e568144 · 2022-01-03T08:56:13.000-05:00
diff --git a/README.md b/README.md
@@ -46,9 +46,9 @@ Let's redefine static methods and verify their calls at runtime.
 
 function testTableName()
 {
-	$this->assertEquals('users', UserModel::tableName());	
+	$this->assertSame('users', UserModel::tableName());	
 	$userModel = test::double('UserModel', ['tableName' => 'my_users']);
-	$this->assertEquals('my_users', UserModel::tableName());
+	$this->assertSame('my_users', UserModel::tableName());
 	$userModel->verifyInvoked('tableName');	
 }
 ```
@@ -83,7 +83,7 @@ function testUserCreate()
 	$user = test::double('User', ['save' => null]);
 	$service = new UserService;
 	$service->createUserByName('davert');
-	$this->assertEquals('davert', $user->getName());
+	$this->assertSame('davert', $user->getName());
 	$user->verifyInvoked('save');
 }
 ```
@@ -99,10 +99,10 @@ function testUserCreate()
 	$AR = test::double('ActiveRecord', ['save' => null]));
 	test::double('User', ['findByNameAndEmail' => new User(['name' => 'jon'])])); 
 	$user = User::findByNameAndEmail('jon','jon@coltrane.com'); // magic method
-	$this->assertEquals('jon', $user->getName());
+	$this->assertSame('jon', $user->getName());
 	$user->save(['name' => 'miles']); // ActiveRecord->save did not hit database
 	$AR->verifyInvoked('save');
-	$this->assertEquals('miles', $user->getName());
+	$this->assertSame('miles', $user->getName());
 }
 ```
 
@@ -113,7 +113,7 @@ function testUserCreate()
 
 namespace demo;
 test::func('demo', 'time', 'now');
-$this->assertEquals('now', time());
+$this->assertSame('now', time());
 ```
 
 #### Beautifully simple
@@ -126,7 +126,7 @@ Only 4 methods are necessary for method call verification and one method to defi
 function testSimpleStubAndMock()
 {
 	$user = test::double(new User, ['getName' => 'davert']);
-	$this->assertEquals('davert', $user->getName());
+	$this->assertSame('davert', $user->getName());
 	$user->verifyInvoked('getName');
 	$user->verifyInvokedOnce('getName');
 	$user->verifyNeverInvoked('setName');
diff --git a/docs/InstanceProxy.md b/docs/InstanceProxy.md
@@ -24,7 +24,7 @@ Contains verification methods and `class` property that points to `ClassProxy`.
 $user = new User(['name' => 'davert']);
 $user = test::double(new User);
 // now $user is a proxy class of user
-$this->assertEquals('davert', $user->getName()); // success
+$this->assertSame('davert', $user->getName()); // success
 $user->verifyInvoked('getName'); // success
 $this->assertInstanceOf('User', $user); // fail
 ```
diff --git a/docs/Test.md b/docs/Test.md
@@ -99,7 +99,7 @@ You can create instances of undefined classes and play with them:
 $user = test::spec('User')->construct();
 $user->setName('davert');
 $user->setNumPosts(count($user->getPosts()));
-$this->assertEquals('davert', $user->getName()); // fail
+$this->assertSame('davert', $user->getName()); // fail
 ```
 
 The test will be executed normally and will fail at the first assertion.
diff --git a/src/AspectMock/Proxy/InstanceProxy.php b/src/AspectMock/Proxy/InstanceProxy.php
@@ -29,7 +29,7 @@
  * $user = new User(['name' => 'davert']);
  * $user = test::double(new User);
  * // now $user is a proxy class of user
- * $this->assertEquals('davert', $user->getName()); // success
+ * $this->assertSame('davert', $user->getName()); // success
  * $user->verifyInvoked('getName'); // success
  * $this->assertInstanceOf('User', $user); // fail
  * ```
diff --git a/src/AspectMock/Test.php b/src/AspectMock/Test.php
@@ -128,7 +128,7 @@ public static function double($classOrObject, array $params = array())
      * $user = test::spec('User')->construct();
      * $user->setName('davert');
      * $user->setNumPosts(count($user->getPosts()));
-     * $this->assertEquals('davert', $user->getName()); // fail
+     * $this->assertSame('davert', $user->getName()); // fail
      * ```
      *
      * The test will be executed normally and will fail at the first assertion.
diff --git a/tests/unit/AccessDemoClassesTest.php b/tests/unit/AccessDemoClassesTest.php
@@ -12,7 +12,7 @@ final class AccessDemoClassesTest extends TestCase
     public function testUserModel()
     {
         $user = new UserModel(['name' => 'davert']);
-        $this->assertEquals('davert', $user->getName());
+        $this->assertSame('davert', $user->getName());
     }
 
     public function testUserService()
diff --git a/tests/unit/StubTest.php b/tests/unit/StubTest.php
@@ -27,15 +27,15 @@ public function testSaveAgain()
         double::registerClass('\demo\UserModel', ['save' => "saved!"]);
         $user = new UserModel();
         $saved = $user->save();
-        $this->assertEquals('saved!', $saved);
+        $this->assertSame('saved!', $saved);
     }
 
     public function testCallback()
     {
         double::registerClass('\demo\UserModel', ['save' => function () { return $this->name; }]);
         $user = new UserModel(['name' => 'davert']);
         $name = $user->save();
-        $this->assertEquals('davert', $name);
+        $this->assertSame('davert', $name);
 
     }
 
@@ -45,7 +45,7 @@ public function testBindSelfCallback()
             return UserModel::$topSecret;
         }]);
         $topSecret = UserModel::getTopSecret();
-        $this->assertEquals('awesome', $topSecret);
+        $this->assertSame('awesome', $topSecret);
     }
 
     public function testObjectInstance()
@@ -57,51 +57,51 @@ public function testObjectInstance()
 
     public function testStaticAccess()
     {
-        $this->assertEquals('users', UserModel::tableName());
+        $this->assertSame('users', UserModel::tableName());
         double::registerClass('\demo\UserModel', ['tableName' => 'my_users']);
-        $this->assertEquals('my_users', UserModel::tableName());
+        $this->assertSame('my_users', UserModel::tableName());
     }
 
     public function testInheritance()
     {
         double::registerClass('\demo\UserModel', ['save' => false]);
         $admin = new AdminUserModel();
         $admin->save();
-        $this->assertEquals('Admin_111', $admin->getName());
+        $this->assertSame('Admin_111', $admin->getName());
     }
 
     public function testMagic()
     {
         double::registerClass('\demo\UserService', ['rename' => 'David Copperfield']);
         $admin = new UserService();
-        $this->assertEquals('David Copperfield', $admin->rename());
+        $this->assertSame('David Copperfield', $admin->rename());
 
     }
 
     public function testMagicOfInheritedClass()
     {
         double::registerClass('\demo\AdminUserModel', ['renameUser' => 'David Copperfield']);
         $admin = new AdminUserModel();
-        $this->assertEquals('David Copperfield', $admin->renameUser());
+        $this->assertSame('David Copperfield', $admin->renameUser());
     }
 
     public function testMagicStaticInherited()
     {
         double::registerClass('\demo\AdminUserModel', ['defaultRole' => 'admin']);
-        $this->assertEquals('admin', AdminUserModel::defaultRole());
+        $this->assertSame('admin', AdminUserModel::defaultRole());
     }
 
     public function testMagicStatic()
     {
         double::registerClass('\demo\UserModel', ['defaultRole' => 'admin']);
-        $this->assertEquals('admin', UserModel::defaultRole());
+        $this->assertSame('admin', UserModel::defaultRole());
     }
 
 //    public function testStubFunctionCall()
 //    {
 //        double::registerFunc('file_put_contents', 'Done');
 //        $user = new UserModel();
 //        $user->setName('David Bovie');
-//        $this->assertEquals('Done', $user->dump());
+//        $this->assertSame('Done', $user->dump());
 //    }
 }
diff --git a/tests/unit/testDoubleTest.php b/tests/unit/testDoubleTest.php
@@ -160,12 +160,12 @@ public function testPhp7Features()
         $this->assertTrue($obj->arraySth([]));
         $str = 'hello';
         $this->assertTrue($obj->variadicStringSthByRef($str, $str));
-        $this->assertEquals('hey', $obj->stringRth($str));
-        $this->assertEquals(12.2, $obj->floatRth(12.12));
+        $this->assertSame('hey', $obj->stringRth($str));
+        $this->assertSame(12.2, $obj->floatRth(12.12));
         $this->assertTrue($obj->boolRth(false));
-        $this->assertEquals(12, $obj->intRth(15));
+        $this->assertSame(12, $obj->intRth(15));
         //$this->assertInternalType('callable', $obj->callableRth(function() {}));
-        $this->assertEquals([1], $obj->arrayRth([]));
+        $this->assertSame([1], $obj->arrayRth([]));
         $this->assertInstanceOf('Exception', $obj->exceptionRth(new Exception('ups')));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ public static function double($classOrObject, array $params = array())`
`128`	`128`	`* $user = test::spec('User')->construct();`
`129`	`129`	`* $user->setName('davert');`
`130`	`130`	`* $user->setNumPosts(count($user->getPosts()));`
`131`		`- * $this->assertEquals('davert', $user->getName()); // fail`
	`131`	`+ * $this->assertSame('davert', $user->getName()); // fail`
`132`	`132`	* ```
`133`	`133`	`*`
`134`	`134`	`* The test will be executed normally and will fail at the first assertion.`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ final class AccessDemoClassesTest extends TestCase`
`12`	`12`	`public function testUserModel()`
`13`	`13`	`{`
`14`	`14`	`$user = new UserModel(['name' => 'davert']);`
`15`		`- $this->assertEquals('davert', $user->getName());`
	`15`	`+ $this->assertSame('davert', $user->getName());`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public function testUserService()`
Original file line number	Diff line number	Diff line change
`@@ -27,15 +27,15 @@ public function testSaveAgain()`
`27`	`27`	`double::registerClass('\demo\UserModel', ['save' => "saved!"]);`
`28`	`28`	`$user = new UserModel();`
`29`	`29`	`$saved = $user->save();`
`30`		`- $this->assertEquals('saved!', $saved);`
	`30`	`+ $this->assertSame('saved!', $saved);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public function testCallback()`
`34`	`34`	`{`
`35`	`35`	`double::registerClass('\demo\UserModel', ['save' => function () { return $this->name; }]);`
`36`	`36`	`$user = new UserModel(['name' => 'davert']);`
`37`	`37`	`$name = $user->save();`
`38`		`- $this->assertEquals('davert', $name);`
	`38`	`+ $this->assertSame('davert', $name);`
`39`	`39`
`40`	`40`	`}`
`41`	`41`
`@@ -45,7 +45,7 @@ public function testBindSelfCallback()`
`45`	`45`	`return UserModel::$topSecret;`
`46`	`46`	`}]);`
`47`	`47`	`$topSecret = UserModel::getTopSecret();`
`48`		`- $this->assertEquals('awesome', $topSecret);`
	`48`	`+ $this->assertSame('awesome', $topSecret);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`public function testObjectInstance()`
`@@ -57,51 +57,51 @@ public function testObjectInstance()`
`57`	`57`
`58`	`58`	`public function testStaticAccess()`
`59`	`59`	`{`
`60`		`- $this->assertEquals('users', UserModel::tableName());`
	`60`	`+ $this->assertSame('users', UserModel::tableName());`
`61`	`61`	`double::registerClass('\demo\UserModel', ['tableName' => 'my_users']);`
`62`		`- $this->assertEquals('my_users', UserModel::tableName());`
	`62`	`+ $this->assertSame('my_users', UserModel::tableName());`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public function testInheritance()`
`66`	`66`	`{`
`67`	`67`	`double::registerClass('\demo\UserModel', ['save' => false]);`
`68`	`68`	`$admin = new AdminUserModel();`
`69`	`69`	`$admin->save();`
`70`		`- $this->assertEquals('Admin_111', $admin->getName());`
	`70`	`+ $this->assertSame('Admin_111', $admin->getName());`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`public function testMagic()`
`74`	`74`	`{`
`75`	`75`	`double::registerClass('\demo\UserService', ['rename' => 'David Copperfield']);`
`76`	`76`	`$admin = new UserService();`
`77`		`- $this->assertEquals('David Copperfield', $admin->rename());`
	`77`	`+ $this->assertSame('David Copperfield', $admin->rename());`
`78`	`78`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public function testMagicOfInheritedClass()`
`82`	`82`	`{`
`83`	`83`	`double::registerClass('\demo\AdminUserModel', ['renameUser' => 'David Copperfield']);`
`84`	`84`	`$admin = new AdminUserModel();`
`85`		`- $this->assertEquals('David Copperfield', $admin->renameUser());`
	`85`	`+ $this->assertSame('David Copperfield', $admin->renameUser());`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public function testMagicStaticInherited()`
`89`	`89`	`{`
`90`	`90`	`double::registerClass('\demo\AdminUserModel', ['defaultRole' => 'admin']);`
`91`		`- $this->assertEquals('admin', AdminUserModel::defaultRole());`
	`91`	`+ $this->assertSame('admin', AdminUserModel::defaultRole());`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`public function testMagicStatic()`
`95`	`95`	`{`
`96`	`96`	`double::registerClass('\demo\UserModel', ['defaultRole' => 'admin']);`
`97`		`- $this->assertEquals('admin', UserModel::defaultRole());`
	`97`	`+ $this->assertSame('admin', UserModel::defaultRole());`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`// public function testStubFunctionCall()`
`101`	`101`	`// {`
`102`	`102`	`// double::registerFunc('file_put_contents', 'Done');`
`103`	`103`	`// $user = new UserModel();`
`104`	`104`	`// $user->setName('David Bovie');`
`105`		`-// $this->assertEquals('Done', $user->dump());`
	`105`	`+// $this->assertSame('Done', $user->dump());`
`106`	`106`	`// }`
`107`	`107`	`}`