Coverage Summary for Class: InterceptBeforeTransformAndReplaceContainerWithNetowrkEitherTypeKt (com.javiersc.network.either.ktor._internal)

Class Method, % Branch, % Line, % Instruction, %
InterceptBeforeTransformAndReplaceContainerWithNetowrkEitherTypeKt 100% (1/1) 100% (6/6) 100% (30/30)
InterceptBeforeTransformAndReplaceContainerWithNetowrkEitherTypeKt$interceptBeforeTransformAndReplaceContainerWithNetworkEitherType$1 100% (1/1) 75% (6/8) 100% (13/13) 97.5% (79/81)
InterceptBeforeTransformAndReplaceContainerWithNetowrkEitherTypeKt$interceptBeforeTransformAndReplaceContainerWithNetworkEitherType$2 100% (1/1) 100% (6/6) 100% (8/8) 100% (56/56)
Total 100% (3/3) 85.7% (12/14) 100% (27/27) 98.8% (165/167)


 package com.javiersc.network.either.ktor._internal
 
 import com.javiersc.network.either.NetworkEither
 import com.javiersc.network.either.NetworkEither.Companion.localFailure
 import com.javiersc.network.either.NetworkEither.Companion.remoteFailure
 import com.javiersc.network.either.NetworkEither.Companion.unknownFailure
 import com.javiersc.network.either.NetworkFailureLocal
 import com.javiersc.network.either.NetworkFailureRemote
 import io.ktor.client.HttpClient
 import io.ktor.client.statement.HttpResponseContainer
 import io.ktor.client.statement.HttpResponsePipeline
 import io.ktor.util.pipeline.PipelinePhase
 import io.ktor.util.reflect.typeInfo
 import kotlin.reflect.typeOf
 
 internal fun interceptBeforeTransformAndReplaceContainerWithNetworkEitherType(client: HttpClient) {
     val beforeTransformPipelinePhase = PipelinePhase("NetworkEitherBeforeTransform")
     client.responsePipeline.insertPhaseBefore(
         HttpResponsePipeline.Transform,
         beforeTransformPipelinePhase
     )
     client.responsePipeline.intercept(beforeTransformPipelinePhase) { container ->
         if (requestContentIsNetworkFailureLocal) return@intercept
         if (requestContentIsNetworkFailureRemote) return@intercept
         if (!isNetworkEither) return@intercept
 
         val response =
             if (networkEitherTypeInfo.kotlinType != typeOf<Unit>()) container.response else Unit
 
         val modifiedContainer =
             HttpResponseContainer(expectedType = networkEitherTypeInfo, response = response)
 
         try {
             proceedWith(modifiedContainer)
         } catch (throwable: Throwable) {
             val typeInfo = typeInfo<NetworkEither.Failure<Nothing>>()
             val networkEither: NetworkEither<Any, Nothing> = unknownFailure(throwable)
             proceedWith(HttpResponseContainer(typeInfo, networkEither))
         }
     }
 
     client.responsePipeline.intercept(HttpResponsePipeline.Transform) {
         val failure =
             when {
                 requestContentIsNetworkFailureLocal -> {
                     HttpResponseContainer(typeInfo<NetworkFailureLocal>(), localFailure())
                 }
                 requestContentIsNetworkFailureRemote -> {
                     HttpResponseContainer(typeInfo<NetworkFailureRemote>(), remoteFailure())
                 }
                 else -> null
             }
 
         if (failure != null) proceedWith(failure) else proceed()
     }
 }