From dbc3f54ec03cda03e88d0fbe58ad5f934347a1c2 Mon Sep 17 00:00:00 2001
From: Dmitry Baev <baev.dm@gmail.com>
Date: Mon, 29 Jan 2024 15:34:53 +0000
Subject: [PATCH] parse labels from tags using naming convention (via #2326)

---
 .../qameta/allure/ConfigurationBuilder.java   |   2 +-
 .../qameta/allure/DummyReportGenerator.java   |   2 +-
 .../io/qameta/allure/tags/TagsPlugin.java     |  48 ++-
 .../io/qameta/allure/tags/TagsPluginTest.java | 322 ++++++++++++++++++
 4 files changed, 370 insertions(+), 4 deletions(-)
 create mode 100644 allure-generator/src/test/java/io/qameta/allure/tags/TagsPluginTest.java

diff --git a/allure-generator/src/main/java/io/qameta/allure/ConfigurationBuilder.java b/allure-generator/src/main/java/io/qameta/allure/ConfigurationBuilder.java
index ab5414f63..d9cd6d9c6 100644
--- a/allure-generator/src/main/java/io/qameta/allure/ConfigurationBuilder.java
+++ b/allure-generator/src/main/java/io/qameta/allure/ConfigurationBuilder.java
@@ -96,9 +96,9 @@ public ConfigurationBuilder useDefault() {
                 new FreemarkerContext(),
                 new RandomUidContext(),
                 new MarkdownDescriptionsPlugin(),
+                new TagsPlugin(),
                 new RetryPlugin(),
                 new RetryTrendPlugin(),
-                new TagsPlugin(),
                 new SeverityPlugin(),
                 new OwnerPlugin(),
                 new IdeaLinksPlugin(),
diff --git a/allure-generator/src/main/java/io/qameta/allure/DummyReportGenerator.java b/allure-generator/src/main/java/io/qameta/allure/DummyReportGenerator.java
index d64bf71d2..a1a1ddcdd 100644
--- a/allure-generator/src/main/java/io/qameta/allure/DummyReportGenerator.java
+++ b/allure-generator/src/main/java/io/qameta/allure/DummyReportGenerator.java
@@ -84,9 +84,9 @@ public final class DummyReportGenerator {
             new FreemarkerContext(),
             new RandomUidContext(),
             new MarkdownDescriptionsPlugin(),
+            new TagsPlugin(),
             new RetryPlugin(),
             new RetryTrendPlugin(),
-            new TagsPlugin(),
             new SeverityPlugin(),
             new OwnerPlugin(),
             new IdeaLinksPlugin(),
diff --git a/allure-generator/src/main/java/io/qameta/allure/tags/TagsPlugin.java b/allure-generator/src/main/java/io/qameta/allure/tags/TagsPlugin.java
index 54ed3df7a..50b24991c 100644
--- a/allure-generator/src/main/java/io/qameta/allure/tags/TagsPlugin.java
+++ b/allure-generator/src/main/java/io/qameta/allure/tags/TagsPlugin.java
@@ -19,18 +19,27 @@
 import io.qameta.allure.ReportStorage;
 import io.qameta.allure.core.Configuration;
 import io.qameta.allure.core.LaunchResults;
+import io.qameta.allure.entity.Label;
 import io.qameta.allure.entity.LabelName;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 /**
  * @author charlie (Dmitry Baev).
  */
 public class TagsPlugin implements Aggregator2 {
 
+    private static final Pattern LABEL_TAG = Pattern.compile("^@?allure\\.label\\.(?<name>.+)[:=](?<value>.+)$");
+
     public static final String TAGS_BLOCK_NAME = "tags";
 
     @Override
@@ -41,8 +50,43 @@ public void aggregate(final Configuration configuration,
                 .map(LaunchResults::getAllResults)
                 .flatMap(Collection::stream)
                 .forEach(result -> {
-                    final Set<String> tags = new HashSet<>(result.findAllLabels(LabelName.TAG));
-                    result.addExtraBlock(TAGS_BLOCK_NAME, tags);
+
+                    final Set<String> tags = result.findAllLabels(LabelName.TAG, Collectors.toSet());
+
+                    final List<Label> extraLabels = tags.stream()
+                            .filter(Objects::nonNull)
+                            .filter(tag -> LABEL_TAG.matcher(tag).matches())
+                            .map(TagsPlugin::createFromTag)
+                            .filter(Optional::isPresent)
+                            .map(Optional::get)
+                            .collect(Collectors.toList());
+
+                    if (!extraLabels.isEmpty()) {
+                        final List<Label> labels = new ArrayList<>(result.getLabels());
+                        labels.addAll(extraLabels);
+                        result.setLabels(labels);
+                    }
+
+                    final Set<String> filteredTags = tags.stream()
+                            .filter(Objects::nonNull)
+                            .filter(tag -> !LABEL_TAG.matcher(tag).matches())
+                            .map(String::trim)
+                            .filter(s -> !"".equals(s))
+                            .collect(Collectors.toSet());
+
+                    result.addExtraBlock(TAGS_BLOCK_NAME, new HashSet<>(filteredTags));
                 });
     }
+
+    public static Optional<Label> createFromTag(final String tag) {
+        final Matcher label = LABEL_TAG.matcher(tag);
+        if (label.matches()) {
+            final String name = label.group("name");
+            final String value = label.group("value");
+            return Optional.of(new Label()
+                    .setName(name)
+                    .setValue(value.replace("_", " ")));
+        }
+        return Optional.empty();
+    }
 }
diff --git a/allure-generator/src/test/java/io/qameta/allure/tags/TagsPluginTest.java b/allure-generator/src/test/java/io/qameta/allure/tags/TagsPluginTest.java
new file mode 100644
index 000000000..e536164f8
--- /dev/null
+++ b/allure-generator/src/test/java/io/qameta/allure/tags/TagsPluginTest.java
@@ -0,0 +1,322 @@
+/*
+ *  Copyright 2016-2024 Qameta Software Inc
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.tags;
+
+import io.qameta.allure.DefaultConfiguration;
+import io.qameta.allure.DefaultLaunchResults;
+import io.qameta.allure.ReportStorage;
+import io.qameta.allure.core.Configuration;
+import io.qameta.allure.core.LaunchResults;
+import io.qameta.allure.entity.Label;
+import io.qameta.allure.entity.TestResult;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.mockito.Mockito.mock;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+class TagsPluginTest {
+
+    @Test
+    void shouldAddTagsFromLabels() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setName("not a tag")
+                                .setValue("some value"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("first"),
+                        new Label()
+                                .setName("feature")
+                                .setValue("Auth"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("third")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.<Set<String>>getExtraBlock(TagsPlugin.TAGS_BLOCK_NAME))
+                .containsExactlyInAnyOrder(
+                        "first",
+                        "second",
+                        "third"
+                );
+    }
+
+    @Test
+    void shouldRemoveDuplicateTags() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setName("not a tag")
+                                .setValue("some value"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("first"),
+                        new Label()
+                                .setName("feature")
+                                .setValue("Auth"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("first"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("    first    "),
+                        new Label()
+                                .setName("tag")
+                                .setValue("third")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.<Set<String>>getExtraBlock(TagsPlugin.TAGS_BLOCK_NAME))
+                .containsExactlyInAnyOrder(
+                        "first",
+                        "second",
+                        "third"
+                );
+    }
+
+    @Test
+    void shouldTrimTagNames() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setName("not a tag")
+                                .setValue("some value"),
+                        new Label()
+                                .setName("tag")
+                                .setValue(" first  \n "),
+                        new Label()
+                                .setName("feature")
+                                .setValue("Auth"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("  second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("third")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.<Set<String>>getExtraBlock(TagsPlugin.TAGS_BLOCK_NAME))
+                .containsExactlyInAnyOrder(
+                        "first",
+                        "second",
+                        "third"
+                );
+    }
+
+    @Test
+    void shouldParseLabelsWithoutName() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setValue("some value"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("first"),
+                        new Label()
+                                .setName("feature")
+                                .setValue("Auth"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("third")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.<Set<String>>getExtraBlock(TagsPlugin.TAGS_BLOCK_NAME))
+                .containsExactlyInAnyOrder(
+                        "first",
+                        "second",
+                        "third"
+                );
+    }
+
+    @Test
+    void shouldParseLabelsWithoutValue() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setName("tag"),
+                        new Label()
+                                .setName("feature"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("third")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.<Set<String>>getExtraBlock(TagsPlugin.TAGS_BLOCK_NAME))
+                .containsExactlyInAnyOrder(
+                        "second",
+                        "third"
+                );
+    }
+
+    @Test
+    void shouldAddMetaTags() {
+        final TestResult testResult = new TestResult()
+                .setLabels(Arrays.asList(
+                        new Label()
+                                .setName("not a tag")
+                                .setValue("some value"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("first"),
+                        new Label()
+                                .setName("feature")
+                                .setValue("Auth"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("second"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("@allure.label.story=Some_story"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("@allure.label.parentSuite:Regression"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("@allure.label.suite:Search_Articles"),
+                        new Label()
+                                .setName("tag")
+                                .setValue("allure.label.subSuite=Mobile")
+                ));
+
+        final List<LaunchResults> launchResults = List.of(
+                new DefaultLaunchResults(Set.of(testResult), Map.of(), Map.of())
+        );
+
+        final Configuration configuration
+                = new DefaultConfiguration(List.of(), List.of());
+
+        final ReportStorage storage = mock();
+
+        new TagsPlugin().aggregate(
+                configuration,
+                launchResults,
+                storage
+        );
+
+        assertThat(testResult.getLabels())
+                .extracting(Label::getName, Label::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("not a tag", "some value"),
+                        tuple("tag", "first"),
+                        tuple("feature", "Auth"),
+                        tuple("tag", "second"),
+                        tuple("tag", "@allure.label.story=Some_story"),
+                        tuple("tag", "@allure.label.parentSuite:Regression"),
+                        tuple("tag", "@allure.label.suite:Search_Articles"),
+                        tuple("tag", "allure.label.subSuite=Mobile"),
+                        tuple("story", "Some story"),
+                        tuple("parentSuite", "Regression"),
+                        tuple("suite", "Search Articles"),
+                        tuple("subSuite", "Mobile")
+                );
+    }
+}