Merge pull request #327 from GrahamCampbell/2.1-tests

GrahamCampbell · GrahamCampbell · commit 91f0adcdac6b · 2014-09-18T19:29:06.000+01:00
[2.1] More Testing Improvements
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
@@ -11,7 +11,7 @@
          stopOnFailure="false"
          syntaxCheck="true"
          strict="true"
-         verbose="true">
+         verbose="true"
 >
     <testsuites>
         <testsuite name="Factory Muffin Test Suite">
diff --git a/tests/CustomisationTest.php b/tests/CustomisationTest.php
@@ -49,8 +49,8 @@ public function testCustomSaverFail()
         try {
             FactoryMuffin::create($model = 'SaverAndDeleterCustomisationModelStub');
         } catch (SaveFailedException $e) {
-            $this->assertEquals("We could not save the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
+            $this->assertSame("We could not save the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
             $this->assertNull($e->getErrors());
             $this->reload();
             throw $e;
@@ -77,8 +77,8 @@ public function testCustomDeleterFail()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("We could not delete the model of type: '$model'.", $exceptions[0]->getMessage());
+            $this->assertSame("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("We could not delete the model of type: '$model'.", $exceptions[0]->getMessage());
             $this->reload();
             throw $e;
         }
diff --git a/tests/DefinitionTest.php b/tests/DefinitionTest.php
@@ -42,8 +42,8 @@ public function testModelNotFound()
         try {
             FactoryMuffin::create($model = 'NotAClass');
         } catch (ModelNotFoundException $e) {
-            $this->assertEquals("No class was defined for the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
+            $this->assertSame("No class was defined for the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
             throw $e;
         }
     }
@@ -68,7 +68,7 @@ public function testGroupDefineOverwrite()
         $this->assertInternalType('string', $user->address);
         $this->assertInternalType('string', $user->name);
         $this->assertNotInternalType('boolean', $user->active);
-        $this->assertEquals('false', $user->active);
+        $this->assertSame('false', $user->active);
         $this->assertContains('@', $user->email);
     }
 
@@ -77,7 +77,7 @@ public function testGroupCallback()
         $user = FactoryMuffin::create('callbackgroup:UserModelStub');
 
         $this->assertInstanceOf('UserModelStub', $user);
-        $this->assertEquals('bar', $user->test);
+        $this->assertSame('bar', $user->test);
         $this->assertInternalType('string', $user->name);
         $this->assertInternalType('boolean', $user->active);
         $this->assertContains('@', $user->email);
@@ -91,8 +91,8 @@ public function testShouldThrowExceptionWhenLoadingANonExistentGroup()
         try {
             FactoryMuffin::create('error:UserModelStub');
         } catch (NoDefinedFactoryException $e) {
-            $this->assertEquals("No factory definition(s) were defined for the model of type: 'error:UserModelStub'.", $e->getMessage());
-            $this->assertEquals('error:UserModelStub', $e->getModel());
+            $this->assertSame("No factory definition(s) were defined for the model of type: 'error:UserModelStub'.", $e->getMessage());
+            $this->assertSame('error:UserModelStub', $e->getModel());
             throw $e;
         }
     }
@@ -105,8 +105,8 @@ public function testGroupDefineNoBaseModel()
         try {
             FactoryMuffin::create('foo:DogModelStub');
         } catch (NoDefinedFactoryException $e) {
-            $this->assertEquals("No factory definition(s) were defined for the model of type: 'DogModelStub'.", $e->getMessage());
-            $this->assertEquals('DogModelStub', $e->getModel());
+            $this->assertSame("No factory definition(s) were defined for the model of type: 'DogModelStub'.", $e->getMessage());
+            $this->assertSame('DogModelStub', $e->getModel());
             throw $e;
         }
     }
@@ -144,14 +144,14 @@ public function testInstance()
     public function testInstanceCallback()
     {
         $obj = FactoryMuffin::instance('ExampleCallbackStub');
-        $this->assertEquals('yaycalled', $obj->callback);
+        $this->assertSame('yaycalled', $obj->callback);
         $this->assertFalse($obj->saved);
     }
 
     public function testCreateCallback()
     {
         $obj = FactoryMuffin::create('AnotherCallbackStub');
-        $this->assertEquals('hello there', $obj->foo);
+        $this->assertSame('hello there', $obj->foo);
         $this->assertTrue($obj->saved);
     }
 
@@ -185,8 +185,8 @@ public function testShouldThrowExceptionWhenLoadingANonExistentDirectory()
         try {
             FactoryMuffin::loadFactories($path = __DIR__.'/thisdirectorydoesntexist');
         } catch (DirectoryNotFoundException $e) {
-            $this->assertEquals("The directory '$path' was not found.", $e->getMessage());
-            $this->assertEquals($path, $e->getPath());
+            $this->assertSame("The directory '$path' was not found.", $e->getMessage());
+            $this->assertSame($path, $e->getPath());
             throw $e;
         }
     }
diff --git a/tests/FactoryMuffinTest.php b/tests/FactoryMuffinTest.php
@@ -18,7 +18,7 @@ public function testDefaultingToFaker()
         $this->assertArrayHasKey('name', $obj->card);
         $this->assertArrayHasKey('expirationDate', $obj->card);
 
-        $this->assertEquals('http://lorempixel.com/400/600/', $obj->image);
+        $this->assertSame('http://lorempixel.com/400/600/', $obj->image);
         $this->assertNotEquals('unique::text', $obj->unique_text);
         $this->assertNotEquals('optional::text', $obj->optional_text);
     }
@@ -45,9 +45,9 @@ public function testGetIds()
     {
         $obj = FactoryMuffin::instance('IdTestModelStub');
 
-        $this->assertEquals(1, $obj->modelGetKey);
-        $this->assertEquals(1, $obj->modelPk);
-        $this->assertEquals(1, $obj->model_id);
+        $this->assertSame(1, $obj->modelGetKey);
+        $this->assertSame(1, $obj->modelPk);
+        $this->assertSame(1, $obj->model_id);
         $this->assertNull($obj->model_null);
     }
 
@@ -57,7 +57,7 @@ public function testShouldMakeSimpleCalls()
 
         $expected = gmdate('Y-m-d', strtotime('+40 days'));
 
-        $this->assertEquals($expected, $obj->future);
+        $this->assertSame($expected, $obj->future);
     }
 
     public function testShouldPassSimpleArgumentsToCalls()
@@ -105,23 +105,23 @@ public function testShouldThrowExceptionWhenNoDefinedFactoryException()
         try {
             FactoryMuffin::instance($model = 'ModelWithNoFactoryClassStub');
         } catch (NoDefinedFactoryException $e) {
-            $this->assertEquals("No factory definition(s) were defined for the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
+            $this->assertSame("No factory definition(s) were defined for the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
             throw $e;
         }
     }
 
     public function testShouldAcceptClosureAsAttributeFactory()
     {
         $obj = FactoryMuffin::instance('MainModelStub');
-        $this->assertEquals('just a string', $obj->text_closure);
+        $this->assertSame('just a string', $obj->text_closure);
     }
 
     public function testCanCreateFromStaticMethod()
     {
         $obj = FactoryMuffin::instance('ModelWithStaticMethodFactory');
 
-        $this->assertEquals('just a string', $obj->string);
+        $this->assertSame('just a string', $obj->string);
         $this->assertInstanceOf('ModelWithStaticMethodFactory', $obj->data['object']);
         $this->assertFalse($obj->data['saved']);
     }
@@ -134,9 +134,9 @@ public function testThrowExceptionWhenInvalidStaticMethod()
         try {
             FactoryMuffin::create($model = 'ModelWithMissingStaticMethod');
         } catch (MethodNotFoundException $e) {
-            $this->assertEquals("The static method 'doesNotExist' was not found on the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
-            $this->assertEquals('doesNotExist', $e->getMethod());
+            $this->assertSame("The static method 'doesNotExist' was not found on the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
+            $this->assertSame('doesNotExist', $e->getMethod());
             throw $e;
         }
     }
diff --git a/tests/SaveAndDeleteTest.php b/tests/SaveAndDeleteTest.php
@@ -41,9 +41,9 @@ public function testShouldThrowExceptionAfterSaveMethodRename()
         try {
             FactoryMuffin::create($model = 'ModelThatWillSaveStub');
         } catch (SaveMethodNotFoundException $e) {
-            $this->assertEquals("The save method 'foo' was not found on the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
-            $this->assertEquals('foo', $e->getMethod());
+            $this->assertSame("The save method 'foo' was not found on the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
+            $this->assertSame('foo', $e->getMethod());
             $this->assertInstanceOf($model, $e->getObject());
             $this->reload();
             throw $e;
@@ -64,10 +64,10 @@ public function testShouldThrowExceptionAfterDeleteMethodRename()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("The delete method 'bar' was not found on the model of type: '$model'.", $exceptions[0]->getMessage());
-            $this->assertEquals($model, $exceptions[0]->getModel());
-            $this->assertEquals('bar', $exceptions[0]->getMethod());
+            $this->assertSame("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("The delete method 'bar' was not found on the model of type: '$model'.", $exceptions[0]->getMessage());
+            $this->assertSame($model, $exceptions[0]->getModel());
+            $this->assertSame('bar', $exceptions[0]->getMethod());
             $this->assertInstanceOf($model, $exceptions[0]->getObject());
             $this->reload();
             throw $e;
@@ -84,8 +84,8 @@ public function testShouldThrowExceptionOnModelSaveFailure()
         try {
             FactoryMuffin::create($model = 'ModelThatFailsToSaveStub');
         } catch (SaveFailedException $e) {
-            $this->assertEquals("We could not save the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
+            $this->assertSame("We could not save the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
             $this->assertNull($e->getErrors());
             throw $e;
         }
@@ -101,8 +101,8 @@ public function testShouldThrowExceptionOnModelDeleteFailure()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("We could not delete the model of type: '$model'.", $exceptions[0]->getMessage());
+            $this->assertSame("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("We could not delete the model of type: '$model'.", $exceptions[0]->getMessage());
             throw $e;
         }
     }
@@ -117,8 +117,8 @@ public function testShouldAlsoThrowExceptionOnModelDeleteFailure()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("OH NOES!", $exceptions[0]->getMessage());
+            $this->assertSame("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("OH NOES!", $exceptions[0]->getMessage());
             throw $e;
         }
     }
@@ -131,9 +131,9 @@ public function testShouldThrowExceptionWithoutSaveMethod()
         try {
             FactoryMuffin::create($model = 'ModelWithNoSaveMethodStub');
         } catch (SaveMethodNotFoundException $e) {
-            $this->assertEquals("The save method 'save' was not found on the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
-            $this->assertEquals('save', $e->getMethod());
+            $this->assertSame("The save method 'save' was not found on the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
+            $this->assertSame('save', $e->getMethod());
             $this->assertInstanceOf($model, $e->getObject());
             throw $e;
         }
@@ -149,10 +149,10 @@ public function testShouldThrowExceptionWithoutDeleteMethod()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("The delete method 'delete' was not found on the model of type: '$model'.", $exceptions[0]->getMessage());
-            $this->assertEquals($model, $exceptions[0]->getModel());
-            $this->assertEquals('delete', $exceptions[0]->getMethod());
+            $this->assertSame("We encountered 1 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("The delete method 'delete' was not found on the model of type: '$model'.", $exceptions[0]->getMessage());
+            $this->assertSame($model, $exceptions[0]->getModel());
+            $this->assertSame('delete', $exceptions[0]->getMethod());
             $this->assertInstanceOf($model, $exceptions[0]->getObject());
             throw $e;
         }
@@ -166,9 +166,9 @@ public function testShouldThrowExceptionWithValidationErrors()
         try {
             FactoryMuffin::create($model = 'ModelWithValidationErrorsStub');
         } catch (SaveFailedException $e) {
-            $this->assertEquals("Failed to save. We could not save the model of type: '$model'.", $e->getMessage());
-            $this->assertEquals($model, $e->getModel());
-            $this->assertEquals('Failed to save.', $e->getErrors());
+            $this->assertSame("Failed to save. We could not save the model of type: '$model'.", $e->getMessage());
+            $this->assertSame($model, $e->getModel());
+            $this->assertSame('Failed to save.', $e->getErrors());
             throw $e;
         }
     }
@@ -184,11 +184,11 @@ public function testShouldThrowMultipleDeletionExceptions()
             FactoryMuffin::deleteSaved();
         } catch (DeletingFailedException $e) {
             $exceptions = $e->getExceptions();
-            $this->assertEquals("We encountered 2 problem(s) while trying to delete the saved models.", $e->getMessage());
-            $this->assertEquals("OH NOES!", $exceptions[0]->getMessage());
-            $this->assertEquals("The delete method 'delete' was not found on the model of type: '$model'.", $exceptions[1]->getMessage());
-            $this->assertEquals($model, $exceptions[1]->getModel());
-            $this->assertEquals('delete', $exceptions[1]->getMethod());
+            $this->assertSame("We encountered 2 problem(s) while trying to delete the saved models.", $e->getMessage());
+            $this->assertSame("OH NOES!", $exceptions[0]->getMessage());
+            $this->assertSame("The delete method 'delete' was not found on the model of type: '$model'.", $exceptions[1]->getMessage());
+            $this->assertSame($model, $exceptions[1]->getModel());
+            $this->assertSame('delete', $exceptions[1]->getMethod());
             $this->assertInstanceOf($model, $exceptions[1]->getObject());
             $this->assertInternalType('array', $e->getExceptions());
             $this->assertCount(2, $e->getExceptions());

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`	`stopOnFailure="false"`
`12`	`12`	`syntaxCheck="true"`
`13`	`13`	`strict="true"`
`14`		`- verbose="true">`
	`14`	`+ verbose="true"`
`15`	`15`	`>`
`16`	`16`	`<testsuites>`
`17`	`17`	`<testsuite name="Factory Muffin Test Suite">`
Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ public function testModelNotFound()`
`42`	`42`	`try {`
`43`	`43`	`FactoryMuffin::create($model = 'NotAClass');`
`44`	`44`	`} catch (ModelNotFoundException $e) {`
`45`		`- $this->assertEquals("No class was defined for the model of type: '$model'.", $e->getMessage());`
`46`		`- $this->assertEquals($model, $e->getModel());`
	`45`	`+ $this->assertSame("No class was defined for the model of type: '$model'.", $e->getMessage());`
	`46`	`+ $this->assertSame($model, $e->getModel());`
`47`	`47`	`throw $e;`
`48`	`48`	`}`
`49`	`49`	`}`
`@@ -68,7 +68,7 @@ public function testGroupDefineOverwrite()`
`68`	`68`	`$this->assertInternalType('string', $user->address);`
`69`	`69`	`$this->assertInternalType('string', $user->name);`
`70`	`70`	`$this->assertNotInternalType('boolean', $user->active);`
`71`		`- $this->assertEquals('false', $user->active);`
	`71`	`+ $this->assertSame('false', $user->active);`
`72`	`72`	`$this->assertContains('@', $user->email);`
`73`	`73`	`}`
`74`	`74`
`@@ -77,7 +77,7 @@ public function testGroupCallback()`
`77`	`77`	`$user = FactoryMuffin::create('callbackgroup:UserModelStub');`
`78`	`78`
`79`	`79`	`$this->assertInstanceOf('UserModelStub', $user);`
`80`		`- $this->assertEquals('bar', $user->test);`
	`80`	`+ $this->assertSame('bar', $user->test);`
`81`	`81`	`$this->assertInternalType('string', $user->name);`
`82`	`82`	`$this->assertInternalType('boolean', $user->active);`
`83`	`83`	`$this->assertContains('@', $user->email);`
`@@ -91,8 +91,8 @@ public function testShouldThrowExceptionWhenLoadingANonExistentGroup()`
`91`	`91`	`try {`
`92`	`92`	`FactoryMuffin::create('error:UserModelStub');`
`93`	`93`	`} catch (NoDefinedFactoryException $e) {`
`94`		`- $this->assertEquals("No factory definition(s) were defined for the model of type: 'error:UserModelStub'.", $e->getMessage());`
`95`		`- $this->assertEquals('error:UserModelStub', $e->getModel());`
	`94`	`+ $this->assertSame("No factory definition(s) were defined for the model of type: 'error:UserModelStub'.", $e->getMessage());`
	`95`	`+ $this->assertSame('error:UserModelStub', $e->getModel());`
`96`	`96`	`throw $e;`
`97`	`97`	`}`
`98`	`98`	`}`
`@@ -105,8 +105,8 @@ public function testGroupDefineNoBaseModel()`
`105`	`105`	`try {`
`106`	`106`	`FactoryMuffin::create('foo:DogModelStub');`
`107`	`107`	`} catch (NoDefinedFactoryException $e) {`
`108`		`- $this->assertEquals("No factory definition(s) were defined for the model of type: 'DogModelStub'.", $e->getMessage());`
`109`		`- $this->assertEquals('DogModelStub', $e->getModel());`
	`108`	`+ $this->assertSame("No factory definition(s) were defined for the model of type: 'DogModelStub'.", $e->getMessage());`
	`109`	`+ $this->assertSame('DogModelStub', $e->getModel());`
`110`	`110`	`throw $e;`
`111`	`111`	`}`
`112`	`112`	`}`
`@@ -144,14 +144,14 @@ public function testInstance()`
`144`	`144`	`public function testInstanceCallback()`
`145`	`145`	`{`
`146`	`146`	`$obj = FactoryMuffin::instance('ExampleCallbackStub');`
`147`		`- $this->assertEquals('yaycalled', $obj->callback);`
	`147`	`+ $this->assertSame('yaycalled', $obj->callback);`
`148`	`148`	`$this->assertFalse($obj->saved);`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`public function testCreateCallback()`
`152`	`152`	`{`
`153`	`153`	`$obj = FactoryMuffin::create('AnotherCallbackStub');`
`154`		`- $this->assertEquals('hello there', $obj->foo);`
	`154`	`+ $this->assertSame('hello there', $obj->foo);`
`155`	`155`	`$this->assertTrue($obj->saved);`
`156`	`156`	`}`
`157`	`157`
`@@ -185,8 +185,8 @@ public function testShouldThrowExceptionWhenLoadingANonExistentDirectory()`
`185`	`185`	`try {`
`186`	`186`	`FactoryMuffin::loadFactories($path = __DIR__.'/thisdirectorydoesntexist');`
`187`	`187`	`} catch (DirectoryNotFoundException $e) {`
`188`		`- $this->assertEquals("The directory '$path' was not found.", $e->getMessage());`
`189`		`- $this->assertEquals($path, $e->getPath());`
	`188`	`+ $this->assertSame("The directory '$path' was not found.", $e->getMessage());`
	`189`	`+ $this->assertSame($path, $e->getPath());`
`190`	`190`	`throw $e;`
`191`	`191`	`}`
`192`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public function testDefaultingToFaker()`
`18`	`18`	`$this->assertArrayHasKey('name', $obj->card);`
`19`	`19`	`$this->assertArrayHasKey('expirationDate', $obj->card);`
`20`	`20`
`21`		`- $this->assertEquals('http://lorempixel.com/400/600/', $obj->image);`
	`21`	`+ $this->assertSame('http://lorempixel.com/400/600/', $obj->image);`
`22`	`22`	`$this->assertNotEquals('unique::text', $obj->unique_text);`
`23`	`23`	`$this->assertNotEquals('optional::text', $obj->optional_text);`
`24`	`24`	`}`
`@@ -45,9 +45,9 @@ public function testGetIds()`
`45`	`45`	`{`
`46`	`46`	`$obj = FactoryMuffin::instance('IdTestModelStub');`
`47`	`47`
`48`		`- $this->assertEquals(1, $obj->modelGetKey);`
`49`		`- $this->assertEquals(1, $obj->modelPk);`
`50`		`- $this->assertEquals(1, $obj->model_id);`
	`48`	`+ $this->assertSame(1, $obj->modelGetKey);`
	`49`	`+ $this->assertSame(1, $obj->modelPk);`
	`50`	`+ $this->assertSame(1, $obj->model_id);`
`51`	`51`	`$this->assertNull($obj->model_null);`
`52`	`52`	`}`
`53`	`53`
`@@ -57,7 +57,7 @@ public function testShouldMakeSimpleCalls()`
`57`	`57`
`58`	`58`	`$expected = gmdate('Y-m-d', strtotime('+40 days'));`
`59`	`59`
`60`		`- $this->assertEquals($expected, $obj->future);`
	`60`	`+ $this->assertSame($expected, $obj->future);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`public function testShouldPassSimpleArgumentsToCalls()`
`@@ -105,23 +105,23 @@ public function testShouldThrowExceptionWhenNoDefinedFactoryException()`
`105`	`105`	`try {`
`106`	`106`	`FactoryMuffin::instance($model = 'ModelWithNoFactoryClassStub');`
`107`	`107`	`} catch (NoDefinedFactoryException $e) {`
`108`		`- $this->assertEquals("No factory definition(s) were defined for the model of type: '$model'.", $e->getMessage());`
`109`		`- $this->assertEquals($model, $e->getModel());`
	`108`	`+ $this->assertSame("No factory definition(s) were defined for the model of type: '$model'.", $e->getMessage());`
	`109`	`+ $this->assertSame($model, $e->getModel());`
`110`	`110`	`throw $e;`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`public function testShouldAcceptClosureAsAttributeFactory()`
`115`	`115`	`{`
`116`	`116`	`$obj = FactoryMuffin::instance('MainModelStub');`
`117`		`- $this->assertEquals('just a string', $obj->text_closure);`
	`117`	`+ $this->assertSame('just a string', $obj->text_closure);`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`public function testCanCreateFromStaticMethod()`
`121`	`121`	`{`
`122`	`122`	`$obj = FactoryMuffin::instance('ModelWithStaticMethodFactory');`
`123`	`123`
`124`		`- $this->assertEquals('just a string', $obj->string);`
	`124`	`+ $this->assertSame('just a string', $obj->string);`
`125`	`125`	`$this->assertInstanceOf('ModelWithStaticMethodFactory', $obj->data['object']);`
`126`	`126`	`$this->assertFalse($obj->data['saved']);`
`127`	`127`	`}`
`@@ -134,9 +134,9 @@ public function testThrowExceptionWhenInvalidStaticMethod()`
`134`	`134`	`try {`
`135`	`135`	`FactoryMuffin::create($model = 'ModelWithMissingStaticMethod');`
`136`	`136`	`} catch (MethodNotFoundException $e) {`
`137`		`- $this->assertEquals("The static method 'doesNotExist' was not found on the model of type: '$model'.", $e->getMessage());`
`138`		`- $this->assertEquals($model, $e->getModel());`
`139`		`- $this->assertEquals('doesNotExist', $e->getMethod());`
	`137`	`+ $this->assertSame("The static method 'doesNotExist' was not found on the model of type: '$model'.", $e->getMessage());`
	`138`	`+ $this->assertSame($model, $e->getModel());`
	`139`	`+ $this->assertSame('doesNotExist', $e->getMethod());`
`140`	`140`	`throw $e;`
`141`	`141`	`}`
`142`	`142`	`}`