Skip to content

Beautiful Open-Source Form Builder

27.1 KB
Raw Blame
<?php

use App\Jobs\Form\GenerateAiFormula;
use App\Models\Forms\AI\AiFormCompletion;
use App\Service\AI\Prompts\Form\GenerateFormulaPrompt;
use App\Service\OpenAi\GptCompleter;
use Illuminate\Routing\Middleware\ThrottleRequests;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Queue;

$testFields = [
    ['id' => 'uuid-price', 'name' => 'Price', 'type' => 'number'],
    ['id' => 'uuid-quantity', 'name' => 'Quantity', 'type' => 'number'],
    ['id' => 'uuid-name', 'name' => 'Full Name', 'type' => 'text'],
];

$testVariables = [
    ['id' => 'uuid-subtotal', 'name' => 'Subtotal'],
];

beforeEach(function () {
    config()->set('services.openai.api_key', 'test-fake-key');
});

describe('AI Formula Generation', function () use ($testFields, $testVariables) {

    describe('API endpoint POST /forms/ai/generate-formula', function () {
        beforeEach(function () {
            Queue::fake();
        });

        it('requires authentication', function () {
            $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'Multiply price by quantity',
            ])->assertUnauthorized();
        });

        it('creates an ai_form_completion with formula type', function () {
            $user = $this->actingAsUser();

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'Multiply price by quantity',
                'context' => [
                    'fields' => [
                        ['id' => 'uuid-1', 'name' => 'Price', 'type' => 'number'],
                        ['id' => 'uuid-2', 'name' => 'Quantity', 'type' => 'number'],
                    ],
                    'computed_variables' => [],
                ],
            ]);

            $response->assertSuccessful()
                ->assertJsonStructure(['type', 'message', 'ai_form_completion_id']);

            $completionId = $response->json('ai_form_completion_id');
            $this->assertDatabaseHas('ai_form_completions', [
                'id' => $completionId,
                'type' => 'formula',
                'form_prompt' => 'Multiply price by quantity',
                'user_id' => $user->id,
            ]);
        });

        it('validates formula_prompt is required', function () {
            $this->actingAsUser();

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'context' => ['fields' => []],
            ]);

            $response->assertStatus(422)
                ->assertJsonValidationErrors(['formula_prompt']);
        });

        it('validates formula_prompt max length', function () {
            $this->actingAsUser();

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => str_repeat('a', 10001),
                'context' => ['fields' => []],
            ]);

            $response->assertStatus(422)
                ->assertJsonValidationErrors(['formula_prompt']);
        });

        it('stores context with field and variable data', function () {
            $this->actingAsUser();

            $context = [
                'fields' => [
                    ['id' => 'f1', 'name' => 'Name', 'type' => 'text'],
                    ['id' => 'f2', 'name' => 'Email', 'type' => 'email'],
                ],
                'computed_variables' => [
                    ['id' => 'v1', 'name' => 'Full Info'],
                ],
            ];

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'Concatenate name and email',
                'context' => $context,
            ]);

            $response->assertSuccessful();

            $completion = AiFormCompletion::find($response->json('ai_form_completion_id'));
            expect($completion->context)->toBe($context);
            expect($completion->type)->toBe('formula');
        });

        it('stores the existing formula context when updating a formula', function () {
            $this->actingAsUser();

            $context = [
                'fields' => [],
                'computed_variables' => [],
                'current_formula' => '{Price} * {Quantity}',
                'current_variable' => ['name' => 'Total Price'],
            ];

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'Apply a 10% discount',
                'context' => $context,
            ]);

            $response->assertSuccessful();

            $completion = AiFormCompletion::find($response->json('ai_form_completion_id'));
            expect($completion->context)->toBe($context);
        });

        it('accepts request without context', function () {
            $this->actingAsUser();

            $response = $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'Add 1 + 1',
            ]);

            $response->assertSuccessful();
        });

        it('throttles formula generation to ten requests per minute', function () {
            $this->withMiddleware(ThrottleRequests::class);
            $this->actingAsUser();
            Cache::flush();

            for ($attempt = 0; $attempt < 10; $attempt++) {
                $this->postJson(route('forms.ai.generate-formula'), [
                    'formula_prompt' => "Add {$attempt} + 1",
                ])->assertSuccessful();
            }

            $this->postJson(route('forms.ai.generate-formula'), [
                'formula_prompt' => 'This request should be throttled',
            ])->assertStatus(429);
        });

        it('uses the dedicated formula generation rate limiter', function () {
            $route = app('router')->getRoutes()->getByName('forms.ai.generate-formula');

            expect($route->middleware())
                ->toContain('throttle:ai-formula-generation');
        });
    });

    describe('Job dispatch', function () {
        it('dispatches GenerateAiFormula when formula completion is created', function () {
            Queue::fake();

            AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Sum two numbers',
                'context' => ['fields' => [], 'computed_variables' => []],
                'ip' => '127.0.0.1',
            ]);

            Queue::assertPushed(GenerateAiFormula::class);
        });

        it('does not dispatch GenerateAiFormula for form type', function () {
            Queue::fake();

            AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORM,
                'form_prompt' => 'Create a contact form',
                'ip' => '127.0.0.1',
            ]);

            Queue::assertNotPushed(GenerateAiFormula::class);
        });

        it('does not dispatch GenerateAiFormula for fields type', function () {
            Queue::fake();

            AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FIELDS,
                'form_prompt' => 'Add an email field',
                'ip' => '127.0.0.1',
            ]);

            Queue::assertNotPushed(GenerateAiFormula::class);
        });
    });

    describe('GenerateFormulaPrompt - mention conversion', function () use ($testFields, $testVariables) {
        it('converts field name mentions to IDs', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, '{Price} * {Quantity}');
            expect($result)->toBe('{uuid-price} * {uuid-quantity}');
        });

        it('converts case-insensitively', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, '{price} * {QUANTITY}');
            expect($result)->toBe('{uuid-price} * {uuid-quantity}');
        });

        it('converts variable mentions to IDs', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, '{Subtotal} * 1.1');
            expect($result)->toBe('{uuid-subtotal} * 1.1');
        });

        it('leaves unknown mentions unchanged', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, '{Unknown} + {Price}');
            expect($result)->toBe('{Unknown} + {uuid-price}');
        });

        it('handles formula with no mentions', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, '1 + 2 * 3');
            expect($result)->toBe('1 + 2 * 3');
        });

        it('handles field names with spaces', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'convertMentionsToIds');
            $method->setAccessible(true);

            $result = $method->invoke($prompt, 'UPPER({Full Name})');
            expect($result)->toBe('UPPER({uuid-name})');
        });
    });

    describe('GenerateFormulaPrompt - prompt formatting', function () use ($testFields, $testVariables) {
        it('formats fields as mentions with types', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'formatFields');
            $method->setAccessible(true);

            $result = $method->invoke($prompt);
            expect($result)->toContain('{Price} (type: number)');
            expect($result)->toContain('{Quantity} (type: number)');
            expect($result)->toContain('{Full Name} (type: text)');
            expect($result)->toContain('Use these exact mentions');
        });

        it('formats computed variables as mentions', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'formatComputedVariables');
            $method->setAccessible(true);

            $result = $method->invoke($prompt);
            expect($result)->toContain('{Subtotal}');
            expect($result)->toContain('Use these exact mentions');
        });

        it('returns fallback text for empty fields', function () use ($testVariables) {
            $prompt = new GenerateFormulaPrompt('test', [], $testVariables);

            $method = new ReflectionMethod($prompt, 'formatFields');
            $method->setAccessible(true);

            expect($method->invoke($prompt))->toBe('No form fields available');
        });

        it('returns fallback text for empty variables', function () use ($testFields) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, []);

            $method = new ReflectionMethod($prompt, 'formatComputedVariables');
            $method->setAccessible(true);

            expect($method->invoke($prompt))->toBe('No other computed variables available');
        });

        it('includes the current formula when updating a computed variable', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt(
                'Apply a discount',
                $testFields,
                $testVariables,
                '{Price} * {Quantity}',
                'Total Price',
            );

            $method = new ReflectionMethod($prompt, 'formatCurrentFormula');
            $method->setAccessible(true);

            expect($method->invoke($prompt))
                ->toContain('Current formula for the variable "Total Price"')
                ->toContain('{Price} * {Quantity}');
        });

        it('lists available functions', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $method = new ReflectionMethod($prompt, 'formatFunctions');
            $method->setAccessible(true);

            $result = $method->invoke($prompt);
            expect($result)->toContain('IF(condition, trueValue, falseValue)');
            expect($result)->toContain('SUM(value1, value2, ...)');
            expect($result)->toContain('CONCAT(text1, text2, ...)');
        });
    });

    describe('GenerateFormulaPrompt - execute with mocked AI', function () use ($testFields, $testVariables) {
        it('returns valid formula converted to field IDs', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('multiply price by quantity', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => '{Price} * {Quantity}',
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('{uuid-price} * {uuid-quantity}');
        });

        it('returns an AI-generated variable name when the variable is unnamed', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('multiply price by quantity', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => '{Price} * {Quantity}',
                'variable_name' => 'Total Price',
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result)
                ->toMatchArray([
                    'formula' => '{uuid-price} * {uuid-quantity}',
                    'variable_name' => 'Total Price',
                ]);
        });

        it('does not return a generated variable name when the variable is already named', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('multiply price by quantity', $testFields, $testVariables, null, 'Order Total');

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => '{Price} * {Quantity}',
                'variable_name' => null,
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['variable_name'])->toBeNull();
        });

        it('retries on syntax error then returns valid formula', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('discount formula', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')
                ->andReturn(
                    ['formula' => 'IF({Price} > 100, {Price} * 0.9, {Price}'],
                    ['formula' => 'IF({Price} > 100, {Price} * 0.9, {Price})'],
                );

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('IF({uuid-price} > 100, {uuid-price} * 0.9, {uuid-price})');
        });

        it('retries on unknown field reference then returns valid formula', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')
                ->andReturn(
                    ['formula' => '{Nonexistent} + 1'],
                    ['formula' => '{Price} + 1'],
                );

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('{uuid-price} + 1');
        });

        it('retries on an invalid function argument count then returns a valid formula', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')
                ->andReturn(
                    ['formula' => 'MOD({Price})'],
                    ['formula' => 'MOD({Price}, 2)'],
                );

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('MOD({uuid-price}, 2)');
        });

        it('throws RuntimeException after max retries with invalid formulas', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')
                ->andReturn(['formula' => 'IF({Price} > 100, {Price}']);

            $prompt->setGptCompleter($mockCompleter);

            expect(fn () => $prompt->execute())
                ->toThrow(\RuntimeException::class, 'Failed to generate a valid formula after 3 attempts');
        });

        it('strips markdown code fences from AI response', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => "```\n{Price} * {Quantity}\n```",
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('{uuid-price} * {uuid-quantity}');
        });

        it('throws on empty formula after all retries', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('test', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')
                ->andReturn(['formula' => '']);

            $prompt->setGptCompleter($mockCompleter);

            expect(fn () => $prompt->execute())
                ->toThrow(\RuntimeException::class, 'AI returned an empty formula');
        });

        it('accepts formulas using only available computed variables', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('add tax', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => '{Subtotal} * 1.1',
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('{uuid-subtotal} * 1.1');
        });

        it('handles complex nested formulas correctly', function () use ($testFields, $testVariables) {
            $prompt = new GenerateFormulaPrompt('complex calc', $testFields, $testVariables);

            $mockCompleter = Mockery::mock(GptCompleter::class);
            $mockCompleter->shouldReceive('setJsonSchema')->andReturnSelf();
            $mockCompleter->shouldReceive('setSystemMessage')->andReturnSelf();
            $mockCompleter->shouldReceive('completeChat')->andReturnSelf();
            $mockCompleter->shouldReceive('getArray')->andReturn([
                'formula' => 'IF({Quantity} > 100, {Price} * {Quantity} * 0.9, {Price} * {Quantity})',
            ]);

            $prompt->setGptCompleter($mockCompleter);
            $result = $prompt->execute();

            expect($result['formula'])->toBe('IF({uuid-quantity} > 100, {uuid-price} * {uuid-quantity} * 0.9, {uuid-price} * {uuid-quantity})');
        });
    });

    describe('Polling GET /forms/ai/formula/{completion}', function () {
        beforeEach(function () {
            Queue::fake();
        });

        it('requires authentication', function () {
            $owner = $this->createUser();
            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Sum fields',
                'user_id' => $owner->id,
                'ip' => request()->ip(),
            ]);

            $this->getJson(route('forms.ai.formula.show', $completion->id))
                ->assertUnauthorized();
        });

        it('returns completed formula result', function () {
            $user = $this->actingAsUser();

            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Sum fields',
                'context' => ['fields' => [['id' => 'f1', 'name' => 'A', 'type' => 'number']]],
                'user_id' => $user->id,
                'ip' => request()->ip(),
            ]);
            $completion->update([
                'status' => AiFormCompletion::STATUS_COMPLETED,
                'result' => json_encode(['formula' => '{f1} + 1']),
            ]);

            $response = $this->getJson(route('forms.ai.formula.show', $completion->id));

            $response->assertSuccessful()
                ->assertJsonPath('ai_form_completion.status', 'completed')
                ->assertJsonPath('ai_form_completion.result', json_encode(['formula' => '{f1} + 1']));
        });

        it('returns processing status while in progress', function () {
            $user = $this->actingAsUser();

            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Something',
                'context' => ['fields' => []],
                'user_id' => $user->id,
                'ip' => request()->ip(),
            ]);
            $completion->update(['status' => AiFormCompletion::STATUS_PROCESSING]);

            $response = $this->getJson(route('forms.ai.formula.show', $completion->id));

            $response->assertSuccessful()
                ->assertJsonPath('ai_form_completion.status', 'processing');
        });

        it('returns failed status with error', function () {
            $user = $this->actingAsUser();

            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Invalid thing',
                'context' => ['fields' => []],
                'user_id' => $user->id,
                'ip' => request()->ip(),
            ]);
            $completion->update([
                'status' => AiFormCompletion::STATUS_FAILED,
                'error' => 'Failed to generate a valid formula after 3 attempts.',
            ]);

            $response = $this->getJson(route('forms.ai.formula.show', $completion->id));

            $response->assertSuccessful()
                ->assertJsonPath('ai_form_completion.status', 'failed');
        });

        it('rejects a different user on the same IP', function () {
            $this->withServerVariables(['REMOTE_ADDR' => '192.0.2.10']);
            $owner = $this->createUser();
            $otherUser = $this->createUser();
            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'test',
                'context' => ['fields' => []],
                'user_id' => $owner->id,
                'ip' => '192.0.2.10',
            ]);
            $completion->update([
                'status' => AiFormCompletion::STATUS_COMPLETED,
                'result' => json_encode(['formula' => '1 + 1']),
            ]);

            $this->actingAsUser($otherUser);

            $this->getJson(route('forms.ai.formula.show', $completion->id))
                ->assertNotFound();
        });

        it('does not expose formula results through legacy public polling', function () {
            $owner = $this->createUser();
            $completion = AiFormCompletion::create([
                'type' => AiFormCompletion::TYPE_FORMULA,
                'form_prompt' => 'Sum fields',
                'context' => ['fields' => []],
                'user_id' => $owner->id,
                'ip' => request()->ip(),
            ]);

            $this->getJson(route('forms.ai.show', $completion->id))
                ->assertNotFound();
        });
    });
});