mirror of
https://code.mensbeam.com/MensBeam/Arsse.git
synced 2024-12-22 13:12:41 +00:00
Convert user manager tests to Phake
This commit is contained in:
J. King
parent
9d92c1661d
commit
72dd21686e
2 changed files with 166 additions and 172 deletions
|
|
@ -19,15 +19,15 @@ class Arsse {
|
|||
"iconv", // required by PicoFeed only
|
||||
];
|
||||
|
||||
/** @var Factory */
|
||||
/** @var Factory|\Phake\IMock */
|
||||
public static $obj;
|
||||
/** @var Lang */
|
||||
/** @var Lang|\Phake\IMock */
|
||||
public static $lang;
|
||||
/** @var Conf */
|
||||
/** @var Conf|\Phake\IMock */
|
||||
public static $conf;
|
||||
/** @var Database */
|
||||
/** @var Database|\Phake\IMock */
|
||||
public static $db;
|
||||
/** @var User */
|
||||
/** @var User|\Phake\IMock */
|
||||
public static $user;
|
||||
|
||||
/** @codeCoverageIgnore */
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
}
|
||||
|
||||
public function testConstruct(): void {
|
||||
$this->assertInstanceOf(User::class, new User($this->drv->get()));
|
||||
$this->assertInstanceOf(User::class, new User($this->drv));
|
||||
$this->assertInstanceOf(User::class, new User);
|
||||
}
|
||||
|
||||
|
|
@ -89,71 +89,71 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
|
||||
public function testListUsers(): void {
|
||||
$exp = ["john.doe@example.com", "jane.doe@example.com"];
|
||||
$this->drv->userList->returns(["john.doe@example.com", "jane.doe@example.com"]);
|
||||
\Phake::when($this->drv)->userList->thenReturn(["john.doe@example.com", "jane.doe@example.com"]);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($exp, $u->list());
|
||||
$this->drv->userList->calledWith();
|
||||
\Phake::verify($this->drv)->userList();
|
||||
}
|
||||
|
||||
public function testLookUpAUserByNumber(): void {
|
||||
$exp = "john.doe@example.com";
|
||||
$this->dbMock->userLookup->returns($exp);
|
||||
\Phake::when(Arsse::$db)->userLookup->thenReturn($exp);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($exp, $u->lookup(2112));
|
||||
$this->dbMock->userLookup->calledWith(2112);
|
||||
\Phake::verify(Arsse::$db)->userLookup(2112);
|
||||
}
|
||||
|
||||
public function testAddAUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userAdd->returns($pass);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userAdd->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($pass, $u->add($user, $pass));
|
||||
$this->drv->userAdd->calledWith($user, $pass);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userAdd($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testAddAUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userAdd->returns($pass);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userAdd->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($pass, $u->add($user, $pass));
|
||||
$this->drv->userAdd->calledWith($user, $pass);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->dbMock->userAdd->calledWith($user, $pass);
|
||||
\Phake::verify($this->drv)->userAdd($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify(Arsse::$db)->userAdd($user, $pass);
|
||||
}
|
||||
|
||||
public function testAddADuplicateUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userAdd->throws(new ExceptionConflict("alreadyExists"));
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userAdd->thenThrow(new ExceptionConflict("alreadyExists"));
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("alreadyExists", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->add($user, $pass);
|
||||
} finally {
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->drv->userAdd->calledWith($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify($this->drv)->userAdd($user, $pass);
|
||||
}
|
||||
}
|
||||
|
||||
public function testAddADuplicateUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userAdd->throws(new ExceptionConflict("alreadyExists"));
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userAdd->thenThrow(new ExceptionConflict("alreadyExists"));
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("alreadyExists", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->add($user, $pass);
|
||||
} finally {
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->dbMock->userAdd->calledWith($user, null);
|
||||
$this->drv->userAdd->calledWith($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify(Arsse::$db)->userAdd($user, null);
|
||||
\Phake::verify($this->drv)->userAdd($user, $pass);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -178,68 +178,67 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
public function testAddAUserWithARandomPassword(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "random password";
|
||||
$this->drv->userAdd->returns(null)->returns($pass);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
$u = $this->prepTest(function($u) use ($pass) {
|
||||
$u->generatePassword->returns($pass);
|
||||
});
|
||||
$u = \Phake::partialMock(User::class, $this->drv);
|
||||
\Phake::when($u)->generatePassword->thenReturn($pass);
|
||||
\Phake::when($this->drv)->userAdd->thenReturn(null)->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$this->assertSame($pass, $u->add($user));
|
||||
$this->drv->userAdd->calledWith($user, null);
|
||||
$this->drv->userAdd->calledWith($user, $pass);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userAdd($user, null);
|
||||
\Phake::verify($this->drv)->userAdd($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testRenameAUser(): void {
|
||||
$tr = $this->mock(Transaction::class);
|
||||
$this->dbMock->begin->returns($tr);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
$this->dbMock->userAdd->returns(true);
|
||||
$this->dbMock->userRename->returns(true);
|
||||
$this->drv->userRename->returns(true);
|
||||
$tr = \Phake::mock(Transaction::class);
|
||||
\Phake::when(Arsse::$db)->begin->thenReturn($tr);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userAdd->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userRename->thenReturn(true);
|
||||
\Phake::when($this->drv)->userRename->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$old = "john.doe@example.com";
|
||||
$new = "jane.doe@example.com";
|
||||
$this->assertTrue($u->rename($old, $new));
|
||||
Phony::inOrder(
|
||||
$this->drv->userRename->calledWith($old, $new),
|
||||
$this->dbMock->begin->calledWith(),
|
||||
$this->dbMock->userExists->calledWith($old),
|
||||
$this->dbMock->userRename->calledWith($old, $new),
|
||||
$this->dbMock->sessionDestroy->calledWith($new),
|
||||
$this->dbMock->tokenRevoke->calledWith($new, "fever.login"),
|
||||
$tr->commit->called()
|
||||
\Phake::inOrder(
|
||||
\Phake::verify($this->drv)->userRename($old, $new),
|
||||
\Phake::verify(Arsse::$db)->begin(),
|
||||
\Phake::verify(Arsse::$db)->userExists($old),
|
||||
\Phake::verify(Arsse::$db)->userRename($old, $new),
|
||||
\Phake::verify(Arsse::$db)->sessionDestroy($new),
|
||||
\Phake::verify(Arsse::$db)->tokenRevoke($new, "fever.login"),
|
||||
\Phake::verify($tr)->commit()
|
||||
);
|
||||
}
|
||||
|
||||
public function testRenameAUserWeDoNotKnow(): void {
|
||||
$tr = $this->mock(Transaction::class);
|
||||
$this->dbMock->begin->returns($tr);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
$this->dbMock->userAdd->returns(true);
|
||||
$this->dbMock->userRename->returns(true);
|
||||
$this->drv->userRename->returns(true);
|
||||
$tr = \Phake::mock(Transaction::class);
|
||||
\Phake::when(Arsse::$db)->begin->thenReturn($tr);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
\Phake::when(Arsse::$db)->userAdd->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userRename->thenReturn(true);
|
||||
\Phake::when($this->drv)->userRename->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$old = "john.doe@example.com";
|
||||
$new = "jane.doe@example.com";
|
||||
$this->assertTrue($u->rename($old, $new));
|
||||
Phony::inOrder(
|
||||
$this->drv->userRename->calledWith($old, $new),
|
||||
$this->dbMock->begin->calledWith(),
|
||||
$this->dbMock->userExists->calledWith($old),
|
||||
$this->dbMock->userAdd->calledWith($new, null),
|
||||
$tr->commit->called()
|
||||
\Phake::inOrder(
|
||||
\Phake::verify($this->drv)->userRename($old, $new),
|
||||
\Phake::verify(Arsse::$db)->begin(),
|
||||
\Phake::verify(Arsse::$db)->userExists($old),
|
||||
\Phake::verify(Arsse::$db)->userAdd($new, null),
|
||||
\Phake::verify($tr)->commit()
|
||||
);
|
||||
}
|
||||
|
||||
public function testRenameAUserWithoutEffect(): void {
|
||||
$this->dbMock->userExists->returns(false);
|
||||
$this->dbMock->userAdd->returns(true);
|
||||
$this->dbMock->userRename->returns(true);
|
||||
$this->drv->userRename->returns(false);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
\Phake::when(Arsse::$db)->userAdd->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userRename->thenReturn(true);
|
||||
\Phake::when($this->drv)->userRename->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$old = "john.doe@example.com";
|
||||
$this->assertFalse($u->rename($old, $old));
|
||||
$this->drv->userRename->calledWith($old, $old);
|
||||
\Phake::verify($this->drv)->userRename($old, $old);
|
||||
}
|
||||
|
||||
/** @dataProvider provideInvalidUserNames */
|
||||
|
|
@ -251,164 +250,159 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
|
||||
public function testRemoveAUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userRemove->returns(true);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userRemove->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertTrue($u->remove($user));
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->dbMock->userRemove->calledWith($user);
|
||||
$this->drv->userRemove->calledWith($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify(Arsse::$db)->userRemove($user);
|
||||
\Phake::verify($this->drv)->userRemove($user);
|
||||
}
|
||||
|
||||
public function testRemoveAUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userRemove->returns(true);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userRemove->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertTrue($u->remove($user));
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->drv->userRemove->calledWith($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify($this->drv)->userRemove($user);
|
||||
}
|
||||
|
||||
public function testRemoveAMissingUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userRemove->throws(new ExceptionConflict("doesNotExist"));
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userRemove->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->remove($user);
|
||||
} finally {
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->dbMock->userRemove->calledWith($user);
|
||||
$this->drv->userRemove->calledWith($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify(Arsse::$db)->userRemove($user);
|
||||
\Phake::verify($this->drv)->userRemove($user);
|
||||
}
|
||||
}
|
||||
|
||||
public function testRemoveAMissingUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userRemove->throws(new ExceptionConflict("doesNotExist"));
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userRemove->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->remove($user);
|
||||
} finally {
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->drv->userRemove->calledWith($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
\Phake::verify($this->drv)->userRemove($user);
|
||||
}
|
||||
}
|
||||
|
||||
public function testSetAPassword(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($pass, $u->passwordSet($user, $pass));
|
||||
$this->drv->userPasswordSet->calledWith($user, $pass, null);
|
||||
$this->dbMock->userPasswordSet->calledWith($user, $pass);
|
||||
$this->dbMock->sessionDestroy->calledWith($user);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, $pass, null);
|
||||
\Phake::verify(Arsse::$db)->userPasswordSet($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->sessionDestroy($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testSetARandomPassword(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "random password";
|
||||
$this->drv->userPasswordSet->returns(null)->returns($pass);
|
||||
$this->dbMock->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
$u = $this->prepTest(function($u) use ($pass) {
|
||||
$u->generatePassword->returns($pass);
|
||||
});
|
||||
$u = \Phake::partialMock(User::class, $this->drv);
|
||||
\Phake::when($u)->generatePassword->thenReturn($pass);
|
||||
\Phake::when($this->drv)->userPasswordSet->thenReturn(null)->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$this->assertSame($pass, $u->passwordSet($user, null));
|
||||
$this->drv->userPasswordSet->calledWith($user, null, null);
|
||||
$this->drv->userPasswordSet->calledWith($user, $pass, null);
|
||||
$this->dbMock->userPasswordSet->calledWith($user, $pass);
|
||||
$this->dbMock->sessionDestroy->calledWith($user);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, null, null);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, $pass, null);
|
||||
\Phake::verify(Arsse::$db)->userPasswordSet($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->sessionDestroy($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testSetAPasswordForAUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "secret";
|
||||
$this->drv->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($pass, $u->passwordSet($user, $pass));
|
||||
$this->drv->userPasswordSet->calledWith($user, $pass, null);
|
||||
$this->dbMock->userAdd->calledWith($user, $pass);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, $pass, null);
|
||||
\Phake::verify(Arsse::$db)->userAdd($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testSetARandomPasswordForAUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "random password";
|
||||
$this->drv->userPasswordSet->returns(null)->returns($pass);
|
||||
$this->dbMock->userPasswordSet->returns($pass);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
$u = $this->prepTest(function($u) use ($pass) {
|
||||
$u->generatePassword->returns($pass);
|
||||
});
|
||||
$u = \Phake::partialMock(User::class, $this->drv);
|
||||
\Phake::when($u)->generatePassword->thenReturn($pass);
|
||||
\Phake::when($this->drv)->userPasswordSet->thenReturn(null)->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn($pass);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$this->assertSame($pass, $u->passwordSet($user, null));
|
||||
$this->drv->userPasswordSet->calledWith($user, null, null);
|
||||
$this->drv->userPasswordSet->calledWith($user, $pass, null);
|
||||
$this->dbMock->userAdd->calledWith($user, $pass);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, null, null);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, $pass, null);
|
||||
\Phake::verify(Arsse::$db)->userAdd($user, $pass);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testSetARandomPasswordForAMissingUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$pass = "random password";
|
||||
$this->drv->userPasswordSet->throws(new ExceptionConflict("doesNotExist"));
|
||||
$u = $this->prepTest(function($u) use ($pass) {
|
||||
$u->generatePassword->returns($pass);
|
||||
});
|
||||
$u = \Phake::partialMock(User::class, $this->drv);
|
||||
\Phake::when($u)->generatePassword->thenReturn($pass);
|
||||
\Phake::when($this->drv)->userPasswordSet->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->passwordSet($user, null);
|
||||
} finally {
|
||||
$this->drv->userPasswordSet->calledWith($user, null, null);
|
||||
\Phake::verify($this->drv)->userPasswordSet($user, null, null);
|
||||
}
|
||||
}
|
||||
|
||||
public function testUnsetAPassword(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userPasswordUnset->returns(true);
|
||||
$this->dbMock->userPasswordSet->returns(true);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userPasswordUnset->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertTrue($u->passwordUnset($user));
|
||||
$this->drv->userPasswordUnset->calledWith($user, null);
|
||||
$this->dbMock->userPasswordSet->calledWith($user, null);
|
||||
$this->dbMock->sessionDestroy->calledWith($user);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordUnset($user, null);
|
||||
\Phake::verify(Arsse::$db)->userPasswordSet($user, null);
|
||||
\Phake::verify(Arsse::$db)->sessionDestroy($user);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testUnsetAPasswordForAUserWeDoNotKnow(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userPasswordUnset->returns(true);
|
||||
$this->dbMock->userPasswordSet->returns(true);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userPasswordUnset->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userPasswordSet->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertTrue($u->passwordUnset($user));
|
||||
$this->drv->userPasswordUnset->calledWith($user, null);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPasswordUnset($user, null);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testUnsetAPasswordForAMissingUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userPasswordUnset->throws(new ExceptionConflict("doesNotExist"));
|
||||
\Phake::when($this->drv)->userPasswordUnset->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->passwordUnset($user);
|
||||
} finally {
|
||||
$this->drv->userPasswordUnset->calledWith($user, null);
|
||||
\Phake::verify($this->drv)->userPasswordUnset($user, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -416,14 +410,14 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
public function testGetThePropertiesOfAUser(array $exp, array $base, array $extra): void {
|
||||
$user = "john.doe@example.com";
|
||||
$exp = array_merge(['num' => null], array_combine(array_keys(User::PROPERTIES), array_fill(0, sizeof(User::PROPERTIES), null)), $exp);
|
||||
$this->drv->userPropertiesGet->returns($extra);
|
||||
$this->dbMock->userPropertiesGet->returns($base);
|
||||
$this->dbMock->userExists->returns(true);
|
||||
\Phake::when($this->drv)->userPropertiesGet->thenReturn($extra);
|
||||
\Phake::when(Arsse::$db)->userPropertiesGet->thenReturn($base);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($exp, $u->propertiesGet($user));
|
||||
$this->drv->userPropertiesGet->calledWith($user, true);
|
||||
$this->dbMock->userPropertiesGet->calledWith($user, true);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPropertiesGet($user, true);
|
||||
\Phake::verify(Arsse::$db)->userPropertiesGet($user, true);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function provideProperties(): iterable {
|
||||
|
|
@ -442,28 +436,28 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
$base = ['num' => 47, 'admin' => false, 'lang' => null, 'tz' => "Etc/UTC", 'sort_asc' => false];
|
||||
$exp = ['num' => 47, 'admin' => false, 'lang' => null, 'tz' => "Europe/Istanbul", 'sort_asc' => false];
|
||||
$exp = array_merge(['num' => null], array_combine(array_keys(User::PROPERTIES), array_fill(0, sizeof(User::PROPERTIES), null)), $exp);
|
||||
$this->drv->userPropertiesGet->returns($extra);
|
||||
$this->dbMock->userPropertiesGet->returns($base);
|
||||
$this->dbMock->userAdd->returns(true);
|
||||
$this->dbMock->userExists->returns(false);
|
||||
\Phake::when($this->drv)->userPropertiesGet->thenReturn($extra);
|
||||
\Phake::when(Arsse::$db)->userPropertiesGet->thenReturn($base);
|
||||
\Phake::when(Arsse::$db)->userAdd->thenReturn(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($exp, $u->propertiesGet($user));
|
||||
$this->drv->userPropertiesGet->calledWith($user, true);
|
||||
$this->dbMock->userPropertiesGet->calledWith($user, true);
|
||||
$this->dbMock->userPropertiesSet->calledWith($user, $extra);
|
||||
$this->dbMock->userAdd->calledWith($user, null);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPropertiesGet($user, true);
|
||||
\Phake::verify(Arsse::$db)->userPropertiesGet($user, true);
|
||||
\Phake::verify(Arsse::$db)->userPropertiesSet($user, $extra);
|
||||
\Phake::verify(Arsse::$db)->userAdd($user, null);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
|
||||
public function testGetThePropertiesOfAMissingUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$this->drv->userPropertiesGet->throws(new ExceptionConflict("doesNotExist"));
|
||||
\Phake::when($this->drv)->userPropertiesGet->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->propertiesGet($user);
|
||||
} finally {
|
||||
$this->drv->userPropertiesGet->calledWith($user, true);
|
||||
\Phake::verify($this->drv)->userPropertiesGet($user, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -475,14 +469,14 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
$this->assertException($out);
|
||||
$u->propertiesSet($user, $in);
|
||||
} else {
|
||||
$this->dbMock->userExists->returns(true);
|
||||
$this->drv->userPropertiesSet->returns($out);
|
||||
$this->dbMock->userPropertiesSet->returns(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(true);
|
||||
\Phake::when($this->drv)->userPropertiesSet->thenReturn($out);
|
||||
\Phake::when(Arsse::$db)->userPropertiesSet->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($out, $u->propertiesSet($user, $in));
|
||||
$this->drv->userPropertiesSet->calledWith($user, $in);
|
||||
$this->dbMock->userPropertiesSet->calledWith($user, $out);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
\Phake::verify($this->drv)->userPropertiesSet($user, $in);
|
||||
\Phake::verify(Arsse::$db)->userPropertiesSet($user, $out);
|
||||
\Phake::verify(Arsse::$db)->userExists($user);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -494,15 +488,15 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
$this->assertException($out);
|
||||
$u->propertiesSet($user, $in);
|
||||
} else {
|
||||
$this->dbMock->userExists->returns(false);
|
||||
$this->drv->userPropertiesSet->returns($out);
|
||||
$this->dbMock->userPropertiesSet->returns(true);
|
||||
\Phake::when(Arsse::$db)->userExists->thenReturn(false);
|
||||
\Phake::when($this->drv)->userPropertiesSet->thenReturn($out);
|
||||
\Phake::when(Arsse::$db)->userPropertiesSet->thenReturn(true);
|
||||
$u = new User($this->drv);
|
||||
$this->assertSame($out, $u->propertiesSet($user, $in));
|
||||
$this->drv->userPropertiesSet->calledWith($user, $in);
|
||||
$this->dbMock->userPropertiesSet->calledWith($user, $out);
|
||||
$this->dbMock->userExists->calledWith($user);
|
||||
$this->dbMock->userAdd->calledWith($user, null);
|
||||
\Phake::when($this->drv)->userPropertiesSet($user, $in);
|
||||
\Phake::when(Arsse::$db)->userPropertiesSet($user, $out);
|
||||
\Phake::when(Arsse::$db)->userExists($user);
|
||||
\Phake::when(Arsse::$db)->userAdd($user, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -523,13 +517,13 @@ class TestUser extends \JKingWeb\Arsse\Test\AbstractTest {
|
|||
public function testSetThePropertiesOfAMissingUser(): void {
|
||||
$user = "john.doe@example.com";
|
||||
$in = ['admin' => true];
|
||||
$this->drv->userPropertiesSet->throws(new ExceptionConflict("doesNotExist"));
|
||||
\Phake::when($this->drv)->userPropertiesSet->thenThrow(new ExceptionConflict("doesNotExist"));
|
||||
$u = new User($this->drv);
|
||||
$this->assertException("doesNotExist", "User", "ExceptionConflict");
|
||||
try {
|
||||
$u->propertiesSet($user, $in);
|
||||
} finally {
|
||||
$this->drv->userPropertiesSet->calledWith($user, $in);
|
||||
\Phake::verify($this->drv)->userPropertiesSet($user, $in);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue