Beautiful Open-Source Form Builder
<?php
use App\Enterprise\Oidc\Models\IdentityConnection;
use App\Enterprise\Oidc\Models\UserIdentity;
use App\Enterprise\Oidc\ProvisioningService;
use App\Models\User;
use App\Models\Workspace;
use App\Service\License\LicenseCheckResult;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Support\Facades\Cache;
use Tests\TestHelpers;
require_once __DIR__ . '/../../../TestHelpers/OidcTestHelpers.php';
uses(TestHelpers::class);
uses()->group('oidc', 'feature');
afterEach(function () {
Mockery::close();
});
describe('ProvisioningService - New User Creation', function () {
it('creates new user and UserIdentity when no existing user found', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'New User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-123');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user)->toBeInstanceOf(User::class);
expect($user->email)->toBe('[email protected]');
expect($user->name)->toBe('New User');
expect($user->email_verified_at)->not->toBeNull();
// Check UserIdentity was created
$userIdentity = UserIdentity::where('user_id', $user->id)
->where('connection_id', $connection->id)
->first();
expect($userIdentity)->not->toBeNull();
expect($userIdentity->subject)->toBe('sub-123');
expect($userIdentity->email)->toBe('[email protected]');
});
it('creates user with random password for SSO-only accounts', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'SSO User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-456');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->password)->not->toBeNull();
expect(strlen($user->password))->toBeGreaterThan(50); // Hashed password length
});
it('uses email prefix as name when name is not provided', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: null
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-789');
// Remove all name-related fields to test fallback to email prefix
// Note: We need to ensure given_name and family_name are not set, otherwise
// trim(' ') becomes empty string which is truthy
unset($idTokenClaims['name']);
unset($idTokenClaims['display_name']);
unset($idTokenClaims['given_name']);
unset($idTokenClaims['family_name']);
unset($idTokenClaims['preferred_username']);
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
// The service should fall back to email prefix when name is null/empty
// Current implementation: $name ?? $socialiteUser->getName() ?? explode('@', $email)[0]
// Since $name will be null (all fields unset), it should use email prefix
expect($user->name)->toBe('noname');
});
});
describe('ProvisioningService - Self-hosted seat limits', function () {
beforeEach(function () {
config(['app.self_hosted' => true]);
config(['cashier.key' => null]);
Cache::forget('self_hosted_license_check');
});
it('blocks OIDC provisioning beyond the free 2 user instance limit', function () {
User::factory()->create(['email' => '[email protected]']);
User::factory()->create(['email' => '[email protected]']);
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Third User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-third');
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(HttpResponseException::class);
expect(User::where('email', '[email protected]')->exists())->toBeFalse();
expect(UserIdentity::where('subject', 'sub-third')->exists())->toBeFalse();
});
it('allows existing OIDC users to sign in when the free user limit is full', function () {
User::factory()->create(['email' => '[email protected]']);
$existingUser = User::factory()->create(['email' => '[email protected]']);
$connection = IdentityConnection::factory()->create();
UserIdentity::factory()->create([
'user_id' => $existingUser->id,
'connection_id' => $connection->id,
'subject' => 'sub-existing',
'email' => '[email protected]',
]);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Existing User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-existing');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->id)->toBe($existingUser->id);
});
it('allows OIDC provisioning beyond 2 users with an active self-hosted license', function () {
User::factory()->create(['email' => '[email protected]']);
User::factory()->create(['email' => '[email protected]']);
$this->storeSelfHostedLicense([
'license_key' => 'lic_oidc_seats_active',
'status' => 'active',
'features' => ['sso' => true],
'last_checked_at' => now()->format('c'),
'expires_at' => now()->addYear()->format('c'),
]);
Cache::put('self_hosted_license_check', new LicenseCheckResult(
status: 'active',
features: ['sso' => true],
lastChecked: now(),
expiresAt: now()->addYear(),
), 86400);
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Third User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-third');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->email)->toBe('[email protected]');
expect(UserIdentity::where('subject', 'sub-third')->exists())->toBeTrue();
});
});
describe('ProvisioningService - Existing User Login', function () {
it('returns existing user when UserIdentity exists', function () {
$connection = IdentityConnection::factory()->create();
$existingUser = $this->createUser(['email' => '[email protected]']);
$userIdentity = UserIdentity::factory()->create([
'user_id' => $existingUser->id,
'connection_id' => $connection->id,
'subject' => 'sub-existing',
'email' => '[email protected]',
]);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Existing User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-existing');
$idTokenClaims['name'] = 'Updated Name';
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->id)->toBe($existingUser->id);
expect($user->email)->toBe('[email protected]');
// Check UserIdentity was updated
$userIdentity->refresh();
expect($userIdentity->claims)->toHaveKey('name', 'Updated Name');
});
it('updates UserIdentity email if changed', function () {
$connection = IdentityConnection::factory()->create();
$existingUser = $this->createUser(['email' => '[email protected]']);
$userIdentity = UserIdentity::factory()->create([
'user_id' => $existingUser->id,
'connection_id' => $connection->id,
'subject' => 'sub-update',
'email' => '[email protected]',
]);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Updated User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-update');
$idTokenClaims['email'] = '[email protected]';
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
$userIdentity->refresh();
expect($userIdentity->email)->toBe('[email protected]');
});
});
describe('ProvisioningService - Account Linking', function () {
it('throws exception when user with email exists but no UserIdentity', function () {
$connection = IdentityConnection::factory()->create();
$existingUser = $this->createUser(['email' => '[email protected]']);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Existing User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-new');
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'An account with this email already exists');
});
});
describe('ProvisioningService - Field Mappings', function () {
it('uses custom email field mapping when configured', function () {
$connection = IdentityConnection::factory()->withFieldMappings([
'email' => 'mail',
'name' => 'display_name',
])->create();
$socialiteUser = createMockSocialiteUser(
email: null, // Not provided by Socialite
name: null
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-mapped');
$idTokenClaims['mail'] = '[email protected]';
$idTokenClaims['display_name'] = 'Mapped Name';
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->email)->toBe('[email protected]');
expect($user->name)->toBe('Mapped Name');
});
it('falls back to standard fields when mapped field not found', function () {
$connection = IdentityConnection::factory()->withFieldMappings([
'email' => 'nonexistent_field',
])->create();
$socialiteUser = createMockSocialiteUser(
email: null,
name: null
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-fallback');
$idTokenClaims['email'] = '[email protected]';
$idTokenClaims['name'] = 'Fallback Name';
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->email)->toBe('[email protected]');
expect($user->name)->toBe('Fallback Name');
});
it('throws exception when email cannot be extracted', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser(
email: null,
name: null
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-no-email');
unset($idTokenClaims['email']);
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'Email is required for OIDC authentication');
});
});
describe('ProvisioningService - Workspace Membership', function () {
it('adds user to workspace for workspace-scoped connection', function () {
$workspace = Workspace::factory()->create();
$connection = IdentityConnection::factory()->forWorkspace($workspace)->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Workspace User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-workspace');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->workspaces()->where('workspaces.id', $workspace->id)->exists())->toBeTrue();
$pivot = $user->workspaces()->withPivot('role')->where('workspaces.id', $workspace->id)->first();
expect($pivot->pivot->role)->toBe('member'); // Default role
});
it('applies role mapping from groups for workspace-scoped connection', function () {
$workspace = Workspace::factory()->create();
$connection = IdentityConnection::factory()
->forWorkspace($workspace)
->withRoleMappings([
['idp_group' => 'admins', 'role' => 'admin'],
['idp_group' => 'users', 'role' => 'member'],
])
->create();
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Admin User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-admin');
$idTokenClaims['groups'] = ['admins', 'users'];
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
$pivot = $user->workspaces()->withPivot('role')->where('workspaces.id', $workspace->id)->first();
expect($pivot->pivot->role)->toBe('admin'); // Highest privilege role
});
it('finds workspace by domain for global connection', function () {
$workspace = Workspace::factory()->create([
'settings' => [
'oidc' => [
'allowed_domain' => 'example.com',
],
],
]);
$connection = IdentityConnection::factory()->create(['workspace_id' => null]);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Global User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-global');
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user->workspaces()->where('workspaces.id', $workspace->id)->exists())->toBeTrue();
});
it('updates role for existing workspace member', function () {
$workspace = Workspace::factory()->create();
$user = $this->createUser(['email' => '[email protected]']);
$user->workspaces()->attach($workspace->id, ['role' => 'member']);
$connection = IdentityConnection::factory()
->forWorkspace($workspace)
->withRoleMappings([
['idp_group' => 'admins', 'role' => 'admin'],
])
->create();
$userIdentity = UserIdentity::factory()->create([
'user_id' => $user->id,
'connection_id' => $connection->id,
'subject' => 'sub-member',
]);
$socialiteUser = createMockSocialiteUser(
email: '[email protected]',
name: 'Member User'
);
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-member');
$idTokenClaims['groups'] = ['admins'];
$service = app(ProvisioningService::class);
$service->provisionUser($connection, $socialiteUser, $idTokenClaims);
$pivot = $user->workspaces()->withPivot('role')->where('workspaces.id', $workspace->id)->first();
expect($pivot->pivot->role)->toBe('admin'); // Role updated
});
});
describe('ProvisioningService - ID Token Validation', function () {
it('validates issuer matches connection issuer', function () {
$connection = IdentityConnection::factory()->create([
'issuer' => 'https://idp.example.com',
]);
$socialiteUser = createMockSocialiteUser();
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-invalid');
$idTokenClaims['iss'] = 'https://wrong-issuer.com';
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'Invalid issuer');
});
it('validates audience contains client_id', function () {
$connection = IdentityConnection::factory()->create([
'client_id' => 'correct-client-id',
]);
$socialiteUser = createMockSocialiteUser();
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-invalid');
$idTokenClaims['aud'] = 'wrong-client-id';
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'Invalid audience');
});
it('validates audience when it is an array', function () {
$connection = IdentityConnection::factory()->create([
'client_id' => 'correct-client-id',
]);
$socialiteUser = createMockSocialiteUser();
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-array');
$idTokenClaims['aud'] = ['other-client', 'correct-client-id'];
$idTokenClaims['azp'] = 'correct-client-id';
$service = app(ProvisioningService::class);
$user = $service->provisionUser($connection, $socialiteUser, $idTokenClaims);
expect($user)->toBeInstanceOf(User::class);
});
it('validates token expiration', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser();
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-expired');
$idTokenClaims['exp'] = time() - 3600; // Expired 1 hour ago
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'ID token has expired');
});
it('validates subject is present', function () {
$connection = IdentityConnection::factory()->create();
$socialiteUser = createMockSocialiteUser();
$idTokenClaims = createValidIdTokenClaims($connection, 'sub-missing');
unset($idTokenClaims['sub']);
$service = app(ProvisioningService::class);
expect(fn () => $service->provisionUser($connection, $socialiteUser, $idTokenClaims))
->toThrow(Exception::class, 'Missing subject');
});
});