shlink/module/Core/test/EventDispatcher/LocateVisitTest.php

240 lines
9.8 KiB
PHP
Raw Normal View History

<?php
2019-10-05 10:26:10 -05:00
declare(strict_types=1);
namespace ShlinkioTest\Shlink\Core\EventDispatcher;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
2020-11-02 04:50:19 -06:00
use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Log\LoggerInterface;
2019-07-20 05:11:07 -05:00
use Shlinkio\Shlink\CLI\Exception\GeolocationDbUpdateFailedException;
use Shlinkio\Shlink\CLI\Util\GeolocationDbUpdaterInterface;
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\EventDispatcher\Event\UrlVisited;
use Shlinkio\Shlink\Core\EventDispatcher\Event\VisitLocated;
use Shlinkio\Shlink\Core\EventDispatcher\LocateVisit;
use Shlinkio\Shlink\Core\Model\Visitor;
use Shlinkio\Shlink\IpGeolocation\Exception\WrongIpException;
use Shlinkio\Shlink\IpGeolocation\Model\Location;
use Shlinkio\Shlink\IpGeolocation\Resolver\IpLocationResolverInterface;
class LocateVisitTest extends TestCase
{
2020-11-02 04:50:19 -06:00
use ProphecyTrait;
private LocateVisit $locateVisit;
private ObjectProphecy $ipLocationResolver;
private ObjectProphecy $em;
private ObjectProphecy $logger;
private ObjectProphecy $dbUpdater;
private ObjectProphecy $eventDispatcher;
public function setUp(): void
{
$this->ipLocationResolver = $this->prophesize(IpLocationResolverInterface::class);
$this->em = $this->prophesize(EntityManagerInterface::class);
$this->logger = $this->prophesize(LoggerInterface::class);
2019-07-20 05:11:07 -05:00
$this->dbUpdater = $this->prophesize(GeolocationDbUpdaterInterface::class);
$this->eventDispatcher = $this->prophesize(EventDispatcherInterface::class);
$this->locateVisit = new LocateVisit(
$this->ipLocationResolver->reveal(),
$this->em->reveal(),
2019-07-20 05:11:07 -05:00
$this->logger->reveal(),
$this->dbUpdater->reveal(),
2020-01-01 13:48:31 -06:00
$this->eventDispatcher->reveal(),
);
}
/** @test */
public function invalidVisitLogsWarning(): void
{
$event = new UrlVisited('123');
$findVisit = $this->em->find(Visit::class, '123')->willReturn(null);
$logWarning = $this->logger->warning('Tried to locate visit with id "{visitId}", but it does not exist.', [
'visitId' => 123,
]);
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
($this->locateVisit)($event);
$findVisit->shouldHaveBeenCalledOnce();
$this->em->flush()->shouldNotHaveBeenCalled();
$this->ipLocationResolver->resolveIpLocation(Argument::cetera())->shouldNotHaveBeenCalled();
$logWarning->shouldHaveBeenCalled();
$dispatch->shouldNotHaveBeenCalled();
}
/** @test */
public function invalidAddressLogsWarning(): void
{
$event = new UrlVisited('123');
$findVisit = $this->em->find(Visit::class, '123')->willReturn(
Visit::forValidShortUrl(ShortUrl::createEmpty(), new Visitor('', '', '1.2.3.4', '')),
);
$resolveLocation = $this->ipLocationResolver->resolveIpLocation(Argument::cetera())->willThrow(
2020-01-01 13:48:31 -06:00
WrongIpException::class,
);
$logWarning = $this->logger->warning(
Argument::containingString('Tried to locate visit with id "{visitId}", but its address seems to be wrong.'),
2020-01-01 13:48:31 -06:00
Argument::type('array'),
);
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
($this->locateVisit)($event);
$findVisit->shouldHaveBeenCalledOnce();
$resolveLocation->shouldHaveBeenCalledOnce();
$logWarning->shouldHaveBeenCalled();
$this->em->flush()->shouldNotHaveBeenCalled();
$dispatch->shouldHaveBeenCalledOnce();
}
/**
* @test
* @dataProvider provideNonLocatableVisits
*/
public function nonLocatableVisitsResolveToEmptyLocations(Visit $visit): void
{
$event = new UrlVisited('123');
$findVisit = $this->em->find(Visit::class, '123')->willReturn($visit);
2020-01-01 13:48:31 -06:00
$flush = $this->em->flush()->will(function (): void {
});
$resolveIp = $this->ipLocationResolver->resolveIpLocation(Argument::any());
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
($this->locateVisit)($event);
2020-10-03 17:35:14 -05:00
self::assertEquals($visit->getVisitLocation(), new VisitLocation(Location::emptyInstance()));
$findVisit->shouldHaveBeenCalledOnce();
$flush->shouldHaveBeenCalledOnce();
$resolveIp->shouldNotHaveBeenCalled();
$this->logger->warning(Argument::cetera())->shouldNotHaveBeenCalled();
$dispatch->shouldHaveBeenCalledOnce();
}
public function provideNonLocatableVisits(): iterable
{
$shortUrl = ShortUrl::createEmpty();
yield 'null IP' => [Visit::forValidShortUrl($shortUrl, new Visitor('', '', null, ''))];
yield 'empty IP' => [Visit::forValidShortUrl($shortUrl, new Visitor('', '', '', ''))];
yield 'localhost' => [Visit::forValidShortUrl($shortUrl, new Visitor('', '', IpAddress::LOCALHOST, ''))];
}
/**
* @test
* @dataProvider provideIpAddresses
*/
public function locatableVisitsResolveToLocation(Visit $visit, ?string $originalIpAddress): void
{
$ipAddr = $originalIpAddress ?? $visit->getRemoteAddr();
$location = new Location('', '', '', '', 0.0, 0.0, '');
$event = new UrlVisited('123', $originalIpAddress);
$findVisit = $this->em->find(Visit::class, '123')->willReturn($visit);
2020-01-01 13:48:31 -06:00
$flush = $this->em->flush()->will(function (): void {
});
$resolveIp = $this->ipLocationResolver->resolveIpLocation($ipAddr)->willReturn($location);
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
($this->locateVisit)($event);
2020-10-03 17:35:14 -05:00
self::assertEquals($visit->getVisitLocation(), new VisitLocation($location));
$findVisit->shouldHaveBeenCalledOnce();
$flush->shouldHaveBeenCalledOnce();
$resolveIp->shouldHaveBeenCalledOnce();
$this->logger->warning(Argument::cetera())->shouldNotHaveBeenCalled();
$dispatch->shouldHaveBeenCalledOnce();
}
2019-07-20 05:11:07 -05:00
public function provideIpAddresses(): iterable
{
yield 'no original IP address' => [
Visit::forValidShortUrl(ShortUrl::createEmpty(), new Visitor('', '', '1.2.3.4', '')),
null,
];
yield 'original IP address' => [
Visit::forValidShortUrl(ShortUrl::createEmpty(), new Visitor('', '', '1.2.3.4', '')),
'1.2.3.4',
];
yield 'base url' => [Visit::forBasePath(new Visitor('', '', '1.2.3.4', '')), '1.2.3.4'];
yield 'invalid short url' => [Visit::forInvalidShortUrl(new Visitor('', '', '1.2.3.4', '')), '1.2.3.4'];
yield 'regular not found' => [Visit::forRegularNotFound(new Visitor('', '', '1.2.3.4', '')), '1.2.3.4'];
}
2019-07-20 05:11:07 -05:00
/** @test */
public function errorWhenUpdatingGeoLiteWithExistingCopyLogsWarning(): void
2019-07-20 05:11:07 -05:00
{
$e = GeolocationDbUpdateFailedException::withOlderDb();
2019-07-20 05:11:07 -05:00
$ipAddr = '1.2.3.0';
$visit = Visit::forValidShortUrl(ShortUrl::createEmpty(), new Visitor('', '', $ipAddr, ''));
2019-07-20 05:11:07 -05:00
$location = new Location('', '', '', '', 0.0, 0.0, '');
$event = new UrlVisited('123');
2019-07-20 05:11:07 -05:00
$findVisit = $this->em->find(Visit::class, '123')->willReturn($visit);
2020-01-01 13:48:31 -06:00
$flush = $this->em->flush()->will(function (): void {
2019-07-20 05:11:07 -05:00
});
$resolveIp = $this->ipLocationResolver->resolveIpLocation($ipAddr)->willReturn($location);
$checkUpdateDb = $this->dbUpdater->checkDbUpdate(Argument::cetera())->willThrow($e);
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
2019-07-20 05:11:07 -05:00
($this->locateVisit)($event);
2020-10-03 17:35:14 -05:00
self::assertEquals($visit->getVisitLocation(), new VisitLocation($location));
2019-07-20 05:11:07 -05:00
$findVisit->shouldHaveBeenCalledOnce();
$flush->shouldHaveBeenCalledOnce();
$resolveIp->shouldHaveBeenCalledOnce();
$checkUpdateDb->shouldHaveBeenCalledOnce();
$this->logger->warning(
'GeoLite2 database update failed. Proceeding with old version. {e}',
2020-01-01 13:48:31 -06:00
['e' => $e],
2019-07-20 05:11:07 -05:00
)->shouldHaveBeenCalledOnce();
$dispatch->shouldHaveBeenCalledOnce();
2019-07-20 05:11:07 -05:00
}
/** @test */
public function errorWhenDownloadingGeoLiteCancelsLocation(): void
2019-07-20 05:11:07 -05:00
{
$e = GeolocationDbUpdateFailedException::withoutOlderDb();
2019-07-20 05:11:07 -05:00
$ipAddr = '1.2.3.0';
$visit = Visit::forValidShortUrl(ShortUrl::createEmpty(), new Visitor('', '', $ipAddr, ''));
2019-07-20 05:11:07 -05:00
$location = new Location('', '', '', '', 0.0, 0.0, '');
$event = new UrlVisited('123');
2019-07-20 05:11:07 -05:00
$findVisit = $this->em->find(Visit::class, '123')->willReturn($visit);
2020-01-01 13:48:31 -06:00
$flush = $this->em->flush()->will(function (): void {
2019-07-20 05:11:07 -05:00
});
$resolveIp = $this->ipLocationResolver->resolveIpLocation($ipAddr)->willReturn($location);
$checkUpdateDb = $this->dbUpdater->checkDbUpdate(Argument::cetera())->willThrow($e);
$logError = $this->logger->error(
'GeoLite2 database download failed. It is not possible to locate visit with id {visitId}. {e}',
2020-01-01 13:48:31 -06:00
['e' => $e, 'visitId' => 123],
2019-07-20 05:11:07 -05:00
);
2020-01-01 13:48:31 -06:00
$dispatch = $this->eventDispatcher->dispatch(new VisitLocated('123'))->will(function (): void {
});
2019-07-20 05:11:07 -05:00
($this->locateVisit)($event);
2020-10-03 17:35:14 -05:00
self::assertNull($visit->getVisitLocation());
2019-07-20 05:11:07 -05:00
$findVisit->shouldHaveBeenCalledOnce();
$flush->shouldNotHaveBeenCalled();
$resolveIp->shouldNotHaveBeenCalled();
$checkUpdateDb->shouldHaveBeenCalledOnce();
$logError->shouldHaveBeenCalledOnce();
$dispatch->shouldHaveBeenCalledOnce();
2019-07-20 05:11:07 -05:00
}
}