org.cassandraunit.utils.EmbeddedCassandraServerHelper Java Examples

private Session createEmbeddedCassandra() {
    // Disable fsync for a massive speedup on old platters. This improves boot time by a few seconds.
    System.setProperty("cassandra.unsafesystem", "true");

    try {
        File cassandraTmpDir = Files.createTempDir();
        EmbeddedCassandraServerHelper.startEmbeddedCassandra(CASSANDRA_CONFIG, cassandraTmpDir.getAbsolutePath(), STARTUP_TIMEOUT);
    } catch (Exception e) {
        throw new IllegalStateException("Cannot initialize the embedded Cassandra", e);
    }

    Session session = EmbeddedCassandraServerHelper.getSession();
    session.execute("CREATE KEYSPACE " + CASSANDRA_KEYSPACE + " WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 3 }");
    session.execute("USE " + CASSANDRA_KEYSPACE);

    CQLDataLoader dataLoader = new CQLDataLoader(session);
    dataLoader.load(new ClassPathCQLDataSet(CASSANDRA_SCHEMA, "Titus"));

    return session;
}
 

@Override
protected void before() throws Throwable {

	if (runtimeMode == RuntimeMode.REQUIRE_RUNNING_INSTANCE) {
		if (!CassandraSocket.isConnectable(getHost(), getPort())) {
			throw new AssumptionViolatedException(
					String.format("Cassandra is not reachable at %s:%s.", getHost(), getPort()));
		}
	}

	if (runtimeMode == RuntimeMode.EMBEDDED_IF_NOT_RUNNING) {
		if (CassandraSocket.isConnectable(getHost(), getPort())) {
			return;
		}
	}

	EmbeddedCassandraServerHelper.startEmbeddedCassandra("embedded-cassandra.yaml", "target/embeddedCassandra",
			TimeUnit.SECONDS.toMillis(60));
	super.before();
}
 

@Test
public void should_display_statistics_for_non_select_statement() throws Exception {
  //Given
  String query = "USE zeppelin;\nCREATE TABLE IF NOT EXISTS no_select(id int PRIMARY KEY);";
  final String rawResult = reformatHtml(readTestResource(
          "/scalate/NoResultWithExecutionInfo.html"));

  //When
  final InterpreterResult actual = interpreter.interpret(query, intrContext);
  final int port = EmbeddedCassandraServerHelper.getNativeTransportPort();
  final String address = EmbeddedCassandraServerHelper.getHost();
  //Then
  final String expected = rawResult.replaceAll("TRIED_HOSTS", address + ":" + port)
          .replaceAll("QUERIED_HOSTS", address + ":" + port);

  assertThat(actual.code()).isEqualTo(Code.SUCCESS);
  assertThat(reformatHtml(actual.message().get(0).getData())).isEqualTo(expected);
}
 

/**
 * Extract {@link CassandraDaemon} instance using reflection. It will be used
 * to shutdown the cluster
 */
private static CassandraDaemon extractDaemon() {
  try {
    Field field = EmbeddedCassandraServerHelper.class.getDeclaredField("cassandraDaemon");
    field.setAccessible(true);
    CassandraDaemon daemon = (CassandraDaemon) field.get(null);

    if (daemon == null) {
      throw new IllegalStateException("Cassandra daemon was not initialized by "
          + EmbeddedCassandraServerHelper.class.getSimpleName());
    }
    return daemon;
  } catch (NoSuchFieldException | IllegalAccessException e) {
    throw new RuntimeException(e);
  }
}
 

public static void main(String... args) throws Exception {

        EmbeddedCassandraServerHelper.startEmbeddedCassandra();

        ColumnConfiguration configuration = new CassandraConfiguration();
        try(ColumnFamilyManagerFactory entityManagerFactory = configuration.get()) {
            ColumnFamilyManager entityManager = entityManagerFactory.get(KEY_SPACE);
            ColumnEntity columnEntity = ColumnEntity.of(COLUMN_FAMILY);
            Column key = Columns.of("id", 10L);
            Column name = Columns.of("name", "JNoSQL in Acion");
            columnEntity.add(key);
            columnEntity.add(name);
            ColumnEntity saved = entityManager.insert(columnEntity);
            System.out.println(saved);
        }

        EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
        EmbeddedCassandraServerHelper.stopEmbeddedCassandra();
    }
 

@BeforeClass
public static void startEmbeddedCassandra() throws Exception {
  String version = System.getProperty("java.version");
  // this statement can be removed only when this issue[https://github.com/jsevellec/cassandra-unit/issues/249] will be resolved
  if (!version.startsWith("1.8")) {
    throw new IllegalStateException("Only Java 8 is allowed for running tests. Your java version: " + version);
  }
  EmbeddedCassandraServerHelper.startEmbeddedCassandra();
}
 

@BeforeClass
public static void startCassandraEmbedded() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    final Cluster cluster = Cluster.builder().addContactPoints("127.0.0.1").withPort(9142).build();
    LOGGER.info("Server Started at 127.0.0.1:9142... ");
    final Session session = cluster.connect();
    session.execute(KEYSPACE_CREATION_QUERY);
    session.execute(KEYSPACE_ACTIVATE_QUERY);
    LOGGER.info("KeySpace created and activated.");
    Thread.sleep(5000);
}
 

@After
public void after() {
  if (isJdkSupported) {
    try {
      EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
    }
    catch (final Exception e) {
      logger.log(Level.WARNING, e.getMessage(), e);
    }
  }
}
 

@Before
public void before(final MockTracer tracer) throws Exception {
  if (isJdkSupported) {
    tracer.reset();
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    //EmbeddedCassandraServerHelper.getSession();
  }
}
 

@Test
public void should_execute_statement_with_timestamp_option() throws Exception {
  //Given
  String statement1 = "INSERT INTO zeppelin.ts(key,val) VALUES('k','v1');";
  String statement2 = "@timestamp=15\n" +
          "INSERT INTO zeppelin.ts(key,val) VALUES('k','v2');";

  CqlSession session = EmbeddedCassandraServerHelper.getSession();
  // Insert v1 with current timestamp
  interpreter.interpret(statement1, intrContext);
  System.out.println("going to read data from zeppelin.ts;");
  session.execute("SELECT val FROM zeppelin.ts LIMIT 1")
          .forEach(x -> System.out.println("row " + x ));

  Thread.sleep(1);

  //When
  // Insert v2 with past timestamp
  interpreter.interpret(statement2, intrContext);
  System.out.println("going to read data from zeppelin.ts;");
  session.execute("SELECT val FROM zeppelin.ts LIMIT 1")
          .forEach(x -> System.out.println("row " + x ));
  final String actual = session.execute("SELECT val FROM zeppelin.ts LIMIT 1").one()
          .getString("val");

  //Then
  assertThat(actual).isEqualTo("v1");
}
 

@BeforeClass
public static synchronized void setUp() throws IOException, InterruptedException {
  System.setProperty("cassandra.skip_wait_for_gossip_to_settle", "0");
  System.setProperty("cassandra.load_ring_state", "false");
  System.setProperty("cassandra.initial_token", "0");
  System.setProperty("cassandra.num_tokens", "nil");
  System.setProperty("cassandra.allocate_tokens_for_local_replication_factor", "nil");
  EmbeddedCassandraServerHelper.startEmbeddedCassandra();
  CqlSession session = EmbeddedCassandraServerHelper.getSession();
  new CQLDataLoader(session).load(new ClassPathCQLDataSet("prepare_all.cql", "zeppelin"));

  Properties properties = new Properties();
  properties.setProperty(CASSANDRA_CLUSTER_NAME, EmbeddedCassandraServerHelper.getClusterName());
  properties.setProperty(CASSANDRA_COMPRESSION_PROTOCOL, "NONE");
  properties.setProperty(CASSANDRA_CREDENTIALS_USERNAME, "none");
  properties.setProperty(CASSANDRA_CREDENTIALS_PASSWORD, "none");

  properties.setProperty(CASSANDRA_LOAD_BALANCING_POLICY, "DEFAULT");
  properties.setProperty(CASSANDRA_RETRY_POLICY, "DEFAULT");
  properties.setProperty(CASSANDRA_RECONNECTION_POLICY, "DEFAULT");
  properties.setProperty(CASSANDRA_SPECULATIVE_EXECUTION_POLICY, "DEFAULT");

  properties.setProperty(CASSANDRA_POOLING_CONNECTION_PER_HOST_LOCAL, "2");
  properties.setProperty(CASSANDRA_POOLING_CONNECTION_PER_HOST_REMOTE, "1");
  properties.setProperty(CASSANDRA_POOLING_MAX_REQUESTS_PER_CONNECTION, "1024");

  properties.setProperty(CASSANDRA_POOLING_POOL_TIMEOUT_MILLIS, "5000");
  properties.setProperty(CASSANDRA_POOLING_HEARTBEAT_INTERVAL_SECONDS, "30");

  properties.setProperty(CASSANDRA_QUERY_DEFAULT_CONSISTENCY, "ONE");
  properties.setProperty(CASSANDRA_QUERY_DEFAULT_SERIAL_CONSISTENCY, "SERIAL");
  properties.setProperty(CASSANDRA_QUERY_DEFAULT_FETCH_SIZE, "5000");

  properties.setProperty(CASSANDRA_SOCKET_CONNECTION_TIMEOUT_MILLIS, "5000");
  properties.setProperty(CASSANDRA_SOCKET_READ_TIMEOUT_MILLIS, "12000");
  properties.setProperty(CASSANDRA_SOCKET_TCP_NO_DELAY, "true");

  properties.setProperty(CASSANDRA_HOSTS, EmbeddedCassandraServerHelper.getHost());
  properties.setProperty(CASSANDRA_PORT,
          Integer.toString(EmbeddedCassandraServerHelper.getNativeTransportPort()));
  properties.setProperty("datastax-java-driver.advanced.connection.pool.local.size", "1");
  interpreter = new CassandraInterpreter(properties);
  interpreter.open();
}
 

@Override
public void before() throws Throwable {
    cassandraUnit = new MyCassandraCQLUnit(getDataSet(CASSANDRA_KEYSPACE, 1));
    cassandraUnit.before();
    host = EmbeddedCassandraServerHelper.getHost();
    port = EmbeddedCassandraServerHelper.getNativeTransportPort();
}
 

@After
public void after() {
  try {
    EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
  }
  catch (final Exception e) {
    logger.log(Level.WARNING, e.getMessage(), e);
  }
}
 

@BeforeClass
public static void startCassandra() {
    try {
        EmbeddedCassandraServerHelper.startEmbeddedCassandra();
        cqlSession = EmbeddedCassandraServerHelper.getSession();
        CqlOperations.createKeyspace(cqlSession).accept(CassandraTransactionManager.KEYSPACE);
        cqlSession.execute(CassandraTransactionManager.CREATE_TABLE);
    } catch (Exception exception) {
        exception.printStackTrace();
        throw new RuntimeException(exception);
    }
}
 

@SuppressWarnings("UnusedReturnValue")
private static Session startEmbeddedCassandra(boolean disableCassandra) {
    if (disableCassandra) {
        logger.warn("Embedded cassandra is NOT starting up because your app configuration explicitly requests "
                    + "that it be disabled.");
        return null;
    }

    if (cassandraSession == null) {
        File cassandraWorkDir = new File(embeddedClusterWorkDirectory);
        String cassandraWorkDirAbsolutePath = cassandraWorkDir.getAbsolutePath();
        if (!cassandraWorkDir.exists()) {
            logger.info("Creating the  embedded Cassandra folders...{}", cassandraWorkDirAbsolutePath);
            if (!cassandraWorkDir.mkdirs()) {
                throw new RuntimeException("Unable to create working directory " + cassandraWorkDirAbsolutePath);
            }
        }
        // Start embedded cassandra
        logger.info("Finished Creating the  embedded Cassandra folders...{}", cassandraWorkDirAbsolutePath);
        logger.info("Starting embedded Cassandra");

        try {
            EmbeddedCassandraServerHelper.startEmbeddedCassandra(cassandraYamlFile,
                                                                 embeddedClusterWorkDirectory);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }

        Cluster cassandraCluster = Cluster.builder()
                                          .addContactPoint(embeddedClusterContactPointHost)
                                          .withPort(embeddedClusterContactPointPort)
                                          .build();
        cassandraSession = cassandraCluster.connect();
    }

    return cassandraSession;
}
 

@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException, URISyntaxException  {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(9142).build();
    Session session = cluster.connect();
    CQLDataLoader dataLoader = new CQLDataLoader(session);
    dataLoader.load(new ClassPathCQLDataSet("config/cql/create-tables.cql", true, CASSANDRA_UNIT_KEYSPACE));
    applyScripts(dataLoader, "config/cql/changelog/", "*.cql");
}
 

@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(9142).build();
    Session session = cluster.connect();
    CQLDataLoader dataLoader = new CQLDataLoader(session);
    dataLoader.load(new ClassPathCQLDataSet("config/cql/create-tables.cql", true, "cassandra_unit_keyspace"));
}
 

private void startEmbeddedCassandra() throws Exception {
    try {
        EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    } catch (Exception e) {
        LOGGER.error("Error starting embedded cassandra server", e);
        throw e;
    }
}
 

@BeforeClass
public static void startCassandraEmbedded() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    final Cluster cluster = Cluster.builder().addContactPoints("127.0.0.1").withPort(9142).build();
    LOGGER.info("Server Started at 127.0.0.1:9142... ");
    final Session session = cluster.connect();
    session.execute(KEYSPACE_CREATION_QUERY);
    session.execute(KEYSPACE_ACTIVATE_QUERY);
    LOGGER.info("KeySpace created and activated.");
    Thread.sleep(5000);
}
 

@After
public void tearDown(TestContext testContext) {
  final Async async = testContext.async();
  client.close(testContext.asyncAssertSuccess(close -> async.countDown()));
  async.await();
  EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
  vertx.close(testContext.asyncAssertSuccess());
}
 

/**
 * Create DAO with embedded cassandra
 * @return builder using embedded cassandra
 */
public CasquatchTestDaoBuilder withEmbedded() {
    try {

        EmbeddedCassandraServerHelper.startEmbeddedCassandra(EmbeddedCassandraServerHelper.CASSANDRA_RNDPORT_YML_FILE, EmbeddedCassandraServerHelper.DEFAULT_STARTUP_TIMEOUT);
        log.info("Embedded Cassandra Started");
        return (CasquatchTestDaoBuilder) this.withBasicContactPoints(EmbeddedCassandraServerHelper.getHost()+":"+EmbeddedCassandraServerHelper.getNativeTransportPort())
                        .withBasicLoadBalancingPolicyLocalDatacenter("datacenter1")
                        .withBasicRequestConsistency("LOCAL_ONE");
    }
    catch(Exception e) {
        throw new DriverException(e);
    }
}
 

/**
 * Drop all tables in TEST_KEYSPACE
 */
protected static void deleteTestKeyspaceTables() {
    Session session = EmbeddedCassandraServerHelper.getSession();
    Cluster cluster = EmbeddedCassandraServerHelper.getCluster();
    for (TableMetadata tm : cluster.getMetadata().getKeyspace(TEST_KEYSPACE).getTables()) {
        session.execute("DROP TABLE IF EXISTS " + keyspaceTable(tm.getName()));
    }
}
 

@BeforeClass
public static void startCassandraEmbedded() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    final Cluster cluster = Cluster.builder().addContactPoints("127.0.0.1").withPort(9142).build();
    final Session session = cluster.connect();
    session.execute(KEYSPACE_CREATION_QUERY);
    session.execute(KEYSPACE_ACTIVATE_QUERY);
    Thread.sleep(5000);
}
 

@BeforeClass
public static void startCassandraEmbedded() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(25000);
    final Cluster cluster = Cluster.builder().addContactPoints("127.0.0.1").withPort(9142).build();
    LOGGER.info("Server Started at 127.0.0.1:9142... ");
    final Session session = cluster.connect();
    session.execute(KEYSPACE_CREATION_QUERY);
    session.execute(KEYSPACE_ACTIVATE_QUERY);
    LOGGER.info("KeySpace created and activated.");
    Thread.sleep(5000);
}
 

@BeforeClass
public void setup() {
    try {
        EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra_test.yml");
        eventRepository = new CassandraBasedAuditRepository();
        Configuration atlasConf = new MapConfiguration(getClusterProperties());
        ((CassandraBasedAuditRepository) eventRepository).setApplicationProperties(atlasConf);
        ((CassandraBasedAuditRepository) eventRepository).start();

        ensureClusterCreation();
    }
    catch (Exception ex) {
        throw new SkipException("setup: failed!", ex);
    }
}
 

@Override
protected void before() throws Throwable {
    // This improves boot time by a few seconds
    System.setProperty("cassandra.unsafesystem", "true");

    EmbeddedCassandraServerHelper.startEmbeddedCassandra(STARTUP_TIMEOUT);
}
 

public Session getSession() {
    if (session == null) {
        loadSchema();
        session = EmbeddedCassandraServerHelper.getSession();
    }
    return session;
}
 

@BeforeClass
public static void init() throws ConfigurationException, TTransportException, IOException, InterruptedException {
    // Start an embedded Cassandra Server
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(20000L);
}
 

@AfterClass
public static void cleanup() {
    EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
}
 

@AfterClass
public static void cleanup() {
    EmbeddedCassandraServerHelper.cleanEmbeddedCassandra();
}