Skip to content

Beautiful Open-Source Form Builder

19.1 KB
Raw Blame
<?php

use App\Models\User;
use App\Models\Workspace;
use App\Service\Plan\PlanService;
use Illuminate\Support\Str;

uses(\Tests\TestCase::class);

beforeEach(function () {
    $this->planService = app(PlanService::class);
});

describe('Tier Comparison', function () {
    it('correctly compares tier ordering', function () {
        $planService = app(PlanService::class);

        expect($planService->tierMeetsRequirement('free', 'free'))->toBeTrue();
        expect($planService->tierMeetsRequirement('pro', 'free'))->toBeTrue();
        expect($planService->tierMeetsRequirement('business', 'free'))->toBeTrue();
        expect($planService->tierMeetsRequirement('enterprise', 'free'))->toBeTrue();

        expect($planService->tierMeetsRequirement('free', 'pro'))->toBeFalse();
        expect($planService->tierMeetsRequirement('pro', 'pro'))->toBeTrue();
        expect($planService->tierMeetsRequirement('business', 'pro'))->toBeTrue();
        expect($planService->tierMeetsRequirement('enterprise', 'pro'))->toBeTrue();

        expect($planService->tierMeetsRequirement('free', 'business'))->toBeFalse();
        expect($planService->tierMeetsRequirement('pro', 'business'))->toBeFalse();
        expect($planService->tierMeetsRequirement('business', 'business'))->toBeTrue();
        expect($planService->tierMeetsRequirement('enterprise', 'business'))->toBeTrue();

        expect($planService->tierMeetsRequirement('free', 'enterprise'))->toBeFalse();
        expect($planService->tierMeetsRequirement('pro', 'enterprise'))->toBeFalse();
        expect($planService->tierMeetsRequirement('business', 'enterprise'))->toBeFalse();
        expect($planService->tierMeetsRequirement('enterprise', 'enterprise'))->toBeTrue();
    });

    it('handles unknown tiers as free', function () {
        $planService = app(PlanService::class);

        expect($planService->tierMeetsRequirement('unknown', 'free'))->toBeTrue();
        expect($planService->tierMeetsRequirement('unknown', 'pro'))->toBeFalse();
    });
});

describe('User Tier Detection', function () {
    it('returns free for user without subscription', function () {
        $user = $this->createUser();
        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('free');
    });

    it('returns pro for user with default subscription', function () {
        $user = $this->createProUser();
        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('pro');
    });

    it('returns business for user with business subscription', function () {
        $user = $this->createBusinessUser();
        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('business');
    });

    it('returns enterprise for user with enterprise subscription', function () {
        $user = $this->createEnterpriseUser();
        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('enterprise');
    });

    it('returns enterprise when pricing is disabled', function () {
        config()->set('cashier.key', null);
        $user = $this->createUser();
        $tier = $this->planService->getUserTier($user);
        expect($tier)->toBe('enterprise');
    });
});

describe('Workspace Tier Detection', function () {
    it('returns free for workspace with free user', function () {
        $user = $this->createUser();
        $workspace = $this->createUserWorkspace($user);
        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('free');
    });

    it('returns pro for workspace with pro user', function () {
        $user = $this->createProUser();
        $workspace = $this->createUserWorkspace($user);
        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('pro');
    });

    it('returns business for workspace with business user', function () {
        $user = $this->createBusinessUser();
        $workspace = $this->createUserWorkspace($user);
        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('business');
    });

    it('returns enterprise for workspace with enterprise user', function () {
        $user = $this->createEnterpriseUser();
        $workspace = $this->createUserWorkspace($user);
        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('enterprise');
    });

    it('uses highest tier among workspace owners', function () {
        $freeUser = $this->createUser();
        $businessUser = $this->createBusinessUser();

        $workspace = Workspace::create([
            'name' => 'Shared Workspace',
            'icon' => '🏢',
        ]);

        $workspace->users()->sync([
            $freeUser->id => ['role' => 'admin'],
            $businessUser->id => ['role' => 'admin'],
        ]);

        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('business');
    });

    it('respects workspace tier override', function () {
        $user = $this->createUser(); // Free user
        $workspace = $this->createUserWorkspace($user);
        $workspace->update(['plan_overrides' => ['tier' => 'enterprise']]);

        $tier = $this->planService->computeWorkspaceTier($workspace);
        expect($tier)->toBe('enterprise');
    });
});

describe('Feature Access', function () {
    it('allows free tier to access unregistered features', function () {
        expect($this->planService->tierHasFeature('free', 'nonexistent_feature'))->toBeTrue();
    });

    it('gates pro features correctly', function () {
        expect($this->planService->tierHasFeature('free', 'branding.removal'))->toBeFalse();
        expect($this->planService->tierHasFeature('pro', 'branding.removal'))->toBeTrue();
        expect($this->planService->tierHasFeature('business', 'branding.removal'))->toBeTrue();
        expect($this->planService->tierHasFeature('enterprise', 'branding.removal'))->toBeTrue();
    });

    it('gates business features correctly', function () {
        expect($this->planService->tierHasFeature('free', 'enable_partial_submissions'))->toBeFalse();
        expect($this->planService->tierHasFeature('pro', 'enable_partial_submissions'))->toBeFalse();
        expect($this->planService->tierHasFeature('business', 'enable_partial_submissions'))->toBeTrue();
        expect($this->planService->tierHasFeature('enterprise', 'enable_partial_submissions'))->toBeTrue();
    });

    it('gates business features correctly for ip tracking', function () {
        expect($this->planService->tierHasFeature('free', 'enable_ip_tracking'))->toBeFalse();
        expect($this->planService->tierHasFeature('pro', 'enable_ip_tracking'))->toBeFalse();
        expect($this->planService->tierHasFeature('business', 'enable_ip_tracking'))->toBeTrue();
        expect($this->planService->tierHasFeature('enterprise', 'enable_ip_tracking'))->toBeTrue();
    });
});

describe('Workspace Feature Access', function () {
    it('checks workspace feature based on tier', function () {
        $proUser = $this->createProUser();
        $workspace = $this->createUserWorkspace($proUser);

        // Pro feature should be accessible
        expect($this->planService->workspaceHasFeature($workspace, 'branding.removal'))->toBeTrue();

        // Business feature should not be accessible for pro
        expect($this->planService->workspaceHasFeature($workspace, 'enable_partial_submissions'))->toBeFalse();
    });

    it('respects workspace feature overrides', function () {
        $user = $this->createUser(); // Free user
        $workspace = $this->createUserWorkspace($user);

        // Without override, free user doesn't have partial submissions
        expect($this->planService->workspaceHasFeature($workspace, 'enable_partial_submissions'))->toBeFalse();

        // With feature override
        $workspace->update([
            'plan_overrides' => ['features' => ['enable_partial_submissions']],
        ]);
        $workspace->flush();

        expect($this->planService->workspaceHasFeature($workspace, 'enable_partial_submissions'))->toBeTrue();
    });
});

describe('Tier Limits', function () {
    it('returns correct limits per tier', function () {
        expect($this->planService->getTierLimit('free', 'custom_domain_count'))->toBe(0);
        expect($this->planService->getTierLimit('pro', 'custom_domain_count'))->toBe(1);
        expect($this->planService->getTierLimit('business', 'custom_domain_count'))->toBe(10);
        expect($this->planService->getTierLimit('enterprise', 'custom_domain_count'))->toBeNull();
    });

    it('returns correct workspace limits', function () {
        $proUser = $this->createProUser();
        $workspace = $this->createUserWorkspace($proUser);

        $limit = $this->planService->getWorkspaceLimit($workspace, 'custom_domain_count');
        expect($limit)->toBe(1);
    });

    it('respects workspace limit overrides', function () {
        $user = $this->createUser(); // Free user
        $workspace = $this->createUserWorkspace($user);

        // Without override
        $limit = $this->planService->getWorkspaceLimit($workspace, 'custom_domain_count');
        expect($limit)->toBe(0);

        // With override
        $workspace->update([
            'plan_overrides' => ['limits' => ['custom_domain_count' => 5]],
        ]);
        $workspace->flush();

        $limit = $this->planService->getWorkspaceLimit($workspace, 'custom_domain_count');
        expect($limit)->toBe(5);
    });
});

describe('Subscription Mapping', function () {
    it('maps default subscription to pro tier', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'default',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);

        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('pro');
    });

    it('maps business subscription name to business tier', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'business',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);

        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('business');
    });

    it('maps enterprise subscription name to enterprise tier', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'enterprise',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);

        $tier = $this->planService->computeUserTier($user);
        expect($tier)->toBe('enterprise');
    });
});

describe('Display Names', function () {
    it('returns correct display names', function () {
        expect($this->planService->getTierDisplayName('free'))->toBe('Free');
        expect($this->planService->getTierDisplayName('pro'))->toBe('Pro');
        expect($this->planService->getTierDisplayName('business'))->toBe('Business');
        expect($this->planService->getTierDisplayName('enterprise'))->toBe('Enterprise');
    });

    it('capitalizes unknown tiers', function () {
        expect($this->planService->getTierDisplayName('unknown'))->toBe('Unknown');
    });
});

describe('Multi-workspace Authorization', function () {
    it('prevents cross-workspace feature leakage', function () {
        $proUser = $this->createProUser();
        $freeUser = $this->createUser();

        $proWorkspace = $this->createUserWorkspace($proUser);
        $freeWorkspace = $this->createUserWorkspace($freeUser);

        // Pro user's workspace has feature access
        expect($this->planService->workspaceHasFeature($proWorkspace, 'branding.removal'))->toBeTrue();

        // Free user's workspace does NOT, even though a pro user exists elsewhere
        expect($this->planService->workspaceHasFeature($freeWorkspace, 'branding.removal'))->toBeFalse();
    });

    it('grants access when pro user is added to free workspace', function () {
        $proUser = $this->createProUser();
        $freeUser = $this->createUser();

        $workspace = $this->createUserWorkspace($freeUser);

        expect($this->planService->computeWorkspaceTier($workspace))->toBe('free');

        // Add pro user as admin
        $workspace->users()->attach($proUser->id, ['role' => 'admin']);
        $workspace->flush();

        expect($this->planService->computeWorkspaceTier($workspace))->toBe('pro');
    });

    it('downgrades workspace tier when pro owner is removed', function () {
        $proUser = $this->createProUser();
        $freeUser = $this->createUser();

        $workspace = Workspace::create(['name' => 'Shared', 'icon' => '🔗']);
        $workspace->users()->sync([
            $proUser->id => ['role' => 'admin'],
            $freeUser->id => ['role' => 'admin'],
        ]);

        expect($this->planService->computeWorkspaceTier($workspace))->toBe('pro');

        // Remove pro user
        $workspace->users()->detach($proUser->id);
        $workspace->flush();

        expect($this->planService->computeWorkspaceTier($workspace))->toBe('free');
    });
});

describe('Subscription Name Billing', function () {
    it('handles pro subscription type correctly', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'pro',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);

        expect($this->planService->computeUserTier($user))->toBe('pro');
    });

    it('selects highest tier when user has multiple subscriptions', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'pro',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);
        $user->subscriptions()->create([
            'type' => 'business',
            'stripe_id' => Str::random(),
            'stripe_status' => 'active',
            'stripe_price' => Str::random(),
            'quantity' => 1,
        ]);

        expect($this->planService->computeUserTier($user))->toBe('business');
    });

    it('ignores inactive subscriptions', function () {
        $user = $this->createUser();
        $user->subscriptions()->create([
            'type' => 'business',
            'stripe_id' => Str::random(),
            'stripe_status' => 'canceled',
            'stripe_price' => Str::random(),
            'quantity' => 1,
            'ends_at' => now()->subDay(), // Ended subscription — Cashier's valid() checks ends_at
        ]);

        expect($this->planService->computeUserTier($user))->toBe('free');
    });
});

describe('Override-only Workspace', function () {
    it('grants tier via plan_overrides without any subscription', function () {
        $user = $this->createUser();
        $workspace = $this->createUserWorkspace($user);

        // No subscription — free by default
        expect($this->planService->computeWorkspaceTier($workspace))->toBe('free');

        // Admin sets an override
        $workspace->update(['plan_overrides' => ['tier' => 'business']]);
        $workspace->flush();

        expect($this->planService->computeWorkspaceTier($workspace))->toBe('business');
    });

    it('grants specific features via plan_overrides without matching tier', function () {
        $user = $this->createUser();
        $workspace = $this->createUserWorkspace($user);

        $workspace->update(['plan_overrides' => ['features' => ['sso.oidc']]]);
        $workspace->flush();

        // Free tier, but OIDC specifically overridden
        expect($this->planService->getWorkspaceTier($workspace))->toBe('free');
        expect($this->planService->workspaceHasFeature($workspace, 'sso.oidc'))->toBeTrue();
        // Other enterprise features NOT granted
        expect($this->planService->workspaceHasFeature($workspace, 'audit_logs'))->toBeFalse();
    });

    it('grants specific limits via plan_overrides', function () {
        $user = $this->createUser();
        $workspace = $this->createUserWorkspace($user);

        $workspace->update(['plan_overrides' => ['limits' => ['custom_domain_count' => 50]]]);
        $workspace->flush();

        $limit = $this->planService->getWorkspaceLimit($workspace, 'custom_domain_count');
        expect($limit)->toBe(50);
    });

    it('billingOwners returns all admins for override-only workspace', function () {
        $user = $this->createUser();
        $workspace = $this->createUserWorkspace($user);
        $workspace->update(['plan_overrides' => ['tier' => 'pro']]);

        $billingOwners = $workspace->billingOwners();
        expect($billingOwners->count())->toBe(1);
        expect($billingOwners->first()->id)->toBe($user->id);
    });
});

describe('Cache Invalidation', function () {
    it('flushWithOwners clears workspace and owner caches', function () {
        $user = $this->createProUser();
        $workspace = $this->createUserWorkspace($user);

        // Warm the cache
        $this->planService->getWorkspaceTier($workspace);
        expect($workspace->plan_tier)->toBe('pro');

        // Flush
        $workspace->flushWithOwners();

        // After flush, cache should be rebuilt on next access
        // (This tests that flush doesn't error and the value is still correct)
        expect($this->planService->computeWorkspaceTier($workspace))->toBe('pro');
    });

    it('user flushCache cascades to workspaces and forms', function () {
        $user = $this->createProUser();
        $workspace = $this->createUserWorkspace($user);
        $form = $this->createForm($user, $workspace);

        // Warm caches
        $workspace->is_pro;
        $user->is_pro;

        // Flush user cache (cascades to workspaces/forms)
        $user->flushCache();

        // Verify no errors and values rebuild correctly
        expect($user->plan_tier)->toBe('pro');
        expect($workspace->plan_tier)->toBe('pro');
    });
});

describe('Form Feature Checks', function () {
    it('checks form_features via tierHasFeature', function () {
        // Form features should be checked by tierHasFeature too
        expect($this->planService->tierHasFeature('free', 'no_branding'))->toBeFalse();
        expect($this->planService->tierHasFeature('pro', 'no_branding'))->toBeTrue();
        expect($this->planService->tierHasFeature('free', 'seo_meta'))->toBeFalse();
        expect($this->planService->tierHasFeature('pro', 'seo_meta'))->toBeTrue();
        expect($this->planService->tierHasFeature('business', 'seo_meta'))->toBeTrue();
    });

    it('getRequiredTier looks up both features and form_features', function () {
        expect($this->planService->getRequiredTier('custom_smtp'))->toBe('pro');
        expect($this->planService->getRequiredTier('seo_meta'))->toBe('pro');
        expect($this->planService->getRequiredTier('no_branding'))->toBe('pro');
        expect($this->planService->getRequiredTier('nonexistent'))->toBeNull();
    });
});