536 lines
18 KiB
PHP
536 lines
18 KiB
PHP
<?php
|
|
|
|
namespace Tests\Unit\Jobs;
|
|
|
|
use App\Enums\NotificationSeverityEnum;
|
|
use App\Enums\NotificationTypeEnum;
|
|
use App\Exceptions\PublishException;
|
|
use App\Jobs\PublishNextArticleJob;
|
|
use App\Models\Article;
|
|
use App\Models\ArticlePublication;
|
|
use App\Models\Feed;
|
|
use App\Models\Notification;
|
|
use App\Models\Setting;
|
|
use App\Services\Article\ArticleFetcher;
|
|
use App\Services\Notification\NotificationService;
|
|
use App\Services\Publishing\ArticlePublishingService;
|
|
use Illuminate\Foundation\Testing\RefreshDatabase;
|
|
use Illuminate\Support\Collection;
|
|
use Mockery;
|
|
use Tests\TestCase;
|
|
|
|
class PublishNextArticleJobTest extends TestCase
|
|
{
|
|
use RefreshDatabase;
|
|
|
|
private NotificationService $notificationService;
|
|
|
|
protected function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
$this->notificationService = new NotificationService;
|
|
}
|
|
|
|
public function test_constructor_sets_correct_queue(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$this->assertEquals('publishing', $job->queue);
|
|
}
|
|
|
|
public function test_job_implements_should_queue(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$this->assertInstanceOf(\Illuminate\Contracts\Queue\ShouldQueue::class, $job);
|
|
}
|
|
|
|
public function test_job_implements_should_be_unique(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$this->assertInstanceOf(\Illuminate\Contracts\Queue\ShouldBeUnique::class, $job);
|
|
}
|
|
|
|
public function test_job_has_unique_for_property(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$this->assertEquals(300, $job->uniqueFor);
|
|
}
|
|
|
|
public function test_job_uses_queueable_trait(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$this->assertContains(
|
|
\Illuminate\Foundation\Queue\Queueable::class,
|
|
class_uses($job)
|
|
);
|
|
}
|
|
|
|
public function test_handle_returns_early_when_no_approved_articles(): void
|
|
{
|
|
// Arrange - No articles exist
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
// No expectations as handle should return early
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$publishingServiceMock = \Mockery::mock(ArticlePublishingService::class);
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Should complete without error
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_returns_early_when_no_unpublished_approved_articles(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
// Create a publication record to mark it as already published
|
|
ArticlePublication::factory()->create(['article_id' => $article->id]);
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
// No expectations as handle should return early
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$publishingServiceMock = \Mockery::mock(ArticlePublishingService::class);
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Should complete without error
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_skips_non_approved_articles(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'pending',
|
|
]);
|
|
Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'rejected',
|
|
]);
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
// No expectations as handle should return early
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$publishingServiceMock = \Mockery::mock(ArticlePublishingService::class);
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Should complete without error (no approved articles to process)
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_publishes_oldest_approved_article(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
|
|
// Create older article first
|
|
$olderArticle = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
'created_at' => now()->subHours(2),
|
|
]);
|
|
|
|
// Create newer article
|
|
$newerArticle = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
'created_at' => now()->subHour(),
|
|
]);
|
|
|
|
$extractedData = ['title' => 'Test Article', 'content' => 'Test content'];
|
|
|
|
// Mock ArticleFetcher
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->with(Mockery::on(function ($article) use ($olderArticle) {
|
|
return $article->id === $olderArticle->id;
|
|
}))
|
|
->andReturn($extractedData);
|
|
|
|
// Mock ArticlePublishingService
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->with(
|
|
Mockery::on(function ($article) use ($olderArticle) {
|
|
return $article->id === $olderArticle->id;
|
|
}),
|
|
$extractedData
|
|
)
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Mockery expectations are verified in tearDown
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_throws_exception_on_publishing_failure(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
$publishException = new PublishException($article, null);
|
|
|
|
// Mock ArticleFetcher
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->with(Mockery::type(Article::class))
|
|
->andReturn($extractedData);
|
|
|
|
// Mock ArticlePublishingService to throw exception
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andThrow($publishException);
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Assert
|
|
$this->expectException(PublishException::class);
|
|
|
|
// Act
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
}
|
|
|
|
public function test_handle_logs_publishing_start(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
'title' => 'Test Article Title',
|
|
'url' => 'https://example.com/article',
|
|
]);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
|
|
// Mock ArticleFetcher
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
// Mock ArticlePublishingService
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Verify the job completes (logging is verified by observing no exceptions)
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_job_can_be_serialized(): void
|
|
{
|
|
$job = new PublishNextArticleJob;
|
|
|
|
$serialized = serialize($job);
|
|
$unserialized = unserialize($serialized);
|
|
|
|
$this->assertInstanceOf(PublishNextArticleJob::class, $unserialized);
|
|
$this->assertEquals($job->queue, $unserialized->queue);
|
|
$this->assertEquals($job->uniqueFor, $unserialized->uniqueFor);
|
|
}
|
|
|
|
public function test_handle_fetches_article_data_before_publishing(): void
|
|
{
|
|
// Arrange
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
$extractedData = ['title' => 'Extracted Title', 'content' => 'Extracted Content'];
|
|
|
|
// Mock ArticleFetcher with specific expectations
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->with(Mockery::type(Article::class))
|
|
->andReturn($extractedData);
|
|
|
|
// Mock publishing service to receive the extracted data
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->with(Mockery::type(Article::class), $extractedData)
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
// Act
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
// Assert - Mockery expectations verified in tearDown
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_skips_publishing_when_last_publication_within_interval(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
// Last publication was 3 minutes ago, interval is 10 minutes
|
|
ArticlePublication::factory()->create([
|
|
'published_at' => now()->subMinutes(3),
|
|
]);
|
|
Setting::setArticlePublishingInterval(10);
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
|
|
// Neither should be called
|
|
$articleFetcherMock->shouldNotReceive('fetchArticleData');
|
|
$publishingServiceMock->shouldNotReceive('publishToRoutedChannels');
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_publishes_when_last_publication_beyond_interval(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
// Last publication was 15 minutes ago, interval is 10 minutes
|
|
ArticlePublication::factory()->create([
|
|
'published_at' => now()->subMinutes(15),
|
|
]);
|
|
Setting::setArticlePublishingInterval(10);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_publishes_when_interval_is_zero(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
// Last publication was just now, but interval is 0
|
|
ArticlePublication::factory()->create([
|
|
'published_at' => now(),
|
|
]);
|
|
Setting::setArticlePublishingInterval(0);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_publishes_when_last_publication_exactly_at_interval(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
// Last publication was exactly 10 minutes ago, interval is 10 minutes — should publish
|
|
ArticlePublication::factory()->create([
|
|
'published_at' => now()->subMinutes(10),
|
|
]);
|
|
Setting::setArticlePublishingInterval(10);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_publishes_when_no_previous_publications_exist(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
]);
|
|
|
|
Setting::setArticlePublishingInterval(10);
|
|
|
|
$extractedData = ['title' => 'Test Article'];
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection(['publication']));
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertTrue(true);
|
|
}
|
|
|
|
public function test_handle_creates_warning_notification_when_no_publications_created(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
'title' => 'No Route Article',
|
|
]);
|
|
|
|
$extractedData = ['title' => 'No Route Article'];
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andReturn(new Collection);
|
|
|
|
$job = new PublishNextArticleJob;
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
|
|
$this->assertDatabaseHas('notifications', [
|
|
'type' => NotificationTypeEnum::PUBLISH_FAILED->value,
|
|
'severity' => NotificationSeverityEnum::WARNING->value,
|
|
'notifiable_type' => $article->getMorphClass(),
|
|
'notifiable_id' => $article->id,
|
|
]);
|
|
|
|
$notification = Notification::first();
|
|
$this->assertStringContainsString('No Route Article', $notification->title);
|
|
}
|
|
|
|
public function test_handle_creates_notification_on_publish_exception(): void
|
|
{
|
|
$feed = Feed::factory()->create();
|
|
$article = Article::factory()->create([
|
|
'feed_id' => $feed->id,
|
|
'approval_status' => 'approved',
|
|
'title' => 'Failing Article',
|
|
]);
|
|
|
|
$extractedData = ['title' => 'Failing Article'];
|
|
$publishException = new PublishException($article, null);
|
|
|
|
$articleFetcherMock = Mockery::mock(ArticleFetcher::class);
|
|
$articleFetcherMock->shouldReceive('fetchArticleData')
|
|
->once()
|
|
->andReturn($extractedData);
|
|
|
|
$publishingServiceMock = Mockery::mock(ArticlePublishingService::class);
|
|
$publishingServiceMock->shouldReceive('publishToRoutedChannels')
|
|
->once()
|
|
->andThrow($publishException);
|
|
|
|
$job = new PublishNextArticleJob;
|
|
|
|
try {
|
|
$job->handle($articleFetcherMock, $publishingServiceMock, $this->notificationService);
|
|
} catch (PublishException) {
|
|
// Expected
|
|
}
|
|
|
|
$this->assertDatabaseHas('notifications', [
|
|
'type' => NotificationTypeEnum::PUBLISH_FAILED->value,
|
|
'severity' => NotificationSeverityEnum::ERROR->value,
|
|
'notifiable_type' => $article->getMorphClass(),
|
|
'notifiable_id' => $article->id,
|
|
]);
|
|
|
|
$notification = Notification::first();
|
|
$this->assertStringContainsString('Failing Article', $notification->title);
|
|
}
|
|
|
|
protected function tearDown(): void
|
|
{
|
|
Mockery::close();
|
|
parent::tearDown();
|
|
}
|
|
}
|