Core23\SitemapBundle\Test\AbstractSitemapServiceTestCase

Complexity

Total Complexity

20

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
	createService()	0	1	?
B	process()	0	30	6
A	assertSitemap()	0	4	1
A	containsUrl()	0	10	3
A	assertLastmod()	0	16	5
A	assertPriority()	0	13	2
A	assertChangeFreq()	0	13	2

<?php

declare(strict_types=1);

/*
 * (c) Christian Gripp <mail@core23.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Core23\SitemapBundle\Test;

use Core23\SitemapBundle\Definition\SitemapDefinitionInterface;
use Core23\SitemapBundle\Model\UrlInterface;
use Core23\SitemapBundle\Sitemap\SitemapServiceInterface;
use DateTime;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Routing\RouterInterface;

abstract class AbstractSitemapServiceTestCase extends TestCase
{
    protected $router;

    /**
     * @var SitemapServiceInterface
     */
    protected $service;

    /**
     * @var array[]
     */
    private $urls = [];

    /**
     * {@inheritdoc}
     */
    protected function setUp(): void
    {
        $this->router = $this->createMock(RouterInterface::class);

        $this->service = $this->createService();
    }

    /**
     * @return SitemapServiceInterface
     */
    abstract protected function createService(): SitemapServiceInterface;

    /**
     * @param SitemapDefinitionInterface $sitemap
     */
    final protected function process(SitemapDefinitionInterface $sitemap): void
    {
        /** @var UrlInterface[] $urls */
        $result = $this->service->execute($sitemap);

        $count = \count($this->urls);
        $this->assertCount($count, $result);

        if ($count > 0) {
            /** @var UrlInterface $url */
            foreach ($result as $url) {
                if ($data = &$this->containsUrl($url)) {
                    $this->assertPriority($url, $data);
                    $this->assertChangeFreq($url, $data);
                    $this->assertLastmod($data, $url);
                    ++$data['count'];

                    continue;
                }

                throw new AssertionFailedError(sprintf("The url '%s' was not expected to be called.", $url->getLoc()));
            }
        }

        foreach ($this->urls as $data) {
            if (0 === $data['count']) {
                throw new AssertionFailedError(sprintf("The url '%s' was expected to be called actually was not called", $data['location']));
            }
        }
    }

    /**
     * @param string        $location
     * @param int           $priority
     * @param string        $changeFreq
     * @param DateTime|null $lastMod
     */
    final protected function assertSitemap(string $location, int $priority, string $changeFreq, DateTime $lastMod = null): void
    {
        $this->urls[] = ['location' => $location, 'priority' => $priority, 'changefreq' => $changeFreq, 'lastmod' => $lastMod, 'count' => 0];
    }

    /**
     * @param UrlInterface $url
     *
     * @return array|null
     */
    private function &containsUrl(UrlInterface $url): ?array
    {
        foreach ($this->urls as &$data) {
            if ($url->getLoc() === $data['location']) {
                return $data;
            }
        }

        return null;
    }

    /**
     * @param array|null   $data
     * @param UrlInterface $url
     */
    private function assertLastmod(?array $data, UrlInterface $url): void
    {
        if (null === $data['lastmod'] && null === $url->getLastMod()) {
            return;
        }

        if (!$data['lastmod'] instanceof DateTime) {
            throw new AssertionFailedError('The lastmod is not a valid \DateTime object.');
        }

        if ($url->getLastMod() <=> $data['lastmod']) {
            throw new AssertionFailedError(
                sprintf("The url '%s' was expected with a different lastmod.", $url->getLoc())
            );
        }
    }

    /**
     * @param UrlInterface $url
     * @param array|null   $data
     */
    private function assertPriority(UrlInterface $url, ?array $data): void
    {
        if ($url->getPriority() !== $data['priority']) {
            throw new AssertionFailedError(
                sprintf(
                    "The url '%s' was expected with %s priority. %s given.",
                    $url->getLoc(),
                    $data['priority'],
                    $url->getPriority()
                )
            );
        }
    }

    /**
     * @param UrlInterface $url
     * @param array|null   $data
     */
    private function assertChangeFreq(UrlInterface $url, ?array $data): void
    {
        if ($url->getChangeFreq() !== $data['changefreq']) {
            throw new AssertionFailedError(
                sprintf(
                    "The url '%s' was expected with %s changefreq. %s given.",
                    $url->getLoc(),
                    $data['changefreq'],
                    $url->getChangeFreq()
                )
            );
        }
    }
}