Using the assertSame to make assert equals strict (#808)

peter279k · web-flow · commit bfe059927ba3 · 2020-09-04T14:50:55.000-05:00
diff --git a/tests/BrowserTest.php b/tests/BrowserTest.php
@@ -82,7 +82,7 @@ public function test_with_method()
 
         $browser->with('prefix', function ($browser) {
             $this->assertInstanceof(Browser::class, $browser);
-            $this->assertEquals('body prefix', $browser->resolver->prefix);
+            $this->assertSame('body prefix', $browser->resolver->prefix);
         });
     }
 
@@ -99,7 +99,7 @@ public function test_with_method_with_page()
 
         $browser->with('prefix', function ($browser) use ($page) {
             $this->assertInstanceof(Browser::class, $browser);
-            $this->assertEquals('body prefix', $browser->resolver->prefix);
+            $this->assertSame('body prefix', $browser->resolver->prefix);
             $this->assertEquals($page, $browser->page);
             $this->assertFalse($page->asserted);
         });
@@ -112,7 +112,7 @@ public function test_within_method()
 
         $browser->within('prefix', function ($browser) {
             $this->assertInstanceof(Browser::class, $browser);
-            $this->assertEquals('body prefix', $browser->resolver->prefix);
+            $this->assertSame('body prefix', $browser->resolver->prefix);
         });
     }
 
@@ -129,7 +129,7 @@ public function test_within_method_with_page()
 
         $browser->within('prefix', function ($browser) use ($page) {
             $this->assertInstanceof(Browser::class, $browser);
-            $this->assertEquals('body prefix', $browser->resolver->prefix);
+            $this->assertSame('body prefix', $browser->resolver->prefix);
             $this->assertEquals($page, $browser->page);
             $this->assertFalse($page->asserted);
         });
@@ -143,7 +143,7 @@ public function test_elsewhere_method()
         $browser->with('prefix', function ($browser) {
             $browser->elsewhere('.my-class', function ($browser) {
                 $this->assertInstanceof(Browser::class, $browser);
-                $this->assertEquals('body .my-class', $browser->resolver->prefix);
+                $this->assertSame('body .my-class', $browser->resolver->prefix);
             });
         });
     }
diff --git a/tests/ComponentTest.php b/tests/ComponentTest.php
@@ -36,13 +36,13 @@ public function test_resolver_prefix()
         $browser = new Browser($driver);
 
         $browser->within($component = new TestComponent, function ($browser) {
-            $this->assertEquals('body #component-root', $browser->resolver->prefix);
+            $this->assertSame('body #component-root', $browser->resolver->prefix);
 
             $browser->within($nested = new TestNestedComponent, function ($browser) {
-                $this->assertEquals('body #component-root #nested-root', $browser->resolver->prefix);
+                $this->assertSame('body #component-root #nested-root', $browser->resolver->prefix);
 
                 $browser->with('prefix', function ($browser) {
-                    $this->assertEquals('body #component-root #nested-root prefix', $browser->resolver->prefix);
+                    $this->assertSame('body #component-root #nested-root prefix', $browser->resolver->prefix);
                 });
             });
         });
@@ -94,7 +94,7 @@ public function test_root_selector_can_be_dusk_hook()
         $component->selector = '@dusk-hook-root';
 
         $browser->within($component, function ($browser) {
-            $this->assertEquals('body [dusk="dusk-hook-root"]', $browser->resolver->prefix);
+            $this->assertSame('body [dusk="dusk-hook-root"]', $browser->resolver->prefix);
         });
     }
 
@@ -107,7 +107,7 @@ public function test_root_selector_can_be_element_alias()
         $component->selector = '@component-alias';
 
         $browser->within($component, function ($browser) {
-            $this->assertEquals('body #component-alias', $browser->resolver->prefix);
+            $this->assertSame('body #component-alias', $browser->resolver->prefix);
         });
     }
 
diff --git a/tests/Concerns/InteractsWithElementsTest.php b/tests/Concerns/InteractsWithElementsTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Laravel\Dusk\Tests\Conserns;
+namespace Laravel\Dusk\Tests\Concerns;
 
 use Facebook\WebDriver\Remote\RemoteWebDriver;
 use Facebook\WebDriver\Remote\RemoteWebElement;
diff --git a/tests/ElementResolverTest.php b/tests/ElementResolverTest.php
@@ -19,47 +19,47 @@ public function test_resolve_for_typing_resolves_by_id()
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForTyping('#foo'));
+        $this->assertSame('foo', $resolver->resolveForTyping('#foo'));
     }
 
     public function test_resolve_for_typing_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForTyping('foo'));
+        $this->assertSame('foo', $resolver->resolveForTyping('foo'));
     }
 
     public function test_resolve_for_selection_resolves_by_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForSelection('#foo'));
+        $this->assertSame('foo', $resolver->resolveForSelection('#foo'));
     }
 
     public function test_resolve_for_selection_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForSelection('foo'));
+        $this->assertSame('foo', $resolver->resolveForSelection('foo'));
     }
 
     public function test_resolve_for_radio_selection_resolves_by_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForRadioSelection('#foo'));
+        $this->assertSame('foo', $resolver->resolveForRadioSelection('#foo'));
     }
 
     public function test_resolve_for_radio_selection_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForRadioSelection('foo', 'value'));
+        $this->assertSame('foo', $resolver->resolveForRadioSelection('foo', 'value'));
     }
 
     public function test_resolve_for_radio_selection_throws_exception_without_id_and_without_value()
@@ -77,70 +77,70 @@ public function test_resolve_for_checking_resolves_by_id()
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForChecking('#foo'));
+        $this->assertSame('foo', $resolver->resolveForChecking('#foo'));
     }
 
     public function test_resolve_for_checking_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForChecking('foo'));
+        $this->assertSame('foo', $resolver->resolveForChecking('foo'));
     }
 
     public function test_resolve_for_attachment_resolves_by_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForAttachment('#foo'));
+        $this->assertSame('foo', $resolver->resolveForAttachment('#foo'));
     }
 
     public function test_resolve_for_attachment_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForAttachment('foo'));
+        $this->assertSame('foo', $resolver->resolveForAttachment('foo'));
     }
 
     public function test_resolve_for_field_resolves_by_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForField('#foo'));
+        $this->assertSame('foo', $resolver->resolveForField('#foo'));
     }
 
     public function test_resolve_for_field_falls_back_to_selectors_without_id()
     {
         $driver = m::mock(stdClass::class);
         $driver->shouldReceive('findElement')->once()->andReturn('foo');
         $resolver = new ElementResolver($driver);
-        $this->assertEquals('foo', $resolver->resolveForField('foo'));
+        $this->assertSame('foo', $resolver->resolveForField('foo'));
     }
 
     public function test_format_correctly_formats_selectors()
     {
         $resolver = new ElementResolver(new stdClass);
-        $this->assertEquals('body #modal', $resolver->format('#modal'));
+        $this->assertSame('body #modal', $resolver->format('#modal'));
 
         $resolver = new ElementResolver(new stdClass, 'prefix');
-        $this->assertEquals('prefix #modal', $resolver->format('#modal'));
+        $this->assertSame('prefix #modal', $resolver->format('#modal'));
 
         $resolver = new ElementResolver(new stdClass, 'prefix');
         $resolver->pageElements(['@modal' => '#modal']);
-        $this->assertEquals('prefix #modal', $resolver->format('@modal'));
+        $this->assertSame('prefix #modal', $resolver->format('@modal'));
 
         $resolver = new ElementResolver(new stdClass, 'prefix');
         $resolver->pageElements([
             '@modal' => '#first',
             '@modal-second' => '#second',
         ]);
-        $this->assertEquals('prefix #first', $resolver->format('@modal'));
-        $this->assertEquals('prefix #second', $resolver->format('@modal-second'));
-        $this->assertEquals('prefix #first-third', $resolver->format('@modal-third'));
-        $this->assertEquals('prefix [dusk="missing-element"]', $resolver->format('@missing-element'));
+        $this->assertSame('prefix #first', $resolver->format('@modal'));
+        $this->assertSame('prefix #second', $resolver->format('@modal-second'));
+        $this->assertSame('prefix #first-third', $resolver->format('@modal-third'));
+        $this->assertSame('prefix [dusk="missing-element"]', $resolver->format('@missing-element'));
     }
 
     public function test_find_by_id_with_colon()
@@ -154,6 +154,6 @@ public function test_find_by_id_with_colon()
         $method->setAccessible(true);
         $result = $method->invoke($resolver, '#frmLogin:strCustomerLogin_userID');
 
-        $this->assertEquals('foo', $result);
+        $this->assertSame('foo', $result);
     }
 }
diff --git a/tests/WaitsForElementsTest.php b/tests/WaitsForElementsTest.php
@@ -25,7 +25,7 @@ public function test_default_wait_time()
             //
         }
 
-        $this->assertEquals(2, floor(microtime(true) - $then));
+        $this->assertSame(2.0, floor(microtime(true) - $then));
     }
 
     public function test_default_wait_time_can_be_overridden()
@@ -43,7 +43,7 @@ public function test_default_wait_time_can_be_overridden()
             //
         }
 
-        $this->assertEquals(0, floor(microtime(true) - $then));
+        $this->assertSame(0.0, floor(microtime(true) - $then));
     }
 
     public function test_wait_using()
@@ -120,7 +120,7 @@ public function test_wait_for_text_failure_message_containing_a_percent_characte
             $browser->waitForText('Discount: 20%', 1);
             $this->fail('waitForText() did not timeout.');
         } catch (TimeOutException $e) {
-            $this->assertEquals('Waited 1 seconds for text [Discount: 20%].', $e->getMessage());
+            $this->assertSame('Waited 1 seconds for text [Discount: 20%].', $e->getMessage());
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -19,47 +19,47 @@ public function test_resolve_for_typing_resolves_by_id()`
`19`	`19`	`$driver = m::mock(stdClass::class);`
`20`	`20`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`21`	`21`	`$resolver = new ElementResolver($driver);`
`22`		`- $this->assertEquals('foo', $resolver->resolveForTyping('#foo'));`
	`22`	`+ $this->assertSame('foo', $resolver->resolveForTyping('#foo'));`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public function test_resolve_for_typing_falls_back_to_selectors_without_id()`
`26`	`26`	`{`
`27`	`27`	`$driver = m::mock(stdClass::class);`
`28`	`28`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`29`	`29`	`$resolver = new ElementResolver($driver);`
`30`		`- $this->assertEquals('foo', $resolver->resolveForTyping('foo'));`
	`30`	`+ $this->assertSame('foo', $resolver->resolveForTyping('foo'));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public function test_resolve_for_selection_resolves_by_id()`
`34`	`34`	`{`
`35`	`35`	`$driver = m::mock(stdClass::class);`
`36`	`36`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`37`	`37`	`$resolver = new ElementResolver($driver);`
`38`		`- $this->assertEquals('foo', $resolver->resolveForSelection('#foo'));`
	`38`	`+ $this->assertSame('foo', $resolver->resolveForSelection('#foo'));`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`public function test_resolve_for_selection_falls_back_to_selectors_without_id()`
`42`	`42`	`{`
`43`	`43`	`$driver = m::mock(stdClass::class);`
`44`	`44`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`45`	`45`	`$resolver = new ElementResolver($driver);`
`46`		`- $this->assertEquals('foo', $resolver->resolveForSelection('foo'));`
	`46`	`+ $this->assertSame('foo', $resolver->resolveForSelection('foo'));`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public function test_resolve_for_radio_selection_resolves_by_id()`
`50`	`50`	`{`
`51`	`51`	`$driver = m::mock(stdClass::class);`
`52`	`52`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`53`	`53`	`$resolver = new ElementResolver($driver);`
`54`		`- $this->assertEquals('foo', $resolver->resolveForRadioSelection('#foo'));`
	`54`	`+ $this->assertSame('foo', $resolver->resolveForRadioSelection('#foo'));`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`public function test_resolve_for_radio_selection_falls_back_to_selectors_without_id()`
`58`	`58`	`{`
`59`	`59`	`$driver = m::mock(stdClass::class);`
`60`	`60`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`61`	`61`	`$resolver = new ElementResolver($driver);`
`62`		`- $this->assertEquals('foo', $resolver->resolveForRadioSelection('foo', 'value'));`
	`62`	`+ $this->assertSame('foo', $resolver->resolveForRadioSelection('foo', 'value'));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public function test_resolve_for_radio_selection_throws_exception_without_id_and_without_value()`
`@@ -77,70 +77,70 @@ public function test_resolve_for_checking_resolves_by_id()`
`77`	`77`	`$driver = m::mock(stdClass::class);`
`78`	`78`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`79`	`79`	`$resolver = new ElementResolver($driver);`
`80`		`- $this->assertEquals('foo', $resolver->resolveForChecking('#foo'));`
	`80`	`+ $this->assertSame('foo', $resolver->resolveForChecking('#foo'));`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public function test_resolve_for_checking_falls_back_to_selectors_without_id()`
`84`	`84`	`{`
`85`	`85`	`$driver = m::mock(stdClass::class);`
`86`	`86`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`87`	`87`	`$resolver = new ElementResolver($driver);`
`88`		`- $this->assertEquals('foo', $resolver->resolveForChecking('foo'));`
	`88`	`+ $this->assertSame('foo', $resolver->resolveForChecking('foo'));`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`public function test_resolve_for_attachment_resolves_by_id()`
`92`	`92`	`{`
`93`	`93`	`$driver = m::mock(stdClass::class);`
`94`	`94`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`95`	`95`	`$resolver = new ElementResolver($driver);`
`96`		`- $this->assertEquals('foo', $resolver->resolveForAttachment('#foo'));`
	`96`	`+ $this->assertSame('foo', $resolver->resolveForAttachment('#foo'));`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`public function test_resolve_for_attachment_falls_back_to_selectors_without_id()`
`100`	`100`	`{`
`101`	`101`	`$driver = m::mock(stdClass::class);`
`102`	`102`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`103`	`103`	`$resolver = new ElementResolver($driver);`
`104`		`- $this->assertEquals('foo', $resolver->resolveForAttachment('foo'));`
	`104`	`+ $this->assertSame('foo', $resolver->resolveForAttachment('foo'));`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`public function test_resolve_for_field_resolves_by_id()`
`108`	`108`	`{`
`109`	`109`	`$driver = m::mock(stdClass::class);`
`110`	`110`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`111`	`111`	`$resolver = new ElementResolver($driver);`
`112`		`- $this->assertEquals('foo', $resolver->resolveForField('#foo'));`
	`112`	`+ $this->assertSame('foo', $resolver->resolveForField('#foo'));`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`public function test_resolve_for_field_falls_back_to_selectors_without_id()`
`116`	`116`	`{`
`117`	`117`	`$driver = m::mock(stdClass::class);`
`118`	`118`	`$driver->shouldReceive('findElement')->once()->andReturn('foo');`
`119`	`119`	`$resolver = new ElementResolver($driver);`
`120`		`- $this->assertEquals('foo', $resolver->resolveForField('foo'));`
	`120`	`+ $this->assertSame('foo', $resolver->resolveForField('foo'));`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`public function test_format_correctly_formats_selectors()`
`124`	`124`	`{`
`125`	`125`	`$resolver = new ElementResolver(new stdClass);`
`126`		`- $this->assertEquals('body #modal', $resolver->format('#modal'));`
	`126`	`+ $this->assertSame('body #modal', $resolver->format('#modal'));`
`127`	`127`
`128`	`128`	`$resolver = new ElementResolver(new stdClass, 'prefix');`
`129`		`- $this->assertEquals('prefix #modal', $resolver->format('#modal'));`
	`129`	`+ $this->assertSame('prefix #modal', $resolver->format('#modal'));`
`130`	`130`
`131`	`131`	`$resolver = new ElementResolver(new stdClass, 'prefix');`
`132`	`132`	`$resolver->pageElements(['@modal' => '#modal']);`
`133`		`- $this->assertEquals('prefix #modal', $resolver->format('@modal'));`
	`133`	`+ $this->assertSame('prefix #modal', $resolver->format('@modal'));`
`134`	`134`
`135`	`135`	`$resolver = new ElementResolver(new stdClass, 'prefix');`
`136`	`136`	`$resolver->pageElements([`
`137`	`137`	`'@modal' => '#first',`
`138`	`138`	`'@modal-second' => '#second',`
`139`	`139`	`]);`
`140`		`- $this->assertEquals('prefix #first', $resolver->format('@modal'));`
`141`		`- $this->assertEquals('prefix #second', $resolver->format('@modal-second'));`
`142`		`- $this->assertEquals('prefix #first-third', $resolver->format('@modal-third'));`
`143`		`- $this->assertEquals('prefix [dusk="missing-element"]', $resolver->format('@missing-element'));`
	`140`	`+ $this->assertSame('prefix #first', $resolver->format('@modal'));`
	`141`	`+ $this->assertSame('prefix #second', $resolver->format('@modal-second'));`
	`142`	`+ $this->assertSame('prefix #first-third', $resolver->format('@modal-third'));`
	`143`	`+ $this->assertSame('prefix [dusk="missing-element"]', $resolver->format('@missing-element'));`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`public function test_find_by_id_with_colon()`
`@@ -154,6 +154,6 @@ public function test_find_by_id_with_colon()`
`154`	`154`	`$method->setAccessible(true);`
`155`	`155`	`$result = $method->invoke($resolver, '#frmLogin:strCustomerLogin_userID');`
`156`	`156`
`157`		`- $this->assertEquals('foo', $result);`
	`157`	`+ $this->assertSame('foo', $result);`
`158`	`158`	`}`
`159`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public function test_default_wait_time()`
`25`	`25`	`//`
`26`	`26`	`}`
`27`	`27`
`28`		`- $this->assertEquals(2, floor(microtime(true) - $then));`
	`28`	`+ $this->assertSame(2.0, floor(microtime(true) - $then));`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public function test_default_wait_time_can_be_overridden()`
`@@ -43,7 +43,7 @@ public function test_default_wait_time_can_be_overridden()`
`43`	`43`	`//`
`44`	`44`	`}`
`45`	`45`
`46`		`- $this->assertEquals(0, floor(microtime(true) - $then));`
	`46`	`+ $this->assertSame(0.0, floor(microtime(true) - $then));`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public function test_wait_using()`
`@@ -120,7 +120,7 @@ public function test_wait_for_text_failure_message_containing_a_percent_characte`
`120`	`120`	`$browser->waitForText('Discount: 20%', 1);`
`121`	`121`	`$this->fail('waitForText() did not timeout.');`
`122`	`122`	`} catch (TimeOutException $e) {`
`123`		`- $this->assertEquals('Waited 1 seconds for text [Discount: 20%].', $e->getMessage());`
	`123`	`+ $this->assertSame('Waited 1 seconds for text [Discount: 20%].', $e->getMessage());`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`	`}`