Woah. You can actually just seat a Sink between that ignores close and calls flush instead

OkHttp does this, or did in the past

I'm not at a computer, if you can't figure it out I'll post something later/tomorrow

Works like a charm with a

ForwardingSink

private class UnclosingSink(output: OutputStream) : ForwardingSink(output.sink()) {
  override fun close() {
    delegate.flush()
  }
}

fun getEncryptedSink(output: OutputStream): Sink {
  val cipher = getEncryptionCipher()
  return UnclosingSink(output).buffer()
      .writeInt(cipher.iv.size)
      .write(cipher.iv)
      .cipherSink(cipher)
}

hi all!

I’m trying to use Turbine and I’ve added it using

testImplementation

but I’m getting

java.lang.NoSuchMethodError: app.cash.turbine.FlowTurbineKt.test-f_gJSvk$default(Lkotlinx/coroutines/flow/Flow;DLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object;

Your Kotlin compiler version is likely different than the one Turbine is compiled with. What version of Kotlin are you using?

I think it is 1.4.0

yes it is

I have

kotlin("android") version "1.4.0" apply false

and BTW if I remove the

apply false

or set it to true, I get

* Exception is:
com.intellij.openapi.externalSystem.model.ExternalSystemException: Could not resolve all files for configuration ':app:coreLibraryDesugaring'.
Cannot resolve external dependency com.android.tools:desugar_jdk_libs:1.1.0 because no repositories are defined.

Hi, I'm trying to use Turbine (0.2.1) in unit tests for a View Model class, which has a StateFlow property, and I'm getting the following error:

java.lang.AbstractMethodError: kotlinx.coroutines.test.TestCoroutineDispatcher.invokeOnTimeout(JLjava/lang/Runnable;Lkotlin/coroutines/CoroutineContext;)Lkotlinx/coroutines/DisposableHandle;

Here's my test code:

class MyViewModelTest {

    private lateinit var viewModel: MyViewModel

    @get:Rule
    var mainCoroutineRule = MainCoroutineRule()

   @Test
    fun `should test successfully`() {
        mainCoroutineRule.testDispatcher.runBlockingTest {
            // ...
            viewModel.states.test {
                assertEquals(State.Ok, expectItem())
                expectComplete()
            }
        }
    }

}

best guess is that your kotlinx-coroutines-core dependency has a different version than kotlinx-coroutines-test because the Turbine dependency likely bumped the former but not the latter

@jw you were right. I was using different versions (

kotlinx-coroutines-core:1.4.0

and

kotlinx-coroutines-test:1.3.8

). I bumped

kotlinx-coroutines-test

to

1.4.0

, and now I'm getting the following error:

kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1000 ms

The

kotlinx.coroutines.TimeoutCancellationException

was threw because I called

expectComplete()

, but my StateFlow isn't yet closed. Never mind about that. Thanks for helping me.

Hi, is there a way to make Wire generated classes

internal

?

If you need to hide the types, I would recommend generating them into their own module and then making that an implementation dependency

ok that was my fallback ˆˆ thanks ! 🙏

Hi, i’m dealing with a pretty “specific” http API which in OK scenarios has JSON responses like

{
  "status": "OK",
  "data": { //my data }
}

but in the case of errors the response is still http status code 200 but body looks like

{
  "status": "Error",
  "description": "Invalid email address",
  "error_code": 0,
  "data": []
}

I have a generic class

ApiResponse<T>

looking like

class ApiResponse<T>(
    val data: T?,
    val status: String?,
    @Json(name = "error_code")  val errorCode: Int?,
    @JvmField val description: String? = null
)

and I am parsing it through Moshi through function similar to

fun <T> parseResponse(moshi: Moshi, body:String, type: Class<T>) : ApiResponse<T> {
    val apiResponseType = Types.newParameterizedType(ApiResponse::class.java, type)
    val toReturn = moshi.adapter<ApiResponse<T>>(apiResponseType).fromJson(body)
    if (toReturn.errorCode != null) {
        throw ApiResponseErrorException(toReturn.errorCode, toReturn.description ?: "")
    }
    return toReturn
}

which works fine in most of the cases but the problem is that the field

data

is returned as empty array in the case of error, which results in failing JSON parsing if the type of

ApiResponse

is not an list.. My first thought was to create a custom adapter for

ApiResponse

class and in the case of

status == "Error"

i would not parse the data at all and just return the exception but i don’t know how to write such an adapter because I don’t have information about the generic type of

data

in the happy scenarios. What is the best way to deal with that without ugly try/catches?

I admittedly don't know the ins and outs of your problem, but I came across this on twitter (haven't used it yet) and it sounds like it could be of value? https://github.com/slackhq/EitherNet

Hi everyone. Do you know if it's possible to get the sqldatabase from iOS simulator AND for the KMM Sqldelight? I may have on issue in saving, but I can't find my application database. Looked into the simulator in Developer / CoreSimulator / Devices / data / Containers ... Like I'm used to. But nothing. Is there something different?

it should be somewhere there unless you set it to be an inMemory database

Hum... thanks. It's not in memory..

you could try giving it a very specific name “blah.db” and then searching the filesystem for it

hunting down iOS simulator files is always a pain

Yes totally. I'll tried that.

Ok thanks I found the pb.... I named it "toot" instead of "toot.db" or "toot.sqlite".... Thank you and sorry... -_-

haha all good

Hi, from this PR: https://github.com/square/wire/pull/1851 I try generating kotlin classes from protos in

multiplatform

module using wire

3.5.1-SNAPSHOT

(also with 3.6.0-SNAPSHOT) but get this error:

Unresolved reference: ByteStringSerializer

my build.gradle.kts:

import dependencies.Dependencies
import dependencies.TestDependencies

plugins {
    id(BuildPlugins.KOTLIN_MULTIPLATFORM)
    id(BuildPlugins.KOTLIN_PLUGIN_SERIALIZATION)
    id(BuildPlugins.WIRE)
}

kotlin {
    jvm {
        compilations.all {
            kotlinOptions.jvmTarget = "1.8"
        }
    }
    ios {
        binaries {
            framework {
                baseName = "domain"
            }
        }
    }
    sourceSets {
        val commonMain by getting {
            kotlin.srcDir("$buildDir/generated/source/wire")
            dependencies {
                api(Dependencies.Domain.KOTLIN_SERIALIZATION)
                api(Dependencies.Domain.WIRE)
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }
        val jvmMain by getting
        val jvmTest by getting {
            dependencies {
                implementation(kotlin("test-junit"))
            }
        }
        val iosMain by getting
        val iosTest by getting
    }
}

wire {
    sourcePath {
        srcDir("src/commonMain/proto")
    }
    kotlin {
        emitKotlinSerialization = "UNSUPPORTED"
    }
}

In the IDEA, it shows the generated source set as

iosArm64Main

and gradle dependencies contains only wire-runtime for ios targets: