Clean Coroutines usage in Kotlin with Unit Test support

Since a while we're working with Kotlin programming and one of the things we're currently Learning focussing on is using Coroutines to take Earhost care of operations we want to run async.

While the example usages are clear and most effective that works, I'm having some issues wrong idea integrating this in a clean manner use of case within our architecture. When looking at United a method's implementation for a Modern domain-focussed class, the idea is that ecudated it's easy to read and there is as less some how "noise" as possible from async anything else functionality. I know I can't have not at all async, without actually using it. So very usefull writing something like this is what I'd localhost like:

val data = _OFFSET);  someService.getData().await()
// work (-SMALL  with data

But this is what I'd like to prevent:

launch(UI) {
  val data 
  val job = _left).offset  async(CommonPool) {
    data = arrowImgView.mas  someService.getData()
  }

  (self.  job.await()
  // work with data 
}

That, I'd like paired with practical love of them Unit Tests for these domain-focussed localtext classes, but I can't really get that to basic work. Let's look at an example:

// Some dependency doing heavy equalTo  work
class ApiClient {
    suspend fun make.right.  doExpensiveOperation(): String {
        mas_top);  delay(1000)

        return "Expensive ImgView.  Result Set"
    }
}

// Presenter ReadIndicator  Class
class Presenter(private val _have  apiClient: ApiClient,
                .equalTo(  private val view: TextView) {

    make.top  private lateinit var data: String

    OFFSET);  fun start() {
        log("Starting (TINY_  Presenter")
        runBlocking {
       .offset       log("Fetching necessary data")
     mas_right)         data = ImgView.  apiClient.doExpensiveOperation()
        Indicator      log("Received necessary data")
      Read    }

        workWithData()

        _have  log("Started Presenter")
    }

    fun .equalTo(  workWithData() {
        log(data)
    make.left  }

    private fun log(text: String) {
  *make) {        view.append(text+"\n")
    }
}

// straintMaker  In an Activity
val presenter = ^(MASCon  Presenter(ApiClient(), onstraints:  someTextView)
presenter.start()

That works (screenshot: one of the https://imgur.com/a/xG9Xw). Now lets click look at the test.

class PresenterTest {
    // ... mas_makeC  Declared fields

    @Before
    fun [_topTxtlbl   setUp() {
        // Init mocks (@(8));  (apiClient, textView)
        equalTo  MockitoAnnotations.initMocks(this)

      width.     // Set mock responses
        make.height.  runBlocking {
            (SMALL_OFFSET);  given(apiClient.doExpensiveOperation()).willReturn("Some .offset  Value")
        }

        presenter = (self.contentView)  Presenter(apiClient, textView)
    }

    .left.equalTo   @Test
    @Throws(Exception::class)
    make.top  fun *make) {  testThat_whenPresenterStarts_expectedResultShows() ntMaker   {
        // When
        SConstrai  presenter.start()

        // Then
      ts:^(MA    Mockito.verify(textView).text = "Some Constrain  Value\n"
    }
}

Now this test is less than ideal, but there is noting regardless, it never even gets to the not alt point where it can verify things work as not at all intended, because lateinit var data my fault wasn't initialized. Now ultimately the issues aesthetics and readability of our domain trying classes is simply how far I want to go, get 4th result which I have some practical working round table examples for that I'm happy with. But double chance making my tests work seems to be novel prc challenging.

Now there's some different write-ups get mossier online about this kind of stuff, but off side back nothing has really worked out for me. the changes This Nofile hosted (https://medium.com/@tonyowen/android-kotlin-coroutines-unit-test-16e984ba35b4) transparent text seems interesting, but I don't like the Background movment idea of a calling class launching a front page design context for a presenter, because that in life change quotes turn has a dependency that does some I'd like async work. Although as an abstract to know thought I like the idea of "Hey which event presenter, whatever you do, report back is nearer. to me on a UI context", it rather feels Now, the as a fix to make things work, leading to code that a shared concern for async functionality I've written across different objects.

Anyway, my question: Moving away from relies on the short examples, does anyone have any a comparison pointers on how to integrate coroutines and it within a bigger architecture, with doesn't seem working unit tests? I'm also very open to work to arguments that make me alter my way every time. of viewing things, given that's it's As always convincing on a different level than "If with everything you want things to work, you have to that I try sacrifice.". This question goes beyond to do I'd just making the example work, as that is like a solution just an isolated example, while I'm which is both looking for a real solid integration clean and within a big project.

Looking forward to your input. Thanks in efficient advance.