@Test
public void cacheControl() {
String cacheControl = "no-cache";
headers.setCacheControl(cacheControl);
assertEquals("Invalid Cache-Control header", cacheControl, headers.getCacheControl());
assertEquals("Invalid Cache-Control header", "no-cache", headers.getFirst("cache-control"));
}
@Test
public void pragma() {
String pragma = "no-cache";
headers.setPragma(pragma);
assertEquals("Invalid Pragma header", pragma, headers.getPragma());
assertEquals("Invalid Pragma header", "no-cache", headers.getFirst("pragma"));
}
@Test
public void ifNoneMatch() {
String ifNoneMatch = "\"v2.6\"";
headers.setIfNoneMatch(ifNoneMatch);
assertEquals("Invalid If-None-Match header", ifNoneMatch, headers.getIfNoneMatch().get(0));
assertEquals("Invalid If-None-Match header", "\"v2.6\"", headers.getFirst("If-None-Match"));
}
@RequestMapping("/{userPseudo}/validateStep4")
public ResponseEntity<Void> validateStep4(
@PathVariable("userPseudo") String userPseudo,
@RequestParam("userHostAndPort") String userHostAndPort) {
log.info("Validation step 4 for player {} with data {}", userPseudo, userHostAndPort);
ResponseEntity<Void> result = new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
String url = "http://" + userHostAndPort + "/zen/env";
ResponseEntity<String> responseEntityShouldFail =
restTemplate.exchange(
url, HttpMethod.GET, new HttpEntity<>(new HttpHeaders()), String.class);
byte[] encodedAuth = Base64.encodeBase64("zenika:technozaure".getBytes());
String authHeader = "Basic " + new String(encodedAuth);
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
headers.set("Authorization", authHeader);
HttpEntity<String> entity = new HttpEntity<>(headers);
ResponseEntity<String> responseEntityShouldSucceed =
restTemplate.exchange(url, HttpMethod.GET, entity, String.class);
if (responseEntityShouldFail.getStatusCode() != HttpStatus.OK
&& responseEntityShouldSucceed.getStatusCode() == HttpStatus.OK) {
gameStepRepository.save(new GameStep(userPseudo, Step._4));
result = new ResponseEntity<Void>(HttpStatus.OK);
broadcastGameStatus();
}
return result;
}
@Test
public void allow() {
EnumSet<HttpMethod> methods = EnumSet.of(HttpMethod.GET, HttpMethod.POST);
headers.setAllow(methods);
assertEquals("Invalid Allow header", methods, headers.getAllow());
assertEquals("Invalid Allow header", "GET,POST", headers.getFirst("Allow"));
}
@Test
public void eTag() {
String eTag = "\"v2.6\"";
headers.setETag(eTag);
assertEquals("Invalid ETag header", eTag, headers.getETag());
assertEquals("Invalid ETag header", "\"v2.6\"", headers.getFirst("ETag"));
}
@Test(expected = IllegalArgumentException.class)
public void illegalETag() {
String eTag = "v2.6";
headers.setETag(eTag);
assertEquals("Invalid ETag header", eTag, headers.getETag());
assertEquals("Invalid ETag header", "\"v2.6\"", headers.getFirst("ETag"));
}
@Test
public void contentLength() {
long length = 42L;
headers.setContentLength(length);
assertEquals("Invalid Content-Length header", length, headers.getContentLength());
assertEquals("Invalid Content-Length header", "42", headers.getFirst("Content-Length"));
}
/**
* Generate http request entity from Spring Integration message.
*
* @param requestMessage
* @param method
* @return
*/
private HttpEntity<?> generateRequest(Message<?> requestMessage, HttpMethod method) {
HttpHeaders httpHeaders = new HttpHeaders();
headerMapper.fromHeaders(requestMessage.getHeaders(), httpHeaders);
Map<String, ?> messageHeaders = requestMessage.getHeaders();
for (Entry<String, ?> header : messageHeaders.entrySet()) {
if (!header.getKey().startsWith(CitrusMessageHeaders.PREFIX)
&& !MessageUtils.isSpringInternalHeader(header.getKey())
&& !httpHeaders.containsKey(header.getKey())) {
httpHeaders.add(header.getKey(), header.getValue().toString());
}
}
Object payload = requestMessage.getPayload();
if (httpHeaders.getContentType() == null) {
httpHeaders.setContentType(
MediaType.parseMediaType(
contentType.contains("charset") ? contentType : contentType + ";charset=" + charset));
}
if (HttpMethod.POST.equals(method) || HttpMethod.PUT.equals(method)) {
return new HttpEntity<Object>(payload, httpHeaders);
}
return new HttpEntity<Object>(httpHeaders);
}
@Test
public void acceptCharsetWildcard() {
headers.set("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
assertEquals(
"Invalid Accept header",
Arrays.asList(Charset.forName("ISO-8859-1"), Charset.forName("UTF-8")),
headers.getAcceptCharset());
}
@Test
public void location() throws URISyntaxException {
URI location = new URI("http://www.example.com/hotels");
headers.setLocation(location);
assertEquals("Invalid Location header", location, headers.getLocation());
assertEquals(
"Invalid Location header", "http://www.example.com/hotels", headers.getFirst("Location"));
}
@Test
public void contentType() {
MediaType contentType = new MediaType("text", "html", Charset.forName("UTF-8"));
headers.setContentType(contentType);
assertEquals("Invalid Content-Type header", contentType, headers.getContentType());
assertEquals(
"Invalid Content-Type header", "text/html;charset=UTF-8", headers.getFirst("Content-Type"));
}
@Test
public void accessControlRequestHeaders() {
List<String> requestHeaders = headers.getAccessControlRequestHeaders();
assertThat(requestHeaders, Matchers.emptyCollectionOf(String.class));
headers.setAccessControlRequestHeaders(Arrays.asList("header1", "header2"));
requestHeaders = headers.getAccessControlRequestHeaders();
assertEquals(requestHeaders, Arrays.asList("header1", "header2"));
}
@Test
public void accessControlAllowMethods() {
List<HttpMethod> allowedMethods = headers.getAccessControlAllowMethods();
assertThat(allowedMethods, Matchers.emptyCollectionOf(HttpMethod.class));
headers.setAccessControlAllowMethods(Arrays.asList(HttpMethod.GET, HttpMethod.POST));
allowedMethods = headers.getAccessControlAllowMethods();
assertEquals(allowedMethods, Arrays.asList(HttpMethod.GET, HttpMethod.POST));
}
@Test
public void accessControlAllowCredentials() {
assertFalse(headers.getAccessControlAllowCredentials());
headers.setAccessControlAllowCredentials(false);
assertFalse(headers.getAccessControlAllowCredentials());
headers.setAccessControlAllowCredentials(true);
assertTrue(headers.getAccessControlAllowCredentials());
}
/** @return return a clone HttpHeader from default HttpHeader */
private HttpHeaders cloneHttpHeaders() {
HttpHeaders httpHeaders = getHttpHeaders();
HttpHeaders clone = new HttpHeaders();
for (String entry : httpHeaders.keySet()) {
clone.put(entry, httpHeaders.get(entry));
}
return clone;
}
@Test
public void acceptiPlanet() {
headers.add("Accept", "text/html");
headers.add("Accept", "text/plain");
List<MediaType> expected =
Arrays.asList(new MediaType("text", "html"), new MediaType("text", "plain"));
assertEquals("Invalid Accept header", expected, headers.getAccept());
}
@Test
public void expires() {
Calendar calendar = new GregorianCalendar(2008, 11, 18, 11, 20);
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setExpires(date);
assertEquals("Invalid Expires header", date, headers.getExpires());
assertEquals(
"Invalid Expires header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("expires"));
}
@Test
public void acceptCharsets() {
Charset charset1 = Charset.forName("UTF-8");
Charset charset2 = Charset.forName("ISO-8859-1");
List<Charset> charsets = new ArrayList<Charset>(2);
charsets.add(charset1);
charsets.add(charset2);
headers.setAcceptCharset(charsets);
assertEquals("Invalid Accept header", charsets, headers.getAcceptCharset());
assertEquals("Invalid Accept header", "utf-8, iso-8859-1", headers.getFirst("Accept-Charset"));
}
@Test
public void accept() {
MediaType mediaType1 = new MediaType("text", "html");
MediaType mediaType2 = new MediaType("text", "plain");
List<MediaType> mediaTypes = new ArrayList<MediaType>(2);
mediaTypes.add(mediaType1);
mediaTypes.add(mediaType2);
headers.setAccept(mediaTypes);
assertEquals("Invalid Accept header", mediaTypes, headers.getAccept());
assertEquals("Invalid Accept header", "text/html, text/plain", headers.getFirst("Accept"));
}
@Test
public void ifNoneMatchList() {
String ifNoneMatch1 = "\"v2.6\"";
String ifNoneMatch2 = "\"v2.7\"";
List<String> ifNoneMatchList = new ArrayList<String>(2);
ifNoneMatchList.add(ifNoneMatch1);
ifNoneMatchList.add(ifNoneMatch2);
headers.setIfNoneMatch(ifNoneMatchList);
assertEquals("Invalid If-None-Match header", ifNoneMatchList, headers.getIfNoneMatch());
assertEquals(
"Invalid If-None-Match header", "\"v2.6\", \"v2.7\"", headers.getFirst("If-None-Match"));
}
@Test
public void lastModified() {
Calendar calendar = new GregorianCalendar(2008, 11, 18, 11, 20);
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setLastModified(date);
assertEquals("Invalid Last-Modified header", date, headers.getLastModified());
assertEquals(
"Invalid Last-Modified header",
"Thu, 18 Dec 2008 10:20:00 GMT",
headers.getFirst("last-modified"));
}
@Test
public void ifModifiedSince() {
Calendar calendar = new GregorianCalendar(2008, 11, 18, 11, 20);
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setIfModifiedSince(date);
assertEquals("Invalid If-Modified-Since header", date, headers.getIfNotModifiedSince());
assertEquals(
"Invalid If-Modified-Since header",
"Thu, 18 Dec 2008 10:20:00 GMT",
headers.getFirst("if-modified-since"));
}
@GET
@Path("/get2/{tt}")
public void get1(@Context HttpHeaders hh) {
MultivaluedMap<String, String> headerParams = hh.getRequestHeaders();
Map<String, Cookie> cookieMap = hh.getCookies();
for (Map.Entry<String, List<String>> entry : headerParams.entrySet()) {
System.out.printf(
"headers + " + entry.getKey() + "value" + Arrays.toString(entry.getValue().toArray()));
}
for (Map.Entry<String, Cookie> entry : cookieMap.entrySet()) {
System.out.printf("cokie key " + entry.getKey() + entry.getValue().getPath());
}
}
@Test
public void date() {
Calendar calendar = new GregorianCalendar(2008, 11, 18, 11, 20);
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setDate(date);
assertEquals("Invalid Date header", date, headers.getDate());
assertEquals("Invalid Date header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("date"));
// RFC 850
headers.set("Date", "Thursday, 18-Dec-08 11:20:00 CET");
assertEquals("Invalid Date header", date, headers.getDate());
}
@Test
public void contentDisposition() {
headers.setContentDispositionFormData("name", null);
assertEquals(
"Invalid Content-Disposition header",
"form-data; name=\"name\"",
headers.getFirst("Content-Disposition"));
headers.setContentDispositionFormData("name", "filename");
assertEquals(
"Invalid Content-Disposition header",
"form-data; name=\"name\"; filename=\"filename\"",
headers.getFirst("Content-Disposition"));
}
/**
* Retrieve the attribute of an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributeName the attribute name
* @return
*/
public ListenableFuture<String> getAttributeValueAsString(
String entityId, String type, String attributeName) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}/attrs/{attributeName}/value");
addParam(builder, "type", type);
HttpHeaders httpHeaders = cloneHttpHeaders();
httpHeaders.setAccept(Collections.singletonList(MediaType.TEXT_PLAIN));
return adapt(
request(
HttpMethod.GET,
builder.buildAndExpand(entityId, attributeName).toUriString(),
httpHeaders,
null,
String.class));
}
public List<Trainee> getTrainees() {
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
headers.add("X-Parse-Application-Id", "EobLmBPuMPa7y2eZ5yt4ELaWEeEJUprGKrx78zDz");
headers.add("X-Parse-REST-API-Key", "EnT6MvmYC5cK6lH6iBZ0eu3AcBUm5npvdlkdZYxV");
HttpEntity<String> entity = new HttpEntity<String>("parameters", headers);
final String uri = "https://api.parse.com/1/classes/Trainee";
ResponseEntity<TraineeList> trainees =
restTemplate.exchange(uri, HttpMethod.GET, entity, TraineeList.class);
return trainees.getBody().getTrainees();
}
private HttpEntity<?> createHttpEntity(Object document) {
if (document instanceof HttpEntity) {
HttpEntity httpEntity = (HttpEntity) document;
Assert.isTrue(
httpEntity.getHeaders().getContentType().equals(MediaType.APPLICATION_JSON),
"HttpEntity payload with non application/json content type found.");
return httpEntity;
}
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<Object> httpEntity = new HttpEntity<Object>(document, httpHeaders);
return httpEntity;
}
@Test
public void dateOtherLocale() {
Locale defaultLocale = Locale.getDefault();
try {
Locale.setDefault(new Locale("nl", "nl"));
Calendar calendar = new GregorianCalendar(2008, 11, 18, 11, 20);
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setDate(date);
assertEquals(
"Invalid Date header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("date"));
assertEquals("Invalid Date header", date, headers.getDate());
} finally {
Locale.setDefault(defaultLocale);
}
}
