nextcloud/tests/lib/Notification/NotificationTest.php

714 lines
19 KiB
PHP

<?php
declare (strict_types = 1);
/**
* @author Joas Schilling <nickvergessen@owncloud.com>
*
* @copyright Copyright (c) 2015, ownCloud, Inc.
* @license AGPL-3.0
*
* This code is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License, version 3,
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
*/
namespace Test\Notification;
use OC\Notification\Notification;
use OCP\Notification\IAction;
use OCP\Notification\INotification;
use OCP\RichObjectStrings\IValidator;
use Test\TestCase;
class NotificationTest extends TestCase {
/** @var INotification */
protected $notification;
/** @var IValidator|\PHPUnit_Framework_MockObject_MockObject */
protected $validator;
public function setUp() {
parent::setUp();
$this->validator = $this->createMock(IValidator::class);
$this->notification = new Notification($this->validator);
}
protected function dataValidString($maxLength) {
$dataSets = [
['test1'],
['1564'],
[str_repeat('a', 1)],
];
if ($maxLength !== false) {
$dataSets[] = [str_repeat('a', $maxLength)];
}
return $dataSets;
}
protected function dataInvalidString($maxLength) {
$dataSets = [
['']
];
if ($maxLength !== false) {
$dataSets[] = [str_repeat('a', $maxLength + 1)];
}
return $dataSets;
}
protected function dataInvalidStringType() {
return [
[true],
[false],
[16412],
[[]],
[null],
];
}
protected function dataInvalidInt() {
return [
[true],
[false],
[''],
['a'],
[str_repeat('a', 256)],
[[]],
[['a']],
[[str_repeat('a', 256)]],
];
}
public function dataSetApp() {
return $this->dataValidString(32);
}
/**
* @dataProvider dataSetApp
* @param string $app
*/
public function testSetApp($app) {
$this->assertSame('', $this->notification->getApp());
$this->assertSame($this->notification, $this->notification->setApp($app));
$this->assertSame($app, $this->notification->getApp());
}
public function dataSetAppInvalid() {
return $this->dataInvalidString(32);
}
public function dataSetAppInvalidType() {
return $this->dataInvalidStringType();
}
/**
* @dataProvider dataSetAppInvalid
* @param mixed $app
*
* @expectedException \InvalidArgumentException
*/
public function testSetAppInvalid($app) {
$this->notification->setApp($app);
}
/**
* @dataProvider dataSetAppInvalidType
* @param mixed $app
*
* @expectedException \TypeError
*/
public function testSetAppInvalidType($app) {
$this->notification->setApp($app);
}
public function dataSetUser() {
return $this->dataValidString(64);
}
/**
* @dataProvider dataSetUser
* @param string $user
*/
public function testSetUser($user) {
$this->assertSame('', $this->notification->getUser());
$this->assertSame($this->notification, $this->notification->setUser($user));
$this->assertSame($user, $this->notification->getUser());
}
public function dataSetUserInvalid() {
return $this->dataInvalidString(64);
}
public function dataSetUserInvalidType() {
return $this->dataInvalidStringType();
}
/**
* @dataProvider dataSetUserInvalid
* @param mixed $user
*
* @expectedException \InvalidArgumentException
*/
public function testSetUserInvalid($user) {
$this->notification->setUser($user);
}
/**
* @dataProvider dataSetUserInvalidType
* @param mixed $user
*
* @expectedException \TypeError
*/
public function testSetUserInvalidType($user) {
$this->notification->setUser($user);
}
public function dataSetDateTime() {
$past = new \DateTime();
$past->sub(new \DateInterval('P1Y'));
$current = new \DateTime();
$future = new \DateTime();
$future->add(new \DateInterval('P1Y'));
return [
[$past],
[$current],
[$future],
];
}
/**
* @dataProvider dataSetDateTime
* @param \DateTime $dateTime
*/
public function testSetDateTime(\DateTime $dateTime) {
$this->assertSame(0, $this->notification->getDateTime()->getTimestamp());
$this->assertSame($this->notification, $this->notification->setDateTime($dateTime));
$this->assertSame($dateTime, $this->notification->getDateTime());
}
public function dataSetDateTimeZero() {
$nineTeenSeventy = new \DateTime();
$nineTeenSeventy->setTimestamp(0);
return [
[$nineTeenSeventy],
];
}
/**
* @dataProvider dataSetDateTimeZero
* @param \DateTime $dateTime
*
* @expectedException \InvalidArgumentException
* @expectedMessage 'The given date time is invalid'
*/
public function testSetDateTimeZero($dateTime) {
$this->notification->setDateTime($dateTime);
}
public function dataSetObject() {
return [
['a', '21', '21'],
[str_repeat('a', 64), 42, '42'],
];
}
/**
* @dataProvider dataSetObject
* @param string $type
* @param int|string $id
* @param string $exptectedId
*/
public function testSetObject($type, $id, $exptectedId) {
$this->assertSame('', $this->notification->getObjectType());
$this->assertSame('', $this->notification->getObjectId());
$this->assertSame($this->notification, $this->notification->setObject($type, $id));
$this->assertSame($type, $this->notification->getObjectType());
$this->assertSame($exptectedId, $this->notification->getObjectId());
}
public function dataSetObjectTypeInvalid() {
return $this->dataInvalidString(64);
}
/**
* @dataProvider dataSetObjectTypeInvalid
* @param mixed $type
*
* @expectedException \InvalidArgumentException
* @expectedMessage 'The given object type is invalid'
*/
public function testSetObjectTypeInvalid($type) {
$this->notification->setObject($type, 1337);
}
public function dataSetObjectIdInvalid() {
return [
[true],
[false],
[''],
[str_repeat('a', 64 + 1)],
[[]],
[[str_repeat('a', 64 + 1)]],
];
}
/**
* @dataProvider dataSetObjectIdInvalid
* @param mixed $id
*
* @expectedException \InvalidArgumentException
* @expectedMessage 'The given object id is invalid'
*/
public function testSetObjectIdInvalid($id) {
$this->notification->setObject('object', $id);
}
public function dataSetSubject() {
return [
['a', []],
[str_repeat('a', 64), [str_repeat('a', 160)]],
[str_repeat('a', 64), array_fill(0, 160, 'a')],
];
}
/**
* @dataProvider dataSetSubject
* @param string $subject
* @param array $parameters
*/
public function testSetSubject($subject, $parameters) {
$this->assertSame('', $this->notification->getSubject());
$this->assertSame([], $this->notification->getSubjectParameters());
$this->assertSame($this->notification, $this->notification->setSubject($subject, $parameters));
$this->assertSame($subject, $this->notification->getSubject());
$this->assertSame($parameters, $this->notification->getSubjectParameters());
}
public function dataSetSubjectInvalidSubject() {
return $this->dataInvalidString(64);
}
/**
* @dataProvider dataSetSubjectInvalidSubject
* @param mixed $subject
*
* @expectedException \InvalidArgumentException
*/
public function testSetSubjectInvalidSubject($subject) {
$this->notification->setSubject($subject, []);
}
public function dataSetParsedSubject() {
return $this->dataValidString(false);
}
/**
* @dataProvider dataSetParsedSubject
* @param string $subject
*/
public function testSetParsedSubject($subject) {
$this->assertSame('', $this->notification->getParsedSubject());
$this->assertSame($this->notification, $this->notification->setParsedSubject($subject));
$this->assertSame($subject, $this->notification->getParsedSubject());
}
public function dataSetParsedSubjectInvalid() {
return $this->dataInvalidString(false);
}
/**
* @dataProvider dataSetParsedSubjectInvalid
* @param mixed $subject
*
* @expectedException \InvalidArgumentException
*/
public function testSetParsedSubjectInvalid($subject) {
$this->notification->setParsedSubject($subject);
}
public function dataSetMessage() {
return [
['a', []],
[str_repeat('a', 64), [str_repeat('a', 160)]],
[str_repeat('a', 64), array_fill(0, 160, 'a')],
];
}
/**
* @dataProvider dataSetMessage
* @param string $message
* @param array $parameters
*/
public function testSetMessage($message, $parameters) {
$this->assertSame('', $this->notification->getMessage());
$this->assertSame([], $this->notification->getMessageParameters());
$this->assertSame($this->notification, $this->notification->setMessage($message, $parameters));
$this->assertSame($message, $this->notification->getMessage());
$this->assertSame($parameters, $this->notification->getMessageParameters());
}
public function dataSetMessageInvalidMessage() {
return $this->dataInvalidString(64);
}
/**
* @dataProvider dataSetMessageInvalidMessage
* @param mixed $message
*
* @expectedException \InvalidArgumentException
*/
public function testSetMessageInvalidMessage($message) {
$this->notification->setMessage($message, []);
}
public function dataSetParsedMessage() {
return $this->dataValidString(false);
}
/**
* @dataProvider dataSetParsedMessage
* @param string $message
*/
public function testSetParsedMessage($message) {
$this->assertSame('', $this->notification->getParsedMessage());
$this->assertSame($this->notification, $this->notification->setParsedMessage($message));
$this->assertSame($message, $this->notification->getParsedMessage());
}
public function dataSetParsedMessageInvalid() {
return $this->dataInvalidString(false);
}
/**
* @dataProvider dataSetParsedMessageInvalid
* @param mixed $message
*
* @expectedException \InvalidArgumentException
*/
public function testSetParsedMessageInvalid($message) {
$this->notification->setParsedMessage($message);
}
public function dataSetLink() {
return $this->dataValidString(4000);
}
/**
* @dataProvider dataSetLink
* @param string $link
*/
public function testSetLink($link) {
$this->assertSame('', $this->notification->getLink());
$this->assertSame($this->notification, $this->notification->setLink($link));
$this->assertSame($link, $this->notification->getLink());
}
public function dataSetLinkInvalid() {
return $this->dataInvalidString(4000);
}
/**
* @dataProvider dataSetLinkInvalid
* @param mixed $link
*
* @expectedException \InvalidArgumentException
*/
public function testSetLinkInvalid($link) {
$this->notification->setLink($link);
}
public function dataSetIcon() {
return $this->dataValidString(4000);
}
/**
* @dataProvider dataSetIcon
* @param string $icon
*/
public function testSetIcon($icon) {
$this->assertSame('', $this->notification->getIcon());
$this->assertSame($this->notification, $this->notification->setIcon($icon));
$this->assertSame($icon, $this->notification->getIcon());
}
public function dataSetIconInvalid() {
return $this->dataInvalidString(4000);
}
/**
* @dataProvider dataSetIconInvalid
* @param mixed $icon
*
* @expectedException \InvalidArgumentException
*/
public function testSetIconInvalid($icon) {
$this->notification->setIcon($icon);
}
public function testCreateAction() {
$action = $this->notification->createAction();
$this->assertInstanceOf(IAction::class, $action);
}
public function testAddAction() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->once())
->method('isValid')
->willReturn(true);
$action->expects($this->never())
->method('isValidParsed');
$this->assertSame($this->notification, $this->notification->addAction($action));
$this->assertEquals([$action], $this->notification->getActions());
$this->assertEquals([], $this->notification->getParsedActions());
}
/**
* @expectedException \InvalidArgumentException
*/
public function testAddActionInvalid() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->once())
->method('isValid')
->willReturn(false);
$action->expects($this->never())
->method('isValidParsed');
$this->notification->addAction($action);
}
public function testAddActionSecondPrimary() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->exactly(2))
->method('isValid')
->willReturn(true);
$action->expects($this->exactly(2))
->method('isPrimary')
->willReturn(true);
$this->assertSame($this->notification, $this->notification->addAction($action));
$this->expectException(\InvalidArgumentException::class);
$this->notification->addAction($action);
}
public function testAddParsedAction() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->once())
->method('isValidParsed')
->willReturn(true);
$action->expects($this->never())
->method('isValid');
$this->assertSame($this->notification, $this->notification->addParsedAction($action));
$this->assertEquals([$action], $this->notification->getParsedActions());
$this->assertEquals([], $this->notification->getActions());
}
/**
* @expectedException \InvalidArgumentException
*/
public function testAddParsedActionInvalid() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->once())
->method('isValidParsed')
->willReturn(false);
$action->expects($this->never())
->method('isValid');
$this->notification->addParsedAction($action);
}
public function testAddActionSecondParsedPrimary() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action = $this->createMock(IAction::class);
$action->expects($this->exactly(2))
->method('isValidParsed')
->willReturn(true);
$action->expects($this->exactly(2))
->method('isPrimary')
->willReturn(true);
$this->assertSame($this->notification, $this->notification->addParsedAction($action));
$this->expectException(\InvalidArgumentException::class);
$this->notification->addParsedAction($action);
}
public function testAddActionParsedPrimaryEnd() {
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action1 = $this->createMock(IAction::class);
$action1->expects($this->exactly(2))
->method('isValidParsed')
->willReturn(true);
$action1->expects($this->exactly(2))
->method('isPrimary')
->willReturn(false);
/** @var \OCP\Notification\IAction|\PHPUnit_Framework_MockObject_MockObject $action */
$action2 = $this->createMock(IAction::class);
$action2->expects($this->once())
->method('isValidParsed')
->willReturn(true);
$action2->expects($this->once())
->method('isPrimary')
->willReturn(true);
$this->assertSame($this->notification, $this->notification->addParsedAction($action1));
$this->assertSame($this->notification, $this->notification->addParsedAction($action2));
$this->assertSame($this->notification, $this->notification->addParsedAction($action1));
$this->assertEquals([$action2, $action1, $action1], $this->notification->getParsedActions());
}
public function dataIsValid() {
return [
[false, '', false],
[true, '', false],
[false, 'a', false],
[true, 'a', true],
];
}
/**
* @dataProvider dataIsValid
*
* @param bool $isValidCommon
* @param string $subject
* @param bool $expected
*/
public function testIsValid($isValidCommon, $subject, $expected) {
/** @var \OCP\Notification\INotification|\PHPUnit_Framework_MockObject_MockObject $notification */
$notification = $this->getMockBuilder(Notification::class)
->setMethods([
'isValidCommon',
'getSubject',
'getParsedSubject',
])
->setConstructorArgs([$this->validator])
->getMock();
$notification->expects($this->once())
->method('isValidCommon')
->willReturn($isValidCommon);
$notification->expects(!$isValidCommon ? $this->never() : $this->once())
->method('getSubject')
->willReturn($subject);
$notification->expects($this->never())
->method('getParsedSubject')
->willReturn($subject);
$this->assertEquals($expected, $notification->isValid());
}
/**
* @dataProvider dataIsValid
*
* @param bool $isValidCommon
* @param string $subject
* @param bool $expected
*/
public function testIsParsedValid($isValidCommon, $subject, $expected) {
/** @var \OCP\Notification\INotification|\PHPUnit_Framework_MockObject_MockObject $notification */
$notification = $this->getMockBuilder(Notification::class)
->setMethods([
'isValidCommon',
'getParsedSubject',
'getSubject',
])
->setConstructorArgs([$this->validator])
->getMock();
$notification->expects($this->once())
->method('isValidCommon')
->willReturn($isValidCommon);
$notification->expects(!$isValidCommon ? $this->never() : $this->once())
->method('getParsedSubject')
->willReturn($subject);
$notification->expects($this->never())
->method('getSubject')
->willReturn($subject);
$this->assertEquals($expected, $notification->isValidParsed());
}
public function dataIsValidCommon() {
return [
['', '', 0, '', '', false],
['app', '', 0, '', '', false],
['app', 'user', 0, '', '', false],
['app', 'user', time(), '', '', false],
['app', 'user', time(), 'type', '', false],
['app', 'user', time(), 'type', '42', true],
];
}
/**
* @dataProvider dataIsValidCommon
*
* @param string $app
* @param string $user
* @param int $timestamp
* @param string $objectType
* @param string $objectId
* @param bool $expected
*/
public function testIsValidCommon($app, $user, $timestamp, $objectType, $objectId, $expected) {
/** @var \OCP\Notification\INotification|\PHPUnit_Framework_MockObject_MockObject $notification */
$notification = $this->getMockBuilder(Notification::class)
->setMethods([
'getApp',
'getUser',
'getDateTime',
'getObjectType',
'getObjectId',
])
->setConstructorArgs([$this->validator])
->getMock();
$notification->expects($this->any())
->method('getApp')
->willReturn($app);
$notification->expects($this->any())
->method('getUser')
->willReturn($user);
$dateTime = new \DateTime();
$dateTime->setTimestamp($timestamp);
$notification->expects($this->any())
->method('getDateTime')
->willReturn($dateTime);
$notification->expects($this->any())
->method('getObjectType')
->willReturn($objectType);
$notification->expects($this->any())
->method('getObjectId')
->willReturn($objectId);
$this->assertEquals($expected, $this->invokePrivate($notification, 'isValidCommon'));
}
}