Fuzz test with two locks

lukas-krecan · lukas-krecan · commit 841f0882c8e9 · 2020-05-10T18:16:09.000+02:00
diff --git a/providers/jdbc/shedlock-test-support-jdbc/src/main/java/net/javacrumbs/shedlock/test/support/jdbc/TransactionalFuzzTester.java b/providers/jdbc/shedlock-test-support-jdbc/src/main/java/net/javacrumbs/shedlock/test/support/jdbc/TransactionalFuzzTester.java
@@ -15,6 +15,7 @@
  */
 package net.javacrumbs.shedlock.test.support.jdbc;
 
+import net.javacrumbs.shedlock.core.LockConfiguration;
 import net.javacrumbs.shedlock.core.LockProvider;
 import net.javacrumbs.shedlock.test.support.FuzzTester;
 import org.springframework.jdbc.datasource.DataSourceTransactionManager;
@@ -28,9 +29,9 @@ public class TransactionalFuzzTester {
     public static void fuzzTestShouldWorkWithTransaction(LockProvider lockProvider, DataSource dataSource) throws ExecutionException, InterruptedException {
         new FuzzTester(lockProvider) {
             @Override
-            protected Void task(int iterations) {
+            protected Void task(int iterations, Job job) {
                 TransactionTemplate transactionTemplate = new TransactionTemplate(new DataSourceTransactionManager(dataSource));
-                return transactionTemplate.execute(status -> super.task(iterations));
+                return transactionTemplate.execute(status -> super.task(iterations, job));
             }
 
             @Override
diff --git a/shedlock-test-support/src/main/java/net/javacrumbs/shedlock/test/support/FuzzTester.java b/shedlock-test-support/src/main/java/net/javacrumbs/shedlock/test/support/FuzzTester.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2009-2020 the original author or authors.
- *
+ * <p>
  * 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
- *
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
  * 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.
@@ -46,8 +46,8 @@ public class FuzzTester {
 
     private final LockProvider lockProvider;
 
-    private int counter;
-    private final LockConfiguration config = new LockConfiguration("lock", Duration.of(5, ChronoUnit.MINUTES), Duration.of(5, ChronoUnit.MILLIS));
+    private static final LockConfiguration config1 = new LockConfiguration("lock1", Duration.of(5, ChronoUnit.MINUTES), Duration.of(5, ChronoUnit.MILLIS));
+    private static final LockConfiguration config2 = new LockConfiguration("lock2", Duration.of(5, ChronoUnit.MINUTES), Duration.of(5, ChronoUnit.MILLIS));
 
     private final Logger logger = LoggerFactory.getLogger(getClass());
 
@@ -59,11 +59,17 @@ public void doFuzzTest() throws InterruptedException, ExecutionException {
         ExecutorService executor = Executors.newFixedThreadPool(THREADS);
         int[] iterations = range(0, THREADS).map(i -> ITERATIONS).toArray();
         iterations[0] = SHORT_ITERATION; // short task to simulate MySql issues
+        Job job1 = new Job(config1);
+        Job job2 = new Job(config2);
 
-        List<Callable<Void>> tasks = range(0, THREADS).mapToObj(i -> (Callable<Void>) () -> this.task(iterations[i])).collect(toList());
+
+        List<Callable<Void>> tasks = range(0, THREADS).mapToObj(i -> (Callable<Void>) () ->
+            this.task(iterations[i], i % 2 == 0 ? job1 : job2)).collect(toList()
+        );
         waitForIt(executor.invokeAll(tasks));
 
-        assertThat(counter).isEqualTo((THREADS - 1) * ITERATIONS + SHORT_ITERATION);
+        assertThat(job1.getCounter()).isEqualTo((THREADS / 2 - 1) * ITERATIONS + SHORT_ITERATION);
+        assertThat(job2.getCounter()).isEqualTo(THREADS / 2 * ITERATIONS);
     }
 
     private void waitForIt(List<Future<Void>> futures) throws InterruptedException, ExecutionException {
@@ -72,16 +78,16 @@ private void waitForIt(List<Future<Void>> futures) throws InterruptedException,
         }
     }
 
-    protected Void task(int iterations) {
+    protected Void task(int iterations, Job job) {
         try {
             for (int i = 0; i < iterations; ) {
-                Optional<SimpleLock> lock = lockProvider.lock(config);
+                Optional<SimpleLock> lock = lockProvider.lock(job.getLockConfiguration());
                 if (lock.isPresent()) {
-                    int n = counter;
+                    int n = job.getCounter();
                     if (shouldLog()) logger.debug("action=getLock value={} i={}", n, i);
                     sleep();
                     if (shouldLog()) logger.debug("action=setCounter value={} i={}", n + 1, i);
-                    counter = n + 1;
+                    job.setCounter(n + 1);
                     i++;
                     lock.get().unlock();
                 }
@@ -106,4 +112,26 @@ private void sleep() {
         }
     }
 
+    protected static class Job {
+        private final LockConfiguration lockConfiguration;
+        private int counter = 0;
+
+        Job(LockConfiguration lockConfiguration) {
+            this.lockConfiguration = lockConfiguration;
+        }
+
+        public LockConfiguration getLockConfiguration() {
+            return lockConfiguration;
+        }
+
+        public int getCounter() {
+            return counter;
+        }
+
+        public void setCounter(int counter) {
+            this.counter = counter;
+        }
+    }
 }
+
+
