package net.pterodactylus.sone.main
+import com.codahale.metrics.*
import com.google.common.base.*
import com.google.common.eventbus.*
-import com.google.inject.*
+import com.google.inject.Guice.*
import com.google.inject.name.Names.*
+import freenet.l10n.*
+import net.pterodactylus.sone.core.*
import net.pterodactylus.sone.database.*
import net.pterodactylus.sone.database.memory.*
+import net.pterodactylus.sone.freenet.*
+import net.pterodactylus.sone.freenet.plugin.*
import net.pterodactylus.sone.freenet.wot.*
import net.pterodactylus.sone.test.*
import net.pterodactylus.util.config.*
import net.pterodactylus.util.version.Version
import org.hamcrest.MatcherAssert.*
import org.hamcrest.Matchers.*
-import org.junit.*
+import org.junit.experimental.categories.*
+import org.mockito.Mockito.*
import java.io.*
+import java.util.concurrent.*
import java.util.concurrent.atomic.*
+import kotlin.test.*
+const val versionString = "v80"
+
+@Category(NotParallel::class)
class SoneModuleTest {
private val currentDir: File = File(".")
- private val pluginVersion = Version("", 0, 1, 2)
+ private val pluginVersion = Version("", 80)
private val pluginYear = 2019
private val pluginHomepage = "home://page"
+ private val l10n = deepMock<PluginL10n>()
private val sonePlugin = mock<SonePlugin>().apply {
- whenever(version).thenReturn(pluginVersion.toString())
+ whenever(version).thenReturn(versionString)
whenever(year).thenReturn(pluginYear)
whenever(homepage).thenReturn(pluginHomepage)
+ whenever(l10n()).thenReturn(l10n)
+ }
+
+ private val injector by lazy {
+ createInjector(
+ SoneModule(sonePlugin, EventBus()),
+ FreenetInterface::class.isProvidedByDeepMock(),
+ PluginRespiratorFacade::class.isProvidedByDeepMock(),
+ PluginConnector::class.isProvidedByDeepMock()
+ )
}
- @After
+ @AfterTest
fun removePropertiesFromCurrentDirectory() {
File(currentDir, "sone.properties").delete()
}
@Test
fun `creator binds configuration when no file is present`() {
File(currentDir, "sone.properties").delete()
- assertThat(getInstance<Configuration>(), notNullValue())
+ assertThat(injector.getInstance<Configuration>(), notNullValue())
}
@Test
fun `creator binds first start to true when no file is present`() {
File(currentDir, "sone.properties").delete()
- assertThat(getInstance(named("FirstStart")), equalTo(true))
+ assertThat(injector.getInstance(named("FirstStart")), equalTo(true))
}
@Test
fun `config file is created in current directory if not present`() {
File(currentDir, "sone.properties").delete()
- val configuration = getInstance<Configuration>()
+ val configuration = injector.getInstance<Configuration>()
configuration.save()
assertThat(File(currentDir, "sone.properties").exists(), equalTo(true))
}
@Test
fun `creator binds configuration when file is present`() {
File(currentDir, "sone.properties").writeText("Option=old")
- assertThat(getInstance<Configuration>().getStringValue("Option").value, equalTo("old"))
+ assertThat(injector.getInstance<Configuration>().getStringValue("Option").value, equalTo("old"))
}
@Test
fun `creator binds first start to false when file is present`() {
File(currentDir, "sone.properties").writeText("Option=old")
- assertThat(getInstance(named("FirstStart")), equalTo(false))
+ assertThat(injector.getInstance(named("FirstStart")), equalTo(false))
}
@Test
fun `invalid config file leads to new config being created`() {
File(currentDir, "sone.properties").writeText("Option=old\nbroken")
- val configuration = getInstance<Configuration>()
+ val configuration = injector.getInstance<Configuration>()
assertThat(configuration.getStringValue("Option").getValue(null), nullValue())
}
@Test
fun `invalid config file leads to new config being set to true`() {
File(currentDir, "sone.properties").writeText("Option=old\nbroken")
- assertThat(getInstance(named("NewConfig")), equalTo(true))
+ assertThat(injector.getInstance(named("NewConfig")), equalTo(true))
}
@Test
fun `valid config file leads to new config being set to false`() {
File(currentDir, "sone.properties").writeText("Option=old")
- assertThat(getInstance(named("NewConfig")), equalTo(false))
+ assertThat(injector.getInstance(named("NewConfig")), equalTo(false))
}
@Test
fun `event bus is bound`() {
- assertThat(getInstance<EventBus>(), notNullValue())
+ assertThat(injector.getInstance<EventBus>(), notNullValue())
}
@Test
fun `context is bound`() {
- assertThat(getInstance<Context>().context, equalTo("Sone"))
+ assertThat(injector.getInstance<Context>().context, equalTo("Sone"))
}
@Test
fun `optional context is bound`() {
- assertThat(getInstance<Optional<Context>>().get().context, equalTo("Sone"))
+ assertThat(injector.getInstance<Optional<Context>>().get().context, equalTo("Sone"))
}
@Test
fun `sone plugin is bound`() {
- assertThat(getInstance(), sameInstance(sonePlugin))
+ assertThat(injector.getInstance(), sameInstance(sonePlugin))
}
@Test
fun `version is bound`() {
- assertThat(getInstance(), equalTo(pluginVersion))
+ assertThat(injector.getInstance(), equalTo(pluginVersion))
}
@Test
fun `plugin version is bound`() {
- assertThat(getInstance(), equalTo(PluginVersion(pluginVersion.toString())))
+ assertThat(injector.getInstance(), equalTo(PluginVersion(versionString)))
}
@Test
fun `plugin year is bound`() {
- assertThat(getInstance(), equalTo(PluginYear(pluginYear)))
+ assertThat(injector.getInstance(), equalTo(PluginYear(pluginYear)))
}
@Test
fun `plugin homepage in bound`() {
- assertThat(getInstance(), equalTo(PluginHomepage(pluginHomepage)))
+ assertThat(injector.getInstance(), equalTo(PluginHomepage(pluginHomepage)))
}
@Test
fun `database is bound correctly`() {
- assertThat(getInstance<Database>(), instanceOf(MemoryDatabase::class.java))
+ assertThat(injector.getInstance<Database>(), instanceOf(MemoryDatabase::class.java))
+ }
+
+ @Test
+ fun `translation is bound correctly`() {
+ assertThat(injector.getInstance<Translation>(), notNullValue())
}
@Test
fun `default loader is used without dev options`() {
- assertThat(getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
+ assertThat(injector.getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
}
@Test
fun `default loaders are used if no path is given`() {
File(currentDir, "sone.properties").writeText("Developer.LoadFromFilesystem=true")
- assertThat(getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
+ assertThat(injector.getInstance<Loaders>(), instanceOf(DefaultLoaders::class.java))
}
@Test
fun `debug loaders are used if path is given`() {
File(currentDir, "sone.properties").writeText("Developer.LoadFromFilesystem=true\nDeveloper.FilesystemPath=/tmp")
- assertThat(getInstance<Loaders>(), instanceOf(DebugLoaders::class.java))
+ assertThat(injector.getInstance<Loaders>(), instanceOf(DebugLoaders::class.java))
}
class TestObject {
@Test
fun `created objects are registered with event bus`() {
- val injector = createInjector()
- val eventBus: EventBus = getInstance(injector = injector)
- val testObject = getInstance<TestObject>(injector = injector)
+ val eventBus: EventBus = injector.getInstance()
+ val testObject = injector.getInstance<TestObject>()
val event = Any()
eventBus.post(event)
assertThat(testObject.ref.get(), sameInstance(event))
}
- private fun createInjector(): Injector = SoneModule(sonePlugin)
- .let { Guice.createInjector(it) }
+ @Test
+ fun `core is created as singleton`() {
+ injector.verifySingletonInstance<Core>()
+ }
+
+ @Test
+ fun `core is registered with event bus`() {
+ val eventBus = mock<EventBus>()
+ val injector = createInjector(
+ SoneModule(sonePlugin, eventBus),
+ FreenetInterface::class.isProvidedByDeepMock(),
+ PluginRespiratorFacade::class.isProvidedByDeepMock(),
+ PluginConnector::class.isProvidedByDeepMock()
+ )
+ val core = injector.getInstance<Core>()
+ verify(eventBus).register(core)
+ }
+
+ @Test
+ fun `metrics registry is created as singleton`() {
+ injector.verifySingletonInstance<MetricRegistry>()
+ }
+
+ @Test
+ fun `wot connector is created as singleton`() {
+ injector.verifySingletonInstance<WebOfTrustConnector>()
+ }
- private inline fun <reified R : Any> getInstance(annotation: Annotation? = null, injector: Injector = createInjector()): R =
- annotation
- ?.let { injector.getInstance(Key.get(object : TypeLiteral<R>() {}, it)) }
- ?: injector.getInstance(Key.get(object : TypeLiteral<R>() {}))
+ @Test
+ fun `notification ticker is created as singleton`() {
+ injector.verifySingletonInstance<ScheduledExecutorService>(named("notification"))
+ }
+
+ @Test
+ fun `ticker shutdown is created as singleton`() {
+ injector.verifySingletonInstance<TickerShutdown>()
+ }
}
projects / Sone.git / blobdiff