Make TextFileBasedViolationStore thread-safe under parallel test execution

Multiple FreezingArchRule instances each create a fresh TextFileBasedViolationStore
and load stored.rules into their own private snapshot. Concurrent saves caused a
lost-update: the last writer overwrote the file with only its own entries.

Fix by sharing one FileSyncedProperties per stored.rules canonical path via a
static ConcurrentHashMap, and synchronizing writes with a putIfAbsent method that
atomically checks, sets, and flushes to disk under one lock.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: kelunik

archunit/src/main/java/com/tngtech/archunit/library/freeze/TextFileBasedViolationStore.java

@@ -23,6 +23,7 @@
 import java.util.List;
 import java.util.Properties;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Pattern;
 
 import com.google.common.base.Splitter;
@@ -74,6 +75,8 @@ public final class TextFileBasedViolationStore implements ViolationStore {
     private static final String ALLOW_STORE_UPDATE_PROPERTY_NAME = "default.allowStoreUpdate";
     private static final String ALLOW_STORE_UPDATE_DEFAULT = "true";
 
+    private static final ConcurrentHashMap<String, FileSyncedProperties> STORED_RULES_BY_PATH = new ConcurrentHashMap<>();
+
     private final RuleViolationFileNameStrategy ruleViolationFileNameStrategy;
 
     private boolean storeCreationAllowed;
@@ -108,10 +111,18 @@ public void initialize(Properties properties) {
         ensureExistence(storeFolder);
         File storedRulesFile = getStoredRulesFile();
         log.trace("Initializing {} at {}", TextFileBasedViolationStore.class.getSimpleName(), storedRulesFile.getAbsolutePath());
-        storedRules = new FileSyncedProperties(storedRulesFile);
+        storedRules = getOrCreateStoredRules(storedRulesFile);
         checkInitialization(storedRules.initializationSuccessful(), "Cannot create rule store at %s", storedRulesFile.getAbsolutePath());
     }
 
+    private FileSyncedProperties getOrCreateStoredRules(File storedRulesFile) {
+        try {
+            return STORED_RULES_BY_PATH.computeIfAbsent(storedRulesFile.getCanonicalPath(), path -> new FileSyncedProperties(storedRulesFile));
+        } catch (IOException e) {
+            throw new StoreInitializationFailedException(e);
+        }
+    }
+
     private File getStoredRulesFile() {
         File rulesFile = new File(storeFolder, STORED_RULES_FILE_NAME);
         if (!rulesFile.exists() && !storeCreationAllowed) {
@@ -171,17 +182,14 @@ private String unescape(String violation) {
 
     private String ensureRuleFileName(ArchRule rule) {
         String ruleDescription = rule.getDescription();
-
-        String ruleFileName;
-        if (storedRules.containsKey(ruleDescription)) {
-            ruleFileName = storedRules.getProperty(ruleDescription);
-            log.trace("Rule '{}' is already stored in file {}", ruleDescription, ruleFileName);
-        } else {
-            ruleFileName = ruleViolationFileNameStrategy.createRuleFileName(ruleDescription);
-            log.trace("Assigning new file {} to rule '{}'", ruleFileName, ruleDescription);
-            storedRules.setProperty(ruleDescription, ruleFileName);
+        String candidateFileName = ruleViolationFileNameStrategy.createRuleFileName(ruleDescription);
+        String existingFileName = storedRules.putIfAbsent(ruleDescription, candidateFileName);
+        if (existingFileName == null) {
+            log.trace("Assigning new file {} to rule '{}'", candidateFileName, ruleDescription);
+            return candidateFileName;
         }
-        return ruleFileName;
+        log.trace("Rule '{}' is already stored in file {}", ruleDescription, existingFileName);
+        return existingFileName;
     }
 
     @Override
@@ -250,9 +258,15 @@ String getProperty(String propertyName) {
             return loadedProperties.getProperty(ensureUnixLineBreaks(propertyName));
         }
 
-        void setProperty(String propertyName, String value) {
-            loadedProperties.setProperty(ensureUnixLineBreaks(propertyName), ensureUnixLineBreaks(value));
+        synchronized String putIfAbsent(String key, String value) {
+            String normalizedKey = ensureUnixLineBreaks(key);
+            String existing = loadedProperties.getProperty(normalizedKey);
+            if (existing != null) {
+                return existing;
+            }
+            loadedProperties.setProperty(normalizedKey, ensureUnixLineBreaks(value));
             syncFileSystem();
+            return null;
         }
 
         private void syncFileSystem() {

archunit/src/test/java/com/tngtech/archunit/library/freeze/TextFileBasedViolationStoreTest.java

@@ -6,6 +6,11 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Properties;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.Files;
@@ -33,9 +38,7 @@ public class TextFileBasedViolationStoreTest {
     public void setUp() throws Exception {
         configuredFolder = new File(temporaryFolder.newFolder(), "notyetthere");
 
-        store.initialize(propertiesOf(
-                "default.path", configuredFolder.getAbsolutePath(),
-                "default.allowStoreCreation", String.valueOf(true)));
+        store.initialize(defaultStoreProperties());
     }
 
     @Test
@@ -108,6 +111,38 @@ public void stores_violations_of_multiple_rules() {
         assertThat(store.getViolations(thirdRule)).containsOnly("third violation1", "third violation2");
     }
 
+    @Test
+    public void is_safe_when_multiple_instances_save_to_the_same_store_concurrently() throws Exception {
+        int ruleCount = 20;
+        try (ExecutorService executor = Executors.newFixedThreadPool(8)) {
+            CountDownLatch startSignal = new CountDownLatch(1);
+
+            IntStream.range(0, ruleCount).forEach(i -> executor.submit(() -> {
+                ArchRule concurrentRule = rule("concurrent rule " + i);
+                ViolationStore instanceStore = new TextFileBasedViolationStore();
+                instanceStore.initialize(defaultStoreProperties());
+                startSignal.await();
+                instanceStore.save(concurrentRule, ImmutableList.of("violation " + i));
+                return null;
+            }));
+
+            startSignal.countDown();
+            executor.shutdown();
+            assertThat(executor.awaitTermination(30, TimeUnit.SECONDS)).isTrue();
+        }
+
+        Properties storedRules = readProperties(new File(configuredFolder, "stored.rules"));
+        assertThat(storedRules).hasSize(ruleCount);
+
+        ViolationStore readerStore = new TextFileBasedViolationStore();
+        readerStore.initialize(defaultStoreProperties());
+        for (int i = 0; i < ruleCount; i++) {
+            ArchRule concurrentRule = rule("concurrent rule " + i);
+            assertThat(readerStore.contains(concurrentRule)).as("store contains " + concurrentRule.getDescription()).isTrue();
+            assertThat(readerStore.getViolations(concurrentRule)).containsOnly("violation " + i);
+        }
+    }
+
     @Test
     public void stores_violations_with_line_breaks() {
         List<String> expected = ImmutableList.of(String.format("first with%nlinebreak"), String.format("second with%nlinebreak"));
@@ -126,6 +161,12 @@ private Properties readProperties(File file) throws IOException {
         return properties;
     }
 
+    private Properties defaultStoreProperties() {
+        return propertiesOf(
+                "default.path", configuredFolder.getAbsolutePath(),
+                "default.allowStoreCreation", String.valueOf(true));
+    }
+
     private Properties propertiesOf(String... keyValuePairs) {
         Properties result = new Properties();
         LinkedList<String> keyValues = new LinkedList<>(asList(keyValuePairs));