@Test
  public void adhocIMChat6() throws JsonGenerationException, JsonMappingException, IOException {
    Setup.startTest("Checking that User 1 has received a chat message");

    receiveMessageStatusURL = INVALID;
    String url = (Setup.channelURL[1].split("username\\=")[0]) + "username="******"notificationList.messageNotification.chatMessage.text",
                    Matchers.hasItem("how are you"),
                "notificationList.messageNotification.sessionId", Matchers.hasItem("adhoc"),
                "notificationList.messageNotification.messageId", Matchers.notNullValue(),
                "notificationList.messageNotification.senderAddress",
                    Matchers.hasItem(Setup.TestUser2Contact),
                "notificationList.messageNotification.link", Matchers.notNullValue())
            .post(url);
    System.out.println("Response = " + response.getStatusCode() + " / " + response.asString());

    receiveMessageStatusURL =
        response.jsonPath().getString("notificationList.messageNotification[0].link[0].href");
    System.out.println("message status URL = " + receiveMessageStatusURL);
    Setup.endTest();
  }
 public void testClusterHealth() throws IOException {
   ClusterState clusterState =
       ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
   int pendingTasks = randomIntBetween(0, 200);
   int inFlight = randomIntBetween(0, 200);
   int delayedUnassigned = randomIntBetween(0, 200);
   TimeValue pendingTaskInQueueTime = TimeValue.timeValueMillis(randomIntBetween(1000, 100000));
   ClusterHealthResponse clusterHealth =
       new ClusterHealthResponse(
           "bla",
           new String[] {MetaData.ALL},
           clusterState,
           pendingTasks,
           inFlight,
           delayedUnassigned,
           pendingTaskInQueueTime);
   clusterHealth = maybeSerialize(clusterHealth);
   assertClusterHealth(clusterHealth);
   assertThat(clusterHealth.getNumberOfPendingTasks(), Matchers.equalTo(pendingTasks));
   assertThat(clusterHealth.getNumberOfInFlightFetch(), Matchers.equalTo(inFlight));
   assertThat(clusterHealth.getDelayedUnassignedShards(), Matchers.equalTo(delayedUnassigned));
   assertThat(clusterHealth.getTaskMaxWaitingTime().millis(), is(pendingTaskInQueueTime.millis()));
   assertThat(
       clusterHealth.getActiveShardsPercent(),
       is(allOf(greaterThanOrEqualTo(0.0), lessThanOrEqualTo(100.0))));
 }
 private void checkExceptions(String script) {
   try {
     SearchResponse sr =
         client()
             .prepareSearch("test")
             .setQuery(QueryBuilders.matchAllQuery())
             .addScriptField("tvtest", script)
             .execute()
             .actionGet();
     assertThat(sr.getHits().hits().length, equalTo(0));
     ShardSearchFailure[] shardFails = sr.getShardFailures();
     for (ShardSearchFailure fail : shardFails) {
       assertThat(
           fail.reason()
               .indexOf(
                   "Cannot iterate twice! If you want to iterate more that once, add _CACHE explicitly."),
           Matchers.greaterThan(-1));
     }
   } catch (SearchPhaseExecutionException ex) {
     assertThat(
         "got " + ex.getDetailedMessage(),
         ex.getDetailedMessage()
             .indexOf(
                 "Cannot iterate twice! If you want to iterate more that once, add _CACHE explicitly."),
         Matchers.greaterThan(-1));
   }
 }
  @Test
  public void testAfterPaneWithFixedWindow() throws Exception {
    Duration windowDuration = Duration.millis(10);
    ReduceFnTester<Integer, Iterable<Integer>, IntervalWindow> tester =
        ReduceFnTester.nonCombining(
            FixedWindows.of(windowDuration),
            AfterPane.<IntervalWindow>elementCountAtLeast(2),
            AccumulationMode.DISCARDING_FIRED_PANES,
            Duration.millis(100));

    tester.injectElements(
        TimestampedValue.of(1, new Instant(1)), // first in window [0, 10)
        TimestampedValue.of(2, new Instant(9)));

    assertThat(
        tester.extractOutput(),
        Matchers.contains(
            WindowMatchers.isSingleWindowedValue(Matchers.containsInAnyOrder(1, 2), 1, 0, 10)));

    // This element belongs in the window that has already fired. It should not be re-output because
    // that trigger (which was one-time) has already gone off.
    tester.injectElements(TimestampedValue.of(6, new Instant(2)));
    assertThat(tester.extractOutput(), Matchers.emptyIterable());

    assertTrue(tester.isMarkedFinished(new IntervalWindow(new Instant(0), new Instant(10))));
    assertFalse(tester.isMarkedFinished(new IntervalWindow(new Instant(10), new Instant(20))));

    tester.assertHasOnlyGlobalAndFinishedSetsFor(
        new IntervalWindow(new Instant(0), new Instant(10)));
  }
 /**
  * Cacheable can cache static calls.
  *
  * @throws Exception If something goes wrong
  */
 @Test
 public void cachesSimpleStaticCall() throws Exception {
   final String first = CacheableTest.Foo.staticGet();
   MatcherAssert.assertThat(first, Matchers.equalTo(CacheableTest.Foo.staticGet()));
   CacheableTest.Foo.staticFlush();
   MatcherAssert.assertThat(CacheableTest.Foo.staticGet(), Matchers.not(Matchers.equalTo(first)));
 }
  @Test
  public void testFallThrough() throws Exception {
    HandlerList list = new HandlerList();
    _server.setHandler(list);

    ServletContextHandler root =
        new ServletContextHandler(list, "/", ServletContextHandler.SESSIONS);

    ServletHandler servlet = root.getServletHandler();
    servlet.setEnsureDefaultServlet(false);
    servlet.addServletWithMapping(HelloServlet.class, "/hello/*");

    list.addHandler(
        new AbstractHandler() {
          @Override
          public void handle(
              String target,
              Request baseRequest,
              HttpServletRequest request,
              HttpServletResponse response)
              throws IOException, ServletException {
            response.sendError(404, "Fell Through");
          }
        });

    _server.start();

    String response = _connector.getResponses("GET /hello HTTP/1.0\r\n\r\n");
    Assert.assertThat(response, Matchers.containsString("200 OK"));

    response = _connector.getResponses("GET /other HTTP/1.0\r\n\r\n");
    Assert.assertThat(response, Matchers.containsString("404 Fell Through"));
  }
Exemple #7
0
  public Map<String, Path> buildMultipleAndReturnOutputs(String... args) throws IOException {
    // Add in `--show-output` to the build, so we can parse the output paths after the fact.
    ImmutableList<String> buildArgs =
        ImmutableList.<String>builder().add("--show-output").add(args).build();
    ProjectWorkspace.ProcessResult buildResult =
        runBuckBuild(buildArgs.toArray(new String[buildArgs.size()]));
    buildResult.assertSuccess();

    // Grab the stdout lines, which have the build outputs.
    List<String> lines =
        Splitter.on(CharMatcher.anyOf(System.lineSeparator()))
            .trimResults()
            .omitEmptyStrings()
            .splitToList(buildResult.getStdout());

    // Skip the first line, which is just "The outputs are:".
    assertThat(lines.get(0), Matchers.equalTo("The outputs are:"));
    lines = lines.subList(1, lines.size());

    Splitter lineSplitter = Splitter.on(' ').trimResults();
    ImmutableMap.Builder<String, Path> builder = ImmutableMap.builder();
    for (String line : lines) {
      List<String> fields = lineSplitter.splitToList(line);
      assertThat(fields, Matchers.hasSize(2));
      builder.put(fields.get(0), getPath(fields.get(1)));
    }

    return builder.build();
  }
  @Test
  public void shouldAllowToNotResetStateBeforeScenario() throws Throwable {
    // Given
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    Step pendingStep = mock(Step.class);
    when(pendingStep.perform(null)).thenReturn(pending("pendingStep"));
    Step secondStep = mockSuccessfulStep("secondStep");
    StepCollector collector = mock(StepCollector.class);
    CandidateSteps mySteps = new Steps();
    Scenario scenario1 = new Scenario();
    Scenario scenario2 = new Scenario();
    when(collector.collectScenarioSteps(asList(mySteps), scenario1, parameters))
        .thenReturn(asList(pendingStep));
    when(collector.collectScenarioSteps(asList(mySteps), scenario2, parameters))
        .thenReturn(asList(secondStep));
    Story story = new Story(asList(scenario1, scenario2));
    givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps);

    // When
    StoryRunner runner = new StoryRunner();
    Configuration configuration = configurationWith(reporter, collector);
    configuration.storyControls().doResetStateBeforeScenario(false);
    runner.run(configuration, asList(mySteps), story);

    // Then
    verify(pendingStep).perform(Matchers.<UUIDExceptionWrapper>any());
    verify(secondStep).doNotPerform(Matchers.<UUIDExceptionWrapper>any());
    verify(secondStep, never()).perform(Matchers.<UUIDExceptionWrapper>any());
  }
  @Test
  public void shouldAllowToNotResetStateBeforeStory() throws Throwable {
    // Given
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    Step failedStep = mock(Step.class, "failedStep");
    when(failedStep.perform(null))
        .thenReturn(
            failed(
                "before stories",
                new UUIDExceptionWrapper(new RuntimeException("BeforeStories fail"))));
    Step pendingStep = mock(Step.class, "pendingStep");
    when(pendingStep.perform(null)).thenReturn(pending("pendingStep"));
    StepCollector collector = mock(StepCollector.class);
    CandidateSteps mySteps = new Steps();
    Scenario scenario1 = new Scenario();
    List<CandidateSteps> candidateSteps = asList(mySteps);
    when(collector.collectBeforeOrAfterStoriesSteps(candidateSteps, Stage.BEFORE))
        .thenReturn(asList(failedStep));
    when(collector.collectScenarioSteps(candidateSteps, scenario1, parameters))
        .thenReturn(asList(pendingStep));
    Story story = new Story(asList(scenario1));
    givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps);

    // When
    StoryRunner runner = new StoryRunner();
    Configuration configuration = configurationWith(reporter, collector);
    configuration.storyControls().doResetStateBeforeStory(false).doResetStateBeforeScenario(false);
    runner.runBeforeOrAfterStories(configuration, candidateSteps, Stage.BEFORE);
    runner.run(configuration, candidateSteps, story);

    // Then
    verify(failedStep).perform(Matchers.<UUIDExceptionWrapper>any());
    verify(pendingStep).perform(Matchers.<UUIDExceptionWrapper>any());
  }
  @Test
  public void testPlayersGetNewStatus() throws com.yazino.game.api.GameException {
    whenGameStart();
    command = commandFrom(PLAYER1_ID);
    com.yazino.game.api.GamePlayer p1 =
        new com.yazino.game.api.GamePlayer(PLAYER1_ID, SESSION_ID, "");
    com.yazino.game.api.GamePlayer p2 =
        new com.yazino.game.api.GamePlayer(PLAYER2_ID, SESSION_ID, "");
    table.setCurrentGame(gameStatus1);
    whenPlayers(p1, p2);
    when(gameRules.getObservableStatus(gameStatus1, getContextFor(p1, false, table.getIncrement())))
        .thenReturn(new PrintlnStatus());
    when(gameRules.getObservableStatus(gameStatus1, getContextFor(p2, true, table.getIncrement())))
        .thenReturn(new PrintlnStatus());
    final com.yazino.game.api.ExecutionResult result =
        new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus1)
            .scheduledEvents(emptyEvents)
            .build();
    when(gameRules.execute(
            isA(com.yazino.game.api.ExecutionContext.class), eq(command.toCommand(PLAYER_NAME))))
        .thenReturn(result);
    final List<HostDocument> hostDocuments = executeCommand();

    // table.lastGameChanges?
    assertThat(hostDocuments.size(), is(equalTo(2)));
    assertThat(
        (GameStatusHostDocument) hostDocuments.get(0), Matchers.isA(GameStatusHostDocument.class));
    assertThat(
        (GameStatusHostDocument) hostDocuments.get(1), Matchers.isA(GameStatusHostDocument.class));
  }
 private Step mockSuccessfulStep(String result) {
   Step step = mock(Step.class, result);
   when(step.perform(Matchers.<UUIDExceptionWrapper>any())).thenReturn(successful(result));
   when(step.doNotPerform(Matchers.<UUIDExceptionWrapper>any()))
       .thenReturn(notPerformed("successfulStep"));
   return step;
 }
  @Test
  public void testEquivalent() throws ResourceNotFoundException {
    Sensor newSensor = Mockito.mock(Sensor.class);
    Map<String, Object> props = new HashMap<>();
    props.put("fuelType", "diesel");
    props.put("constructionYear", 2015);
    props.put("engineDisplacement", 1234);
    props.put("model", "Dito");
    props.put("manufacturer", "Vito");
    Mockito.when(newSensor.getProperties()).thenReturn(props);

    SensorDao dao = createDao();

    CarSimilarityServiceImpl service = new CarSimilarityServiceImpl(dao);
    CarSimilarityServiceImpl serviceMock = Mockito.spy(service);
    serviceMock.setSimilarityDefinition("/car-similarity-test.json");

    Sensor equi = serviceMock.resolveEquivalent(newSensor);
    Assert.assertThat(equi, Matchers.is(oldSensor));

    props.put("manufacturer", "vito mobile  ");

    Sensor similar = serviceMock.resolveEquivalent(newSensor);
    Assert.assertThat(similar, Matchers.is(oldSensor));

    Mockito.verify(serviceMock, Mockito.times(1))
        .isManufacturerSimilar(Mockito.any(String.class), Mockito.any(String.class));
  }
  @Test
  public void testArgsWithLocationMacroAffectDependenciesAndExpands() throws Exception {
    BuildRuleResolver resolver =
        new BuildRuleResolver(TargetGraph.EMPTY, new DefaultTargetNodeToBuildRuleTransformer());
    SourcePathResolver pathResolver = new SourcePathResolver(resolver);

    BuildRule shBinaryRule =
        new ShBinaryBuilder(BuildTargetFactory.newInstance("//:my_exe"))
            .setMain(new FakeSourcePath("bin/exe"))
            .build(resolver);

    BuildRule exportFileRule =
        ExportFileBuilder.newExportFileBuilder(BuildTargetFactory.newInstance("//:file"))
            .setSrc(new FakeSourcePath("file.txt"))
            .build(resolver);

    WorkerToolBuilder workerToolBuilder =
        WorkerToolBuilder.newWorkerToolBuilder(BuildTargetFactory.newInstance("//:worker_rule"))
            .setExe(shBinaryRule.getBuildTarget())
            .setArgs("--input $(location //:file)");
    WorkerTool workerTool = (WorkerTool) workerToolBuilder.build(resolver);

    assertThat(
        workerToolBuilder.findImplicitDeps(), Matchers.hasItem(exportFileRule.getBuildTarget()));
    assertThat(workerTool.getDeps(), Matchers.hasItems(shBinaryRule, exportFileRule));
    assertThat(workerTool.getRuntimeDeps(), Matchers.hasItems(shBinaryRule, exportFileRule));
    assertThat(
        workerTool.getArgs(),
        Matchers.containsString(
            pathResolver
                .getAbsolutePath(new BuildTargetSourcePath(exportFileRule.getBuildTarget()))
                .toString()));
  }
  @Test
  public void testCreateWorkerTool() throws NoSuchBuildTargetException {
    BuildRuleResolver resolver =
        new BuildRuleResolver(TargetGraph.EMPTY, new DefaultTargetNodeToBuildRuleTransformer());

    BuildRule shBinaryRule =
        new ShBinaryBuilder(BuildTargetFactory.newInstance("//:my_exe"))
            .setMain(new FakeSourcePath("bin/exe"))
            .build(resolver);

    BuildRule workerRule =
        WorkerToolBuilder.newWorkerToolBuilder(BuildTargetFactory.newInstance("//:worker_rule"))
            .setExe(shBinaryRule.getBuildTarget())
            .setArgs("arg1 arg2")
            .build(resolver);

    assertThat(
        "getBinaryBuildRule should return the build rule supplied in the definition.",
        shBinaryRule,
        Matchers.equalToObject(((WorkerTool) workerRule).getBinaryBuildRule()));

    assertThat(
        "getArgs should return the args string supplied in the definition.",
        "arg1 arg2",
        Matchers.is(((WorkerTool) workerRule).getArgs()));
  }
  @Test
  public void testPutFacilityUuid() throws Exception {
    OrganisationUnit organisationUnit = createOrganisationUnit('A');
    manager.save(organisationUnit);

    Facility facility = new OrganisationUnitToFacilityConverter().convert(organisationUnit);
    facility.setName("FacilityB");
    facility.setActive(false);

    MockHttpSession session = getSession("ALL");

    mvc.perform(
            put("/fred/v1/facilities/" + organisationUnit.getUuid())
                .content(objectMapper.writeValueAsString(facility))
                .session(session)
                .contentType(MediaType.APPLICATION_JSON))
        .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.uuid", Matchers.notNullValue()))
        .andExpect(jsonPath("$.name").value("FacilityB"))
        .andExpect(jsonPath("$.active").value(false))
        .andExpect(jsonPath("$.createdAt", Matchers.notNullValue()))
        .andExpect(jsonPath("$.updatedAt", Matchers.notNullValue()))
        .andExpect(header().string("ETag", Matchers.notNullValue()))
        .andExpect(status().isOk());
  }
  @Test
  public void testGetByIdOrNull() throws Exception {
    assertThat(service.getByIdOrNull(new TransUnitId(2)), Matchers.equalTo(data.get(1)));

    // not in current page
    assertThat(service.getByIdOrNull(new TransUnitId(99)), Matchers.nullValue());
  }
  @Test
  public void canGetProjects() {
    Project[] projects = client.getProjects();

    assertThat(projects, Matchers.arrayWithSize(1));
    assertThat(projects[0].getId(), Matchers.equalTo("about-fedora"));
  }
  /** @see DATAREST-609 */
  @Test
  public void addsSelfAndSingleResourceLinkToResourceByDefault() throws Exception {

    Projector projector = mock(Projector.class);

    when(projector.projectExcerpt(anyObject())).thenAnswer(new ReturnsArgumentAt(0));

    PersistentEntityResourceAssembler assembler =
        new PersistentEntityResourceAssembler(
            entities,
            projector,
            associations,
            new DefaultSelfLinkProvider(
                entities, entityLinks, Collections.<EntityLookup<?>>emptyList()));

    User user = new User();
    user.id = BigInteger.valueOf(4711);

    PersistentEntityResource resource = assembler.toResource(user);

    Links links = new Links(resource.getLinks());

    assertThat(links, is(Matchers.<Link>iterableWithSize(2)));
    assertThat(links.getLink("self").getVariables(), is(Matchers.empty()));
    assertThat(links.getLink("user").getVariableNames(), is(hasItem("projection")));
  }
  @Test
  public void testDefaultRecoverAfterTime() throws IOException {

    // check that the default is not set
    GatewayService service = createService(Settings.builder());
    assertNull(service.recoverAfterTime());

    // ensure default is set when setting expected_nodes
    service = createService(Settings.builder().put("gateway.expected_nodes", 1));
    assertThat(
        service.recoverAfterTime(),
        Matchers.equalTo(GatewayService.DEFAULT_RECOVER_AFTER_TIME_IF_EXPECTED_NODES_IS_SET));

    // ensure default is set when setting expected_data_nodes
    service = createService(Settings.builder().put("gateway.expected_data_nodes", 1));
    assertThat(
        service.recoverAfterTime(),
        Matchers.equalTo(GatewayService.DEFAULT_RECOVER_AFTER_TIME_IF_EXPECTED_NODES_IS_SET));

    // ensure default is set when setting expected_master_nodes
    service = createService(Settings.builder().put("gateway.expected_master_nodes", 1));
    assertThat(
        service.recoverAfterTime(),
        Matchers.equalTo(GatewayService.DEFAULT_RECOVER_AFTER_TIME_IF_EXPECTED_NODES_IS_SET));

    // ensure settings override default
    TimeValue timeValue = TimeValue.timeValueHours(3);
    // ensure default is set when setting expected_nodes
    service =
        createService(
            Settings.builder()
                .put("gateway.expected_nodes", 1)
                .put("gateway.recover_after_time", timeValue.toString()));
    assertThat(service.recoverAfterTime().millis(), Matchers.equalTo(timeValue.millis()));
  }
  @Test
  @SuppressWarnings("unchecked")
  public void testGetTimeSinceLastMeasurement() throws Exception {
    long sleepTime = 20L;
    // fill history with the same value.
    long now = System.nanoTime() - 2 * sleepTime * 1000000;
    for (int i = 0; i < TestUtils.getPropertyValue(history, "retention", Integer.class); i++) {
      history.success(now);
    }
    final Deque<Long> times = TestUtils.getPropertyValue(history, "times", Deque.class);
    assertEquals(Long.valueOf(now), times.peekFirst());
    assertEquals(Long.valueOf(now), times.peekLast());

    // increment just so we'll have a different value between first and last
    history.success(System.nanoTime() - sleepTime * 1000000);
    assertNotEquals(times.peekFirst(), times.peekLast());

    /*
     * We've called Thread.sleep twice with the same value in quick
     * succession. If timeSinceLastSend is pulling off the correct end of
     * the queue, then we should be closer to the sleep time than we are to
     * 2 x sleepTime, but we should definitely be greater than the sleep
     * time.
     */
    double timeSinceLastMeasurement = history.getTimeSinceLastMeasurement();
    assertThat(timeSinceLastMeasurement, Matchers.greaterThan((double) (sleepTime / 100)));
    assertThat(timeSinceLastMeasurement, Matchers.lessThanOrEqualTo(1.5 * sleepTime / 100));
  }
  @Test
  public void testAfterPaneWithGlobalWindowsAndCombining() throws Exception {
    Duration windowDuration = Duration.millis(10);
    ReduceFnTester<Integer, Integer, IntervalWindow> tester =
        ReduceFnTester.combining(
            FixedWindows.of(windowDuration),
            AfterPane.<IntervalWindow>elementCountAtLeast(2),
            AccumulationMode.DISCARDING_FIRED_PANES,
            new SumIntegerFn().<String>asKeyedFn(),
            VarIntCoder.of(),
            Duration.millis(100));

    tester.injectElements(
        TimestampedValue.of(1, new Instant(1)), TimestampedValue.of(2, new Instant(9)));

    assertThat(
        tester.extractOutput(),
        Matchers.contains(WindowMatchers.isSingleWindowedValue(Matchers.equalTo(3), 1, 0, 10)));

    // This element should not be output because that trigger (which was one-time) has already
    // gone off.
    tester.injectElements(TimestampedValue.of(6, new Instant(2)));
    assertThat(tester.extractOutput(), Matchers.emptyIterable());

    assertTrue(tester.isMarkedFinished(new IntervalWindow(new Instant(0), new Instant(10))));
    assertFalse(tester.isMarkedFinished(new IntervalWindow(new Instant(10), new Instant(20))));

    tester.assertHasOnlyGlobalAndFinishedSetsFor(
        new IntervalWindow(new Instant(0), new Instant(10)));
  }
  @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)));
  }
 /**
  * Cacheable can clean cache after timeout.
  *
  * @throws Exception If something goes wrong
  */
 @Test
 public void cleansCacheWhenExpired() throws Exception {
   final CacheableTest.Foo foo = new CacheableTest.Foo(1L);
   final String first = foo.get().toString();
   TimeUnit.SECONDS.sleep((long) Tv.FIVE);
   MatcherAssert.assertThat(foo.get().toString(), Matchers.not(Matchers.equalTo(first)));
 }
  @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)));
  }
Exemple #25
0
  public void testEmptyAggregation() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("empty_bucket_idx")
            .setQuery(matchAllQuery())
            .addAggregation(
                histogram("histo")
                    .field("value")
                    .interval(1L)
                    .minDocCount(0)
                    .subAggregation(nested("nested", "nested")))
            .execute()
            .actionGet();

    assertThat(searchResponse.getHits().getTotalHits(), equalTo(2L));
    Histogram histo = searchResponse.getAggregations().get("histo");
    assertThat(histo, Matchers.notNullValue());
    Histogram.Bucket bucket = histo.getBuckets().get(1);
    assertThat(bucket, Matchers.notNullValue());

    Nested nested = bucket.getAggregations().get("nested");
    assertThat(nested, Matchers.notNullValue());
    assertThat(nested.getName(), equalTo("nested"));
    assertThat(nested.getDocCount(), is(0L));
  }
  /**
   * TODO DOCUMENT ME!
   *
   * @throws Exception
   */
  @Test
  public void testMentionedInCommit() throws Exception {
    MentionedInCommitStrategy strategy = new MentionedInCommitStrategy();

    ChangeLogSet mockChangeSet =
        MockChangeLogUtil.mockChangeLogSet(
            new MockChangeLogUtil.MockChangeLog("FOO-101 first", "knork"),
            new MockChangeLogUtil.MockChangeLog("[BAR-102] with square brackets", "zark"),
            new MockChangeLogUtil.MockChangeLog("Fixed FOO-103 inbetween", "flarp"),
            new MockChangeLogUtil.MockChangeLog("Fixed BAR-104typo", "narf"),
            new MockChangeLogUtil.MockChangeLog(
                "FOO-101 again but, because FOO-101 was invalid, but FOO-105 not", "knork"),
            new MockChangeLogUtil.MockChangeLog("Invalid [foo-103] lowercase", "flarp"),
            new MockChangeLogUtil.MockChangeLog("No Valid Ticket", "build robot"));
    AbstractBuild mockBuild = mock(AbstractBuild.class);
    when(mockBuild.getChangeSet()).thenReturn(mockChangeSet);

    List<JiraCommit> commits =
        strategy.getJiraCommits(
            mockBuild, new StreamBuildListener(System.out, Charset.defaultCharset()));

    assertEquals(commits.size(), 6);

    assertThat(
        commits, hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("FOO-101"))));
    assertThat(
        commits, hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("BAR-102"))));
    assertThat(
        commits, hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("FOO-103"))));
    assertThat(
        commits, hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("BAR-104"))));
    assertThat(
        commits, hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("FOO-105"))));
  }
  @JavascriptEnabled
  @Ignore(
      value = {SAFARI, MARIONETTE},
      reason = " Safari: issue 4061. Other platforms: not properly tested")
  @Test
  public void testChangeEventIsFiredAppropriatelyWhenFocusIsLost() {
    driver.get(pages.javascriptPage);

    WebElement input = driver.findElement(By.id("changeable"));
    input.sendKeys("test");
    moveFocus();
    assertThat(
        driver.findElement(By.id("result")).getText().trim(),
        Matchers.<String>either(is("focus change blur")).or(is("focus blur change")));

    input.sendKeys(Keys.BACK_SPACE, "t");
    moveFocus();

    // I weep.
    assertThat(
        driver.findElement(By.id("result")).getText().trim(),
        Matchers.<String>either(is("focus change blur focus blur"))
            .or(is("focus blur change focus blur"))
            .or(is("focus blur change focus blur change"))
            .or(is("focus change blur focus change blur"))); // What Chrome does
  }
  @Test
  public void sockJsAttributesSupport() {
    loadBeanDefinitions("websocket-config-handlers-sockjs-attributes.xml");
    SimpleUrlHandlerMapping handlerMapping = appContext.getBean(SimpleUrlHandlerMapping.class);
    assertNotNull(handlerMapping);
    SockJsHttpRequestHandler handler =
        (SockJsHttpRequestHandler) handlerMapping.getUrlMap().get("/test/**");
    assertNotNull(handler);
    checkDelegateHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class);
    SockJsService sockJsService = handler.getSockJsService();
    assertNotNull(sockJsService);
    assertThat(sockJsService, Matchers.instanceOf(TransportHandlingSockJsService.class));
    TransportHandlingSockJsService defaultSockJsService =
        (TransportHandlingSockJsService) sockJsService;
    assertThat(
        defaultSockJsService.getTaskScheduler(), Matchers.instanceOf(TestTaskScheduler.class));
    assertThat(
        defaultSockJsService.getTransportHandlers().values(),
        Matchers.containsInAnyOrder(
            Matchers.instanceOf(XhrPollingTransportHandler.class),
            Matchers.instanceOf(XhrStreamingTransportHandler.class)));

    assertEquals("testSockJsService", defaultSockJsService.getName());
    assertFalse(defaultSockJsService.isWebSocketEnabled());
    assertFalse(defaultSockJsService.isSessionCookieNeeded());
    assertEquals(2048, defaultSockJsService.getStreamBytesLimit());
    assertEquals(256, defaultSockJsService.getDisconnectDelay());
    assertEquals(1024, defaultSockJsService.getHttpMessageCacheSize());
    assertEquals(20, defaultSockJsService.getHeartbeatTime());
  }
  @Test
  public void testCachedPut() throws Exception {
    HttpFields header = new HttpFields();

    header.put("Connection", "Keep-Alive");
    header.put("tRansfer-EncOding", "CHUNKED");
    header.put("CONTENT-ENCODING", "gZIP");

    ByteBuffer buffer = BufferUtil.allocate(1024);
    BufferUtil.flipToFill(buffer);
    HttpGenerator.putTo(header, buffer);
    BufferUtil.flipToFlush(buffer, 0);
    String out = BufferUtil.toString(buffer).toLowerCase();

    Assert.assertThat(
        out,
        Matchers.containsString(
            (HttpHeader.CONNECTION + ": " + HttpHeaderValue.KEEP_ALIVE).toLowerCase()));
    Assert.assertThat(
        out,
        Matchers.containsString(
            (HttpHeader.TRANSFER_ENCODING + ": " + HttpHeaderValue.CHUNKED).toLowerCase()));
    Assert.assertThat(
        out,
        Matchers.containsString(
            (HttpHeader.CONTENT_ENCODING + ": " + HttpHeaderValue.GZIP).toLowerCase()));
  }
  @Test
  public void sessionIMChatAccept23()
      throws JsonGenerationException, JsonMappingException, IOException {
    Setup.startTest("Checking that User 3 has received chat closed notification");

    System.out.println("sessionID=" + sessionID);
    System.out.println("receiveSessionID=" + receiveSessionID);

    RestAssured.authentication = RestAssured.DEFAULT_AUTH;
    String url = (Setup.channelURL[3].split("username\\=")[0]) + "username="******"notificationList.chatEventNotification.eventType",
                    Matchers.hasItem("SessionEnded"),
                "notificationList.chatEventNotification.sessionId", Matchers.hasItem(sessionID),
                "notificationList.chatEventNotification.link[0].rel",
                    Matchers.hasItem("ChatSessionInformation"))
            .post(url);
    System.out.println("Response = " + response.getStatusCode() + " / " + response.asString());
    Setup.endTest();
  }