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