1 package net.pterodactylus.sone.main
3 import com.google.common.eventbus.*
4 import com.google.inject.*
5 import freenet.client.async.*
6 import freenet.l10n.BaseL10n.LANGUAGE.*
8 import freenet.pluginmanager.*
9 import net.pterodactylus.sone.core.*
10 import net.pterodactylus.sone.core.event.*
11 import net.pterodactylus.sone.fcp.*
12 import net.pterodactylus.sone.freenet.wot.*
13 import net.pterodactylus.sone.test.*
14 import net.pterodactylus.sone.web.*
15 import net.pterodactylus.sone.web.notification.*
16 import org.hamcrest.MatcherAssert.*
17 import org.hamcrest.Matchers.*
18 import org.mockito.Mockito.*
20 import java.util.concurrent.atomic.*
24 * Unit test for [SonePlugin].
27 class SonePluginTest {
29 private var sonePlugin = SonePlugin { injector }
30 private val pluginRespirator = deepMock<PluginRespirator>()
31 private val node = deepMock<Node>()
32 private val clientCore = deepMock<NodeClientCore>()
33 private val uskManager = deepMock<USKManager>()
36 setField(node, "clientCore", clientCore)
37 whenever(pluginRespirator.node).thenReturn(node)
38 setField(clientCore, "uskManager", uskManager)
42 fun `sone plugin can be started`() {
43 sonePlugin.setLanguage(ENGLISH)
44 sonePlugin.runPlugin(pluginRespirator)
48 fun `core can be created`() {
49 val injector: Injector = runSonePluginWithRealInjector()
50 assertThat(injector.getInstance<Core>(), notNullValue())
54 fun `fcp interface can be created`() {
55 val injector: Injector = runSonePluginWithRealInjector()
56 assertThat(injector.getInstance<FcpInterface>(), notNullValue())
60 fun `web interface can be created`() {
61 val injector: Injector = runSonePluginWithRealInjector()
62 assertThat(injector.getInstance<WebInterface>(), notNullValue())
66 fun `web of trust connector can be created`() {
67 val injector: Injector = runSonePluginWithRealInjector()
68 assertThat(injector.getInstance<WebOfTrustConnector>(), notNullValue())
72 fun `notification handler can be created`() {
73 val injector: Injector = runSonePluginWithRealInjector()
74 assertThat(injector.getInstance<NotificationHandler>(), notNullValue())
77 private fun runSonePluginWithRealInjector(injectorConsumer: (Injector) -> Unit = {}): Injector {
78 lateinit var injector: Injector
79 sonePlugin = SonePlugin {
80 Guice.createInjector(*it).also {
85 sonePlugin.setLanguage(ENGLISH)
86 sonePlugin.runPlugin(pluginRespirator)
91 fun `core is being started`() {
92 sonePlugin.runPlugin(pluginRespirator)
93 val core = injector.getInstance<Core>()
98 fun `notification handler is being requested`() {
99 sonePlugin.runPlugin(pluginRespirator)
100 assertThat(getInjected(NotificationHandler::class.java), notNullValue())
103 private class FirstStartListener(private val firstStartReceived: AtomicBoolean) {
105 fun firstStart(firstStart: FirstStart) {
106 firstStartReceived.set(true)
111 fun `first-start event is sent to event bus when first start is true`() {
112 File("sone.properties").delete()
113 val firstStartReceived = AtomicBoolean()
114 runSonePluginWithRealInjector {
115 val eventBus = it.getInstance(EventBus::class.java)
116 eventBus.register(FirstStartListener(firstStartReceived))
118 assertThat(firstStartReceived.get(), equalTo(true))
122 fun `first-start event is not sent to event bus when first start is false`() {
123 File("sone.properties").deleteAfter {
125 val firstStartReceived = AtomicBoolean()
126 runSonePluginWithRealInjector {
127 val eventBus = it.getInstance(EventBus::class.java)
128 eventBus.register(FirstStartListener(firstStartReceived))
130 assertThat(firstStartReceived.get(), equalTo(false))
134 private class ConfigNotReadListener(private val configNotReadReceiver: AtomicBoolean) {
136 fun configNotRead(configNotRead: ConfigNotRead) {
137 configNotReadReceiver.set(true)
142 fun `config-not-read event is sent to event bus when new config is true`() {
143 File("sone.properties").deleteAfter {
145 val configNotReadReceived = AtomicBoolean()
146 runSonePluginWithRealInjector {
147 val eventBus = it.getInstance(EventBus::class.java)
148 eventBus.register(ConfigNotReadListener(configNotReadReceived))
150 assertThat(configNotReadReceived.get(), equalTo(true))
155 fun `config-not-read event is not sent to event bus when first start is true`() {
156 File("sone.properties").delete()
157 val configNotReadReceived = AtomicBoolean()
158 runSonePluginWithRealInjector {
159 val eventBus = it.getInstance(EventBus::class.java)
160 eventBus.register(ConfigNotReadListener(configNotReadReceived))
162 assertThat(configNotReadReceived.get(), equalTo(false))
166 fun `config-not-read event is not sent to event bus when new config is false`() {
167 File("sone.properties").deleteAfter {
168 writeText("# comment")
169 val configNotReadReceived = AtomicBoolean()
170 runSonePluginWithRealInjector {
171 val eventBus = it.getInstance(EventBus::class.java)
172 eventBus.register(ConfigNotReadListener(configNotReadReceived))
174 assertThat(configNotReadReceived.get(), equalTo(false))
178 private class StartupListener(private val startupReceived: () -> Unit) {
180 fun startup(startup: Startup) {
186 fun `startup event is sent to event bus`() {
187 val startupReceived = AtomicBoolean()
188 runSonePluginWithRealInjector {
189 val eventBus = it.getInstance(EventBus::class.java)
190 eventBus.register(StartupListener { startupReceived.set(true) })
192 assertThat(startupReceived.get(), equalTo(true))
195 private class ShutdownListener(private val shutdownReceived: () -> Unit) {
197 fun shutdown(shutdown: Shutdown) {
203 fun `shutdown event is sent to event bus on terminate`() {
204 val shutdownReceived = AtomicBoolean()
205 runSonePluginWithRealInjector {
206 val eventBus = it.getInstance(EventBus::class.java)
207 eventBus.register(ShutdownListener { shutdownReceived.set(true) })
209 sonePlugin.terminate()
210 assertThat(shutdownReceived.get(), equalTo(true))
213 private fun <T> getInjected(clazz: Class<T>, annotation: Annotation? = null): T? =
214 injected[TypeLiteral.get(clazz) to annotation] as? T
216 private val injected =
217 mutableMapOf<Pair<TypeLiteral<*>, Annotation?>, Any>()
219 private val injector = mock<Injector>().apply {
220 fun mockValue(clazz: Class<*>) = false.takeIf { clazz.name == java.lang.Boolean::class.java.name } ?: mock(clazz)
221 whenever(getInstance(any<Key<*>>())).then {
222 injected.getOrPut((it.getArgument(0) as Key<*>).let { it.typeLiteral to it.annotation }) {
223 it.getArgument<Key<*>>(0).typeLiteral.type.typeName.toClass().let(::mockValue)
226 whenever(getInstance(any<Class<*>>())).then {
227 injected.getOrPut(TypeLiteral.get(it.getArgument(0) as Class<*>) to null) {
228 it.getArgument<Class<*>>(0).let(::mockValue)
235 private fun String.toClass(): Class<*> = SonePlugin::class.java.classLoader.loadClass(this)
237 private fun File.deleteAfter(action: File.() -> Unit) = try {