v3 part 2

Author: baev

.idea/vcs.xml

@@ -4,10 +4,10 @@ Never create pull requests or push git branches without explicit confirmation fr
 
 ## Test Work
 
-Use [Allure Test Agent](docs/allure-test-agent.md) for test-related work in this repository.
+Use [Allure Agent Mode](docs/allure-agent-mode.md) for test-related work in this repository.
 
-- Read `docs/allure-test-agent.md` before designing, writing, reviewing, validating, debugging, or enriching tests.
-- Use the `$allure-test-agent` skill as the durable behavior guide when it is installed; this project file contains local commands and conventions.
+- Read `docs/allure-agent-mode.md` before designing, writing, reviewing, validating, debugging, or enriching tests.
+- Use the `$allure-agent-mode` skill as the durable behavior guide when it is installed; this project file contains local commands and conventions.
 - If a command executes tests and its result will be used for smoke checking, reasoning, review, coverage analysis, debugging, or a user-facing conclusion, run it through `allure agent`.
 - Use agent-mode execution for smoke checks too, even when the change is small or mechanical.
 - If agent output is missing or incomplete, debug that first and treat console-only conclusions as provisional.

AGENTS.md

@@ -15,14 +15,14 @@
  */
 package io.qameta.allure.assertj;
 
+import io.qameta.allure.AllureExternalKey;
 import io.qameta.allure.model.Stage;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StatusDetails;
 import io.qameta.allure.model.StepResult;
 import org.assertj.core.api.AbstractAssert;
 
 import java.util.Optional;
-import java.util.UUID;
 
 /**
  * Parent Allure step for one AssertJ assertion chain.
@@ -69,14 +69,14 @@ final class AssertJChain {
 
     private static final String ASSERTJ_STEP_PREFIX = "assert ";
 
-    private final String uuid;
+    private final AllureExternalKey key;
 
     private final AbstractAssert<?, ?> assertion;
 
     private final StepResult step;
 
     AssertJChain(final AbstractAssert<?, ?> assertion, final String subject) {
-        this.uuid = UUID.randomUUID().toString();
+        this.key = AllureExternalKey.random(AllureAspectJ.class);
         this.assertion = assertion;
         this.step = new StepResult()
                 .setName(chainName(subject))
@@ -86,8 +86,8 @@ final class AssertJChain {
                 .setStop(System.currentTimeMillis());
     }
 
-    String getUuid() {
-        return uuid;
+    AllureExternalKey getKey() {
+        return key;
     }
 
     AbstractAssert<?, ?> getAssertion() {

allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJChain.java

@@ -187,8 +187,10 @@ private void attachChain(final AllureLifecycle lifecycle,
                              final AssertJChain chain,
                              final AssertJOperation parentOperation) {
         if (parentOperation == null) {
-            lifecycle.startStep(chain.getUuid(), chain.getStep());
-            lifecycle.stopStep(chain.getUuid());
+            lifecycle.getCurrentExecutableKey().ifPresent(parent -> {
+                lifecycle.startStep(parent, chain.getKey(), chain.getStep());
+                lifecycle.stopStep(chain.getKey());
+            });
             return;
         }
 

allure-assertj/src/main/java/io/qameta/allure/assertj/AssertJRecorder.java

@@ -16,7 +16,9 @@
 package io.qameta.allure.awaitility;
 
 import io.qameta.allure.Allure;
+import io.qameta.allure.AllureExternalKey;
 import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.AttachmentOptions;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StepResult;
 import org.awaitility.Awaitility;
@@ -27,10 +29,10 @@
 import org.awaitility.core.StartEvaluationEvent;
 import org.awaitility.core.TimeoutEvent;
 
+import java.io.ByteArrayInputStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.nio.charset.StandardCharsets;
-import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -74,7 +76,7 @@ public class AllureAwaitilityListener implements ConditionEvaluationListener<Obj
     private final String onTimeoutStepTextPattern;
     private final String onExceptionStepTextPattern;
 
-    private String currentConditionStepUUID;
+    private AllureExternalKey currentConditionStepKey;
 
     private static final InheritableThreadLocal<AllureLifecycle> LIFECYCLE = new InheritableThreadLocal<AllureLifecycle>() {
         @Override
@@ -134,17 +136,22 @@ public AllureAwaitilityListener setLogIgnoredExceptions(final boolean logging) {
      */
     @Override
     public void beforeEvaluation(final StartEvaluationEvent<Object> startEvaluationEvent) {
-        currentConditionStepUUID = UUID.randomUUID().toString();
-        final String nameWoAlias = String.format(onStartStepTextPattern, startEvaluationEvent.getDescription());
-        final String nameWithAlias = String.format(onStartStepTextPattern, startEvaluationEvent.getAlias());
-        final String stepName = startEvaluationEvent.getAlias() != null ? nameWithAlias : nameWoAlias;
-        getLifecycle().startStep(
-                currentConditionStepUUID,
-                new StepResult()
-                        .setName(stepName)
-                        .setDescription("Awaitility condition started")
-                        .setStatus(Status.FAILED)
-        );
+        currentConditionStepKey = null;
+        getLifecycle().getCurrentExecutableKey().ifPresent(parent -> {
+            final String nameWoAlias = String.format(onStartStepTextPattern, startEvaluationEvent.getDescription());
+            final String nameWithAlias = String.format(onStartStepTextPattern, startEvaluationEvent.getAlias());
+            final String stepName = startEvaluationEvent.getAlias() != null ? nameWithAlias : nameWoAlias;
+            final AllureExternalKey conditionStepKey = AllureExternalKey.random(AllureAwaitilityListener.class);
+            currentConditionStepKey = conditionStepKey;
+            getLifecycle().startStep(
+                    parent,
+                    conditionStepKey,
+                    new StepResult()
+                            .setName(stepName)
+                            .setDescription("Awaitility condition started")
+                            .setStatus(Status.FAILED)
+            );
+        });
     }
 
     /**
@@ -154,19 +161,20 @@ public void beforeEvaluation(final StartEvaluationEvent<Object> startEvaluationE
      */
     @Override
     public void onTimeout(final TimeoutEvent timeoutEvent) {
-        getLifecycle().updateStep(awaitilityCondition -> {
-            final String currentTimeoutStepUUID = UUID.randomUUID().toString();
-            getLifecycle().startStep(
-                    currentConditionStepUUID,
-                    currentTimeoutStepUUID,
-                    new StepResult()
-                            .setName(String.format(onTimeoutStepTextPattern, timeoutEvent.getDescription()))
-                            .setDescription("Awaitility condition timeout")
-                            .setStatus(Status.BROKEN)
-            );
-            getLifecycle().stopStep(currentTimeoutStepUUID);
-        });
-        getLifecycle().stopStep(currentConditionStepUUID);
+        if (currentConditionStepKey == null) {
+            return;
+        }
+        final AllureExternalKey timeoutStepKey = AllureExternalKey.random(AllureAwaitilityListener.class);
+        getLifecycle().startStep(
+                currentConditionStepKey,
+                timeoutStepKey,
+                new StepResult()
+                        .setName(String.format(onTimeoutStepTextPattern, timeoutEvent.getDescription()))
+                        .setDescription("Awaitility condition timeout")
+                        .setStatus(Status.BROKEN)
+        );
+        getLifecycle().stopStep(timeoutStepKey);
+        getLifecycle().stopStep(currentConditionStepKey);
     }
 
     /**
@@ -191,22 +199,25 @@ public void conditionEvaluated(final EvaluatedCondition<Object> condition) {
                 new TemporalDuration(condition.getPollInterval())
         );
 
-        getLifecycle().updateStep(awaitilityCondition -> {
-            final String lastAwaitStepUUID = UUID.randomUUID().toString();
-            getLifecycle().startStep(
-                    currentConditionStepUUID,
-                    lastAwaitStepUUID,
-                    new StepResult()
-                            .setName(message)
-                            .setDescription("Awaitility condition satisfied or not, but awaiting still in progress")
-                            .setStatus(Status.PASSED)
+        if (currentConditionStepKey == null) {
+            return;
+        }
+        final AllureExternalKey lastAwaitStepKey = AllureExternalKey.random(AllureAwaitilityListener.class);
+        getLifecycle().startStep(
+                currentConditionStepKey,
+                lastAwaitStepKey,
+                new StepResult()
+                        .setName(message)
+                        .setDescription("Awaitility condition satisfied or not, but awaiting still in progress")
+                        .setStatus(Status.PASSED)
+        );
+        getLifecycle().stopStep(lastAwaitStepKey);
+        if (condition.isSatisfied()) {
+            getLifecycle().updateStep(
+                    currentConditionStepKey, awaitilityCondition -> awaitilityCondition.setStatus(Status.PASSED)
             );
-            getLifecycle().stopStep(lastAwaitStepUUID);
-            if (condition.isSatisfied()) {
-                awaitilityCondition.setStatus(Status.PASSED);
-                getLifecycle().stopStep(currentConditionStepUUID);
-            }
-        });
+            getLifecycle().stopStep(currentConditionStepKey);
+        }
     }
 
     /**
@@ -224,29 +235,30 @@ public void conditionEvaluated(final EvaluatedCondition<Object> condition) {
      */
     @Override
     public void exceptionIgnored(final IgnoredException ignoredException) {
-        if (logIgnoredExceptions) {
-            getLifecycle().updateStep(awaitilityCondition -> {
-                final String currentExceptionIgnoredStepUUID = UUID.randomUUID().toString();
-                final String message = String.format(
-                        onExceptionStepTextPattern, ignoredException.getThrowable().getMessage()
-                );
-                final StringWriter stringWriter = new StringWriter();
-                ignoredException.getThrowable().printStackTrace(new PrintWriter(stringWriter));
-                final String stackTrace = stringWriter.toString();
-                getLifecycle().startStep(
-                        currentConditionStepUUID,
-                        currentExceptionIgnoredStepUUID,
-                        new StepResult()
-                                .setName(message)
-                                .setDescription("Exception occurred and ignored, but awaiting still in progress")
-                                .setStatus(Status.SKIPPED)
-                );
-                getLifecycle().addAttachment(
-                        ignoredException.getThrowable().getMessage(), "text/plain", ".txt",
-                        stackTrace.getBytes(StandardCharsets.UTF_8)
-                );
-                getLifecycle().stopStep(currentExceptionIgnoredStepUUID);
-            });
+        if (logIgnoredExceptions && currentConditionStepKey != null) {
+            final AllureExternalKey exceptionIgnoredStepKey = AllureExternalKey.random(AllureAwaitilityListener.class);
+            final String message = String.format(
+                    onExceptionStepTextPattern, ignoredException.getThrowable().getMessage()
+            );
+            final StringWriter stringWriter = new StringWriter();
+            ignoredException.getThrowable().printStackTrace(new PrintWriter(stringWriter));
+            final String stackTrace = stringWriter.toString();
+            getLifecycle().startStep(
+                    currentConditionStepKey,
+                    exceptionIgnoredStepKey,
+                    new StepResult()
+                            .setName(message)
+                            .setDescription("Exception occurred and ignored, but awaiting still in progress")
+                            .setStatus(Status.SKIPPED)
+            );
+            getLifecycle().addAttachment(
+                    exceptionIgnoredStepKey,
+                    ignoredException.getThrowable().getMessage(),
+                    "text/plain",
+                    new ByteArrayInputStream(stackTrace.getBytes(StandardCharsets.UTF_8)),
+                    AttachmentOptions.empty()
+            );
+            getLifecycle().stopStep(exceptionIgnoredStepKey);
         }
     }