PHP Unittest class that loads another class

I have the following situation

class User 
{
  private $id;
  private $roleId;
  private $role;

  public function __construct(int $id, int $roleId)
  {
    $this->id = $id;
    $this->setRoleId($roleId);
  }

  public function setRoleId(int $roleId)
  {
    $this->role = Role::load($roleId);
  }
}

class Role
{
  public function __construct($x, $y ,$z)
  {
    //...
  }

  static function load(int $id) : Role
  {
    // some magic code
    return new Role($id);
  }

  public function getRoleId() : int
  {
    return $this->role->getId();
  }

  public function getRole() : Role
  {
    return $this->role;
  }
}

My Problem is, how can I unittest the User-Class?
The Role Class loads itself from a webservice... A Stub or Mock is not suitable (I guess) because, the to-be-mocked-object is Role and I'm testing the User-Class here...

Any Idea is welcome

/BR

Philippe

Your User class here doesn't do anything except it loads Role. So the question is what would you unitest in this class?

Unit test purpose is to check if one method works as it should. It means if for defined inputs it returns expected results, or throw errors if inputs are not valid.

Stub or mock Role class is completely OK if you do unit testing. Imagine that you have next method in User class(pseudo code I am not so good in PHP)

public function getUserRights() : String[]
  {
    String[] array = new String[5];
    if ($this->role.equals('ADMIN'){
       
        .... some logic here ...
    }

    return array;
  }

If now you stub your role and in different tests you return different Role from stubbed(mocked) object you can check that your method getUserRights() works properly based on different Roles.

And also it is OK to loads Role from a webservice but in that case I would call that Integration tests and in that case you want to check if your webservice works correctly and setting those kind of tests is not as easy as it is to do with unit test.

In this case you are making your User class responsible for loading the role. Typically that is not the responsibility of your User class. Instead, you could for example define a function setRole(Role $role) on your User class that accepts either a real Role, or a fake/stub/mock/whatever Role, instead of a user ID. The retrieving of the role is then done in the function/code that actually uses the user object.

But then how to test that class?

In unit testing it is usually easier not to depend on static methods like your Role::load one. Instead you could have a non-static method. Then you could write a class that extends Role, that does something that you want it to do during your tests. Then you can also write something that checks if what you told it to do was done.

That's why it is often discouraged to use many static methods: because it's hard to test (with) them.