jjsm01/kimai2
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Configurable PDF exports (#5641)

Browse Source
This commit is contained in:
Kevin Papst
2025-09-23 18:32:31 +02:00
committed by GitHub
parent 5d3e46cce2
commit 6d78c6ba36
107 changed files with 2428 additions and 1575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
tests/Controller/ExportControllerTest.php
View File

@@ -105,10 +105,8 @@ class ExportControllerTest extends AbstractControllerBaseTestCase
// assert export type buttons are available
$expected = [
'csv' => 'csv',
'default.html.twig' => 'default.html.twig',
'default-budget.pdf.twig' => 'default-budget.pdf.twig',
'default-internal.pdf.twig' => 'default-internal.pdf.twig',
'default.pdf.twig' => 'default.pdf.twig',
'html' => 'html',
'pdf' => 'pdf',
'xlsx' => 'xlsx'
];
$node = $client->getCrawler()->filter('#export-buttons .startExportBtn');
@@ -164,10 +162,8 @@ class ExportControllerTest extends AbstractControllerBaseTestCase
// assert export type buttons are available
$expected = [
'csv' => 'csv',
'default.html.twig' => 'default.html.twig',
'default-budget.pdf.twig' => 'default-budget.pdf.twig',
'default-internal.pdf.twig' => 'default-internal.pdf.twig',
'default.pdf.twig' => 'default.pdf.twig',
'html' => 'html',
'pdf' => 'pdf',
'xlsx' => 'xlsx'
];
$node = $client->getCrawler()->filter('#export-buttons .startExportBtn');
@@ -231,7 +227,7 @@ class ExportControllerTest extends AbstractControllerBaseTestCase
// don't add daterange to make sure the current month is the default range
$client->submit($form, [
'renderer' => 'default.html.twig',
'renderer' => 'html',
'markAsExported' => 1
]);

34
tests/Entity/ExportTemplateTest.php
View File

@@ -24,6 +24,12 @@ class ExportTemplateTest extends AbstractEntityTestCase
self::assertNull($sut->getLanguage());
self::assertEquals([], $sut->getColumns());
self::assertEquals([], $sut->getOptions());
self::assertNull($sut->getName());
self::assertNull($sut->getFont());
self::assertNull($sut->getOrientation());
self::assertNull($sut->getPageSize());
self::assertEquals(',', $sut->getSeparator());
self::assertEquals([], $sut->getSummaryColumns());
}
public function testSetter(): void
@@ -51,13 +57,24 @@ class ExportTemplateTest extends AbstractEntityTestCase
$sut->setColumns(null);
self::assertEquals([], $sut->getColumns());
$sut->setName('my name is funny');
$sut->setFont('Helvetica');
$sut->setPageSize('Letter');
$sut->setSummaryColumns(['customer', 'rate', 'duration_decimal']);
self::assertEquals('my name is funny', $sut->getName());
self::assertEquals('Helvetica', $sut->getFont());
self::assertEquals('Letter', $sut->getPageSize());
self::assertEquals(['customer', 'rate', 'duration_decimal'], $sut->getSummaryColumns());
$sut->setOptions(['foo' => 1, 'bar' => true, 'WORLD' => 'HELLO']);
self::assertEquals(['foo' => 1, 'bar' => true, 'WORLD' => 'HELLO'], $sut->getOptions());
$sut->setOption('empty', 123);
self::assertEquals(['foo' => 1, 'bar' => true, 'WORLD' => 'HELLO', 'empty' => 123], $sut->getOptions());
$sut->setOption('foo', 4711);
$sut->setOption('empty', null);
$sut->setOption('bar', false);
$sut->setOption('hello', 'kimai');
self::assertEquals(['foo' => 4711, 'bar' => false, 'WORLD' => 'HELLO', 'empty' => null, 'hello' => 'kimai'], $sut->getOptions());
self::assertEquals(['foo' => 4711, 'bar' => false, 'WORLD' => 'HELLO', 'hello' => 'kimai'], $sut->getOptions());
$sut->setOptions(null);
self::assertEquals([], $sut->getOptions());
}
@@ -75,6 +92,21 @@ class ExportTemplateTest extends AbstractEntityTestCase
$sut->setSeparator('.');
}
public function testSetOrientation(): void
{
$sut = new ExportTemplate();
self::assertNull($sut->getOrientation());
$sut->setOrientation('landscape');
self::assertEquals('landscape', $sut->getOrientation());
$sut->setOrientation('PORTRAIT');
self::assertEquals('portrait', $sut->getOrientation());
$sut->setOrientation('LandScapE');
self::assertEquals('landscape', $sut->getOrientation());
$this->expectException(\InvalidArgumentException::class);
$sut->setOrientation('vertical');
}
public function testClone(): void
{
$sut = new ExportTemplate();

51
tests/Export/Base/CsvRendererTest.php
View File

@@ -9,37 +9,31 @@
namespace App\Tests\Export\Base;
use App\Entity\User;
use App\Export\Base\AbstractSpreadsheetRenderer;
use App\Export\Base\CsvRenderer;
use App\Export\Base\SpreadsheetRenderer;
use App\Export\ColumnConverter;
use App\Export\DefaultTemplate;
use App\Export\Package\SpoutSpreadsheet;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use App\Tests\Mocks\MetaFieldColumnSubscriberMock;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Contracts\Translation\TranslatorInterface;
/**
* @covers \App\Export\Base\RendererTrait
*/
#[CoversClass(CsvRenderer::class)]
#[CoversClass(SpreadsheetRenderer::class)]
#[CoversClass(AbstractSpreadsheetRenderer::class)]
#[CoversClass(SpoutSpreadsheet::class)]
#[CoversClass(CsvRenderer::class)]
#[Group('integration')]
class CsvRendererTest extends AbstractRendererTestCase
{
protected function getAbstractRenderer(bool $exportDecimal = false): CsvRenderer
protected function getAbstractRenderer(?string $locale): CsvRenderer
{
$user = $this->createMock(User::class);
$user->expects($this->any())->method('isExportDecimal')->willReturn($exportDecimal);
$security = $this->createMock(Security::class);
$security->expects($this->any())->method('getUser')->willReturn($user);
$security->expects($this->any())->method('getUser')->willReturn(null);
$security->expects($this->any())->method('isGranted')->willReturn(true);
$translator = $this->getContainer()->get(TranslatorInterface::class);
@@ -48,21 +42,23 @@ class CsvRendererTest extends AbstractRendererTestCase
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MetaFieldColumnSubscriberMock());
return new CsvRenderer(new SpreadsheetRenderer($dispatcher, $security, $this->createMock(LoggerInterface::class)), $translator);
$converter = new ColumnConverter($dispatcher, $security);
$template = new DefaultTemplate($dispatcher, 'csv', $locale);
return new CsvRenderer($converter, $translator, $template);
}
public function testConfiguration(): void
public function testConfigurationFromTemplate(): void
{
$sut = $this->getAbstractRenderer();
$sut = $this->getAbstractRenderer('en');
self::assertEquals('csv', $sut->getType());
self::assertEquals('csv', $sut->getId());
self::assertEquals('default', $sut->getTitle());
$sut->setTitle('foo-bar');
self::assertEquals('foo-bar', $sut->getTitle());
$sut->setId('bar-id');
self::assertEquals('bar-id', $sut->getId());
self::assertFalse($sut->isInternal());
$sut->setInternal(true);
self::assertTrue($sut->isInternal());
}
public static function getTestModel(): array
@@ -89,11 +85,10 @@ class CsvRendererTest extends AbstractRendererTestCase
#[DataProvider('getTestModel')]
public function testRender(string $totalDuration, string $totalRate, string $expectedRate, int $expectedRows, int $expectedDescriptions, int $expectedUser1, int $expectedUser2, int $expectedUser3, bool $exportDecimal, ?string $locale, array $header): void
{
$sut = $this->getAbstractRenderer($exportDecimal);
$sut->setLocale($locale);
$sut = $this->getAbstractRenderer($locale);
/** @var BinaryFileResponse $response */
$response = $this->render($sut);
$response = $this->render($sut, $exportDecimal);
self::assertInstanceOf(BinaryFileResponse::class, $response);
$file = $response->getFile();
$prefix = date('Ymd');
@@ -120,10 +115,10 @@ class CsvRendererTest extends AbstractRendererTestCase
self::assertFalse(file_exists($file->getRealPath()));
$all = [];
$rows = str_getcsv($content2, PHP_EOL);
$rows = array_filter(explode(PHP_EOL, $content2), function (string $line) { return $line !== ''; });
foreach ($rows as $row) {
self::assertIsString($row);
$all[] = str_getcsv($row);
$all[] = str_getcsv($row, ',', '"', '\\');
}
self::assertEquals($header, $all[0]);

73
tests/Export/Base/HtmlRendererTest.php Normal file
View File

@@ -0,0 +1,73 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export\Base;
use App\Activity\ActivityStatisticService;
use App\Export\Base\HtmlRenderer;
use App\Export\Base\RendererTrait;
use App\Project\ProjectStatisticService;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\Response;
use Twig\Environment;
#[CoversClass(RendererTrait::class)]
#[CoversClass(HtmlRenderer::class)]
#[Group('integration')]
class HtmlRendererTest extends AbstractRendererTestCase
{
protected function getAbstractRenderer(): HtmlRenderer
{
return new HtmlRenderer(
$this->createMock(Environment::class),
$this->createMock(EventDispatcherInterface::class),
$this->createMock(ProjectStatisticService::class),
$this->createMock(ActivityStatisticService::class),
'foo',
'bar',
'export/print.html.twig'
);
}
public function testConfiguration(): void
{
$sut = $this->getAbstractRenderer();
self::assertEquals('foo', $sut->getId());
self::assertEquals('bar', $sut->getTitle());
self::assertEquals('html', $sut->getType());
self::assertFalse($sut->isInternal());
}
/**
* @group legacy
*/
public function testLegacy(): void
{
$sut = $this->getAbstractRenderer();
$sut->setTemplate('some'); // @phpstan-ignore method.deprecated
$sut->setId('xxxxxx'); // @phpstan-ignore method.deprecated
self::assertEquals('xxxxxx', $sut->getId());
}
public function testRender(): void
{
$sut = $this->getAbstractRenderer();
$response = $this->render($sut);
self::assertInstanceOf(Response::class, $response);
$content = $response->getContent();
self::assertIsString($content);
}
}

57
tests/Export/Base/PdfRendererTest.php
View File

@@ -10,17 +10,18 @@
namespace App\Tests\Export\Base;
use App\Export\Base\PDFRenderer;
use App\Export\Base\RendererTrait;
use App\Pdf\HtmlToPdfConverter;
use App\Pdf\PdfRendererTrait;
use App\Project\ProjectStatisticService;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use Symfony\Component\HttpFoundation\Response;
use Twig\Environment;
/**
* @covers \App\Export\Base\RendererTrait
* @covers \App\Pdf\PdfRendererTrait
*/
#[CoversClass(RendererTrait::class)]
#[CoversClass(PdfRendererTrait::class)]
#[CoversClass(PDFRenderer::class)]
#[Group('integration')]
class PdfRendererTest extends AbstractRendererTestCase
@@ -31,22 +32,22 @@ class PdfRendererTest extends AbstractRendererTestCase
$converter = $this->createMock(HtmlToPdfConverter::class);
$projectStatisticService = $this->createMock(ProjectStatisticService::class);
return new PDFRenderer($twig, $converter, $projectStatisticService);
return new PDFRenderer(
$twig,
$converter,
$projectStatisticService,
'foo',
'bar',
'export/print.html.twig'
);
}
public function testConfiguration(): void
{
$sut = $this->getAbstractRenderer();
self::assertEquals('pdf', $sut->getId());
self::assertEquals('pdf', $sut->getTitle());
$sut->setTitle('foo-bar');
self::assertEquals('foo-bar', $sut->getTitle());
$sut->setId('bar-id');
self::assertEquals('bar-id', $sut->getId());
self::assertEquals('foo', $sut->getId());
self::assertEquals('bar', $sut->getTitle());
self::assertEquals([], $sut->getPdfOptions());
$sut->setPdfOption('foo', 'bar');
self::assertEquals(['foo' => 'bar'], $sut->getPdfOptions());
@@ -54,5 +55,33 @@ class PdfRendererTest extends AbstractRendererTestCase
self::assertEquals(['foo' => 'bar2'], $sut->getPdfOptions());
$sut->setPdfOption('hello', 'world');
self::assertEquals(['foo' => 'bar2', 'hello' => 'world'], $sut->getPdfOptions());
self::assertFalse($sut->isInternal());
}
/**
* @group legacy
*/
public function testLegacy(): void
{
$sut = $this->getAbstractRenderer();
$sut->setTemplate('some'); // @phpstan-ignore method.deprecated
$sut->setTitle('xxxxxx'); // @phpstan-ignore method.deprecated
self::assertEquals('xxxxxx', $sut->getTitle());
}
public function testRender(): void
{
$sut = $this->getAbstractRenderer();
$response = $this->render($sut);
self::assertInstanceOf(Response::class, $response);
$prefix = date('Ymd');
self::assertEquals('application/pdf', $response->headers->get('Content-Type'));
self::assertEquals('attachment; filename=' . $prefix . '-Customer_Name-project_name.pdf', $response->headers->get('Content-Disposition'));
$content = $response->getContent();
self::assertIsString($content);
}
}

193
tests/Export/Base/PdfTemplateRendererTest.php Normal file
View File

@@ -0,0 +1,193 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export\Base;
use App\Entity\User;
use App\Export\Base\PdfTemplateRenderer;
use App\Export\Base\RendererTrait;
use App\Export\ColumnConverter;
use App\Export\DefaultTemplate;
use App\Export\Template;
use App\Export\TemplateInterface;
use App\Pdf\HtmlToPdfConverter;
use App\Pdf\PdfRendererTrait;
use App\Project\ProjectStatisticService;
use App\Repository\Query\TimesheetQuery;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use App\Tests\Mocks\MetaFieldColumnSubscriberMock;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Translation\LocaleSwitcher;
use Twig\Environment;
#[CoversClass(PdfRendererTrait::class)]
#[CoversClass(RendererTrait::class)]
#[CoversClass(PdfTemplateRenderer::class)]
#[Group('integration')]
class PdfTemplateRendererTest extends AbstractRendererTestCase
{
protected function getAbstractRenderer(Environment $twig, ?TemplateInterface $template = null): PdfTemplateRenderer
{
$htmlConverter = $this->createMock(HtmlToPdfConverter::class);
$projectStatisticService = $this->createMock(ProjectStatisticService::class);
$security = $this->createMock(Security::class);
$security->expects($this->any())->method('getUser')->willReturn(new User());
$security->expects($this->any())->method('isGranted')->willReturn(true);
$security->expects($this->any())->method('isGranted')->willReturn(true);
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MetaFieldColumnSubscriberMock());
if ($template === null) {
$template = new DefaultTemplate($dispatcher, 'test', 'en', 'bar');
}
$converter = new ColumnConverter($dispatcher, $security);
return new PdfTemplateRenderer(
$twig,
$htmlConverter,
$projectStatisticService,
$converter,
$this->createMock(LocaleSwitcher::class),
$template
);
}
public function testConfiguration(): void
{
$sut = $this->getAbstractRenderer($this->createMock(Environment::class));
self::assertEquals('test', $sut->getId());
self::assertEquals('bar', $sut->getTitle());
self::assertEquals('pdf', $sut->getType());
self::assertTrue($sut->isInternal());
}
public function testDefaultTemplateRender(): void
{
$twig = $this->createMock(Environment::class);
$twig->expects(self::once())->method('render')->willReturnCallback(function (string $templateName, array $options) {
if ($templateName !== 'export/renderer.pdf.twig') {
$this->fail('Wrong template given, expected "export/renderer.pdf.twig"');
}
self::assertArrayHasKey('font', $options);
self::assertArrayHasKey('columns', $options);
self::assertArrayHasKey('summary', $options);
self::assertArrayHasKey('template', $options);
self::assertArrayHasKey('title', $options);
self::assertArrayHasKey('locale', $options);
self::assertArrayHasKey('entries', $options);
self::assertArrayHasKey('query', $options);
self::assertEquals('sans-serif', $options['font']);
self::assertEquals([
'date',
'begin',
'end',
'duration',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
'timesheet.meta.foo',
'timesheet.meta.foo2',
'customer.meta.customer-foo',
'project.meta.project-foo',
'project.meta.project-foo2',
'activity.meta.activity-foo',
'user.meta.mypref',
], array_keys($options['columns']));
self::assertEquals([], $options['summary']);
self::assertNull($options['title']);
self::assertEquals('en', $options['locale']);
self::assertIsArray($options['entries']);
self::assertInstanceOf(TimesheetQuery::class, $options['query']);
return '';
});
$sut = $this->getAbstractRenderer($twig);
$response = $this->render($sut);
self::assertInstanceOf(Response::class, $response);
}
public function testRender(): void
{
$template = new Template('test_id', 'My title');
$template->setLocale('de');
$template->setOptions([
'summary_columns' => 'duration,rate,project_budget_money',
'orientation' => 'landscape',
'pageSize' => 'Letter',
'font' => 'freesans',
'name' => 'My title 2',
]);
$twig = $this->createMock(Environment::class);
$twig->expects(self::once())->method('render')->willReturnCallback(function (string $templateName, array $options) use ($template) {
if ($templateName !== 'export/renderer.pdf.twig') {
$this->fail('Wrong template given, expected "export/renderer.pdf.twig"');
}
self::assertArrayHasKey('font', $options);
self::assertArrayHasKey('columns', $options);
self::assertArrayHasKey('summary', $options);
self::assertArrayHasKey('template', $options);
self::assertArrayHasKey('title', $options);
self::assertArrayHasKey('locale', $options);
self::assertArrayHasKey('entries', $options);
self::assertArrayHasKey('query', $options);
self::assertEquals('freesans', $options['font']);
self::assertEquals([], $options['columns']);
self::assertEquals(['duration', 'rate', 'project_budget_money'], $options['summary']);
self::assertSame($options['template'], $template);
self::assertEquals('My title 2', $options['title']);
self::assertEquals('de', $options['locale']);
self::assertIsArray($options['entries']);
self::assertInstanceOf(TimesheetQuery::class, $options['query']);
return '';
});
$sut = $this->getAbstractRenderer($twig, $template);
$response = $this->render($sut);
self::assertInstanceOf(Response::class, $response);
$prefix = date('Ymd');
self::assertEquals('application/pdf', $response->headers->get('Content-Type'));
self::assertEquals('attachment; filename=' . $prefix . '-Customer_Name-project_name.pdf', $response->headers->get('Content-Disposition'));
$content = $response->getContent();
self::assertIsString($content);
}
}

193
tests/Export/Base/SpreadsheetRendererTest.php
View File

@@ -1,193 +0,0 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export\Base;
use App\Entity\ExportableItem;
use App\Export\Base\SpreadsheetRenderer;
use App\Export\Package\SpreadsheetPackage;
use App\Export\Template;
use App\Repository\Query\TimesheetQuery;
use App\Tests\Export\Package\MemoryPackage;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use App\Tests\Mocks\MetaFieldColumnSubscriberMock;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Contracts\Translation\TranslatorInterface;
#[CoversClass(SpreadsheetRenderer::class)]
#[Group('integration')]
class SpreadsheetRendererTest extends AbstractRendererTestCase
{
public function testWriteSpreadsheetCreatesSpreadsheetWithCorrectHeaders(): void
{
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$security = $this->createMock(Security::class);
$spreadsheetPackage = $this->createMock(SpreadsheetPackage::class);
$spreadsheetPackage->expects(self::once())->method('setColumns');
$renderer = new SpreadsheetRenderer($dispatcher, $security, $this->createMock(LoggerInterface::class));
$renderer->writeSpreadsheet($spreadsheetPackage, [], new TimesheetQuery());
}
public function testWriteSpreadsheetAddsRowsForExportItems(): void
{
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$security = $this->createMock(Security::class);
$spreadsheetPackage = $this->createMock(SpreadsheetPackage::class);
$spreadsheetPackage->expects(self::exactly(2))->method('addRow');
$spreadsheetPackage->expects(self::once())->method('save');
$exportItem = $this->createMock(ExportableItem::class);
$exportItem->method('getBegin')->willReturn(new \DateTime());
$exportItem->method('getEnd')->willReturn(new \DateTime());
$exportItem->method('getDuration')->willReturn(3600);
$exportItem->method('getRate')->willReturn(100.0);
$exportItem->method('getInternalRate')->willReturn(80.0);
$exportItem->method('getHourlyRate')->willReturn(50.0);
$exportItem->method('getFixedRate')->willReturn(200.0);
$exportItem->method('getUser')->willReturn(null);
$exportItem->method('getProject')->willReturn(null);
$exportItem->method('getActivity')->willReturn(null);
$exportItem->method('getDescription')->willReturn('Test description');
$exportItem->method('isBillable')->willReturn(true);
$exportItem->method('getTagsAsArray')->willReturn(['tag1', 'tag2']);
$exportItem->method('getType')->willReturn('type');
$exportItem->method('getCategory')->willReturn('category');
$renderer = new SpreadsheetRenderer($dispatcher, $security, $this->createMock(LoggerInterface::class));
$renderer->writeSpreadsheet($spreadsheetPackage, [$exportItem], new TimesheetQuery());
}
public function testWriteSpreadsheetAddsTotalRowWhenMoreThanOneRow(): void
{
$translator = $this->createMock(TranslatorInterface::class);
$translator->method('trans')->willReturnArgument(0);
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$security = $this->createMock(Security::class);
$spreadsheetPackage = $this->createMock(SpreadsheetPackage::class);
$spreadsheetPackage->expects(self::exactly(3))->method('addRow');
$exportItem = $this->createMock(ExportableItem::class);
$exportItem->method('getBegin')->willReturn(new \DateTime());
$exportItem->method('getEnd')->willReturn(new \DateTime());
$exportItem->method('getDuration')->willReturn(3600);
$exportItem->method('getRate')->willReturn(100.0);
$exportItem->method('getInternalRate')->willReturn(80.0);
$exportItem->method('getHourlyRate')->willReturn(50.0);
$exportItem->method('getFixedRate')->willReturn(200.0);
$exportItem->method('getUser')->willReturn(null);
$exportItem->method('getProject')->willReturn(null);
$exportItem->method('getActivity')->willReturn(null);
$exportItem->method('getDescription')->willReturn('Test description');
$exportItem->method('isBillable')->willReturn(true);
$exportItem->method('getTagsAsArray')->willReturn(['tag1', 'tag2']);
$exportItem->method('getType')->willReturn('type');
$exportItem->method('getCategory')->willReturn('category');
$renderer = new SpreadsheetRenderer($dispatcher, $security);
$renderer->writeSpreadsheet($spreadsheetPackage, [$exportItem, $exportItem], new TimesheetQuery());
}
public static function getTestData(): iterable
{
yield [null, [
'date' => 'date',
'begin' => 'begin',
'end' => 'end',
'duration' => 'duration',
'currency' => 'currency',
'rate' => 'rate',
'internalRate' => 'internalRate',
'hourlyRate' => 'hourlyRate',
'fixedRate' => 'fixedRate',
'alias' => 'alias',
'username' => 'username',
'account_number' => 'account_number',
'customer' => 'customer',
'project' => 'project',
'activity' => 'activity',
'description' => 'description',
'billable' => 'billable',
'tags' => 'tags',
'type' => 'type',
'category' => 'category',
'number' => 'number',
'project_number' => 'project_number',
'vat_id' => 'vat_id',
'orderNumber' => 'orderNumber',
'timesheet.meta.foo' => 'Working place',
'timesheet.meta.foo2' => 'Working place',
'customer.meta.customer-foo' => 'Working place',
'project.meta.project-foo' => 'Working place',
'project.meta.project-foo2' => 'Working place',
'activity.meta.activity-foo' => 'Working place',
'user.meta.mypref' => 'mypref',
'email' => 'email'
]];
$template = new Template('test', 'Testing');
$template->setLocale('de');
$template->setColumns(['date', 'user.name', 'duration_decimal', 'customer.name', 'exported', 'user.meta.mypref']);
yield [$template, [
'date' => 'date',
'duration' => 'duration',
'username' => 'username',
'customer' => 'customer',
'exported' => 'exported',
'user.meta.mypref' => 'mypref',
]];
}
#[DataProvider('getTestData')]
public function testWriteSpreadsheetCsv(?Template $template, array $expectedColumns): void
{
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MetaFieldColumnSubscriberMock());
$security = $this->createMock(Security::class);
$spreadsheetPackage = new MemoryPackage();
$exportItem = $this->createMock(ExportableItem::class);
$exportItem->method('getBegin')->willReturn(new \DateTime());
$exportItem->method('getEnd')->willReturn(new \DateTime());
$exportItem->method('getDuration')->willReturn(3600);
$exportItem->method('getRate')->willReturn(100.0);
$exportItem->method('getInternalRate')->willReturn(80.0);
$exportItem->method('getHourlyRate')->willReturn(50.0);
$exportItem->method('getFixedRate')->willReturn(200.0);
$exportItem->method('getUser')->willReturn(null);
$exportItem->method('getProject')->willReturn(null);
$exportItem->method('getActivity')->willReturn(null);
$exportItem->method('getDescription')->willReturn('Test description');
$exportItem->method('isBillable')->willReturn(true);
$exportItem->method('getTagsAsArray')->willReturn(['tag1', 'tag2']);
$exportItem->method('getType')->willReturn('type');
$exportItem->method('getCategory')->willReturn('category');
$renderer = new SpreadsheetRenderer($dispatcher, $security, $this->createMock(LoggerInterface::class));
$renderer->setTemplate($template);
$renderer->writeSpreadsheet($spreadsheetPackage, [$exportItem], new TimesheetQuery());
$columnNames = [];
foreach ($spreadsheetPackage->getColumns() as $column) {
$columnNames[$column->getName()] = $column->getHeader();
}
self::assertEquals(null, $spreadsheetPackage->getFilename());
self::assertEquals($expectedColumns, $columnNames);
self::assertCount(2, $spreadsheetPackage->getRows());
}
}

31
tests/Export/Base/XlsxRendererTest.php
View File

@@ -10,9 +10,11 @@
namespace App\Tests\Export\Base;
use App\Entity\User;
use App\Export\Base\SpreadsheetRenderer;
use App\Export\Base\AbstractSpreadsheetRenderer;
use App\Export\Base\XlsxRenderer;
use App\Export\ColumnConverter;
use App\Export\Package\SpoutSpreadsheet;
use App\Export\Renderer\XlsxRendererFactory;
use App\Tests\Export\Renderer\AbstractRendererTestCase;
use App\Tests\Mocks\MetaFieldColumnSubscriberMock;
use PHPUnit\Framework\Attributes\CoversClass;
@@ -22,12 +24,9 @@ use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Contracts\Translation\TranslatorInterface;
/**
* @covers \App\Export\Base\RendererTrait
*/
#[CoversClass(XlsxRenderer::class)]
#[CoversClass(SpreadsheetRenderer::class)]
#[CoversClass(AbstractSpreadsheetRenderer::class)]
#[CoversClass(SpoutSpreadsheet::class)]
#[CoversClass(XlsxRenderer::class)]
#[Group('integration')]
class XlsxRendererTest extends AbstractRendererTestCase
{
@@ -43,30 +42,30 @@ class XlsxRendererTest extends AbstractRendererTestCase
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MetaFieldColumnSubscriberMock());
return new XlsxRenderer(new SpreadsheetRenderer($dispatcher, $security), $translator);
$converter = new ColumnConverter($dispatcher, $security);
$factory = new XlsxRendererFactory($converter, $dispatcher, $translator);
return $factory->createDefault();
}
public function testConfiguration(): void
public function testConfigurationFromTemplate(): void
{
$sut = $this->getAbstractRenderer();
$sut->setLocale('de');
self::assertEquals('xlsx', $sut->getType());
self::assertEquals('xlsx', $sut->getId());
self::assertEquals('default', $sut->getTitle());
$sut->setTitle('foo-bar');
self::assertEquals('foo-bar', $sut->getTitle());
$sut->setId('bar-id');
self::assertEquals('bar-id', $sut->getId());
self::assertFalse($sut->isInternal());
$sut->setInternal(true);
self::assertTrue($sut->isInternal());
}
public function testRender(): void
{
$sut = $this->getAbstractRenderer();
/** @var BinaryFileResponse $response */
$response = $this->render($sut);
self::assertInstanceOf(BinaryFileResponse::class, $response);
$file = $response->getFile();
$prefix = date('Ymd');

291
tests/Export/ColumnConverterTest.php Normal file
View File

@@ -0,0 +1,291 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export;
use App\Entity\ActivityMeta;
use App\Entity\CustomerMeta;
use App\Entity\ProjectMeta;
use App\Entity\TimesheetMeta;
use App\Entity\User;
use App\Entity\UserPreference;
use App\Event\AbstractMetaDisplayEvent;
use App\Event\ActivityMetaDisplayEvent;
use App\Event\CustomerMetaDisplayEvent;
use App\Event\ProjectMetaDisplayEvent;
use App\Event\TimesheetMetaDisplayEvent;
use App\Event\UserPreferenceDisplayEvent;
use App\Export\ColumnConverter;
use App\Export\DefaultTemplate;
use App\Export\Template;
use App\Repository\Query\TimesheetQuery;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\EventDispatcher\EventDispatcher;
#[CoversClass(ColumnConverter::class)]
class ColumnConverterTest extends TestCase
{
public function testDefaultValues(): void
{
$dispatcher = new EventDispatcher();
$security = $this->createMock(Security::class);
$logger = $this->createMock(LoggerInterface::class);
$logger->expects(self::never())->method('warning');
$template = new DefaultTemplate($dispatcher, 'foo');
$query = new TimesheetQuery();
$sut = new ColumnConverter($dispatcher, $security, $logger);
$columns = $sut->getColumns($template, $query);
$expected = [
'date',
'begin',
'end',
'duration',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
];
self::assertEquals($expected, array_keys($columns));
}
public function testSkipsRate(): void
{
$user = new User();
$dispatcher = $this->createMock(EventDispatcher::class);
$security = $this->createMock(Security::class);
$security->method('getUser')->willReturn($user);
$security->method('isGranted')->willReturn(false);
$logger = $this->createMock(LoggerInterface::class);
$logger->expects(self::never())->method('warning');
$template = new DefaultTemplate($dispatcher, 'foo');
$query = new TimesheetQuery();
$query->setUser($user);
$sut = new ColumnConverter($dispatcher, $security, $logger);
$columns = $sut->getColumns($template, $query);
$expected = [
'date',
'begin',
'end',
'duration',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
];
self::assertEquals($expected, array_keys($columns));
}
public function testWithMetaFields(): void
{
$user = new User();
$dispatcher = $this->createMock(EventDispatcher::class);
$dispatcher->method('dispatch')->willReturnCallback(function (AbstractMetaDisplayEvent|UserPreferenceDisplayEvent $event) {
if ($event instanceof CustomerMetaDisplayEvent) {
$event->addField((new CustomerMeta())->setName('foo_meta')->setIsVisible(true));
$event->addField((new CustomerMeta())->setName('bar_meta')->setIsVisible(true));
} elseif ($event instanceof ProjectMetaDisplayEvent) {
$event->addField((new ProjectMeta())->setName('visible_project')->setIsVisible(true));
$event->addField((new ProjectMeta())->setName('hidden_project')->setIsVisible(false));
} elseif ($event instanceof ActivityMetaDisplayEvent) {
$event->addField((new ActivityMeta())->setName('activity_world')->setIsVisible(true));
$event->addField((new ActivityMeta())->setName('hello_activity')->setIsVisible(false));
} elseif ($event instanceof TimesheetMetaDisplayEvent) {
$event->addField((new TimesheetMeta())->setName('timesheet_one')->setIsVisible(true));
$event->addField((new TimesheetMeta())->setName('timesheet_two')->setIsVisible(false));
} elseif ($event instanceof UserPreferenceDisplayEvent) {
$event->addPreference((new UserPreference('user_acme'))->setEnabled(true));
$event->addPreference((new UserPreference('user_foo'))->setEnabled(false));
}
return $event;
});
$security = $this->createMock(Security::class);
$security->method('getUser')->willReturn($user);
$security->method('isGranted')->willReturn(false);
$logger = $this->createMock(LoggerInterface::class);
$logger->expects(self::never())->method('warning');
$template = new DefaultTemplate($dispatcher, 'foo');
$query = new TimesheetQuery();
$query->setUser($user);
$sut = new ColumnConverter($dispatcher, $security, $logger);
$columns = $sut->getColumns($template, $query);
$expected = [
'date',
'begin',
'end',
'duration',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
'timesheet.meta.timesheet_one',
'timesheet.meta.timesheet_two',
'customer.meta.foo_meta',
'customer.meta.bar_meta',
'project.meta.visible_project',
'project.meta.hidden_project',
'activity.meta.activity_world',
'activity.meta.hello_activity',
'user.meta.user_acme',
'user.meta.user_foo',
];
self::assertEquals($expected, array_keys($columns));
}
public function testWithAllAndUnknownColumns(): void
{
$user = new User();
$dispatcher = $this->createMock(EventDispatcher::class);
$security = $this->createMock(Security::class);
$security->method('getUser')->willReturn($user);
$security->method('isGranted')->willReturn(true);
$logger = $this->createMock(LoggerInterface::class);
$logger->expects(self::exactly(3))->method('warning');
$template = new Template('bar', 'foo');
$template->setColumns([
'date',
'begin',
'end',
'duration',
'duration_decimal',
'duration_seconds',
'break',
'break_decimal',
'break_seconds',
'exported',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'unknown.1',
'activity.number',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.tralalala',
'project.number',
'customer.vat_id',
'customer.is.never,evil',
'project.order_number',
]);
$query = new TimesheetQuery();
$query->setUser($user);
$sut = new ColumnConverter($dispatcher, $security, $logger);
$columns = $sut->getColumns($template, $query);
$expected = [
'date',
'begin',
'end',
'duration',
'duration_decimal',
'duration_seconds',
'break',
'break_decimal',
'break_seconds',
'exported',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'activity.number',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
];
self::assertEquals($expected, array_keys($columns));
}
}

114
tests/Export/DefaultTemplateTest.php Normal file
View File

@@ -0,0 +1,114 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export;
use App\Entity\User;
use App\Export\DefaultTemplate;
use App\Repository\Query\TimesheetQuery;
use App\Tests\Mocks\MetaFieldColumnSubscriberMock;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
use Psr\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
#[CoversClass(DefaultTemplate::class)]
class DefaultTemplateTest extends TestCase
{
public function testDefaultValues(): void
{
$template = new DefaultTemplate($this->createMock(EventDispatcherInterface::class), 'foo');
self::assertEquals('foo', $template->getId());
self::assertEquals('default', $template->getTitle());
self::assertEquals('en', $template->getLocale());
self::assertEquals([], $template->getOptions());
$columns = [
'date',
'begin',
'end',
'duration',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
];
self::assertEquals($columns, $template->getColumns(new TimesheetQuery()));
}
public function testFullConstructorWithDecimalDurationAndMetaColumns(): void
{
$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new MetaFieldColumnSubscriberMock());
$template = new DefaultTemplate($dispatcher, 'hello', null, 'world');
self::assertEquals('hello', $template->getId());
self::assertEquals('world', $template->getTitle());
self::assertNull($template->getLocale());
self::assertEquals([], $template->getOptions());
$user = new User();
$user->setPreferenceValue('export_decimal', true);
$query = new TimesheetQuery();
$query->setCurrentUser($user);
$columns = [
'date',
'begin',
'end',
'duration_decimal',
'currency',
'rate',
'internal_rate',
'hourly_rate',
'fixed_rate',
'user.alias',
'user.name',
'user.email',
'user.account_number',
'customer.name',
'project.name',
'activity.name',
'description',
'billable',
'tags',
'type',
'category',
'customer.number',
'project.number',
'customer.vat_id',
'project.order_number',
'timesheet.meta.foo',
'timesheet.meta.foo2',
'customer.meta.customer-foo',
'project.meta.project-foo',
'project.meta.project-foo2',
'activity.meta.activity-foo',
'user.meta.mypref',
];
self::assertEquals($columns, $template->getColumns($query));
}
}

27
tests/Export/Package/ColumnTest.php
View File

@@ -10,20 +10,38 @@
namespace App\Tests\Export\Package;
use App\Entity\ExportableItem;
use App\Entity\Timesheet;
use App\Export\Package\CellFormatter\CellFormatterInterface;
use App\Export\Package\CellFormatter\DateFormatter;
use App\Export\Package\Column;
use App\Export\Package\ColumnWidth;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
#[CoversClass(Column::class)]
class ColumnTest extends TestCase
{
public function testGetNameReturnsColumnName(): void
public function testDefaults(): void
{
$formatter = $this->createMock(CellFormatterInterface::class);
$column = new Column('testName', $formatter);
self::assertEquals('testName', $column->getName());
self::assertNull($column->getFormat());
self::assertEquals('testName', $column->getHeader());
self::assertSame(ColumnWidth::DEFAULT, $column->getColumnWidth());
$column->withColumnWidth(ColumnWidth::LARGE);
self::assertSame(ColumnWidth::LARGE, $column->getColumnWidth());
}
public function testThrowsOnMissiungExtractor(): void
{
$this->expectException(\InvalidArgumentException::class);
$this->expectExceptionMessage('Missing extractor on column: testName');
$formatter = $this->createMock(CellFormatterInterface::class);
$column = new Column('testName', $formatter);
self::assertEquals('testName', $column->getValue(new Timesheet()));
}
public function withHeaderSetsHeader(): void
@@ -86,13 +104,6 @@ class ColumnTest extends TestCase
self::assertEquals('testName', $column->getHeader());
}
public function testWithFormatReturnsNull(): void
{
$formatter = $this->createMock(CellFormatterInterface::class);
$column = new Column('testName', $formatter);
self::assertNull($column->getFormat());
}
public function testWithFormatReturnsValueFromFormatter(): void
{
$column = new Column('testName', new DateFormatter());

3
tests/Export/Package/MemoryPackage.php
View File

@@ -12,9 +12,6 @@ namespace App\Tests\Export\Package;
use App\Export\Package\Column;
use App\Export\Package\SpreadsheetPackage;
/**
* @covers \App\Export\Package\SpoutSpreadsheet
*/
class MemoryPackage implements SpreadsheetPackage
{
private ?string $filename = null;

6
tests/Export/Renderer/AbstractRendererTestCase.php
View File

@@ -26,7 +26,7 @@ use Symfony\Component\HttpFoundation\Response;
abstract class AbstractRendererTestCase extends KernelTestCase
{
protected function render(ExportRendererInterface $renderer): Response
protected function render(ExportRendererInterface $renderer, bool $exportDecimal = false): Response
{
$customer = new Customer('Customer Name');
$customer->setNumber('A-0123456789');
@@ -129,11 +129,15 @@ abstract class AbstractRendererTestCase extends KernelTestCase
$entries = [$timesheet, $timesheet2, $timesheet3, $timesheet4, $timesheet5, $timesheet6];
$currentUser = $this->createMock(User::class);
$currentUser->expects($this->any())->method('isExportDecimal')->willReturn($exportDecimal);
$query = new TimesheetQuery();
$query->setActivities([$activity]);
$query->setBegin(new \DateTime());
$query->setEnd(new \DateTime());
$query->setProjects([$project]);
$query->setCurrentUser($currentUser);
return $renderer->render($entries, $query);
}

13
tests/Export/Renderer/CsvRendererFactoryTest.php
View File

@@ -10,6 +10,7 @@
namespace App\Tests\Export\Renderer;
use App\Export\Base\CsvRenderer;
use App\Export\ColumnConverter;
use App\Export\Renderer\CsvRendererFactory;
use App\Export\Template;
use PHPUnit\Framework\Attributes\CoversClass;
@@ -24,12 +25,17 @@ class CsvRendererFactoryTest extends TestCase
{
public function testCreate(): void
{
$sut = new CsvRendererFactory(
$this->createMock(EventDispatcherInterface::class),
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$converter = new ColumnConverter(
$dispatcher,
$this->createMock(Security::class),
$this->createMock(TranslatorInterface::class),
$this->createMock(LoggerInterface::class)
);
$sut = new CsvRendererFactory(
$converter,
$dispatcher,
$this->createMock(TranslatorInterface::class),
);
$template = new Template('foo-id', 'bar-title');
$template->setLocale('it_IT');
@@ -39,5 +45,6 @@ class CsvRendererFactoryTest extends TestCase
self::assertInstanceOf(CsvRenderer::class, $renderer);
self::assertEquals('foo-id', $renderer->getId());
self::assertEquals('bar-title', $renderer->getTitle());
self::assertTrue($renderer->isInternal());
}
}

1
tests/Export/Renderer/HtmlRendererFactoryTest.php
View File

@@ -35,5 +35,6 @@ class HtmlRendererFactoryTest extends TestCase
self::assertInstanceOf(HtmlRenderer::class, $renderer);
self::assertEquals('foo', $renderer->getId());
self::assertEquals('print', $renderer->getTitle());
self::assertFalse($renderer->isInternal());
}
}

5
tests/Export/Renderer/HtmlRendererTest.php
View File

@@ -12,6 +12,7 @@ namespace App\Tests\Export\Renderer;
use App\Activity\ActivityStatisticService;
use App\Entity\User;
use App\Export\Base\HtmlRenderer;
use App\Export\Base\RendererTrait;
use App\Project\ProjectStatisticService;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
@@ -23,9 +24,7 @@ use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Twig\Environment;
/**
* @covers \App\Export\Base\RendererTrait
*/
#[CoversClass(RendererTrait::class)]
#[CoversClass(HtmlRenderer::class)]
#[Group('integration')]
class HtmlRendererTest extends AbstractRendererTestCase

27
tests/Export/Renderer/PdfRendererFactoryTest.php
View File

@@ -10,27 +10,38 @@
namespace App\Tests\Export\Renderer;
use App\Export\Base\PDFRenderer;
use App\Export\Base\PdfTemplateRenderer;
use App\Export\Renderer\PdfRendererFactory;
use App\Pdf\HtmlToPdfConverter;
use App\Project\ProjectStatisticService;
use App\Export\Template;
use App\Tests\Mocks\Export\PdfRendererFactoryMock;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
use Twig\Environment;
#[CoversClass(PdfRendererFactory::class)]
class PdfRendererFactoryTest extends TestCase
{
public function testCreate(): void
{
$sut = new PdfRendererFactory(
$this->createMock(Environment::class),
$this->createMock(HtmlToPdfConverter::class),
$this->createMock(ProjectStatisticService::class)
);
$mock = new PdfRendererFactoryMock($this);
$sut = $mock->create();
$renderer = $sut->create('foo', 'bar.pdf.twig');
self::assertInstanceOf(PDFRenderer::class, $renderer);
self::assertEquals('foo', $renderer->getId());
self::assertFalse($renderer->isInternal());
}
public function testCreateFromTemplate(): void
{
$mock = new PdfRendererFactoryMock($this);
$sut = $mock->create();
$template = new Template('foo', 'bar');
$renderer = $sut->createFromTemplate($template);
self::assertInstanceOf(PdfTemplateRenderer::class, $renderer);
self::assertEquals('foo', $renderer->getId());
self::assertTrue($renderer->isInternal());
}
}

7
tests/Export/Renderer/PdfRendererTest.php
View File

@@ -10,8 +10,10 @@
namespace App\Tests\Export\Renderer;
use App\Export\Base\PDFRenderer;
use App\Export\Base\RendererTrait;
use App\Pdf\HtmlToPdfConverter;
use App\Pdf\MPdfConverter;
use App\Pdf\PdfRendererTrait;
use App\Project\ProjectStatisticService;
use App\Tests\Mocks\FileHelperFactory;
use PHPUnit\Framework\Attributes\CoversClass;
@@ -20,9 +22,8 @@ use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Environment;
/**
* @covers \App\Export\Base\RendererTrait
*/
#[CoversClass(PDFRendererTrait::class)]
#[CoversClass(RendererTrait::class)]
#[CoversClass(PDFRenderer::class)]
#[Group('integration')]
class PdfRendererTest extends AbstractRendererTestCase

13
tests/Export/Renderer/XlsxRendererFactoryTest.php
View File

@@ -10,6 +10,7 @@
namespace App\Tests\Export\Renderer;
use App\Export\Base\XlsxRenderer;
use App\Export\ColumnConverter;
use App\Export\Renderer\XlsxRendererFactory;
use App\Export\Template;
use PHPUnit\Framework\Attributes\CoversClass;
@@ -24,12 +25,17 @@ class XlsxRendererFactoryTest extends TestCase
{
public function testCreate(): void
{
$sut = new XlsxRendererFactory(
$this->createMock(EventDispatcherInterface::class),
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$converter = new ColumnConverter(
$dispatcher,
$this->createMock(Security::class),
$this->createMock(TranslatorInterface::class),
$this->createMock(LoggerInterface::class)
);
$sut = new XlsxRendererFactory(
$converter,
$dispatcher,
$this->createMock(TranslatorInterface::class),
);
$template = new Template('foo-id', 'bar-title');
$template->setLocale('it_IT');
@@ -39,5 +45,6 @@ class XlsxRendererFactoryTest extends TestCase
self::assertInstanceOf(XlsxRenderer::class, $renderer);
self::assertEquals('foo-id', $renderer->getId());
self::assertEquals('bar-title', $renderer->getTitle());
self::assertTrue($renderer->isInternal());
}
}

30
tests/Export/ServiceExportTest.php
View File

@@ -16,7 +16,6 @@ use App\Export\Base\HtmlRenderer;
use App\Export\Base\XlsxRenderer;
use App\Export\ExportRepositoryInterface;
use App\Export\ServiceExport;
use App\Export\Timesheet\HtmlRenderer as HtmlExporter;
use App\Project\ProjectStatisticService;
use App\Repository\ExportTemplateRepository;
use App\Repository\Query\ExportQuery;
@@ -83,10 +82,10 @@ class ServiceExportTest extends TestCase
{
$sut = $this->createSut();
self::assertEmpty($sut->getRenderer());
self::assertCount(4, $sut->getRenderer());
self::assertNull($sut->getRendererById('default'));
self::assertEmpty($sut->getTimesheetExporter());
self::assertCount(4, $sut->getTimesheetExporter());
self::assertNull($sut->getTimesheetExporterById('default'));
}
@@ -102,7 +101,7 @@ class ServiceExportTest extends TestCase
);
$sut->addRenderer($renderer);
self::assertEquals(1, \count($sut->getRenderer()));
self::assertEquals(5, \count($sut->getRenderer()));
self::assertSame($renderer, $sut->getRendererById('html'));
}
@@ -110,10 +109,18 @@ class ServiceExportTest extends TestCase
{
$sut = $this->createSut();
$exporter = new HtmlExporter($this->createMock(Environment::class), new EventDispatcher(), $this->createMock(ProjectStatisticService::class), $this->createMock(ActivityStatisticService::class));
self::assertEquals(4, \count($sut->getTimesheetExporter()));
$exporter = new HtmlRenderer(
$this->createMock(Environment::class),
new EventDispatcher(),
$this->createMock(ProjectStatisticService::class),
$this->createMock(ActivityStatisticService::class),
'print'
);
$sut->addTimesheetExporter($exporter);
self::assertEquals(1, \count($sut->getTimesheetExporter()));
self::assertEquals(5, \count($sut->getTimesheetExporter()));
self::assertSame($exporter, $sut->getTimesheetExporterById('print'));
}
@@ -133,15 +140,12 @@ class ServiceExportTest extends TestCase
public function testWithTemplates(): void
{
$sut = $this->createSut(true, 5);
$sut = $this->createSut(true, 2);
$renderer = $sut->getRenderer();
self::assertCount(2, $renderer);
self::assertInstanceOf(CsvRenderer::class, $renderer[0]);
self::assertInstanceOf(XlsxRenderer::class, $renderer[1]);
self::assertCount(6, $renderer);
self::assertInstanceOf(CsvRenderer::class, $renderer[4]);
self::assertInstanceOf(XlsxRenderer::class, $renderer[5]);
self::assertInstanceOf(CsvRenderer::class, $sut->getRendererById('1'));
self::assertNull($sut->getRendererById('default'));
self::assertNull($sut->getRendererById('csv'));
self::assertNull($sut->getRendererById('xlsx'));
}
}

4
tests/Export/Spreadsheet/ColumnDefinitionTest.php
View File

@@ -22,9 +22,13 @@ class ColumnDefinitionTest extends TestCase
return 'hello world';
});
self::assertEquals('messages', $sut->getTranslationDomain());
self::assertEquals('foo', $sut->getLabel());
self::assertEquals('bar', $sut->getType());
self::assertIsCallable($sut->getAccessor());
self::assertEquals('hello world', \call_user_func($sut->getAccessor()));
$sut->setTranslationDomain('foo');
self::assertEquals('foo', $sut->getTranslationDomain());
}
}

7
tests/Export/TemplateTest.php
View File

@@ -10,6 +10,7 @@
namespace App\Tests\Export;
use App\Export\Template;
use App\Repository\Query\TimesheetQuery;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
@@ -22,7 +23,7 @@ class TemplateTest extends TestCase
self::assertEquals('id', $template->getId());
self::assertEquals('title', $template->getTitle());
self::assertNull($template->getLocale());
self::assertEquals([], $template->getColumns());
self::assertEquals([], $template->getColumns(new TimesheetQuery()));
self::assertEquals([], $template->getOptions());
}
@@ -31,9 +32,9 @@ class TemplateTest extends TestCase
$template = new Template('id', 'title');
$columns = ['Column1', 'Column2'];
$template->setColumns($columns);
self::assertEquals($columns, $template->getColumns());
self::assertEquals($columns, $template->getColumns(new TimesheetQuery()));
$template->setColumns([]);
self::assertEquals([], $template->getColumns());
self::assertEquals([], $template->getColumns(new TimesheetQuery()));
}
public function testSetsAndGetsOptionsCorrectly(): void

4
tests/Export/Timesheet/AbstractRendererTestCase.php
View File

@@ -24,7 +24,7 @@ use App\Event\ActivityMetaDisplayEvent;
use App\Event\CustomerMetaDisplayEvent;
use App\Event\ProjectMetaDisplayEvent;
use App\Event\TimesheetMetaDisplayEvent;
use App\Export\TimesheetExportInterface;
use App\Export\ExportRendererInterface;
use App\Repository\Query\TimesheetQuery;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
@@ -33,7 +33,7 @@ use Symfony\Component\HttpFoundation\Response;
abstract class AbstractRendererTestCase extends KernelTestCase
{
protected function render(TimesheetExportInterface $renderer): Response
protected function render(ExportRendererInterface $renderer): Response
{
$customer = new Customer('Customer Name');
$customer->setNumber('A-0123456789');

63
tests/Export/Timesheet/HtmlRendererTest.php
View File

@@ -1,63 +0,0 @@
<?php
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace App\Tests\Export\Timesheet;
use App\Activity\ActivityStatisticService;
use App\Export\Timesheet\HtmlRenderer;
use App\Project\ProjectStatisticService;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Group;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Environment;
#[CoversClass(HtmlRenderer::class)]
#[Group('integration')]
class HtmlRendererTest extends AbstractRendererTestCase
{
public function testConfiguration(): void
{
$sut = new HtmlRenderer(
$this->createMock(Environment::class),
new EventDispatcher(),
$this->createMock(ProjectStatisticService::class),
$this->createMock(ActivityStatisticService::class)
);
self::assertEquals('print', $sut->getId());
self::assertEquals('print', $sut->getTitle());
}
public function testRender(): void
{
$kernel = self::bootKernel();
/** @var Environment $twig */
$twig = self::getContainer()->get('twig');
/** @var RequestStack $stack */
$stack = self::getContainer()->get('request_stack');
$request = new Request();
$request->setLocale('en');
$stack->push($request);
$sut = new HtmlRenderer(
$twig,
new EventDispatcher(),
$this->createMock(ProjectStatisticService::class),
$this->createMock(ActivityStatisticService::class)
);
$response = $this->render($sut);
$content = $response->getContent();
self::assertStringContainsString('>1:50<', $content);
}
}

7
tests/Export/Timesheet/PdfRendererTest.php
View File

@@ -10,8 +10,10 @@
namespace App\Tests\Export\Timesheet;
use App\Export\Base\PDFRenderer;
use App\Export\Base\RendererTrait;
use App\Pdf\HtmlToPdfConverter;
use App\Pdf\MPdfConverter;
use App\Pdf\PdfRendererTrait;
use App\Project\ProjectStatisticService;
use App\Tests\Mocks\FileHelperFactory;
use PHPUnit\Framework\Attributes\CoversClass;
@@ -20,9 +22,8 @@ use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Environment;
/**
* @covers \App\Export\Base\RendererTrait
*/
#[CoversClass(PDFRendererTrait::class)]
#[CoversClass(RendererTrait::class)]
#[CoversClass(PDFRenderer::class)]
#[Group('integration')]
class PdfRendererTest extends AbstractRendererTestCase

13
tests/Mocks/Export/CsvRendererFactoryMock.php
View File

@@ -9,6 +9,7 @@
namespace App\Tests\Mocks\Export;
use App\Export\ColumnConverter;
use App\Export\Renderer\CsvRendererFactory;
use App\Tests\Mocks\AbstractMockFactory;
use Psr\EventDispatcher\EventDispatcherInterface;
@@ -20,11 +21,17 @@ class CsvRendererFactoryMock extends AbstractMockFactory
{
public function create(): CsvRendererFactory
{
return new CsvRendererFactory(
$this->createMock(EventDispatcherInterface::class),
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$converter = new ColumnConverter(
$dispatcher,
$this->createMock(Security::class),
$this->createMock(TranslatorInterface::class),
$this->createMock(LoggerInterface::class),
);
return new CsvRendererFactory(
$converter,
$dispatcher,
$this->createMock(TranslatorInterface::class),
);
}
}

13
tests/Mocks/Export/PdfRendererFactoryMock.php
View File

@@ -9,20 +9,33 @@
namespace App\Tests\Mocks\Export;
use App\Export\ColumnConverter;
use App\Export\Renderer\PdfRendererFactory;
use App\Pdf\HtmlToPdfConverter;
use App\Project\ProjectStatisticService;
use App\Tests\Mocks\AbstractMockFactory;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Log\LoggerInterface;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\Translation\LocaleSwitcher;
use Twig\Environment;
class PdfRendererFactoryMock extends AbstractMockFactory
{
public function create(): PdfRendererFactory
{
$converter = new ColumnConverter(
$this->createMock(EventDispatcherInterface::class),
$this->createMock(Security::class),
$this->createMock(LoggerInterface::class),
);
return new PdfRendererFactory(
$this->createMock(Environment::class),
$this->createMock(HtmlToPdfConverter::class),
$this->createMock(ProjectStatisticService::class),
$this->createMock(LocaleSwitcher::class),
$converter
);
}
}

13
tests/Mocks/Export/XlsxRendererFactoryMock.php
View File

@@ -9,6 +9,7 @@
namespace App\Tests\Mocks\Export;
use App\Export\ColumnConverter;
use App\Export\Renderer\XlsxRendererFactory;
use App\Tests\Mocks\AbstractMockFactory;
use Psr\EventDispatcher\EventDispatcherInterface;
@@ -20,11 +21,17 @@ class XlsxRendererFactoryMock extends AbstractMockFactory
{
public function create(): XlsxRendererFactory
{
return new XlsxRendererFactory(
$this->createMock(EventDispatcherInterface::class),
$dispatcher = $this->createMock(EventDispatcherInterface::class);
$converter = new ColumnConverter(
$dispatcher,
$this->createMock(Security::class),
$this->createMock(TranslatorInterface::class),
$this->createMock(LoggerInterface::class),
);
return new XlsxRendererFactory(
$converter,
$dispatcher,
$this->createMock(TranslatorInterface::class),
);
}
}

5
tests/phpstan.neon
View File

@@ -1351,11 +1351,6 @@ parameters:
count: 1
path: Export/Spreadsheet/Writer/BinaryFileResponseWriterTest.php
-
message: "#^Parameter \\#2 \\$haystack of static method PHPUnit\\\\Framework\\\\Assert\\:\\:assertStringContainsString\\(\\) expects string, string\\|false given\\.$#"
count: 1
path: Export/Timesheet/HtmlRendererTest.php
-
message: "#^Parameter \\#1 \\$items of method App\\\\Export\\\\TimesheetExportRepository\\:\\:setExported\\(\\) expects array\\<App\\\\Entity\\\\Timesheet\\>, array\\<int, App\\\\Entity\\\\Activity\\|App\\\\Entity\\\\Timesheet\\|stdClass\\|null\\> given\\.$#"
count: 1