Provide a way to update the attributes of a CoroutineCondition

conditional-kotlin/src/main/kotlin/com/linecorp/conditional/kotlin/ConditionExtension.kt

@@ -40,7 +40,7 @@ fun condition(
     function: ConditionFunction,
 ): Condition = Condition.of(function)
     .alias(alias).async(async).executor(executor)
-    .delay(delayMillis).timeout(timeoutMillis).cancellable(cancellable)
+    .delayMillis(delayMillis).timeoutMillis(timeoutMillis).cancellable(cancellable)
 
 /**
  * Returns the [ConditionBuilder].

conditional-kotlin/src/main/kotlin/com/linecorp/conditional/kotlin/CoroutineCondition.kt

@@ -39,6 +39,31 @@ abstract class CoroutineCondition(
     fun attributes(block: (AttributeUpdater) -> Unit) =
         with(AttributeUpdater(this)) { block(this).run { update() } }
 
+    /**
+     * Returns a newly created [CoroutineCondition] with [alias] updated.
+     */
+    fun alias(block: () -> String?) = attributes { it.alias(block()) }
+
+    /**
+     * Returns a newly created [CoroutineCondition] with [delayMillis] updated.
+     */
+    fun delayMillis(block: () -> Long) = attributes { it.delayMillis(block()) }
+
+    /**
+     * Returns a newly created [CoroutineCondition] with [delayMillis] updated.
+     */
+    fun delay(block: () -> Duration) = attributes { it.delay(block()) }
+
+    /**
+     * Returns a newly created [CoroutineCondition] with [timeoutMillis] updated.
+     */
+    fun timeoutMillis(block: () -> Long) = attributes { it.timeoutMillis(block()) }
+
+    /**
+     * Returns a newly created [CoroutineCondition] with [timeoutMillis] updated.
+     */
+    fun timeout(block: () -> Duration) = attributes { it.timeout(block()) }
+
     /**
      * Returns a newly created [CoroutineCondition].
      * This [CoroutineCondition] is composed with the AND operator.
@@ -140,37 +165,37 @@ abstract class CoroutineCondition(
         }
 
         /**
-         * Returns the [AttributeUpdater] with [alias] set.
+         * Returns the [AttributeUpdater] with [alias] updated.
          */
         fun alias(alias: String?) = also { this.alias = alias }
 
         /**
-         * Returns the [AttributeUpdater] with [delayMillis] set.
+         * Returns the [AttributeUpdater] with [delayMillis] updated.
          */
-        fun delay(delayMillis: Long) = also { this.delayMillis = delayMillis }
+        fun delayMillis(delayMillis: Long) = also { this.delayMillis = delayMillis }
 
         /**
-         * Returns the [AttributeUpdater] with [delayMillis] set.
+         * Returns the [AttributeUpdater] with [delayMillis] updated.
          */
         fun delay(delay: Long, unit: TimeUnit) = also { delayMillis = unit.toMillis(delay) }
 
         /**
-         * Returns the [AttributeUpdater] with [delayMillis] set.
+         * Returns the [AttributeUpdater] with [delayMillis] updated.
          */
         fun delay(delay: Duration) = also { delayMillis = delay.toMillis() }
 
         /**
-         * Returns the [AttributeUpdater] with [timeoutMillis] set.
+         * Returns the [AttributeUpdater] with [timeoutMillis] updated.
          */
-        fun timeout(timeoutMillis: Long) = also { this.timeoutMillis = timeoutMillis }
+        fun timeoutMillis(timeoutMillis: Long) = also { this.timeoutMillis = timeoutMillis }
 
         /**
-         * Returns the [AttributeUpdater] with [timeoutMillis] set.
+         * Returns the [AttributeUpdater] with [timeoutMillis] updated.
          */
         fun timeout(timeout: Long, unit: TimeUnit) = also { timeoutMillis = unit.toMillis(timeout) }
 
         /**
-         * Returns the [AttributeUpdater] with [timeoutMillis] set.
+         * Returns the [AttributeUpdater] with [timeoutMillis] updated.
          */
         fun timeout(timeout: Duration) = also { timeoutMillis = timeout.toMillis() }
 

conditional-kotlin/src/test/kotlin/com/linecorp/conditional/kotlin/CoroutineConditionTest.kt

@@ -23,6 +23,7 @@ import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.*
 import org.awaitility.Awaitility.await
 import org.junit.jupiter.api.Test
+import java.time.Duration
 import java.util.concurrent.TimeUnit
 
 class CoroutineConditionTest {
@@ -69,23 +70,72 @@ class CoroutineConditionTest {
     }
 
     @Test
-    fun attributes() {
+    fun update_attributes() {
         val condition = coroutineCondition { true }
         assertThat(condition.alias).isEqualTo(CoroutineCondition.DEFAULT_ALIAS)
         assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
         assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
 
         val updated = condition.attributes {
             it.alias("AliasedCoroutineCondition")
-            it.delay(1000)
-            it.timeout(2000)
+            it.delayMillis(1000)
+            it.timeoutMillis(2000)
         }
         assertThat(updated.alias).isEqualTo("AliasedCoroutineCondition")
         assertThat(updated.delayMillis).isEqualTo(1000)
         assertThat(updated.timeoutMillis).isEqualTo(2000)
+        assertThat(condition.alias).isEqualTo(CoroutineCondition.DEFAULT_ALIAS)
+        assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
+        assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
+    }
+
+    @Test
+    fun update_alias() {
+        val condition = coroutineCondition { true }
+        assertThat(condition.alias).isEqualTo(CoroutineCondition.DEFAULT_ALIAS)
 
+        val updated = condition.alias { "AliasedCoroutineCondition" }
+        assertThat(updated.alias).isEqualTo("AliasedCoroutineCondition")
         assertThat(condition.alias).isEqualTo(CoroutineCondition.DEFAULT_ALIAS)
+    }
+
+    @Test
+    fun update_delayMillis() {
+        val condition = coroutineCondition { true }
         assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
+
+        val updated = condition.delayMillis { 1000 }
+        assertThat(updated.delayMillis).isEqualTo(1000)
+        assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
+    }
+
+    @Test
+    fun update_delay() {
+        val condition = coroutineCondition { true }
+        assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
+
+        val updated = condition.delay { Duration.ofMillis(1000) }
+        assertThat(updated.delayMillis).isEqualTo(1000)
+        assertThat(condition.delayMillis).isEqualTo(CoroutineCondition.DEFAULT_DELAY_MILLIS)
+    }
+
+    @Test
+    fun update_timeoutMillis() {
+        val condition = coroutineCondition { true }
+        assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
+
+        val updated = condition.timeoutMillis { 1000 }
+        assertThat(updated.timeoutMillis).isEqualTo(1000)
+        assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
+    }
+
+    @Test
+    fun update_timeout() {
+        val condition = coroutineCondition { true }
+        assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
+
+        val updated = condition.timeout { Duration.ofMillis(1000) }
+        assertThat(updated.timeoutMillis).isEqualTo(1000)
         assertThat(condition.timeoutMillis).isEqualTo(CoroutineCondition.DEFAULT_TIMEOUT_MILLIS)
     }
 

conditional/src/main/java/com/linecorp/conditional/Condition.java

@@ -47,7 +47,7 @@
  * // Step 3: Match a conditional expression.
  * assert condition.matches(ctx) == true;</pre>
  * <p>
- * If you need set timeout, use {@link Condition#timeout(long)}, {@link Condition#timeout(long, TimeUnit)}.
+ * If you need set timeout, use {@link Condition#timeoutMillis(long)}, {@link Condition#timeout(long, TimeUnit)}.
  * </p><p>
  * If you need asynchronous support, use {@link Condition#async()} related methods.
  * Alternatively, {@link Condition#parallel()} might also help.
@@ -129,7 +129,7 @@ protected boolean match(ConditionContext ctx) {
      * @throws NullPointerException if the {@code function} is null.
      */
     public static Condition of(ConditionFunction function, long timeoutMillis) {
-        return of(function).timeout(timeoutMillis);
+        return of(function).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -180,7 +180,7 @@ public static Condition of(ConditionFunction function, String alias) {
      * @throws NullPointerException if {@code function} or {@code alias} is null.
      */
     public static Condition of(ConditionFunction function, String alias, long timeoutMillis) {
-        return of(function, alias).timeout(timeoutMillis);
+        return of(function, alias).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -230,7 +230,7 @@ public static Condition async(ConditionFunction function) {
      * @throws NullPointerException if the {@code function} is null.
      */
     public static Condition async(ConditionFunction function, long timeoutMillis) {
-        return async(function).timeout(timeoutMillis);
+        return async(function).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -243,7 +243,7 @@ public static Condition async(ConditionFunction function, long timeoutMillis) {
      * @throws NullPointerException if {@code function} or {@code executor} is null.
      */
     public static Condition async(ConditionFunction function, long timeoutMillis, Executor executor) {
-        return async(function, executor).timeout(timeoutMillis);
+        return async(function, executor).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -334,7 +334,7 @@ public static Condition async(ConditionFunction function, String alias) {
      * @throws NullPointerException if {@code function} or {@code alias} is null.
      */
     public static Condition async(ConditionFunction function, String alias, long timeoutMillis) {
-        return async(function, alias).timeout(timeoutMillis);
+        return async(function, alias).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -350,7 +350,7 @@ public static Condition async(ConditionFunction function, String alias, long tim
     public static Condition async(ConditionFunction function, String alias, long timeoutMillis,
                                   Executor executor) {
         requireNonNull(executor, "executor");
-        return async(function, alias).timeout(timeoutMillis).executor(executor);
+        return async(function, alias).timeoutMillis(timeoutMillis).executor(executor);
     }
 
     /**
@@ -422,7 +422,7 @@ public static Condition async(ConditionFunction function, String alias, Duration
      * @throws NullPointerException if the {@code function} is null.
      */
     public static Condition delayed(ConditionFunction function, long delayMillis) {
-        return of(function).delay(delayMillis);
+        return of(function).delayMillis(delayMillis);
     }
 
     /**
@@ -460,7 +460,7 @@ public static Condition delayed(ConditionFunction function, Duration delay) {
      * @throws NullPointerException if {@code function} or {@code alias} is null.
      */
     public static Condition delayed(ConditionFunction function, String alias, long delayMillis) {
-        return of(function, alias).delay(delayMillis);
+        return of(function, alias).delayMillis(delayMillis);
     }
 
     /**
@@ -525,7 +525,7 @@ public static Condition from(CompletableFuture<Boolean> future, String alias) {
      * @throws NullPointerException if {@code future} or {@code alias} is null.
      */
     public static Condition from(CompletableFuture<Boolean> future, String alias, long timeoutMillis) {
-        return from(future, alias).timeout(timeoutMillis);
+        return from(future, alias).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -551,7 +551,7 @@ public static Condition from(CompletableFuture<Boolean> future, String alias, lo
      * @throws NullPointerException if the {@code future} is null.
      */
     public static Condition from(CompletableFuture<Boolean> future, long timeoutMillis) {
-        return from(future).timeout(timeoutMillis);
+        return from(future).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -602,7 +602,7 @@ public static Condition from(Supplier<Boolean> supplier, String alias) {
      * @throws NullPointerException if {@code supplier} or {@code alias} is null.
      */
     public static Condition from(Supplier<Boolean> supplier, String alias, long timeoutMillis) {
-        return from(supplier, alias).timeout(timeoutMillis);
+        return from(supplier, alias).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -628,7 +628,7 @@ public static Condition from(Supplier<Boolean> supplier, String alias, long time
      * @throws NullPointerException if the {@code supplier} is null.
      */
     public static Condition from(Supplier<Boolean> supplier, long timeoutMillis) {
-        return from(supplier).timeout(timeoutMillis);
+        return from(supplier).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -679,7 +679,7 @@ public static Condition from(Function<ConditionContext, Boolean> function, Strin
      */
     public static Condition from(Function<ConditionContext, Boolean> function, String alias,
                                  long timeoutMillis) {
-        return from(function, alias).timeout(timeoutMillis);
+        return from(function, alias).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -706,7 +706,7 @@ public static Condition from(Function<ConditionContext, Boolean> function, Strin
      * @throws NullPointerException if the {@code function} is null.
      */
     public static Condition from(Function<ConditionContext, Boolean> function, long timeoutMillis) {
-        return from(function).timeout(timeoutMillis);
+        return from(function).timeoutMillis(timeoutMillis);
     }
 
     /**
@@ -954,8 +954,8 @@ public final Executor executor() {
     /**
      * Returns the {@link Condition} with {@code delayMillis} attribute updated.
      */
-    public Condition delay(long delayMillis) {
-        return update(attributeUpdater -> attributeUpdater.delay(delayMillis));
+    public Condition delayMillis(long delayMillis) {
+        return update(attributeUpdater -> attributeUpdater.delayMillis(delayMillis));
     }
 
     /**
@@ -986,8 +986,8 @@ public final long delayMillis() {
     /**
      * Returns the {@link Condition} with {@code timeoutMillis} attribute updated.
      */
-    public Condition timeout(long timeoutMillis) {
-        return update(attributeUpdater -> attributeUpdater.timeout(timeoutMillis));
+    public Condition timeoutMillis(long timeoutMillis) {
+        return update(attributeUpdater -> attributeUpdater.timeoutMillis(timeoutMillis));
     }
 
     /**

conditional/src/main/java/com/linecorp/conditional/ConditionAttributeUpdater.java

@@ -76,7 +76,7 @@ final Executor executor() {
         return executor;
     }
 
-    final ConditionAttributeUpdater delay(long delayMillis) {
+    final ConditionAttributeUpdater delayMillis(long delayMillis) {
         this.delayMillis = delayMillis;
         return this;
     }
@@ -97,7 +97,7 @@ final long delayMillis() {
         return delayMillis;
     }
 
-    final ConditionAttributeUpdater timeout(long timeoutMillis) {
+    final ConditionAttributeUpdater timeoutMillis(long timeoutMillis) {
         this.timeoutMillis = timeoutMillis;
         return this;
     }

conditional/src/main/java/com/linecorp/conditional/ConditionBuilder.java

@@ -77,7 +77,7 @@ public ConditionBuilder executor(@Nullable Executor executor) {
     /**
      * Returns the {@link ConditionBuilder} with {@code delayMillis} set.
      */
-    public ConditionBuilder delay(long delayMillis) {
+    public ConditionBuilder delayMillis(long delayMillis) {
         this.delayMillis = delayMillis;
         return this;
     }
@@ -107,7 +107,7 @@ public ConditionBuilder delay(Duration delay) {
     /**
      * Returns the {@link ConditionBuilder} with {@code timeoutMillis} set.
      */
-    public ConditionBuilder timeout(long timeoutMillis) {
+    public ConditionBuilder timeoutMillis(long timeoutMillis) {
         this.timeoutMillis = timeoutMillis;
         return this;
     }

conditional/src/test/java/com/linecorp/conditional/ComposableConditionTest.java

@@ -30,7 +30,7 @@ void matches() {
             @Override
             protected Condition compose() {
                 final var a = Condition.async(ctx -> true).alias("a");
-                final var b = Condition.failed(new RuntimeException()).async().delay(1000).alias("b");
+                final var b = Condition.failed(new RuntimeException()).async().delayMillis(1000).alias("b");
                 return a.and(b);
             }
         }.alias("Composed");