src/test/java/net/pterodactylus/sone/web/ajax/JsonPageTest.java

   1 package net.pterodactylus.sone.web.ajax;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.is;
   5 import static org.mockito.Matchers.any;
   6 import static org.mockito.Matchers.anyBoolean;
   7 import static org.mockito.Mockito.mock;
   8 import static org.mockito.Mockito.when;
   9
  10 import java.io.ByteArrayOutputStream;
  11 import java.io.IOException;
  12 import java.io.OutputStream;
  13
  14 import net.pterodactylus.sone.data.Mocks;
  15 import net.pterodactylus.sone.data.Sone;
  16 import net.pterodactylus.sone.web.page.FreenetRequest;
  17 import net.pterodactylus.util.web.Response;
  18
  19 import freenet.clients.http.ToadletContext;
  20 import freenet.support.api.HTTPRequest;
  21
  22 import org.junit.Test;
  23
  24 /**
  25  * Unit test for {@link JsonPage}.
  26  *
  27  * @author <a href="mailto:">David Roden</a>
  28  */
  29 public class JsonPageTest {
  30
  31         private static final String PATH = "/test/path";
  32         private final Mocks mocks = new Mocks();
  33         private final FreenetRequest request = createRequest();
  34         private final Response response = createResponse();
  35
  36         @Test
  37         public void defaultJsonPageRequiresFormPassword() {
  38                 JsonPage jsonPage = createJsonPage(true, true);
  39                 assertThat(jsonPage.needsFormPassword(), is(true));
  40         }
  41
  42         @Test
  43         public void defaultJsonPageRequiresLogin() {
  44                 JsonPage jsonPage = createJsonPage(true, true);
  45                 assertThat(jsonPage.requiresLogin(), is(true));
  46         }
  47
  48         @Test
  49         public void defaultJsonPageReturnsTheCorrectPath() {
  50                 JsonPage jsonPage = createJsonPage(true, true);
  51                 assertThat(jsonPage.getPath(), is(PATH));
  52         }
  53
  54         @Test
  55         public void defaultJsonPageIsNotAPrefixPage() {
  56                 JsonPage jsonPage = createJsonPage(true, true);
  57                 assertThat(jsonPage.isPrefixPage(), is(false));
  58         }
  59
  60         @Test
  61         public void defaultJsonPageIsNotLinkExcepted() {
  62                 JsonPage jsonPage = createJsonPage(true, true);
  63                 assertThat(jsonPage.isLinkExcepted(null), is(false));
  64         }
  65
  66         @Test
  67         public void defaultJsonPageResultsIn403IfAccessedWithFullAccessIfRequired() throws IOException {
  68                 JsonPage jsonPage = createJsonPage(true, true);
  69                 configureFullAccess();
  70                 jsonPage.handleRequest(request, response);
  71                 verifyResponse(response, 403, "Forbidden");
  72         }
  73
  74         private void verifyResponseIs500(Response response) {
  75                 assertThat(response.getStatusCode(), is(500));
  76         }
  77
  78         private void verifyResponse(Response response, int statusCode, String statusText) {
  79                 assertThat(response.getStatusCode(), is(statusCode));
  80                 assertThat(response.getStatusText(), is(statusText));
  81         }
  82
  83         private Response createResponse() {
  84                 OutputStream outputStream = new ByteArrayOutputStream();
  85                 return new Response(outputStream);
  86         }
  87
  88         private FreenetRequest createRequest() {
  89                 ToadletContext toadletContext = mock(ToadletContext.class);
  90                 when(toadletContext.isAllowedFullAccess()).thenReturn(false);
  91                 FreenetRequest request = mock(FreenetRequest.class);
  92                 when(request.getToadletContext()).thenReturn(toadletContext);
  93                 return request;
  94         }
  95
  96         private void configureFullAccess() {
  97                 mocks.core.getPreferences().setRequireFullAccess(true);
  98         }
  99
 100         @Test
 101         public void defaultJsonPageResultsIn403IfPasswordIsRequiredButNotGiven() throws IOException {
 102                 JsonPage jsonPage = createJsonPage(true, true);
 103                 configureRequiredPassword("password");
 104                 configureRequestPassword(request, null);
 105                 jsonPage.handleRequest(request, response);
 106                 verifyResponse(response, 403, "Forbidden");
 107         }
 108
 109         private void configureRequestPassword(FreenetRequest request, String password) {
 110                 HTTPRequest httpRequest = mock(HTTPRequest.class);
 111                 when(httpRequest.getParam("formPassword")).thenReturn(password);
 112                 when(request.getHttpRequest()).thenReturn(httpRequest);
 113         }
 114
 115         private void configureRequiredPassword(String password) {
 116                 when(mocks.webInterface.getFormPassword()).thenReturn(password);
 117         }
 118
 119         @Test
 120         public void defaultJsonPageResultsIn403IfPasswordIsRequiredButWrong() throws IOException {
 121                 JsonPage jsonPage = createJsonPage(true, true);
 122                 configureRequiredPassword("password");
 123                 configureRequestPassword(request, "wrongpassword");
 124                 jsonPage.handleRequest(request, response);
 125                 verifyResponse(response, 403, "Forbidden");
 126         }
 127
 128         @Test
 129         public void defaultJsonPageResultsIn403IfLoginIsRequiredAndSessionIsNull() throws IOException {
 130                 JsonPage jsonPage = createJsonPage(true, true);
 131                 configureRequiredPassword("password");
 132                 configureRequestPassword(request, "password");
 133                 jsonPage.handleRequest(request, response);
 134                 verifyResponse(response, 403, "Forbidden");
 135         }
 136
 137         @Test
 138         public void defaultJsonPageResultsIn200() throws IOException {
 139                 JsonPage jsonPage = createJsonPage(true, true);
 140                 configureSession();
 141                 configureRequiredPassword("password");
 142                 configureRequestPassword(request, "password");
 143                 jsonPage.handleRequest(request, response);
 144                 verifyResponse(response, 200, "OK");
 145         }
 146
 147         private void configureSession() {
 148                 Sone sone = mocks.mockSone("Sone").create();
 149                 when(mocks.webInterface.getCurrentSone(any(ToadletContext.class), anyBoolean())).thenReturn(sone);
 150         }
 151
 152         @Test
 153         public void exceptionDuringReturnObjectCreationResultsIn500() throws IOException {
 154                 JsonPage jsonPage = createExceptionThrowingJsonPage();
 155                 configureSession();
 156                 configureRequiredPassword("password");
 157                 configureRequestPassword(request, "password");
 158                 jsonPage.handleRequest(request, response);
 159                 verifyResponseIs500(response);
 160         }
 161
 162         @Test
 163         public void jsonPageWithoutPasswordAndLoginResultsIn200() throws IOException {
 164                 JsonPage jsonPage = createJsonPage(false, false);
 165                 jsonPage.handleRequest(request, response);
 166                 verifyResponse(response, 200, "OK");
 167         }
 168
 169         private JsonPage createJsonPage(final boolean needsFormPassword, final boolean requiresLogin) {
 170                 return new JsonPage(PATH, mocks.webInterface) {
 171                         @Override
 172                         protected JsonReturnObject createJsonObject(FreenetRequest request) {
 173                                 return createSuccessJsonObject();
 174                         }
 175
 176                         @Override
 177                         protected boolean needsFormPassword() {
 178                                 return needsFormPassword;
 179                         }
 180
 181                         @Override
 182                         protected boolean requiresLogin() {
 183                                 return requiresLogin;
 184                         }
 185                 };
 186         }
 187
 188         private JsonPage createExceptionThrowingJsonPage() {
 189                 return new JsonPage(PATH, mocks.webInterface) {
 190                         @Override
 191                         protected JsonReturnObject createJsonObject(FreenetRequest request) {
 192                                 throw new NullPointerException();
 193                         }
 194                 };
 195         }
 196
 197 }