Skip to content

Open-source social media scheduler built for AI agents and the teams behind them. Create, schedule and publish posts to every network through MCP or the REST API, or write them yourself in a composer your team will love.

9.5 KB
Raw Blame
<?php

declare(strict_types=1);

use App\Enums\SocialAccount\Status;
use App\Exceptions\PlatformUnavailableException;
use App\Exceptions\TokenExpiredException;
use App\Jobs\Analytics\BootstrapAccountAnalytics;
use App\Jobs\Analytics\CollectAccountDailySnapshot;
use App\Jobs\VerifyWorkspaceConnections;
use App\Mail\WorkspaceConnectionsDisconnected;
use App\Models\SocialAccount;
use App\Models\Workspace;
use App\Services\Social\ConnectionVerifier;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Queue;

beforeEach(function () {
    Queue::fake([BootstrapAccountAnalytics::class, CollectAccountDailySnapshot::class]);
});

test('job does nothing when workspace has no connected accounts', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();

    VerifyWorkspaceConnections::dispatch($workspace);

    Mail::assertNothingSent();
});

test('job does not send email when all connections are valid', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    SocialAccount::factory()->linkedin()->create(['workspace_id' => $workspace->id]);
    SocialAccount::factory()->x()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')->andReturn(true);

    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    Mail::assertNothingSent();
});

test('job marks account as token expired on first failure and disconnected on second', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    $account = SocialAccount::factory()->linkedin()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')
        ->andThrow(new TokenExpiredException('Token expired'));

    app()->instance(ConnectionVerifier::class, $verifier);

    // First run — marks as TokenExpired
    VerifyWorkspaceConnections::dispatch($workspace);

    expect($account->fresh()->status)->toBe(Status::TokenExpired);
    expect($account->fresh()->error_message)->toBe('Token expired');

    // Second run — escalates to Disconnected
    VerifyWorkspaceConnections::dispatch($workspace);

    expect($account->fresh()->status)->toBe(Status::Disconnected);

    Mail::assertQueued(WorkspaceConnectionsDisconnected::class, function ($mail) use ($workspace) {
        return $mail->workspace->id === $workspace->id
            && $mail->disconnectedAccounts->count() === 1;
    });
});

test('job sends single email with all failed accounts', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    $account1 = SocialAccount::factory()->linkedin()->create(['workspace_id' => $workspace->id]);
    $account2 = SocialAccount::factory()->x()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')
        ->andThrow(new TokenExpiredException('Token expired'));

    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    expect($account1->fresh()->status)->toBe(Status::TokenExpired);
    expect($account2->fresh()->status)->toBe(Status::TokenExpired);

    Mail::assertQueued(WorkspaceConnectionsDisconnected::class, function ($mail) use ($workspace) {
        return $mail->workspace->id === $workspace->id
            && $mail->disconnectedAccounts->count() === 2;
    });

    Mail::assertQueuedCount(1);
});

test('job only includes failed accounts in email', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    $validAccount = SocialAccount::factory()->linkedin()->create(['workspace_id' => $workspace->id]);
    $invalidAccount = SocialAccount::factory()->x()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')
        ->with(Mockery::on(fn ($acc) => $acc->id === $validAccount->id))
        ->andReturn(true);
    $verifier->shouldReceive('verify')
        ->with(Mockery::on(fn ($acc) => $acc->id === $invalidAccount->id))
        ->andThrow(new TokenExpiredException('Token expired'));

    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    expect($validAccount->fresh()->status)->toBe(Status::Connected);
    expect($invalidAccount->fresh()->status)->toBe(Status::TokenExpired);

    Mail::assertQueued(WorkspaceConnectionsDisconnected::class, function ($mail) use ($invalidAccount) {
        return $mail->disconnectedAccounts->count() === 1
            && $mail->disconnectedAccounts->first()->id === $invalidAccount->id;
    });
});

test('job does NOT disconnect or email when platform is unavailable', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    $account = SocialAccount::factory()->bluesky()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')->andThrow(
        new PlatformUnavailableException('Bluesky API returned 503 during token refresh', 503)
    );

    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    expect($account->fresh()->status)->toBe(Status::Connected);
    Mail::assertNothingQueued();
});

test('job skips already disconnected accounts', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    SocialAccount::factory()->linkedin()->disconnected()->create(['workspace_id' => $workspace->id]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldNotReceive('verify');

    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    Mail::assertNothingSent();
});

test('daily sweep skips verifying a connected account a recent refresh already proved valid', function () {
    Mail::fake();
    Http::fake([
        config('trypost.platforms.x.api').'/users/me*' => Http::response(['data' => ['id' => '123']], 200),
    ]);

    $workspace = Workspace::factory()->create();
    SocialAccount::factory()->x()->create([
        'workspace_id' => $workspace->id,
        'status' => Status::Connected,
        'last_verified_at' => now()->subHours(2),
    ]);

    VerifyWorkspaceConnections::dispatch($workspace);

    // A successful token refresh within the trust window already proved the
    // credential — re-reading the profile would only burn a billed User Read.
    Http::assertNotSent(fn ($request) => str_contains($request->url(), '/users/me'));
    Mail::assertNothingSent();
});

test('daily sweep still verifies a connected account whose last_verified_at is stale', function () {
    Mail::fake();
    Http::fake([
        config('trypost.platforms.x.api').'/users/me*' => Http::response(['data' => ['id' => '123']], 200),
    ]);

    $workspace = Workspace::factory()->create();
    SocialAccount::factory()->x()->create([
        'workspace_id' => $workspace->id,
        'status' => Status::Connected,
        'last_verified_at' => now()->subHours(20),
    ]);

    VerifyWorkspaceConnections::dispatch($workspace);

    Http::assertSent(fn ($request) => str_contains($request->url(), '/users/me'));
});

test('daily sweep still verifies a TokenExpired account despite a fresh last_verified_at', function () {
    Mail::fake();
    Http::fake([
        config('trypost.platforms.x.api').'/users/me*' => Http::response(['data' => ['id' => '123']], 200),
    ]);

    $workspace = Workspace::factory()->create();
    $account = SocialAccount::factory()->x()->create([
        'workspace_id' => $workspace->id,
        'status' => Status::TokenExpired,
        'last_verified_at' => now()->subMinutes(5),
    ]);

    VerifyWorkspaceConnections::dispatch($workspace);

    // Skipping here would strand a recovered account in TokenExpired forever.
    Http::assertSent(fn ($request) => str_contains($request->url(), '/users/me'));
    expect($account->fresh()->status)->toBe(Status::Connected);
});

test('daily sweep records its own successful verification', function () {
    Mail::fake();
    Http::fake([
        config('trypost.platforms.x.api').'/users/me*' => Http::response(['data' => ['id' => '123']], 200),
    ]);

    $workspace = Workspace::factory()->create();
    $account = SocialAccount::factory()->x()->create([
        'workspace_id' => $workspace->id,
        'status' => Status::Connected,
        'last_verified_at' => null,
    ]);

    VerifyWorkspaceConnections::dispatch($workspace);

    // Otherwise VerifyUpcomingPostConnections burns a fresh call minutes later
    // on an account this sweep just confirmed healthy.
    expect($account->fresh()->last_verified_at)->not->toBeNull();
});

test('an unreachable platform does not revive an account nobody verified', function () {
    Mail::fake();

    $workspace = Workspace::factory()->create();
    $account = SocialAccount::factory()->x()->create([
        'workspace_id' => $workspace->id,
        'status' => Status::TokenExpired,
    ]);

    $verifier = mock(ConnectionVerifier::class);
    $verifier->shouldReceive('verify')->andThrow(new PlatformUnavailableException('X API returned 503', 503));
    app()->instance(ConnectionVerifier::class, $verifier);

    VerifyWorkspaceConnections::dispatch($workspace);

    // "Don't disconnect" is not the same as "verified". Promoting on an
    // outage tells the owner their reconnect worked when nothing was checked.
    expect($account->fresh()->status)->toBe(Status::TokenExpired);
});