@ExpectMaxQueryExecutionTime: change annotation elements and improve reporting

See #93
Co-authored-by: Fabrice Tarfasse <[email protected]>

Author: FTarfasse

sql/sql-annotations/src/main/java/org/quickperf/sql/annotation/ExpectMaxQueryExecutionTime.java

@@ -24,7 +24,7 @@
  * <p>
  * <h4>Example:</h4>
  * <pre>
- *      <b>&#064;ExpectMaxQueryExecutionTime(value = 20, unit = TimeUnit.MILLISECONDS)</b>
+ *      <b>&#064;ExpectMaxQueryExecutionTime(thresholdInMilliSeconds = 2)</b>
  *      public void execute() {
  *          <code>..</code>
  *      }
@@ -35,16 +35,11 @@
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface ExpectMaxQueryExecutionTime {
 
-	/**
-	 * Max query execution time.
-	 */
+    /**
+     * Specifies a <code>value</code> (integer) to cause test method to fail if any query has a greater execution time.
+     * Note that if left empty, the assumed value will be zero.
+     */
 
-	long value();
-
-	/**
-	 * Time unit. Possible values are listed in {@link java.util.concurrent.TimeUnit }.
-	 */
-
-	TimeUnit unit();
+    int thresholdInMilliSeconds() default 0;
 
 }

sql/sql-annotations/src/main/java/org/quickperf/sql/annotation/SqlAnnotationBuilder.java

@@ -12,7 +12,6 @@
 package org.quickperf.sql.annotation;
 
 import java.lang.annotation.Annotation;
-import java.util.concurrent.TimeUnit;
 
 public class SqlAnnotationBuilder {
 
@@ -210,19 +209,16 @@ public int value() {
         };
     }
 
-    public static ExpectMaxQueryExecutionTime expectMaxQueryExecutionTime(final int value, final TimeUnit unit) {
+    public static ExpectMaxQueryExecutionTime expectMaxQueryExecutionTime(final int thresholdInMilliSeconds) {
         return new ExpectMaxQueryExecutionTime() {
             @Override
             public Class<? extends Annotation> annotationType() {
                 return ExpectMaxQueryExecutionTime.class;
             }
+
             @Override
-            public long value() {
-                return value;
-            }
-            @Override
-            public TimeUnit unit() {
-                return unit;
+            public int thresholdInMilliSeconds() {
+                return thresholdInMilliSeconds;
             }
         };
     }

sql/sql-annotations/src/main/java/org/quickperf/sql/time/SqlQueryMaxExecutionTimeVerifier.java

@@ -16,6 +16,8 @@
 import org.quickperf.sql.annotation.ExpectMaxQueryExecutionTime;
 import org.quickperf.time.ExecutionTime;
 
+import java.util.concurrent.TimeUnit;
+
 public class SqlQueryMaxExecutionTimeVerifier implements VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> {
 
 	public static final SqlQueryMaxExecutionTimeVerifier INSTANCE = new SqlQueryMaxExecutionTimeVerifier();
@@ -25,17 +27,20 @@ private SqlQueryMaxExecutionTimeVerifier() {}
 	@Override
 	public PerfIssue verifyPerfIssue(ExpectMaxQueryExecutionTime annotation, ExecutionTime measure) {
 
-		ExecutionTime maxExpectedSqlExecutionTime = new ExecutionTime(annotation.value(), annotation.unit());
+		ExecutionTime maxExpectedSqlExecutionTime = new ExecutionTime(annotation.thresholdInMilliSeconds(), TimeUnit.MILLISECONDS);
 
 		if(measure.isGreaterThan(maxExpectedSqlExecutionTime)) {
-
-			String message = "At least one request exceeds the max expected query execution time <" + maxExpectedSqlExecutionTime + ">.";
-
-			return new PerfIssue(message);
-
+			return buildPerfIssue(measure, maxExpectedSqlExecutionTime);
 		}
 
 		return PerfIssue.NONE;
 	}
 
+	private PerfIssue buildPerfIssue(ExecutionTime effectiveExecutionTime, ExecutionTime maxExecutionTime) {
+		String description =
+				"Query execution time expected to be less than <" +maxExecutionTime.toString() + ">"
+						+ "\n	At least one query has a greater execution time. The greater query execution time is <" + effectiveExecutionTime.toString() + ">";
+		return new PerfIssue(description);
+	}
+
 }

sql/sql-annotations/src/test/java/org/quickperf/sql/time/SqlQueryMaxExecutionTimeVerifierTest.java

@@ -11,6 +11,7 @@
 
 package org.quickperf.sql.time;
 
+import org.assertj.core.api.Assertions;
 import org.junit.Test;
 import org.quickperf.issue.PerfIssue;
 import org.quickperf.issue.VerifiablePerformanceIssue;
@@ -20,60 +21,60 @@
 
 import java.util.concurrent.TimeUnit;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-
 public class SqlQueryMaxExecutionTimeVerifierTest {
-	
-	@Test
-	public void should_return_a_perf_issue_if_query_execution_time_is_greater_than_expected () {
-		
-		VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
-
-		ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(10, TimeUnit.MILLISECONDS);
-		
-		ExecutionTime sqlExecTime = new ExecutionTime(50L, TimeUnit.MILLISECONDS);
-		
-		PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
-		
-		assertNotEquals(PerfIssue.NONE.getDescription(), perfIssue.getDescription());
-		
-		assertNotEquals(PerfIssue.NONE, perfIssue);
-
-	}
-
-	@Test
-	public void should_return_no_perf_issue_if_query_execution_time_is_less_than_expected () {
-
-		VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
-		
-		ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(1, TimeUnit.MILLISECONDS);
-		
-		ExecutionTime sqlExecTime = new ExecutionTime(5, TimeUnit.NANOSECONDS);
-		
-		PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
-		
-		assertEquals(PerfIssue.NONE, perfIssue);
-		
-		assertEquals(PerfIssue.NONE.getDescription(), perfIssue.getDescription());
-
-	}
-	
-	@Test
-	public void should_return_no_perf_issue_if_query_execution_time_is_same_as_expected () {
-
-		VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
-
-		ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(1, TimeUnit.SECONDS);
-
-		ExecutionTime sqlExecTime = new ExecutionTime(1000L, TimeUnit.MILLISECONDS);
-		
-		PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
-		
-		assertEquals(PerfIssue.NONE.getDescription(), perfIssue.getDescription());
-		
-		assertEquals(PerfIssue.NONE, perfIssue);
-
-	}
+
+    @Test
+    public void should_return_a_perf_issue_if_query_execution_time_is_greater_than_expected() {
+
+        // GIVEN
+        VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
+        ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(1);
+        ExecutionTime sqlExecTime = new ExecutionTime(5, TimeUnit.MILLISECONDS);
+
+        // WHEN
+        PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
+
+        // THEN
+        Assertions.assertThat(PerfIssue.NONE).isNotEqualTo(perfIssue);
+        Assertions.assertThat(PerfIssue.NONE.getDescription()).isNotEqualTo(perfIssue.getDescription());
+        Assertions.assertThat(perfIssue.getDescription())
+                .contains("Query execution time expected to be less than <1 ms>")
+                .contains("At least one query has a greater execution time. The greater query execution time is <5 ms>");
+
+    }
+
+    @Test
+    public void should_return_no_perf_issue_if_query_execution_time_is_less_than_expected() {
+
+        // GIVEN
+        VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
+        ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(5);
+        ExecutionTime sqlExecTime = new ExecutionTime(1, TimeUnit.MILLISECONDS);
+
+        // WHEN
+        PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
+
+        // THEN
+        Assertions.assertThat(PerfIssue.NONE).isEqualTo(perfIssue);
+        Assertions.assertThat(PerfIssue.NONE.getDescription()).isEqualTo(perfIssue.getDescription());
+
+    }
+
+    @Test
+    public void should_return_no_perf_issue_if_query_execution_time_is_same_as_expected() {
+
+        // GIVEN
+        VerifiablePerformanceIssue<ExpectMaxQueryExecutionTime, ExecutionTime> verifier = SqlQueryMaxExecutionTimeVerifier.INSTANCE;
+        ExpectMaxQueryExecutionTime expectedMaxExecutionTime = SqlAnnotationBuilder.expectMaxQueryExecutionTime(1);
+        ExecutionTime sqlExecTime = new ExecutionTime(1, TimeUnit.MILLISECONDS);
+
+        // WHEN
+        PerfIssue perfIssue = verifier.verifyPerfIssue(expectedMaxExecutionTime, sqlExecTime);
+
+        // THEN
+        Assertions.assertThat(PerfIssue.NONE).isEqualTo(perfIssue);
+        Assertions.assertThat(PerfIssue.NONE.getDescription()).isEqualTo(perfIssue.getDescription());
+
+    }
 
 }