<?php

declare(strict_types=1);

/**

* This file is part of Hyperf.

*

* @link https://www.hyperf.io

* @document https://hyperf.wiki

* @contact group@hyperf.io

* @license https://github.com/hyperf/hyperf/blob/master/LICENSE

*/

namespace HyperfTest\Database;

use Hyperf\Collection\Arr;

use Hyperf\Collection\Collection;

use Hyperf\Contract\Arrayable;

use Hyperf\Contract\Castable;

use Hyperf\Contract\CastsAttributes;

use Hyperf\Contract\CastsInboundAttributes;

use Hyperf\Database\Exception\InvalidCastException;

use Hyperf\Database\Model\Casts\ArrayObject;

use Hyperf\Database\Model\Casts\AsArrayObject;

use Hyperf\Database\Model\Casts\AsCollection;

use Hyperf\Database\Model\CastsValue;

use Hyperf\Database\Model\Model;

use HyperfTest\Database\Stubs\ContainerStub;

use JsonSerializable;

use Mockery;

use PHPUnit\Framework\Attributes\CoversNothing;

use PHPUnit\Framework\TestCase;

use ReflectionClass;

use stdClass;

/**

* @internal

* @coversNothing

*/

#[CoversNothing]

class DatabaseModelCustomCastingTest extends TestCase

{

protected function setUp(): void

{

ContainerStub::unsetContainer();

}

protected function tearDown(): void

{

Mockery::close();

UserInfoCaster::$setCount = 0;

UserInfoCaster::$getCount = 0;

}

public function testBasicCustomCasting()

{

$model = new TestModelWithCustomCast();

$model->uppercase = 'taylor';

$this->assertSame('TAYLOR', $model->uppercase);

$this->assertSame('TAYLOR', $model->getAttributes()['uppercase']);

$this->assertSame('TAYLOR', $model->toArray()['uppercase']);

$unserializedModel = unserialize(serialize($model));

$this->assertSame('TAYLOR', $unserializedModel->uppercase);

$this->assertSame('TAYLOR', $unserializedModel->getAttributes()['uppercase']);

$this->assertSame('TAYLOR', $unserializedModel->toArray()['uppercase']);

$model->syncOriginal();

$model->uppercase = 'dries';

$this->assertEquals('TAYLOR', $model->getOriginal('uppercase'));

$model = new TestModelWithCustomCast();

$model->uppercase = 'taylor';

$model->syncOriginal();

$model->uppercase = 'dries';

$model->getOriginal();

$this->assertEquals('DRIES', $model->uppercase);

$model = new TestModelWithCustomCast();

$model->address = $address = new Address('110 Kingsbrook St.', 'My Childhood House');

$address->lineOne = '117 Spencer St.';

$this->assertSame('117 Spencer St.', $model->syncAttributes()->getAttributes()['address_line_one']);

$model = new TestModelWithCustomCast();

$model->setRawAttributes([

'address_line_one' => '110 Kingsbrook St.',

'address_line_two' => 'My Childhood House',

]);

$this->assertSame('110 Kingsbrook St.', $model->address->lineOne);

$this->assertSame('My Childhood House', $model->address->lineTwo);

$this->assertSame('110 Kingsbrook St.', $model->toArray()['address_line_one']);

$this->assertSame('My Childhood House', $model->toArray()['address_line_two']);

$model->address->lineOne = '117 Spencer St.';

$this->assertFalse(isset($model->toArray()['address']));

$this->assertSame('117 Spencer St.', $model->toArray()['address_line_one']);

$this->assertSame('My Childhood House', $model->toArray()['address_line_two']);

$this->assertSame('117 Spencer St.', json_decode($model->toJson(), true)['address_line_one']);

$this->assertSame('My Childhood House', json_decode($model->toJson(), true)['address_line_two']);

$model->address = null;

$this->assertNull($model->toArray()['address_line_one']);

$this->assertNull($model->toArray()['address_line_two']);

$model->options = ['foo' => 'bar'];

$this->assertEquals(['foo' => 'bar'], $model->options);

$this->assertEquals(['foo' => 'bar'], $model->options);

$model->options = ['foo' => 'bar'];

$model->options = ['foo' => 'bar'];

$this->assertEquals(['foo' => 'bar'], $model->options);

$this->assertEquals(['foo' => 'bar'], $model->options);

$this->assertEquals(json_encode(['foo' => 'bar']), $model->getAttributes()['options']);

$model = new TestModelWithCustomCast(['options' => []]);

$model->syncOriginal();

$model->options = ['foo' => 'bar'];

$this->assertTrue($model->isDirty('options'));

}

public function testOneWayCasting()

{

// CastsInboundAttributes is used for casting that is unidirectional... only use case I can think of is one-way hashing...

$model = new TestModelWithCustomCast();

$model->password = 'secret';

$this->assertEquals(hash('sha256', 'secret'), $model->password);

$this->assertEquals(hash('sha256', 'secret'), $model->getAttributes()['password']);

$this->assertEquals(hash('sha256', 'secret'), $model->getAttributes()['password']);

$this->assertEquals(hash('sha256', 'secret'), $model->password);

$model->password = 'secret2';

$this->assertEquals(hash('sha256', 'secret2'), $model->password);

$this->assertEquals(hash('sha256', 'secret2'), $model->getAttributes()['password']);

$this->assertEquals(hash('sha256', 'secret2'), $model->getAttributes()['password']);

$this->assertEquals(hash('sha256', 'secret2'), $model->password);

}

public function testSettingRawAttributesClearsTheCastCache()

{

$model = new TestModelWithCustomCast();

$model->setRawAttributes([

'address_line_one' => '110 Kingsbrook St.',

'address_line_two' => 'My Childhood House',

]);

$this->assertSame('110 Kingsbrook St.', $model->address->lineOne);

$model->setRawAttributes([

'address_line_one' => '117 Spencer St.',

'address_line_two' => 'My Childhood House',

]);

$this->assertSame('117 Spencer St.', $model->address->lineOne);

}

public function testWithCastableInterface()

{

$model = new TestModelWithCustomCast();

$model->setRawAttributes([

'value_object_with_caster' => serialize(new ValueObject('hello')),

]);

$this->assertInstanceOf(ValueObject::class, $model->value_object_with_caster);

$model->setRawAttributes([

'value_object_caster_with_argument' => null,

]);

$this->assertEquals('argument', $model->value_object_caster_with_argument);

$model->setRawAttributes([

'value_object_caster_with_caster_instance' => serialize(new ValueObject('hello')),

]);

$this->assertInstanceOf(ValueObject::class, $model->value_object_caster_with_caster_instance);

}

public function testGetAttribute()

{

$model = new TestModelWithCustomCast();

$model->mergeCasts([

'mockery' => MockeryAttribute::class,

]);

$mockery = Mockery::mock(CastsAttributes::class);

$mockery->shouldReceive('get')->withAnyArgs()->andReturn(function ($_, $key, $value, $attributes) {

$obj = new stdClass();

$obj->value = $attributes[$key . '_origin'] - 1;

return $obj;

});

$mockery->shouldReceive('set')->withAnyArgs()->once()->andReturnUsing(function ($_, $key, $value, $attributes) {

return [

$key . '_origin' => $value->value + 1,

];

});

MockeryAttribute::$attribute = $mockery;

$std = new stdClass();

$std->value = 1;

$model->mockery = $std;

$this->assertSame(1, $model->mockery->value);

}

public function testResolveCasterClass()

{

$model = new TestModelWithCustomCast();

$ref = new ReflectionClass($model);

$method = $ref->getMethod('resolveCasterClass');

CastUsing::$castsAttributes = UppercaseCaster::class;

$this->assertNotSame($method->invokeArgs($model, ['cast_using']), $method->invokeArgs($model, ['cast_using']));

CastUsing::$castsAttributes = new UppercaseCaster();

$this->assertSame($method->invokeArgs($model, ['cast_using']), $method->invokeArgs($model, ['cast_using']));

}

public function testIsSynchronized()

{

$model = new TestModelWithCustomCast();

$model->user = $user = new UserInfo($model, ['name' => 'Hyperf', 'gender' => 1]);

$model->syncOriginal();

$attributes = $model->getAttributes();

$this->assertSame(['name' => 'Hyperf', 'gender' => 1], Arr::only($attributes, ['name', 'gender']));

$user->name = 'Nano';

$attributes = $model->getAttributes();

$this->assertSame(['name' => 'Nano', 'gender' => 1], Arr::only($attributes, ['name', 'gender']));

$this->assertSame(['name' => 'Nano'], $model->getDirty());

$this->assertSame(2, UserInfoCaster::$setCount);

$this->assertSame(0, UserInfoCaster::$getCount);

}

public function testCastsValueSupportNull()

{

$model = new TestModelWithCustomCast();

$model->user = $user = new UserInfo($model, ['name' => 'Hyperf', 'gender' => 1]);

$attributes = $model->getAttributes();

$this->assertSame(['name' => 'Hyperf', 'gender' => 1, 'role_id' => 0], $attributes);

$this->assertSame(0, $user->role_id);

$user->role_id = 1;

$this->assertSame(['name' => 'Hyperf', 'gender' => 1, 'role_id' => 1], $model->getAttributes());

unset($user->role_id);

$this->assertSame(['name' => 'Hyperf', 'gender' => 1, 'role_id' => null], $model->getAttributes());

$this->assertSame(null, $user->role_id);

unset($user->not_found);

$this->assertSame(['name' => 'Hyperf', 'gender' => 1, 'role_id' => null], $model->getAttributes());

}

public function testThrowExceptionWhenCastClassNotExist()

{

$this->expectException(InvalidCastException::class);

$this->expectExceptionMessage('Call to undefined cast [HyperfTest\Database\InvalidCaster] on column [invalid_caster] in model [HyperfTest\Database\TestModelWithCustomCast].');

$model = new TestModelWithCustomCast();

$model->invalid_caster = 'foo';

}

public function testAsArrayObjectCasting()

{

$model = new TestModelWithArrayObjectCast();

// Test setting array data

$data = ['name' => 'Hyperf', 'version' => '3.1', 'features' => ['fast', 'modern']];

$model->config = $data;

$this->assertInstanceOf(ArrayObject::class, $model->config);

$this->assertEquals($data, $model->config->toArray());

$this->assertEquals(json_encode($data), $model->getAttributes()['config']);

// Test ArrayObject methods

$this->assertEquals('Hyperf', $model->config['name']);

$this->assertEquals('3.1', $model->config['version']);

$this->assertCount(3, $model->config);

// Test collect method

$collection = $model->config->collect();

$this->assertInstanceOf(Collection::class, $collection);

$this->assertEquals($data, $collection->toArray());

// Test modification

$model->config['type'] = 'framework';

$this->assertEquals('framework', $model->config['type']);

$this->assertCount(4, $model->config);

// Test JSON serialization

$this->assertEquals($model->config->toArray(), $model->config->jsonSerialize());

// Test with null value

$model->config = null;

$this->assertNull($model->config);

// Test with empty array

$model->config = [];

$this->assertInstanceOf(ArrayObject::class, $model->config);

$this->assertCount(0, $model->config);

$this->assertEquals([], $model->config->toArray());

}

public function testAsArrayObjectCastingFromDatabase()

{

$model = new TestModelWithArrayObjectCast();

// Simulate loading from database

$jsonData = json_encode(['database' => 'mysql', 'driver' => 'swoole']);

$model->setRawAttributes(['config' => $jsonData]);

$this->assertInstanceOf(ArrayObject::class, $model->config);

$this->assertEquals('mysql', $model->config['database']);

$this->assertEquals('swoole', $model->config['driver']);

$this->assertEquals(['database' => 'mysql', 'driver' => 'swoole'], $model->config->toArray());

}

public function testAsArrayObjectCastingInvalidJson()

{

$model = new TestModelWithArrayObjectCast();

$this->expectExceptionMessage('Syntax error');

// Test with invalid JSON - should return null

$model->setRawAttributes(['config' => 'invalid json']);

$this->assertNull($model->config);

// Test with non-array JSON - should return null

$model->setRawAttributes(['config' => json_encode('string value')]);

$this->assertNull($model->config);

$model->setRawAttributes(['config' => json_encode(123)]);

$this->assertNull($model->config);

}

public function testArrayObjectCollectMethod()

{

$data = ['a' => 1, 'b' => 2, 'c' => 3];

$arrayObject = new ArrayObject($data);

$collection = $arrayObject->collect();

$this->assertInstanceOf(Collection::class, $collection);

$this->assertEquals($data, $collection->toArray());

// Test collection methods work

$filtered = $arrayObject->collect()->filter(fn ($value) => $value > 1);

$this->assertEquals(['b' => 2, 'c' => 3], $filtered->toArray());

}

public function testArrayObjectInterfaces()

{

$data = ['key' => 'value', 'number' => 42];

$arrayObject = new ArrayObject($data);

// Test Arrayable interface

$this->assertInstanceOf(Arrayable::class, $arrayObject);

$this->assertEquals($data, $arrayObject->toArray());

// Test JsonSerializable interface

$this->assertInstanceOf(JsonSerializable::class, $arrayObject);

$this->assertEquals($data, $arrayObject->jsonSerialize());

// Test array access

$this->assertEquals('value', $arrayObject['key']);

$this->assertEquals(42, $arrayObject['number']);

// Test modification

$arrayObject['new_key'] = 'new_value';

$this->assertEquals('new_value', $arrayObject['new_key']);

}

public function testArrayObjectSerialization()

{

$model = new TestModelWithArrayObjectCast();

$data = ['serialized' => true, 'data' => [1, 2, 3]];

$model->config = $data;

// Test model serialization/unserialization

$serialized = serialize($model);

$unserialized = unserialize($serialized);

$this->assertInstanceOf(ArrayObject::class, $unserialized->config);

$this->assertEquals($data, $unserialized->config->toArray());

$this->assertEquals(json_encode($data), $unserialized->getAttributes()['config']);

}

public function testCastsAsCollection()

{

$m = new TestModelWithCustomCast();

$m->fill([

'as_collection' => [['id' => 1, 'name' => 'hyperf'], ['id' => 2, 'name' => 'swoole']],

'as_collection2' => [['id' => 3, 'name' => 'hyperf'], ['id' => 4, 'name' => 'swoole']],

]);

/** @var Collection $collection */

$collection = $m->as_collection;

$this->assertSame(1, $collection->first()['id']);

$this->assertSame(2, $collection->last()['id']);

/** @var Collection $collection */

$collection = $m->as_collection2;

$this->assertSame(3, $collection->first()->id);

$this->assertSame(4, $collection->last()->id);

}

}

class TestModelWithCustomCast extends Model

{

/**

* The attributes that aren't mass assignable.

*/

protected array $guarded = [];

/**

* The attributes that should be cast to native types.

*/

protected array $casts = [

'address' => AddressCaster::class,

'user' => UserInfoCaster::class,

'password' => HashCaster::class,

'other_password' => HashCaster::class . ':md5',

'uppercase' => UppercaseCaster::class,

'options' => JsonCaster::class,

'value_object_with_caster' => ValueObject::class,

'value_object_caster_with_argument' => ValueObject::class . ':argument',

'value_object_caster_with_caster_instance' => ValueObjectWithCasterInstance::class,

'cast_using' => CastUsing::class,

'invalid_caster' => InvalidCaster::class,

'as_collection' => AsCollection::class,

'as_collection2' => AsCollection::class,

];

public function getCasts(): array

{

$casts = parent::getCasts();

$casts['as_collection2'] = AsCollection::using(Collection::class, [TestModelValue::class, 'from']);

return $casts;

}

}

class TestModelValue

{

public function __construct(public int $id, public string $name)

{

}

public static function from(array $item)

{

return new TestModelValue($item['id'], $item['name']);

}

}

class TestModelWithArrayObjectCast extends Model

{

/**

* The attributes that aren't mass assignable.

*/

protected array $guarded = [];

/**

* The attributes that should be cast to native types.

*/

protected array $casts = [

'config' => AsArrayObject::class,

'settings' => AsArrayObject::class,

'metadata' => AsArrayObject::class,

];

}

class CastUsing implements Castable

{

/**

* @var CastsAttributes

*/

public static $castsAttributes;

public static function castUsing()

{

return self::$castsAttributes;

}

}

class HashCaster implements CastsInboundAttributes

{

public function __construct($algorithm = 'sha256')

{

$this->algorithm = $algorithm;

}

public function set($model, $key, $value, $attributes)

{

return [$key => hash($this->algorithm, $value)];

}

}

class UppercaseCaster implements CastsAttributes

{

public function get($model, $key, $value, $attributes)

{

return strtoupper($value);

}

public function set($model, $key, $value, $attributes)

{

return [$key => strtoupper($value)];

}

}

class AddressCaster implements CastsAttributes

{

public function get($model, $key, $value, $attributes)

{

return new Address($attributes['address_line_one'], $attributes['address_line_two']);

}

public function set($model, $key, $value, $attributes)

{

return ['address_line_one' => $value->lineOne, 'address_line_two' => $value->lineTwo];

}

}

class UserInfoCaster implements CastsAttributes

{

public static $setCount = 0;

public static $getCount = 0;

public function get($model, string $key, $value, array $attributes)

{

++self::$getCount;

return new UserInfo($model, Arr::only($attributes, ['name', 'gender']));

}

public function set($model, string $key, $value, array $attributes)

{

++self::$setCount;

return [

'name' => $value->name,

'gender' => $value->gender,

'role_id' => $value->role_id,

];

}

}

class JsonCaster implements CastsAttributes

{

public function get($model, $key, $value, $attributes)

{

return json_decode($value, true);

}

public function set($model, $key, $value, $attributes)

{

return json_encode($value);

}

}

class ValueObjectCaster implements CastsAttributes

{

private $argument;

public function __construct($argument = null)

{

$this->argument = $argument;

}

public function get($model, $key, $value, $attributes)

{

if ($this->argument) {

return $this->argument;

}

return unserialize($value);

}

public function set($model, $key, $value, $attributes)

{

return serialize($value);

}

}

class MockeryAttribute implements CastsAttributes

{

/**

* @var CastsAttributes

*/

public static $attribute;

public function get($model, string $key, $value, array $attributes)

{

return self::$attribute->get($model, $key, $value, $attributes);

}

public function set($model, string $key, $value, array $attributes)

{

return self::$attribute->set($model, $key, $value, $attributes);

}

}

class ValueObject implements Castable

{

public static function castUsing()

{

return ValueObjectCaster::class;

}

}

class ValueObjectWithCasterInstance extends ValueObject

{

public static function castUsing()

{

return new ValueObjectCaster();

}

}

class Address

{

public $lineOne;

public $lineTwo;

public function __construct($lineOne, $lineTwo)

{

$this->lineOne = $lineOne;

$this->lineTwo = $lineTwo;

}

}

/**

* @property string $name

* @property int $gender

* @property null|int $role_id

*/

class UserInfo extends CastsValue

{

protected array $items = [

'role_id' => 0,

];

}