X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fweb%2FWebPageTest.java;h=6f99879bf6d7f445ed82d0ad064372dabee02b50;hp=1a6fb59c02c98c5407f2af6f58543ecb2b52cd86;hb=9acbc5bdec4ccb752e0856a501568b0bb6161579;hpb=ae036a458cbfc027367cab1464b2a618f650228e diff --git a/src/test/java/net/pterodactylus/sone/web/WebPageTest.java b/src/test/java/net/pterodactylus/sone/web/WebPageTest.java index 1a6fb59..6f99879 100644 --- a/src/test/java/net/pterodactylus/sone/web/WebPageTest.java +++ b/src/test/java/net/pterodactylus/sone/web/WebPageTest.java @@ -1,33 +1,72 @@ package net.pterodactylus.sone.web; +import static net.pterodactylus.sone.test.GuiceKt.supply; +import static net.pterodactylus.sone.web.WebTestUtils.redirectsTo; +import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; import java.net.URI; import java.net.URISyntaxException; import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.annotation.Nonnull; import net.pterodactylus.sone.core.Core; +import net.pterodactylus.sone.core.Preferences; import net.pterodactylus.sone.core.UpdateChecker; +import net.pterodactylus.sone.data.Album; +import net.pterodactylus.sone.data.Image; import net.pterodactylus.sone.data.Post; +import net.pterodactylus.sone.data.PostReply; import net.pterodactylus.sone.data.Sone; +import net.pterodactylus.sone.data.SoneOptions.DefaultSoneOptions; +import net.pterodactylus.sone.data.TemporaryImage; +import net.pterodactylus.sone.freenet.wot.OwnIdentity; import net.pterodactylus.sone.web.page.FreenetRequest; +import net.pterodactylus.sone.web.page.FreenetTemplatePage.RedirectException; import net.pterodactylus.util.notify.Notification; import net.pterodactylus.util.template.Template; import net.pterodactylus.util.template.TemplateContext; import net.pterodactylus.util.web.Method; +import net.pterodactylus.util.web.Response; import freenet.clients.http.ToadletContext; +import freenet.l10n.BaseL10n; +import freenet.support.SimpleReadOnlyArrayBucket; +import freenet.support.api.Bucket; import freenet.support.api.HTTPRequest; +import freenet.support.api.HTTPUploadedFile; +import freenet.support.io.NullBucket; import com.google.common.base.Optional; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; +import com.google.common.collect.Multimap; +import com.google.common.eventbus.EventBus; +import com.google.common.io.ByteStreams; +import com.google.inject.Guice; +import com.google.inject.Injector; import org.junit.Before; import org.junit.Rule; import org.junit.rules.ExpectedException; +import org.mockito.ArgumentMatchers; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -43,37 +82,220 @@ public abstract class WebPageTest { protected final Template template = new Template(); protected final WebInterface webInterface = mock(WebInterface.class, RETURNS_DEEP_STUBS); + protected final EventBus eventBus = mock(EventBus.class); protected final Core core = webInterface.getCore(); + protected final BaseL10n l10n = webInterface.getL10n(); protected final Sone currentSone = mock(Sone.class); protected final TemplateContext templateContext = new TemplateContext(); protected final HTTPRequest httpRequest = mock(HTTPRequest.class); + protected final Multimap requestParameters = ArrayListMultimap.create(); + protected final Map requestHeaders = new HashMap<>(); + private final Map uploadedFilesNames = new HashMap<>(); + private final Map uploadedFilesContentTypes = new HashMap<>(); + private final Map uploadedFilesSources = new HashMap<>(); protected final FreenetRequest freenetRequest = mock(FreenetRequest.class); + private final PipedOutputStream responseOutputStream = new PipedOutputStream(); + private final PipedInputStream responseInputStream; + protected final Response response = new Response(responseOutputStream); protected final ToadletContext toadletContext = mock(ToadletContext.class); + private final Set ownIdentities = new HashSet<>(); + private final Map sones = new HashMap<>(); + protected final List localSones = new ArrayList<>(); + private final ListMultimap postReplies = ArrayListMultimap.create(); + + protected final Injector injector = Guice.createInjector( + supply(WebInterface.class).byInstance(webInterface), + supply(Template.class).byInstance(template) + ); + + protected WebPageTest() { + try { + responseInputStream = new PipedInputStream(responseOutputStream); + } catch (IOException e) { + throw new RuntimeException(e); + } + } @Before public final void setupFreenetRequest() { when(freenetRequest.getToadletContext()).thenReturn(toadletContext); when(freenetRequest.getHttpRequest()).thenReturn(httpRequest); + when(httpRequest.getMultipleParam(anyString())).thenAnswer(new Answer() { + @Override + public String[] answer(InvocationOnMock invocation) throws Throwable { + return requestParameters.get(invocation.getArgument(0)).toArray(new String[0]); + } + }); + when(httpRequest.getPartAsStringFailsafe(anyString(), anyInt())).thenAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + String parameter = invocation.getArgument(0); + int maxLength = invocation.getArgument(1); + Collection values = requestParameters.get(parameter); + return requestParameters.containsKey(parameter) ? values.iterator().next().substring(0, Math.min(maxLength, values.iterator().next().length())) : ""; + } + }); + when(httpRequest.hasParameters()).thenAnswer(new Answer() { + @Override + public Boolean answer(InvocationOnMock invocation) throws Throwable { + return !requestParameters.isEmpty(); + } + }); + when(httpRequest.getParameterNames()).thenAnswer(new Answer>() { + @Override + public Collection answer(InvocationOnMock invocation) throws Throwable { + return requestParameters.keySet(); + } + }); + when(httpRequest.getParam(anyString())).thenAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + String parameter = invocation.getArgument(0); + return requestParameters.containsKey(parameter) ? requestParameters.get(parameter).iterator().next() : ""; + } + }); + when(httpRequest.getParam(anyString(), ArgumentMatchers.any())).thenAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + String parameter = invocation.getArgument(0); + return requestParameters.containsKey(parameter) ? requestParameters.get(parameter).iterator().next() : invocation.getArgument(1); + } + }); + when(httpRequest.isParameterSet(anyString())).thenAnswer(new Answer() { + @Override + public Boolean answer(InvocationOnMock invocation) throws Throwable { + return requestParameters.containsKey(invocation.getArgument(0)) && + requestParameters.get(invocation.getArgument(0)).iterator().next() != null; + } + }); + when(httpRequest.isPartSet(anyString())).thenAnswer(new Answer() { + @Override + public Boolean answer(InvocationOnMock invocation) throws Throwable { + return requestParameters.containsKey(invocation.getArgument(0)) && + requestParameters.get(invocation.getArgument(0)).iterator().next() != null; + } + }); + when(httpRequest.getParts()).thenAnswer(new Answer() { + @Override + public String[] answer(InvocationOnMock invocation) throws Throwable { + return requestParameters.keySet().toArray(new String[requestParameters.size()]); + } + }); + when(httpRequest.getHeader(anyString())).thenAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + return requestHeaders.get(invocation.getArgument(0).toLowerCase()); + } + }); + when(httpRequest.getUploadedFile(anyString())).thenAnswer(new Answer() { + @Override + public HTTPUploadedFile answer(InvocationOnMock invocation) throws Throwable { + final String name = invocation.getArgument(0); + if (!uploadedFilesSources.containsKey(name)) { + return null; + } + return new HTTPUploadedFile() { + @Override + public String getContentType() { + return uploadedFilesContentTypes.get(name); + } + + @Override + public Bucket getData() { + try (InputStream inputStream = getClass().getResourceAsStream(uploadedFilesSources.get(name))) { + byte[] bytes = ByteStreams.toByteArray(inputStream); + return new SimpleReadOnlyArrayBucket(bytes, 0, bytes.length); + } catch (IOException ioe1) { + return new NullBucket(); + } + } + + @Override + public String getFilename() { + return uploadedFilesNames.get(name); + } + }; + } + }); } @Before public final void setupCore() { UpdateChecker updateChecker = mock(UpdateChecker.class); - when(webInterface.getCore().getUpdateChecker()).thenReturn(updateChecker); + when(core.getUpdateChecker()).thenReturn(updateChecker); + when(core.getPreferences()).thenReturn(new Preferences(eventBus)); + when(core.getLocalSone(anyString())).thenReturn(null); + when(core.getLocalSones()).thenReturn(localSones); + when(core.getSone(anyString())).thenReturn(Optional.absent()); + when(core.getSones()).thenAnswer(new Answer>() { + @Override + public Collection answer(InvocationOnMock invocation) throws Throwable { + return sones.values(); + } + }); + when(core.getSone(anyString())).thenAnswer(new Answer>() { + @Override + public Optional answer(InvocationOnMock invocation) throws Throwable { + return Optional.fromNullable(sones.get(invocation.getArgument(0))); + } + }); + when(core.getPost(anyString())).thenReturn(Optional.absent()); + when(core.getPostReply(anyString())).thenReturn(Optional.absent()); + when(core.getReplies(anyString())).thenAnswer(new Answer>() { + @Override + public List answer(InvocationOnMock invocation) throws Throwable { + return postReplies.get(invocation.getArgument(0)); + } + }); + when(core.getAlbum(anyString())).thenReturn(null); + when(core.getImage(anyString())).thenReturn(null); + when(core.getImage(anyString(), anyBoolean())).thenReturn(null); + when(core.getTemporaryImage(anyString())).thenReturn(null); + } + + @Before + public void setupL10n() { + when(l10n.getString(anyString())).thenAnswer(new Answer() { + @Override + public String answer(InvocationOnMock invocation) throws Throwable { + return invocation.getArgument(0); + } + }); + } + + @Before + public final void setupIdentityManager() { + when(core.getIdentityManager().getAllOwnIdentities()).thenReturn(ownIdentities); } @Before public final void setupWebInterface() { - when(webInterface.getCurrentSone(toadletContext)).thenReturn(currentSone); - when(webInterface.getCurrentSone(eq(toadletContext), anyBoolean())).thenReturn(currentSone); + when(webInterface.getCurrentSoneCreatingSession(toadletContext)).thenReturn(currentSone); + when(webInterface.getCurrentSoneWithoutCreatingSession(toadletContext)).thenReturn(currentSone); + when(webInterface.getNotification(anyString())).thenReturn(Optional.absent()); when(webInterface.getNotifications(currentSone)).thenReturn(new ArrayList()); } + @Before + public void setupSone() { + when(currentSone.getOptions()).thenReturn(new DefaultSoneOptions()); + } + + protected SoneTemplatePage getPage() { + return null; + } + + protected void unsetCurrentSone() { + when(webInterface.getCurrentSoneCreatingSession(toadletContext)).thenReturn(null); + when(webInterface.getCurrentSoneWithoutCreatingSession(toadletContext)).thenReturn(null); + } + protected void request(String uri, Method method) { try { + when(httpRequest.getPath()).thenReturn(uri); when(freenetRequest.getUri()).thenReturn(new URI(uri)); } catch (URISyntaxException e) { throw new RuntimeException(e); @@ -81,18 +303,82 @@ public abstract class WebPageTest { when(freenetRequest.getMethod()).thenReturn(method); } + protected void addHttpRequestHeader(@Nonnull String name, String value) { + requestHeaders.put(name.toLowerCase(), value); + } + protected void addHttpRequestParameter(String name, final String value) { - when(httpRequest.getPartAsStringFailsafe(eq(name), anyInt())).thenAnswer(new Answer() { - @Override - public String answer(InvocationOnMock invocation) throws Throwable { - int maxLength = invocation.getArgument(1); - return value.substring(0, Math.min(maxLength, value.length())); - } - }); + requestParameters.put(name, value); } protected void addPost(String postId, Post post) { when(core.getPost(postId)).thenReturn(Optional.fromNullable(post)); } + protected void addPostReply(String postReplyId, PostReply postReply) { + if (postReply.getPostId() != null) { + postReplies.put(postReply.getPostId(), postReply); + } + when(core.getPostReply(postReplyId)).thenReturn(Optional.fromNullable(postReply)); + } + + protected void addSone(String soneId, Sone sone) { + sones.put(soneId, sone); + } + + protected void addLocalSone(String soneId, Sone sone) { + when(core.getLocalSone(eq(soneId))).thenReturn(sone); + localSones.add(sone); + } + + protected void addOwnIdentity(OwnIdentity ownIdentity) { + ownIdentities.add(ownIdentity); + } + + protected void addAlbum(String albumId, Album album) { + when(core.getAlbum(eq(albumId))).thenReturn(album); + } + + protected void addImage(String imageId, Image image) { + when(core.getImage(eq(imageId))).thenReturn(image); + when(core.getImage(eq(imageId), anyBoolean())).thenReturn(image); + } + + protected void addTemporaryImage(String imageId, TemporaryImage temporaryImage) { + when(core.getTemporaryImage(eq(imageId))).thenReturn(temporaryImage); + } + + protected void addUploadedFile(@Nonnull String name, @Nonnull String filename, @Nonnull String contentType, @Nonnull String resource) { + uploadedFilesNames.put(name, filename); + uploadedFilesContentTypes.put(name, contentType); + uploadedFilesSources.put(name, resource); + } + + protected byte[] getResponseBytes() throws IOException { + response.getContent().close(); + try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) { + ByteStreams.copy(responseInputStream, outputStream); + return outputStream.toByteArray(); + } + } + + protected void addNotification(String notificationId, Notification notification) { + when(webInterface.getNotification(eq(notificationId))).thenReturn(Optional.of(notification)); + } + + protected void verifyRedirect(String target) throws RedirectException { + expectedException.expect(redirectsTo(target)); + getPage().handleRequest(freenetRequest, templateContext); + } + + protected void verifyRedirect(String target, Runnable verification) throws RedirectException { + expectedException.expect(redirectsTo(target)); + try { + getPage().handleRequest(freenetRequest, templateContext); + fail(); + } finally { + verification.run(); + } + } + }