From e49048b666f49f697b2d825e4dcea236df034c0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20B=C3=B6hmer?= Date: Wed, 12 Nov 2025 21:31:44 +0100 Subject: [PATCH] Added tests --- ...nonymsAsTranslationParametersListener.php} | 4 +- src/Settings/SynonymSettings.php | 18 ++++- ...terSynonymsAsTranslationParametersTest.php | 49 ++++++++++++ .../Services/ElementTypeNameGeneratorTest.php | 41 +++++++++- tests/Services/ElementTypesTest.php | 79 +++++++++++++++++++ tests/Settings/SynonymSettingsTest.php | 76 ++++++++++++++++++ translations/messages.en.xlf | 12 +++ 7 files changed, 272 insertions(+), 7 deletions(-) rename src/EventListener/{RegisterSynonymsAsTranslationParameters.php => RegisterSynonymsAsTranslationParametersListener.php} (94%) create mode 100644 tests/EventListener/RegisterSynonymsAsTranslationParametersTest.php create mode 100644 tests/Services/ElementTypesTest.php create mode 100644 tests/Settings/SynonymSettingsTest.php diff --git a/src/EventListener/RegisterSynonymsAsTranslationParameters.php b/src/EventListener/RegisterSynonymsAsTranslationParametersListener.php similarity index 94% rename from src/EventListener/RegisterSynonymsAsTranslationParameters.php rename to src/EventListener/RegisterSynonymsAsTranslationParametersListener.php index e55a0f9a..b216aad4 100644 --- a/src/EventListener/RegisterSynonymsAsTranslationParameters.php +++ b/src/EventListener/RegisterSynonymsAsTranslationParametersListener.php @@ -35,7 +35,7 @@ use Symfony\Contracts\Cache\TagAwareCacheInterface; use Symfony\Contracts\Translation\TranslatorInterface; #[AsEventListener] -readonly class RegisterSynonymsAsTranslationParameters +readonly class RegisterSynonymsAsTranslationParametersListener { private Translator $translator; @@ -67,7 +67,7 @@ readonly class RegisterSynonymsAsTranslationParameters //And we have lowercase versions for both $placeholders['[' . $elementType->value . ']'] = mb_strtolower($this->typeNameGenerator->typeLabel($elementType)); - $placeholders['[' . $elementType->value . ']'] = mb_strtolower($this->typeNameGenerator->typeLabelPlural($elementType)); + $placeholders['[[' . $elementType->value . ']]'] = mb_strtolower($this->typeNameGenerator->typeLabelPlural($elementType)); } return $placeholders; diff --git a/src/Settings/SynonymSettings.php b/src/Settings/SynonymSettings.php index 1d1475ec..25fc87e9 100644 --- a/src/Settings/SynonymSettings.php +++ b/src/Settings/SynonymSettings.php @@ -71,7 +71,7 @@ class SynonymSettings */ public function isSynonymDefinedForType(ElementTypes $type): bool { - return isset($this->typeSynonyms[$type->value]); + return isset($this->typeSynonyms[$type->value]) && count($this->typeSynonyms[$type->value]) > 0; } /** @@ -97,4 +97,20 @@ class SynonymSettings ?? $this->typeSynonyms[$type->value][$locale]['singular'] ?? null; } + + /** + * Sets a synonym for the given type and locale. + * @param ElementTypes $type + * @param string $locale + * @param string $singular + * @param string $plural + * @return void + */ + public function setSynonymForType(ElementTypes $type, string $locale, string $singular, string $plural): void + { + $this->typeSynonyms[$type->value][$locale] = [ + 'singular' => $singular, + 'plural' => $plural, + ]; + } } diff --git a/tests/EventListener/RegisterSynonymsAsTranslationParametersTest.php b/tests/EventListener/RegisterSynonymsAsTranslationParametersTest.php new file mode 100644 index 00000000..d08edecb --- /dev/null +++ b/tests/EventListener/RegisterSynonymsAsTranslationParametersTest.php @@ -0,0 +1,49 @@ +. + */ + +namespace App\Tests\EventListener; + +use App\EventListener\RegisterSynonymsAsTranslationParametersListener; +use PHPUnit\Framework\TestCase; +use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase; + +class RegisterSynonymsAsTranslationParametersTest extends KernelTestCase +{ + + private RegisterSynonymsAsTranslationParametersListener $listener; + + public function setUp(): void + { + self::bootKernel(); + $this->listener = self::getContainer()->get(RegisterSynonymsAsTranslationParametersListener::class); + } + + public function testGetSynonymPlaceholders(): void + { + $placeholders = $this->listener->getSynonymPlaceholders(); + + $this->assertIsArray($placeholders); + $this->assertSame('Part', $placeholders['{part}']); + $this->assertSame('Parts', $placeholders['{{part}}']); + //Lowercase versions: + $this->assertSame('part', $placeholders['[part]']); + $this->assertSame('parts', $placeholders['[[part]]']); + } +} diff --git a/tests/Services/ElementTypeNameGeneratorTest.php b/tests/Services/ElementTypeNameGeneratorTest.php index f99b0676..8739dd06 100644 --- a/tests/Services/ElementTypeNameGeneratorTest.php +++ b/tests/Services/ElementTypeNameGeneratorTest.php @@ -30,20 +30,27 @@ use App\Entity\Parts\Category; use App\Entity\Parts\Part; use App\Exceptions\EntityNotSupportedException; use App\Services\ElementTypeNameGenerator; +use App\Services\ElementTypes; use App\Services\Formatters\AmountFormatter; +use App\Settings\SynonymSettings; use Symfony\Bundle\FrameworkBundle\Test\WebTestCase; class ElementTypeNameGeneratorTest extends WebTestCase { - /** - * @var AmountFormatter - */ - protected $service; + protected ElementTypeNameGenerator $service; + private SynonymSettings $synonymSettings; protected function setUp(): void { //Get an service instance. $this->service = self::getContainer()->get(ElementTypeNameGenerator::class); + $this->synonymSettings = self::getContainer()->get(SynonymSettings::class); + } + + protected function tearDown(): void + { + //Clean up synonym settings + $this->synonymSettings->typeSynonyms = []; } public function testGetLocalizedTypeNameCombination(): void @@ -84,4 +91,30 @@ class ElementTypeNameGeneratorTest extends WebTestCase } }); } + + public function testTypeLabel(): void + { + //If no synonym is defined, the default label should be used + $this->assertSame('Part', $this->service->typeLabel(Part::class)); + $this->assertSame('Part', $this->service->typeLabel(new Part())); + $this->assertSame('Part', $this->service->typeLabel(ElementTypes::PART)); + $this->assertSame('Part', $this->service->typeLabel('part')); + + //Define a synonym for parts in english + $this->synonymSettings->setSynonymForType(ElementTypes::PART, 'en', 'Singular', 'Plurals'); + $this->assertSame('Singular', $this->service->typeLabel(Part::class)); + } + + public function testTypeLabelPlural(): void + { + //If no synonym is defined, the default label should be used + $this->assertSame('Parts', $this->service->typeLabelPlural(Part::class)); + $this->assertSame('Parts', $this->service->typeLabelPlural(new Part())); + $this->assertSame('Parts', $this->service->typeLabelPlural(ElementTypes::PART)); + $this->assertSame('Parts', $this->service->typeLabelPlural('part')); + + //Define a synonym for parts in english + $this->synonymSettings->setSynonymForType(ElementTypes::PART, 'en', 'Singular', 'Plurals'); + $this->assertSame('Plurals', $this->service->typeLabelPlural(Part::class)); + } } diff --git a/tests/Services/ElementTypesTest.php b/tests/Services/ElementTypesTest.php new file mode 100644 index 00000000..d4fa77ff --- /dev/null +++ b/tests/Services/ElementTypesTest.php @@ -0,0 +1,79 @@ +. + */ + +namespace App\Tests\Services; + +use App\Entity\Parameters\CategoryParameter; +use App\Entity\Parts\Category; +use App\Exceptions\EntityNotSupportedException; +use App\Services\ElementTypes; +use PHPUnit\Framework\TestCase; + +class ElementTypesTest extends TestCase +{ + + public function testFromClass(): void + { + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromClass(Category::class)); + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromClass(new Category())); + + //Should also work with subclasses + $this->assertSame(ElementTypes::PARAMETER, ElementTypes::fromClass(CategoryParameter::class)); + $this->assertSame(ElementTypes::PARAMETER, ElementTypes::fromClass(new CategoryParameter())); + } + + public function testFromClassNotExisting(): void + { + $this->expectException(EntityNotSupportedException::class); + ElementTypes::fromClass(\LogicException::class); + } + + public function testFromValue(): void + { + //By enum value + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromValue('category')); + $this->assertSame(ElementTypes::ATTACHMENT, ElementTypes::fromValue('attachment')); + + //From enum instance + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromValue(ElementTypes::CATEGORY)); + + //From class string + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromValue(Category::class)); + $this->assertSame(ElementTypes::PARAMETER, ElementTypes::fromValue(CategoryParameter::class)); + + //From class instance + $this->assertSame(ElementTypes::CATEGORY, ElementTypes::fromValue(new Category())); + $this->assertSame(ElementTypes::PARAMETER, ElementTypes::fromValue(new CategoryParameter())); + } + + public function testGetDefaultLabelKey(): void + { + $this->assertSame('category.label', ElementTypes::CATEGORY->getDefaultLabelKey()); + $this->assertSame('attachment.label', ElementTypes::ATTACHMENT->getDefaultLabelKey()); + } + + public function testGetDefaultPluralLabelKey(): void + { + $this->assertSame('category.labelp', ElementTypes::CATEGORY->getDefaultPluralLabelKey()); + $this->assertSame('attachment.labelp', ElementTypes::ATTACHMENT->getDefaultPluralLabelKey()); + } + + +} diff --git a/tests/Settings/SynonymSettingsTest.php b/tests/Settings/SynonymSettingsTest.php new file mode 100644 index 00000000..2d1407ac --- /dev/null +++ b/tests/Settings/SynonymSettingsTest.php @@ -0,0 +1,76 @@ +. + */ + +namespace App\Tests\Settings; + +use App\Services\ElementTypes; +use App\Settings\SynonymSettings; +use App\Tests\SettingsTestHelper; +use PHPUnit\Framework\TestCase; + +class SynonymSettingsTest extends TestCase +{ + + public function testGetSingularSynonymForType(): void + { + $settings = SettingsTestHelper::createSettingsDummy(SynonymSettings::class); + $settings->typeSynonyms['category'] = [ + 'en' => ['singular' => 'Category', 'plural' => 'Categories'], + 'de' => ['singular' => 'Kategorie', 'plural' => 'Kategorien'], + ]; + + $this->assertEquals('Category', $settings->getSingularSynonymForType(ElementTypes::CATEGORY, 'en')); + $this->assertEquals('Kategorie', $settings->getSingularSynonymForType(ElementTypes::CATEGORY, 'de')); + + //If no synonym is defined, it should return null + $this->assertNull($settings->getSingularSynonymForType(ElementTypes::MANUFACTURER, 'en')); + } + + public function testIsSynonymDefinedForType(): void + { + $settings = SettingsTestHelper::createSettingsDummy(SynonymSettings::class); + $settings->typeSynonyms['category'] = [ + 'en' => ['singular' => 'Category', 'plural' => 'Categories'], + 'de' => ['singular' => 'Kategorie', 'plural' => 'Kategorien'], + ]; + + $settings->typeSynonyms['supplier'] = []; + + $this->assertTrue($settings->isSynonymDefinedForType(ElementTypes::CATEGORY)); + $this->assertFalse($settings->isSynonymDefinedForType(ElementTypes::FOOTPRINT)); + $this->assertFalse($settings->isSynonymDefinedForType(ElementTypes::SUPPLIER)); + } + + public function testGetPluralSynonymForType(): void + { + $settings = SettingsTestHelper::createSettingsDummy(SynonymSettings::class); + $settings->typeSynonyms['category'] = [ + 'en' => ['singular' => 'Category', 'plural' => 'Categories'], + 'de' => ['singular' => 'Kategorie',], + ]; + + $this->assertEquals('Categories', $settings->getPluralSynonymForType(ElementTypes::CATEGORY, 'en')); + //Fallback to singular if no plural is defined + $this->assertEquals('Kategorie', $settings->getPluralSynonymForType(ElementTypes::CATEGORY, 'de')); + + //If no synonym is defined, it should return null + $this->assertNull($settings->getPluralSynonymForType(ElementTypes::MANUFACTURER, 'en')); + } +} diff --git a/translations/messages.en.xlf b/translations/messages.en.xlf index acaee869..db4370f4 100644 --- a/translations/messages.en.xlf +++ b/translations/messages.en.xlf @@ -14400,5 +14400,17 @@ Please note that this system is currently experimental, and the synonyms defined Parts + + + log.element_edited.changed_fields.part_ipn_prefix + IPN prefix + + + + + part.labelp + Parts + +