@Test
public void testBatchWithoutProject() throws Exception {
Event.EventContext api = Event.EventContext.apiKey(apiKeys.writeKey());
ImmutableMap<String, Object> props =
ImmutableMap.of("test0", "test", "test1", ImmutableList.of("test"), "test2", false);
byte[] bytes =
mapper.writeValueAsBytes(
ImmutableMap.of(
"api",
api,
"events",
ImmutableList.of(
ImmutableMap.of("collection", "test", "properties", props),
ImmutableMap.of("collection", "test", "properties", props))));
EventList events = mapper.readValue(bytes, EventList.class);
assertEquals("test", events.project);
assertEquals(api, events.api);
for (Event event : events.events) {
assertEquals("test", event.collection());
assertEquals(eventBuilder.createEvent("test", props).properties(), event.properties());
}
}
@Test
public void testHttp() throws Exception {
// Verify that http_proxy and HTTP_PROXY are used for http requests
assertExpectedProxyConfig(
proxyConfigFromEnv(
"http",
ImmutableMap.of(
"http_proxy", PROXY_URL,
"HTTP_PROXY", "http://ignore",
"https_proxy", "http://ignore",
"HTTPS_PROXY", "http://ignore"))
.get());
assertExpectedProxyConfig(
proxyConfigFromEnv(
"http",
ImmutableMap.of(
"HTTP_PROXY", PROXY_URL,
"https_proxy", "http://ignore",
"HTTPS_PROXY", "http://ignore"))
.get());
// Verify that https_proxy and HTTPS_PROXY are not used for http requests
assertThat(
proxyConfigFromEnv(
"http", ImmutableMap.of("https_proxy", PROXY_URL, "HTTPS_PROXY", "http://ignore")),
is(Optional.absent()));
assertThat(
proxyConfigFromEnv("http", ImmutableMap.of("HTTPS_PROXY", PROXY_URL)),
is(Optional.absent()));
}
public void test_presentValue() {
Currency ccy1 = TRADE.getProduct().getNonDeliverableCurrency();
Currency ccy2 = TRADE.getProduct().getSettlementCurrency();
LocalDate valDate = TRADE.getProduct().getPaymentDate().plusDays(7);
FunctionConfig<FxNdfTrade> config =
FxNdfFunctionGroups.discounting().functionConfig(TRADE, Measure.PRESENT_VALUE).get();
CalculationSingleFunction<FxNdfTrade, ?> function = config.createFunction();
FunctionRequirements reqs = function.requirements(TRADE);
assertThat(reqs.getOutputCurrencies()).containsOnly(ccy1, ccy2);
assertThat(reqs.getSingleValueRequirements())
.isEqualTo(ImmutableSet.of(DiscountCurveKey.of(ccy1), DiscountCurveKey.of(ccy2)));
assertThat(reqs.getTimeSeriesRequirements()).isEqualTo(ImmutableSet.of());
assertThat(function.defaultReportingCurrency(TRADE)).hasValue(GBP);
DiscountFactors df1 =
SimpleDiscountFactors.of(
ccy1, valDate, ConstantNodalCurve.of(Curves.discountFactors("Test", ACT_360), 0.99));
DiscountFactors df2 =
SimpleDiscountFactors.of(
ccy2, valDate, ConstantNodalCurve.of(Curves.discountFactors("Test", ACT_360), 0.99));
TestMarketDataMap md =
new TestMarketDataMap(
valDate,
ImmutableMap.of(DiscountCurveKey.of(ccy1), df1, DiscountCurveKey.of(ccy2), df2),
ImmutableMap.of());
assertThat(function.execute(TRADE, md))
.isEqualTo(FxConvertibleList.of(ImmutableList.of(CurrencyAmount.zero(GBP))));
}
private ImmutableMap<ConfigurationKeys, String> getPushParameters() {
ImmutableMap<Factory.ConfigurationKeys, String> response = null;
if (Push.PUSH_SANDBOX_ENABLE.getValueAsBoolean()) {
response =
ImmutableMap.of(
ConfigurationKeys.ANDROID_API_KEY,
"" + Push.SANDBOX_ANDROID_API_KEY.getValueAsString(),
ConfigurationKeys.APPLE_TIMEOUT, "" + Push.PUSH_APPLE_TIMEOUT.getValueAsString(),
ConfigurationKeys.IOS_CERTIFICATE,
"" + Push.SANDBOX_IOS_CERTIFICATE.getValueAsString(),
ConfigurationKeys.IOS_CERTIFICATE_PASSWORD,
"" + Push.SANDBOX_IOS_CERTIFICATE_PASSWORD.getValueAsString(),
ConfigurationKeys.IOS_SANDBOX, "" + Boolean.TRUE.toString());
} else {
response =
ImmutableMap.of(
ConfigurationKeys.ANDROID_API_KEY,
"" + Push.PRODUCTION_ANDROID_API_KEY.getValueAsString(),
ConfigurationKeys.APPLE_TIMEOUT, "" + Push.PUSH_APPLE_TIMEOUT.getValueAsString(),
ConfigurationKeys.IOS_CERTIFICATE,
"" + Push.PRODUCTION_IOS_CERTIFICATE.getValueAsString(),
ConfigurationKeys.IOS_CERTIFICATE_PASSWORD,
"" + Push.PRODUCTION_IOS_CERTIFICATE_PASSWORD.getValueAsString(),
ConfigurationKeys.IOS_SANDBOX, "" + Boolean.FALSE.toString());
}
return response;
}
public static LocalQueryRunner createLocalQueryRunner(ExecutorService executor) {
ConnectorSession session =
new ConnectorSession(
"user", "test", "default", "default", UTC_KEY, Locale.ENGLISH, null, null);
LocalQueryRunner localQueryRunner = new LocalQueryRunner(session, executor);
// add tpch
InMemoryNodeManager nodeManager = localQueryRunner.getNodeManager();
localQueryRunner.createCatalog(
"tpch", new TpchConnectorFactory(nodeManager, 1), ImmutableMap.<String, String>of());
// add raptor
RaptorConnectorFactory raptorConnectorFactory =
createRaptorConnectorFactory(TPCH_CACHE_DIR, nodeManager);
localQueryRunner.createCatalog(
"default", raptorConnectorFactory, ImmutableMap.<String, String>of());
MetadataManager metadata = localQueryRunner.getMetadata();
if (!metadata
.getTableHandle(session, new QualifiedTableName("default", "default", "orders"))
.isPresent()) {
localQueryRunner.execute("CREATE TABLE orders AS SELECT * FROM tpch.sf1.orders");
}
if (!metadata
.getTableHandle(session, new QualifiedTableName("default", "default", "lineitem"))
.isPresent()) {
localQueryRunner.execute("CREATE TABLE lineitem AS SELECT * FROM tpch.sf1.lineitem");
}
return localQueryRunner;
}
@ResponseBody
@RequestMapping(value = "/delete", method = RequestMethod.POST)
public ImmutableMap<String, String> linkDelete(Long[] linkIds, HttpSession session) {
try {
if (linkIds == null || linkIds.length == 0) {
LOGGER.warn("要删除链接的ID为空！");
return ImmutableMap.of("status", "0", "message", getMessage("link.deletefailed.message"));
}
List<Link> links = linkService.findAll(linkIds);
String realPath = session.getServletContext().getRealPath("");
List<File> deleteFiles = Lists.newArrayList();
File deleteFile;
for (Link link : links) {
if (link.getLinkPic() == null || "".equals(link.getLinkPic())) continue;
deleteFile = new File(realPath + link.getLinkPic());
deleteFiles.add(deleteFile);
}
linkService.deleteInBatch(links);
deleteLinkRes(deleteFiles);
} catch (Exception e) {
LOGGER.error("链接信息删除失败，失败原因：{}", e.getMessage());
return ImmutableMap.of("status", "0", "message", getMessage("link.deletefailed.message"));
}
LOGGER.info("链接信息删除成功，ID为{}", StringUtils.join(linkIds, ","));
return ImmutableMap.of("status", "1", "message", getMessage("link.deletesuccess.message"));
}
@Test
public void test7() {
// Subscribers(guid1)/accounts(acc1)/subscribers(guid1)/preferences
SIGPathSegment preferences = SIGPathSegment.newSegment("Preferences");
GenericKey guid1 = newSubscriberKey();
guid1.inferValues(ImmutableMap.of("guid", "guid1"));
SIGPathSegment subscriber2 = SIGPathSegment.newSegment("Subscribers", guid1);
GenericKey acc1 = newAccountKey();
acc1.inferValues(ImmutableMap.of("accId", "acc1"));
SIGPathSegment accounts = SIGPathSegment.newSegment("Accounts", acc1);
SIGPathSegment subscriber1 = SIGPathSegment.newSegment("Subscribers", guid1);
preferences.setPrev(subscriber2);
subscriber2.setPrev(accounts);
accounts.setPrev(subscriber1);
SIGSegmentExecutor accountsExecutor = SIGSegmentExecutor.newExecutor(gateway, preferences);
@SuppressWarnings("unchecked")
Map<GenericKey, GenericData> result = (Map<GenericKey, GenericData>) accountsExecutor.execute();
assertNotNull(result);
GenericData obj = (GenericData) result.values().iterator().next();
assertEquals("off", obj.get("pin_flag"));
}
@Test
public void ruleKeyChangesIfInputContentsFromPathSourcePathInRuleKeyAppendableChanges() {
BuildRuleResolver resolver =
new BuildRuleResolver(TargetGraph.EMPTY, new DefaultTargetNodeToBuildRuleTransformer());
SourcePathResolver pathResolver = new SourcePathResolver(resolver);
final FakeProjectFilesystem filesystem = new FakeProjectFilesystem();
final Path output = Paths.get("output");
BuildRuleParams params =
new FakeBuildRuleParamsBuilder("//:rule").setProjectFilesystem(filesystem).build();
BuildRule rule =
new NoopBuildRule(params, pathResolver) {
@AddToRuleKey
RuleKeyAppendableWithInput input =
new RuleKeyAppendableWithInput(new PathSourcePath(filesystem, output));
};
// Build a rule key with a particular hash set for the output for the above rule.
FakeFileHashCache hashCache =
new FakeFileHashCache(ImmutableMap.of(filesystem.resolve(output), HashCode.fromInt(0)));
RuleKey inputKey1 = new InputBasedRuleKeyBuilderFactory(0, hashCache, pathResolver).build(rule);
// Now, build a rule key with a different hash for the output for the above rule.
hashCache =
new FakeFileHashCache(ImmutableMap.of(filesystem.resolve(output), HashCode.fromInt(1)));
RuleKey inputKey2 = new InputBasedRuleKeyBuilderFactory(0, hashCache, pathResolver).build(rule);
assertThat(inputKey1, Matchers.not(Matchers.equalTo(inputKey2)));
}
@Test
public void ruleKeyChangesIfInputContentsFromPathSourceChanges() throws Exception {
BuildRuleResolver resolver =
new BuildRuleResolver(TargetGraph.EMPTY, new DefaultTargetNodeToBuildRuleTransformer());
SourcePathResolver pathResolver = new SourcePathResolver(resolver);
FakeProjectFilesystem filesystem = new FakeProjectFilesystem();
Path output = Paths.get("output");
BuildRule rule =
ExportFileBuilder.newExportFileBuilder(BuildTargetFactory.newInstance("//:rule"))
.setOut("out")
.setSrc(new PathSourcePath(filesystem, output))
.build(resolver, filesystem);
// Build a rule key with a particular hash set for the output for the above rule.
FakeFileHashCache hashCache =
new FakeFileHashCache(ImmutableMap.of(filesystem.resolve(output), HashCode.fromInt(0)));
RuleKey inputKey1 = new InputBasedRuleKeyBuilderFactory(0, hashCache, pathResolver).build(rule);
// Now, build a rule key with a different hash for the output for the above rule.
hashCache =
new FakeFileHashCache(ImmutableMap.of(filesystem.resolve(output), HashCode.fromInt(1)));
RuleKey inputKey2 = new InputBasedRuleKeyBuilderFactory(0, hashCache, pathResolver).build(rule);
assertThat(inputKey1, Matchers.not(Matchers.equalTo(inputKey2)));
}
@Override
public Map<String, Org> get() {
return ImmutableMap.<String, Org>of(
"org",
new TerremarkOrgImpl(
"org",
null,
URI.create("https://vcloud.safesecureweb.com/api/v0.8/org/1"),
null,
ImmutableMap.<String, ReferenceType>of(
"catalog",
new ReferenceTypeImpl(
"catalog",
TerremarkVCloudExpressMediaType.CATALOG_XML,
URI.create("https://vcloud.safesecureweb.com/api/v0.8/catalog/1"))),
ImmutableMap.<String, ReferenceType>of(
"vdc",
new ReferenceTypeImpl(
"vdc",
TerremarkVCloudExpressMediaType.VDC_XML,
URI.create("https://vcloud.safesecureweb.com/api/v0.8/vdc/1"))),
ImmutableMap.<String, ReferenceType>of(),
new ReferenceTypeImpl(
"tasksList",
TerremarkVCloudExpressMediaType.TASKSLIST_XML,
URI.create("https://vcloud.safesecureweb.com/api/v0.8/tasksList/1")),
new ReferenceTypeImpl(
"keysList",
TerremarkVCloudExpressMediaType.KEYSLIST_XML,
URI.create("https://vcloud.safesecureweb.com/api/v0.8/keysList/1"))));
}
/** Matches the contents of instances-response.json */
private List<InstanceInfo> getExpectedInstances() {
return ImmutableList.of(
new InstanceInfo(
"10.1.100.78",
"analytics-service",
60000,
false,
"2014-02-05T17:05:39.000Z",
"2014-02-05T18:46:48.000Z",
ImmutableMap.of(
"ami-id",
"ami-133cb31d",
"availability-zone",
"us-east-1d",
"local-ipv4",
"10.1.100.78",
"instance-type",
"m1.small")),
new InstanceInfo(
"10.1.100.79",
"analytics-service",
50000,
true,
"2014-03-05T17:05:39.000Z",
"2014-03-05T18:46:48.000Z",
ImmutableMap.of(
"ami-id",
"ami-133cb31d",
"availability-zone",
"us-east-1d",
"local-ipv4",
"10.1.100.79",
"instance-type",
"m1.small")));
}
/**
* @param params
* @param request
* @param response
* @return
* @throws RepositoryException
* @throws JCRNodeFactoryServiceException
* @throws IOException
*/
private Map<String, Object> doRequestConnect(
FriendsParams params, HttpServletRequest request, HttpServletResponse response)
throws JCRNodeFactoryServiceException, RepositoryException, IOException {
FriendsBean myFriends = friendsResolverService.resolve(params.uuid);
FriendsBean friendFriends = friendsResolverService.resolve(params.friendUuid);
if (myFriends.hasFriend(params.friendUuid) || friendFriends.hasFriend(params.uuid)) {
throw new RestServiceFaultException(
HttpServletResponse.SC_CONFLICT,
"There is already a connection invited, pending or accepted ");
}
FriendBean friend = new FriendBean(params.uuid, params.friendUuid, FriendStatus.PENDING);
FriendBean me = new FriendBean(params.friendUuid, params.uuid, FriendStatus.INVITED);
if (!StringUtils.isEmpty(params.type)) {
me.setProperties(ImmutableMap.of("type", params.type, "message", params.message));
friend.setProperties(ImmutableMap.of("type", params.type, "message", params.message));
}
myFriends.addFriend(friend);
friendFriends.addFriend(me);
authzResolverService.setRequestGrant("Saving Request Connect");
try {
myFriends.save();
friendFriends.save();
jcrService.getSession().save();
} finally {
authzResolverService.clearRequestGrant();
}
return OK;
}
@Test
public void create() throws Exception {
Map<String, String> attrs = ImmutableMap.of("x", "X");
Map<String, String> attrsToSave =
ImmutableMap.of(
"x", "X",
"_accessedAt", "2",
"_createdAt", "1",
"_savedAt", "3");
new MockUnit(JedisPool.class, Session.class)
.expect(
unit -> {
Session session = unit.get(Session.class);
expect(session.id()).andReturn("1234");
expect(session.attributes()).andReturn(attrs);
expect(session.createdAt()).andReturn(1L);
expect(session.accessedAt()).andReturn(2L);
expect(session.savedAt()).andReturn(3L);
})
.expect(
unit -> {
Jedis jedis = unit.mock(Jedis.class);
expect(jedis.hmset("sessions:1234", attrsToSave)).andReturn("sessions:1234");
expect(jedis.expire("sessions:1234", 1800)).andReturn(1L);
jedis.close();
JedisPool pool = unit.get(JedisPool.class);
expect(pool.getResource()).andReturn(jedis);
})
.run(
unit -> {
new RedisSessionStore(unit.get(JedisPool.class), "sessions", "30m")
.create(unit.get(Session.class));
});
}
@Override
public void bindToRequest(HttpRequest request, Object toBind) {
checkArgument(toBind instanceof String, "this binder is only valid for Strings!");
super.bindToRequest(
request,
ImmutableMap.of("server", ImmutableMap.of("adminPass", checkNotNull(toBind, "adminPass"))));
}
@Test
public void structuredAndUnstructuredOptions() throws Exception {
// From https://developers.google.com/protocol-buffers/docs/proto#options
Schema schema =
new SchemaBuilder()
.add(
"foo.proto",
""
+ "import \"google/protobuf/descriptor.proto\";\n"
+ "message FooOptions {\n"
+ " optional int32 opt1 = 1;\n"
+ " optional string opt2 = 2;\n"
+ "}\n"
+ "\n"
+ "extend google.protobuf.FieldOptions {\n"
+ " optional FooOptions foo_options = 1234;\n"
+ "}\n"
+ "\n"
+ "message Bar {\n"
+ " optional int32 a = 1 [(foo_options).opt1 = 123, (foo_options).opt2 = \"baz\"];\n"
+ " optional int32 b = 2 [(foo_options) = { opt1: 456 opt2: \"quux\" }];\n"
+ "}\n")
.add("google/protobuf/descriptor.proto")
.build();
ProtoMember fooOptions = ProtoMember.get(Options.FIELD_OPTIONS, "foo_options");
ProtoMember opt1 = ProtoMember.get(ProtoType.get("FooOptions"), "opt1");
ProtoMember opt2 = ProtoMember.get(ProtoType.get("FooOptions"), "opt2");
MessageType bar = (MessageType) schema.getType("Bar");
assertThat(bar.field("a").options().map())
.isEqualTo(ImmutableMap.of(fooOptions, ImmutableMap.of(opt1, "123", opt2, "baz")));
assertThat(bar.field("b").options().map())
.isEqualTo(ImmutableMap.of(fooOptions, ImmutableMap.of(opt1, "456", opt2, "quux")));
}
@Test
public void testOnlyChild() {
Archetype parent =
TestAdlParser.parseAdl(
"adl15/reference/features/annotations/openEHR-EHR-EVALUATION.annotations_parent.v1.adls");
Archetype specialized =
TestAdlParser.parseAdl(
"adl15/reference/features/annotations/openEHR-EHR-EVALUATION.annotations_only_child.v1.adls");
Archetype flattened = flatten(parent, specialized);
assertThat(flattened.getAnnotations().getItems()).hasSize(1);
ResourceAnnotationNodes annotations = flattened.getAnnotations().getItems().get(0);
assertThat(annotations.getLanguage()).isEqualTo("en");
assertThat(annotations.getItems()).hasSize(2);
assertThat(getAnnotation(annotations, "/data[id2]"))
.isEqualTo(ImmutableMap.of("ui", "passthrough"));
assertThat(getAnnotation(annotations, "/data[id2]/items[id3]"))
.isEqualTo(
ImmutableMap.of(
"requirements note", "this is a requirements note on Statement",
"medline ref", "this is a medline ref on Statement",
"design note", "this is a SPECIALISED design note on Statement",
"NEW TAG", "this is a SPECIALISED design note on Statement"));
}
@ResponseBody
@RequestMapping(value = "/upload", method = RequestMethod.POST)
public ImmutableMap<String, String> linkImgUpload(
MultipartFile file, HttpServletRequest request) {
if (file.isEmpty()) {
return ImmutableMap.of("status", "0", "message", getMessage("global.uploadempty.message"));
}
Site site = (Site) (SystemUtils.getSessionSite());
String linkPath = PathFormat.parseSiteId(SystemConstant.LINK_RES_PATH, site.getSiteId() + "");
String realPath = HttpUtils.getRealPath(request, linkPath);
SystemUtils.isNotExistCreate(realPath);
String timeFileName = SystemUtils.timeFileName(file.getOriginalFilename());
try {
file.transferTo(new File(realPath + "/" + timeFileName));
} catch (IOException e) {
LOGGER.error("链接图片添加失败，错误：{}", e.getMessage());
return ImmutableMap.of("status", "0", "message", getMessage("link.uploaderror.message"));
}
return ImmutableMap.of(
"status",
"1",
"message",
getMessage("link.uploadsuccess.message"),
"filePath",
(linkPath + "/" + timeFileName),
"contentPath",
HttpUtils.getBasePath(request));
}
public void test_toUI_LinkedCorrectionProposal() throws Exception {
Source source = createTestFileSource();
// fill SourceChange
SourceChange sourceChange = new SourceChange("My linked change", source);
sourceChange.addEdit(new Edit(10, 1, "a"));
sourceChange.addEdit(new Edit(20, 1, "a"));
sourceChange.addEdit(new Edit(30, 3, "b"));
// create SourceCorrectionProposal
SourceCorrectionProposal proposal =
new SourceCorrectionProposal(sourceChange, CorrectionKind.QA_ADD_TYPE_ANNOTATION);
{
List<SourceRange> ranges = ImmutableList.of(new SourceRange(10, 1), new SourceRange(20, 1));
Map<String, List<SourceRange>> linkedPositons = ImmutableMap.of("a", ranges);
proposal.setLinkedPositions(linkedPositons);
}
{
List<LinkedPositionProposal> proposals =
ImmutableList.of(
new LinkedPositionProposal(CorrectionImage.IMG_CORRECTION_CHANGE, "proposalA"));
Map<String, List<LinkedPositionProposal>> linkedProposals = ImmutableMap.of("a", proposals);
proposal.setLinkedPositionProposals(linkedProposals);
}
//
LinkedCorrectionProposal uiProposal = ServiceUtils.toUI(proposal);
CompilationUnitChange ltkChange = (CompilationUnitChange) uiProposal.getChange();
assertEquals("My linked change", ltkChange.getName());
}
@ResponseBody
@RequestMapping(value = "/edit", method = RequestMethod.POST)
public ImmutableMap<String, Object> linkEdit(@Valid Link link, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
Map<String, Object> errorMessage = Maps.newHashMap();
errorMessage.put("status", 0);
List<FieldError> fes = bindingResult.getFieldErrors();
for (FieldError fe : fes) {
errorMessage.put(fe.getField(), fe.getDefaultMessage());
}
return ImmutableMap.<String, Object>builder().putAll(errorMessage).build();
}
if (link.getLinkId() == null || link.getLinkId() == 0) {
Link result = linkService.save(link);
if (result == null || result.getLinkId() == null || result.getLinkId() == 0) {
LOGGER.warn("内容链接失败，链接{}", result);
return ImmutableMap.<String, Object>of(
"status", "0", "message", getMessage("link.addfailed.message"));
}
LOGGER.info("内容添加成功，链接ID{}", result.getLinkId());
return ImmutableMap.<String, Object>of(
"status", "1", "message", getMessage("link.addsuccess.message"));
}
try {
linkService.save(link);
} catch (Exception e) {
LOGGER.error("链接修改失败,{}", e);
return ImmutableMap.<String, Object>of(
"status", "0", "message", getMessage("link.updatefailed.message"));
}
LOGGER.info("链接添加成功,{}", link);
return ImmutableMap.<String, Object>of(
"status", "1", "message", getMessage("link.updatesuccess.message"));
}
@Test
@SuppressWarnings("unchecked")
public void twoHits() {
setup(
"The quick brown fox jumped over the lazy dog.", ImmutableMap.of("lazy", 10f, "brown", 1f));
List<Snippet> snippets = chooser.choose(segmenter, hitEnum, 2);
assertThat(
snippets,
contains(
extracted(extracter, "over the lazy dog."),
extracted(extracter, "quick brown fox jumped")));
assertThat(snippets.get(0).hits(), contains(extracted(extracter, "lazy")));
assertThat(snippets.get(1).hits(), contains(extracted(extracter, "brown")));
chooser = new BasicScoreBasedSnippetChooser(false);
setup(
"The quick brown fox jumped over the lazy dog.", ImmutableMap.of("lazy", 10f, "brown", 1f));
snippets = chooser.choose(segmenter, hitEnum, 2);
assertThat(
snippets,
contains(
extracted(extracter, "quick brown fox jumped"),
extracted(extracter, "over the lazy dog.")));
assertThat(snippets.get(0).hits(), contains(extracted(extracter, "brown")));
assertThat(snippets.get(1).hits(), contains(extracted(extracter, "lazy")));
}
@Test
public void testMoveTaskSerde() throws Exception {
final MoveTask task =
new MoveTask(
null,
"foo",
new Interval("2010-01-01/P1D"),
ImmutableMap.<String, Object>of("bucket", "hey", "baseKey", "what"),
null,
null);
final String json = jsonMapper.writeValueAsString(task);
Thread.sleep(100); // Just want to run the clock a bit to make sure the task id doesn't change
final MoveTask task2 = (MoveTask) jsonMapper.readValue(json, Task.class);
Assert.assertEquals("foo", task.getDataSource());
Assert.assertEquals(new Interval("2010-01-01/P1D"), task.getInterval());
Assert.assertEquals(
ImmutableMap.<String, Object>of("bucket", "hey", "baseKey", "what"),
task.getTargetLoadSpec());
Assert.assertEquals(task.getId(), task2.getId());
Assert.assertEquals(task.getGroupId(), task2.getGroupId());
Assert.assertEquals(task.getDataSource(), task2.getDataSource());
Assert.assertEquals(task.getInterval(), task2.getInterval());
Assert.assertEquals(task.getTargetLoadSpec(), task2.getTargetLoadSpec());
}
@Test
public void testUnassignedShardAndEmptyNodesInRoutingTable() throws Exception {
internalCluster().startNode();
createIndex("a");
ensureSearchable("a");
ClusterState current = clusterService().state();
GatewayAllocator allocator = internalCluster().getInstance(GatewayAllocator.class);
AllocationDeciders allocationDeciders =
new AllocationDeciders(Settings.EMPTY, new AllocationDecider[0]);
RoutingNodes routingNodes =
new RoutingNodes(
ClusterState.builder(current)
.routingTable(
RoutingTable.builder(current.routingTable())
.remove("a")
.addAsRecovery(current.metaData().index("a")))
.nodes(DiscoveryNodes.EMPTY_NODES)
.build());
ClusterInfo clusterInfo =
new ClusterInfo(ImmutableMap.<String, DiskUsage>of(), ImmutableMap.<String, Long>of());
RoutingAllocation routingAllocation =
new RoutingAllocation(allocationDeciders, routingNodes, current.nodes(), clusterInfo);
allocator.allocateUnassigned(routingAllocation);
}
@Test
public void shouldMatchHeaderWithMultipleValues() {
ignoringNotifier();
RequestPattern requestPattern1 =
new RequestPattern(
RequestMethod.GET, "/multi/header", ImmutableMap.of("X-Multi", equalTo("one")));
RequestPattern requestPattern2 =
new RequestPattern(
RequestMethod.GET, "/multi/header", ImmutableMap.of("X-Multi", equalTo("two")));
Request request =
aRequest(context)
.withUrl("/multi/header")
.withMethod(GET)
.withHeader("X-Multi", "one")
.withHeader("X-Multi", "two")
.build();
assertTrue(
"Request should match request pattern with header X-Multi:one",
requestPattern1.isMatchedBy(request));
assertTrue(
"Request should match request pattern with header X-Multi:two",
requestPattern2.isMatchedBy(request));
}
@Override
public Map<String, Map<String, ? extends org.jclouds.trmk.vcloud_0_8.domain.Catalog>> get() {
return ImmutableMap
.<String, Map<String, ? extends org.jclouds.trmk.vcloud_0_8.domain.Catalog>>of(
ORG_REF.getName(),
ImmutableMap.<String, org.jclouds.trmk.vcloud_0_8.domain.Catalog>of(
CATALOG_REF.getName(),
new CatalogImpl(
CATALOG_REF.getName(),
CATALOG_REF.getType(),
CATALOG_REF.getHref(),
null,
ImmutableMap.<String, ReferenceType>of(
"item",
new ReferenceTypeImpl(
"item",
"application/vnd.vmware.vcloud.catalogItem+xml",
URI.create(
"https://vcloud.safesecureweb.com/api/v0.8/catalogItem/1")),
"template",
new ReferenceTypeImpl(
"template",
"application/vnd.vmware.vcloud.vAppTemplate+xml",
URI.create(
"https://vcloud.safesecureweb.com/api/v0.8/catalogItem/2"))))));
}
@Test
public void test_loading_of_module_settings() {
BatchSettings batchSettings = mock(BatchSettings.class);
when(batchSettings.getDefinitions()).thenReturn(new PropertyDefinitions());
when(batchSettings.getProperties())
.thenReturn(
ImmutableMap.of(
"overridding", "batch",
"on-batch", "true"));
when(batchSettings.getModuleProperties("struts-core"))
.thenReturn(
ImmutableMap.of(
"on-module", "true",
"overridding", "module"));
ProjectDefinition module = ProjectDefinition.create().setKey("struts-core");
Configuration deprecatedConf = new PropertiesConfiguration();
ModuleSettings moduleSettings = new ModuleSettings(batchSettings, module, deprecatedConf);
assertThat(moduleSettings.getString("overridding")).isEqualTo("module");
assertThat(moduleSettings.getString("on-batch")).isEqualTo("true");
assertThat(moduleSettings.getString("on-module")).isEqualTo("true");
assertThat(deprecatedConf.getString("overridding")).isEqualTo("module");
assertThat(deprecatedConf.getString("on-batch")).isEqualTo("true");
assertThat(deprecatedConf.getString("on-module")).isEqualTo("true");
}
/**
* Merge the dag acls with the AM acls in the configuration object. The config object will contain
* the updated acls.
*
* @param conf The AM config.
*/
@Private
public synchronized void mergeIntoAmAcls(Configuration conf) {
ACLConfigurationParser parser = new ACLConfigurationParser(conf, false);
parser.addAllowedGroups(
ImmutableMap.of(
ACLType.AM_VIEW_ACL, groupsWithViewACLs, ACLType.AM_MODIFY_ACL, groupsWithModifyACLs));
parser.addAllowedUsers(
ImmutableMap.of(
ACLType.AM_VIEW_ACL, usersWithViewACLs, ACLType.AM_MODIFY_ACL, usersWithModifyACLs));
Set<String> viewUsers = parser.getAllowedUsers().get(ACLType.AM_VIEW_ACL);
Set<String> viewGroups = parser.getAllowedGroups().get(ACLType.AM_VIEW_ACL);
if (viewUsers.contains(ACLManager.WILDCARD_ACL_VALUE)) {
conf.set(TezConfiguration.TEZ_AM_VIEW_ACLS, ACLManager.WILDCARD_ACL_VALUE);
} else {
String userList = ACLManager.toCommaSeparatedString(viewUsers);
String groupList = ACLManager.toCommaSeparatedString(viewGroups);
conf.set(TezConfiguration.TEZ_AM_VIEW_ACLS, userList + " " + groupList);
}
Set<String> modifyUsers = parser.getAllowedUsers().get(ACLType.AM_MODIFY_ACL);
Set<String> modifyGroups = parser.getAllowedGroups().get(ACLType.AM_MODIFY_ACL);
if (modifyUsers.contains(ACLManager.WILDCARD_ACL_VALUE)) {
conf.set(TezConfiguration.TEZ_AM_MODIFY_ACLS, ACLManager.WILDCARD_ACL_VALUE);
} else {
String userList = ACLManager.toCommaSeparatedString(modifyUsers);
String groupList = ACLManager.toCommaSeparatedString(modifyGroups);
conf.set(TezConfiguration.TEZ_AM_MODIFY_ACLS, userList + " " + groupList);
}
}
@Test
public void testHttps() throws Exception {
assertExpectedProxyConfig(
proxyConfigFromEnv(
"https",
ImmutableMap.of(
"https_proxy", PROXY_URL,
"HTTPS_PROXY", "http://ignore",
"http_proxy", "http://ignore",
"HTTP_PROXY", "http://ignore"))
.get());
assertExpectedProxyConfig(
proxyConfigFromEnv(
"https",
ImmutableMap.of(
"HTTPS_PROXY", PROXY_URL,
"http_proxy", "http://ignore",
"HTTP_PROXY", "http://ignore"))
.get());
assertExpectedProxyConfig(
proxyConfigFromEnv(
"https", ImmutableMap.of("http_proxy", PROXY_URL, "HTTP_PROXY", "http://ignore"))
.get());
assertExpectedProxyConfig(
proxyConfigFromEnv("https", ImmutableMap.of("HTTP_PROXY", PROXY_URL)).get());
}
/**
* Tests that {@link Type#selectableConvert} returns either the native type or a selector on that
* type, in accordance with the provided input.
*/
@SuppressWarnings("unchecked")
@Test
public void testSelectableConvert() throws Exception {
Object nativeInput = Arrays.asList("//a:a1", "//a:a2");
Object selectableInput =
SelectorList.of(
new SelectorValue(
ImmutableMap.of(
"//conditions:a",
nativeInput,
Type.Selector.DEFAULT_CONDITION_KEY,
nativeInput)));
List<Label> expectedLabels = ImmutableList.of(Label.create("a", "a1"), Label.create("a", "a2"));
// Conversion to direct type:
Object converted = Type.LABEL_LIST.selectableConvert(nativeInput, null, currentRule);
assertTrue(converted instanceof List<?>);
assertSameContents(expectedLabels, (List<Label>) converted);
// Conversion to selectable type:
converted = Type.LABEL_LIST.selectableConvert(selectableInput, null, currentRule);
Type.SelectorList<?> selectorList = (Type.SelectorList<?>) converted;
assertSameContents(
ImmutableMap.of(
Label.parseAbsolute("//conditions:a"), expectedLabels,
Label.parseAbsolute(Type.Selector.DEFAULT_CONDITION_KEY), expectedLabels)
.entrySet(),
((Type.Selector<Label>) selectorList.getSelectors().get(0)).getEntries().entrySet());
}
/** Main method. */
public static void main(String[] args) throws Exception {
// Alice init cluster
ICluster alice = Cluster.joinAwait(ImmutableMap.of("name", "Alice"));
System.out.println(now() + " Alice join members: " + alice.members());
alice
.listenMembership()
.subscribe(event -> System.out.println(now() + " Alice received: " + event));
// Bob join cluster
ICluster bob = Cluster.joinAwait(ImmutableMap.of("name", "Bob"), alice.address());
System.out.println(now() + " Bob join members: " + bob.members());
bob.listenMembership()
.subscribe(event -> System.out.println(now() + " Bob received: " + event));
// Carol join cluster
ICluster carol =
Cluster.joinAwait(ImmutableMap.of("name", "Carol"), alice.address(), bob.address());
System.out.println(now() + " Carol join members: " + carol.members());
carol
.listenMembership()
.subscribe(event -> System.out.println(now() + " Carol received: " + event));
// Bob leave cluster
Future<Void> shutdownFuture = bob.shutdown();
shutdownFuture.get();
// Avoid exit main thread immediately ]:->
long maxRemoveTimeout =
MembershipConfig.DEFAULT_SUSPECT_TIMEOUT + 3 * FailureDetectorConfig.DEFAULT_PING_INTERVAL;
Thread.sleep(maxRemoveTimeout);
}
@Test
public void testEmptyMap() throws Exception {
Event.EventContext api = Event.EventContext.apiKey(apiKeys.writeKey());
byte[] bytes =
mapper.writeValueAsBytes(
ImmutableMap.of(
"collection",
"test",
"api",
api,
"properties",
ImmutableMap.of(
"test",
1,
"test2",
new HashMap<String, String>() {
{
put("a", null);
}
}),
"test20",
ImmutableMap.of(),
"test3",
true));
Event event = mapper.readValue(bytes, Event.class);
assertEquals("test", event.project());
assertEquals("test", event.collection());
assertEquals(api, event.api());
assertEquals(
eventBuilder.createEvent("test", ImmutableMap.of("test", 1.0, "test3", true)).properties(),
event.properties());
}