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