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

   1 package net.pterodactylus.sone.main
   2
   3 import com.codahale.metrics.*
   4 import com.google.common.base.*
   5 import com.google.common.eventbus.*
   6 import com.google.inject.Guice.*
   7 import com.google.inject.name.Names.*
   8 import freenet.l10n.*
   9 import freenet.pluginmanager.*
  10 import net.pterodactylus.sone.core.*
  11 import net.pterodactylus.sone.database.*
  12 import net.pterodactylus.sone.database.memory.*
  13 import net.pterodactylus.sone.freenet.wot.*
  14 import net.pterodactylus.sone.test.*
  15 import net.pterodactylus.util.config.*
  16 import net.pterodactylus.util.version.Version
  17 import org.hamcrest.MatcherAssert.*
  18 import org.hamcrest.Matchers.*
  19 import org.mockito.Mockito.*
  20 import java.io.*
  21 import java.util.concurrent.atomic.*
  22 import kotlin.test.*
  23
  24 const val versionString = "v80"
  25
  26 class SoneModuleTest {
  27
  28         private val currentDir: File = File(".")
  29         private val pluginVersion = Version("", 80)
  30         private val pluginYear = 2019
  31         private val pluginHomepage = "home://page"
  32         private val l10n = deepMock<PluginL10n>()
  33         private val sonePlugin = mock<SonePlugin>().apply {
  34                 whenever(version).thenReturn(versionString)
  35                 whenever(year).thenReturn(pluginYear)
  36                 whenever(homepage).thenReturn(pluginHomepage)
  37                 whenever(l10n()).thenReturn(l10n)
  38         }
  39
  40         private val injector by lazy {
  41                 createInjector(
  42                                 SoneModule(sonePlugin, EventBus()),
  43                                 FreenetInterface::class.isProvidedByDeepMock(),
  44                                 PluginRespirator::class.isProvidedByDeepMock()
  45                 )
  46         }
  47
  48         @AfterTest
  49         fun removePropertiesFromCurrentDirectory() {
  50                 File(currentDir, "sone.properties").delete()
  51         }
  52
  53         @Test
  54         fun `creator binds configuration when no file is present`() {
  55                 File(currentDir, "sone.properties").delete()
  56                 assertThat(injector.getInstance<Configuration>(), notNullValue())
  57         }
  58
  59         @Test
  60         fun `creator binds first start to true when no file is present`() {
  61                 File(currentDir, "sone.properties").delete()
  62                 assertThat(injector.getInstance(named("FirstStart")), equalTo(true))
  63         }
  64
  65         @Test
  66         fun `config file is created in current directory if not present`() {
  67                 File(currentDir, "sone.properties").delete()
  68                 val configuration = injector.getInstance<Configuration>()
  69                 configuration.save()
  70                 assertThat(File(currentDir, "sone.properties").exists(), equalTo(true))
  71         }
  72
  73         @Test
  74         fun `creator binds configuration when file is present`() {
  75                 File(currentDir, "sone.properties").writeText("Option=old")
  76                 assertThat(injector.getInstance<Configuration>().getStringValue("Option").value, equalTo("old"))
  77         }
  78
  79         @Test
  80         fun `creator binds first start to false when file is present`() {
  81                 File(currentDir, "sone.properties").writeText("Option=old")
  82                 assertThat(injector.getInstance(named("FirstStart")), equalTo(false))
  83         }
  84
  85         @Test
  86         fun `invalid config file leads to new config being created`() {
  87                 File(currentDir, "sone.properties").writeText("Option=old\nbroken")
  88                 val configuration = injector.getInstance<Configuration>()
  89                 assertThat(configuration.getStringValue("Option").getValue(null), nullValue())
  90         }
  91
  92         @Test
  93         fun `invalid config file leads to new config being set to true`() {
  94                 File(currentDir, "sone.properties").writeText("Option=old\nbroken")
  95                 assertThat(injector.getInstance(named("NewConfig")), equalTo(true))
  96         }
  97
  98         @Test
  99         fun `valid config file leads to new config being set to false`() {
 100                 File(currentDir, "sone.properties").writeText("Option=old")
 101                 assertThat(injector.getInstance(named("NewConfig")), equalTo(false))
 102         }
 103
 104         @Test
 105         fun `show version information debug information flag is read from config`() {
 106                 File(currentDir, "sone.properties").writeText("Debug/ShowVersionInformation=true")
 107                 assertThat(injector.getInstance<Core>().debugInformation.showVersionInformation, equalTo(true))
 108         }
 109
 110         @Test
 111         fun `event bus is bound`() {
 112                 assertThat(injector.getInstance<EventBus>(), notNullValue())
 113         }
 114
 115         @Test
 116         fun `context is bound`() {
 117                 assertThat(injector.getInstance<Context>().context, equalTo("Sone"))
 118         }
 119
 120         @Test
 121         fun `optional context is bound`() {
 122                 assertThat(injector.getInstance<Optional<Context>>().get().context, equalTo("Sone"))
 123         }
 124
 125         @Test
 126         fun `sone plugin is bound`() {
 127                 assertThat(injector.getInstance(), sameInstance(sonePlugin))
 128         }
 129
 130         @Test
 131         fun `version is bound`() {
 132                 assertThat(injector.getInstance(), equalTo(pluginVersion))
 133         }
 134
 135         @Test
 136         fun `plugin version is bound`() {
 137                 assertThat(injector.getInstance(), equalTo(PluginVersion(versionString)))
 138         }
 139
 140         @Test
 141         fun `plugin year is bound`() {
 142                 assertThat(injector.getInstance(), equalTo(PluginYear(pluginYear)))
 143         }
 144
 145         @Test
 146         fun `plugin homepage in bound`() {
 147                 assertThat(injector.getInstance(), equalTo(PluginHomepage(pluginHomepage)))
 148         }
 149
 150         @Test
 151         fun `database is bound correctly`() {
 152                 assertThat(injector.getInstance<Database>(), instanceOf(MemoryDatabase::class.java))
 153         }
 154
 155         @Test
 156         fun `base l10n is bound correctly`() {
 157                 assertThat(injector.getInstance(), sameInstance(l10n.base))
 158         }
 159
 160         @Test
 161         fun `default loader is used without dev options`() {
 162                 assertThat(injector.getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
 163         }
 164
 165         @Test
 166         fun `default loaders are used if no path is given`() {
 167                 File(currentDir, "sone.properties").writeText("Developer.LoadFromFilesystem=true")
 168                 assertThat(injector.getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
 169         }
 170
 171         @Test
 172         fun `debug loaders are used if path is given`() {
 173                 File(currentDir, "sone.properties").writeText("Developer.LoadFromFilesystem=true\nDeveloper.FilesystemPath=/tmp")
 174                 assertThat(injector.getInstance<Loaders>(), instanceOf(DebugLoaders::class.java))
 175         }
 176
 177         class TestObject {
 178                 val ref: AtomicReference<Any?> = AtomicReference()
 179                 @Subscribe
 180                 fun testEvent(event: Any?) {
 181                         ref.set(event)
 182                 }
 183         }
 184
 185         @Test
 186         fun `created objects are registered with event bus`() {
 187                 val eventBus: EventBus = injector.getInstance()
 188                 val testObject = injector.getInstance<TestObject>()
 189                 val event = Any()
 190                 eventBus.post(event)
 191                 assertThat(testObject.ref.get(), sameInstance(event))
 192         }
 193
 194         @Test
 195         fun `core is created as singleton`() {
 196                 val firstCore = injector.getInstance<Core>()
 197                 val secondCore = injector.getInstance<Core>()
 198                 assertThat(secondCore, sameInstance(firstCore))
 199         }
 200
 201         @Test
 202         fun `core is registered with event bus`() {
 203                 val eventBus = mock<EventBus>()
 204                 val injector = createInjector(
 205                                 SoneModule(sonePlugin, eventBus),
 206                                 FreenetInterface::class.isProvidedByDeepMock(),
 207                                 PluginRespirator::class.isProvidedByDeepMock()
 208                 )
 209                 val core = injector.getInstance<Core>()
 210                 verify(eventBus).register(core)
 211         }
 212
 213         @Test
 214         fun `metrics registry can be created`() {
 215                 assertThat(injector.getInstance<MetricRegistry>(), notNullValue())
 216         }
 217
 218         @Test
 219         fun `metrics registry is created as singleton`() {
 220                 val firstMetricRegistry = injector.getInstance<MetricRegistry>()
 221                 val secondMetricRegistry = injector.getInstance<MetricRegistry>()
 222                 assertThat(firstMetricRegistry, sameInstance(secondMetricRegistry))
 223         }
 224
 225 }