Koin: [Team] Testing Koin 2.0.0

Created on 24 Nov 2018 · 20Comments · Source: InsertKoinIO/koin

Hello all :)

Koin 2.0.0-alpha-2 has been published in jcenter 👍 Here is how you can test it.

Starting Koin with the new DSL:

// Coffee Maker example
fun main(vararg args: String) {
    // declare a KoinApplication
    koinApplication {
        // enable INFO logger
        useLogger()
        // load Koin modules
        loadModules(coffeeAppModule)
    }.start() // don't forget to start it, to setup it in StandAlone Koin Application

    // ...
}

Starting an Android app with the new Koin DSL:

class MainApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        // start Koin context
        koinApplication {
            // Use Android Logger
            useAndroidLogger(Level.DEBUG)
            // Use Android Context from MainApplication
            useAndroidContext(this@MainApplication)
            // Load modules
            loadModules(myModule)
        }.start() // don't forget to start it
    }
}

Starting Koin with Ktor:

fun Application.main() {
    // Install Ktor features
    install(DefaultHeaders)
    install(CallLogging)
    // install Koin Application
    installKoin(koinApplication {
        useLogger(logger = SLF4JLogger())
        loadModules(helloAppModule)
    })

    //...
}

Modules (no more inner module and name for module)

val myModule = module {
     // single, factory, scope, viewModel
}

Binding & names are clearly logged:

module {
    // resolved by name "default"
    single<Simple.ComponentInterface1>("default") { Simple.Component2() }
    // Resolved by type Simple.ComponentInterface1
    single<Simple.ComponentInterface1> { Simple.Component1() }
}

```
[INFO] [Koin] bind name:'default' ~ Single[name:'default', type:'org.koin.Simple.ComponentInterface1']
[INFO] [Koin] bind type:'org.koin.Simple.ComponentInterface1' ~ Single[type:'org.koin.Simple.ComponentInterface1']

* Same API But changes import: inject(), get(), getViewModel(), viewModel() ... Also note that you can request by KClass with get() (check function signature)


* Scope group declaration

```kotlin
module {
     withScope(SCOPE_ID) {
         scoped { Simple.ComponentA() }
         scoped { Simple.ComponentB(get()) }
     }
}

Module check: checkModules() is available on a KoinApplication

val mockedAndroidContext = mock(Application::class.java)

    @Test
    fun testRemoteConfiguration() {
        koinApplication {
            useAndroidContext(mockedAndroidContext)
            loadModules(onlineWeatherApp)
        }.checkModules()
    }

Mock & Testing:

val coffeeKoinApp = koinApplication {
    useLogger()
    loadModules(coffeeAppModule)
}

class CoffeeMakerTest : AutoCloseKoinTest() {

    private val coffeeMaker: CoffeeMaker by inject()
    private val heater: Heater by inject()

    @Before
    fun before() {
        coffeeKoinApp.start()

        declareMock<Heater> {
            given(isHot()).will { true }
        }
    }

    @Test
    fun testHeaterIsTurnedOnAndThenOff() {

        coffeeMaker.brew()

        verify(heater, times(1)).on()
        verify(heater, times(1)).off()
    }
}

Koin instance isolation:

val app1 = koinApplication {
    loadModules(
        module {
            single { Simple.ComponentA() }
        })
}

val app2 = koinApplication {
    loadModules(
        module {
            single { Simple.ComponentA() }
        })
}

val a1: Simple.ComponentA = app1.koin.get()
val a2: Simple.ComponentA = app2.koin.get()
// a1 & a2 not equals

Koin from Java:

KoinApplication.create()
                .useLogger()
                .loadModules(koinModule)
                .start();

Koin extensions still available:

val MVPModule = module {
        single<Repository>()
        single<View>()
        single<Presenter>()
    }

Feel free to give your feedback!

Cheers.

team

Source

arnaudgiuliani

👍13 ❤4

Most helpful comment

Hi! I updated my performance test project with the new alpha: https://github.com/Sloy/android-dependency-injection-performance/compare/koin2

Here are some results in a low end device: Samsung j5nlte with Android 6.0.1

The improvement is huge. There might be room for improvement still, but at least it feels production-ready in terms of performance.
Also, there's still that strange impact when loading Java classes. I'm not sure where's that coming from.

|Test: | Koin 1.0.1 + Kotlin|
|---------|--------------------|
|Startup: | 1121,12 ms|
|Min-Max: | 268,89-290,61 ms|
|Average: | 271,42 ms|

|Test: | Koin 1.0.1 + Java|
|---------|--------------------|
|Startup: | 1578,65 ms|
|Min-Max: | 404,19-416,20 ms|
|Average: | 406,65 ms|

|Test: | Koin 2.0.0 + Kotlin|
|---------|--------------------|
|Startup: | 709,51 ms|
|Min-Max: | 11,80-19,02 ms|
|Average: | 12,41 ms|

|Test: | Koin 2.0.0 + Java|
|---------|--------------------|
|Startup: | 1423,47 ms|
|Min-Max: | 11,97-16,32 ms|
|Average: | 12,48 ms|

|Test: | Kodein + Kotlin|
|---------|--------------------|
|Startup: | 535,60 ms|
|Min-Max: | 8,24-16,70 ms|
|Average: | 8,60 ms|

|Test: | Kodein + Java|
|---------|--------------------|
|Startup: | 506,22 ms|
|Min-Max: | 8,78-11,80 ms|
|Average: | 9,11 ms|

|Test: | Dagger2 + Kotlin|
|---------|--------------------|
|Startup: | 41,53 ms|
|Min-Max: | 0,24-6,26 ms|
|Average: | 0,31 ms|

|Test: | Dagger2 + Java|
|---------|--------------------|
|Startup: | 41,21 ms|
|Min-Max: | 0,21-6,02 ms|
|Average: | 0,28 ms|

|Test: | Custom + Kotlin|
|---------|--------------------|
|Startup: | 408,04 ms|
|Min-Max: | 0,68-0,82 ms|
|Average: | 0,70 ms|

|Test: | Custom + Java|
|---------|--------------------|
|Startup: | 405,69 ms|
|Min-Max: | 0,82-1,05 ms|
|Average: | 0,84 ms|

Sloy on 26 Nov 2018

👍13 🎉4

All 20 comments

// don't forget to start it

why do I have to start it in a separate step? Or phrased another way: when would one not want to start it?

DSL style:

al app2 = koinApplication {
    loadModules(
        module {

You are mixing imperative and declarative styles. It think DSLs read nicest when they stick to declarative. i.e. loadModules and useLogger feel out of place.

Compare to:

 koinApplication {
            // Use Android Logger
            androidLogger(Level.DEBUG)
            // Use Android Context from MainApplication
            androidContext(this@MainApplication)
            // Load modules
            modules(myModule)
        }

westonal on 25 Nov 2018

👍2

why do I have to start it in a separate step? Or phrased another way: when would one not want to start it?

start() on a KoinApplication register it in the StandAloneContext and allow default use of Koin (by inject() ...).
A better naming with that also? register() or toStandalone()?

it think DSLs read nicest when they stick to declarative

ok, yep :)

arnaudgiuliani on 26 Nov 2018