shlink/module/CLI/test/Command/Visit/ProcessVisitsCommandTest.php

<?php
declare(strict_types=1);

namespace ShlinkioTest\Shlink\CLI\Command\Visit;

use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\Prophecy\ObjectProphecy;
use Shlinkio\Shlink\CLI\Command\Visit\ProcessVisitsCommand;
use Shlinkio\Shlink\Common\Exception\WrongIpException;
use Shlinkio\Shlink\Common\IpGeolocation\IpApiLocationResolver;
use Shlinkio\Shlink\Common\Util\IpAddress;
use Shlinkio\Shlink\Core\Entity\ShortUrl;
use Shlinkio\Shlink\Core\Entity\Visit;
use Shlinkio\Shlink\Core\Entity\VisitLocation;
use Shlinkio\Shlink\Core\Exception\IpCannotBeLocatedException;
use Shlinkio\Shlink\Core\Model\Visitor;
use Shlinkio\Shlink\Core\Service\VisitService;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Tester\CommandTester;
use Throwable;
use Zend\I18n\Translator\Translator;
use function array_shift;

class ProcessVisitsCommandTest extends TestCase
{
    /**
     * @var CommandTester
     */
    private $commandTester;
    /**
     * @var ObjectProphecy
     */
    private $visitService;
    /**
     * @var ObjectProphecy
     */
    private $ipResolver;

    public function setUp()
    {
        $this->visitService = $this->prophesize(VisitService::class);
        $this->ipResolver = $this->prophesize(IpApiLocationResolver::class);

        $command = new ProcessVisitsCommand(
            $this->visitService->reveal(),
            $this->ipResolver->reveal(),
            Translator::factory([])
        );
        $app = new Application();
        $app->add($command);

        $this->commandTester = new CommandTester($command);
    }

    /**
     * @test
     */
    public function allPendingVisitsAreProcessed()
    {
        $visit = new Visit(new ShortUrl(''), new Visitor('', '', '1.2.3.4'));
        $location = new VisitLocation([]);

        $locateVisits = $this->visitService->locateVisits(Argument::cetera())->will(
            function (array $args) use ($visit, $location) {
                $firstCallback = array_shift($args);
                $firstCallback($visit);

                $secondCallback = array_shift($args);
                $secondCallback($location, $visit);
            }
        );
        $resolveIpLocation = $this->ipResolver->resolveIpLocation(Argument::any())->willReturn([]);

        $this->commandTester->execute([
            'command' => 'visit:process',
        ]);
        $output = $this->commandTester->getDisplay();

        $this->assertContains('Processing IP 1.2.3.0', $output);
        $locateVisits->shouldHaveBeenCalledOnce();
        $resolveIpLocation->shouldHaveBeenCalledOnce();
    }

    /**
     * @test
     * @dataProvider provideIgnoredAddresses
     */
    public function localhostAndEmptyAddressesAreIgnored(?string $address, string $message)
    {
        $visit = new Visit(new ShortUrl(''), new Visitor('', '', $address));
        $location = new VisitLocation([]);

        $locateVisits = $this->visitService->locateVisits(Argument::cetera())->will(
            function (array $args) use ($visit, $location) {
                $firstCallback = array_shift($args);
                $firstCallback($visit);

                $secondCallback = array_shift($args);
                $secondCallback($location, $visit);
            }
        );
        $resolveIpLocation = $this->ipResolver->resolveIpLocation(Argument::any())->willReturn([]);

        try {
            $this->commandTester->execute([
                'command' => 'visit:process',
            ], ['verbosity' => OutputInterface::VERBOSITY_VERBOSE]);
        } catch (Throwable $e) {
            $output = $this->commandTester->getDisplay();

            $this->assertInstanceOf(IpCannotBeLocatedException::class, $e);

            $this->assertContains($message, $output);
            $locateVisits->shouldHaveBeenCalledOnce();
            $resolveIpLocation->shouldNotHaveBeenCalled();
        }
    }

    public function provideIgnoredAddresses(): array
    {
        return [
            ['', 'Ignored visit with no IP address'],
            [null, 'Ignored visit with no IP address'],
            [IpAddress::LOCALHOST, 'Ignored localhost address'],
        ];
    }

    /**
     * @test
     */
    public function errorWhileLocatingIpIsDisplayed()
    {
        $visit = new Visit(new ShortUrl(''), new Visitor('', '', '1.2.3.4'));
        $location = new VisitLocation([]);

        $locateVisits = $this->visitService->locateVisits(Argument::cetera())->will(
            function (array $args) use ($visit, $location) {
                $firstCallback = array_shift($args);
                $firstCallback($visit);

                $secondCallback = array_shift($args);
                $secondCallback($location, $visit);
            }
        );
        $resolveIpLocation = $this->ipResolver->resolveIpLocation(Argument::any())->willThrow(WrongIpException::class);

        try {
            $this->commandTester->execute([
                'command' => 'visit:process',
            ], ['verbosity' => OutputInterface::VERBOSITY_VERBOSE]);
        } catch (Throwable $e) {
            $output = $this->commandTester->getDisplay();

            $this->assertInstanceOf(IpCannotBeLocatedException::class, $e);

            $this->assertContains('An error occurred while locating IP. Skipped', $output);
            $locateVisits->shouldHaveBeenCalledOnce();
            $resolveIpLocation->shouldHaveBeenCalledOnce();
        }
    }
}