Package com.pardot.rhombus

Examples of com.pardot.rhombus.ConnectionManager


  @Test
  public void testBuildCluster() throws Exception {
    logger.debug("testBuildCluster");
    //Get a connection manager based on the test properties
    ConnectionManager connectionManager = TestHelpers.getTestConnectionManager();
    connectionManager.setLogCql(true);
    Cluster cassCluster = connectionManager.buildCluster(true);
    assertNotNull(connectionManager);

    assertEquals(1,cassCluster.getMetadata().getAllHosts().size());
    assertEquals(cassCluster.getMetadata().getClusterName(), "Test Cluster");

    connectionManager.teardown();
  }
View Full Code Here


  @Test
  public void testBuildKeyspace() throws Exception {
    logger.debug("testBuildKeyspace");
    // Set up a connection manager and build the cluster
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class
        , this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);

    //Build the same keyspace but do not force a rebuild
    cm.buildKeyspace(definition, false);

    //verify that we saved the keyspace definition in cassandra correctly
    CKeyspaceDefinition queriedDef = cm.hydrateLatestKeyspaceDefinitionFromCassandra(definition.getName());
    assertEquals(definition.getDefinitions().size(), queriedDef.getDefinitions().size());
    assertEquals(queriedDef.getDefinitions().get("testtype").getField("foreignid").getType(), CField.CDataType.BIGINT);

    cm.teardown();
  }
View Full Code Here

  @Test
  public void testForceRebuild() throws Exception {
    logger.debug("testForceRebuild");
    // Set up a connection manager and build the cluster
    ConnectionManager cm = getConnectionManager();

    //Build the keyspace forcing a rebuild in case anything has been left behind
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class
        , this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);
    cm.buildKeyspace(definition, true);

    //Build the keyspace without forcing a rebuild, but adding another index
    CKeyspaceDefinition definition2 = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class
        , this.getClass().getClassLoader(), "CKeyspaceTestData2.js");
    assertNotNull(definition2);
    cm.buildKeyspace(definition2, false);

    //Select from the newly created table
    ObjectMapper om = cm.getObjectMapper(definition2);
    ResultSet rs = om.getCqlExecutor().executeSync(CQLStatement.make("SELECT * FROM testtype3cb23c7ffc4256283064bd5eae1886b4", "testtype"));
    assertEquals(0, rs.all().size());

    cm.teardown();
  }
View Full Code Here

  }

  @Test
  public void testDropKeyspace() throws Exception {
    // Set up a connection manager and build the cluster and keyspace
    ConnectionManager cm = getConnectionManager();
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class
        , this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);
    cm.buildKeyspace(definition, false);

    // Drop the keyspace
    cm.dropKeyspace(definition.getName());

    // Make sure it is really dropped
    Session session = cm.getEmptySession();
    boolean caught = false;
    try {
      session.execute("USE " + definition.getName() + ";");
    } catch(InvalidQueryException e) {
      caught = true;
    }
    session.close();
    assertTrue(caught);

    cm.teardown();
  }
View Full Code Here

    //add new object
    CDefinition NewObjectDefinition = JsonUtil.objectFromJsonResource(CDefinition.class, this.getClass().getClassLoader(), "MigrationTestCDefinition.js");
    NewKeyspaceDefinition.getDefinitions().put(NewObjectDefinition.getName(),NewObjectDefinition);

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //This test requires that the keyspace be dropped before running
    cm.dropKeyspace(OldKeyspaceDefinition.getName());
    cm.dropKeyspace(cm.getRhombusKeyspaceName());

    //Rebuild the keyspace and get the object mapper
    cm.buildKeyspace(OldKeyspaceDefinition, true);
    ObjectMapper om = cm.getObjectMapper(OldKeyspaceDefinition.getName());

    //insert some data
    //Get a test object to insert
    Map<String, Object> testObject = JsonUtil.rhombusMapFromJsonMap(TestHelpers.getTestObject(0), OldKeyspaceDefinition.getDefinitions().get("testtype"));
    UUID key = (UUID)om.insert("testtype", testObject);

    //Query to get back the object from the database
    Map<String, Object> dbObject = om.getByKey("testtype", key);
    for(String dbKey : dbObject.keySet()) {
      //Verify that everything but the key is the same
      if(!dbKey.equals("id")) {
        assertEquals(testObject.get(dbKey), dbObject.get(dbKey));
      }
    }

    //run the migration grabbing a brand new object mapper
    cm = getConnectionManager();
    om = cm.getObjectMapper(NewKeyspaceDefinition);

    //make sure that our keyspace definitions do not match
    assertNotEquals(NewKeyspaceDefinition, cm.hydrateLatestKeyspaceDefinitionFromCassandra(NewKeyspaceDefinition.getName()));
    assertNotEquals(NewKeyspaceDefinition, om.getKeyspaceDefinition_ONLY_FOR_TESTING());

    //run the migration
    cm.runMigration(NewKeyspaceDefinition, true);

    //make sure that the object mapper has the new keyspace definition
    CKeyspaceDefinition updatedKeyspaceDefinition = om.getKeyspaceDefinition_ONLY_FOR_TESTING();
    assertEquals(NewKeyspaceDefinition, updatedKeyspaceDefinition);

    //make sure that the new keyspace definition has been stored in the rhombus metadata store
    CKeyspaceDefinition updatedRhombusDefinition = cm.hydrateLatestKeyspaceDefinitionFromCassandra(NewKeyspaceDefinition.getName());
    assertEquals(NewKeyspaceDefinition, updatedRhombusDefinition);

    //now query out some data grabbing a brand new object mapper
    cm = getConnectionManager();
    om = cm.getObjectMapper(NewKeyspaceDefinition.getName());

    //now insert some stuff into the newly added object and indexes
    testObject = JsonUtil.rhombusMapFromJsonMap(TestHelpers.getTestObject(0), OldKeyspaceDefinition.getDefinitions().get("testtype"));
    om.insert("testtype", testObject);


    testObject = Maps.newHashMap();
    testObject.put("index_1", "one");
    testObject.put("index_2", "two");
    testObject.put("value", "three");
    key = (UUID)om.insert("simple", testObject);

    //Query to get back the object from the database
    //Query by foreign key
    Criteria criteria = new Criteria();
    SortedMap<String, Object> indexValues = Maps.newTreeMap();
    indexValues.put("data1", "This is data one");
    indexValues.put("data2", "This is data two");
    criteria.setIndexKeys(indexValues);
    List<Map<String, Object>> results = om.list("testtype", criteria);
    assertEquals(777L,results.get(0).get("foreignid"));
    assertEquals("This is data one",results.get(0).get("data1"));

    Map<String,Object> result = om.getByKey("simple", key);
    assertEquals("one",result.get("index_1"));
    assertEquals("two",result.get("index_2"));
    assertEquals("three",result.get("value"));

    // Make sure we have saved both versions of the keyspace
    Session session = cm.getEmptySession();
    StringBuilder sb = new StringBuilder();
    sb.append("SELECT id from \"");
    sb.append(cm.getRhombusKeyspaceName());
    sb.append("\".\"__keyspace_definitions\" where name='");
    sb.append(NewKeyspaceDefinition.getName());
    sb.append("';");
    ResultSet resultSet = session.execute(sb.toString());
    Iterator<Row> rsIter = resultSet.iterator();
    int counter = 0;
    while(rsIter.hasNext()) {
      counter++;
      rsIter.next();
    }
    assertEquals(2, counter);

    cm.teardown();
  }
View Full Code Here

  @Test
  public void testClientFilter() throws Exception {
    logger.debug("Starting testClientFilter");

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class, this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);
    definition.getDefinitions().get("testtype");

    //Build the keyspace, get the object mapper, and truncate data
    cm.buildKeyspace(definition, true);
    cm.setDefaultKeyspace(definition);
    ObjectMapper om = cm.getObjectMapper(definition.getName());
    om.setExecuteAsync(false);

    //Insert one object which is filtered and one which is not
    Map<String, Object> testObject = Maps.newHashMap();
    testObject.put("foreignid", 123l);
    testObject.put("filtered", 0);
    testObject.put("data1", "notfiltered");
    UUID notFilteredKey = (UUID)om.insert("testtype", testObject);

    testObject = Maps.newHashMap();
    testObject.put("foreignid", 123l);
    testObject.put("filtered", 1);
    testObject.put("data1", "filtered");
    UUID filteredKey = (UUID)om.insert("testtype", testObject);

    Thread.sleep(1000l);

    // Make sure we get both back when we query using a standard index
    Criteria foreignIdCriteria = new Criteria();
    foreignIdCriteria.setOrdering(CObjectOrdering.DESCENDING);
    foreignIdCriteria.setLimit(50l);
    foreignIdCriteria.setAllowFiltering(true);
    SortedMap<String, Object> indexKeys = Maps.newTreeMap();
    indexKeys.put("foreignid", 123l);
    foreignIdCriteria.setIndexKeys(indexKeys);
    List<Map<String, Object>> dbObjects = om.list("testtype", foreignIdCriteria);
    assertEquals(2, dbObjects.size());

    // Make sure we only get one back when searching for not filtered
    Criteria foreignIdAndNotFilteredCriteria = new Criteria();
    foreignIdAndNotFilteredCriteria.setOrdering(CObjectOrdering.DESCENDING);
    foreignIdAndNotFilteredCriteria.setLimit(50l);
    foreignIdAndNotFilteredCriteria.setAllowFiltering(true);
    indexKeys = Maps.newTreeMap();
    indexKeys.put("foreignid", 123l);
    indexKeys.put("filtered", 0);
    foreignIdAndNotFilteredCriteria.setIndexKeys(indexKeys);
    dbObjects = om.list("testtype", foreignIdAndNotFilteredCriteria);
    assertEquals(1, dbObjects.size());
    assertEquals(notFilteredKey, dbObjects.get(0).get("id"));

    // Make sure we only get one back when searching for filtered
    Criteria foreignIdAndFilteredCriteria = new Criteria();
    foreignIdAndFilteredCriteria.setOrdering(CObjectOrdering.DESCENDING);
    foreignIdAndFilteredCriteria.setLimit(50l);
    foreignIdAndFilteredCriteria.setAllowFiltering(true);
    indexKeys = Maps.newTreeMap();
    indexKeys.put("foreignid", 123l);
    indexKeys.put("filtered", 1);
    foreignIdAndFilteredCriteria.setIndexKeys(indexKeys);
    dbObjects = om.list("testtype", foreignIdAndFilteredCriteria);
    assertEquals(1, dbObjects.size());
    assertEquals(filteredKey, dbObjects.get(0).get("id"));

    //Teardown connections
    cm.teardown();
  }
View Full Code Here

  @Test
  public void testClientFilterNoPaging() throws Exception {
    logger.debug("Starting testClientFilterNoPaging");

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class, this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);
    definition.getDefinitions().get("testtype");

    //Build the keyspace, get the object mapper, and truncate data
    cm.buildKeyspace(definition, true);
    cm.setDefaultKeyspace(definition);
    ObjectMapper om = cm.getObjectMapper(definition.getName());
    om.setExecuteAsync(false);

    Map<String, Object> testObject;
    long pageSize = 50;
    for(int i = 0 ; i < pageSize*2 - 5 ; i++) {
      testObject = Maps.newHashMap();
      testObject.put("foreignid", 123l);
      testObject.put("filtered", 0);
      testObject.put("data1", "notfiltered");
      om.insert("testtype", testObject);
    }

    testObject = Maps.newHashMap();
    testObject.put("foreignid", 123l);
    testObject.put("filtered", 1);
    testObject.put("data1", "filtered");
    UUID filteredKey = (UUID)om.insert("testtype", testObject);

    Thread.sleep(1000l);

    // Make sure we get one filtered result back when we query with a limit less than the number of objects
    Criteria foreignIdCriteria = new Criteria();
    foreignIdCriteria.setOrdering(CObjectOrdering.DESCENDING);
    foreignIdCriteria.setLimit(pageSize);
    foreignIdCriteria.setAllowFiltering(true);
    SortedMap<String, Object> indexKeys = Maps.newTreeMap();
    indexKeys.put("foreignid", 123l);
    indexKeys.put("filtered", 1);
    foreignIdCriteria.setIndexKeys(indexKeys);
    List<Map<String, Object>> dbObjects = om.list("testtype", foreignIdCriteria);
    assertEquals(1, dbObjects.size());

    //Teardown connections
    cm.teardown();
  }
View Full Code Here

  @Test
  public void testClientFilterPaging() throws Exception {
    logger.debug("Starting testClientFilterPaging");

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class, this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);
    definition.getDefinitions().get("testtype");

    //Build the keyspace, get the object mapper, and truncate data
    cm.buildKeyspace(definition, true);
    cm.setDefaultKeyspace(definition);
    ObjectMapper om = cm.getObjectMapper(definition.getName());
    om.setExecuteAsync(false);

    Map<String, Object> testObject;
    testObject = Maps.newHashMap();
    testObject.put("foreignid", 123l);
    testObject.put("filtered", 1);
    testObject.put("data1", "filtered");
    UUID filteredKey = (UUID)om.insert("testtype", testObject);


    long pageSize = 50;
    for(int i = 0 ; i < pageSize*2 + 1 ; i++) {
      testObject = Maps.newHashMap();
      testObject.put("foreignid", 123l);
      testObject.put("filtered", 0);
      testObject.put("data1", "notfiltered");
      om.insert("testtype", testObject);
    }

    Thread.sleep(1000l);

    // Make sure we get one filtered result back when we query with a limit less than the number of objects
    Criteria foreignIdCriteria = new Criteria();
    foreignIdCriteria.setOrdering(CObjectOrdering.DESCENDING);
    foreignIdCriteria.setLimit(pageSize);
    foreignIdCriteria.setAllowFiltering(true);
    SortedMap<String, Object> indexKeys = Maps.newTreeMap();
    indexKeys.put("foreignid", 123l);
    indexKeys.put("filtered", 1);
    foreignIdCriteria.setIndexKeys(indexKeys);
    List<Map<String, Object>> dbObjects = om.list("testtype", foreignIdCriteria);
    assertEquals(1, dbObjects.size());

    //Teardown connections
    cm.teardown();
  }
View Full Code Here

  @Test
  public void testObjectMapperWithTTL() throws Exception {
    logger.debug("Starting testObjectMapperWithTTL");

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class, this.getClass().getClassLoader(), "CKeyspaceTestData.js");
    assertNotNull(definition);

    //Rebuild the keyspace and get the object mapper
    cm.buildKeyspace(definition, true);
    cm.setDefaultKeyspace(definition);
    ObjectMapper om = cm.getObjectMapper(definition.getName());

    //Get a test object to insert
    Map<String, Object> testObject = JsonUtil.rhombusMapFromJsonMap(TestHelpers.getTestObject(0), definition.getDefinitions().get("testtype"));
    UUID key = (UUID) om.insert("testtype", testObject);

    // Test that we can insert with TTL
    //Get a test object to insert
    Map<String, Object> testObject4 = JsonUtil.rhombusMapFromJsonMap(TestHelpers.getTestObject(0), definition.getDefinitions().get("testtype"));
    // This one should only persist for 4 seconds
    Integer ttl = 4;
    testObject4.put("_ttl", ttl);
    UUID key5 = (UUID) om.insert("testtype", testObject4);

    Map<String, Object> testObject5 = JsonUtil.rhombusMapFromJsonMap(TestHelpers.getTestObject(0), definition.getDefinitions().get("testtype"));
    // Whereas this one should persist for one day
    ttl = 86400;
    testObject5.put("_ttl", ttl);
    UUID key6 = (UUID) om.insert("testtype", testObject5);

    // Let's wait for five seconds
    Thread.sleep(5000);

    Map<String, Object> dbObject3 = om.getByKey("testtype", key5);
    // So the object created with key5 should be gone
    assertNull(dbObject3);
    Map<String, Object> dbObject4 = om.getByKey("testtype", key6);
    // Yet the object created with key6 should be extant
    assertNotNull(dbObject4);

    //Teardown connections
    cm.teardown();
  }
View Full Code Here

  @Test
  public void testLargeCountWithTTL() throws Exception {
    logger.debug("Starting testLargeCountWithTTL");

    //Build the connection manager
    ConnectionManager cm = getConnectionManager();

    //Build our keyspace definition object
    CKeyspaceDefinition definition = JsonUtil.objectFromJsonResource(CKeyspaceDefinition.class, this.getClass().getClassLoader(), "MultiInsertKeyspace.js");
    assertNotNull(definition);

    //Rebuild the keyspace and get the object mapper
    cm.buildKeyspace(definition, true);
    logger.debug("Built keyspace: {}", definition.getName());
    cm.setDefaultKeyspace(definition);
    ObjectMapper om = cm.getObjectMapper();
    om.setLogCql(true);

    //Set up test data
    int nDataItems = 200;

    List<Map<String, Object>> values2 = Lists.newArrayList();
    Integer ttl = 4;

    // insert additional data, we are testing for counts > 50
    for (int i = 0; i < nDataItems; i++) {
      Map<String, Object> value = Maps.newHashMap();
      value.put("account_id", "00000003-0000-0030-0040-000000030000");
      value.put("user_id", "00000003-0000-0030-0040-000000030000");
      value.put("field2", "Value" + (i + 8));
      values2.add(value);
    }

    List<Map<String, Object>> updatedValues2 = Lists.newArrayList();
    for (Map<String, Object> baseValue : values2) {
      Map<String, Object> value = JsonUtil.rhombusMapFromJsonMap(baseValue, definition.getDefinitions().get("object2"));
      value.put("_ttl", ttl);
      updatedValues2.add(value);
    }

    Map<String, List<Map<String, Object>>> multiInsertMap = Maps.newHashMap();
    multiInsertMap.put("object2", updatedValues2);


    //Insert data with 4-second TTL
    om.insertBatchMixed(multiInsertMap);

    // Sleep for five seconds
    Thread.sleep(5000);

    //Count the number of inserts we made
    SortedMap<String, Object> indexValues = Maps.newTreeMap();
    indexValues.put("account_id", UUID.fromString("00000003-0000-0030-0040-000000030000"));
    indexValues.put("user_id", UUID.fromString("00000003-0000-0030-0040-000000030000"));
    Criteria criteria = new Criteria();
    criteria.setIndexKeys(indexValues);

    // Should be zero.
    long count = om.count("object2", criteria);
    assertEquals(0, count);


    // Good.  Now let's make sure we aren't crazy.
    values2 = Lists.newArrayList();



    for (int i = 0; i < nDataItems; i++) {
      Map<String, Object> value = Maps.newHashMap();
      value.put("account_id", "00000003-0000-0030-0040-000000030000");
      value.put("user_id", "00000003-0000-0030-0040-000000030000");
      value.put("field2", "Value" + (i + 8));
      value.put("_ttl", ttl);
      values2.add(value);
    }

    Integer shortTimeToLive = 4;
    Integer longTimeToLive = 6;
    int numThatShouldBeExcluded = 15;
    int numThatShouldRemain = nDataItems - numThatShouldBeExcluded;
    int j = 0;

    updatedValues2 = Lists.newArrayList();
    for (Map<String, Object> baseValue : values2) {
      if (j < numThatShouldBeExcluded) {
        ttl = shortTimeToLive;
      }
      else {
        ttl = longTimeToLive;
      }
      j++;
      Map<String, Object> value = JsonUtil.rhombusMapFromJsonMap(baseValue, definition.getDefinitions().get("object2"));
      value.put("_ttl", ttl);
      updatedValues2.add(value);
    }

    multiInsertMap = Maps.newHashMap();
    multiInsertMap.put("object2", updatedValues2);


    //Insert data with 4-second TTL
    om.insertBatchMixed(multiInsertMap);

    // Sleep for five seconds
    Thread.sleep(5000);

    //Count the number of inserts we made
    indexValues = Maps.newTreeMap();
    indexValues.put("account_id", UUID.fromString("00000003-0000-0030-0040-000000030000"));
    indexValues.put("user_id", UUID.fromString("00000003-0000-0030-0040-000000030000"));
    criteria = new Criteria();
    criteria.setIndexKeys(indexValues);

    // Should be 185
    count = om.count("object2", criteria);
    assertEquals(numThatShouldRemain, count);

    cm.teardown();
  }
View Full Code Here

TOP

Related Classes of com.pardot.rhombus.ConnectionManager

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.