src/test/kotlin/net/pterodactylus/sone/main/SonePluginTest.kt

   1 package net.pterodactylus.sone.main
   2
   3 import com.google.inject.*
   4 import freenet.client.async.*
   5 import freenet.l10n.BaseL10n.LANGUAGE.*
   6 import freenet.node.*
   7 import freenet.pluginmanager.*
   8 import net.pterodactylus.sone.core.*
   9 import net.pterodactylus.sone.fcp.*
  10 import net.pterodactylus.sone.freenet.wot.*
  11 import net.pterodactylus.sone.test.*
  12 import net.pterodactylus.sone.web.*
  13 import org.hamcrest.MatcherAssert.*
  14 import org.hamcrest.Matchers.*
  15 import org.mockito.Mockito.*
  16 import kotlin.test.*
  17
  18 /**
  19  * Unit test for [SonePlugin].
  20  */
  21 @Dirty
  22 class SonePluginTest {
  23
  24         private var injector = mockInjector()
  25         private val sonePlugin by lazy { SonePlugin { injector } }
  26         private val pluginRespirator = deepMock<PluginRespirator>()
  27         private val node = deepMock<Node>()
  28         private val clientCore = deepMock<NodeClientCore>()
  29         private val uskManager = deepMock<USKManager>()
  30
  31         init {
  32                 setField(node, "clientCore", clientCore)
  33                 whenever(pluginRespirator.node).thenReturn(node)
  34                 setField(clientCore, "uskManager", uskManager)
  35         }
  36
  37         @Test
  38         fun `sone plugin can be started`() {
  39                 sonePlugin.setLanguage(ENGLISH)
  40                 sonePlugin.runPlugin(pluginRespirator)
  41         }
  42
  43         @Test
  44         fun `core can be created`() {
  45                 val injector: Injector = runSonePluginWithRealInjector()
  46                 assertThat(injector.getInstance<Core>(), notNullValue())
  47         }
  48
  49         @Test
  50         fun `fcp interface can be created`() {
  51                 val injector: Injector = runSonePluginWithRealInjector()
  52                 assertThat(injector.getInstance<FcpInterface>(), notNullValue())
  53         }
  54
  55         @Test
  56         fun `web interface can be created`() {
  57                 val injector: Injector = runSonePluginWithRealInjector()
  58                 assertThat(injector.getInstance<WebInterface>(), notNullValue())
  59         }
  60
  61         @Test
  62         fun `web of trust connector can be created`() {
  63                 val injector: Injector = runSonePluginWithRealInjector()
  64                 assertThat(injector.getInstance<WebOfTrustConnector>(), notNullValue())
  65         }
  66
  67         private fun runSonePluginWithRealInjector(): Injector {
  68                 lateinit var injector: Injector
  69                 val sonePlugin = SonePlugin {
  70                         Guice.createInjector(*it).also {
  71                                 injector = it
  72                         }
  73                 }
  74                 sonePlugin.setLanguage(ENGLISH)
  75                 sonePlugin.runPlugin(pluginRespirator)
  76                 return injector
  77         }
  78
  79         @Test
  80         fun `core is being started`() {
  81                 sonePlugin.runPlugin(pluginRespirator)
  82                 val core = injector.getInstance<Core>()
  83                 verify(core).start()
  84         }
  85
  86 }
  87
  88 private fun mockInjector() = mock<Injector>().apply {
  89         val injected = mutableMapOf<Pair<TypeLiteral<*>, Annotation?>, Any>()
  90         fun mockValue(clazz: Class<*>) = false.takeIf { clazz.name == java.lang.Boolean::class.java.name } ?: mock(clazz)
  91         whenever(getInstance(any<Key<*>>())).then {
  92                 injected.getOrPut((it.getArgument(0) as Key<*>).let { it.typeLiteral to it.annotation }) {
  93                         it.getArgument<Key<*>>(0).typeLiteral.type.typeName.toClass().let(::mockValue)
  94                 }
  95         }
  96         whenever(getInstance(any<Class<*>>())).then {
  97                 injected.getOrPut(TypeLiteral.get(it.getArgument(0) as Class<*>) to null) {
  98                         it.getArgument<Class<*>>(0).let(::mockValue)
  99                 }
 100         }
 101 }
 102
 103 private fun String.toClass(): Class<*> = SonePlugin::class.java.classLoader.loadClass(this)