mirror/Arsse
1
1
Fork 0
mirror of https://code.mensbeam.com/MensBeam/Arsse.git synced 2025-01-05 07:22:40 +00:00
Code Issues Activity

Convert method coverage

Browse source
This commit is contained in:
J. King 2024-12-27 21:43:44 -05:00
parent ba4d3f497b
commit 2aa4fc9215
14 changed files with 768 additions and 1107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

792
tests/cases/Database/SeriesArticle.php
View file

File diff suppressed because it is too large Load diff

22
tests/cases/Database/SeriesCleanup.php
View file

@ -10,6 +10,8 @@ namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use DateTimeImmutable as Date; use DateTimeImmutable as Date;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesCleanup { trait SeriesCleanup {
protected function setUpSeriesCleanup(): void { protected function setUpSeriesCleanup(): void {
@ -171,7 +173,7 @@ trait SeriesCleanup {
unset($this->data); unset($this->data);
} }
/** @covers \JKingWeb\Arsse\Database::feedCleanup */ #[CoversMethod(Database::class, "feedCleanup")]
public function testCleanUpOrphanedFeeds(): void { public function testCleanUpOrphanedFeeds(): void {
Arsse::$db->feedCleanup(); Arsse::$db->feedCleanup();
$now = gmdate("Y-m-d H:i:s"); $now = gmdate("Y-m-d H:i:s");
@ -184,7 +186,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedCleanup */ #[CoversMethod(Database::class, "feedCleanup")]
public function testCleanUpOrphanedFeedsWithUnlimitedRetention(): void { public function testCleanUpOrphanedFeedsWithUnlimitedRetention(): void {
Arsse::$conf->import([ Arsse::$conf->import([
'purgeFeeds' => null, 'purgeFeeds' => null,
@ -199,7 +201,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::iconCleanup */ #[CoversMethod(Database::class, "iconCleanup")]
public function testCleanUpOrphanedIcons(): void { public function testCleanUpOrphanedIcons(): void {
Arsse::$db->iconCleanup(); Arsse::$db->iconCleanup();
$now = gmdate("Y-m-d H:i:s"); $now = gmdate("Y-m-d H:i:s");
@ -212,7 +214,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::iconCleanup */ #[CoversMethod(Database::class, "iconCleanup")]
public function testCleanUpOrphanedIconsWithUnlimitedRetention(): void { public function testCleanUpOrphanedIconsWithUnlimitedRetention(): void {
Arsse::$conf->import([ Arsse::$conf->import([
'purgeFeeds' => null, 'purgeFeeds' => null,
@ -227,7 +229,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::articleCleanup */ #[CoversMethod(Database::class, "articleCleanup")]
public function testCleanUpOldArticlesWithStandardRetention(): void { public function testCleanUpOldArticlesWithStandardRetention(): void {
Arsse::$db->articleCleanup(); Arsse::$db->articleCleanup();
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -239,7 +241,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::articleCleanup */ #[CoversMethod(Database::class, "articleCleanup")]
public function testCleanUpOldArticlesWithUnlimitedReadRetention(): void { public function testCleanUpOldArticlesWithUnlimitedReadRetention(): void {
Arsse::$conf->import([ Arsse::$conf->import([
'purgeArticlesRead' => null, 'purgeArticlesRead' => null,
@ -254,7 +256,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::articleCleanup */ #[CoversMethod(Database::class, "articleCleanup")]
public function testCleanUpOldArticlesWithUnlimitedUnreadRetention(): void { public function testCleanUpOldArticlesWithUnlimitedUnreadRetention(): void {
Arsse::$conf->import([ Arsse::$conf->import([
'purgeArticlesUnread' => null, 'purgeArticlesUnread' => null,
@ -269,7 +271,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::articleCleanup */ #[CoversMethod(Database::class, "articleCleanup")]
public function testCleanUpOldArticlesWithUnlimitedRetention(): void { public function testCleanUpOldArticlesWithUnlimitedRetention(): void {
Arsse::$conf->import([ Arsse::$conf->import([
'purgeArticlesRead' => null, 'purgeArticlesRead' => null,
@ -282,7 +284,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::sessionCleanup */ #[CoversMethod(Database::class, "sessionCleanup")]
public function testCleanUpExpiredSessions(): void { public function testCleanUpExpiredSessions(): void {
Arsse::$db->sessionCleanup(); Arsse::$db->sessionCleanup();
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -294,7 +296,7 @@ trait SeriesCleanup {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::tokenCleanup */ #[CoversMethod(Database::class, "tokenCleanup")]
public function testCleanUpExpiredTokens(): void { public function testCleanUpExpiredTokens(): void {
Arsse::$db->tokenCleanup(); Arsse::$db->tokenCleanup();
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [

35
tests/cases/Database/SeriesFeed.php
View file

@ -9,7 +9,10 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use JKingWeb\Arsse\Test\Result; use JKingWeb\Arsse\Test\Result;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\Attributes\DataProvider;
trait SeriesFeed { trait SeriesFeed {
protected $matches; protected $matches;
@ -193,12 +196,12 @@ trait SeriesFeed {
unset($this->data, $this->matches); unset($this->data, $this->matches);
} }
/** @covers \JKingWeb\Arsse\Database::feedMatchLatest */ #[CoversMethod(Database::class, "feedMatchLatest")]
public function testListLatestItems(): void { public function testListLatestItems(): void {
$this->assertResult($this->matches, Arsse::$db->feedMatchLatest(1, 2)); $this->assertResult($this->matches, Arsse::$db->feedMatchLatest(1, 2));
} }
/** @covers \JKingWeb\Arsse\Database::feedMatchIds */ #[CoversMethod(Database::class, "feedMatchIds")]
public function testMatchItemsById(): void { public function testMatchItemsById(): void {
$this->assertResult($this->matches, Arsse::$db->feedMatchIds(1, ['804e517d623390e71497982c77cf6823180342ebcd2e7d5e32da1e55b09dd180','db3e736c2c492f5def5c5da33ddcbea1824040e9ced2142069276b0a6e291a41'])); $this->assertResult($this->matches, Arsse::$db->feedMatchIds(1, ['804e517d623390e71497982c77cf6823180342ebcd2e7d5e32da1e55b09dd180','db3e736c2c492f5def5c5da33ddcbea1824040e9ced2142069276b0a6e291a41']));
foreach ($this->matches as $m) { foreach ($this->matches as $m) {
@ -210,10 +213,8 @@ trait SeriesFeed {
$this->assertResult([['id' => 1]], Arsse::$db->feedMatchIds(1, ['e433653cef2e572eee4215fa299a4a5af9137b2cefd6283c85bd69a32915beda'])); // this ID appears in both feed 1 and feed 2; only one result should be returned $this->assertResult([['id' => 1]], Arsse::$db->feedMatchIds(1, ['e433653cef2e572eee4215fa299a4a5af9137b2cefd6283c85bd69a32915beda'])); // this ID appears in both feed 1 and feed 2; only one result should be returned
} }
/** #[DataProvider("provideFilterRules")]
* @dataProvider provideFilterRules #[CoversMethod(Database::class, "feedRulesGet")]
* @covers \JKingWeb\Arsse\Database::feedRulesGet
*/
public function testGetRules(int $in, array $exp): void { public function testGetRules(int $in, array $exp): void {
$this->assertSame($exp, Arsse::$db->feedRulesGet($in)); $this->assertSame($exp, Arsse::$db->feedRulesGet($in));
} }
@ -228,7 +229,7 @@ trait SeriesFeed {
]; ];
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateAFeed(): void { public function testUpdateAFeed(): void {
// update a valid feed with both new and changed items // update a valid feed with both new and changed items
Arsse::$db->feedUpdate(1); Arsse::$db->feedUpdate(1);
@ -270,25 +271,25 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateAMissingFeed(): void { public function testUpdateAMissingFeed(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->feedUpdate(2112); Arsse::$db->feedUpdate(2112);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateAnInvalidFeed(): void { public function testUpdateAnInvalidFeed(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->feedUpdate(-1); Arsse::$db->feedUpdate(-1);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateAFeedThrowingExceptions(): void { public function testUpdateAFeedThrowingExceptions(): void {
$this->assertException("invalidUrl", "Feed"); $this->assertException("invalidUrl", "Feed");
Arsse::$db->feedUpdate(3, true); Arsse::$db->feedUpdate(3, true);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateAFeedWithEnclosuresAndCategories(): void { public function testUpdateAFeedWithEnclosuresAndCategories(): void {
Arsse::$db->feedUpdate(5); Arsse::$db->feedUpdate(5);
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -309,7 +310,7 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedListStale */ #[CoversMethod(Database::class, "feedListStale")]
public function testListStaleFeeds(): void { public function testListStaleFeeds(): void {
$this->assertEquals([1,3,4], Arsse::$db->feedListStale()); $this->assertEquals([1,3,4], Arsse::$db->feedListStale());
Arsse::$db->feedUpdate(3); Arsse::$db->feedUpdate(3);
@ -317,7 +318,7 @@ trait SeriesFeed {
$this->assertEquals([1], Arsse::$db->feedListStale()); $this->assertEquals([1], Arsse::$db->feedListStale());
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testCheckIconDuringFeedUpdate(): void { public function testCheckIconDuringFeedUpdate(): void {
Arsse::$db->feedUpdate(6); Arsse::$db->feedUpdate(6);
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -327,7 +328,7 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testAssignIconDuringFeedUpdate(): void { public function testAssignIconDuringFeedUpdate(): void {
Arsse::$db->feedUpdate(7); Arsse::$db->feedUpdate(7);
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -338,7 +339,7 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testChangeIconDuringFeedUpdate(): void { public function testChangeIconDuringFeedUpdate(): void {
Arsse::$db->feedUpdate(8); Arsse::$db->feedUpdate(8);
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -349,7 +350,7 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testAddIconDuringFeedUpdate(): void { public function testAddIconDuringFeedUpdate(): void {
Arsse::$db->feedUpdate(9); Arsse::$db->feedUpdate(9);
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -361,7 +362,7 @@ trait SeriesFeed {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::feedUpdate */ #[CoversMethod(Database::class, "feedUpdate")]
public function testUpdateUnmodifiedFeed(): void { public function testUpdateUnmodifiedFeed(): void {
$this->markTestIncomplete("FIXME: there is a bug here around calculation of nextFetch date"); $this->markTestIncomplete("FIXME: there is a bug here around calculation of nextFetch date");
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [

204
tests/cases/Database/SeriesFolder.php
View file

@ -9,6 +9,8 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesFolder { trait SeriesFolder {
protected function setUpSeriesFolder(): void { protected function setUpSeriesFolder(): void {
@ -100,11 +102,9 @@ trait SeriesFolder {
unset($this->data); unset($this->data);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddARootFolder(): void { public function testAddARootFolder(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$folderID = $this->nextID("arsse_folders"); $folderID = $this->nextID("arsse_folders");
@ -114,21 +114,17 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddADuplicateRootFolder(): void { public function testAddADuplicateRootFolder(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Politics"]); Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Politics"]);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddANestedFolder(): void { public function testAddANestedFolder(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$folderID = $this->nextID("arsse_folders"); $folderID = $this->nextID("arsse_folders");
@ -138,70 +134,56 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddANestedFolderToAMissingParent(): void { public function testAddANestedFolderToAMissingParent(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => 2112]); Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => 2112]);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddANestedFolderToAnInvalidParent(): void { public function testAddANestedFolderToAnInvalidParent(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => "stringFolderId"]); Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => "stringFolderId"]);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddANestedFolderForTheWrongOwner(): void { public function testAddANestedFolderForTheWrongOwner(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => 4]); // folder ID 4 belongs to Jane Arsse::$db->folderAdd("john.doe@example.com", ['name' => "Sociology", 'parent' => 4]); // folder ID 4 belongs to Jane
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddAFolderWithAMissingName(): void { public function testAddAFolderWithAMissingName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", []); Arsse::$db->folderAdd("john.doe@example.com", []);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddAFolderWithABlankName(): void { public function testAddAFolderWithABlankName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => ""]); Arsse::$db->folderAdd("john.doe@example.com", ['name' => ""]);
} }
/** #[CoversMethod(Database::class, "folderAdd")]
* @covers \JKingWeb\Arsse\Database::folderAdd #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testAddAFolderWithAWhitespaceName(): void { public function testAddAFolderWithAWhitespaceName(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
Arsse::$db->folderAdd("john.doe@example.com", ['name' => " "]); Arsse::$db->folderAdd("john.doe@example.com", ['name' => " "]);
} }
/** #[CoversMethod(Database::class, "folderList")]
* @covers \JKingWeb\Arsse\Database::folderList #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId
*/
public function testListRootFolders(): void { public function testListRootFolders(): void {
$exp = [ $exp = [
['id' => 5, 'name' => "Politics", 'parent' => null, 'children' => 0, 'feeds' => 2], ['id' => 5, 'name' => "Politics", 'parent' => null, 'children' => 0, 'feeds' => 2],
@ -216,10 +198,8 @@ trait SeriesFolder {
$this->assertResult($exp, Arsse::$db->folderList("admin@example.net", null, false)); $this->assertResult($exp, Arsse::$db->folderList("admin@example.net", null, false));
} }
/** #[CoversMethod(Database::class, "folderList")]
* @covers \JKingWeb\Arsse\Database::folderList #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId
*/
public function testListFoldersRecursively(): void { public function testListFoldersRecursively(): void {
$exp = [ $exp = [
['id' => 5, 'name' => "Politics", 'parent' => null, 'children' => 0, 'feeds' => 2], ['id' => 5, 'name' => "Politics", 'parent' => null, 'children' => 0, 'feeds' => 2],
@ -239,25 +219,21 @@ trait SeriesFolder {
$this->assertResult($exp, Arsse::$db->folderList("jane.doe@example.com", 4, true)); $this->assertResult($exp, Arsse::$db->folderList("jane.doe@example.com", 4, true));
} }
/** #[CoversMethod(Database::class, "folderList")]
* @covers \JKingWeb\Arsse\Database::folderList #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId
*/
public function testListFoldersOfAMissingParent(): void { public function testListFoldersOfAMissingParent(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderList("john.doe@example.com", 2112); Arsse::$db->folderList("john.doe@example.com", 2112);
} }
/** #[CoversMethod(Database::class, "folderList")]
* @covers \JKingWeb\Arsse\Database::folderList #[CoversMethod(Database::class, "folderValidateId")]
* @covers \JKingWeb\Arsse\Database::folderValidateId
*/
public function testListFoldersOfTheWrongOwner(): void { public function testListFoldersOfTheWrongOwner(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderList("john.doe@example.com", 4); // folder ID 4 belongs to Jane Arsse::$db->folderList("john.doe@example.com", 4); // folder ID 4 belongs to Jane
} }
/** @covers \JKingWeb\Arsse\Database::folderRemove */ #[CoversMethod(Database::class, "folderRemove")]
public function testRemoveAFolder(): void { public function testRemoveAFolder(): void {
$this->assertTrue(Arsse::$db->folderRemove("john.doe@example.com", 6)); $this->assertTrue(Arsse::$db->folderRemove("john.doe@example.com", 6));
$state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]); $state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]);
@ -265,7 +241,7 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::folderRemove */ #[CoversMethod(Database::class, "folderRemove")]
public function testRemoveAFolderTree(): void { public function testRemoveAFolderTree(): void {
$this->assertTrue(Arsse::$db->folderRemove("john.doe@example.com", 1)); $this->assertTrue(Arsse::$db->folderRemove("john.doe@example.com", 1));
$state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]); $state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]);
@ -275,25 +251,25 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::folderRemove */ #[CoversMethod(Database::class, "folderRemove")]
public function testRemoveAMissingFolder(): void { public function testRemoveAMissingFolder(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderRemove("john.doe@example.com", 2112); Arsse::$db->folderRemove("john.doe@example.com", 2112);
} }
/** @covers \JKingWeb\Arsse\Database::folderRemove */ #[CoversMethod(Database::class, "folderRemove")]
public function testRemoveAnInvalidFolder(): void { public function testRemoveAnInvalidFolder(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->folderRemove("john.doe@example.com", -1); Arsse::$db->folderRemove("john.doe@example.com", -1);
} }
/** @covers \JKingWeb\Arsse\Database::folderRemove */ #[CoversMethod(Database::class, "folderRemove")]
public function testRemoveAFolderOfTheWrongOwner(): void { public function testRemoveAFolderOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderRemove("john.doe@example.com", 4); // folder ID 4 belongs to Jane Arsse::$db->folderRemove("john.doe@example.com", 4); // folder ID 4 belongs to Jane
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesGet */ #[CoversMethod(Database::class, "folderPropertiesGet")]
public function testGetThePropertiesOfAFolder(): void { public function testGetThePropertiesOfAFolder(): void {
$exp = [ $exp = [
'id' => 6, 'id' => 6,
@ -303,33 +279,31 @@ trait SeriesFolder {
$this->assertArraySubset($exp, Arsse::$db->folderPropertiesGet("john.doe@example.com", 6)); $this->assertArraySubset($exp, Arsse::$db->folderPropertiesGet("john.doe@example.com", 6));
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesGet */ #[CoversMethod(Database::class, "folderPropertiesGet")]
public function testGetThePropertiesOfAMissingFolder(): void { public function testGetThePropertiesOfAMissingFolder(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesGet("john.doe@example.com", 2112); Arsse::$db->folderPropertiesGet("john.doe@example.com", 2112);
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesGet */ #[CoversMethod(Database::class, "folderPropertiesGet")]
public function testGetThePropertiesOfAnInvalidFolder(): void { public function testGetThePropertiesOfAnInvalidFolder(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesGet("john.doe@example.com", -1); Arsse::$db->folderPropertiesGet("john.doe@example.com", -1);
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesGet */ #[CoversMethod(Database::class, "folderPropertiesGet")]
public function testGetThePropertiesOfAFolderOfTheWrongOwner(): void { public function testGetThePropertiesOfAFolderOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesGet("john.doe@example.com", 4); // folder ID 4 belongs to Jane Arsse::$db->folderPropertiesGet("john.doe@example.com", 4); // folder ID 4 belongs to Jane
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesSet */ #[CoversMethod(Database::class, "folderPropertiesSet")]
public function testMakeNoChangesToAFolder(): void { public function testMakeNoChangesToAFolder(): void {
$this->assertFalse(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, [])); $this->assertFalse(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, []));
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testRenameAFolder(): void { public function testRenameAFolder(): void {
$this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => "Opinion"])); $this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => "Opinion"]));
$state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]); $state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]);
@ -337,45 +311,35 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testRenameTheRootFolder(): void { public function testRenameTheRootFolder(): void {
$this->assertFalse(Arsse::$db->folderPropertiesSet("john.doe@example.com", null, ['name' => "Opinion"])); $this->assertFalse(Arsse::$db->folderPropertiesSet("john.doe@example.com", null, ['name' => "Opinion"]));
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testRenameAFolderToTheEmptyString(): void { public function testRenameAFolderToTheEmptyString(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => ""])); $this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => ""]));
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testRenameAFolderToWhitespaceOnly(): void { public function testRenameAFolderToWhitespaceOnly(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => " "])); $this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => " "]));
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName
*/
public function testRenameAFolderToAnInvalidValue(): void { public function testRenameAFolderToAnInvalidValue(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => []])); $this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['name' => []]));
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveAFolder(): void { public function testMoveAFolder(): void {
$this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['parent' => 5])); $this->assertTrue(Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['parent' => 5]));
$state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]); $state = $this->primeExpectations($this->data, ['arsse_folders' => ['id','owner', 'parent', 'name']]);
@ -383,83 +347,69 @@ trait SeriesFolder {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveTheRootFolder(): void { public function testMoveTheRootFolder(): void {
$this->assertException("circularDependence", "Db", "ExceptionInput"); $this->assertException("circularDependence", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 0, ['parent' => 1]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 0, ['parent' => 1]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveAFolderToItsDescendant(): void { public function testMoveAFolderToItsDescendant(): void {
$this->assertException("circularDependence", "Db", "ExceptionInput"); $this->assertException("circularDependence", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 3]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 3]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveAFolderToItself(): void { public function testMoveAFolderToItself(): void {
$this->assertException("circularDependence", "Db", "ExceptionInput"); $this->assertException("circularDependence", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 1]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 1]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveAFolderToAMissingParent(): void { public function testMoveAFolderToAMissingParent(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 2112]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => 2112]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testMoveAFolderToAnInvalidParent(): void { public function testMoveAFolderToAnInvalidParent(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => "ThisFolderDoesNotExist"]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 1, ['parent' => "ThisFolderDoesNotExist"]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testCauseAFolderCollision(): void { public function testCauseAFolderCollision(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['parent' => null]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 6, ['parent' => null]);
} }
/** #[CoversMethod(Database::class, "folderPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::folderPropertiesSet #[CoversMethod(Database::class, "folderValidateName")]
* @covers \JKingWeb\Arsse\Database::folderValidateName #[CoversMethod(Database::class, "folderValidateMove")]
* @covers \JKingWeb\Arsse\Database::folderValidateMove
*/
public function testCauseACompoundFolderCollision(): void { public function testCauseACompoundFolderCollision(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 3, ['parent' => null, 'name' => "Technology"]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 3, ['parent' => null, 'name' => "Technology"]);
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesSet */ #[CoversMethod(Database::class, "folderPropertiesSet")]
public function testSetThePropertiesOfAMissingFolder(): void { public function testSetThePropertiesOfAMissingFolder(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 2112, ['parent' => null]); Arsse::$db->folderPropertiesSet("john.doe@example.com", 2112, ['parent' => null]);
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesSet */ #[CoversMethod(Database::class, "folderPropertiesSet")]
public function testSetThePropertiesOfAnInvalidFolder(): void { public function testSetThePropertiesOfAnInvalidFolder(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", -1, ['parent' => null]); Arsse::$db->folderPropertiesSet("john.doe@example.com", -1, ['parent' => null]);
} }
/** @covers \JKingWeb\Arsse\Database::folderPropertiesSet */ #[CoversMethod(Database::class, "folderPropertiesSet")]
public function testSetThePropertiesOfAFolderForTheWrongOwner(): void { public function testSetThePropertiesOfAFolderForTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->folderPropertiesSet("john.doe@example.com", 4, ['parent' => null]); // folder ID 4 belongs to Jane Arsse::$db->folderPropertiesSet("john.doe@example.com", 4, ['parent' => null]); // folder ID 4 belongs to Jane

4
tests/cases/Database/SeriesIcon.php
View file

@ -9,6 +9,8 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesIcon { trait SeriesIcon {
protected function setUpSeriesIcon(): void { protected function setUpSeriesIcon(): void {
@ -84,7 +86,7 @@ trait SeriesIcon {
unset($this->data); unset($this->data);
} }
/** @covers \JKingWeb\Arsse\Database::iconList */ #[CoversMethod(Database::class, "iconList")]
public function testListTheIconsOfAUser() { public function testListTheIconsOfAUser() {
$exp = [ $exp = [
['id' => 1,'url' => 'http://localhost:8000/Icon/PNG', 'type' => 'image/png', 'data' => base64_decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMjHxIGmVAAAADUlEQVQYV2NgYGBgAAAABQABijPjAAAAAABJRU5ErkJggg==")], ['id' => 1,'url' => 'http://localhost:8000/Icon/PNG', 'type' => 'image/png', 'data' => base64_decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuMjHxIGmVAAAADUlEQVQYV2NgYGBgAAAABQABijPjAAAAAABJRU5ErkJggg==")],

253
tests/cases/Database/SeriesLabel.php
View file

@ -11,6 +11,7 @@ namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database; use JKingWeb\Arsse\Database;
use JKingWeb\Arsse\Context\Context; use JKingWeb\Arsse\Context\Context;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesLabel { trait SeriesLabel {
protected $checkLabels; protected $checkLabels;
@ -256,10 +257,8 @@ trait SeriesLabel {
unset($this->data, $this->checkLabels, $this->checkMembers, $this->user); unset($this->data, $this->checkLabels, $this->checkMembers, $this->user);
} }
/** #[CoversMethod(Database::class, "labelAdd")]
* @covers \JKingWeb\Arsse\Database::labelAdd #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testAddALabel(): void { public function testAddALabel(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$labelID = $this->nextID("arsse_labels"); $labelID = $this->nextID("arsse_labels");
@ -269,43 +268,35 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelAdd")]
* @covers \JKingWeb\Arsse\Database::labelAdd #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testAddADuplicateLabel(): void { public function testAddADuplicateLabel(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->labelAdd("john.doe@example.com", ['name' => "Interesting"]); Arsse::$db->labelAdd("john.doe@example.com", ['name' => "Interesting"]);
} }
/** #[CoversMethod(Database::class, "labelAdd")]
* @covers \JKingWeb\Arsse\Database::labelAdd #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testAddALabelWithAMissingName(): void { public function testAddALabelWithAMissingName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->labelAdd("john.doe@example.com", []); Arsse::$db->labelAdd("john.doe@example.com", []);
} }
/** #[CoversMethod(Database::class, "labelAdd")]
* @covers \JKingWeb\Arsse\Database::labelAdd #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testAddALabelWithABlankName(): void { public function testAddALabelWithABlankName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->labelAdd("john.doe@example.com", ['name' => ""]); Arsse::$db->labelAdd("john.doe@example.com", ['name' => ""]);
} }
/** #[CoversMethod(Database::class, "labelAdd")]
* @covers \JKingWeb\Arsse\Database::labelAdd #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testAddALabelWithAWhitespaceName(): void { public function testAddALabelWithAWhitespaceName(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
Arsse::$db->labelAdd("john.doe@example.com", ['name' => " "]); Arsse::$db->labelAdd("john.doe@example.com", ['name' => " "]);
} }
/** @covers \JKingWeb\Arsse\Database::labelList */ #[CoversMethod(Database::class, "labelList")]
public function testListLabels(): void { public function testListLabels(): void {
$exp = [ $exp = [
['id' => 2, 'name' => "Fascinating", 'articles' => 3, 'read' => 1], ['id' => 2, 'name' => "Fascinating", 'articles' => 3, 'read' => 1],
@ -321,10 +312,8 @@ trait SeriesLabel {
$this->assertResult($exp, Arsse::$db->labelList("jane.doe@example.com", false)); $this->assertResult($exp, Arsse::$db->labelList("jane.doe@example.com", false));
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveALabel(): void { public function testRemoveALabel(): void {
$this->assertTrue(Arsse::$db->labelRemove("john.doe@example.com", 1)); $this->assertTrue(Arsse::$db->labelRemove("john.doe@example.com", 1));
$state = $this->primeExpectations($this->data, $this->checkLabels); $state = $this->primeExpectations($this->data, $this->checkLabels);
@ -332,10 +321,8 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveALabelByName(): void { public function testRemoveALabelByName(): void {
$this->assertTrue(Arsse::$db->labelRemove("john.doe@example.com", "Interesting", true)); $this->assertTrue(Arsse::$db->labelRemove("john.doe@example.com", "Interesting", true));
$state = $this->primeExpectations($this->data, $this->checkLabels); $state = $this->primeExpectations($this->data, $this->checkLabels);
@ -343,46 +330,36 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveAMissingLabel(): void { public function testRemoveAMissingLabel(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelRemove("john.doe@example.com", 2112); Arsse::$db->labelRemove("john.doe@example.com", 2112);
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveAnInvalidLabel(): void { public function testRemoveAnInvalidLabel(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelRemove("john.doe@example.com", -1); Arsse::$db->labelRemove("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveAnInvalidLabelByName(): void { public function testRemoveAnInvalidLabelByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelRemove("john.doe@example.com", [], true); Arsse::$db->labelRemove("john.doe@example.com", [], true);
} }
/** #[CoversMethod(Database::class, "labelRemove")]
* @covers \JKingWeb\Arsse\Database::labelRemove #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testRemoveALabelOfTheWrongOwner(): void { public function testRemoveALabelOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelRemove("john.doe@example.com", 3); // label ID 3 belongs to Jane Arsse::$db->labelRemove("john.doe@example.com", 3); // label ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "labelPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testGetThePropertiesOfALabel(): void { public function testGetThePropertiesOfALabel(): void {
$exp = [ $exp = [
'id' => 2, 'id' => 2,
@ -394,56 +371,44 @@ trait SeriesLabel {
$this->assertArraySubset($exp, Arsse::$db->labelPropertiesGet("john.doe@example.com", "Fascinating", true)); $this->assertArraySubset($exp, Arsse::$db->labelPropertiesGet("john.doe@example.com", "Fascinating", true));
} }
/** #[CoversMethod(Database::class, "labelPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testGetThePropertiesOfAMissingLabel(): void { public function testGetThePropertiesOfAMissingLabel(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesGet("john.doe@example.com", 2112); Arsse::$db->labelPropertiesGet("john.doe@example.com", 2112);
} }
/** #[CoversMethod(Database::class, "labelPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testGetThePropertiesOfAnInvalidLabel(): void { public function testGetThePropertiesOfAnInvalidLabel(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesGet("john.doe@example.com", -1); Arsse::$db->labelPropertiesGet("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "labelPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testGetThePropertiesOfAnInvalidLabelByName(): void { public function testGetThePropertiesOfAnInvalidLabelByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesGet("john.doe@example.com", [], true); Arsse::$db->labelPropertiesGet("john.doe@example.com", [], true);
} }
/** #[CoversMethod(Database::class, "labelPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testGetThePropertiesOfALabelOfTheWrongOwner(): void { public function testGetThePropertiesOfALabelOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesGet("john.doe@example.com", 3); // label ID 3 belongs to Jane Arsse::$db->labelPropertiesGet("john.doe@example.com", 3); // label ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testMakeNoChangesToALabel(): void { public function testMakeNoChangesToALabel(): void {
$this->assertFalse(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, [])); $this->assertFalse(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, []));
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testRenameALabel(): void { public function testRenameALabel(): void {
$this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => "Curious"])); $this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => "Curious"]));
$state = $this->primeExpectations($this->data, $this->checkLabels); $state = $this->primeExpectations($this->data, $this->checkLabels);
@ -451,11 +416,9 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testRenameALabelByName(): void { public function testRenameALabelByName(): void {
$this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", "Interesting", ['name' => "Curious"], true)); $this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", "Interesting", ['name' => "Curious"], true));
$state = $this->primeExpectations($this->data, $this->checkLabels); $state = $this->primeExpectations($this->data, $this->checkLabels);
@ -463,90 +426,72 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testRenameALabelToTheEmptyString(): void { public function testRenameALabelToTheEmptyString(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => ""])); $this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => ""]));
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testRenameALabelToWhitespaceOnly(): void { public function testRenameALabelToWhitespaceOnly(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => " "])); $this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => " "]));
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testRenameALabelToAnInvalidValue(): void { public function testRenameALabelToAnInvalidValue(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => []])); $this->assertTrue(Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => []]));
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testCauseALabelCollision(): void { public function testCauseALabelCollision(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => "Fascinating"]); Arsse::$db->labelPropertiesSet("john.doe@example.com", 1, ['name' => "Fascinating"]);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testSetThePropertiesOfAMissingLabel(): void { public function testSetThePropertiesOfAMissingLabel(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesSet("john.doe@example.com", 2112, ['name' => "Exciting"]); Arsse::$db->labelPropertiesSet("john.doe@example.com", 2112, ['name' => "Exciting"]);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testSetThePropertiesOfAnInvalidLabel(): void { public function testSetThePropertiesOfAnInvalidLabel(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesSet("john.doe@example.com", -1, ['name' => "Exciting"]); Arsse::$db->labelPropertiesSet("john.doe@example.com", -1, ['name' => "Exciting"]);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testSetThePropertiesOfAnInvalidLabelByName(): void { public function testSetThePropertiesOfAnInvalidLabelByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesSet("john.doe@example.com", [], ['name' => "Exciting"], true); Arsse::$db->labelPropertiesSet("john.doe@example.com", [], ['name' => "Exciting"], true);
} }
/** #[CoversMethod(Database::class, "labelPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::labelPropertiesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId #[CoversMethod(Database::class, "labelValidateName")]
* @covers \JKingWeb\Arsse\Database::labelValidateName
*/
public function testSetThePropertiesOfALabelForTheWrongOwner(): void { public function testSetThePropertiesOfALabelForTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelPropertiesSet("john.doe@example.com", 3, ['name' => "Exciting"]); // label ID 3 belongs to Jane Arsse::$db->labelPropertiesSet("john.doe@example.com", 3, ['name' => "Exciting"]); // label ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "labelArticlesGet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testListLabelledArticles(): void { public function testListLabelledArticles(): void {
$exp = [1,19]; $exp = [1,19];
$this->assertEquals($exp, Arsse::$db->labelArticlesGet("john.doe@example.com", 1)); $this->assertEquals($exp, Arsse::$db->labelArticlesGet("john.doe@example.com", 1));
@ -559,28 +504,22 @@ trait SeriesLabel {
$this->assertEquals($exp, Arsse::$db->labelArticlesGet("john.doe@example.com", "Lonely", true)); $this->assertEquals($exp, Arsse::$db->labelArticlesGet("john.doe@example.com", "Lonely", true));
} }
/** #[CoversMethod(Database::class, "labelArticlesGet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testListLabelledArticlesForAMissingLabel(): void { public function testListLabelledArticlesForAMissingLabel(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->labelArticlesGet("john.doe@example.com", 3); Arsse::$db->labelArticlesGet("john.doe@example.com", 3);
} }
/** #[CoversMethod(Database::class, "labelArticlesGet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesGet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testListLabelledArticlesForAnInvalidLabel(): void { public function testListLabelledArticlesForAnInvalidLabel(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->labelArticlesGet("john.doe@example.com", -1); Arsse::$db->labelArticlesGet("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testApplyALabelToArticles(): void { public function testApplyALabelToArticles(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([2,5])); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([2,5]));
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -589,10 +528,8 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testClearALabelFromArticles(): void { public function testClearALabelFromArticles(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([1,5]), Database::ASSOC_REMOVE); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([1,5]), Database::ASSOC_REMOVE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -600,10 +537,8 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testApplyALabelToArticlesByName(): void { public function testApplyALabelToArticlesByName(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", "Interesting", (new Context)->articles([2,5]), Database::ASSOC_ADD, true); Arsse::$db->labelArticlesSet("john.doe@example.com", "Interesting", (new Context)->articles([2,5]), Database::ASSOC_ADD, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -612,10 +547,8 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testClearALabelFromArticlesByName(): void { public function testClearALabelFromArticlesByName(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", "Interesting", (new Context)->articles([1,5]), Database::ASSOC_REMOVE, true); Arsse::$db->labelArticlesSet("john.doe@example.com", "Interesting", (new Context)->articles([1,5]), Database::ASSOC_REMOVE, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -623,30 +556,24 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testApplyALabelToNoArticles(): void { public function testApplyALabelToNoArticles(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000])); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000]));
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testClearALabelFromNoArticles(): void { public function testClearALabelFromNoArticles(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000]), Database::ASSOC_REMOVE); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000]), Database::ASSOC_REMOVE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testReplaceArticlesOfALabel(): void { public function testReplaceArticlesOfALabel(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([2,5]), Database::ASSOC_REPLACE); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([2,5]), Database::ASSOC_REPLACE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -657,10 +584,8 @@ trait SeriesLabel {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "labelArticlesSet")]
* @covers \JKingWeb\Arsse\Database::labelArticlesSet #[CoversMethod(Database::class, "labelValidateId")]
* @covers \JKingWeb\Arsse\Database::labelValidateId
*/
public function testPurgeArticlesOfALabel(): void { public function testPurgeArticlesOfALabel(): void {
Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000]), Database::ASSOC_REPLACE); Arsse::$db->labelArticlesSet("john.doe@example.com", 1, (new Context)->articles([10000]), Database::ASSOC_REPLACE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);

13
tests/cases/Database/SeriesMeta.php
View file

@ -8,8 +8,9 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Test\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesMeta { trait SeriesMeta {
protected function setUpSeriesMeta(): void { protected function setUpSeriesMeta(): void {
@ -37,7 +38,7 @@ trait SeriesMeta {
unset($this->data); unset($this->data);
} }
/** @covers \JKingWeb\Arsse\Database::metaSet */ #[CoversMethod(Database::class, "metaSet")]
public function testAddANewValue(): void { public function testAddANewValue(): void {
$this->assertTrue(Arsse::$db->metaSet("favourite", "Cygnus X-1")); $this->assertTrue(Arsse::$db->metaSet("favourite", "Cygnus X-1"));
$state = $this->primeExpectations($this->data, ['arsse_meta' => ['key','value']]); $state = $this->primeExpectations($this->data, ['arsse_meta' => ['key','value']]);
@ -45,7 +46,7 @@ trait SeriesMeta {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::metaSet */ #[CoversMethod(Database::class, "metaSet")]
public function testAddANewTypedValue(): void { public function testAddANewTypedValue(): void {
$this->assertTrue(Arsse::$db->metaSet("answer", 42, "int")); $this->assertTrue(Arsse::$db->metaSet("answer", 42, "int"));
$this->assertTrue(Arsse::$db->metaSet("true", true, "bool")); $this->assertTrue(Arsse::$db->metaSet("true", true, "bool"));
@ -59,7 +60,7 @@ trait SeriesMeta {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::metaSet */ #[CoversMethod(Database::class, "metaSet")]
public function testChangeAnExistingValue(): void { public function testChangeAnExistingValue(): void {
$this->assertTrue(Arsse::$db->metaSet("album", "Hemispheres")); $this->assertTrue(Arsse::$db->metaSet("album", "Hemispheres"));
$state = $this->primeExpectations($this->data, ['arsse_meta' => ['key','value']]); $state = $this->primeExpectations($this->data, ['arsse_meta' => ['key','value']]);
@ -67,7 +68,7 @@ trait SeriesMeta {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::metaRemove */ #[CoversMethod(Database::class, "metaRemove")]
public function testRemoveAValue(): void { public function testRemoveAValue(): void {
$this->assertTrue(Arsse::$db->metaRemove("album")); $this->assertTrue(Arsse::$db->metaRemove("album"));
$this->assertFalse(Arsse::$db->metaRemove("album")); $this->assertFalse(Arsse::$db->metaRemove("album"));
@ -76,7 +77,7 @@ trait SeriesMeta {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::metaGet */ #[CoversMethod(Database::class, "metaGet")]
public function testRetrieveAValue(): void { public function testRetrieveAValue(): void {
$this->assertSame("".Database::SCHEMA_VERSION, Arsse::$db->metaGet("schema_version")); $this->assertSame("".Database::SCHEMA_VERSION, Arsse::$db->metaGet("schema_version"));
$this->assertSame("A Farewell to Kings", Arsse::$db->metaGet("album")); $this->assertSame("A Farewell to Kings", Arsse::$db->metaGet("album"));

21
tests/cases/Database/SeriesMiscellany.php
View file

@ -10,6 +10,7 @@ namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database; use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesMiscellany { trait SeriesMiscellany {
protected function setUpSeriesMiscellany(): void { protected function setUpSeriesMiscellany(): void {
@ -21,22 +22,18 @@ trait SeriesMiscellany {
protected function tearDownSeriesMiscellany(): void { protected function tearDownSeriesMiscellany(): void {
} }
/** #[CoversMethod(Database::class, "__construct")]
* @covers \JKingWeb\Arsse\Database::__construct #[CoversMethod(Database::class, "driverSchemaVersion")]
* @covers \JKingWeb\Arsse\Database::driverSchemaVersion #[CoversMethod(Database::class, "driverSchemaUpdate")]
* @covers \JKingWeb\Arsse\Database::driverSchemaUpdate
*/
public function testInitializeDatabase(): void { public function testInitializeDatabase(): void {
static::dbRaze(static::$drv); static::dbRaze(static::$drv);
$d = new Database(true); $d = new Database(true);
$this->assertSame(Database::SCHEMA_VERSION, $d->driverSchemaVersion()); $this->assertSame(Database::SCHEMA_VERSION, $d->driverSchemaVersion());
} }
/** #[CoversMethod(Database::class, "__construct")]
* @covers \JKingWeb\Arsse\Database::__construct #[CoversMethod(Database::class, "driverSchemaVersion")]
* @covers \JKingWeb\Arsse\Database::driverSchemaVersion #[CoversMethod(Database::class, "driverSchemaUpdate")]
* @covers \JKingWeb\Arsse\Database::driverSchemaUpdate
*/
public function testManuallyInitializeDatabase(): void { public function testManuallyInitializeDatabase(): void {
static::dbRaze(static::$drv); static::dbRaze(static::$drv);
$d = new Database(false); $d = new Database(false);
@ -46,12 +43,12 @@ trait SeriesMiscellany {
$this->assertFalse($d->driverSchemaUpdate()); $this->assertFalse($d->driverSchemaUpdate());
} }
/** @covers \JKingWeb\Arsse\Database::driverCharsetAcceptable */ #[CoversMethod(Database::class, "driverCharsetAcceptable")]
public function testCheckCharacterSetAcceptability(): void { public function testCheckCharacterSetAcceptability(): void {
$this->assertIsBool(Arsse::$db->driverCharsetAcceptable()); $this->assertIsBool(Arsse::$db->driverCharsetAcceptable());
} }
/** @covers \JKingWeb\Arsse\Database::driverMaintenance */ #[CoversMethod(Database::class, "driverMaintenance")]
public function testPerformMaintenance(): void { public function testPerformMaintenance(): void {
$this->assertTrue(Arsse::$db->driverMaintenance()); $this->assertTrue(Arsse::$db->driverMaintenance());
} }

34
tests/cases/Database/SeriesSession.php
View file

@ -10,6 +10,8 @@ namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Misc\Date; use JKingWeb\Arsse\Misc\Date;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesSession { trait SeriesSession {
protected function setUpSeriesSession(): void { protected function setUpSeriesSession(): void {
@ -56,10 +58,8 @@ trait SeriesSession {
unset($this->data); unset($this->data);
} }
/** #[CoversMethod(Database::class, "sessionResume")]
* @covers \JKingWeb\Arsse\Database::sessionResume #[CoversMethod(Database::class, "sessionExpiringSoon")]
* @covers \JKingWeb\Arsse\Database::sessionExpiringSoon
*/
public function testResumeAValidSession(): void { public function testResumeAValidSession(): void {
$exp1 = [ $exp1 = [
'id' => "80fa94c1a11f11e78667001e673b2560", 'id' => "80fa94c1a11f11e78667001e673b2560",
@ -78,34 +78,28 @@ trait SeriesSession {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "sessionResume")]
* @covers \JKingWeb\Arsse\Database::sessionResume #[CoversMethod(Database::class, "sessionExpiringSoon")]
* @covers \JKingWeb\Arsse\Database::sessionExpiringSoon
*/
public function testResumeAMissingSession(): void { public function testResumeAMissingSession(): void {
$this->assertException("invalid", "User", "ExceptionSession"); $this->assertException("invalid", "User", "ExceptionSession");
Arsse::$db->sessionResume("thisSessionDoesNotExist"); Arsse::$db->sessionResume("thisSessionDoesNotExist");
} }
/** #[CoversMethod(Database::class, "sessionResume")]
* @covers \JKingWeb\Arsse\Database::sessionResume #[CoversMethod(Database::class, "sessionExpiringSoon")]
* @covers \JKingWeb\Arsse\Database::sessionExpiringSoon
*/
public function testResumeAnExpiredSession(): void { public function testResumeAnExpiredSession(): void {
$this->assertException("invalid", "User", "ExceptionSession"); $this->assertException("invalid", "User", "ExceptionSession");
Arsse::$db->sessionResume("27c6de8da13311e78667001e673b2560"); Arsse::$db->sessionResume("27c6de8da13311e78667001e673b2560");
} }
/** #[CoversMethod(Database::class, "sessionResume")]
* @covers \JKingWeb\Arsse\Database::sessionResume #[CoversMethod(Database::class, "sessionExpiringSoon")]
* @covers \JKingWeb\Arsse\Database::sessionExpiringSoon
*/
public function testResumeAStaleSession(): void { public function testResumeAStaleSession(): void {
$this->assertException("invalid", "User", "ExceptionSession"); $this->assertException("invalid", "User", "ExceptionSession");
Arsse::$db->sessionResume("ab3b3eb8a13311e78667001e673b2560"); Arsse::$db->sessionResume("ab3b3eb8a13311e78667001e673b2560");
} }
/** @covers \JKingWeb\Arsse\Database::sessionCreate */ #[CoversMethod(Database::class, "sessionCreate")]
public function testCreateASession(): void { public function testCreateASession(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$id = Arsse::$db->sessionCreate($user); $id = Arsse::$db->sessionCreate($user);
@ -115,7 +109,7 @@ trait SeriesSession {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::sessionDestroy */ #[CoversMethod(Database::class, "sessionDestroy")]
public function testDestroyASession(): void { public function testDestroyASession(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$id = "80fa94c1a11f11e78667001e673b2560"; $id = "80fa94c1a11f11e78667001e673b2560";
@ -127,7 +121,7 @@ trait SeriesSession {
$this->assertFalse(Arsse::$db->sessionDestroy($user, $id)); $this->assertFalse(Arsse::$db->sessionDestroy($user, $id));
} }
/** @covers \JKingWeb\Arsse\Database::sessionDestroy */ #[CoversMethod(Database::class, "sessionDestroy")]
public function testDestroyAllSessions(): void { public function testDestroyAllSessions(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$this->assertTrue(Arsse::$db->sessionDestroy($user)); $this->assertTrue(Arsse::$db->sessionDestroy($user));
@ -138,7 +132,7 @@ trait SeriesSession {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::sessionDestroy */ #[CoversMethod(Database::class, "sessionDestroy")]
public function testDestroyASessionForTheWrongUser(): void { public function testDestroyASessionForTheWrongUser(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$id = "80fa94c1a11f11e78667001e673b2560"; $id = "80fa94c1a11f11e78667001e673b2560";

154
tests/cases/Database/SeriesSubscription.php
View file

@ -12,6 +12,8 @@ use GuzzleHttp\Exception\ClientException;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Test\Database; use JKingWeb\Arsse\Test\Database;
use JKingWeb\Arsse\Feed\Exception as FeedException; use JKingWeb\Arsse\Feed\Exception as FeedException;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\Attributes\DataProvider;
trait SeriesSubscription { trait SeriesSubscription {
public function setUpSeriesSubscription(): void { public function setUpSeriesSubscription(): void {
@ -205,10 +207,8 @@ trait SeriesSubscription {
unset($this->data, $this->user); unset($this->data, $this->user);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddASubscriptionToAnExistingFeed(): void { public function testAddASubscriptionToAnExistingFeed(): void {
$url = "http://example.com/feed1"; $url = "http://example.com/feed1";
$subID = $this->nextID("arsse_subscriptions"); $subID = $this->nextID("arsse_subscriptions");
@ -224,10 +224,8 @@ trait SeriesSubscription {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddASubscriptionToANewFeed(): void { public function testAddASubscriptionToANewFeed(): void {
$url = "http://example.org/feed1"; $url = "http://example.org/feed1";
$feedID = $this->nextID("arsse_feeds"); $feedID = $this->nextID("arsse_feeds");
@ -245,10 +243,8 @@ trait SeriesSubscription {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddASubscriptionToANewFeedViaDiscovery(): void { public function testAddASubscriptionToANewFeedViaDiscovery(): void {
$url = "http://localhost:8000/Feed/Discovery/Valid"; $url = "http://localhost:8000/Feed/Discovery/Valid";
$discovered = "http://localhost:8000/Feed/Discovery/Feed"; $discovered = "http://localhost:8000/Feed/Discovery/Feed";
@ -267,10 +263,8 @@ trait SeriesSubscription {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddASubscriptionToAnInvalidFeed(): void { public function testAddASubscriptionToAnInvalidFeed(): void {
$url = "http://example.org/feed1"; $url = "http://example.org/feed1";
$feedID = $this->nextID("arsse_feeds"); $feedID = $this->nextID("arsse_feeds");
@ -289,30 +283,24 @@ trait SeriesSubscription {
} }
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddADuplicateSubscription(): void { public function testAddADuplicateSubscription(): void {
$url = "http://example.com/feed2"; $url = "http://example.com/feed2";
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->subscriptionAdd($this->user, $url); Arsse::$db->subscriptionAdd($this->user, $url);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddADuplicateSubscriptionWithEquivalentUrl(): void { public function testAddADuplicateSubscriptionWithEquivalentUrl(): void {
$url = "http://EXAMPLE.COM/feed2"; $url = "http://EXAMPLE.COM/feed2";
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->subscriptionAdd($this->user, $url); Arsse::$db->subscriptionAdd($this->user, $url);
} }
/** #[CoversMethod(Database::class, "subscriptionAdd")]
* @covers \JKingWeb\Arsse\Database::subscriptionAdd #[CoversMethod(Database::class, "feedAdd")]
* @covers \JKingWeb\Arsse\Database::feedAdd
*/
public function testAddADuplicateSubscriptionViaRedirection(): void { public function testAddADuplicateSubscriptionViaRedirection(): void {
$url = "http://localhost:8000/Feed/Parsing/Valid"; $url = "http://localhost:8000/Feed/Parsing/Valid";
Arsse::$db->subscriptionAdd($this->user, $url); Arsse::$db->subscriptionAdd($this->user, $url);
@ -321,7 +309,7 @@ trait SeriesSubscription {
$this->assertSame($subID, Arsse::$db->subscriptionAdd($this->user, $url)); $this->assertSame($subID, Arsse::$db->subscriptionAdd($this->user, $url));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRemove */ #[CoversMethod(Database::class, "subscriptionRemove")]
public function testRemoveASubscription(): void { public function testRemoveASubscription(): void {
$this->assertTrue(Arsse::$db->subscriptionRemove($this->user, 1)); $this->assertTrue(Arsse::$db->subscriptionRemove($this->user, 1));
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -332,29 +320,27 @@ trait SeriesSubscription {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRemove */ #[CoversMethod(Database::class, "subscriptionRemove")]
public function testRemoveAMissingSubscription(): void { public function testRemoveAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionRemove($this->user, 2112); Arsse::$db->subscriptionRemove($this->user, 2112);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRemove */ #[CoversMethod(Database::class, "subscriptionRemove")]
public function testRemoveAnInvalidSubscription(): void { public function testRemoveAnInvalidSubscription(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->subscriptionRemove($this->user, -1); Arsse::$db->subscriptionRemove($this->user, -1);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRemove */ #[CoversMethod(Database::class, "subscriptionRemove")]
public function testRemoveASubscriptionForTheWrongOwner(): void { public function testRemoveASubscriptionForTheWrongOwner(): void {
$this->user = "jane.doe@example.com"; $this->user = "jane.doe@example.com";
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionRemove($this->user, 1); Arsse::$db->subscriptionRemove($this->user, 1);
} }
/** #[CoversMethod(Database::class, "subscriptionList")]
* @covers \JKingWeb\Arsse\Database::subscriptionList #[CoversMethod(Database::class, "subscriptionPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesGet
*/
public function testListSubscriptions(): void { public function testListSubscriptions(): void {
$exp = [ $exp = [
[ [
@ -415,7 +401,7 @@ trait SeriesSubscription {
$this->assertResult($exp, Arsse::$db->subscriptionList("jill.doe@example.com")); $this->assertResult($exp, Arsse::$db->subscriptionList("jill.doe@example.com"));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionList */ #[CoversMethod(Database::class, "subscriptionList")]
public function testListSubscriptionsInAFolder(): void { public function testListSubscriptionsInAFolder(): void {
$exp = [ $exp = [
[ [
@ -431,7 +417,7 @@ trait SeriesSubscription {
$this->assertResult($exp, Arsse::$db->subscriptionList($this->user, null, false)); $this->assertResult($exp, Arsse::$db->subscriptionList($this->user, null, false));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionList */ #[CoversMethod(Database::class, "subscriptionList")]
public function testListSubscriptionsWithRecursion(): void { public function testListSubscriptionsWithRecursion(): void {
$exp = [ $exp = [
[ [
@ -447,41 +433,39 @@ trait SeriesSubscription {
$this->assertResult($exp, Arsse::$db->subscriptionList($this->user, 2)); $this->assertResult($exp, Arsse::$db->subscriptionList($this->user, 2));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionList */ #[CoversMethod(Database::class, "subscriptionList")]
public function testListSubscriptionsInAMissingFolder(): void { public function testListSubscriptionsInAMissingFolder(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionList($this->user, 4); Arsse::$db->subscriptionList($this->user, 4);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionCount */ #[CoversMethod(Database::class, "subscriptionCount")]
public function testCountSubscriptions(): void { public function testCountSubscriptions(): void {
$this->assertSame(3, Arsse::$db->subscriptionCount($this->user)); $this->assertSame(3, Arsse::$db->subscriptionCount($this->user));
$this->assertSame(1, Arsse::$db->subscriptionCount($this->user, 2)); $this->assertSame(1, Arsse::$db->subscriptionCount($this->user, 2));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionCount */ #[CoversMethod(Database::class, "subscriptionCount")]
public function testCountSubscriptionsInAMissingFolder(): void { public function testCountSubscriptionsInAMissingFolder(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionCount($this->user, 4); Arsse::$db->subscriptionCount($this->user, 4);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionPropertiesGet */ #[CoversMethod(Database::class, "subscriptionPropertiesGet")]
public function testGetThePropertiesOfAMissingSubscription(): void { public function testGetThePropertiesOfAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesGet($this->user, 2112); Arsse::$db->subscriptionPropertiesGet($this->user, 2112);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionPropertiesGet */ #[CoversMethod(Database::class, "subscriptionPropertiesGet")]
public function testGetThePropertiesOfAnInvalidSubscription(): void { public function testGetThePropertiesOfAnInvalidSubscription(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesGet($this->user, -1); Arsse::$db->subscriptionPropertiesGet($this->user, -1);
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testSetThePropertiesOfASubscription(): void { public function testSetThePropertiesOfASubscription(): void {
Arsse::$db->subscriptionPropertiesSet($this->user, 1, [ Arsse::$db->subscriptionPropertiesSet($this->user, 1, [
'title' => "Ook Ook", 'title' => "Ook Ook",
@ -510,31 +494,25 @@ trait SeriesSubscription {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testMoveASubscriptionToAMissingFolder(): void { public function testMoveASubscriptionToAMissingFolder(): void {
$this->assertException("idMissing", "Db", "ExceptionInput"); $this->assertException("idMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesSet($this->user, 1, ['folder' => 4]); Arsse::$db->subscriptionPropertiesSet($this->user, 1, ['folder' => 4]);
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testMoveASubscriptionToTheRootFolder(): void { public function testMoveASubscriptionToTheRootFolder(): void {
$this->assertTrue(Arsse::$db->subscriptionPropertiesSet($this->user, 3, ['folder' => null])); $this->assertTrue(Arsse::$db->subscriptionPropertiesSet($this->user, 3, ['folder' => null]));
} }
/** #[DataProvider("provideInvalidSubscriptionProperties")]
* @dataProvider provideInvalidSubscriptionProperties #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testSetThePropertiesOfASubscriptionToInvalidValues(array $data, string $exp): void { public function testSetThePropertiesOfASubscriptionToInvalidValues(array $data, string $exp): void {
$this->assertException($exp, "Db", "ExceptionInput"); $this->assertException($exp, "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesSet($this->user, 1, $data); Arsse::$db->subscriptionPropertiesSet($this->user, 1, $data);
@ -552,36 +530,30 @@ trait SeriesSubscription {
]; ];
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testRenameASubscriptionToZero(): void { public function testRenameASubscriptionToZero(): void {
$this->assertTrue(Arsse::$db->subscriptionPropertiesSet($this->user, 1, ['title' => 0])); $this->assertTrue(Arsse::$db->subscriptionPropertiesSet($this->user, 1, ['title' => 0]));
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testSetThePropertiesOfAMissingSubscription(): void { public function testSetThePropertiesOfAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesSet($this->user, 2112, ['folder' => null]); Arsse::$db->subscriptionPropertiesSet($this->user, 2112, ['folder' => null]);
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testSetThePropertiesOfAnInvalidSubscription(): void { public function testSetThePropertiesOfAnInvalidSubscription(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->subscriptionPropertiesSet($this->user, -1, ['folder' => null]); Arsse::$db->subscriptionPropertiesSet($this->user, -1, ['folder' => null]);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionIcon */ #[CoversMethod(Database::class, "subscriptionIcon")]
public function testRetrieveTheFaviconOfASubscription(): void { public function testRetrieveTheFaviconOfASubscription(): void {
$exp = "http://example.com/favicon.ico"; $exp = "http://example.com/favicon.ico";
$this->assertSame($exp, Arsse::$db->subscriptionIcon(null, 1)['url']); $this->assertSame($exp, Arsse::$db->subscriptionIcon(null, 1)['url']);
@ -589,13 +561,13 @@ trait SeriesSubscription {
$this->assertSame(null, Arsse::$db->subscriptionIcon(null, 6)); $this->assertSame(null, Arsse::$db->subscriptionIcon(null, 6));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionIcon */ #[CoversMethod(Database::class, "subscriptionIcon")]
public function testRetrieveTheFaviconOfAMissingSubscription(): void { public function testRetrieveTheFaviconOfAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionIcon(null, -2112); Arsse::$db->subscriptionIcon(null, -2112);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionIcon */ #[CoversMethod(Database::class, "subscriptionIcon")]
public function testRetrieveTheFaviconOfASubscriptionWithUser(): void { public function testRetrieveTheFaviconOfASubscriptionWithUser(): void {
$exp = "http://example.com/favicon.ico"; $exp = "http://example.com/favicon.ico";
$user = "john.doe@example.com"; $user = "john.doe@example.com";
@ -605,14 +577,14 @@ trait SeriesSubscription {
$this->assertSame($exp, Arsse::$db->subscriptionIcon($user, 2)['url']); $this->assertSame($exp, Arsse::$db->subscriptionIcon($user, 2)['url']);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionIcon */ #[CoversMethod(Database::class, "subscriptionIcon")]
public function testRetrieveTheFaviconOfASubscriptionOfTheWrongUser(): void { public function testRetrieveTheFaviconOfASubscriptionOfTheWrongUser(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionIcon($user, 2); Arsse::$db->subscriptionIcon($user, 2);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionTagsGet */ #[CoversMethod(Database::class, "subscriptionTagsGet")]
public function testListTheTagsOfASubscription(): void { public function testListTheTagsOfASubscription(): void {
$this->assertEquals([1,2], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 1)); $this->assertEquals([1,2], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 1));
$this->assertEquals([2], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 3)); $this->assertEquals([2], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 3));
@ -620,30 +592,28 @@ trait SeriesSubscription {
$this->assertEquals(["Fascinating"], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 3, true)); $this->assertEquals(["Fascinating"], Arsse::$db->subscriptionTagsGet("john.doe@example.com", 3, true));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionTagsGet */ #[CoversMethod(Database::class, "subscriptionTagsGet")]
public function testListTheTagsOfAMissingSubscription(): void { public function testListTheTagsOfAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->subscriptionTagsGet($this->user, 101); Arsse::$db->subscriptionTagsGet($this->user, 101);
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRefreshed */ #[CoversMethod(Database::class, "subscriptionRefreshed")]
public function testGetRefreshTimeOfASubscription(): void { public function testGetRefreshTimeOfASubscription(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$this->assertTime(strtotime("now + 1 hour"), Arsse::$db->subscriptionRefreshed($user)); $this->assertTime(strtotime("now + 1 hour"), Arsse::$db->subscriptionRefreshed($user));
$this->assertTime(strtotime("now - 1 hour"), Arsse::$db->subscriptionRefreshed($user, 1)); $this->assertTime(strtotime("now - 1 hour"), Arsse::$db->subscriptionRefreshed($user, 1));
} }
/** @covers \JKingWeb\Arsse\Database::subscriptionRefreshed */ #[CoversMethod(Database::class, "subscriptionRefreshed")]
public function testGetRefreshTimeOfAMissingSubscription(): void { public function testGetRefreshTimeOfAMissingSubscription(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
$this->assertTime(strtotime("now - 1 hour"), Arsse::$db->subscriptionRefreshed("john.doe@example.com", 2)); $this->assertTime(strtotime("now - 1 hour"), Arsse::$db->subscriptionRefreshed("john.doe@example.com", 2));
} }
/** #[CoversMethod(Database::class, "subscriptionPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::subscriptionPropertiesSet #[CoversMethod(Database::class, "subscriptionValidateId")]
* @covers \JKingWeb\Arsse\Database::subscriptionValidateId #[CoversMethod(Database::class, "subscriptionRulesApply")]
* @covers \JKingWeb\Arsse\Database::subscriptionRulesApply
*/
public function testSetTheFilterRulesOfASubscriptionCheckingMarks(): void { public function testSetTheFilterRulesOfASubscriptionCheckingMarks(): void {
Arsse::$db->subscriptionPropertiesSet("jack.doe@example.com", 5, ['keep_rule' => "1|B|3|D", 'block_rule' => "4"]); Arsse::$db->subscriptionPropertiesSet("jack.doe@example.com", 5, ['keep_rule' => "1|B|3|D", 'block_rule' => "4"]);
$state = $this->primeExpectations($this->data, ['arsse_marks' => ['article', 'subscription', 'hidden']]); $state = $this->primeExpectations($this->data, ['arsse_marks' => ['article', 'subscription', 'hidden']]);

255
tests/cases/Database/SeriesTag.php
View file

@ -10,6 +10,7 @@ namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database; use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesTag { trait SeriesTag {
protected $checkMembers; protected $checkMembers;
@ -114,10 +115,8 @@ trait SeriesTag {
unset($this->data, $this->checkTags, $this->checkMembers, $this->user); unset($this->data, $this->checkTags, $this->checkMembers, $this->user);
} }
/** #[CoversMethod(Database::class, "tagAdd")]
* @covers \JKingWeb\Arsse\Database::tagAdd #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testAddATag(): void { public function testAddATag(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$tagID = $this->nextID("arsse_tags"); $tagID = $this->nextID("arsse_tags");
@ -127,43 +126,35 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagAdd")]
* @covers \JKingWeb\Arsse\Database::tagAdd #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testAddADuplicateTag(): void { public function testAddADuplicateTag(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->tagAdd("john.doe@example.com", ['name' => "Interesting"]); Arsse::$db->tagAdd("john.doe@example.com", ['name' => "Interesting"]);
} }
/** #[CoversMethod(Database::class, "tagAdd")]
* @covers \JKingWeb\Arsse\Database::tagAdd #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testAddATagWithAMissingName(): void { public function testAddATagWithAMissingName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->tagAdd("john.doe@example.com", []); Arsse::$db->tagAdd("john.doe@example.com", []);
} }
/** #[CoversMethod(Database::class, "tagAdd")]
* @covers \JKingWeb\Arsse\Database::tagAdd #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testAddATagWithABlankName(): void { public function testAddATagWithABlankName(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
Arsse::$db->tagAdd("john.doe@example.com", ['name' => ""]); Arsse::$db->tagAdd("john.doe@example.com", ['name' => ""]);
} }
/** #[CoversMethod(Database::class, "tagAdd")]
* @covers \JKingWeb\Arsse\Database::tagAdd #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testAddATagWithAWhitespaceName(): void { public function testAddATagWithAWhitespaceName(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
Arsse::$db->tagAdd("john.doe@example.com", ['name' => " "]); Arsse::$db->tagAdd("john.doe@example.com", ['name' => " "]);
} }
/** @covers \JKingWeb\Arsse\Database::tagList */ #[CoversMethod(Database::class, "tagList")]
public function testListTags(): void { public function testListTags(): void {
$exp = [ $exp = [
['id' => 2, 'name' => "Fascinating"], ['id' => 2, 'name' => "Fascinating"],
@ -179,10 +170,8 @@ trait SeriesTag {
$this->assertResult($exp, Arsse::$db->tagList("jane.doe@example.com", false)); $this->assertResult($exp, Arsse::$db->tagList("jane.doe@example.com", false));
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveATag(): void { public function testRemoveATag(): void {
$this->assertTrue(Arsse::$db->tagRemove("john.doe@example.com", 1)); $this->assertTrue(Arsse::$db->tagRemove("john.doe@example.com", 1));
$state = $this->primeExpectations($this->data, $this->checkTags); $state = $this->primeExpectations($this->data, $this->checkTags);
@ -190,10 +179,8 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveATagByName(): void { public function testRemoveATagByName(): void {
$this->assertTrue(Arsse::$db->tagRemove("john.doe@example.com", "Interesting", true)); $this->assertTrue(Arsse::$db->tagRemove("john.doe@example.com", "Interesting", true));
$state = $this->primeExpectations($this->data, $this->checkTags); $state = $this->primeExpectations($this->data, $this->checkTags);
@ -201,46 +188,36 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveAMissingTag(): void { public function testRemoveAMissingTag(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagRemove("john.doe@example.com", 2112); Arsse::$db->tagRemove("john.doe@example.com", 2112);
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveAnInvalidTag(): void { public function testRemoveAnInvalidTag(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagRemove("john.doe@example.com", -1); Arsse::$db->tagRemove("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveAnInvalidTagByName(): void { public function testRemoveAnInvalidTagByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagRemove("john.doe@example.com", [], true); Arsse::$db->tagRemove("john.doe@example.com", [], true);
} }
/** #[CoversMethod(Database::class, "tagRemove")]
* @covers \JKingWeb\Arsse\Database::tagRemove #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testRemoveATagOfTheWrongOwner(): void { public function testRemoveATagOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagRemove("john.doe@example.com", 3); // tag ID 3 belongs to Jane Arsse::$db->tagRemove("john.doe@example.com", 3); // tag ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "tagPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testGetThePropertiesOfATag(): void { public function testGetThePropertiesOfATag(): void {
$exp = [ $exp = [
'id' => 2, 'id' => 2,
@ -250,56 +227,44 @@ trait SeriesTag {
$this->assertArraySubset($exp, Arsse::$db->tagPropertiesGet("john.doe@example.com", "Fascinating", true)); $this->assertArraySubset($exp, Arsse::$db->tagPropertiesGet("john.doe@example.com", "Fascinating", true));
} }
/** #[CoversMethod(Database::class, "tagPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testGetThePropertiesOfAMissingTag(): void { public function testGetThePropertiesOfAMissingTag(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesGet("john.doe@example.com", 2112); Arsse::$db->tagPropertiesGet("john.doe@example.com", 2112);
} }
/** #[CoversMethod(Database::class, "tagPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testGetThePropertiesOfAnInvalidTag(): void { public function testGetThePropertiesOfAnInvalidTag(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesGet("john.doe@example.com", -1); Arsse::$db->tagPropertiesGet("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "tagPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testGetThePropertiesOfAnInvalidTagByName(): void { public function testGetThePropertiesOfAnInvalidTagByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesGet("john.doe@example.com", [], true); Arsse::$db->tagPropertiesGet("john.doe@example.com", [], true);
} }
/** #[CoversMethod(Database::class, "tagPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testGetThePropertiesOfATagOfTheWrongOwner(): void { public function testGetThePropertiesOfATagOfTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesGet("john.doe@example.com", 3); // tag ID 3 belongs to Jane Arsse::$db->tagPropertiesGet("john.doe@example.com", 3); // tag ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testMakeNoChangesToATag(): void { public function testMakeNoChangesToATag(): void {
$this->assertFalse(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, [])); $this->assertFalse(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, []));
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testRenameATag(): void { public function testRenameATag(): void {
$this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => "Curious"])); $this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => "Curious"]));
$state = $this->primeExpectations($this->data, $this->checkTags); $state = $this->primeExpectations($this->data, $this->checkTags);
@ -307,11 +272,9 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testRenameATagByName(): void { public function testRenameATagByName(): void {
$this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", "Interesting", ['name' => "Curious"], true)); $this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", "Interesting", ['name' => "Curious"], true));
$state = $this->primeExpectations($this->data, $this->checkTags); $state = $this->primeExpectations($this->data, $this->checkTags);
@ -319,90 +282,72 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testRenameATagToTheEmptyString(): void { public function testRenameATagToTheEmptyString(): void {
$this->assertException("missing", "Db", "ExceptionInput"); $this->assertException("missing", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => ""])); $this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => ""]));
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testRenameATagToWhitespaceOnly(): void { public function testRenameATagToWhitespaceOnly(): void {
$this->assertException("whitespace", "Db", "ExceptionInput"); $this->assertException("whitespace", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => " "])); $this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => " "]));
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testRenameATagToAnInvalidValue(): void { public function testRenameATagToAnInvalidValue(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
$this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => []])); $this->assertTrue(Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => []]));
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testCauseATagCollision(): void { public function testCauseATagCollision(): void {
$this->assertException("constraintViolation", "Db", "ExceptionInput"); $this->assertException("constraintViolation", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => "Fascinating"]); Arsse::$db->tagPropertiesSet("john.doe@example.com", 1, ['name' => "Fascinating"]);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testSetThePropertiesOfAMissingTag(): void { public function testSetThePropertiesOfAMissingTag(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesSet("john.doe@example.com", 2112, ['name' => "Exciting"]); Arsse::$db->tagPropertiesSet("john.doe@example.com", 2112, ['name' => "Exciting"]);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testSetThePropertiesOfAnInvalidTag(): void { public function testSetThePropertiesOfAnInvalidTag(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesSet("john.doe@example.com", -1, ['name' => "Exciting"]); Arsse::$db->tagPropertiesSet("john.doe@example.com", -1, ['name' => "Exciting"]);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testSetThePropertiesOfAnInvalidTagByName(): void { public function testSetThePropertiesOfAnInvalidTagByName(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesSet("john.doe@example.com", [], ['name' => "Exciting"], true); Arsse::$db->tagPropertiesSet("john.doe@example.com", [], ['name' => "Exciting"], true);
} }
/** #[CoversMethod(Database::class, "tagPropertiesSet")]
* @covers \JKingWeb\Arsse\Database::tagPropertiesSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId #[CoversMethod(Database::class, "tagValidateName")]
* @covers \JKingWeb\Arsse\Database::tagValidateName
*/
public function testSetThePropertiesOfATagForTheWrongOwner(): void { public function testSetThePropertiesOfATagForTheWrongOwner(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagPropertiesSet("john.doe@example.com", 3, ['name' => "Exciting"]); // tag ID 3 belongs to Jane Arsse::$db->tagPropertiesSet("john.doe@example.com", 3, ['name' => "Exciting"]); // tag ID 3 belongs to Jane
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsGet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testListTaggedSubscriptions(): void { public function testListTaggedSubscriptions(): void {
$exp = [1,5]; $exp = [1,5];
$this->assertEquals($exp, Arsse::$db->tagSubscriptionsGet("john.doe@example.com", 1)); $this->assertEquals($exp, Arsse::$db->tagSubscriptionsGet("john.doe@example.com", 1));
@ -415,28 +360,22 @@ trait SeriesTag {
$this->assertEquals($exp, Arsse::$db->tagSubscriptionsGet("john.doe@example.com", "Lonely", true)); $this->assertEquals($exp, Arsse::$db->tagSubscriptionsGet("john.doe@example.com", "Lonely", true));
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsGet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testListTaggedSubscriptionsForAMissingTag(): void { public function testListTaggedSubscriptionsForAMissingTag(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tagSubscriptionsGet("john.doe@example.com", 3); Arsse::$db->tagSubscriptionsGet("john.doe@example.com", 3);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsGet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsGet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testListTaggedSubscriptionsForAnInvalidTag(): void { public function testListTaggedSubscriptionsForAnInvalidTag(): void {
$this->assertException("typeViolation", "Db", "ExceptionInput"); $this->assertException("typeViolation", "Db", "ExceptionInput");
Arsse::$db->tagSubscriptionsGet("john.doe@example.com", -1); Arsse::$db->tagSubscriptionsGet("john.doe@example.com", -1);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testApplyATagToSubscriptions(): void { public function testApplyATagToSubscriptions(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [3,4]); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [3,4]);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -445,10 +384,8 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testClearATagFromSubscriptions(): void { public function testClearATagFromSubscriptions(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [1,3], Database::ASSOC_REMOVE); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [1,3], Database::ASSOC_REMOVE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -456,10 +393,8 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testApplyATagToSubscriptionsByName(): void { public function testApplyATagToSubscriptionsByName(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [3,4], Database::ASSOC_ADD, true); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [3,4], Database::ASSOC_ADD, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -468,10 +403,8 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testClearATagFromSubscriptionsByName(): void { public function testClearATagFromSubscriptionsByName(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [1,3], Database::ASSOC_REMOVE, true); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [1,3], Database::ASSOC_REMOVE, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -479,30 +412,24 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testApplyATagToNoSubscriptionsByName(): void { public function testApplyATagToNoSubscriptionsByName(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [], Database::ASSOC_ADD, true); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [], Database::ASSOC_ADD, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testClearATagFromNoSubscriptionsByName(): void { public function testClearATagFromNoSubscriptionsByName(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [], Database::ASSOC_REMOVE, true); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", "Interesting", [], Database::ASSOC_REMOVE, true);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testReplaceSubscriptionsOfATag(): void { public function testReplaceSubscriptionsOfATag(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [3,4], Database::ASSOC_REPLACE); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [3,4], Database::ASSOC_REPLACE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -513,10 +440,8 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** #[CoversMethod(Database::class, "tagSubscriptionsSet")]
* @covers \JKingWeb\Arsse\Database::tagSubscriptionsSet #[CoversMethod(Database::class, "tagValidateId")]
* @covers \JKingWeb\Arsse\Database::tagValidateId
*/
public function testPurgeSubscriptionsOfATag(): void { public function testPurgeSubscriptionsOfATag(): void {
Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [], Database::ASSOC_REPLACE); Arsse::$db->tagSubscriptionsSet("john.doe@example.com", 1, [], Database::ASSOC_REPLACE);
$state = $this->primeExpectations($this->data, $this->checkMembers); $state = $this->primeExpectations($this->data, $this->checkMembers);
@ -525,7 +450,7 @@ trait SeriesTag {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::tagSummarize */ #[CoversMethod(Database::class, "tagSummarize")]
public function testSummarizeTags(): void { public function testSummarizeTags(): void {
$exp = [ $exp = [
['id' => 1, 'name' => "Interesting", 'subscription' => 1], ['id' => 1, 'name' => "Interesting", 'subscription' => 1],

20
tests/cases/Database/SeriesToken.php
View file

@ -9,6 +9,8 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
trait SeriesToken { trait SeriesToken {
protected function setUpSeriesToken(): void { protected function setUpSeriesToken(): void {
@ -54,7 +56,7 @@ trait SeriesToken {
unset($this->data); unset($this->data);
} }
/** @covers \JKingWeb\Arsse\Database::tokenLookup */ #[CoversMethod(Database::class, "tokenLookup")]
public function testLookUpAValidToken(): void { public function testLookUpAValidToken(): void {
$exp1 = [ $exp1 = [
'id' => "80fa94c1a11f11e78667001e673b2560", 'id' => "80fa94c1a11f11e78667001e673b2560",
@ -76,25 +78,25 @@ trait SeriesToken {
$this->assertArraySubset($exp3, Arsse::$db->tokenLookup("class.class", "ab3b3eb8a13311e78667001e673b2560")); $this->assertArraySubset($exp3, Arsse::$db->tokenLookup("class.class", "ab3b3eb8a13311e78667001e673b2560"));
} }
/** @covers \JKingWeb\Arsse\Database::tokenLookup */ #[CoversMethod(Database::class, "tokenLookup")]
public function testLookUpAMissingToken(): void { public function testLookUpAMissingToken(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tokenLookup("class", "thisTokenDoesNotExist"); Arsse::$db->tokenLookup("class", "thisTokenDoesNotExist");
} }
/** @covers \JKingWeb\Arsse\Database::tokenLookup */ #[CoversMethod(Database::class, "tokenLookup")]
public function testLookUpAnExpiredToken(): void { public function testLookUpAnExpiredToken(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tokenLookup("fever.login", "27c6de8da13311e78667001e673b2560"); Arsse::$db->tokenLookup("fever.login", "27c6de8da13311e78667001e673b2560");
} }
/** @covers \JKingWeb\Arsse\Database::tokenLookup */ #[CoversMethod(Database::class, "tokenLookup")]
public function testLookUpATokenOfTheWrongClass(): void { public function testLookUpATokenOfTheWrongClass(): void {
$this->assertException("subjectMissing", "Db", "ExceptionInput"); $this->assertException("subjectMissing", "Db", "ExceptionInput");
Arsse::$db->tokenLookup("some.class", "80fa94c1a11f11e78667001e673b2560"); Arsse::$db->tokenLookup("some.class", "80fa94c1a11f11e78667001e673b2560");
} }
/** @covers \JKingWeb\Arsse\Database::tokenCreate */ #[CoversMethod(Database::class, "tokenCreate")]
public function testCreateAToken(): void { public function testCreateAToken(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$state = $this->primeExpectations($this->data, ['arsse_tokens' => ["id", "class", "expires", "user"]]); $state = $this->primeExpectations($this->data, ['arsse_tokens' => ["id", "class", "expires", "user"]]);
@ -109,13 +111,13 @@ trait SeriesToken {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::tokenCreate */ #[CoversMethod(Database::class, "tokenCreate")]
public function testCreateATokenForAMissingUser(): void { public function testCreateATokenForAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->tokenCreate("fever.login", "jane.doe@example.biz"); Arsse::$db->tokenCreate("fever.login", "jane.doe@example.biz");
} }
/** @covers \JKingWeb\Arsse\Database::tokenRevoke */ #[CoversMethod(Database::class, "tokenRevoke")]
public function testRevokeAToken(): void { public function testRevokeAToken(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$id = "80fa94c1a11f11e78667001e673b2560"; $id = "80fa94c1a11f11e78667001e673b2560";
@ -127,7 +129,7 @@ trait SeriesToken {
$this->assertFalse(Arsse::$db->tokenRevoke($user, "fever.login", $id)); $this->assertFalse(Arsse::$db->tokenRevoke($user, "fever.login", $id));
} }
/** @covers \JKingWeb\Arsse\Database::tokenRevoke */ #[CoversMethod(Database::class, "tokenRevoke")]
public function testRevokeAllTokens(): void { public function testRevokeAllTokens(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$state = $this->primeExpectations($this->data, ['arsse_tokens' => ["id", "expires", "user"]]); $state = $this->primeExpectations($this->data, ['arsse_tokens' => ["id", "expires", "user"]]);
@ -142,7 +144,7 @@ trait SeriesToken {
$this->assertFalse(Arsse::$db->tokenRevoke($user, "unknown.class")); $this->assertFalse(Arsse::$db->tokenRevoke($user, "unknown.class"));
} }
/** @covers \JKingWeb\Arsse\Database::tokenList */ #[CoversMethod(Database::class, "tokenList")]
public function testListTokens(): void { public function testListTokens(): void {
$user = "jane.doe@example.com"; $user = "jane.doe@example.com";
$exp = [ $exp = [

53
tests/cases/Database/SeriesUser.php
View file

@ -9,6 +9,9 @@ declare(strict_types=1);
namespace JKingWeb\Arsse\TestCase\Database; namespace JKingWeb\Arsse\TestCase\Database;
use JKingWeb\Arsse\Arsse; use JKingWeb\Arsse\Arsse;
use JKingWeb\Arsse\Database;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\Attributes\DataProvider;
trait SeriesUser { trait SeriesUser {
protected function setUpSeriesUser(): void { protected function setUpSeriesUser(): void {
@ -49,27 +52,27 @@ trait SeriesUser {
unset($this->data); unset($this->data);
} }
/** @covers \JKingWeb\Arsse\Database::userExists */ #[CoversMethod(Database::class, "userExists")]
public function testCheckThatAUserExists(): void { public function testCheckThatAUserExists(): void {
$this->assertTrue(Arsse::$db->userExists("jane.doe@example.com")); $this->assertTrue(Arsse::$db->userExists("jane.doe@example.com"));
$this->assertFalse(Arsse::$db->userExists("jane.doe@example.org")); $this->assertFalse(Arsse::$db->userExists("jane.doe@example.org"));
$this->compareExpectations(static::$drv, $this->data); $this->compareExpectations(static::$drv, $this->data);
} }
/** @covers \JKingWeb\Arsse\Database::userPasswordGet */ #[CoversMethod(Database::class, "userPasswordGet")]
public function testGetAPassword(): void { public function testGetAPassword(): void {
$hash = Arsse::$db->userPasswordGet("admin@example.net"); $hash = Arsse::$db->userPasswordGet("admin@example.net");
$this->assertSame('$2y$10$PbcG2ZR3Z8TuPzM7aHTF8.v61dtCjzjK78gdZJcp4UePE8T9jEgBW', $hash); $this->assertSame('$2y$10$PbcG2ZR3Z8TuPzM7aHTF8.v61dtCjzjK78gdZJcp4UePE8T9jEgBW', $hash);
$this->assertTrue(password_verify("secret", $hash)); $this->assertTrue(password_verify("secret", $hash));
} }
/** @covers \JKingWeb\Arsse\Database::userPasswordGet */ #[CoversMethod(Database::class, "userPasswordGet")]
public function testGetThePasswordOfAMissingUser(): void { public function testGetThePasswordOfAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userPasswordGet("john.doe@example.org"); Arsse::$db->userPasswordGet("john.doe@example.org");
} }
/** @covers \JKingWeb\Arsse\Database::userAdd */ #[CoversMethod(Database::class, "userAdd")]
public function testAddANewUser(): void { public function testAddANewUser(): void {
$this->assertTrue(Arsse::$db->userAdd("john.doe@example.org", "")); $this->assertTrue(Arsse::$db->userAdd("john.doe@example.org", ""));
$state = $this->primeExpectations($this->data, ['arsse_users' => ['id']]); $state = $this->primeExpectations($this->data, ['arsse_users' => ['id']]);
@ -77,13 +80,13 @@ trait SeriesUser {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::userAdd */ #[CoversMethod(Database::class, "userAdd")]
public function testAddAnExistingUser(): void { public function testAddAnExistingUser(): void {
$this->assertException("alreadyExists", "User", "ExceptionConflict"); $this->assertException("alreadyExists", "User", "ExceptionConflict");
Arsse::$db->userAdd("john.doe@example.com", ""); Arsse::$db->userAdd("john.doe@example.com", "");
} }
/** @covers \JKingWeb\Arsse\Database::userRemove */ #[CoversMethod(Database::class, "userRemove")]
public function testRemoveAUser(): void { public function testRemoveAUser(): void {
$this->assertTrue(Arsse::$db->userRemove("admin@example.net")); $this->assertTrue(Arsse::$db->userRemove("admin@example.net"));
$state = $this->primeExpectations($this->data, ['arsse_users' => ['id']]); $state = $this->primeExpectations($this->data, ['arsse_users' => ['id']]);
@ -91,19 +94,19 @@ trait SeriesUser {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::userRemove */ #[CoversMethod(Database::class, "userRemove")]
public function testRemoveAMissingUser(): void { public function testRemoveAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userRemove("john.doe@example.org"); Arsse::$db->userRemove("john.doe@example.org");
} }
/** @covers \JKingWeb\Arsse\Database::userList */ #[CoversMethod(Database::class, "userList")]
public function testListAllUsers(): void { public function testListAllUsers(): void {
$users = ["admin@example.net", "jane.doe@example.com", "john.doe@example.com"]; $users = ["admin@example.net", "jane.doe@example.com", "john.doe@example.com"];
$this->assertSame($users, Arsse::$db->userList()); $this->assertSame($users, Arsse::$db->userList());
} }
/** @covers \JKingWeb\Arsse\Database::userPasswordSet */ #[CoversMethod(Database::class, "userPasswordSet")]
public function testSetAPassword(): void { public function testSetAPassword(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$pass = "secret"; $pass = "secret";
@ -114,7 +117,7 @@ trait SeriesUser {
$this->assertTrue(password_verify($pass, $hash), "Failed verifying password of $user '$pass' against hash '$hash'."); $this->assertTrue(password_verify($pass, $hash), "Failed verifying password of $user '$pass' against hash '$hash'.");
} }
/** @covers \JKingWeb\Arsse\Database::userPasswordSet */ #[CoversMethod(Database::class, "userPasswordSet")]
public function testUnsetAPassword(): void { public function testUnsetAPassword(): void {
$user = "john.doe@example.com"; $user = "john.doe@example.com";
$this->assertEquals("", Arsse::$db->userPasswordGet($user)); $this->assertEquals("", Arsse::$db->userPasswordGet($user));
@ -122,16 +125,14 @@ trait SeriesUser {
$this->assertNull(Arsse::$db->userPasswordGet($user)); $this->assertNull(Arsse::$db->userPasswordGet($user));
} }
/** @covers \JKingWeb\Arsse\Database::userPasswordSet */ #[CoversMethod(Database::class, "userPasswordSet")]
public function testSetThePasswordOfAMissingUser(): void { public function testSetThePasswordOfAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userPasswordSet("john.doe@example.org", "secret"); Arsse::$db->userPasswordSet("john.doe@example.org", "secret");
} }
/** #[DataProvider("provideMetaData")]
* @dataProvider provideMetaData #[CoversMethod(Database::class, "userPropertiesGet")]
* @covers \JKingWeb\Arsse\Database::userPropertiesGet
*/
public function testGetMetadata(string $user, bool $includeLarge, array $exp): void { public function testGetMetadata(string $user, bool $includeLarge, array $exp): void {
$this->assertSame($exp, Arsse::$db->userPropertiesGet($user, $includeLarge)); $this->assertSame($exp, Arsse::$db->userPropertiesGet($user, $includeLarge));
} }
@ -147,13 +148,13 @@ trait SeriesUser {
]; ];
} }
/** @covers \JKingWeb\Arsse\Database::userPropertiesGet */ #[CoversMethod(Database::class, "userPropertiesGet")]
public function testGetTheMetadataOfAMissingUser(): void { public function testGetTheMetadataOfAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userPropertiesGet("john.doe@example.org"); Arsse::$db->userPropertiesGet("john.doe@example.org");
} }
/** @covers \JKingWeb\Arsse\Database::userPropertiesSet */ #[CoversMethod(Database::class, "userPropertiesSet")]
public function testSetMetadata(): void { public function testSetMetadata(): void {
$in = [ $in = [
'admin' => true, 'admin' => true,
@ -170,7 +171,7 @@ trait SeriesUser {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::userPropertiesSet */ #[CoversMethod(Database::class, "userPropertiesSet")]
public function testSetNoMetadata(): void { public function testSetNoMetadata(): void {
$in = [ $in = [
'num' => 2112, 'num' => 2112,
@ -181,26 +182,26 @@ trait SeriesUser {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::userPropertiesSet */ #[CoversMethod(Database::class, "userPropertiesSet")]
public function testSetTheMetadataOfAMissingUser(): void { public function testSetTheMetadataOfAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userPropertiesSet("john.doe@example.org", ['admin' => true]); Arsse::$db->userPropertiesSet("john.doe@example.org", ['admin' => true]);
} }
/** @covers \JKingWeb\Arsse\Database::userLookup */ #[CoversMethod(Database::class, "userLookup")]
public function testLookUpAUserByNumber(): void { public function testLookUpAUserByNumber(): void {
$this->assertSame("admin@example.net", Arsse::$db->userLookup(1)); $this->assertSame("admin@example.net", Arsse::$db->userLookup(1));
$this->assertSame("jane.doe@example.com", Arsse::$db->userLookup(2)); $this->assertSame("jane.doe@example.com", Arsse::$db->userLookup(2));
$this->assertSame("john.doe@example.com", Arsse::$db->userLookup(3)); $this->assertSame("john.doe@example.com", Arsse::$db->userLookup(3));
} }
/** @covers \JKingWeb\Arsse\Database::userLookup */ #[CoversMethod(Database::class, "userLookup")]
public function testLookUpAMissingUserByNumber(): void { public function testLookUpAMissingUserByNumber(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userLookup(2112); Arsse::$db->userLookup(2112);
} }
/** @covers \JKingWeb\Arsse\Database::userRename */ #[CoversMethod(Database::class, "userRename")]
public function testRenameAUser(): void { public function testRenameAUser(): void {
$this->assertTrue(Arsse::$db->userRename("john.doe@example.com", "juan.doe@example.com")); $this->assertTrue(Arsse::$db->userRename("john.doe@example.com", "juan.doe@example.com"));
$state = $this->primeExpectations($this->data, [ $state = $this->primeExpectations($this->data, [
@ -212,24 +213,24 @@ trait SeriesUser {
$this->compareExpectations(static::$drv, $state); $this->compareExpectations(static::$drv, $state);
} }
/** @covers \JKingWeb\Arsse\Database::userRename */ #[CoversMethod(Database::class, "userRename")]
public function testRenameAUserToTheSameName(): void { public function testRenameAUserToTheSameName(): void {
$this->assertFalse(Arsse::$db->userRename("john.doe@example.com", "john.doe@example.com")); $this->assertFalse(Arsse::$db->userRename("john.doe@example.com", "john.doe@example.com"));
} }
/** @covers \JKingWeb\Arsse\Database::userRename */ #[CoversMethod(Database::class, "userRename")]
public function testRenameAMissingUser(): void { public function testRenameAMissingUser(): void {
$this->assertException("doesNotExist", "User", "ExceptionConflict"); $this->assertException("doesNotExist", "User", "ExceptionConflict");
Arsse::$db->userRename("juan.doe@example.com", "john.doe@example.com"); Arsse::$db->userRename("juan.doe@example.com", "john.doe@example.com");
} }
/** @covers \JKingWeb\Arsse\Database::userRename */ #[CoversMethod(Database::class, "userRename")]
public function testRenameAUserToADuplicateName(): void { public function testRenameAUserToADuplicateName(): void {
$this->assertException("alreadyExists", "User", "ExceptionConflict"); $this->assertException("alreadyExists", "User", "ExceptionConflict");
Arsse::$db->userRename("john.doe@example.com", "jane.doe@example.com"); Arsse::$db->userRename("john.doe@example.com", "jane.doe@example.com");
} }
/** @covers \JKingWeb\Arsse\Database::userAdd */ #[CoversMethod(Database::class, "userAdd")]
public function testAddFirstUser(): void { public function testAddFirstUser(): void {
// first truncate the users table // first truncate the users table
static::$drv->exec("DELETE FROM arsse_users"); static::$drv->exec("DELETE FROM arsse_users");

15
tests/cases/Database/TestDatabase.php
View file

@ -12,6 +12,7 @@ use JKingWeb\Arsse\Database;
use JKingWeb\Arsse\Db\Transaction; use JKingWeb\Arsse\Db\Transaction;
use PHPUnit\Framework\Attributes\CoversNothing; use PHPUnit\Framework\Attributes\CoversNothing;
use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\CoversMethod;
#[CoversNothing] #[CoversNothing]
class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest { class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest {
@ -38,9 +39,7 @@ class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest {
return $m->invoke($this->db, ...$arg); return $m->invoke($this->db, ...$arg);
} }
/** #[CoversMethod(Database::class, "generateIn")]
* @covers \JKingWeb\Arsse\Database::generateIn
*/
#[DataProvider('provideInClauses')] #[DataProvider('provideInClauses')]
public function testGenerateInClause(string $clause, array $values, array $inV, string $inT): void { public function testGenerateInClause(string $clause, array $values, array $inV, string $inT): void {
$types = array_fill(0, sizeof($values), $inT); $types = array_fill(0, sizeof($values), $inT);
@ -75,9 +74,7 @@ class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest {
]; ];
} }
/** #[CoversMethod(Database::class, "generateSearch")]
* @covers \JKingWeb\Arsse\Database::generateSearch
*/
#[DataProvider('provideSearchClauses')] #[DataProvider('provideSearchClauses')]
public function testGenerateSearchClause(string $clause, array $values, array $inV, array $inC, bool $inAny): void { public function testGenerateSearchClause(string $clause, array $values, array $inV, array $inC, bool $inAny): void {
// this is not an exhaustive test; integration tests already cover the ins and outs of the functionality // this is not an exhaustive test; integration tests already cover the ins and outs of the functionality
@ -102,7 +99,7 @@ class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest {
]; ];
} }
/** @covers \JKingWeb\Arsse\Database::generateSet */ #[CoversMethod(Database::class, "generateSet")]
public function testGenerateSetClause(): void { public function testGenerateSetClause(): void {
$in = [ $in = [
'ook' => true, 'ook' => true,
@ -124,12 +121,12 @@ class TestDatabase extends \JKingWeb\Arsse\Test\AbstractTest {
$this->assertSame($exp, $this->invoke("generateSet", $in, $valid)); $this->assertSame($exp, $this->invoke("generateSet", $in, $valid));
} }
/** @covers \JKingWeb\Arsse\Database::begin */ #[CoversMethod(Database::class, "begin")]
public function testBeginATransaction(): void { public function testBeginATransaction(): void {
$this->assertInstanceOf(Transaction::class, $this->invoke("begin")); $this->assertInstanceOf(Transaction::class, $this->invoke("begin"));
} }
/** @covers \JKingWeb\Arsse\Database::caller */ #[CoversMethod(Database::class, "caller")]
public function testReportCallingMethod(): void { public function testReportCallingMethod(): void {
$this->assertSame("caller", $this->invoke("caller")); $this->assertSame("caller", $this->invoke("caller"));
} }