DemoTest.php

<?php

declare(strict_types=1);

namespace Tests;

use App\SomeClass;
use App\AnotherClass;
use PHPUnit\Framework\TestCase;
use Tests\Traits\TestsObjects;

class DemoTest extends TestCase
{
    use TestsObjects;

    public function testObjectPrivateMethod(): void
    {
        $expected = sha1(random_bytes(11));
        $someClass = new SomeClass();
        $result = $this->invokeMethod($someClass, 'someMethod', random_int(11, 99));
        $this->assertSame($expected, $result);
    }

    public function testAnotherClassThatDependsOnThing(): void
    {
        $expected = sha1(random_bytes(11));
        $someMethodArg = random_int(11, 99);
        $this->mockMethod(
            $mockSomeClass = $this->createMock(SomeClass::class),
            'someMethod',
            [$someMethodArg]
        )->willReturn($expected);
        
        $anotherClass = new AnotherClass($mockSomeClass);
        $result = $anotherClass->anotherMethod($someMethodArg);
        $this->assertSame($expected, $result);
    }
}

TestsObjects.php

<?php

declare(strict_types=1);

namespace Tests\Traits;

use PHPUnit\Framework\MockObject\Builder\InvocationMocker;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionException;
use ReflectionMethod;

trait TestsObjects
{
    /**
     * @param class-string|object $class
     * @param string $methodName
     * @param ...$args
     * @return mixed
     * @throws ReflectionException
     */
    private function invokeMethod($class, string $methodName, ...$args)
    {
        $method = new ReflectionMethod($class, $methodName);
        $method->setAccessible(true);

        return $method->invokeArgs($class, $args);
    }

    private function mockMethod(MockObject $mock, string $methodName, array $args = []): InvocationMocker
    {
        $invoker = $mock
            ->expects($this->atLeastOnce())
            ->method($methodName);

        if (!empty($args)) {
            $invoker->with(...$args);
        }

        return $invoker;
    }
}