Esempio n. 1
0
 public SimpleResponse asResponse() throws Exception {
   byte[] bytes = toByteArray(document);
   SimpleResponse response = new SimpleResponse();
   response.setContent(bytes);
   response.setContentType("text/xml");
   return response;
 }
  @Test
  public void testHeadersAndFooters() throws Exception {
    WikiPageUtil.addPage(root, PathParser.parse("NormalPage"), "normal");
    WikiPageUtil.addPage(root, PathParser.parse("TestPage"), "test page");
    WikiPageUtil.addPage(root, PathParser.parse("PageHeader"), "header");
    WikiPageUtil.addPage(root, PathParser.parse("PageFooter"), "footer");
    WikiPageUtil.addPage(root, PathParser.parse("SetUp"), "setup");
    WikiPageUtil.addPage(root, PathParser.parse("TearDown"), "teardown");
    WikiPageUtil.addPage(root, PathParser.parse("SuiteSetUp"), "suite setup");
    WikiPageUtil.addPage(root, PathParser.parse("SuiteTearDown"), "suite teardown");

    SimpleResponse response = requestPage("NormalPage");
    String content = response.getContent();
    assertHasRegexp("header", content);
    assertHasRegexp("normal", content);
    assertHasRegexp("footer", content);
    assertDoesntHaveRegexp("setup", content);
    assertDoesntHaveRegexp("teardown", content);
    assertDoesntHaveRegexp("suite setup", content);
    assertDoesntHaveRegexp("suite teardown", content);

    response = requestPage("TestPage");
    content = response.getContent();
    assertHasRegexp("header", content);
    assertHasRegexp("test page", content);
    assertHasRegexp("footer", content);
    assertHasRegexp("setup", content);
    assertHasRegexp("teardown", content);
    assertHasRegexp("suite setup", content);
    assertHasRegexp("suite teardown", content);
  }
 private void getContentForSimpleRename() throws Exception {
   request.setResource("files");
   request.addInput("filename", "MyFile.txt");
   Responder responder = new RenameFileConfirmationResponder(htmlPageFactory);
   SimpleResponse response = (SimpleResponse) responder.makeResponse(request);
   content = response.getContent();
 }
 public Response makeResponse(FitNesseContext context, Request request) throws Exception {
   SimpleResponse response = new SimpleResponse();
   resource = request.getResource();
   String filename = (String) request.getInput("filename");
   response.setContent(makePageContent(filename, context));
   return response;
 }
  @Test
  public void testResponse() throws Exception {
    WikiPage page = WikiPageUtil.addPage(root, PathParser.parse("ChildPage"), "child content");
    PageData data = page.getData();
    WikiPageProperties properties = data.getProperties();
    properties.set(PageData.PropertySUITES, "Wiki Page tags");
    page.commit(data);

    final MockRequest request = new MockRequest();
    request.setResource("ChildPage");

    final Responder responder = new WikiPageResponder();
    final SimpleResponse response = (SimpleResponse) responder.makeResponse(context, request);

    assertEquals(200, response.getStatus());

    final String body = response.getContent();

    assertSubString("<html>", body);
    assertSubString("<body", body);
    assertSubString("child content", body);
    assertSubString("href=\"ChildPage?whereUsed\"", body);
    assertSubString("Cache-Control: max-age=0", response.makeHttpHeaders());
    assertSubString("<h5> Wiki Page tags</h5>", body);
  }
Esempio n. 6
0
  public Response makeResponse(FitNesseContext context, Request request) throws Exception {
    if (!getAndValidateRefactoredPage(context, request)) {
      return new NotFoundResponder().makeResponse(context, request);
    }

    if (!getAndValidateNewParentPage(context, request)) {
      return makeErrorMessageResponder(newParentPath.toString() + " does not exist.")
          .makeResponse(context, request);
    }

    if (!getAndValidateRefactoringParameters(request)) {
      return makeErrorMessageResponder("").makeResponse(context, request);
    }

    if (targetPageExists()) {
      return makeErrorMessageResponder(makeLink(getNewPageName()) + " already exists")
          .makeResponse(context, request);
    }

    if (request.hasInput("refactorReferences")) {
      getReferenceRenamer(context).renameReferences();
    }
    execute();

    SimpleResponse response = new SimpleResponse();
    response.redirect(createRedirectionUrl(newParentPage, getNewPageName()));

    return response;
  }
  private Response makePageHistoryXmlResponse(Request request) {
    VelocityContext velocityContext = new VelocityContext();
    velocityContext.put("pageHistory", pageHistory);

    response.setContentType("text/xml");
    response.setContent(context.pageFactory.render(velocityContext, "pageHistoryXML.vm"));
    return response;
  }
 @Test
 public void testFitnesseLook() throws Exception {
   Responder responder = new RenameFileConfirmationResponder(htmlPageFactory);
   SimpleResponse response = (SimpleResponse) responder.makeResponse(request);
   String content = response.getContent();
   assertSubString(
       "<link rel=\"stylesheet\" type=\"text/css\" href=\"/files/css/fitnesse.css\" media=\"screen\"/>",
       content);
 }
 private Response makeBannedContentResponse(FitNesseContext context, String resource) {
   SimpleResponse response = new SimpleResponse();
   HtmlPage html = context.pageFactory.newPage();
   html.setTitle("Edit " + resource);
   html.setPageTitle(new PageTitle("Banned Content", PathParser.parse(resource)));
   html.setMainTemplate("bannedPage.vm");
   response.setContent(html.html());
   return response;
 }
 @Test
 public void shouldDeleteHistoryFromRequestAndRedirect() throws Exception {
   StubbedPurgeHistoryResponder responder = new StubbedPurgeHistoryResponder();
   request.addInput("days", "30");
   SimpleResponse response = (SimpleResponse) responder.makeResponse(context, request);
   assertEquals(30, responder.daysDeleted);
   assertEquals(303, response.getStatus());
   assertEquals("?testHistory", response.getHeader("Location"));
 }
 private void makeContent(FitNesseContext context, Request request) throws Exception {
   if ("json".equals(request.getInput("format"))) {
     JSONObject jsonObject = makeJson();
     response.setContent(jsonObject.toString(1));
   } else {
     String html = makeHtml(context);
     response.setContent(html);
   }
 }
 private Response generateXMLResponse(File file) {
   try {
     response.setContent(FileUtil.getFileContent(file));
   } catch (IOException e) {
     response.setContent("Error: Unable to read file '" + file.getName() + "'\n");
   }
   response.setContentType(Format.XML);
   return response;
 }
Esempio n. 13
0
 private WikiPage getPropertiesContentFromPage(WikiPage page) throws Exception {
   request = new MockRequest();
   request.setResource(page.getName());
   responder = new PropertiesResponder();
   SimpleResponse response =
       (SimpleResponse) responder.makeResponse(new FitNesseContext(root), request);
   content = response.getContent();
   return page;
 }
  public void testHasEditLinkForWikiWords() throws Exception {
    MockRequest request = new MockRequest();
    request.setResource("PageOne.PageTwo");
    WikiPage root = InMemoryPage.makeRoot("RooT");

    Responder responder = new NotFoundResponder();
    SimpleResponse response =
        (SimpleResponse) responder.makeResponse(FitNesseUtil.makeTestContext(root), request);

    assertHasRegexp("\"PageOne[.]PageTwo[?]edit\"", response.getContent());
  }
Esempio n. 15
0
  public Response makeResponse(Request request) throws Exception {
    SimpleResponse response = new SimpleResponse();
    resource = this.request.getResource();
    WikiPagePath path = PathParser.parse(resource);
    WikiPage page = root.getPageCrawler().getPage(root, path);
    existingContent = page.getData().getContent();
    newContent = (String) this.request.getInput(EditResponder.CONTENT_INPUT_NAME);

    response.setContent(makePageHtml());

    return response;
  }
  private SimpleResponse makeResponse(
      SuiteOverviewTree treeview, WikiPagePath path, Request request) {
    SimpleResponse response = new SimpleResponse();

    HtmlPage page = context.pageFactory.newPage();
    page.setTitle("Suite Overview");
    page.setPageTitle(new PageTitle("Suite Overview", path));
    page.put("treeRoot", treeview.getTreeRoot());
    page.put("viewLocation", request.getResource());
    page.setMainTemplate("suiteOverview");
    response.setContent(page.html());
    return response;
  }
Esempio n. 17
0
  private void makeContent(FitNesseContext context, Request request) {
    if ("json".equals(request.getInput("format"))) {
      JSONObject jsonObject = makeJson();
      try {
        response.setContent(jsonObject.toString(1));
      } catch (JSONException e) {
        throw new RuntimeException(e);
      }
    } else {
      String html = makeHtml(context, request);

      response.setContent(html);
    }
  }
Esempio n. 18
0
  public Response makeResponse(FitNesseContext context, Request request) {
    SimpleResponse response = new SimpleResponse();
    String resource = request.getResource();
    WikiPagePath path = PathParser.parse(resource);
    WikiPage page = context.root.getPageCrawler().getPage(path);
    if (page == null) return new NotFoundResponder().makeResponse(context, request);
    PageData data = page.getData();
    saveAttributes(request, data);
    VersionInfo commitRecord = page.commit(data);
    response.addHeader("Current-Version", commitRecord.getName());
    context.recentChanges.updateRecentChanges(data);
    response.redirect(resource);

    return response;
  }
  public void testResponse() throws Exception {
    MockRequest request = new MockRequest();
    request.setResource("some page");

    Responder responder = new NotFoundResponder();
    SimpleResponse response = (SimpleResponse) responder.makeResponse(context, request);

    assertEquals(404, response.getStatus());

    String body = response.getContent();

    assertHasRegexp("<html>", body);
    assertHasRegexp("<body", body);
    assertHasRegexp("some page", body);
    assertHasRegexp("Not Found", body);
  }
Esempio n. 20
0
  public void testUsernameDisplayed() throws Exception {
    WikiPage page = getContentFromSimplePropertiesPage();

    assertSubString("Last modified anonymously", content);

    PageData data = page.getData();
    data.setAttribute(WikiPage.LAST_MODIFYING_USER, "Bill");
    page.commit(data);

    request.setResource("SomePage");
    SimpleResponse response =
        (SimpleResponse) responder.makeResponse(new FitNesseContext(root), request);
    content = response.getContent();

    assertSubString("Last modified by Bill", content);
  }
  public void testMakeReponder() throws Exception {
    MockRequest request = new MockRequest();
    request.setResource("PageOne");

    Responder responder = new VersionSelectionResponder();
    SimpleResponse response =
        (SimpleResponse) responder.makeResponse(new FitNesseContext(root), request);

    String content = response.getContent();
    assertSubString("<input", content);
    assertSubString("name=\"version\"", content);
    assertSubString("<form", content);
    assertSubString("action=\"PageOne\"", content);
    assertSubString("name=\"responder\"", content);
    assertSubString(" value=\"viewVersion\"", content);
  }
Esempio n. 22
0
 private JSONObject makeJson() {
   response.setContentType("text/json");
   JSONObject jsonObject = new JSONObject();
   String attributes[] =
       new String[] {
         TEST.toString(),
         PropertySEARCH,
         PropertyEDIT,
         PropertyPROPERTIES,
         PropertyVERSIONS,
         PropertyREFACTOR,
         PropertyWHERE_USED,
         PropertyRECENT_CHANGES,
         SUITE.toString(),
         PropertyPRUNE,
         PropertySECURE_READ,
         PropertySECURE_WRITE,
         PropertySECURE_TEST,
         PropertyFILES
       };
   for (String attribute : attributes) addJsonAttribute(jsonObject, attribute);
   if (pageData.hasAttribute(PropertyHELP)) {
     jsonObject.put(PropertyHELP, pageData.getAttribute(PropertyHELP));
   }
   if (pageData.hasAttribute(PropertySUITES)) {
     JSONArray tags = new JSONArray();
     for (String tag : pageData.getAttribute(PropertySUITES).split(",")) {
       if (StringUtils.isNotBlank(tag)) {
         tags.put(tag.trim());
       }
     }
     jsonObject.put(PropertySUITES, tags);
   }
   return jsonObject;
 }
Esempio n. 23
0
  public void testResponse() throws Exception {
    WikiPage page = crawler.addPage(root, PathParser.parse("PageOne"));
    PageData data = page.getData();
    data.setContent("some content");
    WikiPageProperties properties = data.getProperties();
    properties.set("Test", "true");
    properties.set(WikiPageProperties.VIRTUAL_WIKI_ATTRIBUTE, "http://www.fitnesse.org");
    page.commit(data);

    MockRequest request = new MockRequest();
    request.setResource("PageOne");

    Responder responder = new PropertiesResponder();
    SimpleResponse response =
        (SimpleResponse) responder.makeResponse(new FitNesseContext(root), request);
    assertEquals("max-age=0", response.getHeader("Cache-Control"));

    String content = response.getContent();
    assertSubString("PageOne", content);
    assertSubString("value=\"http://www.fitnesse.org\"", content);
    assertDoesntHaveRegexp("textarea name=\"extensionXml\"", content);
    assertHasRegexp("<input.*value=\"Save Properties\".*>", content);

    assertHasRegexp("<input.*value=\"saveProperties\"", content);

    assertSubString("<input type=\"checkbox\" name=\"Test\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Search\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Edit\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Properties\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Suite\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Prune\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Versions\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"Refactor\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"WhereUsed\" checked=\"true\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"RecentChanges\" checked=\"true\"/>", content);

    assertSubString("<input type=\"checkbox\" name=\"" + WikiPage.SECURE_READ + "\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"" + WikiPage.SECURE_WRITE + "\"/>", content);
    assertSubString("<input type=\"checkbox\" name=\"" + WikiPage.SECURE_TEST + "\"/>", content);
  }
Esempio n. 24
0
  public Response makeResponse(FitNesseContext context, Request request) {
    response = new SimpleResponse();
    resource = request.getResource();
    path = PathParser.parse(resource);
    PageCrawler crawler = context.root.getPageCrawler();
    page = crawler.getPage(path, new MockingPageCrawler());
    if (page == null) return new NotFoundResponder().makeResponse(context, request);

    pageData = page.getData();
    makeContent(context, request);
    response.setMaxAge(0);
    return response;
  }
Esempio n. 25
0
  protected Response doMakeResponse(
      FitNesseContext context, Request request, boolean firstTimeForNewPage) throws Exception {
    initializeResponder(context.root, request);

    SimpleResponse response = new SimpleResponse();
    String resource = request.getResource();
    WikiPagePath path = PathParser.parse(resource);
    PageCrawler crawler = context.root.getPageCrawler();
    if (!crawler.pageExists(root, path)) {
      crawler.setDeadEndStrategy(new MockingPageCrawler());
      page = crawler.getPage(root, path);
    } else page = crawler.getPage(root, path);

    pageData = page.getData();
    content = createPageContent();

    String html = doMakeHtml(resource, context, firstTimeForNewPage);

    response.setContent(html);
    response.setMaxAge(0);

    return response;
  }
  public Response makeResponse(FitNesseContext context, Request request) throws Exception {
    response = new SimpleResponse();
    resource = request.getResource();
    path = PathParser.parse(resource);
    PageCrawler crawler = context.root.getPageCrawler();
    if (!crawler.pageExists(context.root, path))
      crawler.setDeadEndStrategy(new MockingPageCrawler());
    page = crawler.getPage(context.root, path);
    if (page == null) return new NotFoundResponder().makeResponse(context, request);

    pageData = page.getData();
    makeContent(context, request);
    response.setMaxAge(0);
    return response;
  }
  @Test
  public void testAttributeButtons() throws Exception {
    WikiPageUtil.addPage(root, PathParser.parse("NormalPage"), "");
    final WikiPage noButtonsPage = WikiPageUtil.addPage(root, PathParser.parse("NoButtonPage"), "");
    for (final String attribute : PageData.NON_SECURITY_ATTRIBUTES) {
      final PageData data = noButtonsPage.getData();
      data.removeAttribute(attribute);
      noButtonsPage.commit(data);
    }

    SimpleResponse response = requestPage("NormalPage");
    assertSubString(">Edit</a>", response.getContent());
    assertSubString(">Search</a>", response.getContent());
    assertSubString(">Versions</a>", response.getContent());
    assertNotSubString(">Suite</a>", response.getContent());
    assertNotSubString(">Test</a>", response.getContent());

    response = requestPage("NoButtonPage");
    assertNotSubString(">Edit</a>", response.getContent());
    assertNotSubString(">Search</a>", response.getContent());
    assertNotSubString(">Versions</a>", response.getContent());
    assertNotSubString(">Suite</a>", response.getContent());
    assertNotSubString(">Test</a>", response.getContent());
  }
Esempio n. 28
0
  private JSONObject makeJson() {
    response.setContentType("text/json");
    JSONObject jsonObject = new JSONObject();
    String attributes[] =
        new String[] {
          TEST.toString(),
          PropertySEARCH,
          PropertyEDIT,
          PropertyPROPERTIES,
          PropertyVERSIONS,
          PropertyREFACTOR,
          PropertyWHERE_USED,
          PropertyRECENT_CHANGES,
          SUITE.toString(),
          PropertyPRUNE,
          PropertySECURE_READ,
          PropertySECURE_WRITE,
          PropertySECURE_TEST
        };
    for (String attribute : attributes) addJsonAttribute(jsonObject, attribute);

    return jsonObject;
  }
 private Response makeResponse() {
   response.setContent(page.html());
   return response;
 }