Fix tests by parsing the created JSON reply
[Sone.git] / src / test / kotlin / net / pterodactylus / sone / fcp / FcpInterfaceTest.kt
1 @file:Suppress("DEPRECATION")
2
3 package net.pterodactylus.sone.fcp
4
5 import com.google.inject.Guice
6 import freenet.pluginmanager.PluginNotFoundException
7 import freenet.pluginmanager.PluginReplySender
8 import freenet.support.SimpleFieldSet
9 import net.pterodactylus.sone.core.Core
10 import net.pterodactylus.sone.fcp.FcpInterface.AccessAuthorizer
11 import net.pterodactylus.sone.fcp.FcpInterface.CommandSupplier
12 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired
13 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS
14 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.NO
15 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING
16 import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent
17 import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent
18 import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged
19 import net.pterodactylus.sone.freenet.fcp.Command.AccessType
20 import net.pterodactylus.sone.freenet.fcp.Command.AccessType.FULL_FCP
21 import net.pterodactylus.sone.freenet.fcp.Command.AccessType.RESTRICTED_FCP
22 import net.pterodactylus.sone.freenet.fcp.Command.Response
23 import net.pterodactylus.sone.test.capture
24 import net.pterodactylus.sone.test.isProvidedBy
25 import net.pterodactylus.sone.test.mock
26 import net.pterodactylus.sone.test.whenever
27 import org.hamcrest.MatcherAssert.assertThat
28 import org.hamcrest.Matchers.containsInAnyOrder
29 import org.hamcrest.Matchers.equalTo
30 import org.hamcrest.Matchers.sameInstance
31 import org.junit.Test
32 import org.mockito.ArgumentMatchers
33 import org.mockito.Mockito.any
34 import org.mockito.Mockito.anyBoolean
35 import org.mockito.Mockito.verify
36
37 /**
38  * Unit test for [FcpInterface] and its subclasses.
39  */
40 class FcpInterfaceTest {
41
42         private val core = mock<Core>()
43         private val workingCommand = mock<AbstractSoneCommand>().apply {
44                 whenever(execute(any())).thenReturn(Response("Working", SimpleFieldSet(true).apply {
45                         putSingle("ReallyWorking", "true")
46                 }))
47         }
48         private val brokenCommand = mock<AbstractSoneCommand>().apply {
49                 whenever(execute(any())).thenThrow(RuntimeException::class.java)
50         }
51         private val commandSupplier = object : CommandSupplier() {
52                 override fun supplyCommands(core: Core): Map<String, AbstractSoneCommand> {
53                         return mapOf(
54                                         "Working" to workingCommand,
55                                         "Broken" to brokenCommand
56                         )
57                 }
58         }
59         private val accessAuthorizer = mock<AccessAuthorizer>()
60         private val fcpInterface = FcpInterface(core, commandSupplier, accessAuthorizer)
61         private val pluginReplySender = mock<PluginReplySender>()
62         private val parameters = SimpleFieldSet(true)
63         private val replyParameters = capture<SimpleFieldSet>()
64
65         @Test
66         fun `fcp interface is instantiated as singleton`() {
67                 val injector = Guice.createInjector(Core::class.isProvidedBy(core))
68                 assertThat(injector.getInstance(FcpInterface::class.java), sameInstance(injector.getInstance(FcpInterface::class.java)))
69         }
70
71         @Test
72         fun `fcp interface can be activated`() {
73                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
74                 assertThat(fcpInterface.isActive, equalTo(true))
75         }
76
77         @Test
78         fun `fcp interface can be deactivated`() {
79                 fcpInterface.fcpInterfaceDeactivated(FcpInterfaceDeactivatedEvent())
80                 assertThat(fcpInterface.isActive, equalTo(false))
81         }
82
83         private fun setAndVerifyAccessRequired(fullAccessRequired: FullAccessRequired) {
84                 fcpInterface.fullAccessRequiredChanged(FullAccessRequiredChanged(fullAccessRequired))
85                 assertThat(fcpInterface.fullAccessRequired, equalTo(fullAccessRequired))
86         }
87
88         @Test
89         fun `set full access required can set access to no`() {
90                 setAndVerifyAccessRequired(NO)
91         }
92
93         @Test
94         fun `set full access required can set access to writing`() {
95                 setAndVerifyAccessRequired(WRITING)
96         }
97
98         @Test
99         fun `set full access required can set access to always`() {
100                 setAndVerifyAccessRequired(ALWAYS)
101         }
102
103         @Test
104         fun `sending command to inactive fcp interface results in 503 error reply`() {
105                 fcpInterface.fcpInterfaceDeactivated(FcpInterfaceDeactivatedEvent())
106                 parameters.putSingle("Identifier", "Test")
107                 fcpInterface.handle(pluginReplySender, parameters, null, 0)
108                 verify(pluginReplySender).send(replyParameters.capture())
109                 assertThat(replyParameters.value["Message"], equalTo("Error"))
110                 assertThat(replyParameters.value["ErrorCode"], equalTo("503"))
111         }
112
113         @Test
114         fun `exception while sending reply does not result in exception`() {
115                 fcpInterface.fcpInterfaceDeactivated(FcpInterfaceDeactivatedEvent())
116                 whenever(pluginReplySender.send(ArgumentMatchers.any())).thenThrow(PluginNotFoundException::class.java)
117                 fcpInterface.handle(pluginReplySender, parameters, null, 0)
118         }
119
120         @Test
121         fun `sending command over non-authorized connection results in 401 error reply`() {
122                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
123                 parameters.putSingle("Identifier", "Test")
124                 parameters.putSingle("Message", "Working")
125                 fcpInterface.handle(pluginReplySender, parameters, null, RESTRICTED_FCP.ordinal)
126                 verify(pluginReplySender).send(replyParameters.capture())
127                 assertThat(replyParameters.value["Message"], equalTo("Error"))
128                 assertThat(replyParameters.value["ErrorCode"], equalTo("401"))
129         }
130
131         @Test
132         fun `sending unknown command results in 404 error reply`() {
133                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
134                 parameters.putSingle("Identifier", "Test")
135                 fcpInterface.handle(pluginReplySender, parameters, null, RESTRICTED_FCP.ordinal)
136                 verify(pluginReplySender).send(replyParameters.capture())
137                 assertThat(replyParameters.value["Message"], equalTo("Error"))
138                 assertThat(replyParameters.value["ErrorCode"], equalTo("404"))
139         }
140
141         @Test
142         fun `sending working command without identifier results in 400 error code`() {
143                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
144                 whenever(accessAuthorizer.authorized(any(), any(), anyBoolean())).thenReturn(true)
145                 parameters.putSingle("Message", "Working")
146                 fcpInterface.handle(pluginReplySender, parameters, null, FULL_FCP.ordinal)
147                 verify(pluginReplySender).send(replyParameters.capture())
148                 assertThat(replyParameters.value["Message"], equalTo("Error"))
149                 assertThat(replyParameters.value["ErrorCode"], equalTo("400"))
150         }
151
152         @Test
153         fun `sending working command with empty identifier results in 400 error code`() {
154                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
155                 whenever(accessAuthorizer.authorized(any(), any(), anyBoolean())).thenReturn(true)
156                 parameters.putSingle("Message", "Working")
157                 parameters.putSingle("Identifier", "")
158                 fcpInterface.handle(pluginReplySender, parameters, null, FULL_FCP.ordinal)
159                 verify(pluginReplySender).send(replyParameters.capture())
160                 assertThat(replyParameters.value["Message"], equalTo("Error"))
161                 assertThat(replyParameters.value["ErrorCode"], equalTo("400"))
162         }
163
164         @Test
165         fun `sending working command with identifier results in working reply`() {
166                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
167                 whenever(accessAuthorizer.authorized(any(), any(), anyBoolean())).thenReturn(true)
168                 parameters.putSingle("Message", "Working")
169                 parameters.putSingle("Identifier", "Test")
170                 fcpInterface.handle(pluginReplySender, parameters, null, FULL_FCP.ordinal)
171                 verify(pluginReplySender).send(replyParameters.capture())
172                 assertThat(replyParameters.value["Message"], equalTo("Working"))
173                 assertThat(replyParameters.value["ReallyWorking"], equalTo("true"))
174         }
175
176         @Test
177         fun `sending broken  command with identifier results in 500 error reply`() {
178                 fcpInterface.fcpInterfaceActivated(FcpInterfaceActivatedEvent())
179                 whenever(accessAuthorizer.authorized(any(), any(), anyBoolean())).thenReturn(true)
180                 parameters.putSingle("Message", "Broken")
181                 parameters.putSingle("Identifier", "Test")
182                 fcpInterface.handle(pluginReplySender, parameters, null, FULL_FCP.ordinal)
183                 verify(pluginReplySender).send(replyParameters.capture())
184                 assertThat(replyParameters.value["Message"], equalTo("Error"))
185                 assertThat(replyParameters.value["ErrorCode"], equalTo("500"))
186         }
187
188 }
189
190 class CommandSupplierTest {
191
192         private val core = mock<Core>()
193         private val commandSupplier = CommandSupplier()
194
195         @Test
196         fun `command supplier supplies all commands`() {
197                 val commands = commandSupplier.supplyCommands(core)
198                 assertThat(commands.keys, containsInAnyOrder(
199                                 "CreatePost",
200                                 "CreateReply",
201                                 "DeletePost",
202                                 "DeleteReply",
203                                 "GetLocalSones",
204                                 "GetPost",
205                                 "GetPostFeed",
206                                 "GetPosts",
207                                 "GetSone",
208                                 "GetSones",
209                                 "LikePost",
210                                 "LikeReply",
211                                 "LockSone",
212                                 "UnlockSone",
213                                 "Version"
214                 ))
215         }
216
217         @Test
218         fun `command supplier is instantiated as singleton`() {
219                 val injector = Guice.createInjector()
220                 assertThat(injector.getInstance(CommandSupplier::class.java), sameInstance(injector.getInstance(CommandSupplier::class.java)))
221         }
222
223 }
224
225 class AccessAuthorizerTest {
226
227         private val accessAuthorizer = AccessAuthorizer()
228
229         @Test
230         fun `access authorizer is instantiated as singleton`() {
231                 val injector = Guice.createInjector()
232                 assertThat(injector.getInstance(AccessAuthorizer::class.java), sameInstance(injector.getInstance(AccessAuthorizer::class.java)))
233         }
234
235         @Test
236         fun `access authorizer makes correct decisions`() {
237                 AccessType.values().forEach { accessType ->
238                         FullAccessRequired.values().forEach { fullAccessRequired ->
239                                 listOf(false, true).forEach { commandRequiresWriteAccess ->
240                                         assertThat("$accessType, $fullAccessRequired, $commandRequiresWriteAccess", accessAuthorizer.authorized(accessType, fullAccessRequired, commandRequiresWriteAccess), equalTo(
241                                                         accessType != RESTRICTED_FCP ||
242                                                                         fullAccessRequired == NO ||
243                                                                         (fullAccessRequired == WRITING && !commandRequiresWriteAccess)
244                                         ))
245                                 }
246                         }
247                 }
248         }
249
250 }