@Test
  public void testExecutePLSQLBuilderWithStatement() {
    MockBuilder builder =
        new MockBuilder() {
          @Override
          public void configure() {
            plsql(dataSource)
                .statement("Test Statement")
                .statement("Test2 Statement")
                .statement("Test3 Statement");
          }
        };

    builder.run(null, null);

    Assert.assertEquals(builder.testCase().getActions().size(), 1);
    Assert.assertEquals(
        builder.testCase().getActions().get(0).getClass(), ExecutePLSQLAction.class);

    ExecutePLSQLAction action = (ExecutePLSQLAction) builder.testCase().getActions().get(0);
    Assert.assertEquals(action.getName(), ExecutePLSQLAction.class.getSimpleName());
    Assert.assertEquals(action.isIgnoreErrors(), false);
    Assert.assertEquals(
        action.getStatements().toString(), "[Test Statement, Test2 Statement, Test3 Statement]");
    Assert.assertNull(action.getScript());
    Assert.assertNull(action.getSqlResourcePath());
    Assert.assertEquals(action.getDataSource(), dataSource);
  }
Example #2
0
  @Test
  public void testViewCardinalities() {
    // SwitcherView should appear differently depending on number of views available
    // Multiple views -> Combo box
    // One view       -> Label
    // No views       -> Neither

    // Create the test object
    View switcherView = SwitcherView.VIEW_INFO.createView(mockComponent);

    // During normal initialization, should have two view infos.
    // A Combo Box should be found.
    Assert.assertNotNull(findComponent(switcherView, JComboBox.class));

    // With only one view info, should have a label instead
    Mockito.when(mockComponent.getViewInfos(ViewType.OBJECT))
        .thenReturn(Collections.singleton(mockViewInfo1));
    switcherView = SwitcherView.VIEW_INFO.createView(mockComponent);

    Assert.assertNull(findComponent(switcherView, JComboBox.class));
    Assert.assertNotNull(findComponent(switcherView, JLabel.class));

    // With no views, there should be no label or combo box
    Mockito.when(mockComponent.getViewInfos(ViewType.OBJECT))
        .thenReturn(Collections.<ViewInfo>emptySet());
    switcherView = SwitcherView.VIEW_INFO.createView(mockComponent);

    Assert.assertNull(findComponent(switcherView, JComboBox.class));
    Assert.assertNull(findComponent(switcherView, JLabel.class));
  }
  @Test
  public void testReplace() {
    Assert.assertEquals(_VALUE_1, _ehcachePortalCache.get(_KEY_1));
    Assert.assertNull(_ehcachePortalCache.get(_KEY_2));

    // Replace 1

    Assert.assertEquals(_VALUE_1, _ehcachePortalCache.replace(_KEY_1, _VALUE_2));

    Assert.assertEquals(_VALUE_2, _ehcachePortalCache.get(_KEY_1));
    Assert.assertNull(_ehcachePortalCache.get(_KEY_2));

    _defaultCacheListener.assertActionsCount(1);
    _defaultCacheListener.assertUpdated(_KEY_1, _VALUE_2);

    _defaultCacheListener.reset();

    // Replace 2

    Assert.assertNull(_ehcachePortalCache.replace(_KEY_2, _VALUE_2));

    Assert.assertEquals(_VALUE_2, _ehcachePortalCache.get(_KEY_1));
    Assert.assertNull(_ehcachePortalCache.get(_KEY_2));

    _defaultCacheListener.assertActionsCount(0);

    // Replace 3

    Assert.assertFalse(_ehcachePortalCache.replace(_KEY_1, _VALUE_1, _VALUE_2));

    Assert.assertEquals(_VALUE_2, _ehcachePortalCache.get(_KEY_1));
    Assert.assertNull(_ehcachePortalCache.get(_KEY_2));

    _defaultCacheListener.assertActionsCount(0);
  }
Example #4
0
  @Test(dependsOnMethods = "updateCollectionsRemoveWithWhereOperator")
  public void updateMapsWithPutOperatorAndWhere() {

    ODocument doc =
        database
            .command(
                new OCommandSQL(
                    "insert into cluster:default (equaledges, name, properties) values ('no', 'updateMapsWithPutOperatorAndWhere', {} )"))
            .execute();

    Integer records =
        database
            .command(
                new OCommandSQL(
                    "update "
                        + doc.getIdentity()
                        + " put properties = 'one', 'two' where name = 'updateMapsWithPutOperatorAndWhere'"))
            .execute();

    Assert.assertEquals(records.intValue(), 1);

    ODocument loadedDoc = database.load(doc.getIdentity(), "*:-1", true);

    Assert.assertTrue(loadedDoc.field("properties") instanceof Map);

    @SuppressWarnings("unchecked")
    Map<Object, Object> entries = loadedDoc.field("properties");
    Assert.assertEquals(entries.size(), 1);

    Assert.assertNull(entries.get("round"));
    Assert.assertNull(entries.get("blaaa"));

    Assert.assertEquals(entries.get("one"), "two");
  }
  @Test(description = "convert a model with list property")
  public void listPropertyTest() {
    final Model model =
        new ModelImpl()
            .description("a sample model")
            .property("id", new LongProperty())
            .property("urls", new ArrayProperty().items(new StringProperty()))
            .required("id");
    final DefaultCodegen codegen = new TypeScriptFetchClientCodegen();
    final CodegenModel cm = codegen.fromModel("sample", model);

    Assert.assertEquals(cm.name, "sample");
    Assert.assertEquals(cm.classname, "Sample");
    Assert.assertEquals(cm.description, "a sample model");
    Assert.assertEquals(cm.vars.size(), 2);

    final CodegenProperty property1 = cm.vars.get(0);
    Assert.assertEquals(property1.baseName, "id");
    Assert.assertEquals(property1.datatype, "number");
    Assert.assertEquals(property1.name, "id");
    Assert.assertEquals(property1.defaultValue, "null");
    Assert.assertEquals(property1.baseType, "number");
    Assert.assertTrue(property1.hasMore);
    Assert.assertTrue(property1.required);
    Assert.assertTrue(property1.isNotContainer);

    final CodegenProperty property2 = cm.vars.get(1);
    Assert.assertEquals(property2.baseName, "urls");
    Assert.assertEquals(property2.datatype, "Array<string>");
    Assert.assertEquals(property2.name, "urls");
    Assert.assertEquals(property2.baseType, "Array");
    Assert.assertNull(property2.hasMore);
    Assert.assertNull(property2.required);
    Assert.assertTrue(property2.isContainer);
  }
Example #6
0
 public void testAbstract() {
   final FunctionExclusionGroups groups =
       new AbstractFunctionExclusionGroups<String>() {
         @Override
         protected String getKey(final FunctionDefinition function) {
           if (function.getShortName().startsWith("A_")) {
             return "A";
           } else if (function.getShortName().startsWith("B_")) {
             return "B";
           } else {
             return null;
           }
         }
       };
   final FunctionDefinition a_foo = new Function("A_foo");
   final FunctionDefinition a_bar = new Function("A_bar");
   final FunctionDefinition b_foo = new Function("B_foo");
   final FunctionDefinition b_bar = new Function("B_bar");
   final FunctionDefinition foo = new Function("foo");
   final FunctionDefinition bar = new Function("bar");
   assertNull(groups.getExclusionGroup(foo));
   assertNull(groups.getExclusionGroup(bar));
   final FunctionExclusionGroup afoo1 = groups.getExclusionGroup(a_foo);
   final FunctionExclusionGroup afoo2 = groups.getExclusionGroup(a_foo);
   assertEquals(afoo1, afoo2);
   final FunctionExclusionGroup abar = groups.getExclusionGroup(a_bar);
   assertEquals(abar, afoo1);
   final FunctionExclusionGroup bfoo = groups.getExclusionGroup(b_foo);
   assertNotEquals(abar, bfoo);
   final FunctionExclusionGroup bbar = groups.getExclusionGroup(b_bar);
   assertEquals(bbar, bfoo);
 }
  @Test
  public void testWithAlgorithmOverrides() throws ResolverException {
    roleDesc
        .getKeyDescriptors()
        .add(buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey()));

    config2.setDataEncryptionAlgorithms(
        Collections.singletonList(EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES256));
    config2.setKeyTransportEncryptionAlgorithms(
        Collections.singletonList(EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15));

    EncryptionParameters params = resolver.resolveSingle(criteriaSet);

    Assert.assertNotNull(params);
    Assert.assertEquals(
        params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey());
    Assert.assertEquals(
        params.getKeyTransportEncryptionAlgorithm(),
        EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15);
    Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator());

    Assert.assertNull(params.getDataEncryptionCredential());
    Assert.assertEquals(
        params.getDataEncryptionAlgorithm(), EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES256);
    Assert.assertNull(params.getDataKeyInfoGenerator());
  }
  @Test
  public void testEncryptionMethodWithWhitelist() throws ResolverException {
    KeyDescriptor keyDescriptor =
        buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey());
    keyDescriptor
        .getEncryptionMethods()
        .add(buildEncryptionMethod(EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15));
    keyDescriptor
        .getEncryptionMethods()
        .add(buildEncryptionMethod(EncryptionConstants.ALGO_ID_BLOCKCIPHER_TRIPLEDES));
    roleDesc.getKeyDescriptors().add(keyDescriptor);

    config1.setWhitelistedAlgorithms(
        Arrays.asList(
            EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSAOAEP,
            EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES192));

    EncryptionParameters params = resolver.resolveSingle(criteriaSet);

    Assert.assertNotNull(params);
    Assert.assertEquals(
        params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey());
    Assert.assertEquals(
        params.getKeyTransportEncryptionAlgorithm(),
        EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSAOAEP);
    Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator());

    Assert.assertNull(params.getDataEncryptionCredential());
    Assert.assertEquals(
        params.getDataEncryptionAlgorithm(), EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES192);
    Assert.assertNull(params.getDataKeyInfoGenerator());
  }
  @Test
  public void getProductByDownloadableFilename() {
    fr.gael.dhus.database.object.Collection validCollection;
    fr.gael.dhus.database.object.Collection invalidCollection;
    Product product;

    validCollection = new Collection();
    validCollection.setUUID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3");
    validCollection.setName("Japan");

    invalidCollection = new Collection();
    invalidCollection.setUUID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4");
    invalidCollection.setName("China");

    product = dao.getProductByDownloadableFilename("prod0", validCollection);
    Assert.assertNotNull(product);
    Assert.assertEquals(product.getId().intValue(), 0);

    product = dao.getProductByDownloadableFilename("prod6", validCollection);
    Assert.assertNull(product);

    product = dao.getProductByDownloadableFilename("prod0", invalidCollection);
    Assert.assertNull(product);

    product = dao.getProductByDownloadableFilename("prod6", null);
    Assert.assertNotNull(product);
    Assert.assertEquals(product.getId().intValue(), 6);

    product = dao.getProductByDownloadableFilename(null, null);
    Assert.assertNull(product);
  }
  @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);
  }
Example #11
0
 public void shouldMapModelWithNullItems() {
   D1 result = modelMapper.map(new S1(), D1.class);
   assertNull(result.sub);
   assertEquals(result.subSomething, 0);
   assertNull(result.nullString);
   assertNull(result.longValue);
 }
Example #12
0
  @Test(groups = {"functional.decode", "primitives"})
  public void testDecode() throws Exception {

    byte[] data = this.getData1();

    AsnInputStream asn = new AsnInputStream(data);
    int tag = asn.readTag();

    LocationAreaImpl prim = new LocationAreaImpl();
    prim.decodeAll(asn);

    assertEquals(tag, LocationAreaImpl._TAG_laiFixedLength);
    assertEquals(asn.getTagClass(), Tag.CLASS_CONTEXT_SPECIFIC);

    LAIFixedLength lai = prim.getLAIFixedLength();
    assertEquals(lai.getMCC(), 249);
    assertEquals(lai.getMNC(), 1);
    assertEquals(lai.getLac(), 14010);
    assertNull(prim.getLAC());

    data = this.getData2();

    asn = new AsnInputStream(data);
    tag = asn.readTag();

    prim = new LocationAreaImpl();
    prim.decodeAll(asn);

    assertEquals(tag, LocationAreaImpl._TAG_lac);
    assertEquals(asn.getTagClass(), Tag.CLASS_CONTEXT_SPECIFIC);

    assertNull(prim.getLAIFixedLength());
    LAC lac = prim.getLAC();
    assertEquals(lac.getLac(), 14010);
  }
  /**
   * Test for issue 106: Session not updated in memcached when only a session attribute was removed
   * http://code.google.com/p/memcached-session-manager/issues/detail?id=106
   */
  @Test(enabled = true, dataProviderClass = TestUtils.class, dataProvider = STICKYNESS_PROVIDER)
  public void testSessionUpdatedInMemcachedWhenSessionAttributeIsRemovedIssue106(
      final SessionAffinityMode sessionAffinity)
      throws IOException, InterruptedException, HttpException {

    setStickyness(sessionAffinity);

    final String key = "foo";
    final String value = "bar";
    final String sessionId1 = post(_httpClient, _portTomcat1, null, key, value).getSessionId();
    assertNotNull(sessionId1, "No session created.");

    Response response = get(_httpClient, _portTomcat1, sessionId1);
    assertEquals(response.getSessionId(), sessionId1);
    assertEquals(response.get(key), value);

    final Map<String, String> params = asMap(PARAM_REMOVE, key);
    response = get(_httpClient, _portTomcat1, "/", sessionId1, params);
    assertEquals(response.getSessionId(), sessionId1);
    assertNull(response.get(key));

    // also the next request must not include this session attribute
    response = get(_httpClient, _portTomcat1, sessionId1);
    assertEquals(response.getSessionId(), sessionId1);
    assertNull(response.get(key));
  }
  @Test
  public void testResultSetValidationError() {
    String sql = "select ORDERTYPE, STATUS from orders where ID=5";
    reset(jdbcTemplate);

    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("ORDERTYPE", "small");
    resultMap.put("STATUS", "in_progress");

    expect(jdbcTemplate.queryForList(sql)).andReturn(Collections.singletonList(resultMap));

    replay(jdbcTemplate);

    List<String> stmts = Collections.singletonList(sql);
    executeSQLQueryAction.setStatements(stmts);

    Map<String, List<String>> controlResultSet = new HashMap<String, List<String>>();
    controlResultSet.put(
        "ORDERTYPE", Collections.singletonList("xxl")); // this is supposed to cause an error
    controlResultSet.put("STATUS", Collections.singletonList("in_progress"));

    executeSQLQueryAction.setControlResultSet(controlResultSet);

    try {
      executeSQLQueryAction.execute(context);
    } catch (ValidationException e) {
      Assert.assertNull(context.getVariables().get("${ORDERTYPE}"));
      Assert.assertNull(context.getVariables().get("${STATUS}"));

      return;
    }

    Assert.fail("Expected test to fail with " + ValidationException.class + " but was successful");
  }
  public void testDroolsGeneration(int i) throws Exception {
    String filename = (i % 2 == 0) ? "/drools/stress1.drl" : "/drools/stress2.drl";
    InputStreamReader reader =
        new InputStreamReader(DroolsKnowledgeBaseTest.class.getResourceAsStream(filename));

    KnowledgeAgentConfiguration aconf = KnowledgeAgentFactory.newKnowledgeAgentConfiguration();
    aconf.setProperty("drools.agent.newInstance", "false");
    aconf.setProperty("drools.agent.monitorChangeSetEvents", "false");
    aconf.setProperty("drools.agent.scanResources", "false");

    KnowledgeBuilder builder = compileRules(reader);

    KnowledgeAgent kagent =
        KnowledgeAgentFactory.newKnowledgeAgent("Success Correspondence Agent", aconf);
    KnowledgeBase kbase = kagent.getKnowledgeBase();
    kbase.addKnowledgePackages(builder.getKnowledgePackages());
    //        kagent.monitorResourceChangeEvents(false);
    Rule rule1 = kbase.getRule("com.rosettastone.succor", "Equal rule 1");
    Rule rule5 = kbase.getRule("com.rosettastone.succor", "Equal rule 5");
    Rule rule6 = kbase.getRule("com.rosettastone.succor", "Equal rule 6");

    StatelessKnowledgeSession session = kbase.newStatelessKnowledgeSession();
    if (i % 2 == 0) {
      Assert.assertNotNull(rule1);
      Assert.assertNotNull(rule5);
      Assert.assertNull(rule6);
      testRulesFirst(session);
    } else {
      Assert.assertNull(rule1);
      Assert.assertNotNull(rule5);
      Assert.assertNotNull(rule6);
      testRulesSecond(session);
    }
  }
 @Test
 public void testProduceConsumeMultiMessage() {
   PersistentQueue<Message> queue = new PersistentQueue<Message>("jk.store");
   queue.init();
   for (int i = 0; i < 10; i++) {
     assertTrue(queue.produce(new Message(i)), "always success");
   }
   for (int i = 0; i < 10; i++) {
     Message expected = queue.consume();
     Assert.assertEquals(i, expected.index(), "Comparing index value");
     Assert.assertEquals(
         "My name is JK and I am a crap living in Singapore !@#$$%^^&&",
         expected.value(), "Comparing message value");
   }
   Assert.assertNull(queue.consume(), "Already Popped, so it should not be available");
   queue = new PersistentQueue<Message>("jk.store");
   queue.init();
   Assert.assertNull(queue.consume(), "Already Popped, so it should not be available");
   ////////////////
   queue = new PersistentQueue<Message>("jk.store");
   queue.init();
   for (int i = 11; i <= 20; i++) {
     assertTrue(queue.produce(new Message(i)), "always success");
   }
   for (int i = 11; i <= 20; i++) {
     Message expected = queue.consume();
     Assert.assertEquals(i, expected.index(), "Comparing index value");
     Assert.assertEquals(
         "My name is JK and I am a crap living in Singapore !@#$$%^^&&",
         expected.value(), "Comparing message value");
   }
 }
  @Test
  public void testWithRSAOAEPParametersFromConfig() throws ResolverException {
    roleDesc
        .getKeyDescriptors()
        .add(buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey()));
    config3.setRSAOAEPParameters(
        new RSAOAEPParameters(EncryptionConstants.ALGO_ID_DIGEST_SHA256, null, "oaep-params-3"));

    EncryptionParameters params = resolver.resolveSingle(criteriaSet);

    Assert.assertNotNull(params);
    Assert.assertEquals(
        params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey());
    Assert.assertEquals(params.getKeyTransportEncryptionAlgorithm(), defaultRSAKeyTransportAlgo);
    Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator());

    Assert.assertNull(params.getDataEncryptionCredential());
    Assert.assertEquals(params.getDataEncryptionAlgorithm(), defaultAES128DataAlgo);
    Assert.assertNull(params.getDataKeyInfoGenerator());

    Assert.assertNotNull(params.getRSAOAEPParameters());
    Assert.assertEquals(
        params.getRSAOAEPParameters().getDigestMethod(), EncryptionConstants.ALGO_ID_DIGEST_SHA256);
    Assert.assertNull(params.getRSAOAEPParameters().getMaskGenerationFunction());
    Assert.assertEquals(params.getRSAOAEPParameters().getOAEPParams(), "oaep-params-3");
  }
  @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 testResolve() throws ResolverException {
    roleDesc
        .getKeyDescriptors()
        .add(buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey()));

    Iterable<EncryptionParameters> paramsIter = resolver.resolve(criteriaSet);
    Assert.assertNotNull(paramsIter);

    Iterator<EncryptionParameters> iterator = paramsIter.iterator();
    Assert.assertNotNull(iterator);

    Assert.assertTrue(iterator.hasNext());

    EncryptionParameters params = iterator.next();

    Assert.assertNotNull(params);
    Assert.assertEquals(
        params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey());
    Assert.assertEquals(params.getKeyTransportEncryptionAlgorithm(), defaultRSAKeyTransportAlgo);
    Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator());

    Assert.assertNull(params.getDataEncryptionCredential());
    Assert.assertEquals(params.getDataEncryptionAlgorithm(), defaultAES128DataAlgo);
    Assert.assertNull(params.getDataKeyInfoGenerator());

    Assert.assertFalse(iterator.hasNext());
  }
  /**
   * Tests.
   *
   * @throws Exception exception
   */
  @Test
  public void test() throws Exception {
    final LinkRepository linkRepository = getLinkRepository();

    final int link1Order = 1, link2Order = 2, link3Order = 3;

    JSONObject link1 = new JSONObject();

    link1.put(Link.LINK_TITLE, "link title");
    link1.put(Link.LINK_DESCRIPTION, "link description");
    link1.put(Link.LINK_ADDRESS, "link address");
    link1.put(Link.LINK_ORDER, link1Order);

    Transaction transaction = linkRepository.beginTransaction();
    linkRepository.add(link1);
    transaction.commit();

    Assert.assertNull(linkRepository.getByAddress("test"));
    Assert.assertNotNull(linkRepository.getByAddress("link address"));

    Assert.assertNull(linkRepository.getByOrder(0));
    Assert.assertNotNull(linkRepository.getByOrder(link1Order));

    final JSONObject link2 = new JSONObject();

    link2.put(Link.LINK_TITLE, "link title");
    link2.put(Link.LINK_DESCRIPTION, "link description");
    link2.put(Link.LINK_ADDRESS, "link address");
    link2.put(Link.LINK_ORDER, link2Order);

    transaction = linkRepository.beginTransaction();
    final String link2Id = linkRepository.add(link2);
    transaction.commit();

    Assert.assertEquals(linkRepository.getMaxOrder(), link2Order);

    JSONObject link3 = new JSONObject();

    link3.put(Link.LINK_TITLE, "link title");
    link3.put(Link.LINK_DESCRIPTION, "link description");
    link3.put(Link.LINK_ADDRESS, "link address");
    link3.put(Link.LINK_ORDER, link3Order);
    transaction = linkRepository.beginTransaction();

    linkRepository.add(link3);

    transaction.commit();

    final int total = 3;
    Assert.assertEquals(linkRepository.count(), total);

    link1 = linkRepository.getUpper(link2Id);
    Assert.assertNotNull(link1);
    Assert.assertEquals(link1.getInt(Link.LINK_ORDER), link1Order);

    link3 = linkRepository.getUnder(link2Id);
    Assert.assertNotNull(link3);
    Assert.assertEquals(link3.getInt(Link.LINK_ORDER), link3Order);
  }
  /**
   * Tests.
   *
   * @throws Exception exception
   */
  @Test
  public void add() throws Exception {
    final UserRepository userRepository = getUserRepository();

    final JSONObject another = new JSONObject();
    another.put(User.USER_NAME, "test1");
    another.put(User.USER_EMAIL, "*****@*****.**");
    another.put(User.USER_PASSWORD, "pass1");
    another.put(User.USER_ROLE, Role.DEFAULT_ROLE);
    another.put(UserExt.USER_ARTICLE_COUNT, 0);
    another.put(UserExt.USER_COMMENT_COUNT, 0);
    another.put(UserExt.USER_STATUS, "0");

    Transaction transaction = userRepository.beginTransaction();
    userRepository.add(another);
    transaction.commit();

    Assert.assertNull(userRepository.getAdmin());

    JSONObject admin = new JSONObject();
    admin.put(User.USER_NAME, "test");
    admin.put(User.USER_EMAIL, "*****@*****.**");
    admin.put(User.USER_PASSWORD, "pass");
    admin.put(User.USER_ROLE, Role.ADMIN_ROLE);
    admin.put(UserExt.USER_ARTICLE_COUNT, 1);
    admin.put(UserExt.USER_COMMENT_COUNT, 0);
    admin.put(UserExt.USER_STATUS, "0");

    transaction = userRepository.beginTransaction();
    userRepository.add(admin);
    transaction.commit();

    Assert.assertTrue(userRepository.isAdminEmail("*****@*****.**"));
    Assert.assertFalse(userRepository.isAdminEmail("*****@*****.**"));

    admin = userRepository.getAdmin();

    Assert.assertNotNull(admin);
    Assert.assertEquals(admin.optString(User.USER_NAME), "test");
    Assert.assertEquals(admin.optInt(UserExt.USER_ARTICLE_COUNT), 1);

    final JSONObject result =
        userRepository.get(
            new Query()
                .setFilter(new PropertyFilter(User.USER_NAME, FilterOperator.EQUAL, "test1")));

    final JSONArray users = result.getJSONArray(Keys.RESULTS);
    Assert.assertEquals(users.length(), 1);
    Assert.assertEquals(users.getJSONObject(0).getString(User.USER_EMAIL), "*****@*****.**");

    final JSONObject notFound = userRepository.getByEmail("*****@*****.**");
    Assert.assertNull(notFound);

    final JSONObject found = userRepository.getByEmail("*****@*****.**");
    Assert.assertNotNull(found);
    Assert.assertEquals(found.getString(User.USER_PASSWORD), "pass1");
  }
Example #22
0
 public void simpleGroupTest() {
   Group g = new Group(1L, "g1", null, false, null, null);
   assertEquals(g.getGroupId(), 1L);
   assertEquals(g.getGroupName(), "g1");
   assertNull(g.getDescription());
   assertFalse(g.isNewUserDefault());
   assertNull(g.getRealm());
   assertNull(g.getRealmAttributes());
 }
  @Test(groups = "slow", description = "Verify no PII data is required")
  public void testEmptyAccount() throws Exception {
    final Account emptyAccount = new Account();

    final Account account = killBillClient.createAccount(emptyAccount, createdBy, reason, comment);
    Assert.assertNotNull(account.getExternalKey());
    Assert.assertNull(account.getName());
    Assert.assertNull(account.getEmail());
  }
Example #24
0
  public void shouldSkipNulls() {
    modelMapper.createTypeMap(S1.class, D1.class).setPropertyCondition(Conditions.isNotNull());

    S1 source = new S1();
    D1 d = modelMapper.map(source, D1.class);
    assertEquals(d.longValue, Long.valueOf(4));
    assertEquals(d.subSomething, 5);
    assertNull(d.sub);
    assertNull(d.nullString);
  }
Example #25
0
 @Test
 public void testGetTableHandle() {
   JdbcTableHandle tableHandle =
       metadata.getTableHandle(SESSION, new SchemaTableName("example", "numbers"));
   assertEquals(
       metadata.getTableHandle(SESSION, new SchemaTableName("example", "numbers")), tableHandle);
   assertNull(metadata.getTableHandle(SESSION, new SchemaTableName("example", "unknown")));
   assertNull(metadata.getTableHandle(SESSION, new SchemaTableName("unknown", "numbers")));
   assertNull(metadata.getTableHandle(SESSION, new SchemaTableName("unknown", "unknown")));
 }
Example #26
0
  @Test
  public void testCallSucceedsWhenServiceUnavailable()
      throws ExecutionException, InterruptedException {
    client = newEventClient(Collections.<URI>emptyList());

    client.post(new FixedDummyEventClass("host", new DateTime(), UUID.randomUUID(), 1, "foo"));

    assertNull(servlet.lastPath);
    assertNull(servlet.lastBody);
  }
 @Test
 public void checkUnionNulls() {
   DoublesUnion union = new HeapDoublesUnion(128);
   DoublesSketch sk1 = union.getResultAndReset();
   DoublesSketch sk2 = union.getResultAndReset();
   assertNull(sk1);
   assertNull(sk2);
   union.update(sk2);
   DoublesSketch sk3 = union.getResultAndReset();
   assertNull(sk3);
 }
  @Test
  public void testNullEmpty() throws IOException {
    EvalFunc<String> func = new SketchToString("false");
    Tuple dataTuple = null;
    String result = func.exec(dataTuple);
    assertNull(result);

    dataTuple = TupleFactory.getInstance().newTuple(0);
    result = func.exec(dataTuple);
    assertNull(result);
  }
 public void testNoGenerations() {
   final BerkeleyDBTempTargetRepository targets = createTempTargetRepository();
   try {
     assertNull(targets.getOldGeneration(0));
     assertNull(targets.getNewGeneration(0));
     assertFalse(targets.copyOldToNewGeneration(0, new ArrayList<Long>()));
     targets.nextGeneration();
   } finally {
     targets.stop();
   }
 }
  public void testRemoveFromMainOwner() {
    Object k = getKeyForCache(0);
    cache(0).put(k, "0");
    cache(0).remove(k, "1");

    assertEquals(advancedCache(0).getDataContainer().get(k, null).getValue(), "0");
    assertEquals(advancedCache(1).getDataContainer().get(k, null).getValue(), "0");

    cache(0).remove(k, "0");
    assertNull(advancedCache(0).getDataContainer().get(k, null));
    assertNull(advancedCache(1).getDataContainer().get(k, null));
  }