Example usage for org.springframework.mock.web MockHttpServletRequest setParameter

List of usage examples for org.springframework.mock.web MockHttpServletRequest setParameter

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.mock.web.*
  5. MockHttpServletRequest
  6. setParameter

Introduction

In this page you can find the example usage for org.springframework.mock.web MockHttpServletRequest setParameter.

Prototype

public void setParameter(String name, String... values)

Source Link

Document

Set an array of values for the specified HTTP parameter.

Usage

From source file:org.jasig.cas.support.oauth.web.OAuth20AuthorizeCallbackActionControllerTests.java

@Test
public void verifyActionDenied() throws Exception {
    final MockHttpServletRequest mockRequest = new MockHttpServletRequest("GET",
            CONTEXT + OAuthConstants.CALLBACK_AUTHORIZE_ACTION_URL);
    final MockHttpSession mockSession = new MockHttpSession();
    mockSession.putValue(OAuthConstants.OAUTH20_RESPONSE_TYPE, RESPONSE_TYPE);
    mockSession.putValue(OAuthConstants.OAUTH20_CLIENT_ID, CLIENT_ID);
    mockSession.putValue(OAuthConstants.OAUTH20_STATE, STATE);
    mockSession.putValue(OAuthConstants.OAUTH20_REDIRECT_URI, REDIRECT_URI);
    mockSession.putValue(OAuthConstants.OAUTH20_TOKEN_TYPE, TokenType.OFFLINE);
    mockSession.putValue(OAuthConstants.OAUTH20_LOGIN_TICKET_ID, TICKET_GRANTING_TICKET_ID);
    mockSession.putValue(OAuthConstants.OAUTH20_SCOPE, SCOPE);
    mockRequest.setSession(mockSession);
    mockRequest.setParameter(OAuthConstants.OAUTH20_APPROVAL_PROMPT_ACTION, "deny");

    final MockHttpServletResponse mockResponse = new MockHttpServletResponse();

    final OAuth20WrapperController oauth20WrapperController = new OAuth20WrapperController();
    oauth20WrapperController.afterPropertiesSet();

    final ModelAndView modelAndView = oauth20WrapperController.handleRequest(mockRequest, mockResponse);
    assertTrue(modelAndView.getView() instanceof RedirectView);
    final RedirectView redirectView = (RedirectView) modelAndView.getView();
    assertTrue(redirectView.getUrl()/*from  www  .  j a  v  a  2  s . co m*/
            .endsWith(REDIRECT_URI + "?" + OAuthConstants.ERROR + "=" + OAuthConstants.ACCESS_DENIED));

    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_RESPONSE_TYPE));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_CLIENT_ID));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_STATE));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_REDIRECT_URI));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_TOKEN_TYPE));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_LOGIN_TICKET_ID));
    assertNull(mockSession.getAttribute(OAuthConstants.OAUTH20_SCOPE_SET));
}

From source file:com.gisgraphy.addressparser.web.AddressQueryHttpBuilderTest.java

@Test
public void buildStructuredFromRequest() {
    AddressQueryHttpBuilder builder = AddressQueryHttpBuilder.getInstance();
    MockHttpServletRequest request = new MockHttpServletRequest();
    AddressQuery query;/*from   www.  ja  va 2  s .  com*/
    //without parameters
    try {
        builder.buildFromRequest(request);
        Assert.fail("without parameters the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }
    //country
    //without country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    query = builder.buildFromRequest(request);
    Assert.assertNull("country parameter is not required", query.getCountry());
    Assert.assertEquals("address", query.getAddress());

    //with empty country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, " ");
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    query = builder.buildFromRequest(request);
    Assert.assertNull("with empty country equals to space, the builder should set countrycode to null",
            query.getCountry());
    Assert.assertEquals("address", query.getAddress());

    //with empty country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "");
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    query = builder.buildFromRequest(request);
    Assert.assertNull("with empty country , the builder should set countrycode to null", query.getCountry());
    Assert.assertEquals("address", query.getAddress());

    //address
    //without address
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "US");
    try {
        builder.buildFromRequest(request);
        Assert.fail("without address parameter or structured address the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }
    //with empty address
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, " ");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    try {
        builder.buildFromRequest(request);
        Assert.fail("with empty country equals to space, the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }

    //with empty country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    try {
        builder.buildFromRequest(request);
        Assert.fail("with empty string the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }

    //all ok
    request = new MockHttpServletRequest();
    String city = "city";
    String houseNumber = "1";
    String streetName = "california street";
    request.setParameter(city, city);
    request.setParameter("houseNumber", houseNumber);
    request.setParameter("streetName", streetName);
    request.setParameter("NotExistingFieldName", "foo");
    request.setParameter("country", "france");
    request.setParameter("zipcode", "");//empty paramter should be ignored
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    StructuredAddressQuery structuredquery = (StructuredAddressQuery) builder.buildFromRequest(request);
    Address address = structuredquery.getStructuredAddress();
    Assert.assertEquals("us", structuredquery.getCountry());
    Assert.assertEquals(city, address.getCity());
    Assert.assertEquals(houseNumber, address.getHouseNumber());
    Assert.assertEquals(streetName, address.getStreetName());
    Assert.assertNull("empty paramter should be ignored", address.getZipCode());
    Assert.assertNull(address.getCountry());

    // test outputFormat
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When no " + AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER
                    + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getFormat());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "UNK");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When wrong " + AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER
                    + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getFormat());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "json");
    query = builder.buildFromRequest(request);
    assertEquals(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER + " should be case insensitive  ",
            OutputFormat.JSON, query.getFormat());

    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "unsupported");
    query = builder.buildFromRequest(request);
    assertEquals(GisgraphyServlet.FORMAT_PARAMETER + " should set default if not supported  ",
            OutputFormat.getDefault(), query.getFormat());

    //test indent
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When no " + AbstractAddressServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default indentation",
            AddressQuery.DEFAULT_INDENTATION, query.isIndent());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When wrong " + AbstractAddressServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default value",
            AddressQuery.DEFAULT_INDENTATION, query.isIndent());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.INDENT_PARAMETER + " should be case insensitive  ", query.isIndent());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.INDENT_PARAMETER
            + " should be true for 'on' value (case insensitive and on value)  ", query.isIndent());

    //test postal
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertFalse("When no " + AbstractAddressServlet.POSTAL_PARAMETER
            + " is specified, the  parameter should be set to false", query.isPostal());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertFalse("When wrong " + AbstractAddressServlet.POSTAL_PARAMETER
            + " is specified, the  parameter should be set to false", query.isPostal());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.POSTAL_PARAMETER + " should be case insensitive  ", query.isPostal());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.POSTAL_PARAMETER
            + " should be true for 'on' value (case insensitive and on value)  ", query.isPostal());

    //test standardize
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertFalse("When no " + AbstractAddressServlet.STANDARDIZE_PARAMETER
            + " is specified, the  parameter should be set to false", query.isStandardize());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertFalse("When wrong " + AbstractAddressServlet.STANDARDIZE_PARAMETER
            + " is specified, the  parameter should be set to false", query.isStandardize());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.STANDARDIZE_PARAMETER + " should be case insensitive  ",
            query.isStandardize());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(
            AbstractAddressServlet.STANDARDIZE_PARAMETER
                    + " should be true for 'on' value (case insensitive and on value)  ",
            query.isStandardize());

    //callback not set
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertNull("callback should be null when not set", query.getCallback());

    //callback set with non alpha value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.CALLBACK_PARAMETER, "doit(");
    query = builder.buildFromRequest(request);
    assertNull("callback should not be set when not alphanumeric", query.getCallback());

    //callback set with alpha value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.CALLBACK_PARAMETER, "doit");
    query = builder.buildFromRequest(request);
    assertEquals("callback should not be set when alphanumeric", "doit", query.getCallback());

}

From source file:com.gisgraphy.addressparser.web.AddressQueryHttpBuilderTest.java

@Test
public void buildFromRequest() {
    AddressQueryHttpBuilder builder = AddressQueryHttpBuilder.getInstance();
    MockHttpServletRequest request = new MockHttpServletRequest();
    AddressQuery query;//w ww .  j  av  a2 s. com
    //without parameters
    try {
        builder.buildFromRequest(request);
        Assert.fail("without parameters the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }
    //country
    //without country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    query = builder.buildFromRequest(request);
    Assert.assertNull("country parameter is not required", query.getCountry());

    //with country=space
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, " ");
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    query = builder.buildFromRequest(request);
    Assert.assertNull("with empty country equals to space, the country should be considered as null",
            query.getCountry());

    //with empty country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "");
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    builder.buildFromRequest(request);
    Assert.assertNull("with empty country, the country should be considered as null", query.getCountry());

    //address
    //without address nor structured
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "US");
    try {
        builder.buildFromRequest(request);
        Assert.fail("without address parameter or structured the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }
    //with empty address, nor structured
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, " ");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    try {
        builder.buildFromRequest(request);
        Assert.fail("with empty country equals to space, the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }

    //with empty country
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, " ");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    try {
        builder.buildFromRequest(request);
        Assert.fail("with empty string the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }

    //with too long address
    request = new MockHttpServletRequest();
    String tooLongAddress = RandomStringUtils.random(AbstractAddressServlet.QUERY_MAX_LENGTH + 1);
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, tooLongAddress);
    try {
        builder.buildFromRequest(request);
        Assert.fail("with empty string the builder should throws");
    } catch (AddressParserException e) {
        //ignore
    }

    //all ok
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    Assert.assertEquals("address", query.getAddress());
    Assert.assertEquals("us", query.getCountry());

    // test outputFormat
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When no " + AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER
                    + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getFormat());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "UNK");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When wrong " + AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER
                    + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getFormat());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "json");
    query = builder.buildFromRequest(request);
    assertEquals(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER + " should be case insensitive  ",
            OutputFormat.JSON, query.getFormat());

    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.OUTPUT_FORMAT_PARAMETER, "unsupported");
    query = builder.buildFromRequest(request);
    assertEquals(GisgraphyServlet.FORMAT_PARAMETER + " should set default if not supported  ",
            OutputFormat.getDefault(), query.getFormat());

    //test indent
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When no " + AbstractAddressServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default indentation",
            AddressQuery.DEFAULT_INDENTATION, query.isIndent());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertEquals(
            "When wrong " + AbstractAddressServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default value",
            AddressQuery.DEFAULT_INDENTATION, query.isIndent());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.INDENT_PARAMETER + " should be case insensitive  ", query.isIndent());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.INDENT_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.INDENT_PARAMETER
            + " should be true for 'on' value (case insensitive and on value)  ", query.isIndent());

    //test postal
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertFalse("When no " + AbstractAddressServlet.POSTAL_PARAMETER
            + " is specified, the  parameter should be set to false", query.isPostal());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertFalse("When wrong " + AbstractAddressServlet.POSTAL_PARAMETER
            + " is specified, the  parameter should be set to false", query.isPostal());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.POSTAL_PARAMETER + " should be case insensitive  ", query.isPostal());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.POSTAL_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.POSTAL_PARAMETER
            + " should be true for 'on' value (case insensitive and on value)  ", query.isPostal());

    //test standardize
    // with no value specified
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertFalse("When no " + AbstractAddressServlet.STANDARDIZE_PARAMETER
            + " is specified, the  parameter should be set to false", query.isStandardize());
    // with wrong value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "unk");
    query = builder.buildFromRequest(request);
    assertFalse("When wrong " + AbstractAddressServlet.STANDARDIZE_PARAMETER
            + " is specified, the  parameter should be set to false", query.isStandardize());
    // test case sensitive
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "TrUe");
    query = builder.buildFromRequest(request);
    assertTrue(AbstractAddressServlet.STANDARDIZE_PARAMETER + " should be case insensitive  ",
            query.isStandardize());
    // test 'on' value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.STANDARDIZE_PARAMETER, "On");
    query = builder.buildFromRequest(request);
    assertTrue(
            AbstractAddressServlet.STANDARDIZE_PARAMETER
                    + " should be true for 'on' value (case insensitive and on value)  ",
            query.isStandardize());

    //callback not set
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    query = builder.buildFromRequest(request);
    assertNull("callback should be null when not set", query.getCallback());

    //callback set with non alpha value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.CALLBACK_PARAMETER, "doit(");
    query = builder.buildFromRequest(request);
    assertNull("callback should not be set when not alphanumeric", query.getCallback());

    //callback set with alpha value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.CALLBACK_PARAMETER, "doit");
    query = builder.buildFromRequest(request);
    assertEquals("callback should not be set when alphanumeric", "doit", query.getCallback());

    //callback set with alpha value
    request = new MockHttpServletRequest();
    request.setParameter(AbstractAddressServlet.ADDRESS_PARAMETER, "address");
    request.setParameter(AbstractAddressServlet.COUNTRY_PARAMETER, "us");
    request.setParameter(AbstractAddressServlet.APIKEY_PARAMETER, "apiKEY");
    query = builder.buildFromRequest(request);
    assertEquals("api key Should Be set", "apiKEY", query.getApikey());

}

From source file:com.alexshabanov.springrestapi.restapitest.RestOperationsTestClient.java

private MockHttpServletRequest toMockHttpServletRequest(URI url, HttpMethod method,
        ClientHttpRequest clientHttpRequest) throws IOException {
    final MockHttpServletRequest mockHttpServletRequest = new MockHttpServletRequest(method.name(),
            url.getPath());// w w  w .  java2 s  .  c o  m

    // copy headers
    final HttpHeaders headers = clientHttpRequest.getHeaders();
    for (final String headerKey : headers.toSingleValueMap().keySet()) {
        final List<String> headerValues = headers.get(headerKey);
        for (final String headerValue : headerValues) {
            mockHttpServletRequest.addHeader(headerKey, headerValue);
        }
    }

    // copy query parameters
    final String query = clientHttpRequest.getURI().getQuery();
    if (query != null) {
        mockHttpServletRequest.setQueryString(query);
        final String[] queryParameters = query.split("&");
        for (String keyValueParam : queryParameters) {
            final String[] components = keyValueParam.split("=");
            if (components.length == 1) {
                continue; // optional parameter
            }

            Assert.isTrue(components.length == 2,
                    "Can't split query parameters " + keyValueParam + " by key-value pair");
            mockHttpServletRequest.setParameter(components[0], components[1]);
        }
    }

    // copy request body
    // TODO: another byte copying approach here
    // TODO: for now we rely to the fact that request body is always presented as byte array output stream
    final OutputStream requestBodyStream = clientHttpRequest.getBody();
    if (requestBodyStream instanceof ByteArrayOutputStream) {
        mockHttpServletRequest.setContent(((ByteArrayOutputStream) requestBodyStream).toByteArray());
    } else {
        throw new AssertionError("Ooops, client http request has non-ByteArrayOutputStream body");
    }

    return mockHttpServletRequest;
}

From source file:com.gisgraphy.fulltext.FulltextQueryHttpBuilderTest.java

@Test
public void testFulltextQueryFromAnHttpServletRequest() {

    MockHttpServletRequest request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    FulltextQuery query = buildQuery(request);

    // test Point
    // with empty lat
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "");
    try {/*from   w w  w  .jav a2 s  .  c  o m*/
        query = buildQuery(request);
    } catch (RuntimeException e) {
        fail("When there is empty latitude, query should throw");
    }
    // With wrong lat
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "a");
    try {
        query = buildQuery(request);
        fail("A null lat should throw");
    } catch (RuntimeException e) {
    }
    // With too small lat
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "-92");
    try {
        query = buildQuery(request);
        fail("latitude should not accept latitude < -90");
    } catch (RuntimeException e) {
    }

    // With too high lat
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "92");
    try {
        query = buildQuery(request);
        fail("latitude should not accept latitude > 90");
    } catch (RuntimeException e) {
    }

    // with empty long
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "");
    try {
        query = buildQuery(request);
    } catch (RuntimeException e) {
        fail("When there is empty longitude, query should throw");
    }
    // With wrong Long
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "a");
    try {
        query = buildQuery(request);
        fail("A null lat should throw");
    } catch (RuntimeException e) {
    }

    // with too small long
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "-182");
    try {
        query = buildQuery(request);
        fail("longitude should not accept longitude < -180");
    } catch (RuntimeException e) {
    }

    // with too high long
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "182");
    try {
        query = buildQuery(request);
        fail("longitude should not accept longitude > 180");
    } catch (RuntimeException e) {
    }

    // with long with comma
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "10,3");
    try {
        query = buildQuery(request);
        Assert.assertEquals("request should accept longitude with comma", 10.3D,
                query.getLongitude().doubleValue(), 0.1);

    } catch (RuntimeException e) {
    }

    // with long with point
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LONG_PARAMETER, "10.3");
    try {
        query = buildQuery(request);
        Assert.assertEquals("request should accept longitude with comma", 10.3D,
                query.getLongitude().doubleValue(), 0.1);

    } catch (RuntimeException e) {
    }

    // with lat with comma
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "10,3");
    try {
        query = buildQuery(request);
        Assert.assertEquals("request should accept latitude with comma", 10.3D,
                query.getLatitude().doubleValue(), 0.1);

    } catch (RuntimeException e) {
    }

    // with lat with point
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LAT_PARAMETER, "10.3");
    try {
        query = buildQuery(request);
        Assert.assertEquals("request should accept latitude with point", 10.3D,
                query.getLatitude().doubleValue(), 0.1);

    } catch (RuntimeException e) {
    }

    // test radius
    // with missing radius
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.RADIUS_PARAMETER);
    query = buildQuery(request);
    assertEquals("When no " + FulltextQuery.RADIUS_PARAMETER
            + " is specified, the  parameter should be set to  " + FulltextQuery.DEFAULT_RADIUS,
            FulltextQuery.DEFAULT_RADIUS, query.getRadius(), 0.1);
    // With wrong radius
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.RADIUS_PARAMETER, "a");
    query = buildQuery(request);
    assertEquals("When wrong " + FulltextQuery.RADIUS_PARAMETER
            + " is specified, the  parameter should be set to  " + FulltextQuery.DEFAULT_RADIUS,
            FulltextQuery.DEFAULT_RADIUS, query.getRadius(), 0.1);
    // radius with comma
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.RADIUS_PARAMETER, "1,4");
    query = buildQuery(request);
    assertEquals("Radius should accept comma as decimal separator", 1.4D, query.getRadius(), 0.1);

    // radius with point
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.RADIUS_PARAMETER, "1.4");
    query = buildQuery(request);
    assertEquals("Radius should accept point as decimal separator", 1.4D, query.getRadius(), 0.1);

    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    query = buildQuery(request);
    int firstPaginationIndex = 3;
    assertEquals(firstPaginationIndex, query.getFirstPaginationIndex());
    assertEquals(DEFAULT_MAX_RESULTS + firstPaginationIndex - 1, query.getLastPaginationIndex());
    assertEquals("the pagination should be limit to " + DEFAULT_MAX_RESULTS, DEFAULT_MAX_RESULTS,
            query.getMaxNumberOfResults());
    assertEquals("FR", query.getCountryCode());
    assertEquals(OutputFormat.XML, query.getOutputFormat());
    assertEquals("FR", query.getOutputLanguage());
    assertEquals(OutputStyle.FULL, query.getOutputStyle());
    assertEquals(City.class, query.getPlaceTypes()[0]);
    assertEquals("query", query.getQuery());

    //test trim
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.FROM_PARAMETER,
            " " + request.getParameter(FulltextQuery.QUERY_PARAMETER) + " ");
    query = buildQuery(request);
    Assert.assertTrue("query parameter shoud be trimed", !query.getQuery().endsWith(" "));
    Assert.assertTrue("query parameter shoud be trimed", !query.getQuery().startsWith(" "));

    // test first pagination index
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextServlet.FROM_PARAMETER);
    query = buildQuery(request);
    assertEquals("When no " + FulltextServlet.FROM_PARAMETER + " is specified, the parameter should be "
            + Pagination.DEFAULT_FROM, Pagination.DEFAULT_FROM, query.getFirstPaginationIndex());
    // with a wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.FROM_PARAMETER, "-1");
    query = buildQuery(request);
    assertEquals("When a wrong " + FulltextServlet.FROM_PARAMETER + " is specified, the parameter should be "
            + Pagination.DEFAULT_FROM, Pagination.DEFAULT_FROM, query.getFirstPaginationIndex());
    // with a non mumeric value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.FROM_PARAMETER, "a");
    query = buildQuery(request);
    assertEquals("When a wrong " + FulltextServlet.FROM_PARAMETER + " is specified, the parameter should be "
            + Pagination.DEFAULT_FROM, Pagination.DEFAULT_FROM, query.getFirstPaginationIndex());

    // test last pagination index
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextServlet.TO_PARAMETER);
    query = buildQuery(request);
    int expectedLastPagination = (FulltextQuery.DEFAULT_NB_RESULTS + query.getFirstPaginationIndex() - 1);
    assertEquals(GisgraphyServlet.TO_PARAMETER + " is wrong when no " + GisgraphyServlet.TO_PARAMETER
            + " is specified ", expectedLastPagination, query.getLastPaginationIndex());

    // with too high value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextServlet.TO_PARAMETER);
    request.setParameter(FulltextServlet.TO_PARAMETER, "100");
    query = buildQuery(request);
    expectedLastPagination = (FulltextQuery.DEFAULT_MAX_RESULTS + query.getFirstPaginationIndex() - 1);
    assertEquals(GisgraphyServlet.TO_PARAMETER + " is too high, to should be limited ", expectedLastPagination,
            query.getLastPaginationIndex());
    assertEquals(
            "When no " + FulltextServlet.TO_PARAMETER
                    + " is specified, the  parameter should be set to limit results to "
                    + FulltextQuery.DEFAULT_MAX_RESULTS,
            FulltextQuery.DEFAULT_MAX_RESULTS, query.getMaxNumberOfResults());

    // with a wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.TO_PARAMETER, "2");// to<from
    query = buildQuery(request);
    expectedLastPagination = (FulltextQuery.DEFAULT_NB_RESULTS + query.getFirstPaginationIndex() - 1);
    assertEquals(GisgraphyServlet.TO_PARAMETER + " is wrong when wrong " + GisgraphyServlet.TO_PARAMETER
            + " is specified ", expectedLastPagination, query.getLastPaginationIndex());
    assertEquals(
            "When a wrong " + FulltextServlet.TO_PARAMETER
                    + " is specified, the number of results should be default nb results",
            FulltextQuery.DEFAULT_NB_RESULTS, query.getMaxNumberOfResults());
    assertEquals("a wrong to does not change the from value", 3, query.getFirstPaginationIndex());
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    //non numeric
    request.setParameter(FulltextServlet.TO_PARAMETER, "a");
    query = buildQuery(request);
    expectedLastPagination = (FulltextQuery.DEFAULT_NB_RESULTS + query.getFirstPaginationIndex() - 1);
    assertEquals(GisgraphyServlet.TO_PARAMETER + " is wrong when non numeric " + GisgraphyServlet.TO_PARAMETER
            + " is specified ", expectedLastPagination, query.getLastPaginationIndex());
    assertEquals("a wrong to does not change the from value", 3, query.getFirstPaginationIndex());
    assertEquals(
            "When a wrong " + FulltextServlet.TO_PARAMETER + " is specified, the numberOf results should be "
                    + FulltextQuery.DEFAULT_NB_RESULTS,
            FulltextQuery.DEFAULT_NB_RESULTS, query.getMaxNumberOfResults());

    // test countrycode
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.COUNTRY_PARAMETER);
    query = buildQuery(request);
    Assert.assertNull(
            "When no " + FulltextQuery.COUNTRY_PARAMETER + " is specified, the parameter should be set to null",
            query.getCountryCode());
    // with a wrong value
    // can not have a wrong value=>always a string

    // test outputFormat
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextServlet.FORMAT_PARAMETER);
    query = buildQuery(request);
    assertEquals("When no " + FulltextServlet.FORMAT_PARAMETER
            + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getOutputFormat());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.FORMAT_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals(
            "When wrong " + FulltextServlet.FORMAT_PARAMETER
                    + " is specified, the  parameter should be set to  " + OutputFormat.getDefault(),
            OutputFormat.getDefault(), query.getOutputFormat());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextServlet.FORMAT_PARAMETER, "json");
    query = buildQuery(request);
    assertEquals(FulltextServlet.FORMAT_PARAMETER + " should be case insensitive  ", OutputFormat.JSON,
            query.getOutputFormat());
    //with unsupported value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(GisgraphyServlet.FORMAT_PARAMETER, "unsupported");
    query = buildQuery(request);
    assertEquals(GisgraphyServlet.FORMAT_PARAMETER + " should set default if not supported  ",
            OutputFormat.getDefault(), query.getOutputFormat());
    // test language
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.LANG_PARAMETER);
    query = buildQuery(request);
    assertNull(FulltextQuery.LANG_PARAMETER + " should be null when not specified  ",
            query.getOutputLanguage());
    // with empty string
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LANG_PARAMETER, " ");
    query = buildQuery(request);
    assertEquals(FulltextQuery.LANG_PARAMETER + " should be null when not specified  ",
            Output.DEFAULT_LANGUAGE_CODE, query.getOutputLanguage());

    // test uppercase
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.LANG_PARAMETER, "fr");
    query = buildQuery(request);
    assertEquals(FulltextQuery.LANG_PARAMETER + " should be uppercase  ", "FR", query.getOutputLanguage());

    // test placetype
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.PLACETYPE_PARAMETER);
    query = buildQuery(request);
    assertNull("When no " + FulltextQuery.PLACETYPE_PARAMETER
            + " is specified, the  parameter should be set null ", query.getPlaceTypes());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.PLACETYPE_PARAMETER);
    request.setParameter(FulltextQuery.PLACETYPE_PARAMETER, "unk");
    query = buildQuery(request);
    assertNull("When wrong " + FulltextQuery.PLACETYPE_PARAMETER
            + " is specified, the  parameter should be set null ", query.getPlaceTypes()[0]);
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.PLACETYPE_PARAMETER, "ciTy");
    query = buildQuery(request);
    assertEquals(FulltextQuery.PLACETYPE_PARAMETER + " should be case insensitive  ", City.class,
            query.getPlaceTypes()[0]);

    // test with multipleplacetype
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.PLACETYPE_PARAMETER, new String[] { "city", "adm" });
    query = buildQuery(request);
    assertEquals(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ", 2,
            query.getPlaceTypes().length);
    List<Class<?>> placetypeList = Arrays.asList(query.getPlaceTypes());

    assertTrue(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ",
            placetypeList.contains(City.class));
    assertTrue(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ",
            placetypeList.contains(Adm.class));

    // test with multipleplacetype with wrong values
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.PLACETYPE_PARAMETER, new String[] { "city", "unk" });
    query = buildQuery(request);
    assertEquals(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ", 2,
            query.getPlaceTypes().length);
    placetypeList = Arrays.asList(query.getPlaceTypes());

    assertTrue(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ",
            placetypeList.contains(City.class));
    assertTrue(FulltextQuery.PLACETYPE_PARAMETER + " should accept several placetype  ",
            placetypeList.contains(null));

    // test output style
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.STYLE_PARAMETER);
    query = buildQuery(request);
    assertEquals("When no " + FulltextQuery.STYLE_PARAMETER + " is specified, the  parameter should be set to  "
            + OutputStyle.getDefault(), OutputStyle.getDefault(), query.getOutputStyle());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.STYLE_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals("When wrong " + FulltextQuery.STYLE_PARAMETER
            + " is specified, the  parameter should be set to  " + OutputStyle.getDefault(),
            OutputStyle.getDefault(), query.getOutputStyle());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.STYLE_PARAMETER, "medium");
    query = buildQuery(request);
    assertEquals(FulltextQuery.STYLE_PARAMETER + " should be case insensitive  ", OutputStyle.MEDIUM,
            query.getOutputStyle());

    // test indentation
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(GisgraphyServlet.INDENT_PARAMETER);
    query = buildQuery(request);
    assertEquals(
            "When no " + GisgraphyServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default",
            Output.DEFAULT_INDENTATION, query.isOutputIndented());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(GisgraphyServlet.INDENT_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals(
            "When wrong " + GisgraphyServlet.INDENT_PARAMETER
                    + " is specified, the  parameter should be set to default",
            Output.DEFAULT_INDENTATION, query.isOutputIndented());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(GisgraphyServlet.INDENT_PARAMETER, "True");
    query = buildQuery(request);
    assertTrue(GisgraphyServlet.INDENT_PARAMETER + " should be case insensitive  ", query.isOutputIndented());
    // test with on value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(GisgraphyServlet.INDENT_PARAMETER, "oN");
    query = buildQuery(request);
    assertTrue(
            GisgraphyServlet.INDENT_PARAMETER
                    + " should be true for 'on' value (case insensitive and on value)  ",
            query.isOutputIndented());

    // test suggest
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.SUGGEST_PARAMETER);
    query = buildQuery(request);
    assertEquals("When no " + FulltextQuery.SUGGEST_PARAMETER
            + " is specified, the  parameter should be set to default", false, query.isSuggest());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.SUGGEST_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals("When wrong " + FulltextQuery.SUGGEST_PARAMETER
            + " is specified, the  parameter should be set to default", false, query.isSuggest());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.SUGGEST_PARAMETER, "True");
    query = buildQuery(request);
    assertTrue(FulltextQuery.SUGGEST_PARAMETER + " should be case insensitive  ", query.isSuggest());
    // test with on value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.SUGGEST_PARAMETER, "oN");
    query = buildQuery(request);
    assertTrue(FulltextQuery.SUGGEST_PARAMETER
            + " should be true for 'on' value (case insensitive and on value)  ", query.isSuggest());

    // test allwordsRequired
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.ALLWORDSREQUIRED_PARAMETER);
    query = buildQuery(request);
    assertEquals(
            "When no " + FulltextQuery.ALLWORDSREQUIRED_PARAMETER
                    + " is specified, the  parameter should be set to default",
            FulltextQuery.ALL_WORDS_REQUIRED_DEFAULT_OPTION, query.isAllwordsRequired());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.ALLWORDSREQUIRED_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals(
            "When wrong " + FulltextQuery.ALLWORDSREQUIRED_PARAMETER
                    + " is specified, the  parameter should be set to default",
            FulltextQuery.ALL_WORDS_REQUIRED_DEFAULT_OPTION, query.isAllwordsRequired());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.ALLWORDSREQUIRED_PARAMETER, "False");
    query = buildQuery(request);
    assertFalse(FulltextQuery.ALLWORDSREQUIRED_PARAMETER + " should be case insensitive  ",
            query.isAllwordsRequired());
    // test with on value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.ALLWORDSREQUIRED_PARAMETER, "oN");
    query = buildQuery(request);
    assertTrue(
            FulltextQuery.ALLWORDSREQUIRED_PARAMETER
                    + " should be true for 'on' value (case insensitive and on value)  ",
            query.isAllwordsRequired());

    // test spellchecking
    // with no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.SPELLCHECKING_PARAMETER);
    query = buildQuery(request);
    assertEquals(
            "When no " + FulltextQuery.SPELLCHECKING_PARAMETER
                    + " is specified, the  parameter should be the default one",
            SpellCheckerConfig.activeByDefault, query.hasSpellChecking());
    // with wrong value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.SPELLCHECKING_PARAMETER, "UNK");
    query = buildQuery(request);
    assertEquals(
            "When wrong " + FulltextQuery.SPELLCHECKING_PARAMETER
                    + " is specified, the  parameter should be set to the default one",
            SpellCheckerConfig.activeByDefault, query.hasSpellChecking());
    // test case sensitive
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.SPELLCHECKING_PARAMETER,
            String.valueOf(!SpellCheckerConfig.activeByDefault).toUpperCase());
    query = buildQuery(request);
    assertEquals(FulltextQuery.SPELLCHECKING_PARAMETER + " should be case insensitive  ",
            !SpellCheckerConfig.activeByDefault, query.hasSpellChecking());
    // test with on value

    boolean savedSpellCheckingValue = SpellCheckerConfig.activeByDefault;
    try {
        SpellCheckerConfig.activeByDefault = false;
        request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
        request.setParameter(FulltextQuery.SPELLCHECKING_PARAMETER, "oN");
        query = buildQuery(request);
        assertTrue(
                FulltextQuery.SPELLCHECKING_PARAMETER
                        + " should be true for 'on' value (case insensitive and on value)  ",
                query.hasSpellChecking());
    } catch (RuntimeException e) {
        Assert.fail(e.getMessage());
    } finally {
        //reset the last value
        SpellCheckerConfig.activeByDefault = savedSpellCheckingValue;
    }

    //apiKey
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(GisgraphyServlet.APIKEY_PARAMETER, "apiKey");
    query = buildQuery(request);
    Assert.assertEquals("apiKey", query.getApikey());

    // test query
    //test with good value
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    query = buildQuery(request);
    assertEquals("query should be set when specified", request.getParameter(FulltextQuery.QUERY_PARAMETER),
            query.getQuery());

    // With no value specified
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.removeParameter(FulltextQuery.QUERY_PARAMETER);
    try {
        query = buildQuery(request);
        fail("A null query should throw");
    } catch (RuntimeException e) {
    }
    // empty string
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.QUERY_PARAMETER, " ");
    try {
        query = buildQuery(request);
        fail("An empty query should throw");
    } catch (RuntimeException e) {
    }
    // too long string
    request = GisgraphyTestHelper.createMockHttpServletRequestForFullText();
    request.setParameter(FulltextQuery.QUERY_PARAMETER,
            RandomStringUtils.random(FulltextQuery.QUERY_MAX_LENGTH) + 1);
    try {
        query = buildQuery(request);
        fail("query must have a maximmum length of " + FulltextQuery.QUERY_MAX_LENGTH);
    } catch (RuntimeException e) {
    }

}

From source file:org.openmrs.web.controller.ConceptFormControllerTest.java

/**
 * Checks that the conceptId query param gets a concept from the database
 * /*  ww  w. j av a  2  s .c  o m*/
 * @throws Exception
 */
@Test
public void shouldGetConcept() throws Exception {

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "");
    request.setParameter("conceptId", "3");

    HttpServletResponse response = new MockHttpServletResponse();

    ConceptFormController controller = (ConceptFormController) applicationContext.getBean("conceptForm");

    ModelAndView modelAndView = controller.handleRequest(request, response);

    // make sure there is an "conceptId" filled in on the concept
    ConceptFormBackingObject command = (ConceptFormBackingObject) modelAndView.getModel().get("command");
    Assert.assertNotNull(command.getConcept().getConceptId());

}

From source file:org.openmrs.module.htmlformentry19ext.IntegrationTest.java

@Test
public void encounterProviderAndRole_testRemovingProviderFromEncounter() throws Exception {
    final Date date = new Date();
    new RegressionTestHelper() {

        @Override/* ww  w  . j a v a 2  s . co  m*/
        protected String getXmlDatasetPath() {
            return "org/openmrs/module/htmlformentry19ext/include/";
        }

        @Override
        public String getFormName() {
            return "specifyingEncounterRoleTwiceWithSameRole";
        }

        @Override
        public String[] widgetLabels() {
            return new String[] { "Date:", "Location:", "Doctors:", "Doctors:!!1" };
        }

        @Override
        public void setupRequest(MockHttpServletRequest request, Map<String, String> widgets) {

            // first set two providers
            request.addParameter(widgets.get("Date:"), dateAsString(date));
            request.addParameter(widgets.get("Location:"), "2");
            request.addParameter(widgets.get("Doctors:"), "2"); // Doctor Bob
            request.addParameter(widgets.get("Doctors:!!1"), "1"); // Superuser

        }

        @Override
        public boolean doEditEncounter() {
            return true;
        }

        @Override
        public String[] widgetLabelsForEdit() {
            return new String[] { "Date:", "Location:", "Doctors:", "Doctors:!!1" };
        }

        @Override
        public void setupEditRequest(MockHttpServletRequest request, Map<String, String> widgets) {
            // now, in the edit request, only set a single provider
            request.setParameter(widgets.get("Doctors:"), "1"); // Superuser
            request.setParameter(widgets.get("Doctors:!!1"), ""); // set the second doctor field blank
        }

        @Override
        public void testEditedResults(SubmissionResults results) {
            results.assertNoErrors();
            results.assertLocation(2);

            Map<EncounterRole, Set<Provider>> byRoles = results.getEncounterCreated().getProvidersByRoles();
            Assert.assertEquals(1, byRoles.size());

            Set<Provider> doctors = byRoles.get(Context.getEncounterService().getEncounterRole(3));
            Assert.assertEquals(1, doctors.size());

            Assert.assertEquals(1, doctors.size());
            Assert.assertEquals(new Integer(1), doctors.iterator().next().getId());
        }
    }.run();
}

From source file:org.openmrs.web.controller.ConceptFormControllerTest.java

/**
 * @see ConceptFormController#onSubmit(HttpServletRequest,HttpServletResponse,Object,BindException)
 * @verifies not save changes if there are validation errors
 *//* w  w w. jav  a  2  s.  c  o m*/
@Test
public void onSubmit_shouldNotSaveChangesIfThereAreValidationErrors() throws Exception {
    Integer conceptId = 792;

    MockHttpServletRequest request = new MockHttpServletRequest("POST", "/dictionary/concept.form");
    request.setParameter("conceptId", conceptId.toString());
    request.setParameter("namesByLocale[en_GB].name", "should not change");
    request.setParameter("preferredNamesByLocale[en_GB]", "should not change");
    request.setParameter("synonymsByLocale[en_GB][1].name", ""); //empty name is invalid
    request.setParameter("synonymsByLocale[en_GB][1].voided", "false");

    Response response = webTestHelper.handle(request);
    assertThat(response.getErrors().hasFieldErrors("synonymsByLocale[en_GB][1].name"), is(true));

    Context.clearSession();

    Concept concept = conceptService.getConcept(conceptId);
    assertThat(concept.getPreferredName(britishEn).getName(), is("STAVUDINE LAMIVUDINE AND NEVIRAPINE"));
}

From source file:org.openmrs.web.controller.ConceptFormControllerTest.java

/**
 * @see ConceptFormController#onSubmit(HttpServletRequest,HttpServletResponse,Object,BindException)
 *//*from  w w w  . j a  v  a 2 s.c om*/
@Test
@Verifies(value = "should return a concept with a null id if no match is found", method = "onSubmit(HttpServletRequest,HttpServletResponse,Object,BindException)")
public void onSubmit_shouldReturnAConceptWithANullIdIfNoMatchIsFound() throws Exception {

    ConceptFormController conceptFormController = (ConceptFormController) applicationContext
            .getBean("conceptForm");
    MockHttpServletRequest mockRequest = new MockHttpServletRequest();
    mockRequest.setMethod("GET");
    mockRequest.setParameter("conceptId", "57432223");
    ModelAndView mav = conceptFormController.handleRequest(mockRequest, new MockHttpServletResponse());
    assertNotNull(mav);
    ConceptFormBackingObject formBackingObject = (ConceptFormBackingObject) mav.getModel().get("command");
    assertNotNull(formBackingObject.getConcept());
    assertNull(formBackingObject.getConcept().getConceptId());
}