Exemplo n.º 1
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testMonitorAndContinueWithoutTimeout() {
    ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
    ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
    expect(
            schedulerMock.scheduleWithFixedDelay(
                anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
        .andReturn(mockFuture);

    replay(mockFuture);
    replay(schedulerMock);

    CoutingEventHandler handler = new CoutingEventHandler();
    EventBus eventBus = new EventBus();
    eventBus.register(handler);

    AsyncMonitor<Object> monitor =
        mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.CONTINUE), eventBus);

    assertNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.startMonitoring(null);
    assertNotNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.run();
    assertEquals(handler.numCompletes, 0);
    assertEquals(handler.numFailures, 0);
    assertEquals(handler.numTimeouts, 0);

    verify(mockFuture);
    verify(schedulerMock);
  }
 @Test
 public void testAcquireTokenAuthCode_ClientCredential() throws Exception {
   ctx =
       PowerMock.createPartialMock(
           AuthenticationContext.class,
           new String[] {"acquireTokenCommon"},
           TestConfiguration.AAD_TENANT_ENDPOINT,
           true,
           service);
   PowerMock.expectPrivate(
           ctx,
           "acquireTokenCommon",
           EasyMock.isA(AdalAuthorizatonGrant.class),
           EasyMock.isA(ClientAuthentication.class),
           EasyMock.isA(ClientDataHttpHeaders.class))
       .andReturn(
           new AuthenticationResult(
               "bearer",
               "accessToken",
               "refreshToken",
               new Date().getTime(),
               "idToken",
               null,
               false));
   PowerMock.replay(ctx);
   Future<AuthenticationResult> result =
       ctx.acquireTokenByAuthorizationCode(
           "auth_code",
           new URI(TestConfiguration.AAD_DEFAULT_REDIRECT_URI),
           new ClientCredential("clientId", "clientSecret"),
           null);
   AuthenticationResult ar = result.get();
   Assert.assertNotNull(ar);
   PowerMock.verifyAll();
 }
  @Test
  public void testCanParseBoxServerError()
      throws BoxRestException, IllegalStateException, IOException, BoxJSONException {
    BoxJSONParser jsonParser = new BoxJSONParser(new BoxResourceHub());
    EasyMock.reset(boxResponse, response, entity);
    inputStream =
        new ByteArrayInputStream(jsonParser.convertBoxObjectToJSONString(error).getBytes());
    EasyMock.expect(boxResponse.getHttpResponse()).andStubReturn(response);
    EasyMock.expect(response.getEntity()).andStubReturn(entity);
    EasyMock.expect(entity.getContent()).andStubReturn(inputStream);
    EasyMock.expect(entity.isStreaming()).andStubReturn(false);

    EasyMock.expect(boxResponse.getHttpResponse()).andStubReturn(response);
    EasyMock.expect(response.getStatusLine()).andStubReturn(statusLine);
    EasyMock.expect(statusLine.getStatusCode()).andStubReturn(statusCode);

    EasyMock.replay(boxResponse, response, entity, statusLine);
    ErrorResponseParser parser = new ErrorResponseParser(jsonParser);
    Object object = parser.parse(boxResponse);
    Assert.assertEquals(BoxServerError.class, object.getClass());

    Assert.assertEquals(
        jsonParser.convertBoxObjectToJSONString(error),
        jsonParser.convertBoxObjectToJSONString(object));
    EasyMock.verify(boxResponse, response, entity, statusLine);
  }
Exemplo n.º 4
0
 @Test
 public void testSetAction() {
   Action localAction = EasyMock.createMock(Action.class);
   EasyMock.replay(localAction);
   injecter.setAction(localAction);
   EasyMock.verify(localAction);
 }
Exemplo n.º 5
0
  /** TEST FORCE DELETING */
  @Test
  public void testForceDelete() {
    Story story = new Story();
    story.setId(1);

    Story child = new Story();
    child.setParent(story);
    story.setChildren(new ArrayList<Story>(Arrays.asList(child)));

    story.setTasks(new HashSet<Task>(Arrays.asList(new Task(), new Task())));
    story.setHourEntries(
        new HashSet<StoryHourEntry>(
            Arrays.asList(new StoryHourEntry(), new StoryHourEntry(), new StoryHourEntry())));

    taskBusiness.delete(EasyMock.isA(Task.class), EasyMock.same(HourEntryHandlingChoice.DELETE));
    expectLastCall().times(2);

    hourEntryBusiness.deleteAll(story.getHourEntries());

    storyDAO.remove(1);

    replayAll();
    storyBusiness.forceDelete(story);
    verifyAll();

    assertNull("Child story's parent not null", child.getParent());
    assertEquals("Parent story's children not empty", 0, story.getChildren().size());
  }
  @Test
  public void testForNonUniqueCodeListNotExisting() {
    String name = "TestCodeList";
    String catId = "1";
    String codeSystemId = "2";
    String steward = "TestSteward";
    String stewardOther = null;
    String oid = "3";

    ManageCodeListDetailModel model1 = new ManageCodeListDetailModel();
    model1.setName(name);
    model1.setCategory(catId);
    model1.setCodeSystem(codeSystemId);
    model1.setSteward(steward);
    model1.setStewardOther(stewardOther);
    model1.setOid(oid);
    //
    // editing a code list so that it matches a different existing code list
    //
    ManageCodeListDetailModel model = new ManageCodeListDetailModel();
    model.setName(name);
    model.setCategory(catId);
    model.setSteward(steward);
    model.setCodeSystem(codeSystemId);

    CodeList existingCl = new CodeList();
    String id = "id";
    model.setExistingCodeList(false);
    existingCl.setId(id);
    EasyMock.expect(codeListDAO.getCodeList(model1, LoggedInUserUtil.getLoggedInUser()))
        .andReturn(existingCl);
    EasyMock.replay(codeListDAO);

    assertFalse(codeListService.isCodeListUnique(model));
  }
  @Test
  public void testEmptyHostmapUseCase() throws Exception {
    URL configUrl = TestUtils.getResourceUrl(this.getClass(), "empty-hostmap.txt");

    UrlRewriteEnvironment environment = EasyMock.createNiceMock(UrlRewriteEnvironment.class);
    EasyMock.expect(environment.getResource("/WEB-INF/hostmap.txt"))
        .andReturn(configUrl)
        .anyTimes();
    Resolver resolver = EasyMock.createNiceMock(Resolver.class);
    EasyMock.expect(resolver.resolve("host"))
        .andReturn(Arrays.asList("test-inbound-host"))
        .anyTimes();
    EasyMock.replay(environment, resolver);

    UrlRewriteRulesDescriptor descriptor = UrlRewriteRulesDescriptorFactory.create();
    UrlRewriteRuleDescriptor rule = descriptor.addRule("test-rule");
    rule.pattern("{*}://{host}:{*}/{**}?{**}");
    UrlRewriteActionRewriteDescriptorExt rewrite = rule.addStep("rewrite");
    rewrite.template("{*}://{$hostmap(host)}:{*}/{**}?{**}");

    UrlRewriteProcessor rewriter = new UrlRewriteProcessor();
    rewriter.initialize(environment, descriptor);

    Template input =
        Parser.parseLiteral(
            "test-scheme://test-inbound-host:42/test-path/test-file?test-name=test-value");
    Template output = rewriter.rewrite(resolver, input, UrlRewriter.Direction.IN, null);
    // System.out.println( output );
    assertThat(output, notNullValue());
    assertThat(output.getHost().getFirstValue().getPattern(), is("test-inbound-host"));
  }
  @Test
  public void testDeployProcess() throws PluginException {
    HashSet<RequestParameterType<?>> mandatoryProperties = new HashSet<>();
    RequestParameterType<String> prop = new RequestParameterType<>("test", "test");
    mandatoryProperties.add(prop);

    CanonicalProcessType cpf = new CanonicalProcessType();
    AnnotationsType anf = new AnnotationsType();

    expect(mockDeploymentPlugin.getNativeType()).andReturn("test");
    expect(mockDeploymentPlugin.getName()).andReturn("test");
    expect(mockDeploymentPlugin.getVersion()).andReturn("1.0");
    PluginResultImpl result = new PluginResultImpl();
    result.addPluginMessage("test");
    expect(
            mockDeploymentPlugin.deployProcess(
                EasyMock.eq(cpf), EasyMock.eq(anf), EasyMock.anyObject(PluginRequest.class)))
        .andReturn(result);

    replay(mockDeploymentPlugin);

    List<PluginMessage> messages = myService.deployProcess("test", cpf, anf, mandatoryProperties);
    assertTrue(messages.size() == 1);

    verify(mockDeploymentPlugin);
  }
  @SuppressWarnings("unchecked")
  @Test
  public void checkRPCCallSuccess() {
    // Setup
    Button button = GwtReflectionUtils.getPrivateFieldValue(composite, "button");
    Label label = GwtReflectionUtils.getPrivateFieldValue(composite, "label");

    service.createBean(EasyMock.eq("OCTO"), EasyMock.isA(AsyncCallback.class));

    FooBean expected = new FooBean();
    expected.setName("mocked");

    expectServiceAndCallbackOnSuccess(expected);

    // replay all @Mock objects
    replay();

    Assert.assertEquals("", label.getText());

    // Test
    Browser.click(button);

    // Assert
    // verify all @Mock objects
    verify();

    Assert.assertEquals("Bean \"mocked\" has been created", label.getText());
  }
Exemplo n.º 10
0
  /**
   * Test de verification de deplacement du singe.
   *
   * @throws Exception expection technique de l'acces a la methode privee
   */
  @Test
  public void testVerifierDeplacementSinge() throws Exception {
    final List<SingeErratique> erratiques = new ArrayList<SingeErratique>();
    this.preparerAutreSingeHaut();
    erratiques.add(this.singeErratiqueMock);
    EasyMock.expect(this.bandeDeSingesErratiquesMock.getSingesErratiques())
        .andStubReturn(erratiques);
    EasyMock.replay(this.bandeDeSingesErratiquesMock);

    this.preparerPirateMock(2, 3);
    this.preparerIleMock();

    // Accessibilité de la méthode privée
    final Method method =
        SingeErratique.class.getDeclaredMethod("verifierDeplacementSinge", int.class, int.class);
    method.setAccessible(true);

    // * Déplacement autorisé
    // Sur la terre
    Assert.assertFalse(((boolean) method.invoke(this.singeErratiqueIleMock, 2, 1)));

    // Pirate
    Assert.assertFalse(((boolean) method.invoke(this.singeErratiqueIleMock, 2, 3)));

    // * Déplacement interdit
    // Autre singe
    Assert.assertTrue(((boolean) method.invoke(this.singeErratiqueIleMock, 1, 2)));

    // Dans l'eau
    Assert.assertTrue(((boolean) method.invoke(this.singeErratiqueIleMock, 2, 0)));
  }
 @Test
 public void testIteratorInSamePartition() throws Exception {
   EasyMock.expect(
           this.consumer.get(
               this.topic,
               new Partition("0-0"),
               0L,
               this.maxSize,
               this.timeoutInMills,
               TimeUnit.MILLISECONDS))
       .andReturn(new MessageIterator(this.topic, this.createMessageBuffer()))
       .once();
   EasyMock.expect(
           this.consumer.get(
               this.topic,
               new Partition("0-0"),
               25L,
               this.maxSize,
               this.timeoutInMills,
               TimeUnit.MILLISECONDS))
       .andReturn(new MessageIterator(this.topic, this.createMessageBuffer()))
       .once();
   this.control.replay();
   Iterator<Message> it = this.browser.iterator();
   if (it.hasNext()) {
     this.assertMsg(it.next());
   }
   if (it.hasNext()) {
     this.assertMsg(it.next());
   }
   this.control.verify();
   MetaTopicBrowser.Itr mit = (MetaTopicBrowser.Itr) it;
   assertEquals(2, mit.partitions.size());
   assertFalse(mit.partitions.contains(new Partition("0-0")));
 }
Exemplo n.º 12
0
  @Test
  public void testStart() throws Exception {
    RoundRobinSchedulerStats stats =
        EasyMock.createMockBuilder(RoundRobinSchedulerStats.class)
            .withConstructor()
            .addMockedMethod("registerMBean")
            .addMockedMethod("createMovingAverage")
            .createStrictMock();

    MovingAverage mavg = EasyMock.createStrictMock(MovingAverage.class);
    EasyMock.expect(stats.createMovingAverage()).andReturn(mavg);
    mavg.startTimer("RoundRobinAddMavg", stats.getAddMavgPeriod(), TimeUnit.MILLISECONDS);
    EasyMock.expectLastCall();

    stats.registerMBean();
    EasyMock.expectLastCall();

    EasyMock.replay(stats, mavg);
    stats.start();
    EasyMock.verify(stats, mavg);
    assertEquals("Mavg not set.", mavg, stats.m_addMavg);

    // with already called
    EasyMock.reset(stats, mavg);
    EasyMock.replay(stats, mavg);
    stats.start();
    EasyMock.verify(stats, mavg);
  }
Exemplo n.º 13
0
 @Before
 public void setUp() {
   peekIterator = EasyMock.createMock(PeekingIterator.class);
   comparator = EasyMock.createMock(Comparator.class);
   binaryFn = EasyMock.createMock(BinaryFn.class);
   testingIterator = CombiningIterator.create(peekIterator, comparator, binaryFn);
 }
Exemplo n.º 14
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testStartMonitoringWithTimeout() {
    ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
    ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
    expect(
            schedulerMock.scheduleWithFixedDelay(
                anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
        .andReturn(mockFuture);

    replay(mockFuture);
    replay(schedulerMock);

    AsyncMonitor<Object> monitor =
        mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.DONE), new EventBus());

    assertNull(monitor.getFuture());
    assertNull(monitor.getTimeout());

    monitor.startMonitoring(100L);

    assertNotNull(monitor.getFuture());
    assertNotNull(monitor.getTimeout());
    assertTrue(monitor.getTimeout() > 100L);

    verify(mockFuture);
    verify(schedulerMock);
  }
  private OpenStreetMapSimpleImporter createImporterThatThrows() {
    OpenStreetMapSimpleImporter importer =
        new OpenStreetMapSimpleImporter() {
          @Override
          public boolean shouldBeSkipped() {
            return false;
          }

          @Override
          public long getNumberOfLinesToProcess() {
            return 2L;
          }

          @Override
          protected void tearDown() {
            return;
          }
        };

    // ImporterConfig config = new ImporterConfig();
    // config.setOpenStreetMapDir(this.openStreetMapImporter.importerConfig.getOpenStreetMapDir());
    IOpenStreetMapDao dao = EasyMock.createNiceMock(IOpenStreetMapDao.class);
    // now we simulate the fact that the dao should not be called
    EasyMock.expect(dao.save((OpenStreetMap) EasyMock.anyObject()))
        .andThrow(new RuntimeException("message"));
    EasyMock.replay(dao);
    importer.setOpenStreetMapDao(dao);
    importer.setImporterConfig(new ImporterConfig());
    // importer.setTransactionManager(openStreetMapImporter.transactionManager);
    return importer;
  }
Exemplo n.º 16
0
  private Message mockMessage(
      String baseAddress, String pathInfo, String query, List<ClassResourceInfo> cris)
      throws Exception {
    Message m = new MessageImpl();
    Exchange e = new ExchangeImpl();
    e.put(Service.class, new JAXRSServiceImpl(cris));
    m.setExchange(e);
    control.reset();
    ServletDestination d = control.createMock(ServletDestination.class);
    EndpointInfo epr = new EndpointInfo();
    epr.setAddress(baseAddress);
    d.getEndpointInfo();
    EasyMock.expectLastCall().andReturn(epr).anyTimes();

    Endpoint endpoint = new EndpointImpl(null, null, epr);
    e.put(Endpoint.class, endpoint);
    endpoint.put(ServerProviderFactory.class.getName(), ServerProviderFactory.getInstance());
    e.setDestination(d);
    BindingInfo bi = control.createMock(BindingInfo.class);
    epr.setBinding(bi);
    bi.getProperties();
    EasyMock.expectLastCall().andReturn(Collections.emptyMap()).anyTimes();
    m.put(Message.REQUEST_URI, pathInfo);
    m.put(Message.QUERY_STRING, query);
    m.put(Message.HTTP_REQUEST_METHOD, "GET");
    control.replay();
    return m;
  }
  @Test
  public void testForNonUniqueGroupedCodeListExistingMatch() throws Exception {
    String name = "TestCodeList";
    String catId = "1";
    String steward = "TestSteward";
    //
    // editing a code list so that it matches a different existing code list
    //
    ManageCodeListDetailModel model = new ManageCodeListDetailModel();
    model.setName(name);
    model.setCategory(catId);
    model.setSteward(steward);
    ListObject codeList = new ListObject();

    ListObject existingCl = new ListObject();
    String id = "id";
    model.setID(id);
    model.setExistingCodeList(true);
    existingCl.setId(id);
    EasyMock.expect(listObjectDAO.find(id)).andReturn(codeList);
    EasyMock.expect(
            listObjectDAO.getListObject(name, steward, catId, LoggedInUserUtil.getLoggedInUser()))
        .andReturn(existingCl);
    EasyMock.replay(listObjectDAO);

    assertTrue(codeListService.isGroupedCodeListUnique(model));
  }
Exemplo n.º 18
0
  @Test
  public void testGetBuildTargetForAlias() throws IOException, NoSuchBuildTargetException {
    BuildTargetParser parser = EasyMock.createMock(BuildTargetParser.class);
    EasyMock.expect(parser.parse("//java/com/example:foo", ParseContext.fullyQualified()))
        .andReturn(BuildTargetFactory.newInstance("//java/com/example:foo"));
    EasyMock.expect(parser.parse("//java/com/example:bar", ParseContext.fullyQualified()))
        .andReturn(BuildTargetFactory.newInstance("//java/com/example:bar"));
    EasyMock.replay(parser);

    Reader reader =
        new StringReader(
            Joiner.on('\n')
                .join("[alias]", "foo = //java/com/example:foo", "bar = //java/com/example:bar"));
    BuckConfig config = createWithDefaultFilesystem(reader, parser);
    assertEquals("//java/com/example:foo", config.getBuildTargetForAlias("foo"));
    assertEquals("//java/com/example:bar", config.getBuildTargetForAlias("bar"));
    assertNull(
        "Invalid alias names, such as build targets, should be tolerated by this method.",
        config.getBuildTargetForAlias("//java/com/example:foo"));
    assertNull(config.getBuildTargetForAlias("baz"));

    Reader noAliasesReader = new StringReader("");
    BuckConfig noAliasesConfig = createWithDefaultFilesystem(noAliasesReader, parser);
    assertNull(noAliasesConfig.getBuildTargetForAlias("foo"));
    assertNull(noAliasesConfig.getBuildTargetForAlias("bar"));
    assertNull(noAliasesConfig.getBuildTargetForAlias("baz"));

    EasyMock.verify(parser);
  }
  @Test
  public void testTranslate() {

    String expectedLookUp = "lookUp";
    String expectedKey = "foo";
    String expectedLookUpKeyStr = "(" + expectedLookUp + ")" + expectedKey;
    LookUpKey expectedLookUpKey = new LookUpKey(expectedLookUp, expectedKey, expectedLookUpKeyStr);
    String expectedValue = "bar";

    Property property = new Property(expectedLookUpKeyStr, expectedValue);

    LookUpKeyResolver lookUpKeyResolver = EasyMock.createStrictMock(LookUpKeyResolver.class);
    EasyMock.expect(lookUpKeyResolver.resolve(property.getKey())).andReturn(expectedLookUpKey);
    EasyMock.replay(lookUpKeyResolver);

    PropertyServiceImpl service = new PropertyServiceImpl(lookUpKeyResolver);

    ClearProperty clearProperty = service.translate(property);

    Assert.assertNotNull(clearProperty);
    Assert.assertNotNull(clearProperty.getLookUpKey());
    Assert.assertNotNull(clearProperty.getKey());
    Assert.assertNotNull(clearProperty.getValue());
    Assert.assertNotNull(clearProperty.getLookUpKey().getKey());
    Assert.assertNotNull(clearProperty.getLookUpKey().getLookUp());

    Assert.assertEquals(clearProperty.getKey(), expectedKey);
    Assert.assertEquals(clearProperty.getValue(), expectedValue);
    Assert.assertEquals(clearProperty.getLookUpKey().getLookUp(), expectedLookUp);
    Assert.assertEquals(clearProperty.getLookUpKey().getLookUpKey(), expectedLookUpKeyStr);
  }
Exemplo n.º 20
0
  @Test
  public void testReferentialAliases() throws IOException, NoSuchBuildTargetException {
    BuildTargetParser parser = EasyMock.createMock(BuildTargetParser.class);
    EasyMock.expect(parser.parse("//java/com/example:foo", ParseContext.fullyQualified()))
        .andReturn(BuildTargetFactory.newInstance("//java/com/example:foo"));
    EasyMock.expect(parser.parse("//java/com/example:bar", ParseContext.fullyQualified()))
        .andReturn(BuildTargetFactory.newInstance("//java/com/example:bar"));
    EasyMock.replay(parser);

    Reader reader =
        new StringReader(
            Joiner.on('\n')
                .join(
                    "[alias]",
                    "foo            = //java/com/example:foo",
                    "bar            = //java/com/example:bar",
                    "foo_codename   = foo",
                    "",
                    "# Do not delete these: automation builds require these aliases to exist!",
                    "automation_foo = foo_codename",
                    "automation_bar = bar"));
    BuckConfig config = createWithDefaultFilesystem(reader, parser);
    assertEquals("//java/com/example:foo", config.getBuildTargetForAlias("foo"));
    assertEquals("//java/com/example:bar", config.getBuildTargetForAlias("bar"));
    assertEquals("//java/com/example:foo", config.getBuildTargetForAlias("foo_codename"));
    assertEquals("//java/com/example:foo", config.getBuildTargetForAlias("automation_foo"));
    assertEquals("//java/com/example:bar", config.getBuildTargetForAlias("automation_bar"));
    assertNull(config.getBuildTargetForAlias("baz"));

    EasyMock.verify(parser);
  }
Exemplo n.º 21
0
 @Test
 public void testSetClassResource() {
   ClassResource cr = EasyMock.createMock(ClassResource.class);
   EasyMock.replay(cr);
   injecter.setClassResource(cr);
   EasyMock.verify(cr);
 }
Exemplo n.º 22
0
  @Test
  public void testIgnorePaths() throws IOException {
    ProjectFilesystem filesystem = EasyMock.createMock(ProjectFilesystem.class);
    EasyMock.expect(filesystem.getPathRelativizer())
        .andReturn(Functions.<String>identity())
        .times(2);
    BuildTargetParser parser = EasyMock.createMock(BuildTargetParser.class);
    EasyMock.replay(filesystem, parser);

    Reader reader =
        new StringReader(
            Joiner.on('\n').join("[project]", "ignore = .git, foo, bar/, baz//, a/b/c"));
    BuckConfig config = BuckConfig.createFromReader(reader, filesystem, parser, Platform.detect());

    ImmutableSet<String> ignorePaths = config.getIgnorePaths();
    assertEquals(
        "Should ignore paths, sans trailing slashes",
        ignorePaths,
        ImmutableSet.of(
            BuckConstant.BUCK_OUTPUT_DIRECTORY,
            ".idea",
            System.getProperty(BuckConfig.BUCK_BUCKD_DIR_KEY, ".buckd"),
            config.getCacheDir(),
            ".git",
            "foo",
            "bar",
            "baz",
            "a/b/c"));

    EasyMock.verify(filesystem, parser);
  }
Exemplo n.º 23
0
  @Test
  public void inloggenMetOnjuistWachtwoord() {
    Medewerker medewerker = new Medewerker();
    medewerker.setIdentificatie("emailadres");
    medewerker.setHashWachtwoord("wachtwoord");

    try {
      EasyMock.expect(gebruikerRepository.zoek("emailadres")).andReturn(medewerker);
    } catch (NietGevondenException e1) {
      fail();
    }

    HttpSession httpSession = EasyMock.createMock(HttpSession.class);
    EasyMock.expect(servletRequest.getSession()).andReturn(httpSession);
    EasyMock.expect(servletRequest.getRemoteAddr()).andReturn("1234");

    EasyMock.expect(httpSession.getId()).andReturn("234");

    replayAll();

    try {
      gebruikerService.inloggen("emailadres", "foutwachtwoord", "false", servletRequest);
      fail("exception verwacht");
    } catch (OnjuistWachtwoordException e) {
      // Verwacht..
    } catch (LeegVeldException | NietGevondenException e) {
      fail(e.getMessage());
    }

    verifyAll();
  }
  @Test
  public void testConfigurationEventAdded() throws Exception {
    String testPid = SecuredCommandConfigTransformer.PROXY_COMMAND_ACL_PID_PREFIX + "test123";
    Configuration conf = EasyMock.createMock(Configuration.class);
    EasyMock.expect(conf.getPid()).andReturn(testPid).anyTimes();
    EasyMock.replay(conf);

    ConfigurationAdmin cm = EasyMock.createMock(ConfigurationAdmin.class);
    EasyMock.expect(cm.listConfigurations(EasyMock.isA(String.class))).andReturn(null).anyTimes();
    EasyMock.expect(cm.getConfiguration(testPid)).andReturn(conf).anyTimes();
    EasyMock.replay(cm);

    final List<String> generateCalled = new ArrayList<String>();
    SecuredCommandConfigTransformer scct =
        new SecuredCommandConfigTransformer() {
          @Override
          void generateServiceGuardConfig(Configuration config) throws IOException {
            generateCalled.add(config.getPid());
          }
        };
    scct.setConfigAdmin(cm);
    scct.init();

    @SuppressWarnings("unchecked")
    ServiceReference<ConfigurationAdmin> cmRef = EasyMock.createMock(ServiceReference.class);
    EasyMock.replay(cmRef);

    ConfigurationEvent event =
        new ConfigurationEvent(cmRef, ConfigurationEvent.CM_UPDATED, null, testPid);

    assertEquals("Precondition", 0, generateCalled.size());
    scct.configurationEvent(event);
    assertEquals(1, generateCalled.size());
    assertEquals(testPid, generateCalled.iterator().next());
  }
Exemplo n.º 25
0
  public void testShouldBuildJiraOkUsingElementAndFixVersionsWithMoreThanOneFixVersion() {
    Element e = createClassMock(Element.class);
    List<JiraVersion> fixVersions = createInterfaceMock(List.class);

    setupMockActualsForElement(e, "LLU-1", "Blah", "BlahStatus", "BlahResolution", "BlahType");
    EasyMock.expect(fixVersions.get(0)).andReturn(TestObjects.Version_10);
    EasyMock.expect(fixVersions.size()).andReturn(2);

    replay();

    JiraIssue jira = jiraBuilder.buildJira(e, fixVersions);

    verify();

    assertJiraDetails(
        jira,
        "LLU-1",
        "Blah",
        "BlahStatus",
        "BlahResolution",
        "BlahType",
        new JiraVersion[] {TestObjects.Version_10});
    assertEquals(1, jira.getFixVersions().size());
    assertEquals(TestObjects.Version_10, jira.getFixVersions().get(0));
    assertEquals(null, jira.getBuildNo());
  }
Exemplo n.º 26
0
  @Test
  public void testReplace() {
    final AnalysesModel model = new AnalysesModel();
    final MCMCPresentation inco1 = new MCMCPresentation(d_wrapper, "inco1");
    final MCMCPresentation inco2 = new MCMCPresentation(d_wrapper, "inco2");

    model.add(ModelType.Inconsistency, inco1);
    JUnitUtil.assertAllAndOnly(
        model.getModels(ModelType.Inconsistency), Collections.singleton(inco1));

    TreeModelListener listener = EasyMock.createStrictMock(TreeModelListener.class);

    TreeModelEvent event1a =
        new TreeModelEvent(
            model,
            new Object[] {model.getRoot(), ModelType.Inconsistency},
            new int[] {0},
            new Object[] {inco2});
    listener.treeNodesChanged(TreeModelEventMatcher.eqTreeModelEvent(event1a));

    EasyMock.replay(listener);
    model.addTreeModelListener(listener);
    model.replace(ModelType.Inconsistency, inco1, inco2);
    EasyMock.verify(listener);

    JUnitUtil.assertAllAndOnly(
        model.getModels(ModelType.Inconsistency), Collections.singleton(inco2));
  }
Exemplo n.º 27
0
  @Test
  public void testCreateMods() {
    ModsDefinition mods = new ModsDefinition();
    NdkPeriodicalMapper mapper = new NdkPeriodicalMapper();
    Context ctx = EasyMock.createMock(Context.class);
    EasyMock.expect(ctx.getPid()).andReturn("uuid:testId").anyTimes();
    EasyMock.replay(ctx);

    mapper.createMods(mods, ctx);
    List<IdentifierDefinition> identifiersResult = mods.getIdentifier();
    assertEquals(1, identifiersResult.size());
    IdentifierDefinition idResult = identifiersResult.get(0);
    assertEquals("uuid", idResult.getType());
    assertEquals("testId", idResult.getValue());

    assertEquals(1, mods.getTypeOfResource().size());
    assertEquals("text", mods.getTypeOfResource().get(0).getValue());

    assertEquals(1, mods.getGenre().size());
    assertEquals("title", mods.getGenre().get(0).getValue());

    assertEquals(1, mods.getOriginInfo().size());
    assertEquals(1, mods.getOriginInfo().get(0).getIssuance().size());
    assertEquals(IssuanceDefinition.CONTINUING, mods.getOriginInfo().get(0).getIssuance().get(0));
    assertEquals(0, mods.getOriginInfo().get(0).getPlace().size());
  }
  @Test
  public void testGetNearestCity_filterMunicipality() {
    ImporterConfig importerConfig = new ImporterConfig();
    importerConfig.setGeonamesImporterEnabled(true);
    importerConfig.setOpenStreetMapFillIsIn(true);
    OpenStreetMapSimpleImporter openStreetMapImporter = new OpenStreetMapSimpleImporter();
    openStreetMapImporter.setImporterConfig(importerConfig);
    final String cityName = "cityName";
    final Integer population = 123;
    final City city = new City();
    city.setName(cityName);
    city.setPopulation(population);

    ICityDao citydao = EasyMock.createMock(ICityDao.class);
    Point location = GeolocHelper.createPoint(2F, 3F);
    String countryCode = "FR";
    EasyMock.expect(
            citydao.getNearest(location, countryCode, true, OpenStreetMapSimpleImporter.DISTANCE))
        .andReturn(city);
    EasyMock.replay(citydao);

    openStreetMapImporter.setCityDao(citydao);

    City actual = openStreetMapImporter.getNearestCity(location, countryCode, true);
    Assert.assertEquals(cityName, actual.getName());
    Assert.assertEquals(population, actual.getPopulation());
    EasyMock.verify(citydao);
  }
  @Test
  public void testGetQueryNoCache() throws Exception {
    final PermissionsFilterCache cache = mockController.getMock(PermissionsFilterCache.class);
    final BooleanQuery generatedQuery = new BooleanQuery();

    org.easymock.EasyMock.expect(cache.getQuery(theUser)).andReturn(null);

    cache.storeQuery(generatedQuery, theUser);
    org.easymock.EasyMock.expectLastCall();

    replay();
    final PermissionQueryFactory permissionQueryFactory =
        new PermissionQueryFactory() {
          public Query getQuery(com.atlassian.crowd.embedded.api.User searcher, int permissionId) {
            assertSame(theUser, searcher);
            assertEquals(Permissions.BROWSE, permissionId);
            return generatedQuery;
          }
        };

    final PermissionsFilterGeneratorImpl generator =
        new PermissionsFilterGeneratorImpl(permissionQueryFactory) {
          @Override
          PermissionsFilterCache getCache() {
            return cache;
          }
        };

    final Query result = generator.getQuery(theUser);

    assertSame(generatedQuery, result);
  }
  public static FedoraAccessImpl prepareFedoraAccess(StatisticsAccessLog acLog)
      throws NoSuchMethodException, IOException, ParserConfigurationException, SAXException,
          LexerException {
    FedoraAccessImpl fa33 =
        createMockBuilder(FedoraAccessImpl.class)
            .withConstructor(KConfiguration.getInstance(), acLog)
            .addMockedMethod("getFedoraDescribeStream")
            .addMockedMethod("getRelsExt")
            .addMockedMethod("isImageFULLAvailable")
            .addMockedMethod("getDC")
            .addMockedMethod("getBiblioMods")
            .addMockedMethod(
                FedoraAccessImpl.class.getMethod("getKrameriusModelName", String.class))
            .createMock();

    EasyMock.expect(fa33.getFedoraDescribeStream()).andReturn(DataPrepare.fedoraProfile33());

    DataPrepare.drobnustkyRelsExt(fa33);
    DataPrepare.drobnustkyWithIMGFULL(fa33);
    DataPrepare.drobnustkyDCS(fa33);
    DataPrepare.drobnustkyMODS(fa33);

    Set<String> keySet = DocumentServiceTest.MODELS_MAPPING.keySet();
    for (String key : keySet) {
      String model = DocumentServiceTest.MODELS_MAPPING.get(key);
      PIDParser pidParser = new PIDParser(model);
      pidParser.disseminationURI();
      String modelK4Name = pidParser.getObjectId();
      EasyMock.expect(fa33.getKrameriusModelName(key)).andReturn(modelK4Name).anyTimes();
    }
    return fa33;
  }