Object Assertions

Object assertions validate objects, classes, interfaces, and their properties/methods.

Available Assertions

isInstanceOf()

Assert that a value is an instance of a given class.

use Cline\Assert\Assertions\Assertion;

Assertion::isInstanceOf($user, User::class);
Assertion::isInstanceOf($model, Model::class, 'Expected Model instance');

notIsInstanceOf()

Assert that a value is NOT an instance of a given class.

Assertion::notIsInstanceOf($value, LegacyUser::class);

classExists()

Assert that a class exists.

Assertion::classExists(User::class);
Assertion::classExists($className, 'Class does not exist');

interfaceExists()

Assert that an interface exists.

Assertion::interfaceExists(UserInterface::class);

subclassOf()

Assert that a class is a subclass of another.

Assertion::subclassOf(AdminUser::class, User::class);

implementsInterface()

Assert that a class implements an interface.

Assertion::implementsInterface(User::class, UserInterface::class);

methodExists()

Assert that a method exists on an object.

Assertion::methodExists('save', $model);
Assertion::methodExists('handle', $handler, 'Handler must have handle method');

propertyExists()

Assert that a property exists on an object or class.

Assertion::propertyExists($user, 'email');

propertiesExist()

Assert that multiple properties exist.

$required = ['id', 'name', 'email'];
Assertion::propertiesExist($user, $required);

Chaining Object Assertions

use Cline\Assert\Assert;

Assert::that($user)
    ->isObject()
    ->isInstanceOf(User::class);

Assert::that(User::class)
    ->classExists()
    ->implementsInterface(UserInterface::class);

Common Patterns

Dependency Injection Validation

Assert::that($logger)
    ->isObject()
    ->implementsInterface(LoggerInterface::class);

Model Validation

Assert::that($model)
    ->isObject()
    ->isInstanceOf(Model::class)
    ->propertyExists('id')
    ->propertyExists('created_at');

Plugin Validation

Assert::that($plugin)
    ->isObject()
    ->implementsInterface(PluginInterface::class)
    ->methodExists('register')
    ->methodExists('boot');

Factory Pattern Validation

public function make(string $class)
{
    Assertion::classExists($class);
    Assertion::subclassOf($class, BaseService::class);

    return new $class();
}

Working with Interfaces

Assertion::implementsInterface(JsonSerializer::class, Serializer::class);

Assert::that($serializer)
    ->isObject()
    ->isInstanceOf(Serializer::class);

Best Practices

Interface Over Implementation

// Tightly coupled
Assert::that($logger)->isInstanceOf(MonologLogger::class);

// Depends on interface
Assert::that($logger)->isInstanceOf(LoggerInterface::class);

Combine with Method Checks

Assert::that($handler)
    ->isObject()
    ->isInstanceOf(HandlerInterface::class)
    ->methodExists('handle');

Next Steps

• Type Assertions - Basic type checking
• Custom Assertions - Custom object validation
• Lazy Assertions - Validate multiple properties