sam-api/tests/Unit/ModelParameterServiceTest.php

<?php

namespace Tests\Unit;

use App\Models\Model;
use App\Models\ModelParameter;
use App\Services\ModelParameterService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class ModelParameterServiceTest extends TestCase
{
    use RefreshDatabase;

    private ModelParameterService $service;
    private Model $model;

    protected function setUp(): void
    {
        parent::setUp();
        $this->service = new ModelParameterService();
        $this->service->setTenantId(1)->setApiUserId(1);

        $this->model = Model::factory()->screen()->create();
    }

    /** @test */
    public function it_can_get_all_parameters_for_model()
    {
        // Arrange
        ModelParameter::factory()
            ->count(3)
            ->create(['model_id' => $this->model->id]);

        // Act
        $result = $this->service->getParametersByModel($this->model->id);

        // Assert
        $this->assertCount(3, $result);
        $this->assertEquals($this->model->id, $result->first()->model_id);
    }

    /** @test */
    public function it_filters_inactive_parameters()
    {
        // Arrange
        ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'is_active' => true]);
        ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'is_active' => false]);

        // Act
        $result = $this->service->getParametersByModel($this->model->id);

        // Assert
        $this->assertCount(1, $result);
        $this->assertTrue($result->first()->is_active);
    }

    /** @test */
    public function it_orders_parameters_by_sort_order()
    {
        // Arrange
        $param1 = ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'sort_order' => 3, 'name' => 'third']);
        $param2 = ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'sort_order' => 1, 'name' => 'first']);
        $param3 = ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'sort_order' => 2, 'name' => 'second']);

        // Act
        $result = $this->service->getParametersByModel($this->model->id);

        // Assert
        $this->assertEquals('first', $result->get(0)->name);
        $this->assertEquals('second', $result->get(1)->name);
        $this->assertEquals('third', $result->get(2)->name);
    }

    /** @test */
    public function it_can_create_parameter()
    {
        // Arrange
        $data = [
            'name' => 'test_param',
            'label' => 'Test Parameter',
            'type' => 'NUMBER',
            'default_value' => '100',
            'validation_rules' => ['required' => true, 'numeric' => true],
            'sort_order' => 1,
            'is_required' => true,
        ];

        // Act
        $result = $this->service->createParameter($this->model->id, $data);

        // Assert
        $this->assertInstanceOf(ModelParameter::class, $result);
        $this->assertEquals('test_param', $result->name);
        $this->assertEquals($this->model->id, $result->model_id);
        $this->assertEquals(1, $result->tenant_id);
        $this->assertEquals(1, $result->created_by);
    }

    /** @test */
    public function it_can_update_parameter()
    {
        // Arrange
        $parameter = ModelParameter::factory()
            ->create(['model_id' => $this->model->id, 'name' => 'old_name']);

        $updateData = [
            'name' => 'new_name',
            'label' => 'New Label',
            'default_value' => '200',
        ];

        // Act
        $result = $this->service->updateParameter($parameter->id, $updateData);

        // Assert
        $this->assertEquals('new_name', $result->name);
        $this->assertEquals('New Label', $result->label);
        $this->assertEquals('200', $result->default_value);
        $this->assertEquals(1, $result->updated_by);
    }

    /** @test */
    public function it_can_delete_parameter()
    {
        // Arrange
        $parameter = ModelParameter::factory()
            ->create(['model_id' => $this->model->id]);

        // Act
        $result = $this->service->deleteParameter($parameter->id);

        // Assert
        $this->assertTrue($result);
        $this->assertSoftDeleted('model_parameters', ['id' => $parameter->id]);
    }

    /** @test */
    public function it_respects_tenant_isolation()
    {
        // Arrange
        $otherTenantModel = Model::factory()->create(['tenant_id' => 2]);
        $otherTenantParameter = ModelParameter::factory()
            ->create(['model_id' => $otherTenantModel->id, 'tenant_id' => 2]);

        // Act
        $result = $this->service->getParametersByModel($otherTenantModel->id);

        // Assert
        $this->assertCount(0, $result);
    }

    /** @test */
    public function it_validates_parameter_types()
    {
        // Test NUMBER type
        $numberParam = ModelParameter::factory()
            ->number()
            ->create(['model_id' => $this->model->id]);

        $this->assertEquals('NUMBER', $numberParam->type);
        $this->assertNull($numberParam->options);

        // Test SELECT type
        $selectParam = ModelParameter::factory()
            ->select()
            ->create(['model_id' => $this->model->id]);

        $this->assertEquals('SELECT', $selectParam->type);
        $this->assertNotNull($selectParam->options);

        // Test BOOLEAN type
        $booleanParam = ModelParameter::factory()
            ->boolean()
            ->create(['model_id' => $this->model->id]);

        $this->assertEquals('BOOLEAN', $booleanParam->type);
        $this->assertEquals('false', $booleanParam->default_value);
    }

    /** @test */
    public function it_can_bulk_update_parameters()
    {
        // Arrange
        $parameters = ModelParameter::factory()
            ->count(3)
            ->create(['model_id' => $this->model->id]);

        $updateData = [
            [
                'id' => $parameters[0]->id,
                'name' => 'updated_param_1',
                'sort_order' => 10,
            ],
            [
                'id' => $parameters[1]->id,
                'name' => 'updated_param_2',
                'sort_order' => 20,
            ],
            [
                'id' => $parameters[2]->id,
                'is_active' => false,
            ],
        ];

        // Act
        $result = $this->service->bulkUpdateParameters($this->model->id, $updateData);

        // Assert
        $this->assertTrue($result);

        $updated = ModelParameter::whereIn('id', $parameters->pluck('id'))->get();
        $this->assertEquals('updated_param_1', $updated->where('id', $parameters[0]->id)->first()->name);
        $this->assertEquals('updated_param_2', $updated->where('id', $parameters[1]->id)->first()->name);
        $this->assertFalse($updated->where('id', $parameters[2]->id)->first()->is_active);
    }

    /** @test */
    public function it_validates_required_fields()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->service->createParameter($this->model->id, [
            'label' => 'Missing Name Parameter',
            'type' => 'NUMBER',
        ]);
    }

    /** @test */
    public function it_handles_parameter_validation_rules()
    {
        // Arrange
        $parameter = ModelParameter::factory()
            ->create([
                'model_id' => $this->model->id,
                'type' => 'NUMBER',
                'validation_rules' => json_encode([
                    'required' => true,
                    'numeric' => true,
                    'min' => 100,
                    'max' => 1000,
                ]),
            ]);

        // Act
        $validationRules = json_decode($parameter->validation_rules, true);

        // Assert
        $this->assertArrayHasKey('required', $validationRules);
        $this->assertArrayHasKey('numeric', $validationRules);
        $this->assertArrayHasKey('min', $validationRules);
        $this->assertArrayHasKey('max', $validationRules);
        $this->assertEquals(100, $validationRules['min']);
        $this->assertEquals(1000, $validationRules['max']);
    }
}