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.

24.7 KB
Raw Blame
<?php

declare(strict_types=1);

use App\Enums\Post\PublishStatus;
use App\Enums\PostPlatform\ContentType;
use App\Enums\Repurpose\ItemReason;
use App\Enums\Repurpose\ItemStatus;
use App\Enums\Repurpose\PublishMode;
use App\Enums\Repurpose\SourceFormat;
use App\Enums\SocialAccount\Platform;
use App\Enums\SocialAccount\Status as AccountStatus;
use App\Enums\TikTok\PrivacyLevel;
use App\Jobs\Analytics\BootstrapAccountAnalytics;
use App\Jobs\Analytics\CollectAccountDailySnapshot;
use App\Models\Post;
use App\Models\Repurpose;
use App\Models\RepurposeItem;
use App\Models\SocialAccount;
use App\Models\User;
use App\Models\Workspace;
use Illuminate\Support\Facades\Queue;

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

function repurposeOwnerWithAccounts(): array
{
    $user = User::factory()->create();
    $workspace = Workspace::factory()->create([
        'account_id' => $user->account_id,
        'user_id' => $user->id,
    ]);
    $workspace->members()->attach($user->id, membershipPivot('admin'));
    $user->update(['current_workspace_id' => $workspace->id]);

    $source = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::Instagram]);
    $destination = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::TikTok]);

    return [$user->fresh(), $workspace, $source, $destination];
}

test('the edit page shows the watched format, the destinations and the settings tab', function () {
    [$user, $workspace, $source, $destination] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'source_format' => SourceFormat::Reel,
        'destinations' => [[
            'social_account_id' => $destination->id,
            'content_type' => ContentType::TikTokVideo->value,
            'meta' => [],
        ]],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@source-format-select');

    $page->assertRoute('app.repurposes.show', ['repurpose' => $repurpose->id])
        ->assertVisible('@repurpose-summary')
        ->assertVisible('@repurpose-source-card')
        ->assertVisible('@source-format-select')
        ->assertVisible('@repurpose-lifecycle')
        ->assertNoJavaScriptErrors();
});

test('a destination is not warned about missing media before there is any', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $facebook = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::Facebook]);

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
        'destinations' => [[
            'social_account_id' => $facebook->id,
            'content_type' => ContentType::FacebookReel->value,
            'meta' => [],
        ]],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, "@channel-type-{$facebook->id}-facebook_reel");

    $page->assertVisible("@channel-settings-{$facebook->id}")
        ->assertAttribute("@channel-type-{$facebook->id}-facebook_reel", 'aria-checked', 'true')
        ->assertDontSee('requires_media')
        ->assertDontSee(trans('posts.form.warnings.requires_media'))
        ->assertNoJavaScriptErrors();
});

test('the source account is picked from a searchable list and handed back to the destinations when switched', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $facebook = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::Facebook]);
    $broken = SocialAccount::factory()->for($workspace)->create([
        'platform' => Platform::Instagram,
        'status' => AccountStatus::TokenExpired,
    ]);

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@source-account-select');

    $page->assertVisible("@channel-{$facebook->id}")
        ->assertMissing("@channel-{$source->id}")
        ->assertAttribute('@repurpose-source-avatar', 'data-platform', Platform::Instagram->value)
        ->click('@source-account-select');

    waitFor($page, "@source-option-{$facebook->id}");

    $page->assertSee($facebook->display_name)
        ->assertVisible("@source-option-disconnected-{$broken->id}")
        ->assertMissing("@source-option-disconnected-{$source->id}")
        ->click("@source-option-{$facebook->id}");

    waitFor($page, "@channel-{$source->id}");

    $page->assertVisible("@channel-{$source->id}")
        ->assertMissing("@channel-{$facebook->id}")
        ->assertAttribute('@repurpose-source-avatar', 'data-platform', Platform::Facebook->value)
        ->assertNoJavaScriptErrors();
});

test('deleting sits behind the menu instead of on the page', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@repurpose-menu');

    $page->assertMissing('@delete-repurpose')
        ->click('@repurpose-menu');

    waitFor($page, '@delete-repurpose');

    $page->assertVisible('@delete-repurpose')
        ->assertNoJavaScriptErrors();
});

test('the activity list reads as what happened, never as a database id', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->active()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
    ]);

    $withoutLink = RepurposeItem::factory()->for($repurpose)->create([
        'status' => ItemStatus::Skipped,
        'reason' => ItemReason::MediaUrlMissing,
        'source_permalink' => null,
        'source_created_at' => now()->subHour(),
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@tab-activity');

    $page->click('@tab-activity');

    waitFor($page, "@repurpose-item-{$withoutLink->id}");

    $page->assertVisible("@repurpose-item-{$withoutLink->id}")
        ->assertDontSee($withoutLink->source_media_id)
        ->assertNoJavaScriptErrors();
});

test('a repurposed post deleted on the network reads as deleted in the activity list', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->active()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
    ]);
    $item = RepurposeItem::factory()->for($repurpose)->create(['source_created_at' => now()->subHour()]);
    $post = Post::factory()->forAccount($source)->deletedOnNetwork()->create([
        'repurpose_item_id' => $item->id,
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@tab-activity');
    $page->click('@tab-activity');
    waitFor($page, "@repurpose-item-post-state-{$post->id}");

    $page->assertSeeIn("@repurpose-item-post-state-{$post->id}", __('posts.publish.deleted_on_network.badge'))
        ->assertDontSeeIn("@repurpose-item-post-state-{$post->id}", 'posts.')
        ->assertNoJavaScriptErrors();
});

test('a repurposed post in Google review reads as in review in the activity list', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->active()->create([
        'workspace_id' => $workspace->id,
        'source_social_account_id' => $source->id,
    ]);
    $item = RepurposeItem::factory()->for($repurpose)->create(['source_created_at' => now()->subHour()]);
    $post = Post::factory()->forAccount($source)->published()->create([
        'repurpose_item_id' => $item->id,
        'publish_status' => PublishStatus::PendingReview,
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@tab-activity');
    $page->click('@tab-activity');
    waitFor($page, "@repurpose-item-post-state-{$post->id}");

    $page->assertSeeIn("@repurpose-item-post-state-{$post->id}", __('posts.publish.in_google_review'))
        ->assertDontSeeIn("@repurpose-item-post-state-{$post->id}", 'posts.')
        ->assertNoJavaScriptErrors();
});

test('a destination missing its required meta saves anyway but blocks activating', function () {
    [$user, $workspace, $source, $tiktok] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, '@activate-repurpose');

    $page->assertVisible('@activate-repurpose')
        ->assertMissing('@save-destinations')
        ->click("@channel-{$tiktok->id}");

    waitFor($page, '@repurpose-saved');

    $saved = $repurpose->fresh()->destinations;

    expect($saved)->toHaveCount(1)
        ->and(data_get($saved, '0.social_account_id'))->toBe($tiktok->id)
        ->and($page->script('document.querySelector(\'[data-testid="activate-repurpose"]\').disabled'))->toBeTrue();

    $page->assertNoJavaScriptErrors();
});

test('an autosave the backend rejects says so instead of failing quietly', function () {
    [$user, $workspace, $source, $tiktok] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->active()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [[
            'social_account_id' => $tiktok->id,
            'content_type' => ContentType::TikTokVideo->value,
            'meta' => ['privacy_level' => PrivacyLevel::PublicToEveryone->value],
        ]],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));

    waitFor($page, "@channel-{$tiktok->id}");

    $page->click("@channel-{$tiktok->id}");

    waitFor($page, '@destinations-error');

    $page->assertVisible('@destinations-error')
        ->assertSee(trans('repurposes.errors.destinations_required'))
        ->assertNoJavaScriptErrors();

    expect($repurpose->fresh()->destinations)->toHaveCount(1);
});

test('the list shows each repurpose as a row that opens it and the back button returns', function () {
    [$user, $workspace, $source, $destination] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'source_format' => SourceFormat::Reel,
        'destinations' => [[
            'social_account_id' => $destination->id,
            'content_type' => ContentType::TikTokVideo->value,
            'meta' => [],
        ]],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.index'));

    waitFor($page, "@repurpose-row-{$repurpose->id}");

    $page->assertVisible('@create-repurpose-button')
        ->assertVisible('@header-icon')
        ->assertScript("document.querySelector('[data-testid=\"repurpose-row-{$repurpose->id}\"]').tagName", 'A')
        ->assertScript('document.documentElement.scrollWidth <= window.innerWidth + 1', true)
        ->click("@repurpose-row-{$repurpose->id}");

    waitFor($page, '@repurpose-back');

    $page->assertRoute('app.repurposes.show', ['repurpose' => $repurpose->id])
        ->click('@repurpose-back');

    waitFor($page, '@repurposes-table');

    $page->assertRoute('app.repurposes.index')
        ->resize(390, 844)
        ->assertScript('document.documentElement.scrollWidth <= window.innerWidth + 1', true)
        ->assertNoJavaScriptErrors();
});

test('without any channel the empty state offers to connect one, like the publish page', function () {
    $user = User::factory()->create();
    $workspace = Workspace::factory()->create(['account_id' => $user->account_id, 'user_id' => $user->id]);
    $workspace->members()->attach($user->id, membershipPivot('admin'));
    $user->update(['current_workspace_id' => $workspace->id]);
    $this->actingAs($user->fresh());

    $page = visit(route('app.repurposes.index'));
    waitFor($page, '@repurposes-empty');

    $page->assertVisible('@repurposes-empty-illustration')
        ->assertSeeIn('@repurposes-empty', __('repurposes.empty.title'))
        ->assertMissing('@repurposes-empty-create')
        ->assertSeeIn('@repurposes-empty-connect', __('channels.connect'))
        ->click('@repurposes-empty-connect');
    waitFor($page, '@connect-channel-dialog');

    $page->assertVisible('@connect-channel-dialog')
        ->assertNoJavaScriptErrors();
});

test('with a source channel and no repurpose the empty state starts a new one', function () {
    [$user] = repurposeOwnerWithAccounts();
    $this->actingAs($user);

    $page = visit(route('app.repurposes.index'));
    waitFor($page, '@repurposes-empty');

    $page->assertVisible('@repurposes-empty-illustration')
        ->assertMissing('@repurposes-empty-connect')
        ->click('@repurposes-empty-create');
    waitFor($page, '@create-repurpose-dialog');

    $page->assertVisible('@create-repurpose-dialog')
        ->click('[data-testid="create-repurpose-dialog"] [data-testid="source-account-select"] button');
    waitFor($page, '@source-account-option');

    expect($page->script(<<<'JS'
        [...document.querySelectorAll('[data-testid="source-account-option"]')].map((option) => [
            option.querySelector('[data-slot="avatar"]') !== null,
            option.querySelector('[data-slot="avatar"]').offsetHeight,
        ])
    JS))->toBe([[true, 32]]);
    $page->assertNoJavaScriptErrors();
});

test('the edit page reads like channel settings: source avatar, status, tabs and setting rows', function () {
    [$user, $workspace, $source, $destination] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose))->resize(1440, 1000);
    waitFor($page, '@repurpose-source-avatar');

    $page->assertAttribute('@repurpose-source-avatar', 'data-platform', Platform::Instagram->value)
        ->assertSeeIn('@repurpose-status', __("repurposes.status.{$repurpose->status->value}"))
        ->assertAttribute('@tab-configuration', 'aria-selected', 'true')
        ->assertVisible("@channel-row-{$destination->id}")
        ->assertAttribute("@channel-{$destination->id}", 'aria-checked', 'false')
        ->assertMissing('@flow-source-instagram');

    expect($page->script("document.querySelectorAll('[data-testid=\"repurpose-configuration\"] > hr').length"))->toBe(3);

    $page->click('@tab-activity');
    waitFor($page, '@repurpose-activity-empty');

    $page->assertAttribute('@tab-activity', 'aria-selected', 'true')
        ->assertVisible('@repurposes-empty-illustration')
        ->assertMissing('@repurpose-configuration')
        ->assertNoJavaScriptErrors();
});

test('a destination row switch adds and removes the destination', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();
    $youtube = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::YouTube]);

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));
    waitFor($page, "@channel-{$youtube->id}");

    $page->assertMissing("@channel-settings-{$youtube->id}")
        ->click("@channel-{$youtube->id}");
    waitFor($page, "@channel-settings-{$youtube->id}");
    waitFor($page, '@repurpose-saved');

    $page->assertAttribute("@channel-{$youtube->id}", 'aria-checked', 'true');
    expect(data_get($repurpose->fresh()->destinations, '0.social_account_id'))->toBe($youtube->id);

    $page->click("@channel-{$youtube->id}");
    waitForGone($page, "@channel-settings-{$youtube->id}");

    $page->assertAttribute("@channel-{$youtube->id}", 'aria-checked', 'false')
        ->assertNoJavaScriptErrors();
});

test('the watched format select and the publishing radio save', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'source_format' => SourceFormat::Reel,
        'publish_mode' => PublishMode::Publish,
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose));
    waitFor($page, '@source-format-select');

    $page->click('@source-format-select');
    waitFor($page, '@source-format-option-story');
    $page->click('@source-format-option-story');

    waitForDatabase($page, fn () => $repurpose->fresh()->source_format === SourceFormat::Story);

    expect($repurpose->fresh()->source_format)->toBe(SourceFormat::Story);

    $page->assertAttribute('@publish-mode-publish', 'aria-checked', 'true')
        ->click('@publish-mode-draft');

    waitForDatabase($page, fn () => $repurpose->fresh()->publish_mode === PublishMode::Draft);

    expect($repurpose->fresh()->publish_mode)->toBe(PublishMode::Draft);
    $page->assertAttribute('@publish-mode-draft', 'aria-checked', 'true')
        ->assertNoJavaScriptErrors();
});

test('the list shows each repurpose source and destinations as channel avatars', function () {
    [$user, $workspace, $source, $destination] = repurposeOwnerWithAccounts();
    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [['social_account_id' => $destination->id]],
    ]);
    $this->actingAs($user);

    $page = visit(route('app.repurposes.index'))->resize(1440, 900);
    waitFor($page, "@repurpose-row-{$repurpose->id}");

    $page->assertSeeIn("@repurpose-row-{$repurpose->id}", $source->display_name)
        ->assertSeeIn("@repurpose-row-{$repurpose->id}", __('repurposes.formats.reel'));

    expect($page->script(<<<JS
        (() => {
            const source = document.querySelector('[data-testid="repurpose-source-{$repurpose->id}"]');
            const destinations = document.querySelector('[data-testid="repurpose-destinations-{$repurpose->id}"]');
            return [source.querySelector('[data-slot="avatar"]') !== null, destinations.querySelectorAll('[data-slot="avatar"]').length];
        })()
    JS))->toBe([true, 1]);
    $page->assertNoJavaScriptErrors();
});

test('the destination post types sit centered in their settings panel', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();
    $facebook = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::Facebook]);
    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [['social_account_id' => $facebook->id, 'content_type' => ContentType::FacebookReel->value, 'meta' => []]],
    ]);
    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose))->resize(1440, 1000);
    waitFor($page, "@channel-settings-{$facebook->id}");

    expect($page->script(<<<JS
        (() => {
            const panel = document.querySelector('[data-testid="channel-settings-{$facebook->id}"]').getBoundingClientRect();
            const types = document.querySelector('[data-testid="channel-type-{$facebook->id}"]').getBoundingClientRect();
            return Math.abs((types.top - panel.top) - (panel.bottom - types.bottom)) <= 2;
        })()
    JS))->toBeTrue();
    $page->assertNoJavaScriptErrors();
});

test('an x destination offers no poll, while a threads destination still offers a ghost post', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();
    $x = SocialAccount::factory()->for($workspace)->x()->create();
    $threads = SocialAccount::factory()->for($workspace)->create(['platform' => Platform::Threads]);
    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [
            ['social_account_id' => $x->id, 'content_type' => ContentType::XPost->value, 'meta' => []],
            ['social_account_id' => $threads->id, 'content_type' => ContentType::ThreadsPost->value, 'meta' => []],
        ],
    ]);
    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose))->resize(1440, 1000);
    waitFor($page, "@channel-row-{$x->id}");
    waitFor($page, "@channel-row-{$threads->id}");
    waitForState($page, "@channel-{$x->id}", "element.getAttribute('aria-checked') === 'true'");

    $page->assertAttribute("@channel-{$threads->id}", 'aria-checked', 'true')
        ->assertMissing("@channel-type-{$x->id}-x_poll")
        ->assertMissing("@channel-type-{$x->id}")
        ->assertMissing("@channel-settings-{$x->id}")
        ->assertPresent("@channel-type-{$threads->id}-threads_ghost_post")
        ->assertNoJavaScriptErrors();
});

test('mastodon and threads destinations offer no poll', function () {
    [$user, $workspace, $source] = repurposeOwnerWithAccounts();
    $mastodon = SocialAccount::factory()->for($workspace)->mastodon()->create();
    $threads = SocialAccount::factory()->for($workspace)->threads()->create();
    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'destinations' => [
            ['social_account_id' => $mastodon->id, 'content_type' => ContentType::MastodonPost->value, 'meta' => []],
            ['social_account_id' => $threads->id, 'content_type' => ContentType::ThreadsPost->value, 'meta' => []],
        ],
    ]);
    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose))->resize(1440, 1000);
    waitFor($page, "@channel-row-{$mastodon->id}");
    waitFor($page, "@channel-row-{$threads->id}");
    waitForState($page, "@channel-{$mastodon->id}", "element.getAttribute('aria-checked') === 'true'");

    $page->assertAttribute("@channel-{$threads->id}", 'aria-checked', 'true')
        ->assertMissing("@channel-type-{$mastodon->id}-mastodon_poll")
        ->assertMissing("@channel-type-{$mastodon->id}")
        ->assertPresent("@channel-type-{$threads->id}-threads_post")
        ->assertMissing("@channel-type-{$threads->id}-threads_poll")
        ->assertNoJavaScriptErrors();
});

test('on a phone the header puts the summary and the actions on their own rows', function () {
    [$user, $workspace, $source, $destination] = repurposeOwnerWithAccounts();

    $repurpose = Repurpose::factory()->create([
        'workspace_id' => $workspace->id,
        'user_id' => $user->id,
        'source_social_account_id' => $source->id,
        'source_format' => SourceFormat::Reel,
        'destinations' => [[
            'social_account_id' => $destination->id,
            'content_type' => ContentType::TikTokVideo->value,
            'meta' => [],
        ]],
    ]);

    $this->actingAs($user);

    $page = visit(route('app.repurposes.show', $repurpose))->resize(390, 844);
    waitFor($page, '@repurpose-summary');
    waitFor($page, '@repurpose-lifecycle');

    $layout = $page->script(<<<'JS'
        (() => {
            const summary = document.querySelector('[data-testid="repurpose-summary"]').getBoundingClientRect();
            const actions = document.querySelector('[data-testid="repurpose-lifecycle"]').getBoundingClientRect();
            const title = document.querySelector('[data-testid="repurpose-status"]').getBoundingClientRect();
            return { summaryWidth: Math.round(summary.width), summaryBelowTitle: summary.top >= title.bottom - 1, actionsBelow: actions.top >= summary.bottom - 1, overflow: document.documentElement.scrollWidth > window.innerWidth };
        })()
    JS);

    expect($layout['summaryWidth'])->toBeGreaterThan(300)
        ->and($layout['summaryBelowTitle'])->toBeTrue()
        ->and($layout['actionsBelow'])->toBeTrue()
        ->and($layout['overflow'])->toBeFalse();
    $page->assertNoJavaScriptErrors();
});