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