ALL = List.of(
+ CASE_1,
+ CASE_2,
+ CASE_3,
+ CASE_3B,
+ CASE_4,
+ CASE_5,
+ CASE_6,
+ CASE_7,
+ CASE_8,
+ CASE_9,
+ CASE_10,
+ CASE_11
+ );
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/tests/AbstractE2ETest.java b/src/test/java/de/avatic/lcc/e2e/tests/AbstractE2ETest.java
new file mode 100644
index 0000000..0045991
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/tests/AbstractE2ETest.java
@@ -0,0 +1,443 @@
+package de.avatic.lcc.e2e.tests;
+
+import com.microsoft.playwright.Browser;
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.BrowserType;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.Playwright;
+import de.avatic.lcc.LccApplication;
+import de.avatic.lcc.config.DatabaseTestConfiguration;
+import de.avatic.lcc.e2e.config.TestFrontendConfig;
+import de.avatic.lcc.e2e.pages.DevLoginPage;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.TestInstance;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.context.annotation.Import;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ActiveProfiles;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Abstract base class for E2E tests.
+ * Starts Spring Boot backend with integrated frontend and provides Playwright setup.
+ *
+ * Prerequisites:
+ *
+ * - Frontend must be built to src/main/resources/static before running tests
+ * - Run: {@code cd src/frontend && BUILD_FOR_SPRING=true npm run build}
+ *
+ *
+ * Or use Maven profile (if configured):
+ * {@code mvn test -Dtest="*E2ETest" -Pe2e}
+ */
+@SpringBootTest(
+ classes = LccApplication.class,
+ webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT
+)
+@Import({DatabaseTestConfiguration.class, TestFrontendConfig.class})
+@Testcontainers
+@ActiveProfiles({"test", "dev", "mysql", "e2e"})
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@Tag("e2e")
+public abstract class AbstractE2ETest {
+
+ @Autowired
+ protected JdbcTemplate jdbcTemplate;
+
+ private static final Logger logger = Logger.getLogger(AbstractE2ETest.class.getName());
+
+ protected static final boolean HEADLESS = Boolean.parseBoolean(
+ System.getProperty("playwright.headless", "true")
+ );
+ protected static final double TOLERANCE = 0.03; // 3% tolerance for numeric comparisons
+
+ @LocalServerPort
+ protected int port;
+
+ protected Playwright playwright;
+ protected Browser browser;
+ protected BrowserContext context;
+ protected Page page;
+
+ protected String getBaseUrl() {
+ return "http://localhost:" + port;
+ }
+
+ @BeforeAll
+ void setupPlaywright() {
+ // Load E2E test data
+ loadTestData();
+
+ checkFrontendBuilt();
+
+ logger.info("Setting up Playwright");
+ playwright = Playwright.create();
+ browser = playwright.chromium().launch(
+ new BrowserType.LaunchOptions()
+ .setHeadless(HEADLESS)
+ .setSlowMo(HEADLESS ? 0 : 100)
+ );
+
+ // Ensure screenshot directory exists
+ try {
+ Files.createDirectories(Paths.get("target/screenshots"));
+ } catch (Exception e) {
+ logger.warning("Could not create screenshots directory");
+ }
+
+ logger.info(() -> String.format(
+ "Playwright setup complete. Headless: %s, Base URL: %s",
+ HEADLESS, getBaseUrl()
+ ));
+ }
+
+ @BeforeEach
+ void setupPage() {
+ context = browser.newContext(new Browser.NewContextOptions()
+ .setViewportSize(1920, 1080)
+ );
+ page = context.newPage();
+
+ // Login via DevLoginPage
+ DevLoginPage loginPage = new DevLoginPage(page);
+ loginPage.login(getBaseUrl(), "John");
+
+ // Navigate to home page after login
+ page.navigate(getBaseUrl());
+ page.waitForLoadState();
+
+ // Take screenshot after login
+ takeScreenshot("after_login");
+
+ logger.info(() -> "Page setup complete, logged in as John. Current URL: " + page.url());
+ }
+
+ @AfterEach
+ void teardownPage() {
+ if (context != null) {
+ context.close();
+ }
+ }
+
+ @AfterAll
+ void teardownPlaywright() {
+ if (browser != null) {
+ browser.close();
+ }
+ if (playwright != null) {
+ playwright.close();
+ }
+ logger.info("Playwright teardown complete");
+ }
+
+ /**
+ * Takes a screenshot for debugging purposes.
+ */
+ protected void takeScreenshot(String name) {
+ Path screenshotPath = Paths.get("target/screenshots/" + name + ".png");
+ page.screenshot(new Page.ScreenshotOptions().setPath(screenshotPath));
+ logger.info(() -> "Screenshot saved to: " + screenshotPath);
+ }
+
+ /**
+ * Checks if the frontend has been built to static resources.
+ * Throws an exception with instructions if not.
+ */
+ private void checkFrontendBuilt() {
+ Path staticIndex = Paths.get("src/main/resources/static/index.html");
+ if (!Files.exists(staticIndex)) {
+ // Try to build frontend automatically
+ if (tryBuildFrontend()) {
+ logger.info("Frontend built successfully");
+ } else {
+ throw new IllegalStateException(
+ "Frontend not built. Please run:\n" +
+ " cd src/frontend && BUILD_FOR_SPRING=true npm run build\n" +
+ "Or set -Dskip.frontend.check=true to skip this check."
+ );
+ }
+ } else {
+ logger.info("Frontend already built at: " + staticIndex);
+ }
+ }
+
+ /**
+ * Attempts to build the frontend automatically.
+ * Returns true if successful, false otherwise.
+ */
+ private boolean tryBuildFrontend() {
+ if (Boolean.getBoolean("skip.frontend.build")) {
+ return false;
+ }
+
+ logger.info("Attempting to build frontend...");
+
+ try {
+ File frontendDir = new File("src/frontend");
+ if (!frontendDir.exists()) {
+ logger.warning("Frontend directory not found");
+ return false;
+ }
+
+ // Check if node_modules exists
+ File nodeModules = new File(frontendDir, "node_modules");
+ if (!nodeModules.exists()) {
+ logger.info("Installing npm dependencies...");
+ ProcessBuilder npmInstall = new ProcessBuilder("npm", "install")
+ .directory(frontendDir)
+ .inheritIO();
+ Process installProcess = npmInstall.start();
+ if (!installProcess.waitFor(5, TimeUnit.MINUTES)) {
+ installProcess.destroyForcibly();
+ return false;
+ }
+ }
+
+ // Build frontend (to dist/)
+ ProcessBuilder npmBuild = new ProcessBuilder("npm", "run", "build")
+ .directory(frontendDir)
+ .inheritIO();
+
+ Process buildProcess = npmBuild.start();
+ boolean completed = buildProcess.waitFor(3, TimeUnit.MINUTES);
+
+ if (!completed) {
+ buildProcess.destroyForcibly();
+ return false;
+ }
+
+ if (buildProcess.exitValue() != 0) {
+ return false;
+ }
+
+ // Copy dist/ to src/main/resources/static/
+ return copyFrontendToStatic(frontendDir);
+
+ } catch (IOException | InterruptedException e) {
+ logger.warning("Failed to build frontend: " + e.getMessage());
+ return false;
+ }
+ }
+
+ /**
+ * Loads E2E test data into the database.
+ * This is called once before all tests run.
+ */
+ private void loadTestData() {
+ logger.info("Loading E2E test data...");
+
+ // Check if test users already exist
+ Integer existingUsers = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM sys_user WHERE email = 'john.doe@test.com'",
+ Integer.class
+ );
+
+ if (existingUsers != null && existingUsers > 0) {
+ logger.info("Test users already exist, checking nodes...");
+ addMissingNodes();
+ return;
+ }
+
+ // Create test users
+ jdbcTemplate.update(
+ "INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active) VALUES (?, ?, ?, ?, ?)",
+ "WD001TEST", "john.doe@test.com", "John", "Doe", true
+ );
+ jdbcTemplate.update(
+ "INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active) VALUES (?, ?, ?, ?, ?)",
+ "WD002TEST", "jane.smith@test.com", "Jane", "Smith", true
+ );
+ jdbcTemplate.update(
+ "INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active) VALUES (?, ?, ?, ?, ?)",
+ "WD003TEST", "admin.test@test.com", "Admin", "User", true
+ );
+
+ // Assign groups to users
+ // John gets 'super' role for full E2E testing capabilities
+ jdbcTemplate.update(
+ "INSERT INTO sys_user_group_mapping (user_id, group_id) " +
+ "SELECT u.id, g.id FROM sys_user u, sys_group g " +
+ "WHERE u.email = 'john.doe@test.com' AND g.group_name = 'super'"
+ );
+ jdbcTemplate.update(
+ "INSERT INTO sys_user_group_mapping (user_id, group_id) " +
+ "SELECT u.id, g.id FROM sys_user u, sys_group g " +
+ "WHERE u.email = 'jane.smith@test.com' AND g.group_name = 'super'"
+ );
+ jdbcTemplate.update(
+ "INSERT INTO sys_user_group_mapping (user_id, group_id) " +
+ "SELECT u.id, g.id FROM sys_user u, sys_group g " +
+ "WHERE u.email = 'admin.test@test.com' AND g.group_name = 'super'"
+ );
+
+ // Add missing nodes for E2E tests
+ addMissingNodes();
+
+ logger.info("E2E test data loaded successfully");
+ }
+
+ /**
+ * Adds missing nodes needed for E2E tests.
+ */
+ private void addMissingNodes() {
+ logger.info("Adding missing nodes for E2E tests...");
+
+ // Add Ireland supplier to node table (if not exists)
+ Integer irelandCount = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM node WHERE name = 'Ireland supplier'", Integer.class);
+ if (irelandCount == null || irelandCount == 0) {
+ Integer ieCountryId = jdbcTemplate.queryForObject(
+ "SELECT id FROM country WHERE iso_code = 'IE'", Integer.class);
+ jdbcTemplate.update(
+ "INSERT INTO node (country_id, name, address, external_mapping_id, predecessor_required, " +
+ "is_destination, is_source, is_intermediate, geo_lat, geo_lng, is_deprecated) " +
+ "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+ ieCountryId, "Ireland supplier", "Dublin Ireland", "IE_SUP", false,
+ false, true, false, 53.3494, -6.2606, false
+ );
+ logger.info("Added Ireland supplier to node table");
+ }
+
+ // Get test user ID for sys_user_node entries
+ Integer testUserId = jdbcTemplate.queryForObject(
+ "SELECT id FROM sys_user WHERE email = 'john.doe@test.com'", Integer.class);
+
+ // Add Turkey supplier to sys_user_node (if not exists)
+ Integer turkeyCount = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM sys_user_node WHERE name = 'Turkey supplier'", Integer.class);
+ if (turkeyCount == null || turkeyCount == 0) {
+ Integer trCountryId = jdbcTemplate.queryForObject(
+ "SELECT id FROM country WHERE iso_code = 'TR'", Integer.class);
+ jdbcTemplate.update(
+ "INSERT INTO sys_user_node (user_id, country_id, name, address, geo_lat, geo_lng, is_deprecated) " +
+ "VALUES (?, ?, ?, ?, ?, ?, ?)",
+ testUserId, trCountryId, "Turkey supplier", "Antalya Türkiye",
+ 36.8864, 30.7105, false
+ );
+ logger.info("Added Turkey supplier to sys_user_node table");
+ }
+
+ // Add Yantian supplier to sys_user_node (if not exists)
+ Integer yantianCount = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM sys_user_node WHERE name = 'Yantian supplier'", Integer.class);
+ if (yantianCount == null || yantianCount == 0) {
+ Integer cnCountryId = jdbcTemplate.queryForObject(
+ "SELECT id FROM country WHERE iso_code = 'CN'", Integer.class);
+ jdbcTemplate.update(
+ "INSERT INTO sys_user_node (user_id, country_id, name, address, geo_lat, geo_lng, is_deprecated) " +
+ "VALUES (?, ?, ?, ?, ?, ?, ?)",
+ testUserId, cnCountryId, "Yantian supplier", "Yantian, China",
+ 22.5925, 114.2460, false
+ );
+ logger.info("Added Yantian supplier to sys_user_node table");
+ }
+
+ logger.info("Missing nodes added");
+
+ // Add test materials
+ addTestMaterials();
+ }
+
+ /**
+ * Adds test materials needed for E2E tests.
+ */
+ private void addTestMaterials() {
+ logger.info("Adding test materials...");
+
+ String[] materials = {
+ "3064540201", "003064540201", "84312000", "wheel hub",
+ "4222640104", "004222640104", "84139100", "gearbox housing blank",
+ "4222640803", "004222640803", "84139100", "planet gear carrier blank stage 1",
+ "4222640805", "004222640805", "84139100", "planet gear carrier blank stage 2",
+ "5512640106", "005512640106", "84312000", "transmission housing blank",
+ "8212640113", "008212640113", "84312000", "transmission housing blank GR2E-04",
+ "8212640827", "008212640827", "84312000", "planet gear carrier blank Stufe 1",
+ "8222640822", "008222640822", "84839089", "planet gear carrier blank stage 1",
+ "8263500575", "008263500575", "85015220", "traction motor assy"
+ };
+
+ for (int i = 0; i < materials.length; i += 4) {
+ String partNumber = materials[i];
+ String normalizedPartNumber = materials[i + 1];
+ String hsCode = materials[i + 2];
+ String name = materials[i + 3];
+
+ // Check by normalized_part_number since that has the UNIQUE constraint
+ Integer count = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM material WHERE normalized_part_number = ?",
+ Integer.class, normalizedPartNumber);
+ if (count == null || count == 0) {
+ try {
+ jdbcTemplate.update(
+ "INSERT INTO material (part_number, normalized_part_number, hs_code, name, is_deprecated) " +
+ "VALUES (?, ?, ?, ?, ?)",
+ partNumber, normalizedPartNumber, hsCode, name, false
+ );
+ logger.info(() -> "Added material: " + partNumber + " (normalized: " + normalizedPartNumber + ")");
+ } catch (Exception e) {
+ logger.warning(() -> "Failed to insert material " + partNumber + ": " + e.getMessage());
+ }
+ } else {
+ logger.info(() -> "Material already exists: " + normalizedPartNumber);
+ }
+ }
+
+ logger.info("Test materials added");
+ }
+
+ /**
+ * Copies the built frontend from dist/ to src/main/resources/static/.
+ */
+ private boolean copyFrontendToStatic(File frontendDir) {
+ Path source = frontendDir.toPath().resolve("dist");
+ Path target = Paths.get("src/main/resources/static");
+
+ if (!Files.exists(source)) {
+ logger.warning("Frontend dist directory not found: " + source);
+ return false;
+ }
+
+ try {
+ // Create target directory if needed
+ Files.createDirectories(target);
+
+ // Copy all files recursively
+ try (var walk = Files.walk(source)) {
+ walk.forEach(sourcePath -> {
+ try {
+ Path targetPath = target.resolve(source.relativize(sourcePath));
+ if (Files.isDirectory(sourcePath)) {
+ Files.createDirectories(targetPath);
+ } else {
+ Files.copy(sourcePath, targetPath,
+ java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+ }
+ } catch (IOException e) {
+ throw new RuntimeException("Failed to copy: " + sourcePath, e);
+ }
+ });
+ }
+
+ logger.info("Frontend copied to: " + target);
+ return true;
+
+ } catch (IOException | RuntimeException e) {
+ logger.warning("Failed to copy frontend: " + e.getMessage());
+ return false;
+ }
+ }
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/tests/CalculationWorkflowE2ETest.java b/src/test/java/de/avatic/lcc/e2e/tests/CalculationWorkflowE2ETest.java
new file mode 100644
index 0000000..758f172
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/tests/CalculationWorkflowE2ETest.java
@@ -0,0 +1,193 @@
+package de.avatic.lcc.e2e.tests;
+
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.options.WaitForSelectorState;
+import de.avatic.lcc.e2e.pages.AssistantPage;
+import de.avatic.lcc.e2e.pages.CalculationEditPage;
+import de.avatic.lcc.e2e.pages.ResultsPage;
+import de.avatic.lcc.e2e.testdata.DestinationInput;
+import de.avatic.lcc.e2e.testdata.TestCase;
+import de.avatic.lcc.e2e.testdata.TestCases;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.logging.Logger;
+import java.util.stream.Stream;
+
+/**
+ * End-to-end tests for the calculation workflow.
+ * Tests all scenarios from Testfälle.xlsx using Playwright.
+ *
+ *
The backend with integrated frontend is started automatically via @SpringBootTest.
+ *
+ *
Run with: {@code mvn test -Dtest=CalculationWorkflowE2ETest -Dgroups=e2e -Dspring.profiles.active=test,dev,mysql}
+ */
+@DisplayName("Calculation Workflow E2E Tests")
+class CalculationWorkflowE2ETest extends AbstractE2ETest {
+
+ private static final Logger logger = Logger.getLogger(CalculationWorkflowE2ETest.class.getName());
+
+ // Maximum time to wait for calculation to complete (in milliseconds)
+ private static final int CALCULATION_TIMEOUT_MS = 120000; // 2 minutes
+ private static final int POLL_INTERVAL_MS = 2000; // Check every 2 seconds
+
+ @ParameterizedTest(name = "Testfall {0}: {1}")
+ @MethodSource("provideTestCases")
+ @DisplayName("Calculation workflow")
+ void testCalculationWorkflow(String id, String name, TestCase testCase) {
+ logger.info(() -> "Starting test case: " + id + " - " + name);
+
+ try {
+ // 1. Navigate to assistant and search part numbers
+ AssistantPage assistant = new AssistantPage(page);
+ assistant.navigate(getBaseUrl());
+ assistant.searchPartNumbers(testCase.input().partNumber());
+
+ // 2. Select supplier
+ assistant.deletePreselectedSuppliers();
+ assistant.selectSupplier(testCase.input().supplierName());
+
+ // 3. Create calculation
+ assistant.createCalculation(testCase.input().loadFromPrevious());
+
+ // 4. Fill the calculation form
+ CalculationEditPage calcPage = new CalculationEditPage(page);
+ calcPage.fillForm(testCase.input());
+
+ // 5. Add and fill destinations
+ for (DestinationInput dest : testCase.input().destinations()) {
+ calcPage.addDestination(dest);
+ calcPage.fillDestination(dest);
+ }
+
+ // 6. Take screenshot before clicking Calculate & close
+ takeScreenshot("before_calculate_" + id);
+
+ // 7. Click "Calculate & close" button
+ Locator calcButton = page.locator("xpath=//button[contains(., 'Calculate & close')]");
+ calcButton.waitFor();
+
+ if (!calcButton.isEnabled()) {
+ throw new AssertionError("Calculate & close button is not enabled");
+ }
+
+ logger.info(() -> "Clicking Calculate & close for test case " + id);
+ calcButton.click();
+
+ // 8. Wait for navigation to calculations list
+ page.waitForURL("**/calculations**", new com.microsoft.playwright.Page.WaitForURLOptions().setTimeout(10000));
+ logger.info(() -> "Navigated to calculations page");
+
+ // 9. Wait for calculation to complete
+ boolean completed = waitForCalculationComplete(testCase.input().partNumber());
+ if (!completed) {
+ takeScreenshot("calculation_timeout_" + id);
+ throw new AssertionError("Calculation did not complete within timeout");
+ }
+
+ takeScreenshot("calculation_completed_" + id);
+ logger.info(() -> "Test case " + id + " - calculation completed!");
+
+ // 10. Navigate to Reports and verify results
+ ResultsPage resultsPage = new ResultsPage(page);
+ resultsPage.navigateToReports(getBaseUrl(), testCase.input().partNumber(), testCase.input().supplierName());
+
+ takeScreenshot("report_" + id);
+
+ // 11. Verify results match expected values
+ resultsPage.verifyResults(testCase.expected(), TOLERANCE);
+
+ logger.info(() -> "Test case " + id + " - all results verified successfully!");
+
+ } catch (Exception e) {
+ // Take screenshot on failure
+ takeScreenshot("failure_" + id);
+ logger.severe(() -> "Test case " + id + " failed: " + e.getMessage());
+ throw e;
+ }
+ }
+
+ /**
+ * Waits for a calculation to complete by polling the calculations list.
+ * Looks for a COMPLETED badge for the given part number.
+ *
+ * @param partNumber the part number to look for
+ * @return true if calculation completed, false if timeout
+ */
+ private boolean waitForCalculationComplete(String partNumber) {
+ logger.info("Waiting for calculation to complete for: " + partNumber);
+
+ long startTime = System.currentTimeMillis();
+ int attempts = 0;
+
+ while (System.currentTimeMillis() - startTime < CALCULATION_TIMEOUT_MS) {
+ attempts++;
+ final int attemptNum = attempts;
+
+ // Wait a bit for dashboard to update (it pulls every few seconds)
+ page.waitForTimeout(POLL_INTERVAL_MS);
+
+ // Check the "Running" counter in the dashboard
+ // Structure: .dashboard-box contains .dashboard-box-number (the count) and .dashboard-box-number-text (the label)
+ Locator runningBox = page.locator(".dashboard-box:has(.dashboard-box-number-text:text-is('Running'))");
+
+ if (runningBox.count() > 0) {
+ Locator runningCount = runningBox.locator(".dashboard-box-number");
+ if (runningCount.count() > 0) {
+ String runningText = runningCount.textContent().trim();
+ logger.info("Attempt " + attemptNum + ": Running calculations = " + runningText);
+
+ try {
+ int running = Integer.parseInt(runningText);
+ if (running == 0) {
+ // No more running calculations - check if ours completed or failed
+ logger.info("No running calculations. Checking final status...");
+
+ // Check the Failed counter
+ Locator failedBox = page.locator(".dashboard-box:has(.dashboard-box-number-text:text-is('Failed'))");
+ if (failedBox.count() > 0) {
+ Locator failedCount = failedBox.locator(".dashboard-box-number");
+ String failedText = failedCount.textContent().trim();
+ int failed = Integer.parseInt(failedText);
+ if (failed > 0) {
+ logger.severe("Calculation failed! Failed count: " + failed);
+ takeScreenshot("calculation_failed");
+ return false;
+ }
+ }
+
+ // Check the Completed counter increased
+ Locator completedBox = page.locator(".dashboard-box:has(.dashboard-box-number-text:text-is('Completed'))");
+ if (completedBox.count() > 0) {
+ Locator completedCount = completedBox.locator(".dashboard-box-number");
+ String completedText = completedCount.textContent().trim();
+ logger.info("Completed calculations: " + completedText);
+ }
+
+ logger.info("Calculation completed after " + attemptNum + " attempts");
+ return true;
+ }
+ } catch (NumberFormatException e) {
+ logger.warning("Could not parse running count: " + runningText);
+ }
+ }
+ } else {
+ // Dashboard not found, try refreshing
+ logger.info("Attempt " + attemptNum + ": Dashboard not found, refreshing...");
+ page.reload();
+ page.waitForLoadState();
+ }
+ }
+
+ logger.warning("Calculation did not complete within " + CALCULATION_TIMEOUT_MS + "ms");
+ takeScreenshot("calculation_timeout");
+ return false;
+ }
+
+ static Stream provideTestCases() {
+ return TestCases.ALL.stream()
+ .map(tc -> Arguments.of(tc.id(), tc.name(), tc));
+ }
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/tests/DeviationAnalysisE2ETest.java b/src/test/java/de/avatic/lcc/e2e/tests/DeviationAnalysisE2ETest.java
new file mode 100644
index 0000000..f2bc4bc
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/tests/DeviationAnalysisE2ETest.java
@@ -0,0 +1,183 @@
+package de.avatic.lcc.e2e.tests;
+
+import com.microsoft.playwright.Locator;
+import de.avatic.lcc.e2e.pages.AssistantPage;
+import de.avatic.lcc.e2e.pages.CalculationEditPage;
+import de.avatic.lcc.e2e.pages.ResultsPage;
+import de.avatic.lcc.e2e.testdata.DestinationInput;
+import de.avatic.lcc.e2e.testdata.TestCase;
+import de.avatic.lcc.e2e.testdata.TestCases;
+import de.avatic.lcc.e2e.util.DeviationReport;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.logging.Logger;
+
+/**
+ * Runs all test cases and generates a deviation report comparing expected vs actual values.
+ * This test does not fail on deviations - it collects them all and prints a summary.
+ */
+@DisplayName("Deviation Analysis E2E Test")
+@Tag("analysis")
+class DeviationAnalysisE2ETest extends AbstractE2ETest {
+
+ private static final Logger logger = Logger.getLogger(DeviationAnalysisE2ETest.class.getName());
+ private static final int CALCULATION_TIMEOUT_MS = 120000;
+ private static final int POLL_INTERVAL_MS = 2000;
+
+ @Test
+ @DisplayName("Analyze deviations across all test cases")
+ void analyzeDeviations() {
+ DeviationReport report = new DeviationReport();
+
+ for (TestCase testCase : TestCases.ALL) {
+ String id = testCase.id();
+ String name = testCase.name();
+
+ logger.info(() -> "\n========================================");
+ logger.info(() -> "Processing test case: " + id + " - " + name);
+ logger.info(() -> "========================================\n");
+
+ try {
+ // Run the calculation workflow
+ Map actualResults = runCalculationAndGetResults(testCase);
+
+ // Add to deviation report
+ report.addTestCase(id, name, testCase.expected(), actualResults);
+
+ logger.info(() -> "Test case " + id + " completed successfully");
+
+ } catch (Exception e) {
+ logger.severe(() -> "Test case " + id + " failed with error: " + e.getMessage());
+ report.addError(id, name, e.getMessage());
+ takeScreenshot("error_" + id);
+ }
+ }
+
+ // Print the deviation report
+ String reportContent = report.generateMarkdownTable();
+ System.out.println(reportContent);
+ logger.info(reportContent);
+
+ // Write report to file
+ try {
+ Path reportPath = Path.of("target/deviation-report.md");
+ Files.writeString(reportPath, reportContent);
+ logger.info("Deviation report written to: " + reportPath.toAbsolutePath());
+ } catch (IOException e) {
+ logger.warning("Could not write deviation report file: " + e.getMessage());
+ }
+ }
+
+ private Map runCalculationAndGetResults(TestCase testCase) {
+ // 1. Navigate to assistant and search part numbers
+ AssistantPage assistant = new AssistantPage(page);
+ assistant.navigate(getBaseUrl());
+ assistant.searchPartNumbers(testCase.input().partNumber());
+
+ // 2. Select supplier
+ assistant.deletePreselectedSuppliers();
+ assistant.selectSupplier(testCase.input().supplierName());
+
+ // 3. Create calculation
+ assistant.createCalculation(testCase.input().loadFromPrevious());
+
+ // 4. Fill the calculation form
+ CalculationEditPage calcPage = new CalculationEditPage(page);
+
+ // Enable screenshots for debugging
+ calcPage.enableScreenshots("case_" + testCase.id());
+
+ calcPage.fillForm(testCase.input());
+
+ // 5. Add and fill destinations (screenshots taken automatically for each)
+ for (DestinationInput dest : testCase.input().destinations()) {
+ calcPage.addDestination(dest);
+ calcPage.fillDestination(dest);
+ }
+
+ // 6. Take screenshot before clicking Calculate
+ calcPage.screenshotBeforeCalculate();
+
+ // 7. Click "Calculate & close" button
+ Locator calcButton = page.locator("xpath=//button[contains(., 'Calculate & close')]");
+ calcButton.waitFor();
+
+ if (!calcButton.isEnabled()) {
+ throw new AssertionError("Calculate & close button is not enabled for test case " + testCase.id());
+ }
+
+ calcButton.click();
+
+ // 8. Wait for navigation to calculations list
+ page.waitForURL("**/calculations**", new com.microsoft.playwright.Page.WaitForURLOptions().setTimeout(10000));
+
+ // 9. Wait for calculation to complete
+ boolean completed = waitForCalculationComplete(testCase.input().partNumber());
+ if (!completed) {
+ throw new AssertionError("Calculation did not complete within timeout for test case " + testCase.id());
+ }
+
+ // 10. Navigate to Reports and read results
+ ResultsPage resultsPage = new ResultsPage(page);
+ resultsPage.navigateToReports(getBaseUrl(), testCase.input().partNumber(), testCase.input().supplierName());
+
+ // 11. Take full page screenshot with all collapsible boxes expanded
+ resultsPage.takeFullPageScreenshot("report_" + testCase.id());
+
+ // 12. Read and return results (without verification)
+ return resultsPage.readResults();
+ }
+
+ private boolean waitForCalculationComplete(String partNumber) {
+ logger.info("Waiting for calculation to complete for: " + partNumber);
+
+ long startTime = System.currentTimeMillis();
+ int attempts = 0;
+
+ while (System.currentTimeMillis() - startTime < CALCULATION_TIMEOUT_MS) {
+ attempts++;
+ final int attemptNum = attempts;
+
+ page.waitForTimeout(POLL_INTERVAL_MS);
+
+ Locator runningBox = page.locator(".dashboard-box:has(.dashboard-box-number-text:text-is('Running'))");
+
+ if (runningBox.count() > 0) {
+ Locator runningCount = runningBox.locator(".dashboard-box-number");
+ if (runningCount.count() > 0) {
+ String runningText = runningCount.textContent().trim();
+
+ try {
+ int running = Integer.parseInt(runningText);
+ if (running == 0) {
+ Locator failedBox = page.locator(".dashboard-box:has(.dashboard-box-number-text:text-is('Failed'))");
+ if (failedBox.count() > 0) {
+ Locator failedCount = failedBox.locator(".dashboard-box-number");
+ String failedText = failedCount.textContent().trim();
+ int failed = Integer.parseInt(failedText);
+ if (failed > 0) {
+ logger.severe("Calculation failed! Failed count: " + failed);
+ return false;
+ }
+ }
+ return true;
+ }
+ } catch (NumberFormatException e) {
+ logger.warning("Could not parse running count: " + runningText);
+ }
+ }
+ } else {
+ page.reload();
+ page.waitForLoadState();
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/tests/SmokeE2ETest.java b/src/test/java/de/avatic/lcc/e2e/tests/SmokeE2ETest.java
new file mode 100644
index 0000000..15a02a0
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/tests/SmokeE2ETest.java
@@ -0,0 +1,110 @@
+package de.avatic.lcc.e2e.tests;
+
+import de.avatic.lcc.e2e.pages.AssistantPage;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Smoke tests to verify basic application functionality.
+ * These tests run quickly and verify that the application is accessible.
+ *
+ * The backend with integrated frontend is started automatically via @SpringBootTest.
+ *
+ *
Run with: {@code mvn test -Dtest=SmokeE2ETest -Dspring.profiles.active=test,mysql}
+ */
+@Tag("smoke")
+@DisplayName("Smoke E2E Tests")
+class SmokeE2ETest extends AbstractE2ETest {
+
+ private static final Logger logger = Logger.getLogger(SmokeE2ETest.class.getName());
+
+ @Test
+ @DisplayName("Application is accessible")
+ void testApplicationIsAccessible() {
+ page.navigate(getBaseUrl());
+ String title = page.title();
+
+ logger.info(() -> "Page title: " + title);
+ assertTrue(title != null && !title.isEmpty(), "Page should have a title");
+ }
+
+ @Test
+ @DisplayName("Login was successful")
+ void testLoginWasSuccessful() {
+ // Login happens in @BeforeEach via AbstractE2ETest
+ // After login, we navigate away from dev page (done in AbstractE2ETest)
+ String currentUrl = page.url();
+ assertTrue(!currentUrl.contains("/dev"), "Should not be on dev page after login");
+ }
+
+ @Test
+ @DisplayName("Navigate to assistant page")
+ void testNavigateToAssistant() {
+ // Navigate to assistant
+ AssistantPage assistant = new AssistantPage(page);
+ assistant.navigate(getBaseUrl());
+
+ String currentUrl = page.url();
+ assertTrue(currentUrl.contains("/assistant"), "Should be on assistant page");
+ }
+
+ @Test
+ @DisplayName("Part number search is functional")
+ void testPartNumberSearchFunctional() {
+ // Navigate to assistant
+ AssistantPage assistant = new AssistantPage(page);
+ assistant.navigate(getBaseUrl());
+
+ // Take screenshot to debug
+ takeScreenshot("assistant_page");
+
+ // Verify the part number modal is shown with textarea
+ boolean textAreaVisible = page.locator("textarea").isVisible();
+ logger.info(() -> "Text area visible: " + textAreaVisible);
+
+ // Verify analyze button is present (text: "Analyze input")
+ boolean analyzeButtonVisible = page.getByText("Analyze input").isVisible();
+ logger.info(() -> "Analyze button visible: " + analyzeButtonVisible);
+
+ assertTrue(textAreaVisible, "Text area for part numbers should be visible");
+ assertTrue(analyzeButtonVisible, "Analyze input button should be visible");
+ }
+
+ @Test
+ @DisplayName("Test materials exist in database")
+ void testMaterialsExistInDatabase() {
+ // Check if our test materials are in the database
+ Integer count = jdbcTemplate.queryForObject(
+ "SELECT COUNT(*) FROM material WHERE normalized_part_number IN ('004222640104', '003064540201')",
+ Integer.class
+ );
+ logger.info(() -> "Found " + count + " test materials in database");
+
+ // List all materials for debugging
+ var materials = jdbcTemplate.queryForList(
+ "SELECT part_number, normalized_part_number, name FROM material LIMIT 20"
+ );
+ logger.info(() -> "Materials in DB: " + materials);
+
+ // Test the exact SQL that the API uses
+ var searchResult = jdbcTemplate.queryForList(
+ "SELECT * FROM material WHERE part_number IN (?) OR normalized_part_number IN (?)",
+ "003064540201", "003064540201"
+ );
+ logger.info(() -> "Search result for '003064540201': " + searchResult);
+
+ // Also test with the original part number
+ var searchResult2 = jdbcTemplate.queryForList(
+ "SELECT * FROM material WHERE part_number IN (?) OR normalized_part_number IN (?)",
+ "3064540201", "3064540201"
+ );
+ logger.info(() -> "Search result for '3064540201': " + searchResult2);
+
+ assertTrue(count != null && count >= 2, "At least 2 test materials should exist. Found: " + count);
+ }
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/util/DeviationReport.java b/src/test/java/de/avatic/lcc/e2e/util/DeviationReport.java
new file mode 100644
index 0000000..ec4c123
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/util/DeviationReport.java
@@ -0,0 +1,182 @@
+package de.avatic.lcc.e2e.util;
+
+import de.avatic.lcc.e2e.testdata.TestCaseExpected;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Collects and reports deviations between expected and actual values.
+ */
+public class DeviationReport {
+
+ private final List deviations = new ArrayList<>();
+
+ public void addTestCase(String testCaseId, String testCaseName, TestCaseExpected expected, Map actual) {
+ TestCaseDeviation deviation = new TestCaseDeviation(testCaseId, testCaseName);
+
+ deviation.addField("MEK_A", expected.mekA(), (Double) actual.get("mekA"));
+ deviation.addField("LOGISTIC_COST", expected.logisticCost(), (Double) actual.get("logisticCost"));
+ deviation.addField("MEK_B", expected.mekB(), (Double) actual.get("mekB"));
+ deviation.addField("FCA_FEE", expected.fcaFee(), (Double) actual.get("fcaFee"));
+ deviation.addField("TRANSPORTATION", expected.transportation(), (Double) actual.get("transportation"));
+ deviation.addField("D2D", expected.d2d(), (Double) actual.get("d2d"));
+ deviation.addField("AIR_FREIGHT", expected.airFreight(), (Double) actual.get("airFreight"));
+ deviation.addField("CUSTOM", expected.custom(), (Double) actual.get("custom"));
+ deviation.addField("REPACKAGING", expected.repackaging(), (Double) actual.get("repackaging"));
+ deviation.addField("HANDLING", expected.handling(), (Double) actual.get("handling"));
+ deviation.addField("DISPOSAL", expected.disposal(), (Double) actual.get("disposal"));
+ deviation.addField("SPACE", expected.space(), (Double) actual.get("space"));
+ deviation.addField("CAPITAL", expected.capital(), (Double) actual.get("capital"));
+
+ deviations.add(deviation);
+ }
+
+ public void addError(String testCaseId, String testCaseName, String errorMessage) {
+ TestCaseDeviation deviation = new TestCaseDeviation(testCaseId, testCaseName);
+ deviation.setError(errorMessage);
+ deviations.add(deviation);
+ }
+
+ public String generateMarkdownTable() {
+ StringBuilder sb = new StringBuilder();
+
+ sb.append("\n\n");
+ sb.append("# DEVIATION REPORT\n");
+ sb.append("================================================================================\n\n");
+
+ // Summary table per test case
+ sb.append("## Summary by Test Case\n\n");
+ sb.append("| Test | Name | Status | Max Deviation |\n");
+ sb.append("|------|------|--------|---------------|\n");
+
+ for (TestCaseDeviation dev : deviations) {
+ if (dev.hasError()) {
+ sb.append(String.format("| %s | %s | ERROR | %s |\n",
+ dev.testCaseId, truncate(dev.testCaseName, 30), dev.errorMessage));
+ } else {
+ double maxDev = dev.getMaxDeviation();
+ String status = maxDev > 5.0 ? "⚠️ HIGH" : (maxDev > 1.0 ? "⚡ MEDIUM" : "✓ OK");
+ sb.append(String.format("| %s | %s | %s | %.2f%% |\n",
+ dev.testCaseId, truncate(dev.testCaseName, 30), status, maxDev));
+ }
+ }
+
+ // Detailed deviations per field
+ sb.append("\n\n## Detailed Field Deviations\n\n");
+ sb.append("| Test | Field | Expected | Actual | Deviation |\n");
+ sb.append("|------|-------|----------|--------|----------|\n");
+
+ for (TestCaseDeviation dev : deviations) {
+ if (dev.hasError()) {
+ sb.append(String.format("| %s | ERROR | - | - | %s |\n", dev.testCaseId, dev.errorMessage));
+ } else {
+ for (FieldDeviation field : dev.fields) {
+ if (field.deviationPercent > 1.0 || field.actual == null) {
+ sb.append(String.format("| %s | %s | %.4f | %s | %.2f%% |\n",
+ dev.testCaseId,
+ field.fieldName,
+ field.expected,
+ field.actual != null ? String.format("%.4f", field.actual) : "null",
+ field.deviationPercent));
+ }
+ }
+ }
+ }
+
+ // Field summary - which fields have issues across all tests
+ sb.append("\n\n## Field Summary (Average Deviation Across All Tests)\n\n");
+ sb.append("| Field | Avg Deviation | Max Deviation | Tests with >1% |\n");
+ sb.append("|-------|---------------|---------------|----------------|\n");
+
+ String[] fieldNames = {"MEK_A", "LOGISTIC_COST", "MEK_B", "FCA_FEE", "TRANSPORTATION",
+ "D2D", "AIR_FREIGHT", "CUSTOM", "REPACKAGING", "HANDLING", "DISPOSAL", "SPACE", "CAPITAL"};
+
+ for (String fieldName : fieldNames) {
+ double sumDev = 0;
+ double maxDev = 0;
+ int countHigh = 0;
+ int count = 0;
+
+ for (TestCaseDeviation dev : deviations) {
+ if (!dev.hasError()) {
+ for (FieldDeviation field : dev.fields) {
+ if (field.fieldName.equals(fieldName)) {
+ sumDev += field.deviationPercent;
+ maxDev = Math.max(maxDev, field.deviationPercent);
+ if (field.deviationPercent > 1.0) countHigh++;
+ count++;
+ }
+ }
+ }
+ }
+
+ if (count > 0) {
+ double avgDev = sumDev / count;
+ sb.append(String.format("| %s | %.2f%% | %.2f%% | %d/%d |\n",
+ fieldName, avgDev, maxDev, countHigh, count));
+ }
+ }
+
+ sb.append("\n================================================================================\n");
+
+ return sb.toString();
+ }
+
+ private String truncate(String s, int maxLen) {
+ return s.length() > maxLen ? s.substring(0, maxLen - 3) + "..." : s;
+ }
+
+ public static class TestCaseDeviation {
+ String testCaseId;
+ String testCaseName;
+ List fields = new ArrayList<>();
+ String errorMessage;
+
+ public TestCaseDeviation(String testCaseId, String testCaseName) {
+ this.testCaseId = testCaseId;
+ this.testCaseName = testCaseName;
+ }
+
+ public void addField(String fieldName, double expected, Double actual) {
+ fields.add(new FieldDeviation(fieldName, expected, actual));
+ }
+
+ public void setError(String errorMessage) {
+ this.errorMessage = errorMessage;
+ }
+
+ public boolean hasError() {
+ return errorMessage != null;
+ }
+
+ public double getMaxDeviation() {
+ return fields.stream()
+ .mapToDouble(f -> f.deviationPercent)
+ .max()
+ .orElse(0.0);
+ }
+ }
+
+ public static class FieldDeviation {
+ String fieldName;
+ double expected;
+ Double actual;
+ double deviationPercent;
+
+ public FieldDeviation(String fieldName, double expected, Double actual) {
+ this.fieldName = fieldName;
+ this.expected = expected;
+ this.actual = actual;
+
+ if (actual == null) {
+ // Null actual - if expected is ~0, no deviation; otherwise 100%
+ this.deviationPercent = Math.abs(expected) < 0.001 ? 0.0 : 100.0;
+ } else {
+ double diff = Math.abs(expected - actual);
+ this.deviationPercent = expected != 0 ? (diff / Math.abs(expected)) * 100 : diff * 100;
+ }
+ }
+ }
+}
diff --git a/src/test/java/de/avatic/lcc/e2e/util/ResultComparator.java b/src/test/java/de/avatic/lcc/e2e/util/ResultComparator.java
new file mode 100644
index 0000000..b4f2c8a
--- /dev/null
+++ b/src/test/java/de/avatic/lcc/e2e/util/ResultComparator.java
@@ -0,0 +1,180 @@
+package de.avatic.lcc.e2e.util;
+
+import de.avatic.lcc.e2e.testdata.DestinationExpected;
+import de.avatic.lcc.e2e.testdata.TestCaseExpected;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+/**
+ * Utility class for comparing actual results with expected values.
+ * Supports tolerance-based comparison for numeric values.
+ */
+public final class ResultComparator {
+
+ private static final Logger logger = Logger.getLogger(ResultComparator.class.getName());
+
+ private ResultComparator() {
+ // Utility class
+ }
+
+ /**
+ * Asserts that actual results match expected values within the given tolerance.
+ *
+ * @param actualResults Map of actual result values from the UI
+ * @param expected Expected values from test case definition
+ * @param tolerance Relative tolerance for numeric comparisons (0.01 = 1%)
+ * @throws AssertionError if any values don't match within tolerance
+ */
+ public static void assertResultsMatch(Map actualResults,
+ TestCaseExpected expected,
+ double tolerance) {
+ List failures = new ArrayList<>();
+
+ // Compare main result fields
+ compareNumeric(failures, "MEK_A", expected.mekA(), getDouble(actualResults, "mekA"), tolerance);
+ compareNumeric(failures, "LOGISTIC_COST", expected.logisticCost(), getDouble(actualResults, "logisticCost"), tolerance);
+ compareNumeric(failures, "MEK_B", expected.mekB(), getDouble(actualResults, "mekB"), tolerance);
+ compareNumeric(failures, "FCA_FEE", expected.fcaFee(), getDouble(actualResults, "fcaFee"), tolerance);
+ compareNumeric(failures, "TRANSPORTATION", expected.transportation(), getDouble(actualResults, "transportation"), tolerance);
+ compareNumeric(failures, "D2D", expected.d2d(), getDouble(actualResults, "d2d"), tolerance);
+ compareNumeric(failures, "AIR_FREIGHT", expected.airFreight(), getDouble(actualResults, "airFreight"), tolerance);
+ compareNumeric(failures, "CUSTOM", expected.custom(), getDouble(actualResults, "custom"), tolerance);
+ compareNumeric(failures, "REPACKAGING", expected.repackaging(), getDouble(actualResults, "repackaging"), tolerance);
+ compareNumeric(failures, "HANDLING", expected.handling(), getDouble(actualResults, "handling"), tolerance);
+ compareNumeric(failures, "DISPOSAL", expected.disposal(), getDouble(actualResults, "disposal"), tolerance);
+ compareNumeric(failures, "SPACE", expected.space(), getDouble(actualResults, "space"), tolerance);
+ compareNumeric(failures, "CAPITAL", expected.capital(), getDouble(actualResults, "capital"), tolerance);
+ compareNumeric(failures, "SAFETY_STOCK", (double) expected.safetyStock(), getDouble(actualResults, "safetyStock"), tolerance);
+
+ // Compare destination results
+ @SuppressWarnings("unchecked")
+ List> actualDestinations = (List>) actualResults.get("destinations");
+ List expectedDestinations = expected.destinations();
+
+ if (actualDestinations == null) {
+ actualDestinations = List.of();
+ }
+
+ if (expectedDestinations.size() != actualDestinations.size()) {
+ failures.add(String.format(
+ "DESTINATION_COUNT: expected %d, got %d",
+ expectedDestinations.size(), actualDestinations.size()
+ ));
+ } else {
+ for (int i = 0; i < expectedDestinations.size(); i++) {
+ DestinationExpected expDest = expectedDestinations.get(i);
+ Map actDest = actualDestinations.get(i);
+ String prefix = "DESTINATION_" + (i + 1) + "_";
+
+ compareNumeric(failures, prefix + "TRANSIT_TIME",
+ (double) expDest.transitTime(),
+ getDouble(actDest, "transitTime"), tolerance);
+ compareNumeric(failures, prefix + "STACKED_LAYERS",
+ (double) expDest.stackedLayers(),
+ getDouble(actDest, "stackedLayers"), tolerance);
+ compareNumeric(failures, prefix + "CONTAINER_UNIT_COUNT",
+ (double) expDest.containerUnitCount(),
+ getDouble(actDest, "containerUnitCount"), tolerance);
+ compareString(failures, prefix + "CONTAINER_TYPE",
+ expDest.containerType(),
+ getString(actDest, "containerType"));
+ compareString(failures, prefix + "LIMITING_FACTOR",
+ expDest.limitingFactor(),
+ getString(actDest, "limitingFactor"));
+ }
+ }
+
+ if (!failures.isEmpty()) {
+ StringBuilder message = new StringBuilder("Result comparison failed:\n");
+ for (String failure : failures) {
+ message.append(" - ").append(failure).append("\n");
+ }
+ throw new AssertionError(message.toString());
+ }
+
+ logger.info("All results match within tolerance");
+ }
+
+ /**
+ * Compares two numeric values with tolerance and adds failure message if they don't match.
+ */
+ private static void compareNumeric(List failures, String fieldName,
+ double expected, Double actual, double tolerance) {
+ // Handle zero expected values - if expected is ~0 and actual is null, treat as pass
+ // (some fields are not displayed in the UI when their value is 0)
+ if (Math.abs(expected) < 1e-10) {
+ if (actual == null) {
+ // Expected ~0 and actual is null (field not shown) - this is acceptable
+ return;
+ }
+ if (Math.abs(actual) > tolerance) {
+ failures.add(String.format("%s: expected ~0, got %.6f", fieldName, actual));
+ }
+ return;
+ }
+
+ if (actual == null) {
+ failures.add(String.format("%s: actual value is null, expected %.6f", fieldName, expected));
+ return;
+ }
+
+ double relativeDiff = Math.abs(expected - actual) / Math.abs(expected);
+ if (relativeDiff > tolerance) {
+ failures.add(String.format(
+ "%s: expected %.6f, got %.6f (diff: %.2f%%)",
+ fieldName, expected, actual, relativeDiff * 100
+ ));
+ }
+ }
+
+ /**
+ * Compares two string values and adds failure message if they don't match.
+ */
+ private static void compareString(List failures, String fieldName,
+ String expected, String actual) {
+ if (expected == null && actual == null) {
+ return;
+ }
+ if (expected == null || actual == null || !expected.equals(actual)) {
+ failures.add(String.format("%s: expected '%s', got '%s'", fieldName, expected, actual));
+ }
+ }
+
+ /**
+ * Safely gets a Double value from a map.
+ */
+ private static Double getDouble(Map map, String key) {
+ if (map == null) {
+ return null;
+ }
+ Object value = map.get(key);
+ if (value == null) {
+ return null;
+ }
+ if (value instanceof Double) {
+ return (Double) value;
+ }
+ if (value instanceof Number) {
+ return ((Number) value).doubleValue();
+ }
+ try {
+ return Double.parseDouble(value.toString().replaceAll("[€$,\\s]", "").replace(",", "."));
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Safely gets a String value from a map.
+ */
+ private static String getString(Map map, String key) {
+ if (map == null) {
+ return null;
+ }
+ Object value = map.get(key);
+ return value != null ? value.toString() : null;
+ }
+}
diff --git a/src/test/resources/application-e2e.properties b/src/test/resources/application-e2e.properties
new file mode 100644
index 0000000..4618e85
--- /dev/null
+++ b/src/test/resources/application-e2e.properties
@@ -0,0 +1,13 @@
+# E2E Test Configuration
+# This profile enables scheduling for the CalculationJobProcessor
+# Use with: -Dspring.profiles.active=test,e2e,mysql
+
+# Enable scheduling for E2E tests (overrides application-test.properties)
+spring.task.scheduling.enabled=true
+
+# Job processor configuration for faster E2E tests
+calculation.job.processor.enabled=true
+calculation.job.processor.delay=2000
+
+# Shorter timeouts for tests
+spring.task.scheduling.pool.size=2
diff --git a/src/test/resources/application-test.properties b/src/test/resources/application-test.properties
index d68718b..dfd0130 100644
--- a/src/test/resources/application-test.properties
+++ b/src/test/resources/application-test.properties
@@ -15,9 +15,10 @@ spring.flyway.baseline-on-migrate=true
spring.flyway.clean-disabled=false
# Note: spring.flyway.locations is set in application-mysql.properties or application-mssql.properties
-# Security disabled for integration tests
+# Security configuration for E2E tests
+# Note: SecurityAutoConfiguration is NOT excluded - we use devSecurityFilterChain with @Profile("test")
+# which permits all requests but still requires HttpSecurity bean
spring.autoconfigure.exclude=\
- org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
@@ -26,6 +27,26 @@ spring.autoconfigure.exclude=\
# Disable Azure AD for tests
spring.cloud.azure.active-directory.enabled=false
+# Azure Maps API - dummy values for E2E tests (real API not called in tests)
+azure.maps.subscription.key=test-dummy-key-not-used
+azure.maps.api.url=https://atlas.microsoft.com
+
+# JWT configuration for tests
+jwt.secret=test-secret-key-for-e2e-tests-must-be-long-enough
+jwt.issuer=test-issuer
+
+# LCC configuration for tests
+lcc.allowed_cors=*
+lcc.allowed_oauth_token_cors=*
+lcc.auth.claim.email=email
+lcc.auth.claim.firstname=given_name
+lcc.auth.claim.lastname=family_name
+lcc.auth.claim.workday=workday_id
+lcc.auth.claim.ignore.workday=false
+lcc.auth.identify.by=workday
+lcc.bulk.sheet_password=test-password
+lcc.help.static=
+
# Disable async processing in tests (EUTaxationApiService uses @Async)
spring.task.execution.pool.core-size=0
spring.task.scheduling.enabled=false
diff --git a/src/test/resources/e2e/e2e-testdata.sql b/src/test/resources/e2e/e2e-testdata.sql
new file mode 100644
index 0000000..4171198
--- /dev/null
+++ b/src/test/resources/e2e/e2e-testdata.sql
@@ -0,0 +1,32 @@
+-- E2E Test Data
+-- This file creates test users and basic data needed for E2E tests
+
+-- Test Users
+INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active)
+VALUES ('WD001TEST', 'john.doe@test.com', 'John', 'Doe', TRUE);
+
+INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active)
+VALUES ('WD002TEST', 'jane.smith@test.com', 'Jane', 'Smith', TRUE);
+
+INSERT INTO sys_user (workday_id, email, firstname, lastname, is_active)
+VALUES ('WD003TEST', 'admin.test@test.com', 'Admin', 'User', TRUE);
+
+-- Assign groups to test users
+-- John gets 'super' role for full E2E testing capabilities
+-- Jane gets 'super' role
+-- Admin gets 'super' and 'right-management' roles
+INSERT INTO sys_user_group_mapping (user_id, group_id)
+SELECT u.id, g.id FROM sys_user u, sys_group g
+WHERE u.email = 'john.doe@test.com' AND g.group_name = 'super';
+
+INSERT INTO sys_user_group_mapping (user_id, group_id)
+SELECT u.id, g.id FROM sys_user u, sys_group g
+WHERE u.email = 'jane.smith@test.com' AND g.group_name = 'super';
+
+INSERT INTO sys_user_group_mapping (user_id, group_id)
+SELECT u.id, g.id FROM sys_user u, sys_group g
+WHERE u.email = 'admin.test@test.com' AND g.group_name = 'super';
+
+INSERT INTO sys_user_group_mapping (user_id, group_id)
+SELECT u.id, g.id FROM sys_user u, sys_group g
+WHERE u.email = 'admin.test@test.com' AND g.group_name = 'right-management';
diff --git a/src/test/resources/master_data/users.sql b/src/test/resources/master_data/users.sql
index 3b280e6..5a180f8 100644
--- a/src/test/resources/master_data/users.sql
+++ b/src/test/resources/master_data/users.sql
@@ -12,6 +12,10 @@ INSERT INTO sys_user_group_mapping (group_id, user_id)
VALUES ((SELECT id FROM sys_group WHERE group_name = 'super'),
(SELECT id FROM sys_user WHERE email = 'john.doe@company.com'));
+INSERT INTO sys_user_group_mapping (group_id, user_id)
+VALUES ((SELECT id FROM sys_group WHERE group_name = 'right-management'),
+ (SELECT id FROM sys_user WHERE email = 'john.doe@company.com'));
+
INSERT INTO sys_user_group_mapping (group_id, user_id)
VALUES ((SELECT id FROM sys_group WHERE group_name = 'basic'),
(SELECT id FROM sys_user WHERE email = 'sarah.smith@company.com'));
diff --git a/test/conftest.py b/test/conftest.py
deleted file mode 100644
index 55cbf47..0000000
--- a/test/conftest.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# conftest.py
-import pytest
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.support.ui import WebDriverWait
-from pathlib import Path
-import openpyxl
-
-
-@pytest.fixture(scope="session")
-def browser_options():
- options = Options()
- options.add_argument("--start-maximized")
- # options.add_argument("--headless") # Optional für CI/CD
- return options
-
-
-@pytest.fixture(scope="function")
-def driver(browser_options):
- """Erstellt einen neuen Browser pro Test"""
- driver = webdriver.Chrome(options=browser_options)
- driver.implicitly_wait(10)
- yield driver
- driver.quit()
-
-
-@pytest.fixture(scope="function")
-def wait(driver):
- """WebDriverWait Instanz"""
- return WebDriverWait(driver, 20)
-
-
-@pytest.fixture
-def base_url():
- """Basis-URL deiner Anwendung"""
- return "http://localhost:5173"
-
-
-def pytest_generate_tests(metafunc):
- """Parametrisiert Tests basierend auf Excel-Dateien im testdata Ordner"""
- if "testcase_file" in metafunc.fixturenames:
- testdata_dir = Path("testcases")
- excel_files = list(testdata_dir.glob("*.xlsx"))
-
- # IDs für bessere Testausgabe
- ids = [f.stem for f in excel_files]
-
- metafunc.parametrize("testcase_file", excel_files, ids=ids)
-
-
-@pytest.fixture
-def test_data(testcase_file):
- """Lädt Testdaten aus Excel-Datei"""
- wb = openpyxl.load_workbook(testcase_file)
-
- # Eingabedaten aus "in" Sheet
- input_sheet = wb["in"]
- input_data = {}
- groups = {}
- for row in input_sheet.iter_rows(values_only=True):
- if row[0]: # Feldname in Spalte A
- if '_' in row[0]:
- [remainder, suffix] = row[0].rsplit('_',1)
- if suffix.isdigit():
- [prefix, name] = remainder.split('_',1)
- if prefix not in groups:
- groups[prefix] = {}
- if groups[prefix].get(suffix) is None:
- groups[prefix][suffix] = {}
- groups[prefix][suffix][name] = row[1]
- else:
- input_data[row[0]] = row[1]
- else:
- input_data[row[0]] = row[1] # Wert in Spalte B
- input_data.update(groups)
-
- # Erwartete Ausgaben aus "out" Sheet
- output_sheet = wb["out"]
- expected_data = {}
- expected_groups = {}
- for row in input_sheet.iter_rows(values_only=True):
- if row[0]: # Feldname in Spalte A
- if '_' in row[0]:
- [remainder, suffix] = row[0].rsplit('_',1)
- if suffix.isdigit():
- [prefix, name] = remainder.split('_',1)
- if prefix not in expected_groups:
- expected_groups[prefix] = {}
- if expected_groups[prefix].get(suffix) is None:
- expected_groups[prefix][suffix] = {}
- expected_groups[prefix][suffix][name] = row[1]
- else:
- expected_data[row[0]] = row[1]
- else:
- expected_data[row[0]] = row[1] # Wert in Spalte B
- expected_data.update(expected_groups)
- return {
- "input": input_data,
- "expected": expected_data,
- "filename": testcase_file.name
- }
\ No newline at end of file
diff --git a/test/pages/assistant.py b/test/pages/assistant.py
deleted file mode 100644
index e5d07ba..0000000
--- a/test/pages/assistant.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import time
-
-from selenium.webdriver.common.by import By
-
-from conftest import driver
-from pages.base_page import BasePage
-
-
-class Assistant(BasePage):
- """Page Object für den Assistant"""
-
- # Mapping von Excel-Feldnamen zu Locators
- FIELD_MAPPING = {
- "PART_NUMBER": (By.CSS_SELECTOR, "textarea[name='partNumbers']"),
- "ANALYZE_BUTTON": (By.CSS_SELECTOR, ".part-number-modal-action > .btn--primary"),
- "SUPPLIER_NAME": (By.CSS_SELECTOR, ".supplier-headers-searchbar-container .search-input"),
- "LOAD_FROM_PREVIOUS": (By.CSS_SELECTOR, ".start-calculation-footer-container .checkbox-item"),
- "CREATE_CALCULATION_BUTTON": (By.CSS_SELECTOR, ".start-calculation-footer-container .btn--secondary"),
- "DELETE_SUPPLIER_BUTTON": (By.CSS_SELECTOR, ".supplier-headers ~ .item-list .item-list-element .icon-btn-container .icon-btn"),
- }
-
- def search_part_numbers(self, data_dict):
- """Füllt das Formular mit Daten aus dem Excel"""
- self.fill_input(*self.FIELD_MAPPING["PART_NUMBER"], data_dict["PART_NUMBER"])
- self.click_button(*self.FIELD_MAPPING["ANALYZE_BUTTON"])
-
- def delete_preselected_suppliers(self):
- while True:
- try:
- button = self.wait_for_clickable(
- *self.FIELD_MAPPING["DELETE_SUPPLIER_BUTTON"],
- timeout=1
- )
- button.click()
- time.sleep(0.2)
- except:
- # Keine Buttons mehr vorhanden
- break
-
- def select_supplier(self, data_dict):
- self.search_and_select_autosuggest(*self.FIELD_MAPPING["SUPPLIER_NAME"], data_dict["SUPPLIER_NAME"])
-
-
- def create_calculation(self, data_dict):
- self.set_checkbox(*self.FIELD_MAPPING["LOAD_FROM_PREVIOUS"], data_dict["LOAD_FROM_PREVIOUS"])
- self.click_button(*self.FIELD_MAPPING["CREATE_CALCULATION_BUTTON"])
diff --git a/test/pages/base_page.py b/test/pages/base_page.py
deleted file mode 100644
index 4a19b18..0000000
--- a/test/pages/base_page.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# pages/base_page.py
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.common.by import By
-from selenium.common.exceptions import TimeoutException
-import time
-import logging
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class BasePage:
- """Basis-Klasse für alle Page Objects"""
-
- def __init__(self, driver, wait):
- self.driver = driver
- self.wait = wait
-
- def wait_for_spa_navigation(self, expected_route_part, timeout=2):
- """Wartet bis SPA zur erwarteten Route navigiert hat"""
- WebDriverWait(self.driver, timeout).until(
- lambda d: expected_route_part in d.current_url
- )
- # Zusätzlich auf Vue-Rendering warten
- time.sleep(0.5)
-
- def wait_for_element(self, by, value, timeout=2):
- """Wartet auf ein Element"""
- start_time = time.time()
- logger.info(f"Waiting for element: {by}={value}")
-
- result = WebDriverWait(self.driver, timeout).until(
- EC.presence_of_element_located((by, value))
- )
-
- elapsed = time.time() - start_time
- logger.info(f"Found element after {elapsed:.2f}s")
- return result
- def wait_for_clickable(self, by, value, timeout=2):
- """Wartet bis Element klickbar ist"""
- return WebDriverWait(self.driver, timeout).until(
- EC.element_to_be_clickable((by, value))
- )
-
- def fill_input(self, by, value, text, check_existence=False, timeout=2):
- if check_existence:
- # Prüfe ob Element existiert
- try:
- element = WebDriverWait(self.driver, timeout).until(
- EC.presence_of_element_located((by, value))
- )
- logger.info(f"Element exists, filling...")
- except TimeoutException:
- logger.warning(f"Element does not exist, skipping (check_existence=True)")
- return False
- else:
- # Normaler Modus - erwarte dass Element existiert
- element = self.wait_for_element(by, value, timeout)
-
- # Element existiert - jetzt füllen
- element.clear()
- element.send_keys(text)
- logger.info(f"Filled input with: {text}")
- return True
-
- def click_button(self, by, value):
- """Klickt einen Button"""
- start_time = time.time()
- logger.info(f"Clicking button: {by}={value}")
-
- button = self.wait_for_clickable(by, value)
- button.click()
-
- elapsed = time.time() - start_time
- logger.info(f"Clicked after {elapsed:.2f}s")
-
- def set_checkbox(self, by, value, checked, timeout=2):
- label = self.wait_for_clickable(by, value, timeout)
-
- checkbox_input = label.find_element(By.CSS_SELECTOR, "input[type='checkbox']")
-
- is_checked = checkbox_input.is_selected()
-
- if is_checked != checked:
- label.click()
- time.sleep(0.3)
-
-
- def select_dropdown_option(self, by, value, option_text, timeout=10):
- dropdown_button = self.wait_for_element(by, value, timeout=timeout)
-
- try:
- current_value = dropdown_button.find_element(
- By.CSS_SELECTOR,
- "span.dropdown-trigger-text"
- ).text
-
- if current_value == option_text:
- logger.info(f"Dropdown already has value: {option_text}")
- return
- except:
- pass # Falls kein Text gefunden wurde, öffne das Dropdown
-
- dropdown_button.click()
- logger.info("Opened dropdown")
-
- menu = WebDriverWait(self.driver, timeout).until(
- EC.visibility_of_element_located((By.CSS_SELECTOR, "ul.dropdown-menu"))
- )
- logger.info("Dropdown menu visible")
-
- option_xpath = f"//li[contains(@class, 'dropdown-option')][normalize-space(text())='{option_text}']"
- option = WebDriverWait(self.driver, timeout).until(
- EC.element_to_be_clickable((By.XPATH, option_xpath))
- )
-
- logger.info(f"Clicking option: {option_text}")
- option.click()
-
-
- time.sleep(0.2)
-
- def search_and_select_autosuggest(self, by_or_selector, value_or_search_text,
- search_text=None,
- suggestion_selector=".suggestion-item",
- timeout=2):
-
- if search_text is not None:
- # Fall: (By.CSS_SELECTOR, ".selector", "search_text")
- search_input = self.wait_for_element(by_or_selector, value_or_search_text, timeout)
- text_to_search = search_text
- else:
- # Fall: (".selector", "search_text")
- search_input = self.wait_for_element(By.CSS_SELECTOR, by_or_selector, timeout)
- text_to_search = value_or_search_text
-
- search_input.clear()
- search_input.send_keys(text_to_search)
-
- time.sleep(1)
-
- suggestion = WebDriverWait(self.driver, timeout).until(
- EC.element_to_be_clickable((By.CSS_SELECTOR, suggestion_selector))
- )
- suggestion.click()
-
- time.sleep(0.5)
diff --git a/test/pages/calculation_page.py b/test/pages/calculation_page.py
deleted file mode 100644
index 56b1fea..0000000
--- a/test/pages/calculation_page.py
+++ /dev/null
@@ -1,157 +0,0 @@
-# pages/calculation_page.py
-from selenium.webdriver.common.by import By
-from pages.base_page import BasePage
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class CalculationPage(BasePage):
- """Page Object für die Berechnungsformulare"""
-
- # WICHTIG: Verwende data-v-* Attribute NUR wenn sie WIRKLICH stabil sind
- # Besser: Positionsbasierte Selektoren mit aussagekräftigen Parent-Elementen
-
- FIELD_MAPPING = {
- # Material-Sektion (erste Box)
- "HS_CODE": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][1]//div[contains(@class, 'caption-column')][text()='HS code']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "TARIFF_RATE": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][1]//div[contains(@class, 'caption-column')][contains(text(), 'Tariff rate')]"
- "/following-sibling::div//input[@class='input-field']"
- ),
-
- # Price-Sektion (zweite Box)
- "PRICE": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][2]//div[contains(@class, 'caption-column')][text()='MEK_A [EUR]']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "OVERSEA_SHARE": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][2]//div[contains(@class, 'caption-column')][contains(text(), 'Oversea share')]"
- "/following-sibling::div//input[@class='input-field']"
- ),
- # Handling Unit-Sektion (dritte Box)
- "LENGTH": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='HU length']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "WIDTH": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='HU width']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "HEIGHT": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='HU height']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "WEIGHT": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='HU weight']"
- "/following-sibling::div//input[@class='input-field']"
- ),
- "PIECES_UNIT": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='Pieces per HU']"
- "/following-sibling::div//input[@class='input-field']"
- ),
-
- # Dropdowns
- "DIMENSION_UNIT": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='Dimension unit']"
- "/following-sibling::div//button[contains(@class, 'dropdown-trigger')]"
- ),
- "WEIGHT_UNIT": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][3]//div[contains(@class, 'caption-column')][text()='Weight unit']"
- "/following-sibling::div//button[contains(@class, 'dropdown-trigger')]"
- ),
-
- # Checkboxen
- "FBA_FEE": (
- By.XPATH,
- "//div[contains(@class, 'master-data-item')][2]"
- "//label[contains(@class, 'checkbox-item')]"
- "[.//span[contains(@class, 'checkbox-label')][normalize-space(text())='']]"
- ),
- "MIXED": (
- By.XPATH,
- "//label[contains(@class, 'checkbox-item')]"
- "[.//span[contains(@class, 'checkbox-label')][text()='Mixable']]"
- ),
- "STACKED": (
- By.XPATH,
- "//label[contains(@class, 'checkbox-item')]"
- "[.//span[contains(@class, 'checkbox-label')][text()='Stackable']]"
- ),
- }
-
- DEST_FIELD_MAPPING = {
- "NAME": (By.XPATH, "//input[@placeholder='Add new Destination ...']"),
- "QUANTITY": (By.XPATH,
- "//div[contains(@class, 'destination-edit-column-caption') and contains(text(), 'Annual quantity')]/following-sibling::div[1]//input[@class='input-field']")
- "ROUTING": (By.XPATH,
- "//input[@type='radio' and @name='model' and @value='routing']"),
- "D2D": (By.XPATH,
- "//input[@type='radio' and @name='model' and @value='d2d']"),
- "ROUTE": (By.XPATH,
- "//div[@class='destination-route-container']//div[contains(@class, 'destination-route-inner-container')][.//span[contains(text(), 'Ireland Su')] and .//span[contains(text(), 'WH ULHA')] and .//span[contains(text(), 'AB')]]")
- "HANDLING_TAB": (By.XPATH, "//button[@class='tab-header' and text()='Handling & Repackaging']"),
- "CUSTOM_HANDLING": (By.XPATH,
- "//div[@class='destination-edit-handling-cost']//label[@class='checkbox-item']/input[@type='checkbox']"),
- "REPACKING": (By.XPATH,
- "//div[@class='destination-edit-column-caption' and contains(text(), 'Repackaging cost')]/following-sibling::div[@class='destination-edit-column-data'][1]//input[@class='input-field']"),
- "HANDLING": (By.XPATH,
- "//div[@class='destination-edit-column-caption' and contains(text(), 'Handling cost')]/following-sibling::div[@class='destination-edit-column-data'][1]//input[@class='input-field']"),
- "DISPOSAL": (By.XPATH,
- "//div[@class='destination-edit-column-caption' and contains(text(), 'Disposal cost')]/following-sibling::div[@class='destination-edit-column-data'][1]//input[@class='input-field']"),
- }
-
- # Buttons
- CALCULATE_CLOSE_BUTTON = (By.XPATH, "//button[contains(., 'Calculate & close')]")
- CLOSE_BUTTON = (By.XPATH, "//button[contains(., 'Close') and not(contains(., 'Calculate'))]")
-
- def fill_form(self, data_dict):
- """Füllt das Formular mit Daten aus dem Excel"""
- for field_name, locator in self.FIELD_MAPPING.items():
-
- value = data_dict[field_name]
- logger.info(f"Filling field: {field_name} = {value}")
-
- try:
- if field_name in ["FBA_FEE", "STACKED", "MIXED"]:
- self.set_checkbox(*locator, str(value) == 'True')
-
- elif field_name in ["DIMENSION_UNIT", "WEIGHT_UNIT"]:
- self.select_dropdown_option(*locator, str(value))
-
- else:
- self.fill_input(*locator, str(value), check_existence=field_name in ["HS_CODE", "TARIFF_RATE"])
-
- except Exception as e:
- logger.error(f"Failed to fill field {field_name}: {e}")
- self.driver.save_screenshot(f"failed_field_{field_name}.png")
- raise Exception(f"Could not fill field '{field_name}': {e}") from e
-
- def add_destination(self, data_dict):
- self.search_and_select_autosuggest(*self.DEST_FIELD_MAPPING["NAME"], data_dict["NAME"])
-
- def fill_destination(self, data_dict):
- self.wait_for_element(*self.DEST_FIELD_MAPPING["QUANTITY"])
- pass
-
- def click_calculate_and_close(self):
- """Klickt auf 'Calculate & close' Button"""
- self.click_button(*self.CALCULATE_CLOSE_BUTTON)
-
- def click_close(self):
- """Klickt auf 'Close' Button"""
- self.click_button(*self.CLOSE_BUTTON)
diff --git a/test/pages/dev_page.py b/test/pages/dev_page.py
deleted file mode 100644
index 66de67d..0000000
--- a/test/pages/dev_page.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# pages/results_page.py
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support import expected_conditions as EC
-import time
-
-class DevPage:
- MODAL_YES_BUTTON = (By.CSS_SELECTOR, "div.modal-dialog-actions button.btn--primary")
- MODAL_NO_BUTTON = (By.CSS_SELECTOR, "div.modal-dialog-actions button.btn--secondary")
-
- def __init__(self, driver, wait):
- self.driver = driver
- self.wait = wait
-
- def dev_login(self, base_url, user_name="John"):
- """
- Simuliert Login über /dev Seite
-
- Args:
- base_url: Basis-URL der Anwendung
- user_name: Vorname des Users (z.B. "John", "Sarah", "Mike")
- """
- # Navigiere zur Dev-Seite
- self.driver.get(f"{base_url}/dev")
-
- # Warte bis Tabelle geladen ist
- self.wait.until(
- EC.presence_of_element_located((By.CSS_SELECTOR, "table.data-table"))
- )
-
- # Finde die User-Row anhand des Vornamens
- # Die Tabelle hat Spalten: First name | Last name | E-Mail | ...
- rows = self.driver.find_elements(By.CSS_SELECTOR, "table.data-table tbody tr.table-row")
-
- for row in rows:
- cells = row.find_elements(By.TAG_NAME, "td")
- if cells and user_name in cells[0].text: # cells[0] ist "First name"
- # Klicke auf die Row
- self.wait.until(EC.element_to_be_clickable(row))
- row.click()
- break
- else:
- raise Exception(f"User '{user_name}' nicht in der Dev-User-Tabelle gefunden")
-
- # Warte auf Modal und klicke "Yes"
- yes_button = self.wait.until(
- EC.element_to_be_clickable(self.MODAL_YES_BUTTON)
- )
- yes_button.click()
-
- # Warte bis Modal geschlossen ist
- self.wait.until(
- EC.invisibility_of_element_located((By.CSS_SELECTOR, "div.modal-container"))
- )
\ No newline at end of file
diff --git a/test/pages/navigation.py b/test/pages/navigation.py
deleted file mode 100644
index 7c8ea82..0000000
--- a/test/pages/navigation.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# pages/navigation.py
-from selenium.webdriver.common.by import By
-
-from pages.assistant import Assistant
-from pages.base_page import BasePage
-from pages.calculation_page import CalculationPage
-from pages.results_page import ResultsPage
-
-
-class Navigation(BasePage):
- """Handhabt die SPA-Navigation"""
-
- # Locators für Navigationselemente
- MENU_BUTTON = (By.CSS_SELECTOR, "button.menu-toggle")
- NEW_CALCULATION_LINK = (By.CSS_SELECTOR, "a[href*='/assistant']")
- RESULTS_LINK = (By.CSS_SELECTOR, "a[href*='/results']")
-
- def start_calculation(self, base_url):
- """Navigiert zur Berechnungsseite"""
- self.driver.get(base_url+"/assistant")
- self.wait_for_spa_navigation("/assistant")
- return Assistant(self.driver, self.wait)
-
-
- def navigate_to_results(self):
- """Navigiert zur Ergebnisseite"""
- self.click_button(*self.RESULTS_LINK)
- self.wait_for_spa_navigation("/results")
- return ResultsPage(self.driver, self.wait)
\ No newline at end of file
diff --git a/test/pages/results_page.py b/test/pages/results_page.py
deleted file mode 100644
index 9d76774..0000000
--- a/test/pages/results_page.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# pages/results_page.py
-from selenium.webdriver.common.by import By
-from pages.base_page import BasePage
-
-
-class ResultsPage(BasePage):
- """Page Object für die Ergebnisseite"""
-
- # Mapping von Excel-Feldnamen zu Locators
- RESULT_MAPPING = {
- "gesamtkosten": (By.ID, "result-total-cost"),
- "zollgebuehr": (By.ID, "result-customs-fee"),
- "transportkosten": (By.ID, "result-transport-cost"),
- "mehrwertsteuer": (By.ID, "result-vat"),
- # Weitere Ergebnisfelder...
- }
-
- def wait_for_results(self):
- """Wartet bis Ergebnisse geladen sind"""
- self.wait_for_element(By.CSS_SELECTOR, ".results-container.loaded")
-
- def read_results(self):
- """Liest alle Ergebniswerte aus"""
- self.wait_for_results()
-
- results = {}
- for field_name, locator in self.RESULT_MAPPING.items():
- try:
- element = self.wait_for_element(*locator)
- results[field_name] = element.text
- except Exception as e:
- print(f"Fehler beim Lesen von '{field_name}': {e}")
- results[field_name] = None
-
- return results
\ No newline at end of file
diff --git a/test/pytest.ini b/test/pytest.ini
deleted file mode 100644
index e74e39e..0000000
--- a/test/pytest.ini
+++ /dev/null
@@ -1,18 +0,0 @@
-[pytest]
-log_cli = true
-log_cli_level = INFO
-log_cli_format = %(asctime)s [%(levelname)s] %(message)s
-log_cli_date_format = %H:%M:%S
-testpaths = .
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-addopts =
- -v
- --tb=short
- --capture=no
- --html=reports/report.html
- --self-contained-html
-markers =
- smoke: Smoke tests
- regression: Regression tests
\ No newline at end of file
diff --git a/test/requirements.txt b/test/requirements.txt
deleted file mode 100644
index 323adac..0000000
--- a/test/requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-pytest==9.0.2
-selenium==4.39.0
-openpyxl==3.1.5
-pytest-html==4.1.1
-webdriver-manager==4.0.2
\ No newline at end of file
diff --git a/test/test_calculation.py b/test/test_calculation.py
deleted file mode 100644
index dd7d95a..0000000
--- a/test/test_calculation.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# tests/test_calculation.py
-import pytest
-
-from pages.dev_page import DevPage
-from pages.navigation import Navigation
-from pages.calculation_page import CalculationPage
-from pages.results_page import ResultsPage
-
-
-class TestCalculation:
- """Testklasse für Berechnungslogik"""
-
- def test_calculation_workflow(self, driver, wait, base_url, test_data):
- """
- Haupttest: Führt einen kompletten Berechnungsdurchlauf durch
- Wird automatisch für jede Excel-Datei parametrisiert
- """
-
- login_page = DevPage(driver, wait)
- login_page.dev_login(base_url, user_name="John")
-
-
- # Setup assistant
- nav = Navigation(driver, wait)
- assistant = nav.start_calculation(base_url)
- assistant.search_part_numbers(test_data["input"])
- assistant.delete_preselected_suppliers()
- assistant.select_supplier(test_data["input"])
- assistant.create_calculation(test_data["input"])
-
- # Fill calculation page
- calc_page = CalculationPage(driver, wait)
- calc_page.fill_form(test_data["input"])
-
- for destination in test_data["input"]["DESTINATION"].values():
- calc_page.add_destination(destination)
- calc_page.fill_destination(destination)
-
- # Ergebnisse lesen
- results_page = ResultsPage(driver, wait)
- actual_results = results_page.read_results()
-
- # Assertions: Vergleich mit erwarteten Werten aus "out" Sheet
- expected = test_data["expected"]
-
- for field_name, expected_value in expected.items():
- actual_value = actual_results.get(field_name)
-
- # Numerische Werte mit Toleranz vergleichen
- if self._is_numeric(expected_value):
- expected_num = float(expected_value)
- actual_num = float(actual_value.replace("€", "").replace(",", ".").strip())
-
- assert pytest.approx(expected_num, rel=0.01) == actual_num, \
- f"Feld '{field_name}': Erwartet {expected_num}, erhalten {actual_num}"
- else:
- # String-Vergleich
- assert str(actual_value).strip() == str(expected_value).strip(), \
- f"Feld '{field_name}': Erwartet '{expected_value}', erhalten '{actual_value}'"
-
- print(f"✓ Test erfolgreich für {test_data['filename']}")
-
- @staticmethod
- def _is_numeric(value):
- """Prüft ob Wert numerisch ist"""
- try:
- float(str(value).replace(",", "."))
- return True
- except (ValueError, AttributeError):
- return False