trypost/tests/Feature/Social/LinkedInControllerTest.php

<?php

declare(strict_types=1);

use App\Enums\SocialAccount\Platform;
use App\Enums\SocialAccount\Status;
use App\Enums\UserWorkspace\Role;
use App\Models\SocialAccount;
use App\Models\User;
use App\Models\Workspace;
use Illuminate\Support\Facades\Http;
use Laravel\Socialite\Facades\Socialite;
use Laravel\Socialite\Two\User as SocialiteUser;

beforeEach(function () {
    $this->user = User::factory()->create();
    $this->workspace = Workspace::factory()->create(['user_id' => $this->user->id]);
    $this->user->update(['current_workspace_id' => $this->workspace->id]);
    $this->workspace->members()->attach($this->user->id, ['role' => Role::Member->value]);
});

test('linkedin connect redirects to oauth provider', function () {
    $driverMock = Mockery::mock();
    $driverMock->shouldReceive('scopes')->andReturnSelf();
    $driverMock->shouldReceive('redirect')->andReturn(Mockery::mock([
        'getTargetUrl' => 'https://www.linkedin.com/oauth/v2/authorization?test=1',
    ]));

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn($driverMock);

    $response = $this->actingAs($this->user)
        ->withHeader('X-Inertia', 'true')
        ->get(route('app.social.linkedin.connect'));

    $response->assertStatus(409); // Inertia::location returns 409 with X-Inertia header

    expect(session('social_connect_workspace'))->toBe($this->workspace->id);
});

/**
 * Mock the LinkedIn Socialite driver, hit /connect, and return the scopes
 * the controller requested.
 *
 * @return array<int, string>
 */
$captureConnectScopes = function (object $test): array {
    $captured = [];

    $driverMock = Mockery::mock();
    $driverMock->shouldReceive('scopes')
        ->withArgs(function (array $scopes) use (&$captured) {
            $captured = $scopes;

            return true;
        })
        ->andReturnSelf();
    $driverMock->shouldReceive('redirect')->andReturn(Mockery::mock([
        'getTargetUrl' => 'https://www.linkedin.com/oauth/v2/authorization?test=1',
    ]));

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn($driverMock);

    $test->actingAs($test->user)
        ->withHeader('X-Inertia', 'true')
        ->get(route('app.social.linkedin.connect'));

    return $captured;
};

test('linkedin connect requests the default scope set', function () use ($captureConnectScopes) {
    config(['trypost.platforms.linkedin.scopes' => ['openid', 'profile', 'email', 'w_member_social']]);

    expect($captureConnectScopes($this))->toEqualCanonicalizing([
        'openid', 'profile', 'email', 'w_member_social',
    ]);
});

test('linkedin connect requests the scopes configured via LINKEDIN_SCOPES', function () use ($captureConnectScopes) {
    // Operators whose LinkedIn app has legacy/enterprise products approved
    // override the default set via LINKEDIN_SCOPES (exploded into the config
    // array), e.g. re-adding r_basicprofile to restore the vanityName lookup.
    config(['trypost.platforms.linkedin.scopes' => ['openid', 'profile', 'email', 'w_member_social', 'r_basicprofile']]);

    expect($captureConnectScopes($this))->toEqualCanonicalizing([
        'openid', 'profile', 'email', 'w_member_social', 'r_basicprofile',
    ]);
});

test('linkedin oauth callback creates account', function () {
    session([
        'social_connect_workspace' => $this->workspace->id,
    ]);

    $socialiteUser = Mockery::mock(SocialiteUser::class);
    $socialiteUser->shouldReceive('getId')->andReturn('abc123xyz');
    $socialiteUser->shouldReceive('getNickname')->andReturn(null);
    $socialiteUser->shouldReceive('getName')->andReturn('John Doe');
    $socialiteUser->shouldReceive('getAvatar')->andReturn(null);
    $socialiteUser->token = 'test-access-token';
    $socialiteUser->refreshToken = 'test-refresh-token';
    $socialiteUser->expiresIn = 5184000; // 60 days
    $socialiteUser->approvedScopes = ['openid', 'profile', 'email', 'w_member_social'];

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn(Mockery::mock([
            'user' => $socialiteUser,
        ]));

    Http::fake([
        'https://api.linkedin.com/v2/me*' => Http::response([
            'id' => 'abc123xyz',
            'vanityName' => 'johndoe',
            'localizedFirstName' => 'John',
            'localizedLastName' => 'Doe',
        ], 200),
    ]);

    $response = $this->actingAs($this->user)->get(route('app.social.linkedin.callback'));

    $response->assertOk();
    $response->assertViewIs('auth.social-callback');
    $response->assertViewHas('success', true);

    $this->assertDatabaseHas('social_accounts', [
        'workspace_id' => $this->workspace->id,
        'platform' => Platform::LinkedIn->value,
        'platform_user_id' => 'abc123xyz',
        'username' => 'johndoe',
        'status' => Status::Connected->value,
    ]);
});

test('linkedin oauth callback splits comma-separated approvedScopes before saving', function () {
    session(['social_connect_workspace' => $this->workspace->id]);

    $socialiteUser = Mockery::mock(SocialiteUser::class);
    $socialiteUser->shouldReceive('getId')->andReturn('abc123xyz');
    $socialiteUser->shouldReceive('getNickname')->andReturn(null);
    $socialiteUser->shouldReceive('getName')->andReturn('John Doe');
    $socialiteUser->shouldReceive('getAvatar')->andReturn(null);
    $socialiteUser->token = 'test-access-token';
    $socialiteUser->refreshToken = 'test-refresh-token';
    $socialiteUser->expiresIn = 5184000;
    // LinkedIn returns scopes comma-separated; Socialite's LinkedInProvider
    // splits on space (the OAuth 2.0 default), so approvedScopes lands as
    // a single-element array with the whole CSV inside. The save path
    // must normalize back to individual tokens.
    $socialiteUser->approvedScopes = ['email,openid,profile,w_member_social'];

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn(Mockery::mock(['user' => $socialiteUser]));

    Http::fake([
        'https://api.linkedin.com/v2/me*' => Http::response([
            'id' => 'abc123xyz',
            'vanityName' => 'johndoe',
        ], 200),
    ]);

    $this->actingAs($this->user)->get(route('app.social.linkedin.callback'));

    $account = SocialAccount::where('platform_user_id', 'abc123xyz')->first();
    expect($account->scopes)->toEqualCanonicalizing([
        'email', 'openid', 'profile', 'w_member_social',
    ]);
});

test('linkedin callback fails with expired session', function () {
    // No session data - simulating expired session

    $response = $this->actingAs($this->user)->get(route('app.social.linkedin.callback'));

    $response->assertOk();
    $response->assertViewHas('success', false);
    $response->assertViewHas('message', 'Session expired. Please try again.');
});

test('user can connect multiple linkedin accounts in self-hosted mode', function () {
    config()->set('trypost.self_hosted', true);

    SocialAccount::factory()->linkedin()->create([
        'workspace_id' => $this->workspace->id,
        'platform_user_id' => 'abc123xyz',
    ]);

    session([
        'social_connect_workspace' => $this->workspace->id,
    ]);

    $socialiteUser = Mockery::mock(SocialiteUser::class);
    $socialiteUser->shouldReceive('getId')->andReturn('xyz789abc');
    $socialiteUser->shouldReceive('getNickname')->andReturn(null);
    $socialiteUser->shouldReceive('getName')->andReturn('Jane Doe');
    $socialiteUser->shouldReceive('getAvatar')->andReturn(null);
    $socialiteUser->token = 'new-access-token';
    $socialiteUser->refreshToken = 'new-refresh-token';
    $socialiteUser->expiresIn = 5184000;
    $socialiteUser->approvedScopes = ['openid', 'profile', 'email', 'w_member_social'];

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn(Mockery::mock([
            'user' => $socialiteUser,
        ]));

    Http::fake([
        'https://api.linkedin.com/v2/me*' => Http::response([
            'vanityName' => 'janedoe',
        ], 200),
    ]);

    $response = $this->actingAs($this->user)->get(route('app.social.linkedin.callback'));

    $response->assertOk();
    $response->assertViewHas('success', true);

    expect($this->workspace->socialAccounts()->where('platform', Platform::LinkedIn)->count())->toBe(2);
});

test('linkedin callback handles oauth errors gracefully', function () {
    session([
        'social_connect_workspace' => $this->workspace->id,
    ]);

    $mock = Mockery::mock();
    $mock->shouldReceive('user')->andThrow(new Exception('OAuth error'));

    Socialite::shouldReceive('driver')
        ->with('linkedin')
        ->andReturn($mock);

    $response = $this->actingAs($this->user)->get(route('app.social.linkedin.callback'));

    $response->assertOk();
    $response->assertViewHas('success', false);
    $response->assertViewHas('message', 'Error connecting account. Please try again.');
});