switchgear-service 0.1.13

use crate::common::db::TestPostgresDatabase;
use crate::common::offer;
use switchgear_service::components::offer::db::DbOfferStore;
use switchgear_testing::services::IntegrationTestServices;
use uuid::Uuid;

async fn create_postgres_store() -> Option<(DbOfferStore, TestPostgresDatabase)> {
    let db_name = format!("test_offer_{}", Uuid::new_v4().to_string().replace("-", ""));
    let services = IntegrationTestServices::create().unwrap();

    let postgres = match services.postgres() {
        None => return None,
        Some(v) => v,
    };
    let db = TestPostgresDatabase::new(db_name, postgres);

    let store = DbOfferStore::connect(db.connection_url(), 5).await.unwrap();
    store.migrate_up().await.unwrap();
    Some((store, db))
}

#[tokio::test]
async fn test_postgres_get_nonexistent_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_get_nonexistent_offer(store).await;
}

#[tokio::test]
async fn test_postgres_post_new_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_post_new_offer(store).await;
}

#[tokio::test]
async fn test_postgres_post_existing_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_post_existing_offer(store).await;
}

#[tokio::test]
async fn test_postgres_put_new_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_put_new_offer(store).await;
}

#[tokio::test]
async fn test_postgres_put_existing_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_put_existing_offer(store).await;
}

#[tokio::test]
async fn test_postgres_delete_existing_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_delete_existing_offer(store).await;
}

#[tokio::test]
async fn test_postgres_delete_nonexistent_offer() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_delete_nonexistent_offer(store).await;
}

#[tokio::test]
async fn test_postgres_get_offers() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_get_offers(store).await;
}

#[tokio::test]
async fn test_postgres_get_nonexistent_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_get_nonexistent_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_post_new_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_post_new_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_post_existing_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_post_existing_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_put_new_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_put_new_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_put_existing_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_put_existing_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_delete_existing_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_delete_existing_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_delete_nonexistent_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_delete_nonexistent_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_get_all_offer_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_get_all_offer_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_successful_retrieval() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_successful_retrieval(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_offer_not_found() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_offer_not_found(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_metadata_not_found() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_metadata_not_found_or_foreign_key_constraint(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_hash_consistency() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_hash_consistency(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_different_metadata_different_hashes() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_different_metadata_different_hashes(store).await;
}

#[tokio::test]
async fn test_postgres_offer_provider_valid_current_offer_returns_some() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_offer_provider_valid_current_offer_returns_some(store).await;
}

#[tokio::test]
async fn test_postgres_post_offer_with_missing_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_post_offer_with_missing_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_put_offer_with_missing_metadata() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_put_offer_with_missing_metadata(store).await;
}

#[tokio::test]
async fn test_postgres_delete_metadata_with_referencing_offers() {
    let (store, _guard) = match create_postgres_store().await {
        None => return,
        Some(v) => v,
    };
    offer::test_delete_metadata_with_referencing_offers(store).await;
}