fedi-feed-router/backend/tests/Feature/JobsAndEventsTest.php

<?php

namespace Tests\Feature;

use App\Events\ArticleApproved;
// use App\Events\ArticleReadyToPublish; // Class no longer exists
use App\Events\ExceptionLogged;
use App\Events\ExceptionOccurred;
use App\Events\NewArticleFetched;
use App\Jobs\ArticleDiscoveryForFeedJob;
use App\Jobs\ArticleDiscoveryJob;
use App\Jobs\PublishNextArticleJob;
use App\Jobs\SyncChannelPostsJob;
use App\Listeners\LogExceptionToDatabase;
// use App\Listeners\PublishApprovedArticle; // Class no longer exists
// use App\Listeners\PublishArticle; // Class no longer exists
use App\Listeners\ValidateArticleListener;
use App\Models\Article;
use App\Models\Feed;
use App\Models\Log;
use App\Models\PlatformChannel;
use App\Services\Log\LogSaver;
use App\Services\Article\ArticleFetcher;
use App\Services\Article\ValidationService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Queue;
use Tests\TestCase;

class JobsAndEventsTest extends TestCase
{
    use RefreshDatabase;

    protected function setUp(): void
    {
        parent::setUp();
    }

    public function test_article_discovery_job_processes_successfully(): void
    {
        Queue::fake();

        $feed = Feed::factory()->create(['is_active' => true]);

        $logSaver = app(LogSaver::class);
        $job = new ArticleDiscoveryJob();
        $job->handle($logSaver);

        // Should dispatch individual feed jobs
        Queue::assertPushed(ArticleDiscoveryForFeedJob::class);
    }

    public function test_article_discovery_for_feed_job_processes_feed(): void
    {
        Event::fake();

        $feed = Feed::factory()->create([
            'url' => 'https://example.com/feed',
            'is_active' => true
        ]);

        // Mock the ArticleFetcher service in the container
        $mockFetcher = \Mockery::mock(\App\Services\Article\ArticleFetcher::class);
        $article1 = Article::factory()->create(['url' => 'https://example.com/article1', 'feed_id' => $feed->id]);
        $article2 = Article::factory()->create(['url' => 'https://example.com/article2', 'feed_id' => $feed->id]);
        $mockFetcher->shouldReceive('getArticlesFromFeed')
            ->with($feed)
            ->andReturn(collect([$article1, $article2]));

        $this->app->instance(\App\Services\Article\ArticleFetcher::class, $mockFetcher);

        $logSaver = app(LogSaver::class);
        $articleFetcher = app(ArticleFetcher::class);
        $job = new ArticleDiscoveryForFeedJob($feed);
        $job->handle($logSaver, $articleFetcher);

        // Should have articles in database (existing articles created by factory)
        $this->assertCount(2, Article::all());
        // Note: Events are not fired by ArticleDiscoveryForFeedJob directly
        // They would be fired by the Article model when created
    }

    public function test_sync_channel_posts_job_processes_successfully(): void
    {
        $channel = PlatformChannel::factory()->create();
        $job = new SyncChannelPostsJob($channel);
        
        // Test that job can be constructed and has correct properties
        $this->assertEquals('sync', $job->queue);
        $this->assertInstanceOf(SyncChannelPostsJob::class, $job);
        
        // Don't actually run the job to avoid HTTP calls
        $this->assertTrue(true);
    }


    public function test_publish_next_article_job_has_correct_configuration(): void
    {
        $job = new PublishNextArticleJob();

        $this->assertEquals('publishing', $job->queue);
        $this->assertInstanceOf(PublishNextArticleJob::class, $job);
    }

    public function test_new_article_fetched_event_is_dispatched(): void
    {
        Event::fake();

        $feed = Feed::factory()->create();
        $article = Article::factory()->create(['feed_id' => $feed->id]);

        event(new NewArticleFetched($article));

        Event::assertDispatched(NewArticleFetched::class, function (NewArticleFetched $event) use ($article) {
            return $event->article->id === $article->id;
        });
    }

    public function test_article_approved_event_is_dispatched(): void
    {
        Event::fake();

        $article = Article::factory()->create();

        event(new ArticleApproved($article));

        Event::assertDispatched(ArticleApproved::class, function (ArticleApproved $event) use ($article) {
            return $event->article->id === $article->id;
        });
    }

    // Test removed - ArticleReadyToPublish class no longer exists
    // public function test_article_ready_to_publish_event_is_dispatched(): void
    // {
    //     Event::fake();

    //     $article = Article::factory()->create();

    //     event(new ArticleReadyToPublish($article));

    //     Event::assertDispatched(ArticleReadyToPublish::class, function (ArticleReadyToPublish $event) use ($article) {
    //         return $event->article->id === $article->id;
    //     });
    // }

    public function test_exception_occurred_event_is_dispatched(): void
    {
        Event::fake();

        $exception = new \Exception('Test exception');

        event(new ExceptionOccurred($exception, \App\Enums\LogLevelEnum::ERROR, 'Test exception', ['context' => 'test']));

        Event::assertDispatched(ExceptionOccurred::class, function (ExceptionOccurred $event) {
            return $event->exception->getMessage() === 'Test exception';
        });
    }

    public function test_exception_logged_event_is_dispatched(): void
    {
        Event::fake();

        $log = Log::factory()->create([
            'level' => 'error',
            'message' => 'Test error',
            'context' => json_encode(['key' => 'value'])
        ]);

        event(new ExceptionLogged($log));

        Event::assertDispatched(ExceptionLogged::class, function (ExceptionLogged $event) use ($log) {
            return $event->log->message === 'Test error';
        });
    }

    public function test_validate_article_listener_processes_new_article(): void
    {
        Event::fake([ArticleReadyToPublish::class]);

        $feed = Feed::factory()->create();
        $article = Article::factory()->create([
            'feed_id' => $feed->id,
            'approval_status' => 'pending',
                    ]);

        // Mock ArticleFetcher to return valid article data
        $mockFetcher = \Mockery::mock(\App\Services\Article\ArticleFetcher::class);
        $this->app->instance(\App\Services\Article\ArticleFetcher::class, $mockFetcher);
        $mockFetcher->shouldReceive('fetchArticleData')
            ->with($article)
            ->andReturn([
                'title' => 'Belgian News',
                'description' => 'News from Belgium',
                'full_article' => 'This is a test article about Belgium and Belgian politics.'
            ]);

        $validationService = app(ValidationService::class);
        $listener = new ValidateArticleListener();
        $event = new NewArticleFetched($article);

        $listener->handle($event, $validationService);

        $article->refresh();
        $this->assertNotEquals('pending', $article->approval_status);
        $this->assertContains($article->approval_status, ['approved', 'rejected']);
    }

    // Test removed - PublishApprovedArticle and ArticleReadyToPublish classes no longer exist
    // public function test_publish_approved_article_listener_queues_job(): void
    // {
    //     Event::fake();

    //     $article = Article::factory()->create([
    //         'approval_status' => 'approved',
    //         'approval_status' => 'approved',
    //                 ]);

    //     $listener = new PublishApprovedArticle();
    //     $event = new ArticleApproved($article);

    //     $listener->handle($event);

    //     Event::assertDispatched(ArticleReadyToPublish::class);
    // }

    // Test removed - PublishArticle and ArticleReadyToPublish classes no longer exist
    // public function test_publish_article_listener_queues_publish_job(): void
    // {
    //     Queue::fake();

    //     $article = Article::factory()->create([
    //         'approval_status' => 'approved',
    //                 ]);

    //     $listener = new PublishArticle();
    //     $event = new ArticleReadyToPublish($article);

    //     $listener->handle($event);

    //     Queue::assertPushed(PublishNextArticleJob::class);
    // }

    public function test_log_exception_to_database_listener_creates_log(): void
    {
        $log = Log::factory()->create([
            'level' => 'error',
            'message' => 'Test exception message',
            'context' => json_encode(['error' => 'details'])
        ]);

        $listener = new LogExceptionToDatabase();
        $exception = new \Exception('Test exception message');
        $event = new ExceptionOccurred($exception, \App\Enums\LogLevelEnum::ERROR, 'Test exception message');

        $listener->handle($event);

        $this->assertDatabaseHas('logs', [
            'level' => 'error',
            'message' => 'Test exception message'
        ]);

        $savedLog = Log::where('message', 'Test exception message')->first();
        $this->assertNotNull($savedLog);
        $this->assertEquals(\App\Enums\LogLevelEnum::ERROR, $savedLog->level);
    }

    public function test_event_listener_registration_works(): void
    {
        // Test that events are properly bound to listeners
        $listeners = Event::getListeners(NewArticleFetched::class);
        $this->assertNotEmpty($listeners);

        // ArticleApproved event exists but has no listeners after publishing redesign
        // $listeners = Event::getListeners(ArticleApproved::class);
        // $this->assertNotEmpty($listeners);

        // ArticleReadyToPublish no longer exists - removed this check
        // $listeners = Event::getListeners(ArticleReadyToPublish::class);
        // $this->assertNotEmpty($listeners);

        $listeners = Event::getListeners(ExceptionOccurred::class);
        $this->assertNotEmpty($listeners);
    }

    public function test_job_retry_configuration(): void
    {
        $job = new PublishNextArticleJob();

        // Test that job has unique configuration
        $this->assertObjectHasProperty('uniqueFor', $job);
        $this->assertEquals(300, $job->uniqueFor);
    }

    public function test_job_queue_configuration(): void
    {
        $feed = Feed::factory()->create(['url' => 'https://unique-test-feed.com/rss']);
        $channel = PlatformChannel::factory()->create();
        $article = Article::factory()->create(['feed_id' => $feed->id]);

        $discoveryJob = new ArticleDiscoveryJob();
        $feedJob = new ArticleDiscoveryForFeedJob($feed);
        $publishJob = new PublishNextArticleJob();
        $syncJob = new SyncChannelPostsJob($channel);

        // Test queue assignments
        $this->assertEquals('feed-discovery', $discoveryJob->queue ?? 'default');
        $this->assertEquals('feed-discovery', $feedJob->queue ?? 'discovery');
        $this->assertEquals('publishing', $publishJob->queue);
        $this->assertEquals('sync', $syncJob->queue ?? 'sync');
    }

    protected function tearDown(): void
    {
        \Mockery::close();
        parent::tearDown();
    }
}