testrepository | Test runner runner and repository of test results | Unit Testing library

According to this article: https://howtodoinjava.com/spring-boot/command-line-runner-interface-example/

correct code for spring boot application, which implement CommandLineRunner, is the following:

In the end I went with a SqlDateReader to skip those exceptions being thrown hundreds of thousands times a day.

Change your create method like below:

Spring Data Elasticsearch never closes the client as it does not create it, you create it in your configuraiton.

And like the linked document states:

you should close the high-level client when you are well and truly done with it

Spring Data Elasticsearch cannot know if and when your application does not need the connection to Elasticsearch any more.

So you might keep a reference to the client and close it if you think you really don't need it. But any calls to ElasticsearchOperations or repositories will fail after that.

Actually I never heard of a problem because of wasted resources of a single instance of this class in an application, I'd say don't bother with closing it.

In your ConcurrentKafkaListenerContainerFactory, just associate a SeekToCurrentErrorHandler:

When using the @SpringBootTest annotation the classes parameter is used for tell Spring wihch classes should be used to load the application context.

If no explicit classes are defined the test will use the context configuration you have defined in your webapp.

In your case I guess you want the later which you get by changing

https://github.com/symfony/maker-bundle/issues/841

symfony/maker-bundle v1.30.1 fixes it.

This works as intended. When you stream items from a Flux it will feed as long as there are items in the stream. Then the stream will close. So in your case, it fetched all data from the database, streamed it to you and then closed.

If you wish to keep the stream open you need to keep sending data. One way to do that is to send :keep alive messages (messages that start with a comma) using ServerSentsEvents. You can read more about ServerSentEvents and the colon operator and these types of messages in the official mozilla documentation.

When you are able to actually keep the stream open, and wish to send data, your service will not know when new data is written to the database. So either you poll your database, or trigger an event when something is written, to fetch the newly written data and place this in the stream.

How to place data in a continuous open stream is way too big of a topic to explain here. But i suggest you read the following sections in the official reactor documentation:

Programmatically creating a sequence

Processors and Sinks

My guess is that mixing Coroutines suspending function with Retrofit and LiveData leads to some side effect here.

I do not have a single solution, but some points they can help you.

In general I would avoid mixing LiveData with suspending functions. LiveData is concept of caching data for the UI/ViewModel layer. Lower layers do not need to know anything like Android concrete stuff like LiveData. More information here

In your repository or dataSource can either use a suspending function that returns a single value or Coroutines Flow that can emit more than one value. In your ViewModel you can then map those results to your LiveData.

DataSource

In your DataSource you can use suspendCoroutine or suspendCancellableCoroutine to connect Retrofit (or any other callback interface) with Coroutines: