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