fix(connector): Use ConnectorError::InvalidConnectorConfig for an invalid CoinbaseConnectorMeta

crates/router/src/connector/coinbase/transformers.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 
+use common_utils::pii;
+use error_stack::ResultExt;
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -250,6 +252,14 @@ pub struct CoinbaseConnectorMeta {
     pub pricing_type: String,
 }
 
+impl TryFrom<&Option<pii::SecretSerdeValue>> for CoinbaseConnectorMeta {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
+        utils::to_connector_meta_from_secret(meta_data.clone())
+            .change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })
+    }
+}
+
 fn get_crypto_specific_payment_data(
     item: &types::PaymentsAuthorizeRouterData,
 ) -> Result<CoinbasePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
@@ -260,11 +270,7 @@ fn get_crypto_specific_payment_data(
     let name =
         billing_address.and_then(|add| add.get_first_name().ok().map(|name| name.to_owned()));
     let description = item.get_description().ok();
-    let connector_meta: CoinbaseConnectorMeta =
-        utils::to_connector_meta_from_secret_with_required_field(
-            item.connector_meta_data.clone(),
-            "Pricing Type Not present in connector meta data",
-        )?;
+    let connector_meta = CoinbaseConnectorMeta::try_from(&item.connector_meta_data)?;
     let pricing_type = connector_meta.pricing_type;
     let local_price = get_local_price(item);
     let redirect_url = item.request.get_return_url()?;

crates/router/src/connector/utils.rs

@@ -1198,23 +1198,6 @@ where
     json.parse_value(std::any::type_name::<T>()).switch()
 }
 
-pub fn to_connector_meta_from_secret_with_required_field<T>(
-    connector_meta: Option<Secret<serde_json::Value>>,
-    error_message: &'static str,
-) -> Result<T, Error>
-where
-    T: serde::de::DeserializeOwned,
-{
-    let connector_error = errors::ConnectorError::MissingRequiredField {
-        field_name: error_message,
-    };
-    let parsed_meta = to_connector_meta_from_secret(connector_meta).ok();
-    match parsed_meta {
-        Some(meta) => Ok(meta),
-        _ => Err(connector_error.into()),
-    }
-}
-
 pub fn to_connector_meta_from_secret<T>(
     connector_meta: Option<Secret<serde_json::Value>>,
 ) -> Result<T, Error>

crates/router/src/core/admin.rs

@@ -1685,9 +1685,9 @@ pub(crate) fn validate_auth_and_metadata_type(
             checkout::transformers::CheckoutAuthType::try_from(val)?;
             Ok(())
         }
-
         api_enums::Connector::Coinbase => {
             coinbase::transformers::CoinbaseAuthType::try_from(val)?;
+            let _ = coinbase::transformers::CoinbaseConnectorMeta::try_from(connector_meta_data)?;
             Ok(())
         }
         api_enums::Connector::Cryptopay => {

crates/router/tests/connectors/coinbase.rs

@@ -1,6 +1,13 @@
+use std::marker::PhantomData;
+
 use api_models::payments::CryptoData;
+use common_utils::pii;
 use masking::Secret;
-use router::types::{self, api, storage::enums, PaymentAddress};
+use router::{
+    connector::coinbase::transformers::{CoinbasePaymentsRequest, LocalPrice},
+    core::errors::ConnectorError,
+    types::{self, api, storage::enums, PaymentAddress},
+};
 use serde_json::json;
 
 use crate::{
@@ -64,8 +71,8 @@ fn get_default_payment_info() -> Option<utils::PaymentInfo> {
     })
 }
 
-fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
-    Some(types::PaymentsAuthorizeData {
+fn payment_method_details() -> types::PaymentsAuthorizeData {
+    types::PaymentsAuthorizeData {
         amount: 1,
         currency: enums::Currency::USD,
         payment_method_data: types::api::PaymentMethodData::Crypto(CryptoData {
@@ -96,14 +103,62 @@ fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
         surcharge_details: None,
         request_incremental_authorization: false,
         metadata: None,
-    })
+    }
+}
+
+fn construct_payment_router_data(
+    connector_meta_data: Option<pii::SecretSerdeValue>,
+) -> types::PaymentsAuthorizeRouterData {
+    let connector_auth_type = types::ConnectorAuthType::HeaderKey {
+        api_key: Secret::new("api_key".to_string()),
+    };
+
+    types::RouterData {
+        flow: PhantomData,
+        merchant_id: String::from("Coinbase"),
+        customer_id: Some(String::from("Coinbase")),
+        connector: "Coinbase".to_string(),
+        payment_id: uuid::Uuid::new_v4().to_string(),
+        attempt_id: uuid::Uuid::new_v4().to_string(),
+        status: Default::default(),
+        auth_type: enums::AuthenticationType::NoThreeDs,
+        payment_method: enums::PaymentMethod::Card,
+        connector_auth_type,
+        description: Some("This is a test".to_string()),
+        return_url: None,
+        request: payment_method_details(),
+        response: Err(Default::default()),
+        payment_method_id: None,
+        address: Default::default(),
+        connector_meta_data,
+        amount_captured: None,
+        access_token: None,
+        session_token: None,
+        reference_id: None,
+        payment_method_token: None,
+        connector_customer: None,
+        recurring_mandate_payment_data: None,
+        preprocessing_id: None,
+        connector_request_reference_id: uuid::Uuid::new_v4().to_string(),
+        #[cfg(feature = "payouts")]
+        payout_method_data: None,
+        #[cfg(feature = "payouts")]
+        quote_id: None,
+        test_mode: None,
+        payment_method_balance: None,
+        connector_api_version: None,
+        connector_http_status_code: None,
+        apple_pay_flow: None,
+        external_latency: None,
+        frm_metadata: None,
+    }
 }
 
 // Creates a payment using the manual capture flow
 #[actix_web::test]
 async fn should_only_authorize_payment() {
     let response = CONNECTOR
-        .authorize_payment(payment_method_details(), get_default_payment_info())
+        .authorize_payment(Some(payment_method_details()), get_default_payment_info())
         .await
         .expect("Authorize payment response");
     assert_eq!(response.status, enums::AttemptStatus::AuthenticationPending);
@@ -192,3 +247,53 @@ async fn should_sync_cancelled_payment() {
         .expect("PSync response");
     assert_eq!(response.status, enums::AttemptStatus::Voided);
 }
+
+#[test]
+fn coinbase_payments_request_try_from_works() {
+    // `connector_meta_data` as `None` - should fail
+    assert_eq!(
+        CoinbasePaymentsRequest::try_from(&construct_payment_router_data(None))
+            .unwrap_err()
+            .current_context(),
+        &ConnectorError::InvalidConnectorConfig { config: "metadata" },
+    );
+
+    // `connector_meta_data` as empty json - should fail
+    assert_eq!(
+        CoinbasePaymentsRequest::try_from(&construct_payment_router_data(Some(Secret::new(
+            serde_json::json!({})
+        ))))
+        .unwrap_err()
+        .current_context(),
+        &ConnectorError::InvalidConnectorConfig { config: "metadata" },
+    );
+
+    // `connector_meta_data` as json with missing `pricing_type`  - should fail
+    assert_eq!(
+        CoinbasePaymentsRequest::try_from(&construct_payment_router_data(Some(Secret::new(
+            serde_json::json!({ "wrong_type" : "blah" })
+        ))))
+        .unwrap_err()
+        .current_context(),
+        &ConnectorError::InvalidConnectorConfig { config: "metadata" },
+    );
+
+    // `connector_meta_data` as json with correct `pricing_type`  - ok
+    assert_eq!(
+        CoinbasePaymentsRequest::try_from(&construct_payment_router_data(Some(Secret::new(
+            serde_json::json!({ "pricing_type" : "fixed_price" })
+        ))))
+        .unwrap(),
+        CoinbasePaymentsRequest {
+            name: None,
+            description: Some("This is a test".to_string()),
+            pricing_type: "fixed_price".to_string(),
+            local_price: LocalPrice {
+                amount: "1".to_string(),
+                currency: "USD".to_string()
+            },
+            redirect_url: "https://google.com/".to_string(),
+            cancel_url: "https://google.com/".to_string(),
+        }
+    );
+}