[renovate]

This PR contains the following updates:

Package	Type	Update	Change	OpenSSF
org.awaitility:awaitility (source)	test	major	3.0.0 → 4.3.0

---

Release Notes

awaitility/awaitility (org.awaitility:awaitility)

v4.3.0

• Support for kotlin.time.Duration in Kotlin DSL (thanks to Ivo Šmíd for PR)

• Upgraded kotlin version in the awaitility-kotlin module to 2.1.10

• Using a more descriptive error message when using VERY long wait conditions or poll durations (issue 290)

• Added an overloaded method of untilAsserted(..) that takes a supplier and a consumer. For example, lets say you have a class like this:
  public class MyClass {
  public String myFunction() {
  // Imagine stuff being executed in asynchronously here and the result of this
  // operation is a string called "my value"
  return "my value"
  }
  }

  // Then in your test you can wait for the "myFunction" to be asserted by a "consumer" that uses
  // assertj to make sure that "myFunction" returns ""my value"
  await().untilAsserted(myClass::myFunction, value -> Assertions.assertThat(value).isEqualTo("my value"));

  This has also been implemented for all atomic, adder, and accumulator methods.

v4.2.2

• Support JDK EA builds in JavaVersionDetector (thanks to Oleg Estekhin for pull request)

v4.2.1

• Upgraded Kotlin to 1.9.22

• Added extension properties forever, then, and, given to the Kotlin extension. This allows you to do e.g.:

  await.forever until { .. }

• Added shortcut for enabling logging. Before you had to do e.g.

  await()
  .with()
  .conditionEvaluationListener(new ConditionEvaluationLogger(log::info))
  .pollInterval(ONE_HUNDRED_MILLISECONDS)
  .until(logs::size, is(4));

  You can now instead use the "logging" shortcut:

  await()
  .with()
  .logging(log::info)
  .pollInterval(ONE_HUNDRED_MILLISECONDS)
  .until(logs::size, is(4));

  or simply ".logging()" for "System.out".

  This shortcut has also been added globally:

  Awaitility.setLogging(log::info);

  or

  Awaitility.setDefaultLogging();

• Improved lambda detection for Java 17 and Java 21

• Upgraded Groovy to 4.0.19

v4.2.0

• Fixed a bug in the shutdown behavior of a polling thread. The wrong time unit was used causing executor shutdown to take way more time than expected in cases where it's stuck. Thanks to Claus Näveke for spotting this and for the initial PR.

• Fixed a bug in which condition was not evaluated correctly with small intervals, such as:
  await().atMost(Duration.ofMillis(10)).pollInterval(Duration.ofMillis(5)).until(..);
  (issue 224). Thanks to Robby Decosemaeker for PR.

• Upgraded the awaitility-kotlin module to use kotlin 1.6.10

• Fail fast conditions can now be specified with assertions. For example:

  await().failFast(() -> assertThat(state).isNotEqualTo("Failed")).until(..);

  (issue 238)

v4.1.1

• Fixed a bug preventing you to specify "fib(-1)" when using the fibonacci poll interval (thanks to Björn Michael for pull request) (issue 201)
• Avoid memory leak by caching only the original default uncaught exception handler globally (thanks to Oliver Grof for pull request (issue 221)
• Added "conditionEvaluationListener" to Kotlin DSL

v4.1.0

• Upgraded to Scala from 2.13.3 to 2.13.5 (thanks to sullis for pull request)

• Upgraded Kotlin from 1.3.72 to 1.5.0

• Added support for fail-fast conditions. This is a special condition that, if fulfilled, will throw a "org.awaitility.core.TerminalFailureException" immediately, thus failing the test.
  This is good when you have a condition that you know beforehand should never be fulfilled. So instead of waiting the full duration of a normal condition evaluation period, the test will fail
  faster if this (fail fast) condition evaluates to true. For example:

  await().timeout(Duration.ofSeconds(5)).failFast(() -> orders.findById(1234).state == PAID).until(() -> orders.findById(1234).state == CLOSED);

  This will fail-fast if the state of order 1234 is ever equal to "PAID" during the 5 second evaluation of the condition specified in "until".
  (Thanks to Antony Stubbs for initial pull request) (issue 178)

• Upgraded Groovy from version 3.0.4 to 3.0.8

v4.0.3

• Upgraded to Scala 2.13.2 from 2.13.0 (thanks to sullis for pull request)

• Upgraded Kotlin extension to use Kotlin 1.3.72 (instead of 1.3.61)

• Improved org.awaitility.core.ConditionEvaluationLogger to accept a consumer that decides how the logs are printed. You can use this to for example log intermediary values using slf4j instead of System.out.println or log to to disk or a data structure such as CopyOnWriteArrayList. For example:

  await().conditionEvaluationListener(new ConditionEvaluationLogger(log::info)).until();

  This will log using a the logger "log" instead of printing to the console.

• Fixed problems with test dependencies in pom.xml

• Upgraded Groovy from 2.5.7 to 3.0.4

v4.0.2

• Improved formatting of elapsed time (or error and logging) for long time durations
• Implemented support for "during" (issue 124) (big thanks to Pablo Díaz-López for pull request)
• org.awaitility.core.ConditionEvaluationListener now has two additional hooks, "beforeEvaluation" and "onTimeout", which you can implement to get notified on these events. They are implemented as default methods to retain backward compatibility. (issue 149) (big thanks to Oliver Grof for pull request)
• Upgraded Kotlin extension to use Kotlin 1.3.61 (instead of 1.3.50)
• Added "handleIgnoredException" to org.awaitility.core.ConditionEvaluationListener. This is a hook that let's you react to ignored exceptions caught when evaluating a condition (thanks to Oliver Grof for pull request)
• Avoid hiding exceptions on the same thread (issue 152) (thanks to Oliver Grof for pull request)
• Fixed condition timeout calculation units (issue 148) (thanks to Anthony Baker for pull request)

v4.0.1

• Removed the dependency to objenesis since it's no longer required after the move to Java 8+
• Fixed so that calculation of condition evaluation duration cannot be negative (thanks to Anders Asplund for pull request)

v4.0.0

• Added support for Adder's. For example: await().untilAdder(myLongAdder, equalTo(5L))
• Added support for Accumulators's. For example: await().untilAccumulator(myLongAccumulator, equalTo(5L))
• Better handling of InterruptedException for Future's by using code from Guava (code from Uninterruptibles)
• Shutting down cleanup ExecutorService in an uninterruptible fashion
• Upgraded Kotlin extension to use Kotlin 1.3.50 (instead of 1.3.41)

v3.1.6

• The Kotlin extension function called "has" is now null safe
• The Kotlin extension function called "has" now accepts non-null types
• Upgraded Kotlin extension to use Kotlin 1.3.11 (instead of 1.2.50)

v3.1.5

• Added a new Kotlin extension function called "has" that allows writing succinct expressions when testing for properties in e.g. data classes. For example:

  val data = await untilCallTo { fakeObjectRepository.data } has {
  state == "Hello"
  }

  where "data" is defined as:

  data class Data(var state: String)

  I.e. inside the scope of "has" the "Data" instance is used as "this" (see here for more info).
  This is the same as doing:

  await untilCallTo { fakeObjectRepository.data } matches { data ->
  data?.state == "Hello"
  }

• Improved error message for "untilNotNull" Kotlin extension function

• Added "untilNull" extension function to the Kotlin DSL: await untilNull { myDataRepository.findById("id") }

v3.1.4

• Added "untilNotNull" extension function to the Kotlin DSL: val data = await untilNotNull { myDataRepository.findById("id") }

v3.1.3

• Last exception is included in hierarchy even if ignoreExceptions is set (issue 121) (thanks to Bryn Cooke for pull request)
• Removed the use of java.beans.Introspector for de-capitalization of String's since it doesn't work on Android (issue 125)

v3.1.2

• Added "alias" method to awaitility which allows one to set the alias using a more english-like DSL:
  await().with().alias("my alias"). ..

• Added several new Kotlin extension methods. For example you can now do:

  await withPollInterval ONE_HUNDRED_MILLISECONDS ignoreException IllegalArgumentException::class untilAsserted {
  assertThat(fakeRepository.value).isEqualTo(1)
  }

  or:

  await withAlias "Kotlin Test" ignoreExceptionsInstanceOf
  IllegalArgumentException::class withPollDelay ONE_HUNDRED_MILLISECONDS withPollInterval
  fibonacci().with().offset(1).and().unit(MILLISECONDS) atLeast TWO_HUNDRED_MILLISECONDS atMost
  ONE_MINUTE untilCallTo { fakeRepository.value } matches { it == 1 }

  All extension functions can be imported from the "org.awaitility.kotlin" package (e.g. 'import org.awaitility.kotlin.*')

v3.1.1

• Hamcrest condition evaluation should be safer if called from multiple threads

• Fixed bug where error message showed in Hamcrest condition could be the same as the expected value when conditional evaluation time exceeded at most time (issue 109).

• Added org.awaitility.core.ConditionFactory.until(java.util.concurrent.Callable, org.awaitility.core.Predicate<? super T>) that allows you to use a predicate to evaluate a condition like this:
  await().until(myRepository::count, cnt -> cnt == 2);

• Added Kotlin module. In maven add:

  org.awaitility awaitility-kotlin 3.1.1

  This module adds an extension function called "untilCallTo" (in org.awaitility.kotlin.AwaitilityKt) that allows you to write conditions as:

  await().untilCallTo { fakeRepository.value } matches { it == 1 }

v3.1.0

• Bumped all identified out of data properties, some of which applied to dependencies, and bumped all plugin versions, tests are all passing (thanks to Andy Glick for pull request)
• Fixed issue with ConditionAwaiter calculating a negative condition duration (and thus raised an IllegalArgumentException) in cases where System.currentTimeMillis returned a non-monotonic value (issue 95)
• Throw TimeoutException from executing long-running Callables as ConditionTimeoutException (thanks to James Withers for pull request) (issue 97)
• Updated Objenesis dependency from 2.5.1 to 2.6.0 (issue 104)
• Use wall-clock agnostic System.nanoTime instead of System.currentTimeMillis internally (thanks to Ben Barnard for pull request)
• Improved error messages for assertion conditions when using aliases. Previously aliases could be included twice in the ConditionTimeoutException which obscured the error message somewhat (issue 108).
• Fixed so that Awaitility doesn't stop working when using custom threading with multiple conditions. This also greatly improves use cases where one supplies a custom ExecutorService to Awaitility.
  It'll no longer be shutdown after each call to Awaitility. It's up to you as a user to shutdown the ExecutorService that you provide to Awaitility (issue 101).

---

Configuration

📅 Schedule: (in timezone America/Los_Angeles)

• Branch creation
  • Between 12:00 AM and 03:59 AM, only on Monday (* 0-3 * * 1)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.