Ytukyg

I have read in laravel's facade documentation the following sentence:

Typically, it would not be possible to mock or stub a truly static
class method.

1) question 1: I'm trying to understand facade in laravel. As I guess, it's implemented because if we have classes, and they have big namespaces and big names and every time we want to use this class and we don't want to use new keyword and use statements, we use the facade which is an easier code and readable. I also think that laravel implemented facades because they wanted to write non-static functions in their classes so that they could be tested. After all of this, we use facades like static classes (because of readability and not using new and use), but in reality, it makes new instances.

Am I right?

2) If the above is right, can you provide me an example why it's not possible to test a static method as laravel docs said?

A facade does not solve the big namespaces problem you mentioned. Big namespaces are solved using aliases. You can declare them in your config/app.php and internally Laravel will use class_alias when you call them. This is how e.g. Cache or DB work.

A facade is basically a proxy class to a singleton object instance of another class (the facade itself ensures the instance is a singleton).

Typically to register a singleton in Laravel you:

1. Add app()->singleton(ABC::class) in your service provider


2. Access it via app()->make(ABC::class)->...

A facade basically takes care of that for you if you haven't already registered that class as a singleton.

Basically a facade is a way to proxy that singleton instance of another class.

Also it's generally not possible to mock or stub static methods however if you are using facades you can do ABCFacade::swap($mockObject) and therefore your facades can be mocked.

It is also false that you cannot test a static method. You can absolutely test a static method. For example:

 public testStaticMethod() {

      $this->assertEquals(1, ABC::method()); // We tested a static method against a desired behaviour

 }

What you usually can't do is mock a static method. Here's how you would typically mock something with PHPUnit:

public testWithDependency() { 

      $dependency = $this->getMockBuilder(Dependency::class)->getMock();

      $dependency->expects($this->once())->method('dependantMethod')->willReturn(true);

      $objectToTest = new ABC($dependency); //We're passing a fake dependency which behaves in an ideal way

      $this->assertEquals(1, $objectToTest->methodToTest()); //Any calls to the dependency will call mock methods and not real ones

 }

The problem arises when trying to mock a static method. As you can see mocking creates mock instances of a certain type. It can't mock the static members of that type because the mock object itself is not actually of that type.

However as I just found out the statement that it's not possible to mock or stub a static method is not entirely true. There's the AspectMock you can mock static methods or helper methods. This seems to work by intercepting all function calls via a custom autoloader.

This being said, just because you can doesn't mean it's good practice to use static methods, there's other issues to consider like e.g. you normally can't have static interfaces in most programming languages or you normally can't override static methods in most programming languages. Note the "in most programming languages" part here. In PHP it's entirely possible to override static methods with late static binding but that means you need to make a conscious decision about this when implementing the static method.

Another disadvantage is that a class of statics can't implement an interface because interfaces apply to object behaviours and not the static behaviour. Therefore you can't swap out one interface for another if you are using statics which is a major disadvantage.

In general the aversion to static methods is not because of testability but because if you are coding in OOP you are really limited if you are using statics.

Hopefully this will help clear up some confusion.