Merge branch 'feature/batch-info-provider-import'

tests/Services/ElementTypeNameGeneratorTest.php

@@ -25,11 +25,12 @@ namespace App\Tests\Services;
 use App\Entity\Attachments\PartAttachment;
 use App\Entity\Base\AbstractDBElement;
 use App\Entity\Base\AbstractNamedDBElement;
+use App\Entity\InfoProviderSystem\BulkInfoProviderImportJob;
 use App\Entity\Parts\Category;
 use App\Entity\Parts\Part;
 use App\Exceptions\EntityNotSupportedException;
-use App\Services\Formatters\AmountFormatter;
 use App\Services\ElementTypeNameGenerator;
+use App\Services\Formatters\AmountFormatter;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 
 class ElementTypeNameGeneratorTest extends WebTestCase
@@ -50,16 +51,18 @@ class ElementTypeNameGeneratorTest extends WebTestCase
         //We only test in english
         $this->assertSame('Part', $this->service->getLocalizedTypeLabel(new Part()));
         $this->assertSame('Category', $this->service->getLocalizedTypeLabel(new Category()));
+        $this->assertSame('Bulk info provider import', $this->service->getLocalizedTypeLabel(new BulkInfoProviderImportJob()));
 
         //Test inheritance
         $this->assertSame('Attachment', $this->service->getLocalizedTypeLabel(new PartAttachment()));
 
         //Test for class name
         $this->assertSame('Part', $this->service->getLocalizedTypeLabel(Part::class));
+        $this->assertSame('Bulk info provider import', $this->service->getLocalizedTypeLabel(BulkInfoProviderImportJob::class));
 
         //Test exception for unknpwn type
         $this->expectException(EntityNotSupportedException::class);
-        $this->service->getLocalizedTypeLabel(new class() extends AbstractDBElement {
+        $this->service->getLocalizedTypeLabel(new class () extends AbstractDBElement {
         });
     }
 
@@ -74,7 +77,7 @@ class ElementTypeNameGeneratorTest extends WebTestCase
 
         //Test exception
         $this->expectException(EntityNotSupportedException::class);
-        $this->service->getTypeNameCombination(new class() extends AbstractNamedDBElement {
+        $this->service->getTypeNameCombination(new class () extends AbstractNamedDBElement {
             public function getIDString(): string
             {
                 return 'Stub';

tests/Services/ImportExportSystem/EntityExporterTest.php

@@ -26,6 +26,7 @@ use App\Entity\Parts\Category;
 use App\Services\ImportExportSystem\EntityExporter;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 use Symfony\Component\HttpFoundation\Request;
+use PhpOffice\PhpSpreadsheet\IOFactory;
 
 class EntityExporterTest extends WebTestCase
 {
@@ -76,7 +77,40 @@ class EntityExporterTest extends WebTestCase
 
         $this->assertSame('application/json', $response->headers->get('Content-Type'));
         $this->assertNotEmpty($response->headers->get('Content-Disposition'));
+    }
 
+    public function testExportToExcel(): void
+    {
+        $entities = $this->getEntities();
 
+        $xlsxData = $this->service->exportEntities($entities, ['format' => 'xlsx', 'level' => 'simple']);
+        $this->assertNotEmpty($xlsxData);
+
+        $tempFile = tempnam(sys_get_temp_dir(), 'test_export') . '.xlsx';
+        file_put_contents($tempFile, $xlsxData);
+        
+        $spreadsheet = IOFactory::load($tempFile);
+        $worksheet = $spreadsheet->getActiveSheet();
+        
+        $this->assertSame('name', $worksheet->getCell('A1')->getValue());
+        $this->assertSame('full_name', $worksheet->getCell('B1')->getValue());
+        
+        $this->assertSame('Enitity 1', $worksheet->getCell('A2')->getValue());
+        $this->assertSame('Enitity 1', $worksheet->getCell('B2')->getValue());
+        
+        unlink($tempFile);
+    }
+
+    public function testExportExcelFromRequest(): void
+    {
+        $entities = $this->getEntities();
+
+        $request = new Request();
+        $request->request->set('format', 'xlsx');
+        $request->request->set('level', 'simple');
+        $response = $this->service->exportEntityFromRequest($entities, $request);
+
+        $this->assertSame('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', $response->headers->get('Content-Type'));
+        $this->assertStringContainsString('export_Category_simple.xlsx', $response->headers->get('Content-Disposition'));
     }
 }

tests/Services/ImportExportSystem/EntityImporterTest.php

@@ -36,6 +36,9 @@ use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 use Symfony\Component\Validator\ConstraintViolation;
 use Symfony\Component\Validator\ConstraintViolationListInterface;
+use Symfony\Component\HttpFoundation\File\File;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
 
 #[Group('DB')]
 class EntityImporterTest extends WebTestCase
@@ -207,6 +210,10 @@ EOT;
         yield ['json', 'json'];
         yield ['yaml', 'yml'];
         yield ['yaml', 'YAML'];
+        yield ['xlsx', 'xlsx'];
+        yield ['xlsx', 'XLSX'];
+        yield ['xls', 'xls'];
+        yield ['xls', 'XLS'];
     }
 
     #[DataProvider('formatDataProvider')]
@@ -342,4 +349,41 @@ EOT;
         $this->assertSame($category, $results[0]->getCategory());
         $this->assertSame('test,test2', $results[0]->getTags());
     }
+
+    public function testImportExcelFileProjects(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $worksheet = $spreadsheet->getActiveSheet();
+        
+        $worksheet->setCellValue('A1', 'name');
+        $worksheet->setCellValue('B1', 'comment');
+        $worksheet->setCellValue('A2', 'Test Excel 1');
+        $worksheet->setCellValue('B2', 'Test Excel 1 notes');
+        $worksheet->setCellValue('A3', 'Test Excel 2');
+        $worksheet->setCellValue('B3', 'Test Excel 2 notes');
+        
+        $tempFile = tempnam(sys_get_temp_dir(), 'test_excel') . '.xlsx';
+        $writer = new Xlsx($spreadsheet);
+        $writer->save($tempFile);
+        
+        $file = new File($tempFile);
+        
+        $errors = [];
+        $results = $this->service->importFile($file, [
+            'class' => Project::class,
+            'format' => 'xlsx',
+            'csv_delimiter' => ';',
+        ], $errors);
+
+        $this->assertCount(2, $results);
+        $this->assertEmpty($errors);
+        $this->assertContainsOnlyInstancesOf(Project::class, $results);
+
+        $this->assertSame('Test Excel 1', $results[0]->getName());
+        $this->assertSame('Test Excel 1 notes', $results[0]->getComment());
+        $this->assertSame('Test Excel 2', $results[1]->getName());
+        $this->assertSame('Test Excel 2 notes', $results[1]->getComment());
+        
+        unlink($tempFile);
+    }
 }

tests/Services/InfoProviderSystem/DTOs/BulkSearchFieldMappingDTOTest.php

@@ -0,0 +1,63 @@
+<?php
+/*
+ * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
+ *
+ *  Copyright (C) 2019 - 2025 Jan Böhmer (https://github.com/jbtronics)
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as published
+ *  by the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace App\Tests\Services\InfoProviderSystem\DTOs;
+
+use App\Services\InfoProviderSystem\DTOs\BulkSearchFieldMappingDTO;
+use PHPUnit\Framework\TestCase;
+
+class BulkSearchFieldMappingDTOTest extends TestCase
+{
+
+    public function testIsSupplierPartNumberField(): void
+    {
+        $fieldMapping = new BulkSearchFieldMappingDTO(field: 'reichelt_spn', providers: ['provider1'], priority: 1);
+        $this->assertTrue($fieldMapping->isSupplierPartNumberField());
+
+        $fieldMapping = new BulkSearchFieldMappingDTO(field: 'partNumber', providers: ['provider1'], priority: 1);
+        $this->assertFalse($fieldMapping->isSupplierPartNumberField());
+    }
+
+    public function testToSerializableArray(): void
+    {
+        $fieldMapping = new BulkSearchFieldMappingDTO(field: 'test', providers: ['provider1', 'provider2'], priority: 3);
+        $array = $fieldMapping->toSerializableArray();
+        $this->assertIsArray($array);
+        $this->assertSame([
+            'field' => 'test',
+            'providers' => ['provider1', 'provider2'],
+            'priority' => 3,
+        ], $array);
+    }
+
+    public function testFromSerializableArray(): void
+    {
+        $data = [
+            'field' => 'test',
+            'providers' => ['provider1', 'provider2'],
+            'priority' => 3,
+        ];
+        $fieldMapping = BulkSearchFieldMappingDTO::fromSerializableArray($data);
+        $this->assertInstanceOf(BulkSearchFieldMappingDTO::class, $fieldMapping);
+        $this->assertSame('test', $fieldMapping->field);
+        $this->assertSame(['provider1', 'provider2'], $fieldMapping->providers);
+        $this->assertSame(3, $fieldMapping->priority);
+    }
+}

tests/Services/InfoProviderSystem/DTOs/BulkSearchPartResultsDTOTest.php

@@ -0,0 +1,63 @@
+<?php
+/*
+ * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
+ *
+ *  Copyright (C) 2019 - 2025 Jan Böhmer (https://github.com/jbtronics)
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as published
+ *  by the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace App\Tests\Services\InfoProviderSystem\DTOs;
+
+use App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultsDTO;
+use PHPUnit\Framework\TestCase;
+
+class BulkSearchPartResultsDTOTest extends TestCase
+{
+
+    public function testHasErrors(): void
+    {
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], []);
+        $this->assertFalse($test->hasErrors());
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], ['error1']);
+        $this->assertTrue($test->hasErrors());
+    }
+
+    public function testGetErrorCount(): void
+    {
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], []);
+        $this->assertCount(0, $test->errors);
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], ['error1', 'error2']);
+        $this->assertCount(2, $test->errors);
+    }
+
+    public function testHasResults(): void
+    {
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], []);
+        $this->assertFalse($test->hasResults());
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [ $this->createMock(\App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultDTO::class) ], []);
+        $this->assertTrue($test->hasResults());
+    }
+
+    public function testGetResultCount(): void
+    {
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [], []);
+        $this->assertCount(0, $test->searchResults);
+        $test = new BulkSearchPartResultsDTO($this->createMock(\App\Entity\Parts\Part::class), [
+            $this->createMock(\App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultDTO::class),
+            $this->createMock(\App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultDTO::class)
+        ], []);
+        $this->assertCount(2, $test->searchResults);
+    }
+}

tests/Services/InfoProviderSystem/DTOs/BulkSearchResponseDTOTest.php

@@ -0,0 +1,258 @@
+<?php
+/*
+ * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
+ *
+ *  Copyright (C) 2019 - 2025 Jan Böhmer (https://github.com/jbtronics)
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as published
+ *  by the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace App\Tests\Services\InfoProviderSystem\DTOs;
+
+use App\Entity\Parts\Part;
+use App\Services\InfoProviderSystem\DTOs\BulkSearchResponseDTO;
+use App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultDTO;
+use App\Services\InfoProviderSystem\DTOs\BulkSearchPartResultsDTO;
+use App\Services\InfoProviderSystem\DTOs\SearchResultDTO;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+
+class BulkSearchResponseDTOTest extends KernelTestCase
+{
+
+    private EntityManagerInterface $entityManager;
+
+    private BulkSearchResponseDTO $dummyEmpty;
+    private BulkSearchResponseDTO $dummy;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->entityManager = self::getContainer()->get(EntityManagerInterface::class);
+
+        $this->dummyEmpty = new BulkSearchResponseDTO(partResults: []);
+        $this->dummy = new BulkSearchResponseDTO(partResults: [
+            new BulkSearchPartResultsDTO(
+                part: $this->entityManager->find(Part::class, 1),
+                searchResults: [
+                    new BulkSearchPartResultDTO(
+                        searchResult: new SearchResultDTO(provider_key: "dummy", provider_id: "1234", name: "Test Part", description: "A part for testing"),
+                        sourceField: "mpn", sourceKeyword: "1234", priority: 1
+                    ),
+                    new BulkSearchPartResultDTO(
+                        searchResult: new SearchResultDTO(provider_key: "test", provider_id: "test", name: "Test Part2", description: "A part for testing"),
+                        sourceField: "name", sourceKeyword: "1234",
+                        localPart: $this->entityManager->find(Part::class, 2), priority: 2,
+                    ),
+                ],
+                errors: ['Error 1']
+            )
+        ]);
+    }
+
+    public function testSerializationBackAndForthEmpty(): void
+    {
+        $serialized = $this->dummyEmpty->toSerializableRepresentation();
+        //Ensure that it is json_encodable
+        $json = json_encode($serialized, JSON_THROW_ON_ERROR);
+        $this->assertJson($json);
+        $deserialized = BulkSearchResponseDTO::fromSerializableRepresentation(json_decode($json), $this->entityManager);
+
+        $this->assertEquals($this->dummyEmpty, $deserialized);
+    }
+
+    public function testSerializationBackAndForth(): void
+    {
+        $serialized = $this->dummy->toSerializableRepresentation();
+        //Ensure that it is json_encodable
+        $this->assertJson(json_encode($serialized, JSON_THROW_ON_ERROR));
+        $deserialized = BulkSearchResponseDTO::fromSerializableRepresentation($serialized, $this->entityManager);
+
+        $this->assertEquals($this->dummy, $deserialized);
+    }
+
+    public function testToSerializableRepresentation(): void
+    {
+        $serialized = $this->dummy->toSerializableRepresentation();
+
+        $expected = array (
+            0 =>
+                array (
+                    'part_id' => 1,
+                    'search_results' =>
+                        array (
+                            0 =>
+                                array (
+                                    'dto' =>
+                                        array (
+                                            'provider_key' => 'dummy',
+                                            'provider_id' => '1234',
+                                            'name' => 'Test Part',
+                                            'description' => 'A part for testing',
+                                            'category' => NULL,
+                                            'manufacturer' => NULL,
+                                            'mpn' => NULL,
+                                            'preview_image_url' => NULL,
+                                            'manufacturing_status' => NULL,
+                                            'provider_url' => NULL,
+                                            'footprint' => NULL,
+                                        ),
+                                    'source_field' => 'mpn',
+                                    'source_keyword' => '1234',
+                                    'localPart' => NULL,
+                                    'priority' => 1,
+                                ),
+                            1 =>
+                                array (
+                                    'dto' =>
+                                        array (
+                                            'provider_key' => 'test',
+                                            'provider_id' => 'test',
+                                            'name' => 'Test Part2',
+                                            'description' => 'A part for testing',
+                                            'category' => NULL,
+                                            'manufacturer' => NULL,
+                                            'mpn' => NULL,
+                                            'preview_image_url' => NULL,
+                                            'manufacturing_status' => NULL,
+                                            'provider_url' => NULL,
+                                            'footprint' => NULL,
+                                        ),
+                                    'source_field' => 'name',
+                                    'source_keyword' => '1234',
+                                    'localPart' => 2,
+                                    'priority' => 2,
+                                ),
+                        ),
+                    'errors' =>
+                        array (
+                            0 => 'Error 1',
+                        ),
+                ),
+        );
+
+        $this->assertEquals($expected, $serialized);
+    }
+
+    public function testFromSerializableRepresentation(): void
+    {
+        $input = array (
+            0 =>
+                array (
+                    'part_id' => 1,
+                    'search_results' =>
+                        array (
+                            0 =>
+                                array (
+                                    'dto' =>
+                                        array (
+                                            'provider_key' => 'dummy',
+                                            'provider_id' => '1234',
+                                            'name' => 'Test Part',
+                                            'description' => 'A part for testing',
+                                            'category' => NULL,
+                                            'manufacturer' => NULL,
+                                            'mpn' => NULL,
+                                            'preview_image_url' => NULL,
+                                            'manufacturing_status' => NULL,
+                                            'provider_url' => NULL,
+                                            'footprint' => NULL,
+                                        ),
+                                    'source_field' => 'mpn',
+                                    'source_keyword' => '1234',
+                                    'localPart' => NULL,
+                                    'priority' => 1,
+                                ),
+                            1 =>
+                                array (
+                                    'dto' =>
+                                        array (
+                                            'provider_key' => 'test',
+                                            'provider_id' => 'test',
+                                            'name' => 'Test Part2',
+                                            'description' => 'A part for testing',
+                                            'category' => NULL,
+                                            'manufacturer' => NULL,
+                                            'mpn' => NULL,
+                                            'preview_image_url' => NULL,
+                                            'manufacturing_status' => NULL,
+                                            'provider_url' => NULL,
+                                            'footprint' => NULL,
+                                        ),
+                                    'source_field' => 'name',
+                                    'source_keyword' => '1234',
+                                    'localPart' => 2,
+                                    'priority' => 2,
+                                ),
+                        ),
+                    'errors' =>
+                        array (
+                            0 => 'Error 1',
+                        ),
+                ),
+        );
+
+        $deserialized = BulkSearchResponseDTO::fromSerializableRepresentation($input, $this->entityManager);
+        $this->assertEquals($this->dummy, $deserialized);
+    }
+
+    public function testMerge(): void
+    {
+        $merged = BulkSearchResponseDTO::merge($this->dummy, $this->dummyEmpty);
+        $this->assertCount(1, $merged->partResults);
+
+        $merged = BulkSearchResponseDTO::merge($this->dummyEmpty, $this->dummyEmpty);
+        $this->assertCount(0, $merged->partResults);
+
+        $merged = BulkSearchResponseDTO::merge($this->dummy, $this->dummy, $this->dummy);
+        $this->assertCount(3, $merged->partResults);
+    }
+
+    public function testReplaceResultsForPart(): void
+    {
+        $newPartResults = new BulkSearchPartResultsDTO(
+            part: $this->entityManager->find(Part::class, 1),
+            searchResults: [
+                new BulkSearchPartResultDTO(
+                    searchResult: new SearchResultDTO(provider_key: "new", provider_id: "new", name: "New Part", description: "A new part"),
+                    sourceField: "mpn", sourceKeyword: "new", priority: 1
+                )
+            ],
+            errors: ['New Error']
+        );
+
+        $replaced = $this->dummy->replaceResultsForPart($newPartResults);
+        $this->assertCount(1, $replaced->partResults);
+        $this->assertSame($newPartResults, $replaced->partResults[0]);
+    }
+
+    public function testReplaceResultsForPartNotExisting(): void
+    {
+        $newPartResults = new BulkSearchPartResultsDTO(
+            part: $this->entityManager->find(Part::class, 1),
+            searchResults: [
+                new BulkSearchPartResultDTO(
+                    searchResult: new SearchResultDTO(provider_key: "new", provider_id: "new", name: "New Part", description: "A new part"),
+                    sourceField: "mpn", sourceKeyword: "new", priority: 1
+                )
+            ],
+            errors: ['New Error']
+        );
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $replaced = $this->dummyEmpty->replaceResultsForPart($newPartResults);
+    }
+}

tests/Services/InfoProviderSystem/Providers/LCSCProviderTest.php

@@ -0,0 +1,540 @@
+<?php
+/*
+ * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
+ *
+ *  Copyright (C) 2019 - 2023 Jan Böhmer (https://github.com/jbtronics)
+ *  Copyright (C) 2024 Nexrem (https://github.com/meganukebmp)
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as published
+ *  by the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace App\Tests\Services\InfoProviderSystem\Providers;
+
+use App\Services\InfoProviderSystem\DTOs\FileDTO;
+use App\Services\InfoProviderSystem\DTOs\ParameterDTO;
+use App\Services\InfoProviderSystem\DTOs\PartDetailDTO;
+use App\Services\InfoProviderSystem\DTOs\PriceDTO;
+use App\Services\InfoProviderSystem\DTOs\PurchaseInfoDTO;
+use App\Services\InfoProviderSystem\Providers\LCSCProvider;
+use App\Services\InfoProviderSystem\Providers\ProviderCapabilities;
+use App\Settings\InfoProviderSystem\LCSCSettings;
+use App\Tests\SettingsTestHelper;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpClient\MockHttpClient;
+use Symfony\Component\HttpClient\Response\MockResponse;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+class LCSCProviderTest extends TestCase
+{
+    private LCSCSettings $settings;
+    private LCSCProvider $provider;
+    private MockHttpClient $httpClient;
+
+    protected function setUp(): void
+    {
+        $this->httpClient = new MockHttpClient();
+        $this->settings = SettingsTestHelper::createSettingsDummy(LCSCSettings::class);
+        $this->settings->currency = 'USD';
+        $this->settings->enabled = true;
+        $this->provider = new LCSCProvider($this->httpClient, $this->settings);
+    }
+
+    public function testGetProviderInfo(): void
+    {
+        $info = $this->provider->getProviderInfo();
+
+        $this->assertIsArray($info);
+        $this->assertArrayHasKey('name', $info);
+        $this->assertArrayHasKey('description', $info);
+        $this->assertArrayHasKey('url', $info);
+        $this->assertArrayHasKey('disabled_help', $info);
+        $this->assertEquals('LCSC', $info['name']);
+        $this->assertEquals('https://www.lcsc.com/', $info['url']);
+    }
+
+    public function testGetProviderKey(): void
+    {
+        $this->assertEquals('lcsc', $this->provider->getProviderKey());
+    }
+
+    public function testIsActiveWhenEnabled(): void
+    {
+        //Ensure that the settings are enabled
+        $this->settings->enabled = true;
+        $this->assertTrue($this->provider->isActive());
+    }
+
+    public function testIsActiveWhenDisabled(): void
+    {
+        //Ensure that the settings are disabled
+        $this->settings->enabled = false;
+        $this->assertFalse($this->provider->isActive());
+    }
+
+    public function testGetCapabilities(): void
+    {
+        $capabilities = $this->provider->getCapabilities();
+
+        $this->assertIsArray($capabilities);
+        $this->assertContains(ProviderCapabilities::BASIC, $capabilities);
+        $this->assertContains(ProviderCapabilities::PICTURE, $capabilities);
+        $this->assertContains(ProviderCapabilities::DATASHEET, $capabilities);
+        $this->assertContains(ProviderCapabilities::PRICE, $capabilities);
+        $this->assertContains(ProviderCapabilities::FOOTPRINT, $capabilities);
+    }
+
+    public function testSearchByKeywordWithCCode(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C123456',
+                'productModel' => 'Test Component',
+                'productIntroEn' => 'Test description',
+                'brandNameEn' => 'Test Manufacturer',
+                'encapStandard' => '0603',
+                'productImageUrl' => 'https://example.com/image.jpg',
+                'productImages' => ['https://example.com/image1.jpg'],
+                'productPriceList' => [
+                    ['ladder' => 1, 'productPrice' => '0.10', 'currencySymbol' => 'US$']
+                ],
+                'paramVOList' => [
+                    ['paramNameEn' => 'Resistance', 'paramValueEn' => '1kΩ']
+                ],
+                'pdfUrl' => 'https://example.com/datasheet.pdf',
+                'weight' => 0.001
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $results = $this->provider->searchByKeyword('C123456');
+
+        $this->assertIsArray($results);
+        $this->assertCount(1, $results);
+        $this->assertInstanceOf(PartDetailDTO::class, $results[0]);
+        $this->assertEquals('C123456', $results[0]->provider_id);
+        $this->assertEquals('Test Component', $results[0]->name);
+    }
+
+    public function testSearchByKeywordWithRegularTerm(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productSearchResultVO' => [
+                    'productList' => [
+                        [
+                            'productCode' => 'C789012',
+                            'productModel' => 'Regular Component',
+                            'productIntroEn' => 'Regular description',
+                            'brandNameEn' => 'Regular Manufacturer',
+                            'encapStandard' => '0805',
+                            'productImageUrl' => 'https://example.com/regular.jpg',
+                            'productImages' => ['https://example.com/regular1.jpg'],
+                            'productPriceList' => [
+                                ['ladder' => 10, 'productPrice' => '0.08', 'currencySymbol' => '€']
+                            ],
+                            'paramVOList' => [],
+                            'pdfUrl' => null,
+                            'weight' => null
+                        ]
+                    ]
+                ]
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $results = $this->provider->searchByKeyword('resistor');
+
+        $this->assertIsArray($results);
+        $this->assertCount(1, $results);
+        $this->assertInstanceOf(PartDetailDTO::class, $results[0]);
+        $this->assertEquals('C789012', $results[0]->provider_id);
+        $this->assertEquals('Regular Component', $results[0]->name);
+    }
+
+    public function testSearchByKeywordWithTipProduct(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productSearchResultVO' => [
+                    'productList' => []
+                ],
+                'tipProductDetailUrlVO' => [
+                    'productCode' => 'C555555'
+                ]
+            ]
+        ]));
+
+        $detailResponse = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C555555',
+                'productModel' => 'Tip Component',
+                'productIntroEn' => 'Tip description',
+                'brandNameEn' => 'Tip Manufacturer',
+                'encapStandard' => '1206',
+                'productImageUrl' => null,
+                'productImages' => [],
+                'productPriceList' => [],
+                'paramVOList' => [],
+                'pdfUrl' => null,
+                'weight' => null
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse, $detailResponse]);
+
+        $results = $this->provider->searchByKeyword('special');
+
+        $this->assertIsArray($results);
+        $this->assertCount(1, $results);
+        $this->assertInstanceOf(PartDetailDTO::class, $results[0]);
+        $this->assertEquals('C555555', $results[0]->provider_id);
+        $this->assertEquals('Tip Component', $results[0]->name);
+    }
+
+    public function testSearchByKeywordsBatch(): void
+    {
+        $mockResponse1 = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C123456',
+                'productModel' => 'Batch Component 1',
+                'productIntroEn' => 'Batch description 1',
+                'brandNameEn' => 'Batch Manufacturer',
+                'encapStandard' => '0603',
+                'productImageUrl' => null,
+                'productImages' => [],
+                'productPriceList' => [],
+                'paramVOList' => [],
+                'pdfUrl' => null,
+                'weight' => null
+            ]
+        ]));
+
+        $mockResponse2 = new MockResponse(json_encode([
+            'result' => [
+                'productSearchResultVO' => [
+                    'productList' => [
+                        [
+                            'productCode' => 'C789012',
+                            'productModel' => 'Batch Component 2',
+                            'productIntroEn' => 'Batch description 2',
+                            'brandNameEn' => 'Batch Manufacturer',
+                            'encapStandard' => '0805',
+                            'productImageUrl' => null,
+                            'productImages' => [],
+                            'productPriceList' => [],
+                            'paramVOList' => [],
+                            'pdfUrl' => null,
+                            'weight' => null
+                        ]
+                    ]
+                ]
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse1, $mockResponse2]);
+
+        $results = $this->provider->searchByKeywordsBatch(['C123456', 'resistor']);
+
+        $this->assertIsArray($results);
+        $this->assertArrayHasKey('C123456', $results);
+        $this->assertArrayHasKey('resistor', $results);
+        $this->assertCount(1, $results['C123456']);
+        $this->assertCount(1, $results['resistor']);
+        $this->assertEquals('C123456', $results['C123456'][0]->provider_id);
+        $this->assertEquals('C789012', $results['resistor'][0]->provider_id);
+    }
+
+    public function testGetDetails(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C123456',
+                'productModel' => 'Detailed Component',
+                'productIntroEn' => 'Detailed description',
+                'brandNameEn' => 'Detailed Manufacturer',
+                'encapStandard' => '0603',
+                'productImageUrl' => 'https://example.com/detail.jpg',
+                'productImages' => ['https://example.com/detail1.jpg'],
+                'productPriceList' => [
+                    ['ladder' => 1, 'productPrice' => '0.10', 'currencySymbol' => 'US$'],
+                    ['ladder' => 10, 'productPrice' => '0.08', 'currencySymbol' => 'US$']
+                ],
+                'paramVOList' => [
+                    ['paramNameEn' => 'Resistance', 'paramValueEn' => '1kΩ'],
+                    ['paramNameEn' => 'Tolerance', 'paramValueEn' => '1%']
+                ],
+                'pdfUrl' => 'https://example.com/datasheet.pdf',
+                'weight' => 0.001
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $result = $this->provider->getDetails('C123456');
+
+        $this->assertInstanceOf(PartDetailDTO::class, $result);
+        $this->assertEquals('C123456', $result->provider_id);
+        $this->assertEquals('Detailed Component', $result->name);
+        $this->assertEquals('Detailed description', $result->description);
+        $this->assertEquals('Detailed Manufacturer', $result->manufacturer);
+        $this->assertEquals('0603', $result->footprint);
+        $this->assertEquals('https://www.lcsc.com/product-detail/C123456.html', $result->provider_url);
+        $this->assertCount(1, $result->images);
+        $this->assertCount(2, $result->parameters);
+        $this->assertCount(1, $result->vendor_infos);
+        $this->assertEquals('0.001', $result->mass);
+    }
+
+    public function testGetDetailsWithNoResults(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productSearchResultVO' => [
+                    'productList' => []
+                ]
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('No part found with ID INVALID');
+
+        $this->provider->getDetails('INVALID');
+    }
+
+    public function testGetDetailsWithMultipleResults(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productSearchResultVO' => [
+                    'productList' => [
+                        [
+                            'productCode' => 'C123456',
+                            'productModel' => 'Component 1',
+                            'productIntroEn' => 'Description 1',
+                            'brandNameEn' => 'Manufacturer 1',
+                            'encapStandard' => '0603',
+                            'productImageUrl' => null,
+                            'productImages' => [],
+                            'productPriceList' => [],
+                            'paramVOList' => [],
+                            'pdfUrl' => null,
+                            'weight' => null
+                        ],
+                        [
+                            'productCode' => 'C789012',
+                            'productModel' => 'Component 2',
+                            'productIntroEn' => 'Description 2',
+                            'brandNameEn' => 'Manufacturer 2',
+                            'encapStandard' => '0805',
+                            'productImageUrl' => null,
+                            'productImages' => [],
+                            'productPriceList' => [],
+                            'paramVOList' => [],
+                            'pdfUrl' => null,
+                            'weight' => null
+                        ]
+                    ]
+                ]
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('Multiple parts found with ID ambiguous');
+
+        $this->provider->getDetails('ambiguous');
+    }
+
+    public function testSanitizeFieldPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('sanitizeField');
+        $method->setAccessible(true);
+
+        $this->assertNull($method->invokeArgs($this->provider, [null]));
+        $this->assertEquals('Clean text', $method->invokeArgs($this->provider, ['Clean text']));
+        $this->assertEquals('Text without tags', $method->invokeArgs($this->provider, ['<b>Text</b> without <i>tags</i>']));
+    }
+
+    public function testGetUsedCurrencyPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('getUsedCurrency');
+        $method->setAccessible(true);
+
+        $this->assertEquals('USD', $method->invokeArgs($this->provider, ['US$']));
+        $this->assertEquals('USD', $method->invokeArgs($this->provider, ['$']));
+        $this->assertEquals('EUR', $method->invokeArgs($this->provider, ['€']));
+        $this->assertEquals('GBP', $method->invokeArgs($this->provider, ['£']));
+        $this->assertEquals('USD', $method->invokeArgs($this->provider, ['UNKNOWN'])); // fallback to configured currency
+    }
+
+    public function testGetProductShortURLPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('getProductShortURL');
+        $method->setAccessible(true);
+
+        $result = $method->invokeArgs($this->provider, ['C123456']);
+        $this->assertEquals('https://www.lcsc.com/product-detail/C123456.html', $result);
+    }
+
+    public function testGetProductDatasheetsPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('getProductDatasheets');
+        $method->setAccessible(true);
+
+        $result = $method->invokeArgs($this->provider, [null]);
+        $this->assertIsArray($result);
+        $this->assertEmpty($result);
+
+        $result = $method->invokeArgs($this->provider, ['https://example.com/datasheet.pdf']);
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+        $this->assertInstanceOf(FileDTO::class, $result[0]);
+    }
+
+    public function testGetProductImagesPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('getProductImages');
+        $method->setAccessible(true);
+
+        $result = $method->invokeArgs($this->provider, [null]);
+        $this->assertIsArray($result);
+        $this->assertEmpty($result);
+
+        $result = $method->invokeArgs($this->provider, [['https://example.com/image1.jpg', 'https://example.com/image2.jpg']]);
+        $this->assertIsArray($result);
+        $this->assertCount(2, $result);
+        $this->assertInstanceOf(FileDTO::class, $result[0]);
+        $this->assertInstanceOf(FileDTO::class, $result[1]);
+    }
+
+    public function testAttributesToParametersPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('attributesToParameters');
+        $method->setAccessible(true);
+
+        $attributes = [
+            ['paramNameEn' => 'Resistance', 'paramValueEn' => '1kΩ'],
+            ['paramNameEn' => 'Tolerance', 'paramValueEn' => '1%'],
+            ['paramNameEn' => 'Empty', 'paramValueEn' => ''],
+            ['paramNameEn' => 'Dash', 'paramValueEn' => '-']
+        ];
+
+        $result = $method->invokeArgs($this->provider, [$attributes]);
+        $this->assertIsArray($result);
+        $this->assertCount(2, $result); // Only non-empty values
+        $this->assertInstanceOf(ParameterDTO::class, $result[0]);
+        $this->assertInstanceOf(ParameterDTO::class, $result[1]);
+    }
+
+    public function testPricesToVendorInfoPrivateMethod(): void
+    {
+        $reflection = new \ReflectionClass($this->provider);
+        $method = $reflection->getMethod('pricesToVendorInfo');
+        $method->setAccessible(true);
+
+        $prices = [
+            ['ladder' => 1, 'productPrice' => '0.10', 'currencySymbol' => 'US$'],
+            ['ladder' => 10, 'productPrice' => '0.08', 'currencySymbol' => 'US$']
+        ];
+
+        $result = $method->invokeArgs($this->provider, ['C123456', 'https://example.com', $prices]);
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+        $this->assertInstanceOf(PurchaseInfoDTO::class, $result[0]);
+        $this->assertEquals('LCSC', $result[0]->distributor_name);
+        $this->assertEquals('C123456', $result[0]->order_number);
+        $this->assertCount(2, $result[0]->prices);
+    }
+
+    public function testCategoryBuilding(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C123456',
+                'productModel' => 'Test Component',
+                'productIntroEn' => 'Test description',
+                'brandNameEn' => 'Test Manufacturer',
+                'parentCatalogName' => 'Electronic Components',
+                'catalogName' => 'Resistors/SMT',
+                'encapStandard' => '0603',
+                'productImageUrl' => null,
+                'productImages' => [],
+                'productPriceList' => [],
+                'paramVOList' => [],
+                'pdfUrl' => null,
+                'weight' => null
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $result = $this->provider->getDetails('C123456');
+        $this->assertEquals('Electronic Components -> Resistors -> SMT', $result->category);
+    }
+
+    public function testEmptyFootprintHandling(): void
+    {
+        $mockResponse = new MockResponse(json_encode([
+            'result' => [
+                'productCode' => 'C123456',
+                'productModel' => 'Test Component',
+                'productIntroEn' => 'Test description',
+                'brandNameEn' => 'Test Manufacturer',
+                'encapStandard' => '-',
+                'productImageUrl' => null,
+                'productImages' => [],
+                'productPriceList' => [],
+                'paramVOList' => [],
+                'pdfUrl' => null,
+                'weight' => null
+            ]
+        ]));
+
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $result = $this->provider->getDetails('C123456');
+        $this->assertNull($result->footprint);
+    }
+
+    public function testSearchByKeywordsBatchWithEmptyKeywords(): void
+    {
+        $result = $this->provider->searchByKeywordsBatch([]);
+        $this->assertIsArray($result);
+        $this->assertEmpty($result);
+    }
+
+    public function testSearchByKeywordsBatchWithException(): void
+    {
+        $mockResponse = new MockResponse('', ['http_code' => 500]);
+        $this->httpClient->setResponseFactory([$mockResponse]);
+
+        $results = $this->provider->searchByKeywordsBatch(['error']);
+        $this->assertIsArray($results);
+        $this->assertArrayHasKey('error', $results);
+        $this->assertEmpty($results['error']);
+    }
+}

tests/Services/Parts/PartsTableActionHandlerTest.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
+ *
+ *  Copyright (C) 2019 - 2023 Jan Böhmer (https://github.com/jbtronics)
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as published
+ *  by the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+namespace App\Tests\Services\Parts;
+
+use App\Entity\Parts\Part;
+use App\Services\Parts\PartsTableActionHandler;
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+
+class PartsTableActionHandlerTest extends WebTestCase
+{
+    private PartsTableActionHandler $service;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->service = self::getContainer()->get(PartsTableActionHandler::class);
+    }
+
+    public function testExportActionsRedirectToExportController(): void
+    {
+        // Mock a Part entity with required properties
+        $part = $this->createMock(Part::class);
+        $part->method('getId')->willReturn(1);
+        $part->method('getName')->willReturn('Test Part');
+        
+        $selected_parts = [$part];
+
+        // Test each export format, focusing on our new xlsx format
+        $formats = ['json', 'csv', 'xml', 'yaml', 'xlsx'];
+        
+        foreach ($formats as $format) {
+            $action = "export_{$format}";
+            $result = $this->service->handleAction($action, $selected_parts, 1, '/test');
+            
+            $this->assertInstanceOf(RedirectResponse::class, $result);
+            $this->assertStringContainsString('parts/export', $result->getTargetUrl());
+            $this->assertStringContainsString("format={$format}", $result->getTargetUrl());
+        }
+    }
+
+}