jlengrand/engine
1
0
Fork 0
mirror of https://github.com/jlengrand/engine.git synced 2026-03-10 08:11:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: kubeconfig issues in tests

Browse Source
This commit is contained in:
enzo
2022-03-10 16:58:01 +01:00
committed by Pierre Mavro
parent d5793b82f2
commit 2d3711a464
21 changed files with 824 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/cloud_provider/digitalocean/kubernetes/mod.rs
View File

@@ -653,17 +653,13 @@ impl DOKS {
}
// push config file to object storage
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
let kubeconfig_name = format!("{}.yaml", self.id());
if let Err(e) = self.spaces.put(
self.kubeconfig_bucket_name().as_str(),
kubeconfig_name.as_str(),
format!(
"{}/{}/{}",
temp_dir.as_str(),
self.kubeconfig_bucket_name().as_str(),
kubeconfig_name.as_str()
)
.as_str(),
kubeconfig_path.to_str().expect("No path for Kubeconfig"),
) {
let error = EngineError::new_object_storage_cannot_put_file_into_bucket_error(
event_details.clone(),
@@ -696,9 +692,6 @@ impl DOKS {
};
// kubernetes helm deployments on the cluster
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
let credentials_environment_variables: Vec<(String, String)> = self
.cloud_provider
.credentials_environment_variables()
@@ -911,7 +904,7 @@ impl DOKS {
fn delete(&self) -> Result<(), EngineError> {
let event_details = self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete));
let listeners_helper = ListenersHelper::new(&self.listeners);
let mut skip_kubernetes_step = false;
let skip_kubernetes_step = false;
self.send_to_customer(
format!("Preparing to delete DOKS cluster {} with id {}", self.name(), self.id()).as_str(),
&listeners_helper,
@@ -961,23 +954,6 @@ impl DOKS {
));
}
let kubernetes_config_file_path = match self.get_kubeconfig_file_path() {
Ok(x) => x,
Err(e) => {
let safe_message = "Skipping Kubernetes uninstall because it can't be reached.";
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
skip_kubernetes_step = true;
"".to_string()
}
};
// should apply before destroy to be sure destroy will compute on all resources
// don't exit on failure, it can happen if we resume a destroy process
let message = format!(
@@ -1009,6 +985,9 @@ impl DOKS {
);
};
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
if !skip_kubernetes_step {
// should make the diff between all namespaces and qovery managed namespaces
let message = format!(
@@ -1023,7 +1002,7 @@ impl DOKS {
self.send_to_customer(&message, &listeners_helper);
let all_namespaces = kubectl_exec_get_all_namespaces(
&kubernetes_config_file_path,
&kubeconfig_path,
self.cloud_provider().credentials_environment_variables(),
);
@@ -1042,7 +1021,7 @@ impl DOKS {
for namespace_to_delete in namespaces_to_delete.iter() {
match cmd::kubectl::kubectl_exec_delete_namespace(
&kubernetes_config_file_path,
&kubeconfig_path,
namespace_to_delete,
self.cloud_provider().credentials_environment_variables(),
) {
@@ -1101,7 +1080,7 @@ impl DOKS {
// delete custom metrics api to avoid stale namespaces on deletion
let helm = Helm::new(
&kubernetes_config_file_path,
&kubeconfig_path,
&self.cloud_provider.credentials_environment_variables(),
)
.map_err(|e| to_engine_error(&event_details, e))?;
@@ -1111,7 +1090,7 @@ impl DOKS {
// required to avoid namespace stuck on deletion
uninstall_cert_manager(
&kubernetes_config_file_path,
&kubeconfig_path,
self.cloud_provider().credentials_environment_variables(),
event_details.clone(),
self.logger(),
@@ -1165,7 +1144,7 @@ impl DOKS {
for qovery_namespace in qovery_namespaces.iter() {
let deletion = cmd::kubectl::kubectl_exec_delete_namespace(
&kubernetes_config_file_path,
&kubeconfig_path,
qovery_namespace,
self.cloud_provider().credentials_environment_variables(),
);

44
src/cloud_provider/scaleway/kubernetes/mod.rs
View File

@@ -786,17 +786,13 @@ impl Kapsule {
}
// push config file to object storage
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
let kubeconfig_name = format!("{}.yaml", self.id());
if let Err(e) = self.object_storage.put(
self.kubeconfig_bucket_name().as_str(),
kubeconfig_name.as_str(),
format!(
"{}/{}/{}",
temp_dir.as_str(),
self.kubeconfig_bucket_name().as_str(),
kubeconfig_name.as_str()
)
.as_str(),
kubeconfig_path.to_str().expect("No path for Kubeconfig"),
) {
let error = EngineError::new_object_storage_cannot_put_file_into_bucket_error(
event_details.clone(),
@@ -1015,9 +1011,6 @@ impl Kapsule {
};
// kubernetes helm deployments on the cluster
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
let credentials_environment_variables: Vec<(String, String)> = self
.cloud_provider
.credentials_environment_variables()
@@ -1325,7 +1318,7 @@ impl Kapsule {
fn delete(&self) -> Result<(), EngineError> {
let event_details = self.get_event_details(Stage::Infrastructure(InfrastructureStep::Delete));
let listeners_helper = ListenersHelper::new(&self.listeners);
let mut skip_kubernetes_step = false;
let skip_kubernetes_step = false;
self.send_to_customer(
format!("Preparing to delete SCW cluster {} with id {}", self.name(), self.id()).as_str(),
@@ -1372,22 +1365,6 @@ impl Kapsule {
));
}
let kubernetes_config_file_path = match self.get_kubeconfig_file_path() {
Ok(x) => x,
Err(e) => {
let safe_message = "Skipping Kubernetes uninstall because it can't be reached.";
self.logger().log(
LogLevel::Warning,
EngineEvent::Deleting(
event_details.clone(),
EventMessage::new(safe_message.to_string(), Some(e.message())),
),
);
skip_kubernetes_step = true;
"".to_string()
}
};
// should apply before destroy to be sure destroy will compute on all resources
// don't exit on failure, it can happen if we resume a destroy process
let message = format!(
@@ -1419,6 +1396,9 @@ impl Kapsule {
);
};
let kubeconfig_path = &self.get_kubeconfig_file_path()?;
let kubeconfig_path = Path::new(kubeconfig_path);
if !skip_kubernetes_step {
// should make the diff between all namespaces and qovery managed namespaces
let message = format!(
@@ -1433,7 +1413,7 @@ impl Kapsule {
self.send_to_customer(&message, &listeners_helper);
let all_namespaces = kubectl_exec_get_all_namespaces(
&kubernetes_config_file_path,
&kubeconfig_path,
self.cloud_provider().credentials_environment_variables(),
);
@@ -1452,7 +1432,7 @@ impl Kapsule {
for namespace_to_delete in namespaces_to_delete.iter() {
match cmd::kubectl::kubectl_exec_delete_namespace(
&kubernetes_config_file_path,
&kubeconfig_path,
namespace_to_delete,
self.cloud_provider().credentials_environment_variables(),
) {
@@ -1511,7 +1491,7 @@ impl Kapsule {
// delete custom metrics api to avoid stale namespaces on deletion
let helm = Helm::new(
&kubernetes_config_file_path,
&kubeconfig_path,
&self.cloud_provider.credentials_environment_variables(),
)
.map_err(|e| to_engine_error(&event_details, e))?;
@@ -1521,7 +1501,7 @@ impl Kapsule {
// required to avoid namespace stuck on deletion
uninstall_cert_manager(
&kubernetes_config_file_path,
&kubeconfig_path,
self.cloud_provider().credentials_environment_variables(),
event_details.clone(),
self.logger(),
@@ -1575,7 +1555,7 @@ impl Kapsule {
for qovery_namespace in qovery_namespaces.iter() {
let deletion = cmd::kubectl::kubectl_exec_delete_namespace(
&kubernetes_config_file_path,
&kubeconfig_path,
qovery_namespace,
self.cloud_provider().credentials_environment_variables(),
);

25
test_utilities/src/aws.rs
View File

@@ -65,8 +65,26 @@ pub fn container_registry_docker_hub(context: &Context) -> DockerHub {
)
}
pub fn aws_default_engine_config(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
AWS::docker_cr_engine(
&context,
logger,
AWS_TEST_REGION.to_string().as_str(),
AWS_KUBERNETES_VERSION.to_string(),
&ClusterDomain::Default,
None,
)
}
impl Cluster<AWS, Options> for AWS {
fn docker_cr_engine(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
fn docker_cr_engine(
context: &Context,
logger: Box<dyn Logger>,
localisation: &str,
kubernetes_version: String,
cluster_domain: &ClusterDomain,
vpc_network_mode: Option<VpcQoveryNetworkMode>,
) -> EngineConfig {
// use ECR
let container_registry = Box::new(container_registry_ecr(context));
@@ -75,8 +93,7 @@ impl Cluster<AWS, Options> for AWS {
// use AWS
let cloud_provider: Arc<Box<dyn CloudProvider>> = Arc::new(AWS::cloud_provider(context));
let dns_provider: Arc<Box<dyn DnsProvider>> =
Arc::new(dns_provider_cloudflare(context, ClusterDomain::Default));
let dns_provider: Arc<Box<dyn DnsProvider>> = Arc::new(dns_provider_cloudflare(context, cluster_domain));
let k = get_environment_test_kubernetes(
Aws,
@@ -84,6 +101,8 @@ impl Cluster<AWS, Options> for AWS {
cloud_provider.clone(),
dns_provider.clone(),
logger.clone(),
localisation,
kubernetes_version.as_str(),
);
EngineConfig::new(

4
test_utilities/src/cloudflare.rs
View File

@@ -4,10 +4,10 @@ use qovery_engine::dns_provider::cloudflare::Cloudflare;
use qovery_engine::dns_provider::DnsProvider;
use qovery_engine::models::{Context, Domain};
pub fn dns_provider_cloudflare(context: &Context, domain: ClusterDomain) -> Box<dyn DnsProvider> {
pub fn dns_provider_cloudflare(context: &Context, domain: &ClusterDomain) -> Box<dyn DnsProvider> {
let secrets = FuncTestsSecrets::new();
let domain = Domain::new(match domain {
ClusterDomain::Custom(domain) => domain,
ClusterDomain::Custom(domain) => domain.to_string(),
ClusterDomain::Default => secrets.CLOUDFLARE_DOMAIN.expect("CLOUDFLARE_DOMAIN is not set"),
});
Box::new(Cloudflare::new(

242
test_utilities/src/common.rs
View File

@@ -10,13 +10,12 @@ use qovery_engine::models::{
GitCredentials, Port, Protocol, Route, Router, Storage, StorageType,
};
use crate::aws::AWS_KUBERNETES_VERSION;
use crate::cloudflare::dns_provider_cloudflare;
use crate::digitalocean::DO_KUBERNETES_VERSION;
use crate::scaleway::SCW_KUBERNETES_VERSION;
use crate::aws::{AWS_KUBERNETES_VERSION, AWS_TEST_REGION};
use crate::digitalocean::{DO_KUBERNETES_VERSION, DO_TEST_REGION};
use crate::scaleway::{SCW_KUBERNETES_VERSION, SCW_TEST_ZONE};
use crate::utilities::{
db_disk_type, db_infos, db_instance_type, generate_cluster_id, generate_id, generate_password, get_pvc, get_svc,
get_svc_name, init, FuncTestsSecrets,
db_disk_type, db_infos, db_instance_type, generate_id, generate_password, get_pvc, get_svc, get_svc_name, init,
FuncTestsSecrets,
};
use base64;
use qovery_engine::cloud_provider::aws::kubernetes::{VpcQoveryNetworkMode, EKS};
@@ -55,7 +54,14 @@ pub enum ClusterDomain {
}
pub trait Cluster<T, U> {
fn docker_cr_engine(context: &Context, logger: Box<dyn Logger>) -> EngineConfig;
fn docker_cr_engine(
context: &Context,
logger: Box<dyn Logger>,
localisation: &str,
kubernetes_version: String,
cluster_domain: &ClusterDomain,
vpc_network_mode: Option<VpcQoveryNetworkMode>,
) -> EngineConfig;
fn cloud_provider(context: &Context) -> Box<T>;
fn kubernetes_nodes() -> Vec<NodeGroups>;
fn kubernetes_cluster_options(secrets: FuncTestsSecrets, cluster_id: Option<String>) -> U;
@@ -68,6 +74,7 @@ pub trait Infrastructure {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult;
fn pause_environment(
&self,
@@ -75,6 +82,7 @@ pub trait Infrastructure {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult;
fn delete_environment(
&self,
@@ -82,6 +90,7 @@ pub trait Infrastructure {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult;
}
@@ -92,14 +101,9 @@ impl Infrastructure for Environment {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult {
let engine: EngineConfig = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(context, logger.clone()),
Kind::Do => DO::docker_cr_engine(context, logger.clone()),
Kind::Scw => Scaleway::docker_cr_engine(context, logger.clone()),
};
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let mut tx = Transaction::new(engine_config, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let _ = tx.deploy_environment_with_options(
&environment_action,
DeploymentOption {
@@ -117,14 +121,9 @@ impl Infrastructure for Environment {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult {
let engine: EngineConfig = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(context, logger.clone()),
Kind::Do => DO::docker_cr_engine(context, logger.clone()),
Kind::Scw => Scaleway::docker_cr_engine(context, logger.clone()),
};
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let mut tx = Transaction::new(engine_config, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let _ = tx.pause_environment(&environment_action);
tx.commit()
@@ -136,14 +135,9 @@ impl Infrastructure for Environment {
context: &Context,
environment_action: &EnvironmentAction,
logger: Box<dyn Logger>,
engine_config: &EngineConfig,
) -> TransactionResult {
let engine: EngineConfig = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(context, logger.clone()),
Kind::Do => DO::docker_cr_engine(context, logger.clone()),
Kind::Scw => Scaleway::docker_cr_engine(context, logger.clone()),
};
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let mut tx = Transaction::new(engine_config, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let _ = tx.delete_environment(&environment_action);
tx.commit()
@@ -1082,7 +1076,40 @@ pub fn test_db(
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(provider_kind.clone(), &context, &ea, logger.clone());
let (localisation, kubernetes_version) = match provider_kind {
Kind::Aws => (AWS_TEST_REGION.to_string(), AWS_KUBERNETES_VERSION.to_string()),
Kind::Do => (DO_TEST_REGION.to_string(), DO_KUBERNETES_VERSION.to_string()),
Kind::Scw => (SCW_TEST_ZONE.to_string(), SCW_KUBERNETES_VERSION.to_string()),
};
let engine_config = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(
&context,
logger.clone(),
localisation.as_str(),
kubernetes_version,
&ClusterDomain::Default,
None,
),
Kind::Do => DO::docker_cr_engine(
&context,
logger.clone(),
localisation.as_str(),
kubernetes_version,
&ClusterDomain::Default,
None,
),
Kind::Scw => Scaleway::docker_cr_engine(
&context,
logger.clone(),
localisation.as_str(),
kubernetes_version,
&ClusterDomain::Default,
None,
),
};
let ret = environment.deploy_environment(provider_kind.clone(), &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
match database_mode.clone() {
@@ -1145,7 +1172,13 @@ pub fn test_db(
}
}
let ret = environment_delete.delete_environment(provider_kind.clone(), &context_for_delete, &ea_delete, logger);
let ret = environment_delete.delete_environment(
provider_kind.clone(),
&context_for_delete,
&ea_delete,
logger,
&engine_config,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -1157,27 +1190,24 @@ pub fn get_environment_test_kubernetes<'a>(
cloud_provider: Arc<Box<dyn CloudProvider>>,
dns_provider: Arc<Box<dyn DnsProvider>>,
logger: Box<dyn Logger>,
localisation: &str,
kubernetes_version: &str,
) -> Box<dyn Kubernetes> {
let secrets = FuncTestsSecrets::new();
let k: Box<dyn Kubernetes>;
match provider_kind {
Kind::Aws => {
let region = secrets
.AWS_DEFAULT_REGION
.as_ref()
.expect("AWS_DEFAULT_REGION is not set")
.as_str();
let aws_region = AwsRegion::from_str(region).expect("wrong AWS region name, please ensure it's correct");
let region = AwsRegion::from_str(localisation).expect("AWS region not supported");
k = Box::new(
EKS::new(
context.clone(),
context.cluster_id(),
uuid::Uuid::new_v4(),
format!("qovery-{}", context.cluster_id()).as_str(),
AWS_KUBERNETES_VERSION,
aws_region.clone(),
aws_region.get_zones_to_string(),
kubernetes_version,
region.clone(),
region.get_zones_to_string(),
cloud_provider,
dns_provider,
AWS::kubernetes_cluster_options(secrets.clone(), None),
@@ -1188,6 +1218,7 @@ pub fn get_environment_test_kubernetes<'a>(
);
}
Kind::Do => {
let region = DoRegion::from_str(localisation).expect("DO region not supported");
k = Box::new(
DOKS::new(
context.clone(),
@@ -1195,14 +1226,7 @@ pub fn get_environment_test_kubernetes<'a>(
uuid::Uuid::new_v4(),
format!("qovery-{}", context.cluster_id()),
DO_KUBERNETES_VERSION.to_string(),
DoRegion::from_str(
secrets
.clone()
.DIGITAL_OCEAN_DEFAULT_REGION
.expect("DIGITAL_OCEAN_DEFAULT_REGION is not set")
.as_str(),
)
.unwrap(),
region,
cloud_provider,
dns_provider,
DO::kubernetes_nodes(),
@@ -1213,6 +1237,7 @@ pub fn get_environment_test_kubernetes<'a>(
);
}
Kind::Scw => {
let zone = ScwZone::from_str(localisation).expect("SCW zone not supported");
k = Box::new(
Kapsule::new(
context.clone(),
@@ -1220,14 +1245,7 @@ pub fn get_environment_test_kubernetes<'a>(
uuid::Uuid::new_v4(),
format!("qovery-{}", context.cluster_id()),
SCW_KUBERNETES_VERSION.to_string(),
ScwZone::from_str(
secrets
.clone()
.SCALEWAY_DEFAULT_REGION
.expect("SCALEWAY_DEFAULT_REGION is not set")
.as_str(),
)
.unwrap(),
zone,
cloud_provider,
dns_provider,
Scaleway::kubernetes_nodes(),
@@ -1330,11 +1348,10 @@ pub fn cluster_test(
logger: Box<dyn Logger>,
localisation: &str,
aws_zones: Option<Vec<AwsZones>>,
secrets: FuncTestsSecrets,
test_type: ClusterTestType,
major_boot_version: u8,
minor_boot_version: u8,
cluster_domain: ClusterDomain,
cluster_domain: &ClusterDomain,
vpc_network_mode: Option<VpcQoveryNetworkMode>,
environment_to_deploy: Option<&EnvironmentAction>,
) -> String {
@@ -1342,15 +1359,33 @@ pub fn cluster_test(
let span = span!(Level::INFO, "test", name = test_name);
let _enter = span.enter();
let cluster_id = generate_cluster_id(localisation.clone());
let cluster_name = generate_cluster_id(localisation.clone());
let boot_version = format!("{}.{}", major_boot_version, minor_boot_version.clone());
let engine = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(&context, logger.clone()),
Kind::Do => DO::docker_cr_engine(&context, logger.clone()),
Kind::Scw => Scaleway::docker_cr_engine(&context, logger.clone()),
Kind::Aws => AWS::docker_cr_engine(
&context,
logger.clone(),
localisation,
boot_version,
cluster_domain,
vpc_network_mode.clone(),
),
Kind::Do => DO::docker_cr_engine(
&context,
logger.clone(),
localisation,
boot_version,
cluster_domain,
vpc_network_mode.clone(),
),
Kind::Scw => Scaleway::docker_cr_engine(
&context,
logger.clone(),
localisation,
boot_version,
cluster_domain,
vpc_network_mode.clone(),
),
};
let mut deploy_tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let mut delete_tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
@@ -1362,28 +1397,6 @@ pub fn cluster_test(
}
};
let dns_provider = Arc::new(dns_provider_cloudflare(&context, cluster_domain));
let cp: Arc<Box<dyn CloudProvider>> = match provider_kind {
Kind::Aws => Arc::new(AWS::cloud_provider(&context)),
Kind::Do => Arc::new(DO::cloud_provider(&context)),
Kind::Scw => Arc::new(Scaleway::cloud_provider(&context)),
};
let kubernetes = get_cluster_test_kubernetes(
provider_kind.clone(),
secrets.clone(),
&context,
cluster_id.clone(),
cluster_name.clone(),
boot_version.clone(),
localisation.clone(),
aws_zones.clone(),
cp.clone(),
dns_provider.clone(),
vpc_network_mode.clone(),
logger.clone(),
);
// Deploy
if let Err(err) = deploy_tx.create_kubernetes() {
panic!("{:?}", err)
@@ -1404,10 +1417,11 @@ pub fn cluster_test(
}
if let Err(err) = metrics_server_test(
kubernetes
engine
.kubernetes()
.get_kubeconfig_file_path()
.expect("Unable to get config file path"),
kubernetes.cloud_provider().credentials_environment_variables(),
engine.kubernetes().cloud_provider().credentials_environment_variables(),
) {
panic!("{:?}", err)
}
@@ -1433,30 +1447,43 @@ pub fn cluster_test(
assert!(matches!(resume_tx.commit(), TransactionResult::Ok));
if let Err(err) = metrics_server_test(
kubernetes
engine
.kubernetes()
.get_kubeconfig_file_path()
.expect("Unable to get config file path"),
kubernetes.cloud_provider().credentials_environment_variables(),
engine.kubernetes().cloud_provider().credentials_environment_variables(),
) {
panic!("{:?}", err)
}
}
ClusterTestType::WithUpgrade => {
let upgrade_to_version = format!("{}.{}", major_boot_version, minor_boot_version.clone() + 1);
let upgraded_kubernetes = get_cluster_test_kubernetes(
provider_kind.clone(),
secrets.clone(),
&context,
cluster_id.clone(),
cluster_name.clone(),
upgrade_to_version.clone(),
localisation.clone(),
aws_zones,
cp,
dns_provider,
vpc_network_mode.clone(),
logger.clone(),
);
let engine = match provider_kind {
Kind::Aws => AWS::docker_cr_engine(
&context,
logger.clone(),
localisation,
upgrade_to_version,
cluster_domain,
vpc_network_mode.clone(),
),
Kind::Do => DO::docker_cr_engine(
&context,
logger.clone(),
localisation,
upgrade_to_version,
cluster_domain,
vpc_network_mode.clone(),
),
Kind::Scw => Scaleway::docker_cr_engine(
&context,
logger.clone(),
localisation,
upgrade_to_version,
cluster_domain,
vpc_network_mode.clone(),
),
};
let mut upgrade_tx =
Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
let mut delete_tx =
@@ -1469,14 +1496,11 @@ pub fn cluster_test(
assert!(matches!(upgrade_tx.commit(), TransactionResult::Ok));
if let Err(err) = metrics_server_test(
upgraded_kubernetes
.as_ref()
engine
.kubernetes()
.get_kubeconfig_file_path()
.expect("Unable to get config file path"),
upgraded_kubernetes
.as_ref()
.cloud_provider()
.credentials_environment_variables(),
engine.kubernetes().cloud_provider().credentials_environment_variables(),
) {
panic!("{:?}", err)
}

26
test_utilities/src/digitalocean.rs
View File

@@ -1,5 +1,6 @@
use const_format::formatcp;
use qovery_engine::build_platform::Image;
use qovery_engine::cloud_provider::aws::kubernetes::VpcQoveryNetworkMode;
use qovery_engine::cloud_provider::digitalocean::kubernetes::DoksOptions;
use qovery_engine::cloud_provider::digitalocean::network::vpc::VpcInitKind;
use qovery_engine::cloud_provider::digitalocean::DO;
@@ -42,8 +43,26 @@ pub fn container_registry_digital_ocean(context: &Context) -> DOCR {
)
}
pub fn do_default_engine_config(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
DO::docker_cr_engine(
&context,
logger,
DO_TEST_REGION.to_string().as_str(),
DO_KUBERNETES_VERSION.to_string(),
&ClusterDomain::Default,
None,
)
}
impl Cluster<DO, DoksOptions> for DO {
fn docker_cr_engine(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
fn docker_cr_engine(
context: &Context,
logger: Box<dyn Logger>,
localisation: &str,
kubernetes_version: String,
cluster_domain: &ClusterDomain,
vpc_network_mode: Option<VpcQoveryNetworkMode>,
) -> EngineConfig {
// use DigitalOcean Container Registry
let container_registry = Box::new(container_registry_digital_ocean(context));
// use LocalDocker
@@ -51,8 +70,7 @@ impl Cluster<DO, DoksOptions> for DO {
// use Digital Ocean
let cloud_provider: Arc<Box<dyn CloudProvider>> = Arc::new(Self::cloud_provider(context));
let dns_provider: Arc<Box<dyn DnsProvider>> =
Arc::new(dns_provider_cloudflare(context, ClusterDomain::Default));
let dns_provider: Arc<Box<dyn DnsProvider>> = Arc::new(dns_provider_cloudflare(context, cluster_domain));
let k = get_environment_test_kubernetes(
Do,
@@ -60,6 +78,8 @@ impl Cluster<DO, DoksOptions> for DO {
cloud_provider.clone(),
dns_provider.clone(),
logger.clone(),
localisation,
kubernetes_version.as_str(),
);
EngineConfig::new(

26
test_utilities/src/scaleway.rs
View File

@@ -14,6 +14,7 @@ use crate::cloudflare::dns_provider_cloudflare;
use crate::utilities::{build_platform_local_docker, generate_id, logger, FuncTestsSecrets};
use crate::common::{get_environment_test_kubernetes, Cluster, ClusterDomain};
use qovery_engine::cloud_provider::aws::kubernetes::VpcQoveryNetworkMode;
use qovery_engine::cloud_provider::models::NodeGroups;
use qovery_engine::cloud_provider::qovery::EngineLocation;
use qovery_engine::cloud_provider::Kind::Scw;
@@ -61,8 +62,26 @@ pub fn container_registry_scw(context: &Context) -> ScalewayCR {
)
}
pub fn scw_default_engine_config(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
Scaleway::docker_cr_engine(
&context,
logger,
SCW_TEST_ZONE.to_string().as_str(),
SCW_KUBERNETES_VERSION.to_string(),
&ClusterDomain::Default,
None,
)
}
impl Cluster<Scaleway, KapsuleOptions> for Scaleway {
fn docker_cr_engine(context: &Context, logger: Box<dyn Logger>) -> EngineConfig {
fn docker_cr_engine(
context: &Context,
logger: Box<dyn Logger>,
localisation: &str,
kubernetes_version: String,
cluster_domain: &ClusterDomain,
vpc_network_mode: Option<VpcQoveryNetworkMode>,
) -> EngineConfig {
// use Scaleway CR
let container_registry = Box::new(container_registry_scw(context));
@@ -71,8 +90,7 @@ impl Cluster<Scaleway, KapsuleOptions> for Scaleway {
// use Scaleway
let cloud_provider: Arc<Box<dyn CloudProvider>> = Arc::new(Self::cloud_provider(context));
let dns_provider: Arc<Box<dyn DnsProvider>> =
Arc::new(dns_provider_cloudflare(context, ClusterDomain::Default));
let dns_provider: Arc<Box<dyn DnsProvider>> = Arc::new(dns_provider_cloudflare(context, cluster_domain));
let cluster = get_environment_test_kubernetes(
Scw,
@@ -80,6 +98,8 @@ impl Cluster<Scaleway, KapsuleOptions> for Scaleway {
cloud_provider.clone(),
dns_provider.clone(),
logger.clone(),
localisation,
kubernetes_version.as_str(),
);
EngineConfig::new(

64
tests/aws/aws_databases.rs
View File

@@ -5,15 +5,17 @@ use qovery_engine::cloud_provider::Kind;
use qovery_engine::models::{
Action, Clone2, Context, Database, DatabaseKind, DatabaseMode, Environment, EnvironmentAction, Port, Protocol,
};
use test_utilities::aws::{aws_default_engine_config, AWS_KUBERNETES_VERSION, AWS_TEST_REGION};
use tracing::{span, Level};
use self::test_utilities::aws::{AWS_DATABASE_DISK_TYPE, AWS_DATABASE_INSTANCE_TYPE};
use self::test_utilities::utilities::{
context, engine_run_test, generate_id, get_pods, get_svc_name, init, is_pod_restarted_env, logger, FuncTestsSecrets,
};
use qovery_engine::cloud_provider::aws::AWS;
use qovery_engine::models::DatabaseMode::{CONTAINER, MANAGED};
use qovery_engine::transaction::TransactionResult;
use test_utilities::common::{test_db, Infrastructure};
use test_utilities::common::{test_db, Cluster, ClusterDomain, Infrastructure};
/**
**
@@ -47,7 +49,9 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environment_3_apps_3_routers_3_databases(
&context,
secrets
@@ -64,10 +68,16 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -99,7 +109,9 @@ fn deploy_an_environment_with_db_and_pause_it() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environnement_2_app_2_routers_1_psql(
&context,
secrets
@@ -117,10 +129,10 @@ fn deploy_an_environment_with_db_and_pause_it() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment.pause_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.pause_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// Check that we have actually 0 pods running for this db
@@ -135,7 +147,13 @@ fn deploy_an_environment_with_db_and_pause_it() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), true);
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -168,7 +186,9 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let test_domain = secrets
.DEFAULT_TEST_DOMAIN
.as_ref()
@@ -195,7 +215,7 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_for_deletion = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// TODO: should be uncommented as soon as cert-manager is fixed
@@ -205,7 +225,13 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
assert_eq!(con, true);
}*/
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_for_deletion, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_for_deletion,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -238,8 +264,11 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_redeploy = context.clone_not_same_execution_id();
let engine_config_for_redeploy = aws_default_engine_config(&context_for_redeploy, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -314,11 +343,16 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret =
environment_to_redeploy.deploy_environment(Kind::Aws, &context_for_redeploy, &ea_redeploy, logger.clone());
let ret = environment_to_redeploy.deploy_environment(
Kind::Aws,
&context_for_redeploy,
&ea_redeploy,
logger.clone(),
&engine_config_for_redeploy,
);
assert!(matches!(ret, TransactionResult::Ok));
// TO CHECK: DATABASE SHOULDN'T BE RESTARTED AFTER A REDEPLOY
@@ -334,7 +368,13 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
(false, _) => assert!(false),
}
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(
ret,
TransactionResult::Ok | TransactionResult::UnrecoverableError(_, _)

168
tests/aws/aws_environment.rs
View File

@@ -13,7 +13,7 @@ use qovery_engine::models::{Action, Clone2, EnvironmentAction, Port, Protocol, S
use qovery_engine::transaction::TransactionResult;
use std::collections::BTreeMap;
use std::time::SystemTime;
use test_utilities::aws::container_registry_ecr;
use test_utilities::aws::{aws_default_engine_config, container_registry_ecr, AWS_KUBERNETES_VERSION, AWS_TEST_REGION};
use test_utilities::utilities::{build_platform_local_docker, context, init, kubernetes_config_path};
use tracing::{span, Level};
@@ -45,7 +45,10 @@ fn deploy_a_working_environment_with_no_router_on_aws_eks() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -62,10 +65,16 @@ fn deploy_a_working_environment_with_no_router_on_aws_eks() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_for_delete.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = environment_for_delete.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -95,6 +104,7 @@ fn test_build_cache() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger());
let environment = test_utilities::common::working_minimal_environment(
&context,
@@ -187,7 +197,10 @@ fn deploy_a_working_environment_and_pause_it_eks() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -200,7 +213,7 @@ fn deploy_a_working_environment_and_pause_it_eks() {
let ea = EnvironmentAction::Environment(environment.clone());
let selector = format!("appId={}", environment.clone().applications[0].id);
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = get_pods(
@@ -213,7 +226,13 @@ fn deploy_a_working_environment_and_pause_it_eks() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), false);
let ret = environment.pause_environment(Kind::Aws, &context_for_delete, &ea, logger.clone());
let ret = environment.pause_environment(
Kind::Aws,
&context_for_delete,
&ea,
logger.clone(),
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
// Check that we have actually 0 pods running for this app
@@ -264,7 +283,8 @@ fn deploy_a_working_environment_and_pause_it_eks() {
// Check we can resume the env
let ctx_resume = context.clone_not_same_execution_id();
let ret = environment.deploy_environment(Kind::Aws, &ctx_resume, &ea, logger.clone());
let engine_config_resume = aws_default_engine_config(&ctx_resume, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &ctx_resume, &ea, logger.clone(), &engine_config_resume);
assert!(matches!(ret, TransactionResult::Ok));
let ret = get_pods(
@@ -317,7 +337,8 @@ fn deploy_a_working_environment_and_pause_it_eks() {
assert!(filtered_pdb);
// Cleanup
let ret = environment.delete_environment(Kind::Aws, &context_for_delete, &ea, logger);
let ret =
environment.delete_environment(Kind::Aws, &context_for_delete, &ea, logger, &engine_config_for_delete);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -348,7 +369,9 @@ fn deploy_a_not_working_environment_with_no_router_on_aws_eks() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::non_working_environment(
&context,
@@ -365,10 +388,16 @@ fn deploy_a_not_working_environment_with_no_router_on_aws_eks() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::UnrecoverableError(_, _)));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(
ret,
TransactionResult::Ok | TransactionResult::UnrecoverableError(_, _)
@@ -403,7 +432,9 @@ fn build_with_buildpacks_and_deploy_a_working_environment() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -437,10 +468,16 @@ fn build_with_buildpacks_and_deploy_a_working_environment() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -472,7 +509,9 @@ fn build_worker_with_buildpacks_and_deploy_a_working_environment() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -506,10 +545,16 @@ fn build_worker_with_buildpacks_and_deploy_a_working_environment() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -541,7 +586,9 @@ fn deploy_a_working_environment_with_domain() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -556,10 +603,16 @@ fn deploy_a_working_environment_with_domain() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -591,7 +644,9 @@ fn deploy_a_working_environment_with_storage_on_aws_eks() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -625,7 +680,7 @@ fn deploy_a_working_environment_with_storage_on_aws_eks() {
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Aws, environment.clone(), secrets.clone()) {
@@ -636,7 +691,13 @@ fn deploy_a_working_environment_with_storage_on_aws_eks() {
Err(_) => assert!(false),
};
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -669,8 +730,11 @@ fn redeploy_same_app_with_ebs() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_bis = context.clone_not_same_execution_id();
let engine_config_bis = aws_default_engine_config(&context_bis, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = aws_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -707,7 +771,7 @@ fn redeploy_same_app_with_ebs() {
let ea2 = EnvironmentAction::Environment(environment_redeploy.clone());
let ea_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Aws, environment.clone(), secrets.clone()) {
@@ -727,7 +791,8 @@ fn redeploy_same_app_with_ebs() {
secrets.clone(),
);
let ret = environment_redeploy.deploy_environment(Kind::Aws, &context_bis, &ea2, logger.clone());
let ret =
environment_redeploy.deploy_environment(Kind::Aws, &context_bis, &ea2, logger.clone(), &engine_config_bis);
assert!(matches!(ret, TransactionResult::Ok));
let (_, number2) = is_pod_restarted_env(
@@ -739,7 +804,13 @@ fn redeploy_same_app_with_ebs() {
);
//nothing change in the app, so, it shouldn't be restarted
assert!(number.eq(&number2));
let ret = environment_delete.delete_environment(Kind::Aws, &context_for_deletion, &ea_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Aws,
&context_for_deletion,
&ea_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -771,8 +842,11 @@ fn deploy_a_not_working_environment_and_after_working_environment() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_not_working = context.clone_not_same_execution_id();
let engine_config_for_not_working = aws_default_engine_config(&context_for_not_working, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
// env part generation
let environment = test_utilities::common::working_minimal_environment(
@@ -808,13 +882,20 @@ fn deploy_a_not_working_environment_and_after_working_environment() {
&context_for_not_working,
&ea_not_working,
logger.clone(),
&engine_config_for_not_working,
);
assert!(matches!(ret, TransactionResult::UnrecoverableError(_, _)));
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_for_delete.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = environment_for_delete.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -850,6 +931,7 @@ fn deploy_ok_fail_fail_ok_environment() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -860,6 +942,7 @@ fn deploy_ok_fail_fail_ok_environment() {
// not working 1
let context_for_not_working_1 = context.clone_not_same_execution_id();
let engine_config_for_not_working_1 = aws_default_engine_config(&context_for_not_working_1, logger.clone());
let mut not_working_env_1 = environment.clone();
not_working_env_1.applications = not_working_env_1
.applications
@@ -875,10 +958,12 @@ fn deploy_ok_fail_fail_ok_environment() {
// not working 2
let context_for_not_working_2 = context.clone_not_same_execution_id();
let engine_config_for_not_working_2 = aws_default_engine_config(&context_for_not_working_2, logger.clone());
let not_working_env_2 = not_working_env_1.clone();
// work for delete
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
@@ -888,7 +973,7 @@ fn deploy_ok_fail_fail_ok_environment() {
let ea_delete = EnvironmentAction::Environment(delete_env.clone());
// OK
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// FAIL and rollback
@@ -897,6 +982,7 @@ fn deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_1,
&ea_not_working_1,
logger.clone(),
&engine_config_for_not_working_1,
);
assert!(matches!(
ret,
@@ -909,6 +995,7 @@ fn deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_2,
&ea_not_working_2,
logger.clone(),
&engine_config_for_not_working_2,
);
assert!(matches!(
ret,
@@ -916,10 +1003,16 @@ fn deploy_ok_fail_fail_ok_environment() {
));
// Should be working
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = delete_env.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = delete_env.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -951,6 +1044,7 @@ fn deploy_a_non_working_environment_with_no_failover_on_aws_eks() {
.expect("AWS_TEST_CLUSTER_ID is not set")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::non_working_environment(
&context,
secrets
@@ -960,16 +1054,23 @@ fn deploy_a_non_working_environment_with_no_failover_on_aws_eks() {
);
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
let ea = EnvironmentAction::Environment(environment.clone());
let ea_delete = EnvironmentAction::Environment(delete_env.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::UnrecoverableError(_, _)));
let ret = delete_env.delete_environment(Kind::Aws, &context_for_delete, &ea_delete, logger);
let ret = delete_env.delete_environment(
Kind::Aws,
&context_for_delete,
&ea_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
return test_name.to_string();
@@ -1001,7 +1102,9 @@ fn aws_eks_deploy_a_working_environment_with_sticky_session() {
.expect("AWS_TEST_CLUSTER_ID is not set in secrets")
.as_str(),
);
let engine_config = aws_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = aws_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::environment_only_http_server_router_with_sticky_session(
&context,
secrets
@@ -1017,14 +1120,19 @@ fn aws_eks_deploy_a_working_environment_with_sticky_session() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Aws, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// checking if cookie is properly set on the app
assert!(routers_sessions_are_sticky(environment.routers.clone()));
let ret =
environment_for_delete.delete_environment(Kind::Aws, &context_for_delete, &env_action_for_delete, logger);
let ret = environment_for_delete.delete_environment(
Kind::Aws,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
test_name.to_string()

30
tests/aws/aws_kubernetes.rs
View File

@@ -9,14 +9,13 @@ use qovery_engine::cloud_provider::aws::kubernetes::VpcQoveryNetworkMode;
use qovery_engine::cloud_provider::aws::kubernetes::VpcQoveryNetworkMode::{WithNatGateways, WithoutNatGateways};
use qovery_engine::cloud_provider::aws::regions::{AwsRegion, AwsZones};
use qovery_engine::cloud_provider::Kind;
use std::borrow::Borrow;
use std::str::FromStr;
use test_utilities::common::{cluster_test, ClusterDomain, ClusterTestType};
#[cfg(feature = "test-aws-infra")]
fn create_and_destroy_eks_cluster(
region: String,
zones: Vec<AwsZones>,
secrets: FuncTestsSecrets,
test_type: ClusterTestType,
major_boot_version: u8,
minor_boot_version: u8,
@@ -25,6 +24,7 @@ fn create_and_destroy_eks_cluster(
) {
engine_run_test(|| {
let region = AwsRegion::from_str(region.as_str()).expect("Wasn't able to convert the desired region");
let zones = region.get_zones();
cluster_test(
test_name,
Kind::Aws,
@@ -35,11 +35,10 @@ fn create_and_destroy_eks_cluster(
logger(),
region.to_aws_format().as_str(),
Some(zones),
secrets,
test_type,
major_boot_version,
minor_boot_version,
ClusterDomain::Default,
&ClusterDomain::Default,
Option::from(vpc_network_mode),
None,
)
@@ -55,13 +54,9 @@ fn create_and_destroy_eks_cluster(
#[named]
#[test]
fn create_and_destroy_eks_cluster_without_nat_gw_in_eu_west_3() {
let secrets = FuncTestsSecrets::new();
let region = secrets.AWS_DEFAULT_REGION.clone().expect("AWS region was not found");
let aws_region = AwsRegion::from_str(region.as_str()).expect("Wasn't able to convert the desired region");
let region = "eu-west-3".to_string();
create_and_destroy_eks_cluster(
region,
AwsRegion::get_zones(&aws_region),
secrets,
ClusterTestType::Classic,
AWS_KUBERNETES_MAJOR_VERSION,
AWS_KUBERNETES_MINOR_VERSION,
@@ -74,13 +69,9 @@ fn create_and_destroy_eks_cluster_without_nat_gw_in_eu_west_3() {
#[named]
#[test]
fn create_and_destroy_eks_cluster_with_nat_gw_in_eu_west_3() {
let secrets = FuncTestsSecrets::new();
let region = secrets.AWS_DEFAULT_REGION.clone().expect("AWS region was not found");
let aws_region = AwsRegion::from_str(&region).expect("Wasn't able to convert the desired region");
let region = "eu-west-3".to_string();
create_and_destroy_eks_cluster(
region,
AwsRegion::get_zones(&aws_region),
secrets,
ClusterTestType::Classic,
AWS_KUBERNETES_MAJOR_VERSION,
AWS_KUBERNETES_MINOR_VERSION,
@@ -93,13 +84,9 @@ fn create_and_destroy_eks_cluster_with_nat_gw_in_eu_west_3() {
#[named]
#[test]
fn create_and_destroy_eks_cluster_in_us_east_2() {
let secrets = FuncTestsSecrets::new();
let region = "us-east-2".to_string();
let aws_region = AwsRegion::from_str(&region).expect("Wasn't able to convert the desired region");
create_and_destroy_eks_cluster(
region,
AwsRegion::get_zones(&aws_region),
secrets,
ClusterTestType::Classic,
AWS_KUBERNETES_MAJOR_VERSION,
AWS_KUBERNETES_MINOR_VERSION,
@@ -133,14 +120,9 @@ fn create_pause_and_destroy_eks_cluster_in_us_east_2() {
#[test]
#[ignore]
fn create_upgrade_and_destroy_eks_cluster_in_eu_west_3() {
let secrets = FuncTestsSecrets::new();
let region = secrets.AWS_DEFAULT_REGION.clone().expect("AWS region was not found");
let aws_region = AwsRegion::from_str(&region).expect("Wasn't able to convert the desired region");
let region = "eu-west-3".to_string();
create_and_destroy_eks_cluster(
region,
AwsRegion::get_zones(&aws_region),
secrets,
ClusterTestType::WithUpgrade,
AWS_KUBERNETES_MAJOR_VERSION,
AWS_KUBERNETES_MINOR_VERSION,

3
tests/aws/aws_whole_enchilada.rs
View File

@@ -43,11 +43,10 @@ fn create_upgrade_and_destroy_eks_cluster_with_env_in_eu_west_3() {
logger(),
&region,
Some(aws_zones),
secrets.clone(),
ClusterTestType::Classic,
AWS_KUBERNETES_MAJOR_VERSION,
AWS_KUBERNETES_MINOR_VERSION,
ClusterDomain::Custom(cluster_domain),
&ClusterDomain::Custom(cluster_domain),
Some(WithNatGateways),
Some(&env_action),
)

59
tests/digitalocean/do_databases.rs
View File

@@ -13,8 +13,9 @@ use test_utilities::utilities::{
use qovery_engine::models::DatabaseMode::{CONTAINER, MANAGED};
use test_utilities::common::{database_test_environment, test_db, working_minimal_environment, Infrastructure};
use test_utilities::digitalocean::{
clean_environments, DO_MANAGED_DATABASE_DISK_TYPE, DO_MANAGED_DATABASE_INSTANCE_TYPE,
DO_SELF_HOSTED_DATABASE_DISK_TYPE, DO_SELF_HOSTED_DATABASE_INSTANCE_TYPE, DO_TEST_REGION,
clean_environments, do_default_engine_config, DO_KUBERNETES_VERSION, DO_MANAGED_DATABASE_DISK_TYPE,
DO_MANAGED_DATABASE_INSTANCE_TYPE, DO_SELF_HOSTED_DATABASE_DISK_TYPE, DO_SELF_HOSTED_DATABASE_INSTANCE_TYPE,
DO_TEST_REGION,
};
/**
@@ -47,7 +48,9 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = do_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environment_3_apps_3_routers_3_databases(
&context,
secrets
@@ -65,10 +68,16 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_delete.delete_environment(Kind::Do, &context_for_deletion, &env_action_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Do,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
// delete images created during test from registries
@@ -103,7 +112,9 @@ fn deploy_an_environment_with_db_and_pause_it() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = do_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environnement_2_app_2_routers_1_psql(
&context,
secrets
@@ -121,10 +132,11 @@ fn deploy_an_environment_with_db_and_pause_it() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action.clone(), logger.clone());
let ret =
environment.deploy_environment(Kind::Do, &context, &env_action.clone(), logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment.pause_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.pause_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// Check that we have actually 0 pods running for this db
@@ -139,7 +151,13 @@ fn deploy_an_environment_with_db_and_pause_it() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), true);
let ret = environment_delete.delete_environment(Kind::Do, &context_for_deletion, &env_action_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Do,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
// delete images created during test from registries
@@ -175,7 +193,9 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = do_default_engine_config(&context_for_deletion, logger.clone());
let test_domain = secrets
.DEFAULT_TEST_DOMAIN
.as_ref()
@@ -202,7 +222,7 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_deletion = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
// TODO: should be uncommented as soon as cert-manager is fixed
@@ -212,8 +232,13 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
assert_eq!(con, true);
}*/
let ret =
environment_delete.delete_environment(Kind::Do, &context_for_deletion, &env_action_for_deletion, logger);
let ret = environment_delete.delete_environment(
Kind::Do,
&context_for_deletion,
&env_action_for_deletion,
logger,
&engine_config_for_deletion,
);
assert!(matches!(ret, TransactionResult::Ok));
// delete images created during test from registries
@@ -254,8 +279,11 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_redeploy = context.clone_not_same_execution_id();
let engine_config_for_redeploy = do_default_engine_config(&context_for_redeploy, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -341,7 +369,7 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = environment_to_redeploy.deploy_environment(
@@ -349,6 +377,7 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
&context_for_redeploy,
&env_action_redeploy,
logger.clone(),
&engine_config_for_redeploy,
);
assert!(matches!(ret, TransactionResult::Ok));
@@ -365,7 +394,13 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
(false, _) => assert!(false),
}
let ret = environment_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_delete, logger);
let ret = environment_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(
ret,
TransactionResult::Ok | TransactionResult::UnrecoverableError(_, _)

177
tests/digitalocean/do_environment.rs
View File

@@ -14,7 +14,7 @@ use qovery_engine::transaction::TransactionResult;
use std::collections::BTreeMap;
use std::time::SystemTime;
use test_utilities::common::Infrastructure;
use test_utilities::digitalocean::container_registry_digital_ocean;
use test_utilities::digitalocean::{container_registry_digital_ocean, do_default_engine_config, DO_KUBERNETES_VERSION};
use test_utilities::utilities::{build_platform_local_docker, context};
use tracing::{span, warn, Level};
@@ -44,7 +44,9 @@ fn digitalocean_doks_deploy_a_working_environment_with_no_router() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -62,11 +64,16 @@ fn digitalocean_doks_deploy_a_working_environment_with_no_router() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret =
environment_for_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_for_delete, logger);
let ret = environment_for_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -98,6 +105,7 @@ fn test_build_cache() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger());
let environment = test_utilities::common::working_minimal_environment(
&context,
@@ -189,7 +197,9 @@ fn digitalocean_doks_deploy_a_not_working_environment_with_no_router() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::non_working_environment(
&context,
@@ -206,11 +216,16 @@ fn digitalocean_doks_deploy_a_not_working_environment_with_no_router() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::UnrecoverableError(_, _)));
let ret =
environment_for_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_for_delete, logger);
let ret = environment_for_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::UnrecoverableError(_, _)));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -244,7 +259,9 @@ fn digitalocean_doks_deploy_a_working_environment_and_pause() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -257,7 +274,7 @@ fn digitalocean_doks_deploy_a_working_environment_and_pause() {
let env_action = EnvironmentAction::Environment(environment.clone());
let selector = format!("appId={}", environment.applications[0].id);
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let ret = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(ret, TransactionResult::Ok));
let ret = get_pods(
@@ -270,7 +287,13 @@ fn digitalocean_doks_deploy_a_working_environment_and_pause() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), false);
let ret = environment.pause_environment(Kind::Do, &context_for_delete, &env_action, logger.clone());
let ret = environment.pause_environment(
Kind::Do,
&context_for_delete,
&env_action,
logger.clone(),
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
// Check that we have actually 0 pods running for this app
@@ -286,7 +309,14 @@ fn digitalocean_doks_deploy_a_working_environment_and_pause() {
// Check we can resume the env
let ctx_resume = context.clone_not_same_execution_id();
let ret = environment.deploy_environment(Kind::Do, &ctx_resume, &env_action, logger.clone());
let engine_config_resume = do_default_engine_config(&ctx_resume, logger.clone());
let ret = environment.deploy_environment(
Kind::Do,
&ctx_resume,
&env_action,
logger.clone(),
&engine_config_resume,
);
assert!(matches!(ret, TransactionResult::Ok));
let ret = get_pods(
@@ -300,7 +330,13 @@ fn digitalocean_doks_deploy_a_working_environment_and_pause() {
assert_eq!(ret.unwrap().items.is_empty(), false);
// Cleanup
let ret = environment.delete_environment(Kind::Do, &context_for_delete, &env_action, logger);
let ret = environment.delete_environment(
Kind::Do,
&context_for_delete,
&env_action,
logger,
&engine_config_for_delete,
);
assert!(matches!(ret, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -334,7 +370,9 @@ fn digitalocean_doks_build_with_buildpacks_and_deploy_a_working_environment() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -369,11 +407,16 @@ fn digitalocean_doks_build_with_buildpacks_and_deploy_a_working_environment() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_for_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -407,7 +450,9 @@ fn digitalocean_doks_deploy_a_working_environment_with_domain() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -423,11 +468,16 @@ fn digitalocean_doks_deploy_a_working_environment_with_domain() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_for_delete, logger);
let result = environment_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -461,8 +511,9 @@ fn digitalocean_doks_deploy_a_working_environment_with_storage() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = do_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -495,7 +546,7 @@ fn digitalocean_doks_deploy_a_working_environment_with_storage() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Do, environment.clone(), secrets.clone()) {
@@ -506,7 +557,13 @@ fn digitalocean_doks_deploy_a_working_environment_with_storage() {
Err(_) => assert!(false),
};
let result = environment_delete.delete_environment(Kind::Do, &context_for_deletion, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Do,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -540,8 +597,11 @@ fn digitalocean_doks_redeploy_same_app() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_bis = context.clone_not_same_execution_id();
let engine_config_bis = do_default_engine_config(&context_bis, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = do_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -579,7 +639,7 @@ fn digitalocean_doks_redeploy_same_app() {
let env_action_redeploy = EnvironmentAction::Environment(environment_redeploy.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Do, environment.clone(), secrets.clone()) {
@@ -599,8 +659,13 @@ fn digitalocean_doks_redeploy_same_app() {
secrets.clone(),
);
let result =
environment_redeploy.deploy_environment(Kind::Do, &context_bis, &env_action_redeploy, logger.clone());
let result = environment_redeploy.deploy_environment(
Kind::Do,
&context_bis,
&env_action_redeploy,
logger.clone(),
&engine_config_bis,
);
assert!(matches!(result, TransactionResult::Ok));
let (_, number2) = is_pod_restarted_env(
@@ -614,7 +679,13 @@ fn digitalocean_doks_redeploy_same_app() {
// nothing changed in the app, so, it shouldn't be restarted
assert!(number.eq(&number2));
let result = environment_delete.delete_environment(Kind::Do, &context_for_deletion, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Do,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -648,8 +719,11 @@ fn digitalocean_doks_deploy_a_not_working_environment_and_then_working_environme
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_not_working = context.clone_not_same_execution_id();
let engine_config_for_not_working = do_default_engine_config(&context_for_not_working, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
// env part generation
let environment = test_utilities::common::working_minimal_environment(
@@ -687,12 +761,18 @@ fn digitalocean_doks_deploy_a_not_working_environment_and_then_working_environme
&context_for_not_working,
&env_action_not_working,
logger.clone(),
&engine_config_for_not_working,
);
assert!(matches!(result, TransactionResult::UnrecoverableError(_, _)));
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_for_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -729,6 +809,7 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -740,6 +821,7 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
// not working 1
let context_for_not_working_1 = context.clone_not_same_execution_id();
let engine_config_for_not_working_1 = do_default_engine_config(&context_for_not_working_1, logger.clone());
let mut not_working_env_1 = environment.clone();
not_working_env_1.applications = not_working_env_1
.applications
@@ -755,10 +837,12 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
// not working 2
let context_for_not_working_2 = context.clone_not_same_execution_id();
let engine_config_for_not_working_2 = do_default_engine_config(&context_for_not_working_2, logger.clone());
let not_working_env_2 = not_working_env_1.clone();
// work for delete
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
@@ -768,7 +852,7 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
let env_action_delete = EnvironmentAction::Environment(delete_env.clone());
// OK
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
// FAIL and rollback
@@ -777,6 +861,7 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_1,
&env_action_not_working_1,
logger.clone(),
&engine_config_for_not_working_1,
);
assert!(matches!(
result,
@@ -789,6 +874,7 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_2,
&env_action_not_working_2,
logger.clone(),
&engine_config_for_not_working_2,
);
assert!(matches!(
result,
@@ -796,10 +882,16 @@ fn digitalocean_doks_deploy_ok_fail_fail_ok_environment() {
));
// Should be working
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result = delete_env.delete_environment(Kind::Do, &context_for_delete, &env_action_delete, logger);
let result = delete_env.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -833,6 +925,7 @@ fn digitalocean_doks_deploy_a_non_working_environment_with_no_failover() {
.as_ref()
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set"),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::non_working_environment(
&context,
secrets
@@ -843,16 +936,23 @@ fn digitalocean_doks_deploy_a_non_working_environment_with_no_failover() {
);
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(delete_env.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::UnrecoverableError(_, _)));
let result = delete_env.delete_environment(Kind::Do, &context_for_delete, &env_action_delete, logger);
let result = delete_env.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {
@@ -888,7 +988,9 @@ fn digitalocean_doks_deploy_a_working_environment_with_sticky_session() {
.expect("DIGITAL_OCEAN_TEST_CLUSTER_ID is not set in secrets")
.as_str(),
);
let engine_config = do_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = do_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::environment_only_http_server_router_with_sticky_session(
&context,
secrets
@@ -904,14 +1006,19 @@ fn digitalocean_doks_deploy_a_working_environment_with_sticky_session() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Do, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
// checking cookie is properly set on the app
assert!(routers_sessions_are_sticky(environment.routers.clone()));
let result =
environment_for_delete.delete_environment(Kind::Do, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Do,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), DO_TEST_REGION) {

8
tests/digitalocean/do_kubernetes.rs
View File

@@ -13,7 +13,6 @@ use test_utilities::common::{cluster_test, ClusterTestType};
#[cfg(feature = "test-do-infra")]
fn create_and_destroy_doks_cluster(
region: DoRegion,
secrets: FuncTestsSecrets,
test_type: ClusterTestType,
major_boot_version: u8,
minor_boot_version: u8,
@@ -27,11 +26,10 @@ fn create_and_destroy_doks_cluster(
logger(),
region.as_str(),
None,
secrets,
test_type,
major_boot_version,
minor_boot_version,
ClusterDomain::Default,
&ClusterDomain::Default,
None,
None,
)
@@ -43,10 +41,8 @@ fn create_and_destroy_doks_cluster(
#[test]
fn create_and_destroy_doks_cluster_ams_3() {
let region = DoRegion::Amsterdam3;
let secrets = FuncTestsSecrets::new();
create_and_destroy_doks_cluster(
region,
secrets,
ClusterTestType::Classic,
DO_KUBERNETES_MAJOR_VERSION,
DO_KUBERNETES_MINOR_VERSION,
@@ -60,10 +56,8 @@ fn create_and_destroy_doks_cluster_ams_3() {
#[ignore]
fn create_upgrade_and_destroy_doks_cluster_in_nyc_3() {
let region = DoRegion::NewYorkCity3;
let secrets = FuncTestsSecrets::new();
create_and_destroy_doks_cluster(
region,
secrets,
ClusterTestType::WithUpgrade,
DO_KUBERNETES_MAJOR_VERSION,
DO_KUBERNETES_MINOR_VERSION,

5
tests/digitalocean/do_utility_kubernetes_doks_test_cluster.rs
View File

@@ -3,6 +3,7 @@ extern crate test_utilities;
use self::test_utilities::utilities::{context, engine_run_test, init, logger, FuncTestsSecrets};
use ::function_name::named;
use qovery_engine::cloud_provider::digitalocean::DO;
use test_utilities::digitalocean::{do_default_engine_config, DO_KUBERNETES_VERSION, DO_TEST_REGION};
use tracing::{span, Level};
use self::test_utilities::common::Cluster;
@@ -36,7 +37,7 @@ fn create_digitalocean_kubernetes_doks_test_cluster() {
let logger = logger();
let context = context(organization_id.as_str(), cluster_id.as_str());
let engine = DO::docker_cr_engine(&context, logger.clone());
let engine = do_default_engine_config(&context, logger.clone());
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
// Deploy
@@ -78,7 +79,7 @@ fn destroy_digitalocean_kubernetes_doks_test_cluster() {
let logger = logger();
let context = context(organization_id.as_str(), cluster_id.as_str());
let engine = DO::docker_cr_engine(&context, logger.clone());
let engine = do_default_engine_config(&context, logger.clone());
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
// Destroy

3
tests/digitalocean/do_whole_enchilada.rs
View File

@@ -39,11 +39,10 @@ fn create_upgrade_and_destroy_doks_cluster_with_env_in_ams_3() {
logger,
region.as_str(),
None,
secrets.clone(),
ClusterTestType::Classic,
DO_KUBERNETES_MAJOR_VERSION,
DO_KUBERNETES_MINOR_VERSION,
ClusterDomain::Custom(cluster_domain),
&ClusterDomain::Custom(cluster_domain),
None,
Some(&env_action),
)

60
tests/scaleway/scw_databases.rs
View File

@@ -15,8 +15,9 @@ use qovery_engine::models::DatabaseMode::{CONTAINER, MANAGED};
use test_utilities::common::{database_test_environment, Infrastructure};
use test_utilities::common::{test_db, working_minimal_environment};
use test_utilities::scaleway::{
clean_environments, SCW_MANAGED_DATABASE_DISK_TYPE, SCW_MANAGED_DATABASE_INSTANCE_TYPE,
SCW_SELF_HOSTED_DATABASE_DISK_TYPE, SCW_SELF_HOSTED_DATABASE_INSTANCE_TYPE, SCW_TEST_ZONE,
clean_environments, scw_default_engine_config, SCW_KUBERNETES_VERSION, SCW_MANAGED_DATABASE_DISK_TYPE,
SCW_MANAGED_DATABASE_INSTANCE_TYPE, SCW_SELF_HOSTED_DATABASE_DISK_TYPE, SCW_SELF_HOSTED_DATABASE_INSTANCE_TYPE,
SCW_TEST_ZONE,
};
/**
@@ -51,7 +52,9 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = scw_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environment_3_apps_3_routers_3_databases(
&context,
secrets
@@ -69,11 +72,16 @@ fn deploy_an_environment_with_3_databases_and_3_apps() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_deletion, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
// delete images created during test from registries
@@ -110,7 +118,9 @@ fn deploy_an_environment_with_db_and_pause_it() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = scw_default_engine_config(&context_for_deletion, logger.clone());
let environment = test_utilities::common::environnement_2_app_2_routers_1_psql(
&context,
secrets
@@ -128,10 +138,10 @@ fn deploy_an_environment_with_db_and_pause_it() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result = environment.pause_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.pause_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
// Check that we have actually 0 pods running for this db
@@ -146,8 +156,13 @@ fn deploy_an_environment_with_db_and_pause_it() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), true);
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_deletion, &env_action_delete, logger.clone());
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_deletion,
&env_action_delete,
logger.clone(),
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
// delete images created during test from registries
@@ -185,7 +200,9 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = scw_default_engine_config(&context_for_deletion, logger.clone());
let test_domain = secrets
.DEFAULT_TEST_DOMAIN
.as_ref()
@@ -211,11 +228,16 @@ fn postgresql_deploy_a_working_development_environment_with_all_options() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_deletion = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_deletion, &env_action_for_deletion, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_deletion,
&env_action_for_deletion,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
// delete images created during test from registries
@@ -258,8 +280,11 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_redeploy = context.clone_not_same_execution_id();
let engine_config_for_redeploy = scw_default_engine_config(&context_for_redeploy, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -346,7 +371,7 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result = environment_to_redeploy.deploy_environment(
@@ -354,6 +379,7 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
&context_for_redeploy,
&env_action_redeploy,
logger.clone(),
&engine_config_for_redeploy,
);
assert!(matches!(result, TransactionResult::Ok));
@@ -370,7 +396,13 @@ fn postgresql_deploy_a_working_environment_and_redeploy() {
(false, _) => assert!(false),
}
let result = environment_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(
result,
TransactionResult::Ok | TransactionResult::UnrecoverableError(_, _)

195
tests/scaleway/scw_environment.rs
View File

@@ -14,7 +14,7 @@ use qovery_engine::transaction::TransactionResult;
use std::collections::BTreeMap;
use std::time::SystemTime;
use test_utilities::common::Infrastructure;
use test_utilities::scaleway::container_registry_scw;
use test_utilities::scaleway::{container_registry_scw, scw_default_engine_config, SCW_KUBERNETES_VERSION};
use test_utilities::utilities::build_platform_local_docker;
use tracing::{span, warn, Level};
@@ -46,7 +46,9 @@ fn scaleway_kapsule_deploy_a_working_environment_with_no_router() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -64,11 +66,16 @@ fn scaleway_kapsule_deploy_a_working_environment_with_no_router() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_for_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -195,7 +202,9 @@ fn scaleway_kapsule_deploy_a_not_working_environment_with_no_router() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::non_working_environment(
&context,
@@ -213,11 +222,16 @@ fn scaleway_kapsule_deploy_a_not_working_environment_with_no_router() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::UnrecoverableError(_, _)));
let result =
environment_for_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(
result,
TransactionResult::Ok | TransactionResult::UnrecoverableError(_, _)
@@ -256,7 +270,9 @@ fn scaleway_kapsule_deploy_a_working_environment_and_pause() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -269,7 +285,7 @@ fn scaleway_kapsule_deploy_a_working_environment_and_pause() {
let env_action = EnvironmentAction::Environment(environment.clone());
let selector = format!("appId={}", environment.applications[0].id);
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let ret = get_pods(
@@ -282,7 +298,13 @@ fn scaleway_kapsule_deploy_a_working_environment_and_pause() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), false);
let result = environment.pause_environment(Kind::Scw, &context_for_delete, &env_action, logger.clone());
let result = environment.pause_environment(
Kind::Scw,
&context_for_delete,
&env_action,
logger.clone(),
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
// Check that we have actually 0 pods running for this app
@@ -298,7 +320,14 @@ fn scaleway_kapsule_deploy_a_working_environment_and_pause() {
// Check we can resume the env
let ctx_resume = context.clone_not_same_execution_id();
let result = environment.deploy_environment(Kind::Scw, &ctx_resume, &env_action, logger.clone());
let engine_config_resume = scw_default_engine_config(&ctx_resume, logger.clone());
let result = environment.deploy_environment(
Kind::Scw,
&ctx_resume,
&env_action,
logger.clone(),
&engine_config_resume,
);
assert!(matches!(result, TransactionResult::Ok));
let ret = get_pods(
@@ -312,7 +341,13 @@ fn scaleway_kapsule_deploy_a_working_environment_and_pause() {
assert_eq!(ret.unwrap().items.is_empty(), false);
// Cleanup
let result = environment.delete_environment(Kind::Scw, &context_for_delete, &env_action, logger);
let result = environment.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -348,7 +383,9 @@ fn scaleway_kapsule_build_with_buildpacks_and_deploy_a_working_environment() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -383,11 +420,16 @@ fn scaleway_kapsule_build_with_buildpacks_and_deploy_a_working_environment() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_for_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -423,7 +465,9 @@ fn scaleway_kapsule_deploy_a_working_environment_with_domain() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -439,11 +483,16 @@ fn scaleway_kapsule_deploy_a_working_environment_with_domain() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_for_delete, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -479,7 +528,9 @@ fn scaleway_kapsule_deploy_a_working_environment_with_storage() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = scw_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -513,7 +564,7 @@ fn scaleway_kapsule_deploy_a_working_environment_with_storage() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Scw, environment.clone(), secrets.clone()) {
@@ -524,8 +575,13 @@ fn scaleway_kapsule_deploy_a_working_environment_with_storage() {
Err(_) => assert!(false),
};
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_deletion, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -560,7 +616,9 @@ fn deploy_a_working_environment_and_pause_it() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -573,7 +631,7 @@ fn deploy_a_working_environment_and_pause_it() {
let ea = EnvironmentAction::Environment(environment.clone());
let selector = format!("appId={}", environment.applications[0].id);
let result = environment.deploy_environment(Kind::Scw, &context, &ea, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &ea, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let ret = get_pods(
@@ -586,7 +644,13 @@ fn deploy_a_working_environment_and_pause_it() {
assert_eq!(ret.is_ok(), true);
assert_eq!(ret.unwrap().items.is_empty(), false);
let result = environment.pause_environment(Kind::Scw, &context_for_delete, &ea, logger.clone());
let result = environment.pause_environment(
Kind::Scw,
&context_for_delete,
&ea,
logger.clone(),
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
// Check that we have actually 0 pods running for this app
@@ -602,7 +666,8 @@ fn deploy_a_working_environment_and_pause_it() {
// Check we can resume the env
let ctx_resume = context.clone_not_same_execution_id();
let result = environment.deploy_environment(Kind::Scw, &ctx_resume, &ea, logger.clone());
let engine_config_resume = scw_default_engine_config(&ctx_resume, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &ctx_resume, &ea, logger.clone(), &engine_config_resume);
assert!(matches!(result, TransactionResult::Ok));
let ret = get_pods(
@@ -616,7 +681,8 @@ fn deploy_a_working_environment_and_pause_it() {
assert_eq!(ret.unwrap().items.is_empty(), false);
// Cleanup
let result = environment.delete_environment(Kind::Scw, &context_for_delete, &ea, logger);
let result =
environment.delete_environment(Kind::Scw, &context_for_delete, &ea, logger, &engine_config_for_delete);
assert!(matches!(result, TransactionResult::Ok));
return test_name.to_string();
})
@@ -647,8 +713,11 @@ fn scaleway_kapsule_redeploy_same_app() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_bis = context.clone_not_same_execution_id();
let engine_config_bis = scw_default_engine_config(&context_bis, logger.clone());
let context_for_deletion = context.clone_not_same_execution_id();
let engine_config_for_deletion = scw_default_engine_config(&context_for_deletion, logger.clone());
let mut environment = test_utilities::common::working_minimal_environment(
&context,
@@ -687,7 +756,7 @@ fn scaleway_kapsule_redeploy_same_app() {
let env_action_redeploy = EnvironmentAction::Environment(environment_redeploy.clone());
let env_action_delete = EnvironmentAction::Environment(environment_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
match get_pvc(context.clone(), Kind::Scw, environment.clone(), secrets.clone()) {
@@ -707,8 +776,13 @@ fn scaleway_kapsule_redeploy_same_app() {
secrets.clone(),
);
let result =
environment_redeploy.deploy_environment(Kind::Scw, &context_bis, &env_action_redeploy, logger.clone());
let result = environment_redeploy.deploy_environment(
Kind::Scw,
&context_bis,
&env_action_redeploy,
logger.clone(),
&engine_config_bis,
);
assert!(matches!(result, TransactionResult::Ok));
let (_, number2) = is_pod_restarted_env(
@@ -722,8 +796,13 @@ fn scaleway_kapsule_redeploy_same_app() {
// nothing changed in the app, so, it shouldn't be restarted
assert!(number.eq(&number2));
let result =
environment_delete.delete_environment(Kind::Scw, &context_for_deletion, &env_action_delete, logger);
let result = environment_delete.delete_environment(
Kind::Scw,
&context_for_deletion,
&env_action_delete,
logger,
&engine_config_for_deletion,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -759,8 +838,11 @@ fn scaleway_kapsule_deploy_a_not_working_environment_and_then_working_environmen
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_not_working = context.clone_not_same_execution_id();
let engine_config_for_not_working = scw_default_engine_config(&context_for_not_working, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
// env part generation
let environment = test_utilities::common::working_minimal_environment(
@@ -798,14 +880,20 @@ fn scaleway_kapsule_deploy_a_not_working_environment_and_then_working_environmen
&context_for_not_working,
&env_action_not_working,
logger.clone(),
&engine_config_for_not_working,
);
assert!(matches!(result, TransactionResult::UnrecoverableError(_, _)));
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result =
environment_for_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -845,6 +933,7 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::working_minimal_environment(
&context,
secrets
@@ -856,6 +945,7 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
// not working 1
let context_for_not_working_1 = context.clone_not_same_execution_id();
let engine_config_for_not_working_1 = scw_default_engine_config(&context_for_not_working_1, logger.clone());
let mut not_working_env_1 = environment.clone();
not_working_env_1.applications = not_working_env_1
.applications
@@ -871,10 +961,12 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
// not working 2
let context_for_not_working_2 = context.clone_not_same_execution_id();
let engine_config_for_not_working_2 = scw_default_engine_config(&context_for_not_working_2, logger.clone());
let not_working_env_2 = not_working_env_1.clone();
// work for delete
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
@@ -884,7 +976,7 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
let env_action_delete = EnvironmentAction::Environment(delete_env.clone());
// OK
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
// FAIL and rollback
@@ -893,6 +985,7 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_1,
&env_action_not_working_1,
logger.clone(),
&engine_config_for_not_working_1,
);
assert!(matches!(
result,
@@ -905,6 +998,7 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
&context_for_not_working_2,
&env_action_not_working_2,
logger.clone(),
&engine_config_for_not_working_2,
);
assert!(matches!(
result,
@@ -912,10 +1006,16 @@ fn scaleway_kapsule_deploy_ok_fail_fail_ok_environment() {
));
// Should be working
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
let result = delete_env.delete_environment(Kind::Scw, &context_for_delete, &env_action_delete, logger);
let result = delete_env.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -952,6 +1052,7 @@ fn scaleway_kapsule_deploy_a_non_working_environment_with_no_failover() {
.expect("SCALEWAY_TEST_CLUSTER_ID")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let environment = test_utilities::common::non_working_environment(
&context,
secrets
@@ -962,16 +1063,23 @@ fn scaleway_kapsule_deploy_a_non_working_environment_with_no_failover() {
);
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let mut delete_env = environment.clone();
delete_env.action = Action::Delete;
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_delete = EnvironmentAction::Environment(delete_env.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::UnrecoverableError(_, _)));
let result = delete_env.delete_environment(Kind::Scw, &context_for_delete, &env_action_delete, logger);
let result = delete_env.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {
@@ -1007,7 +1115,9 @@ fn scaleway_kapsule_deploy_a_working_environment_with_sticky_session() {
.expect("SCALEWAY_TEST_CLUSTER_ID is not set in secrets")
.as_str(),
);
let engine_config = scw_default_engine_config(&context, logger.clone());
let context_for_delete = context.clone_not_same_execution_id();
let engine_config_for_delete = scw_default_engine_config(&context_for_delete, logger.clone());
let environment = test_utilities::common::environment_only_http_server_router_with_sticky_session(
&context,
secrets
@@ -1023,14 +1133,19 @@ fn scaleway_kapsule_deploy_a_working_environment_with_sticky_session() {
let env_action = EnvironmentAction::Environment(environment.clone());
let env_action_for_delete = EnvironmentAction::Environment(environment_for_delete.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone());
let result = environment.deploy_environment(Kind::Scw, &context, &env_action, logger.clone(), &engine_config);
assert!(matches!(result, TransactionResult::Ok));
// checking cookie is properly set on the app
assert!(routers_sessions_are_sticky(environment.routers.clone()));
let result =
environment_for_delete.delete_environment(Kind::Scw, &context_for_delete, &env_action_for_delete, logger);
let result = environment_for_delete.delete_environment(
Kind::Scw,
&context_for_delete,
&env_action_for_delete,
logger,
&engine_config_for_delete,
);
assert!(matches!(result, TransactionResult::Ok));
if let Err(e) = clean_environments(&context, vec![environment.clone()], secrets.clone(), SCW_TEST_ZONE) {

20
tests/scaleway/scw_kubernetes.rs
View File

@@ -13,7 +13,6 @@ use test_utilities::common::{cluster_test, ClusterDomain, ClusterTestType};
#[cfg(feature = "test-scw-infra")]
fn create_and_destroy_kapsule_cluster(
zone: ScwZone,
secrets: FuncTestsSecrets,
test_type: ClusterTestType,
major_boot_version: u8,
minor_boot_version: u8,
@@ -28,11 +27,10 @@ fn create_and_destroy_kapsule_cluster(
logger(),
zone.as_str(),
None,
secrets,
test_type,
major_boot_version,
minor_boot_version,
ClusterDomain::Default,
&ClusterDomain::Default,
vpc_network_mode,
None,
)
@@ -45,10 +43,8 @@ fn create_and_destroy_kapsule_cluster(
#[test]
fn create_and_destroy_kapsule_cluster_par_1() {
let zone = ScwZone::Paris1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::Classic,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -62,10 +58,8 @@ fn create_and_destroy_kapsule_cluster_par_1() {
#[test]
fn create_and_destroy_kapsule_cluster_par_2() {
let zone = ScwZone::Paris2;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::Classic,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -79,10 +73,8 @@ fn create_and_destroy_kapsule_cluster_par_2() {
#[test]
fn create_pause_and_destroy_kapsule_cluster_ams_1() {
let zone = ScwZone::Amsterdam1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::WithPause,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -96,10 +88,8 @@ fn create_pause_and_destroy_kapsule_cluster_ams_1() {
#[test]
fn create_and_destroy_kapsule_cluster_war_1() {
let zone = ScwZone::Warsaw1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::Classic,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -115,10 +105,8 @@ fn create_and_destroy_kapsule_cluster_war_1() {
#[ignore]
fn create_upgrade_and_destroy_kapsule_cluster_in_par_1() {
let zone = ScwZone::Paris1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::WithUpgrade,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -134,10 +122,8 @@ fn create_upgrade_and_destroy_kapsule_cluster_in_par_1() {
#[ignore]
fn create_upgrade_and_destroy_kapsule_cluster_in_par_2() {
let zone = ScwZone::Paris2;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::WithUpgrade,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -153,10 +139,8 @@ fn create_upgrade_and_destroy_kapsule_cluster_in_par_2() {
#[ignore]
fn create_upgrade_and_destroy_kapsule_cluster_in_ams_1() {
let zone = ScwZone::Amsterdam1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::WithUpgrade,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
@@ -172,10 +156,8 @@ fn create_upgrade_and_destroy_kapsule_cluster_in_ams_1() {
#[ignore]
fn create_upgrade_and_destroy_kapsule_cluster_in_war_1() {
let zone = ScwZone::Warsaw1;
let secrets = FuncTestsSecrets::new();
create_and_destroy_kapsule_cluster(
zone,
secrets,
ClusterTestType::WithUpgrade,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,

5
tests/scaleway/scw_utility_kubernetes_kapsule_test_cluster.rs
View File

@@ -2,6 +2,7 @@ extern crate test_utilities;
use self::test_utilities::utilities::{context, engine_run_test, init, logger, FuncTestsSecrets};
use ::function_name::named;
use test_utilities::scaleway::{scw_default_engine_config, SCW_KUBERNETES_VERSION, SCW_TEST_ZONE};
use tracing::{span, Level};
use self::test_utilities::common::Cluster;
@@ -36,7 +37,7 @@ fn create_scaleway_kubernetes_kapsule_test_cluster() {
let logger = logger();
let context = context(organization_id.as_str(), cluster_id.as_str());
let engine = Scaleway::docker_cr_engine(&context, logger.clone());
let engine = scw_default_engine_config(&context, logger.clone());
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
// Deploy
@@ -78,7 +79,7 @@ fn destroy_scaleway_kubernetes_kapsule_test_cluster() {
let logger = logger();
let context = context(organization_id.as_str(), cluster_id.as_str());
let engine = Scaleway::docker_cr_engine(&context, logger.clone());
let engine = scw_default_engine_config(&context, logger.clone());
let mut tx = Transaction::new(&engine, logger.clone(), Box::new(|| false), Box::new(|_| {})).unwrap();
// Destroy

3
tests/scaleway/scw_whole_enchilada.rs
View File

@@ -37,11 +37,10 @@ fn create_and_destroy_kapsule_cluster_with_env_in_par_2() {
logger,
zone.as_str(),
None,
secrets.clone(),
ClusterTestType::Classic,
SCW_KUBERNETES_MAJOR_VERSION,
SCW_KUBERNETES_MINOR_VERSION,
ClusterDomain::Custom(cluster_domain),
&ClusterDomain::Custom(cluster_domain),
None,
Some(&env_action),
)