Skip to content

Commit

Permalink
fix(tests): add new containerized integration tests to run orca with …
Browse files Browse the repository at this point in the history
…mysql and postgres
  • Loading branch information
kirangodishala committed Jun 7, 2024
1 parent e110e65 commit 8cb589b
Show file tree
Hide file tree
Showing 7 changed files with 401 additions and 58 deletions.
5 changes: 5 additions & 0 deletions orca-integration/orca-integration.gradle
Original file line number Diff line number Diff line change
Expand Up @@ -3,10 +3,15 @@ dependencies {
testImplementation "org.assertj:assertj-core"
testImplementation "org.junit.jupiter:junit-jupiter-api"
testImplementation "org.slf4j:slf4j-api"
testImplementation "org.testcontainers:mysql"
testImplementation "org.testcontainers:postgresql"
testImplementation "org.testcontainers:testcontainers"
testImplementation "org.testcontainers:junit-jupiter"
testRuntimeOnly "ch.qos.logback:logback-classic"
testRuntimeOnly "mysql:mysql-connector-java"
testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
testRuntimeOnly "org.postgresql:postgresql"

}

test.configure {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -18,97 +18,53 @@
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.Network;
import org.testcontainers.containers.output.Slf4jLogConsumer;
import org.testcontainers.containers.wait.strategy.Wait;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;

@Testcontainers
class StandaloneContainerTest {
class BaseContainerTest {

private static final String REDIS_NETWORK_ALIAS = "redisHost";
private static final Logger logger = LoggerFactory.getLogger(BaseContainerTest.class);

private static final int REDIS_PORT = 6379;
protected final Network network = Network.newNetwork();

private static final Logger logger = LoggerFactory.getLogger(StandaloneContainerTest.class);
private static final int ORCA_PORT = 8083;

private static final Network network = Network.newNetwork();
protected GenericContainer<?> orcaContainer;

private static final GenericContainer redis =
new GenericContainer(DockerImageName.parse("library/redis:5-alpine"))
.withNetwork(network)
.withNetworkAliases(REDIS_NETWORK_ALIAS)
.withExposedPorts(REDIS_PORT);

private static GenericContainer orcaContainer;
private static DockerImageName dockerImageName;

@BeforeAll
static void setupOnce() throws Exception {
static void setupInit() {
String fullDockerImageName = System.getenv("FULL_DOCKER_IMAGE_NAME");

// Skip the tests if there's no docker image. This allows gradlew build to work.
assumeTrue(fullDockerImageName != null);

redis.start();

DockerImageName dockerImageName = DockerImageName.parse(fullDockerImageName);

orcaContainer =
new GenericContainer(dockerImageName)
.withNetwork(network)
.withExposedPorts(8083)
.dependsOn(redis)
.waitingFor(Wait.forHealthcheck().withStartupTimeout(Duration.ofSeconds(90)))
.withEnv("SPRING_APPLICATION_JSON", getSpringApplicationJson());

Slf4jLogConsumer logConsumer = new Slf4jLogConsumer(logger);
orcaContainer.start();
orcaContainer.followOutput(logConsumer);
}

private static String getSpringApplicationJson() throws JsonProcessingException {
String redisUrl = "redis://" + REDIS_NETWORK_ALIAS + ":" + REDIS_PORT;
logger.info("redisUrl: '{}'", redisUrl);
Map<String, String> properties =
Map.of("redis.connection", redisUrl, "services.fiat.baseUrl", "http://nowhere");
ObjectMapper mapper = new ObjectMapper();
return mapper.writeValueAsString(properties);
}

@AfterAll
static void cleanupOnce() {
if (orcaContainer != null) {
orcaContainer.stop();
}

if (redis != null) {
redis.stop();
}
dockerImageName = DockerImageName.parse(fullDockerImageName);
}

@BeforeEach
void init(TestInfo testInfo) {
void init(TestInfo testInfo) throws Exception {
System.out.println("--------------- Test " + testInfo.getDisplayName());
orcaContainer =
new GenericContainer(dockerImageName)
.withNetwork(network)
.withExposedPorts(ORCA_PORT)
.waitingFor(Wait.forHealthcheck().withStartupTimeout(Duration.ofSeconds(120)));
}

@Test
void testHealthCheck() throws Exception {
// hit an arbitrary endpoint
HttpRequest request =
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,118 @@
/*
* Copyright 2024 Salesforce, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.netflix.spinnaker.orca;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.containers.output.Slf4jLogConsumer;
import org.testcontainers.junit.jupiter.Testcontainers;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@Testcontainers
public class MySqlContainerTest extends BaseContainerTest {

private static final Logger logger = LoggerFactory.getLogger(MySqlContainerTest.class);

private static final String MYSQL_NETWORK_ALIAS = "mysqlHost";

private static final int MYSQL_PORT = 3306;

private MySQLContainer<?> mysql;

private String jdbcUrl = "";

@BeforeEach
void setup() throws Exception {
mysql =
new MySQLContainer<>("mysql:8.0.37")
.withDatabaseName("orca")
.withUsername("root")
.withPassword("root")
.withNetwork(network)
.withNetworkAliases(MYSQL_NETWORK_ALIAS)
.withInitScript("mysql_init.sql");
mysql.start();
jdbcUrl = String.format("jdbc:mysql://%s:%d/orca", MYSQL_NETWORK_ALIAS, MYSQL_PORT);
orcaContainer
.dependsOn(mysql)
.withEnv("SPRING_APPLICATION_JSON", getSpringApplicationJson())
.start();

Slf4jLogConsumer logConsumer = new Slf4jLogConsumer(logger);
orcaContainer.followOutput(logConsumer);
}

private String getSpringApplicationJson() throws JsonProcessingException {
logger.info("--------- jdbcUrl: '{}'", jdbcUrl);
Map<String, String> connectionPool =
Map.of("jdbcUrl", jdbcUrl, "user", "orca_service", "password", "0rcaPassw0rd");
Map<String, String> migration =
Map.of("jdbcUrl", jdbcUrl, "user", "orca_migrate", "password", "0rcaPassw0rd");
Map<String, Boolean> sql = Map.of("enabled", true);
Map<String, Boolean> redis = Map.of("enabled", false);
Map<String, Object> pendingExecutionService = Map.of("sql", sql, "redis", redis);
Map<String, Object> executionRepository = Map.of("sql", sql, "redis", redis);
Map<String, Object> keiko = Map.of("sql", sql, "redis", redis);

Map<String, Object> properties =
Map.of(
"sql.enabled",
"true",
"services.fiat.baseUrl",
"http://nowhere",
"sql.connectionPool",
connectionPool,
"redis.enabled",
"false",
"sql.migration",
migration,
"executionRepository",
executionRepository,
"keiko.queue",
keiko,
"queue.pendingExecutionService",
pendingExecutionService,
"monitor.activeExecutions.redis",
"false");
ObjectMapper mapper = new ObjectMapper();
return mapper.writeValueAsString(properties);
}

@AfterAll
void cleanupOnce() {
if (orcaContainer != null) {
orcaContainer.stop();
}

if (mysql != null) {
mysql.stop();
}
}

@Test
void testHealthCheckWithMySql() throws Exception {
super.testHealthCheck();
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,126 @@
/*
* Copyright 2024 Salesforce, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.netflix.spinnaker.orca;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.containers.output.Slf4jLogConsumer;
import org.testcontainers.junit.jupiter.Testcontainers;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@Testcontainers
public class PostgresContainerTest extends BaseContainerTest {

private static final Logger logger = LoggerFactory.getLogger(PostgresContainerTest.class);

private static final String POSTGRES_NETWORK_ALIAS = "postgresHost";

private static final int POSTGRES_PORT = 5432;

private PostgreSQLContainer<?> postgres;

private String jdbcUrl = "";

@BeforeEach
void setup() throws Exception {
postgres =
new PostgreSQLContainer<>("postgres:15")
.withDatabaseName("orca")
.withUsername("postgres")
.withPassword("postgres")
.withNetwork(network)
.withNetworkAliases(POSTGRES_NETWORK_ALIAS)
.withInitScript("postgres_init.sql");
postgres.start();
jdbcUrl = String.format("jdbc:postgresql://%s:%d/orca", POSTGRES_NETWORK_ALIAS, POSTGRES_PORT);
orcaContainer
.dependsOn(postgres)
.withEnv("SPRING_APPLICATION_JSON", getSpringApplicationJson())
.start();

Slf4jLogConsumer logConsumer = new Slf4jLogConsumer(logger);
orcaContainer.followOutput(logConsumer);
}

private String getSpringApplicationJson() throws JsonProcessingException {
logger.info("--------- jdbcUrl: '{}'", jdbcUrl);
Map<String, String> connectionPool =
Map.of(
"dialect",
"POSTGRES",
"jdbcUrl",
jdbcUrl,
"user",
"orca_service",
"password",
"0rcaPassw0rd");
Map<String, String> migration =
Map.of("jdbcUrl", jdbcUrl, "user", "orca_migrate", "password", "0rcaPassw0rd");
Map<String, Boolean> sql = Map.of("enabled", true);
Map<String, Boolean> redis = Map.of("enabled", false);
Map<String, Object> pendingExecutionService = Map.of("sql", sql, "redis", redis);
Map<String, Object> executionRepository = Map.of("sql", sql, "redis", redis);
Map<String, Object> keiko = Map.of("sql", sql, "redis", redis);

Map<String, Object> properties =
Map.of(
"sql.enabled",
"true",
"services.fiat.baseUrl",
"http://nowhere",
"sql.connectionPool",
connectionPool,
"redis.enabled",
"false",
"sql.migration",
migration,
"executionRepository",
executionRepository,
"keiko.queue",
keiko,
"queue.pendingExecutionService",
pendingExecutionService,
"monitor.activeExecutions.redis",
"false");
ObjectMapper mapper = new ObjectMapper();
return mapper.writeValueAsString(properties);
}

@AfterAll
void cleanupOnce() {
if (orcaContainer != null) {
orcaContainer.stop();
}

if (postgres != null) {
postgres.stop();
}
}

@Test
void testHealthCheckWithPostgres() throws Exception {
super.testHealthCheck();
}
}
Loading

0 comments on commit 8cb589b

Please sign in to comment.