@Test
public void testStatusUpdatingMessageHandler() {
TimelineOperations timelineOperations = Mockito.mock(TimelineOperations.class);
Mockito.when(this.twitter.timelineOperations()).thenReturn(timelineOperations);
ArgumentCaptor<TweetData> argument = ArgumentCaptor.forClass(TweetData.class);
this.in1.send(new GenericMessage<String>("foo"));
Mockito.verify(timelineOperations).updateStatus(argument.capture());
assertEquals("foo", argument.getValue().toRequestParameters().getFirst("status"));
Mockito.reset(timelineOperations);
ClassPathResource media = new ClassPathResource("log4j.properties");
this.in2.send(
MessageBuilder.withPayload(Collections.singletonMap("foo", "bar"))
.setHeader("media", media)
.build());
Mockito.verify(timelineOperations).updateStatus(argument.capture());
TweetData tweetData = argument.getValue();
MultiValueMap<String, Object> requestParameters = tweetData.toRequestParameters();
assertEquals("bar", requestParameters.getFirst("status"));
assertNull(requestParameters.getFirst("media"));
MultiValueMap<String, Object> uploadMediaParameters = tweetData.toUploadMediaParameters();
assertEquals(media, uploadMediaParameters.getFirst("media"));
}
@Test
public void parseMatrixVariablesString() {
MultiValueMap<String, String> variables;
variables = WebUtils.parseMatrixVariables(null);
assertEquals(0, variables.size());
variables = WebUtils.parseMatrixVariables("year");
assertEquals(1, variables.size());
assertEquals("", variables.getFirst("year"));
variables = WebUtils.parseMatrixVariables("year=2012");
assertEquals(1, variables.size());
assertEquals("2012", variables.getFirst("year"));
variables = WebUtils.parseMatrixVariables("year=2012;colors=red,blue,green");
assertEquals(2, variables.size());
assertEquals(Arrays.asList("red", "blue", "green"), variables.get("colors"));
assertEquals("2012", variables.getFirst("year"));
variables = WebUtils.parseMatrixVariables(";year=2012;colors=red,blue,green;");
assertEquals(2, variables.size());
assertEquals(Arrays.asList("red", "blue", "green"), variables.get("colors"));
assertEquals("2012", variables.getFirst("year"));
variables = WebUtils.parseMatrixVariables("colors=red;colors=blue;colors=green");
assertEquals(1, variables.size());
assertEquals(Arrays.asList("red", "blue", "green"), variables.get("colors"));
}
private void saveConditionalURIs(String hash, MultiValueMap<String, String> params) {
logger.info("Iterating through conditional params (if there are)");
String ifurl = "ifurl";
String expr = "expr";
int paramn = 1;
String firstparam = ifurl + paramn;
String secondparam = expr + paramn;
while ((params.getFirst(firstparam) != null && params.getFirst(secondparam) != null)
&& (!params.getFirst(firstparam).equals("") && !params.getFirst(secondparam).equals(""))) {
logger.info(
"Seeking url&expression -- "
+ firstparam
+ params.getFirst(firstparam)
+ secondparam
+ params.getFirst(secondparam));
MultiplesURIs mu =
new MultiplesURIs(hash, params.getFirst(firstparam), params.getFirst(secondparam));
multiplesURIsRepository.save(mu);
paramn++;
firstparam = ifurl + paramn;
secondparam = expr + paramn;
}
logger.info("Already cicled around " + paramn + " conditional params");
}
@Test
public void testImplicitGrant() throws Exception {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
LinkedMultiValueMap<String, String> postBody = new LinkedMultiValueMap<>();
postBody.add("client_id", "cf");
postBody.add("redirect_uri", "https://uaa.cloudfoundry.com/redirect/cf");
postBody.add("response_type", "token id_token");
postBody.add("source", "credentials");
postBody.add("username", user.getUserName());
postBody.add("password", secret);
ResponseEntity<Void> responseEntity =
restOperations.exchange(
loginUrl + "/oauth/authorize",
HttpMethod.POST,
new HttpEntity<>(postBody, headers),
Void.class);
Assert.assertEquals(HttpStatus.FOUND, responseEntity.getStatusCode());
UriComponents locationComponents =
UriComponentsBuilder.fromUri(responseEntity.getHeaders().getLocation()).build();
Assert.assertEquals("uaa.cloudfoundry.com", locationComponents.getHost());
Assert.assertEquals("/redirect/cf", locationComponents.getPath());
MultiValueMap<String, String> params = parseFragmentParams(locationComponents);
Assert.assertThat(params.get("jti"), not(empty()));
Assert.assertEquals("bearer", params.getFirst("token_type"));
Assert.assertThat(Integer.parseInt(params.getFirst("expires_in")), Matchers.greaterThan(40000));
String[] scopes = UriUtils.decode(params.getFirst("scope"), "UTF-8").split(" ");
Assert.assertThat(
Arrays.asList(scopes),
containsInAnyOrder(
"scim.userids",
"password.write",
"cloud_controller.write",
"openid",
"cloud_controller.read",
"uaa.user"));
validateToken("access_token", params.toSingleValueMap(), scopes, aud);
validateToken("id_token", params.toSingleValueMap(), openid, new String[] {"cf"});
}
@RequestMapping(
value = "/headers/{headerKey:.+}",
method = RequestMethod.GET,
produces = {MediaType.APPLICATION_JSON_VALUE})
public String getFirstHeader(
@PathVariable("headerKey") String headerKey,
@RequestHeader MultiValueMap<String, String> headers) {
return headers.getFirst(headerKey);
}
@Test
public void resolveArgumentRawTypeFromParameterizedType() throws Exception {
String content = "fruit=apple&vegetable=kale";
this.servletRequest.setContent(content.getBytes("UTF-8"));
this.servletRequest.setContentType(MediaType.APPLICATION_FORM_URLENCODED_VALUE);
List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
converters.add(new AllEncompassingFormHttpMessageConverter());
RequestResponseBodyMethodProcessor processor =
new RequestResponseBodyMethodProcessor(converters);
@SuppressWarnings("unchecked")
MultiValueMap<String, String> result =
(MultiValueMap<String, String>)
processor.resolveArgument(paramMultiValueMap, mavContainer, webRequest, binderFactory);
assertNotNull(result);
assertEquals("apple", result.getFirst("fruit"));
assertEquals("kale", result.getFirst("vegetable"));
}
/**
* 根据规则名获取规则实例 <功能详细描述>
*
* @param rule
* @return [参数说明]
* @return Rule [返回类型说明]
* @exception throws [异常类型] [异常说明]
* @see [类、类#方法、类#成员]
*/
public Rule getRule(String rule) {
waitLoading();
if (ruleKeyMapCache.containsKey(rule)) {
return ruleKeyMapCache.get(rule);
} else if (multiRuleMapCache.containsKey(rule)) {
if (multiRuleMapCache.get(rule) != null && multiRuleMapCache.get(rule).size() > 1) {
throw new RuleAccessException(rule, null, null, "未带业务类型（命名空间）的规则，检索到超过多个规则:{}", rule);
} else {
return multiRuleMapCache.getFirst(rule);
}
} else {
return null;
}
}
protected final String getCallbackParam(ServerHttpRequest request) {
String query = request.getURI().getQuery();
MultiValueMap<String, String> params =
UriComponentsBuilder.newInstance().query(query).build().getQueryParams();
String value = params.getFirst("c");
if (StringUtils.isEmpty(value)) {
return null;
}
try {
String result = UriUtils.decode(value, "UTF-8");
return (CALLBACK_PARAM_PATTERN.matcher(result).matches() ? result : null);
} catch (UnsupportedEncodingException ex) {
// should never happen
throw new SockJsException("Unable to decode callback query parameter", null, ex);
}
}
@Test
@SuppressWarnings("unchecked")
public void getRequestOk() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("GET");
request.setParameter("foo", "bar");
MockHttpServletResponse response = new MockHttpServletResponse();
defaultAdapter.handleRequest(request, response);
assertEquals(HttpServletResponse.SC_OK, response.getStatus());
Message<?> message = requests.receive(0);
assertNotNull(message);
Object payload = message.getPayload();
assertTrue(payload instanceof MultiValueMap);
MultiValueMap<String, String> map = (MultiValueMap<String, String>) payload;
assertEquals(1, map.size());
assertEquals("foo", map.keySet().iterator().next());
assertEquals(1, map.get("foo").size());
assertEquals("bar", map.getFirst("foo"));
assertNotNull(TestUtils.getPropertyValue(defaultAdapter, "errorChannel"));
}
@RequestMapping(value = "/link", method = RequestMethod.POST)
public ResponseEntity<?> shortener(
@RequestParam("url") String url,
@RequestParam(value = "sponsor", required = false) String sponsor,
@RequestParam(value = "brand", required = false) String brand,
@RequestParam(value = "urlName", required = false) String name,
@RequestParam("username") String username,
@RequestParam(value = "advert", required = false) String advertisement,
@RequestParam(value = "max", required = false) String max,
@RequestParam MultiValueMap<String, String> params,
HttpServletRequest request,
Principal currentUser,
Model model) {
logger.info("Requested new short for uri " + url);
sponsor = "http://localhost:8080/advert";
boolean useConditional = false;
// Comprobamos si se usan URIs condicionales
if (params.getFirst("ifurl1") != null
&& !params.getFirst("ifurl1").equals("")
&& params.getFirst("expr1") != null
&& !params.getFirst("expr1").equals("")) {
useConditional = true;
}
logger.info("Name (hash) is " + name);
// Si se usan URIs condicionales pero no hay url estandar,
// se crea un hash usando las targets de las condicionales
if (name.equals("") && url.equals("") && useConditional) {
logger.info("There are Conditional URIs but no default target" + name);
String ifurl = "ifurl";
String expr = "expr";
String nueva = "a";
int paramn = 1;
String firstparam = ifurl + paramn;
String secondparam = expr + paramn;
while ((params.getFirst(firstparam) != null && params.getFirst(secondparam) != null)
&& (!params.getFirst(firstparam).equals("")
&& !params.getFirst(secondparam).equals(""))) {
nueva += params.getFirst(firstparam);
paramn++;
firstparam = ifurl + paramn;
secondparam = expr + paramn;
}
name =
Hashing.murmur3_32()
.hashString(url + username + nueva, StandardCharsets.UTF_8)
.toString();
while (shortURLRepositoryExtended.findByHash(name, username) != null) {
// seguir creando
name =
Hashing.murmur3_32()
.hashString(url + username + "" + nueva, StandardCharsets.UTF_8)
.toString();
nueva += "a";
}
}
// Si no existe una hash (id or name) se crea una
else if (name.equals("")) {
name = Hashing.murmur3_32().hashString(url + username, StandardCharsets.UTF_8).toString();
String nueva = "a";
while (shortURLRepositoryExtended.findByHash(name, username) != null) {
// seguir creando
name =
Hashing.murmur3_32()
.hashString(url + username + "" + nueva, StandardCharsets.UTF_8)
.toString();
nueva += "a";
}
}
logger.info("After name (hash) is " + name);
boolean advert = false;
int seconds = 0;
if (advertisement != null) {
advert = true;
if (!max.equals("")) {
seconds = Integer.valueOf(max);
if (seconds < 1) {
seconds = 5;
}
}
}
if (shortURLRepositoryExtended.findByHash(name, username) != null
&& url != null
&& !url.equals("")) {
ArrayList<String> sufijos = new ArrayList<String>(); // contiene todos los sufijos
sufijos.add("ada");
sufijos.add("aco");
sufijos.add("ado");
JSONArray arr = new JSONArray();
JSONObject tmp;
try {
for (int i = 0; i < sufijos.size(); i++) {
ShortURL l = shortURLRepositoryExtended.findByHash(name + "" + sufijos.get(i), username);
if (l == null) {
// No existe en la BD, luego no esta cogido
tmp = new JSONObject();
tmp.put("name", name + "" + sufijos.get(i));
arr.put(tmp);
}
}
} catch (Exception e) {
}
String devueltos = "'{\"names\":" + arr.toString() + "}'";
RiWordnet wordnet = new RiWordnet();
// Crea 10 sinonimos
String[] poss = wordnet.getPos(name);
/*
* for (int j = 0; j < poss.length; j++) {
* System.out.println("\n\nSynonyms for " + name + " (pos: " +
* poss[j] + ")");
*/
JSONArray sinonimos = new JSONArray();
try {
String[] synonyms = wordnet.getAllSynonyms(name, poss[0], 10);
Arrays.sort(synonyms);
JSONObject tmpo;
for (int i = 0; i < synonyms.length; i++) {
ShortURL l = shortURLRepositoryExtended.findByHash(synonyms[i], username);
if (l == null) {
// No existe en la BD, luego no esta cogido
tmpo = new JSONObject();
tmpo.put("synonym", synonyms[i]);
sinonimos.put(tmpo);
}
}
} catch (Exception e) {
}
String synDevueltos = "'{\"synonyms\":" + sinonimos.toString() + "}'";
String respuesta = devueltos + "separa" + synDevueltos;
return new ResponseEntity<>(respuesta, HttpStatus.NOT_ACCEPTABLE);
} else {
ShortURL su =
createAndSaveIfValid(
url,
sponsor,
brand,
UUID.randomUUID().toString(),
extractIP(request),
name,
username,
advert,
seconds,
useConditional);
if (su != null) {
HttpHeaders h = new HttpHeaders();
h.setLocation(su.getUri());
saveConditionalURIs(name, params);
return new ResponseEntity<>(su, h, HttpStatus.CREATED);
} else {
return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
}
}
}
