[github/shaarli/Shaarli.git] / tests / helper / DailyPageHelperTest.php

<?php

declare(strict_types=1);

namespace Shaarli\Helper;

use DateTimeImmutable;
use DateTimeInterface;
use Shaarli\Bookmark\Bookmark;
use Shaarli\TestCase;
use Slim\Http\Request;

class DailyPageHelperTest extends TestCase
{
    /**
     * @dataProvider getRequestedTypes
     */
    public function testExtractRequestedType(array $queryParams, string $expectedType): void
    {
        $request = $this->createMock(Request::class);
        $request->method('getQueryParam')->willReturnCallback(function ($key) use ($queryParams): ?string {
            return $queryParams[$key] ?? null;
        });

        $type = DailyPageHelper::extractRequestedType($request);

        static::assertSame($type, $expectedType);
    }

    /**
     * @dataProvider getRequestedDateTimes
     */
    public function testExtractRequestedDateTime(
        string $type,
        string $input,
        ?Bookmark $bookmark,
        DateTimeInterface $expectedDateTime,
        string $compareFormat = 'Ymd'
    ): void {
        $dateTime = DailyPageHelper::extractRequestedDateTime($type, $input, $bookmark);

        static::assertSame($dateTime->format($compareFormat), $expectedDateTime->format($compareFormat));
    }

    public function testExtractRequestedDateTimeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::extractRequestedDateTime('nope', null, null);
    }

    /**
     * @dataProvider getFormatsByType
     */
    public function testGetFormatByType(string $type, string $expectedFormat): void
    {
        $format = DailyPageHelper::getFormatByType($type);

        static::assertSame($expectedFormat, $format);
    }

    public function testGetFormatByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getFormatByType('nope');
    }

    /**
     * @dataProvider getStartDatesByType
     */
    public function testGetStartDatesByType(
        string $type,
        DateTimeImmutable $dateTime,
        DateTimeInterface $expectedDateTime
    ): void {
        $startDateTime = DailyPageHelper::getStartDateTimeByType($type, $dateTime);

        static::assertEquals($expectedDateTime, $startDateTime);
    }

    public function testGetStartDatesByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getStartDateTimeByType('nope', new DateTimeImmutable());
    }

    /**
     * @dataProvider getEndDatesByType
     */
    public function testGetEndDatesByType(
        string $type,
        DateTimeImmutable $dateTime,
        DateTimeInterface $expectedDateTime
    ): void {
        $endDateTime = DailyPageHelper::getEndDateTimeByType($type, $dateTime);

        static::assertEquals($expectedDateTime, $endDateTime);
    }

    public function testGetEndDatesByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getEndDateTimeByType('nope', new DateTimeImmutable());
    }

    /**
     * @dataProvider getDescriptionsByType
     */
    public function testGeDescriptionsByType(
        string $type,
        DateTimeImmutable $dateTime,
        string $expectedDescription
    ): void {
        $description = DailyPageHelper::getDescriptionByType($type, $dateTime);

        static::assertEquals($expectedDescription, $description);
    }

    /**
     * @dataProvider getDescriptionsByTypeNotIncludeRelative
     */
    public function testGeDescriptionsByTypeNotIncludeRelative(
        string $type,
        \DateTimeImmutable $dateTime,
        string $expectedDescription
    ): void {
        $description = DailyPageHelper::getDescriptionByType($type, $dateTime, false);

        static::assertEquals($expectedDescription, $description);
    }

    public function getDescriptionByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getDescriptionByType('nope', new DateTimeImmutable());
    }

    /**
     * @dataProvider getRssLengthsByType
     */
    public function testGeRssLengthsByType(string $type): void {
        $length = DailyPageHelper::getRssLengthByType($type);

        static::assertIsInt($length);
    }

    public function testGeRssLengthsByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getRssLengthByType('nope');
    }

    /**
     * @dataProvider getCacheDatePeriodByType
     */
    public function testGetCacheDatePeriodByType(
        string $type,
        DateTimeImmutable $requested,
        DateTimeInterface $start,
        DateTimeInterface $end
    ): void {
        $period = DailyPageHelper::getCacheDatePeriodByType($type, $requested);

        static::assertEquals($start, $period->getStartDate());
        static::assertEquals($end, $period->getEndDate());
    }

    public function testGetCacheDatePeriodByTypeExceptionUnknownType(): void
    {
        $this->expectException(\Exception::class);
        $this->expectExceptionMessage('Unsupported daily format type');

        DailyPageHelper::getCacheDatePeriodByType('nope');
    }

    /**
     * Data provider for testExtractRequestedType() test method.
     */
    public function getRequestedTypes(): array
    {
        return [
            [['month' => null], DailyPageHelper::DAY],
            [['month' => ''], DailyPageHelper::MONTH],
            [['month' => 'content'], DailyPageHelper::MONTH],
            [['week' => null], DailyPageHelper::DAY],
            [['week' => ''], DailyPageHelper::WEEK],
            [['week' => 'content'], DailyPageHelper::WEEK],
            [['day' => null], DailyPageHelper::DAY],
            [['day' => ''], DailyPageHelper::DAY],
            [['day' => 'content'], DailyPageHelper::DAY],
        ];
    }

    /**
     * Data provider for testExtractRequestedDateTime() test method.
     */
    public function getRequestedDateTimes(): array
    {
        return [
            [DailyPageHelper::DAY, '20201013', null, new \DateTime('2020-10-13')],
            [
                DailyPageHelper::DAY,
                '',
                (new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
                $date,
            ],
            [DailyPageHelper::DAY, '', null, new \DateTime()],
            [DailyPageHelper::WEEK, '202030', null, new \DateTime('2020-07-20')],
            [
                DailyPageHelper::WEEK,
                '',
                (new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
                new \DateTime('2020-10-13'),
            ],
            [DailyPageHelper::WEEK, '', null, new \DateTime(), 'Ym'],
            [DailyPageHelper::MONTH, '202008', null, new \DateTime('2020-08-01'), 'Ym'],
            [
                DailyPageHelper::MONTH,
                '',
                (new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
                new \DateTime('2020-10-13'),
                'Ym'
            ],
            [DailyPageHelper::MONTH, '', null, new \DateTime(), 'Ym'],
        ];
    }

    /**
     * Data provider for testGetFormatByType() test method.
     */
    public function getFormatsByType(): array
    {
        return [
            [DailyPageHelper::DAY, 'Ymd'],
            [DailyPageHelper::WEEK, 'YW'],
            [DailyPageHelper::MONTH, 'Ym'],
        ];
    }

    /**
     * Data provider for testGetStartDatesByType() test method.
     */
    public function getStartDatesByType(): array
    {
        return [
            [DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-09 00:00:00')],
            [DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-05 00:00:00')],
            [DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-01 00:00:00')],
        ];
    }

    /**
     * Data provider for testGetEndDatesByType() test method.
     */
    public function getEndDatesByType(): array
    {
        return [
            [DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-09 23:59:59')],
            [DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-11 23:59:59')],
            [DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-31 23:59:59')],
        ];
    }

    /**
     * Data provider for testGetDescriptionsByType() test method.
     */
    public function getDescriptionsByType(): array
    {
        return [
            [DailyPageHelper::DAY, $date = new DateTimeImmutable(), 'Today - ' . $date->format('F j, Y')],
            [DailyPageHelper::DAY, $date = new DateTimeImmutable('-1 day'), 'Yesterday - ' . $date->format('F j, Y')],
            [DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), 'October 9, 2020'],
            [DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), 'Week 41 (October 5, 2020)'],
            [DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), 'October, 2020'],
        ];
    }

    /**
     * Data provider for testGeDescriptionsByTypeNotIncludeRelative() test method.
     */
    public function getDescriptionsByTypeNotIncludeRelative(): array
    {
        return [
            [DailyPageHelper::DAY, $date = new \DateTimeImmutable(), $date->format('F j, Y')],
            [DailyPageHelper::DAY, $date = new \DateTimeImmutable('-1 day'), $date->format('F j, Y')],
            [DailyPageHelper::DAY, new \DateTimeImmutable('2020-10-09 04:05:06'), 'October 9, 2020'],
            [DailyPageHelper::WEEK, new \DateTimeImmutable('2020-10-09 04:05:06'), 'Week 41 (October 5, 2020)'],
            [DailyPageHelper::MONTH, new \DateTimeImmutable('2020-10-09 04:05:06'), 'October, 2020'],
        ];
    }

    /**
     * Data provider for testGetRssLengthsByType() test method.
     */
    public function getRssLengthsByType(): array
    {
        return [
            [DailyPageHelper::DAY],
            [DailyPageHelper::WEEK],
            [DailyPageHelper::MONTH],
        ];
    }

    /**
     * Data provider for testGetCacheDatePeriodByType() test method.
     */
    public function getCacheDatePeriodByType(): array
    {
        return [
            [
                DailyPageHelper::DAY,
                new DateTimeImmutable('2020-10-09 04:05:06'),
                new \DateTime('2020-10-09 00:00:00'),
                new \DateTime('2020-10-09 23:59:59'),
            ],
            [
                DailyPageHelper::WEEK,
                new DateTimeImmutable('2020-10-09 04:05:06'),
                new \DateTime('2020-10-05 00:00:00'),
                new \DateTime('2020-10-11 23:59:59'),
            ],
            [
                DailyPageHelper::MONTH,
                new DateTimeImmutable('2020-10-09 04:05:06'),
                new \DateTime('2020-10-01 00:00:00'),
                new \DateTime('2020-10-31 23:59:59'),
            ],
        ];
    }
}
Commit	Line	Data
36e6d88d A	1	<?php
	2
	3	declare(strict_types=1);
	4
	5	namespace Shaarli\Helper;
	6
f00600a2 A	7	use DateTimeImmutable;
f00600a2 A	8	use DateTimeInterface;
36e6d88d A	9	use Shaarli\Bookmark\Bookmark;
	10	use Shaarli\TestCase;
	11	use Slim\Http\Request;
	12
	13	class DailyPageHelperTest extends TestCase
	14	{
	15	/**
	16	* @dataProvider getRequestedTypes
	17	*/
	18	public function testExtractRequestedType(array $queryParams, string $expectedType): void
	19	{
	20	$request = $this->createMock(Request::class);
	21	$request->method('getQueryParam')->willReturnCallback(function ($key) use ($queryParams): ?string {
	22	return $queryParams[$key] ?? null;
	23	});
	24
	25	$type = DailyPageHelper::extractRequestedType($request);
	26
	27	static::assertSame($type, $expectedType);
	28	}
	29
	30	/**
	31	* @dataProvider getRequestedDateTimes
	32	*/
	33	public function testExtractRequestedDateTime(
	34	string $type,
	35	string $input,
	36	?Bookmark $bookmark,
f00600a2	37	DateTimeInterface $expectedDateTime,
36e6d88d A	38	string $compareFormat = 'Ymd'
	39	): void {
	40	$dateTime = DailyPageHelper::extractRequestedDateTime($type, $input, $bookmark);
	41
	42	static::assertSame($dateTime->format($compareFormat), $expectedDateTime->format($compareFormat));
	43	}
	44
	45	public function testExtractRequestedDateTimeExceptionUnknownType(): void
	46	{
	47	$this->expectException(\Exception::class);
	48	$this->expectExceptionMessage('Unsupported daily format type');
	49
	50	DailyPageHelper::extractRequestedDateTime('nope', null, null);
	51	}
	52
	53	/**
	54	* @dataProvider getFormatsByType
	55	*/
	56	public function testGetFormatByType(string $type, string $expectedFormat): void
	57	{
	58	$format = DailyPageHelper::getFormatByType($type);
	59
	60	static::assertSame($expectedFormat, $format);
	61	}
	62
	63	public function testGetFormatByTypeExceptionUnknownType(): void
	64	{
	65	$this->expectException(\Exception::class);
	66	$this->expectExceptionMessage('Unsupported daily format type');
	67
	68	DailyPageHelper::getFormatByType('nope');
	69	}
	70
	71	/**
	72	* @dataProvider getStartDatesByType
	73	*/
	74	public function testGetStartDatesByType(
	75	string $type,
f00600a2 A	76	DateTimeImmutable $dateTime,
f00600a2 A	77	DateTimeInterface $expectedDateTime
36e6d88d A	78	): void {
	79	$startDateTime = DailyPageHelper::getStartDateTimeByType($type, $dateTime);
	80
	81	static::assertEquals($expectedDateTime, $startDateTime);
	82	}
	83
	84	public function testGetStartDatesByTypeExceptionUnknownType(): void
	85	{
	86	$this->expectException(\Exception::class);
	87	$this->expectExceptionMessage('Unsupported daily format type');
	88
f00600a2	89	DailyPageHelper::getStartDateTimeByType('nope', new DateTimeImmutable());
36e6d88d A	90	}
	91
	92	/**
	93	* @dataProvider getEndDatesByType
	94	*/
	95	public function testGetEndDatesByType(
	96	string $type,
f00600a2 A	97	DateTimeImmutable $dateTime,
f00600a2 A	98	DateTimeInterface $expectedDateTime
36e6d88d A	99	): void {
	100	$endDateTime = DailyPageHelper::getEndDateTimeByType($type, $dateTime);
	101
	102	static::assertEquals($expectedDateTime, $endDateTime);
	103	}
	104
	105	public function testGetEndDatesByTypeExceptionUnknownType(): void
	106	{
	107	$this->expectException(\Exception::class);
	108	$this->expectExceptionMessage('Unsupported daily format type');
	109
f00600a2	110	DailyPageHelper::getEndDateTimeByType('nope', new DateTimeImmutable());
36e6d88d A	111	}
	112
	113	/**
	114	* @dataProvider getDescriptionsByType
	115	*/
	116	public function testGeDescriptionsByType(
	117	string $type,
f00600a2	118	DateTimeImmutable $dateTime,
36e6d88d A	119	string $expectedDescription
	120	): void {
	121	$description = DailyPageHelper::getDescriptionByType($type, $dateTime);
	122
	123	static::assertEquals($expectedDescription, $description);
	124	}
	125
2883c6d0 A	126	/**
	127	* @dataProvider getDescriptionsByTypeNotIncludeRelative
	128	*/
	129	public function testGeDescriptionsByTypeNotIncludeRelative(
	130	string $type,
	131	\DateTimeImmutable $dateTime,
	132	string $expectedDescription
	133	): void {
	134	$description = DailyPageHelper::getDescriptionByType($type, $dateTime, false);
	135
	136	static::assertEquals($expectedDescription, $description);
	137	}
	138
36e6d88d A	139	public function getDescriptionByTypeExceptionUnknownType(): void
	140	{
	141	$this->expectException(\Exception::class);
	142	$this->expectExceptionMessage('Unsupported daily format type');
	143
f00600a2	144	DailyPageHelper::getDescriptionByType('nope', new DateTimeImmutable());
36e6d88d A	145	}
	146
	147	/**
	148	* @dataProvider getRssLengthsByType
	149	*/
	150	public function testGeRssLengthsByType(string $type): void {
	151	$length = DailyPageHelper::getRssLengthByType($type);
	152
	153	static::assertIsInt($length);
	154	}
	155
	156	public function testGeRssLengthsByTypeExceptionUnknownType(): void
	157	{
	158	$this->expectException(\Exception::class);
	159	$this->expectExceptionMessage('Unsupported daily format type');
	160
	161	DailyPageHelper::getRssLengthByType('nope');
	162	}
	163
f00600a2 A	164	/**
	165	* @dataProvider getCacheDatePeriodByType
	166	*/
	167	public function testGetCacheDatePeriodByType(
	168	string $type,
	169	DateTimeImmutable $requested,
	170	DateTimeInterface $start,
	171	DateTimeInterface $end
	172	): void {
	173	$period = DailyPageHelper::getCacheDatePeriodByType($type, $requested);
	174
	175	static::assertEquals($start, $period->getStartDate());
	176	static::assertEquals($end, $period->getEndDate());
	177	}
	178
	179	public function testGetCacheDatePeriodByTypeExceptionUnknownType(): void
	180	{
	181	$this->expectException(\Exception::class);
	182	$this->expectExceptionMessage('Unsupported daily format type');
	183
	184	DailyPageHelper::getCacheDatePeriodByType('nope');
	185	}
	186
36e6d88d A	187	/**
	188	* Data provider for testExtractRequestedType() test method.
	189	*/
	190	public function getRequestedTypes(): array
	191	{
	192	return [
	193	[['month' => null], DailyPageHelper::DAY],
	194	[['month' => ''], DailyPageHelper::MONTH],
	195	[['month' => 'content'], DailyPageHelper::MONTH],
	196	[['week' => null], DailyPageHelper::DAY],
	197	[['week' => ''], DailyPageHelper::WEEK],
	198	[['week' => 'content'], DailyPageHelper::WEEK],
	199	[['day' => null], DailyPageHelper::DAY],
	200	[['day' => ''], DailyPageHelper::DAY],
	201	[['day' => 'content'], DailyPageHelper::DAY],
	202	];
	203	}
	204
	205	/**
	206	* Data provider for testExtractRequestedDateTime() test method.
	207	*/
	208	public function getRequestedDateTimes(): array
	209	{
	210	return [
	211	[DailyPageHelper::DAY, '20201013', null, new \DateTime('2020-10-13')],
	212	[
	213	DailyPageHelper::DAY,
	214	'',
	215	(new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
	216	$date,
	217	],
	218	[DailyPageHelper::DAY, '', null, new \DateTime()],
	219	[DailyPageHelper::WEEK, '202030', null, new \DateTime('2020-07-20')],
	220	[
	221	DailyPageHelper::WEEK,
	222	'',
	223	(new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
	224	new \DateTime('2020-10-13'),
	225	],
	226	[DailyPageHelper::WEEK, '', null, new \DateTime(), 'Ym'],
	227	[DailyPageHelper::MONTH, '202008', null, new \DateTime('2020-08-01'), 'Ym'],
	228	[
	229	DailyPageHelper::MONTH,
	230	'',
	231	(new Bookmark())->setCreated($date = new \DateTime('2020-10-13 12:05:31')),
	232	new \DateTime('2020-10-13'),
	233	'Ym'
	234	],
	235	[DailyPageHelper::MONTH, '', null, new \DateTime(), 'Ym'],
	236	];
	237	}
	238
	239	/**
	240	* Data provider for testGetFormatByType() test method.
	241	*/
	242	public function getFormatsByType(): array
	243	{
	244	return [
	245	[DailyPageHelper::DAY, 'Ymd'],
	246	[DailyPageHelper::WEEK, 'YW'],
	247	[DailyPageHelper::MONTH, 'Ym'],
	248	];
	249	}
	250
251	/**
252	* Data provider for testGetStartDatesByType() test method.
253	*/
254	public function getStartDatesByType(): array
255	{
256	return [
f00600a2 A	257	[DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-09 00:00:00')],
	258	[DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-05 00:00:00')],
	259	[DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-01 00:00:00')],
36e6d88d A	260	];
	261	}
	262
	263	/**
	264	* Data provider for testGetEndDatesByType() test method.
	265	*/
	266	public function getEndDatesByType(): array
	267	{
	268	return [
f00600a2 A	269	[DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-09 23:59:59')],
	270	[DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-11 23:59:59')],
	271	[DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), new \DateTime('2020-10-31 23:59:59')],
36e6d88d A	272	];
	273	}
	274
	275	/**
	276	* Data provider for testGetDescriptionsByType() test method.
	277	*/
	278	public function getDescriptionsByType(): array
	279	{
	280	return [
f00600a2 A	281	[DailyPageHelper::DAY, $date = new DateTimeImmutable(), 'Today - ' . $date->format('F j, Y')],
	282	[DailyPageHelper::DAY, $date = new DateTimeImmutable('-1 day'), 'Yesterday - ' . $date->format('F j, Y')],
	283	[DailyPageHelper::DAY, new DateTimeImmutable('2020-10-09 04:05:06'), 'October 9, 2020'],
	284	[DailyPageHelper::WEEK, new DateTimeImmutable('2020-10-09 04:05:06'), 'Week 41 (October 5, 2020)'],
	285	[DailyPageHelper::MONTH, new DateTimeImmutable('2020-10-09 04:05:06'), 'October, 2020'],
36e6d88d A	286	];
	287	}
	288
2883c6d0 A	289	/**
	290	* Data provider for testGeDescriptionsByTypeNotIncludeRelative() test method.
	291	*/
	292	public function getDescriptionsByTypeNotIncludeRelative(): array
	293	{
	294	return [
	295	[DailyPageHelper::DAY, $date = new \DateTimeImmutable(), $date->format('F j, Y')],
	296	[DailyPageHelper::DAY, $date = new \DateTimeImmutable('-1 day'), $date->format('F j, Y')],
	297	[DailyPageHelper::DAY, new \DateTimeImmutable('2020-10-09 04:05:06'), 'October 9, 2020'],
	298	[DailyPageHelper::WEEK, new \DateTimeImmutable('2020-10-09 04:05:06'), 'Week 41 (October 5, 2020)'],
	299	[DailyPageHelper::MONTH, new \DateTimeImmutable('2020-10-09 04:05:06'), 'October, 2020'],
	300	];
	301	}
	302
36e6d88d	303	/**
f00600a2	304	* Data provider for testGetRssLengthsByType() test method.
36e6d88d A	305	*/
	306	public function getRssLengthsByType(): array
	307	{
	308	return [
	309	[DailyPageHelper::DAY],
	310	[DailyPageHelper::WEEK],
	311	[DailyPageHelper::MONTH],
	312	];
	313	}
f00600a2 A	314
	315	/**
	316	* Data provider for testGetCacheDatePeriodByType() test method.
	317	*/
	318	public function getCacheDatePeriodByType(): array
	319	{
	320	return [
	321	[
	322	DailyPageHelper::DAY,
	323	new DateTimeImmutable('2020-10-09 04:05:06'),
	324	new \DateTime('2020-10-09 00:00:00'),
	325	new \DateTime('2020-10-09 23:59:59'),
	326	],
	327	[
	328	DailyPageHelper::WEEK,
	329	new DateTimeImmutable('2020-10-09 04:05:06'),
	330	new \DateTime('2020-10-05 00:00:00'),
	331	new \DateTime('2020-10-11 23:59:59'),
	332	],
	333	[
	334	DailyPageHelper::MONTH,
	335	new DateTimeImmutable('2020-10-09 04:05:06'),
	336	new \DateTime('2020-10-01 00:00:00'),
	337	new \DateTime('2020-10-31 23:59:59'),
	338	],
	339	];
	340	}
36e6d88d	341	}