Adds missing fields to subscribers (#780)

* Add an integration test for listing subscribers

* Add missing fields to `wp_com::subscribers::Subscriber`

* Fix parameter names for `ListSubscribersSortField` and add tests

* Use the correct output type for `/sites/<wp_com_site_id>/subscribers/individual`

* Add `SubscriberCountry`

* Use SubscriptionId & UserId for GetSubscriberQuery

* Add retrieve subscriber tests

* Move wp_com test credentials to wp_com_test_credentials.json file

* Ignore subscriber tests

* Update subscriber unit tests for `GetSubscriberQuery` changes

* Remove useless import in subscriber tests

* Add `plans` field to subscribers

Author: oguzkocer

.gitignore

@@ -44,6 +44,9 @@ test_credentials.json
 /logs
 dump.sql
 
+# WP_COM Testing
+wp_com_test_credentials.json
+
 # CI Cache
 .cargo/*
 /vendor

wp_api/src/wp_com/endpoint/subscribers.rs

@@ -4,8 +4,9 @@ use crate::{
         WpComNamespace, WpComSiteId,
         subscribers::{
             AddSubscribersParams, AddSubscribersResponse, GetSubscriberQuery,
-            ListSubscribersResponse, SubscriberImportJob, SubscriberImportJobsListParams,
-            SubscriberStatsResponse, SubscribersListParams, UploadId,
+            ListSubscribersResponse, Subscriber, SubscriberImportJob,
+            SubscriberImportJobsListParams, SubscriberStatsResponse, SubscribersListParams,
+            UploadId,
         },
     },
 };
@@ -15,7 +16,7 @@ use wp_derive_request_builder::WpDerivedRequest;
 enum SubscribersRequest {
     #[get(url = "/sites/<wp_com_site_id>/subscribers", params = &SubscribersListParams, output = ListSubscribersResponse)]
     ListSubscribers,
-    #[get(url = "/sites/<wp_com_site_id>/subscribers/individual", params = &GetSubscriberQuery, output = SubscriberImportJob)]
+    #[get(url = "/sites/<wp_com_site_id>/subscribers/individual", params = &GetSubscriberQuery, output = Subscriber)]
     GetSubscriber,
     #[get(url = "/sites/<wp_com_site_id>/subscribers/import", params = &SubscriberImportJobsListParams, output = Vec<SubscriberImportJob>)]
     ListSubscriberImportJobs,

wp_api/src/wp_com/subscribers.rs

@@ -13,12 +13,17 @@ use wp_serde_helper::deserialize_u64_or_string;
 #[derive(Debug, Serialize, Deserialize, uniffi::Record)]
 pub struct Subscriber {
     pub user_id: UserId,
+    pub subscription_id: SubscriptionId,
     pub display_name: String,
     pub email_address: String,
+    pub is_email_subscriber: bool,
     pub email_subscription_id: Option<u64>,
     pub date_subscribed: WpGmtDateTime,
-    pub subscription_status: String,
+    pub subscription_status: Option<String>,
     pub avatar: String,
+    pub url: Option<String>,
+    pub country: Option<SubscriberCountry>,
+    pub plans: Option<Vec<SubscriptionPlan>>,
 }
 
 #[derive(
@@ -69,6 +74,27 @@ pub enum SubscriptionStatus {
     Custom(String),
 }
 
+#[derive(Debug, Serialize, Deserialize, uniffi::Record)]
+pub struct SubscriberCountry {
+    code: String,
+    name: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, uniffi::Record)]
+pub struct SubscriptionPlan {
+    pub is_gift: bool,
+    pub gift_id: Option<u64>,
+    pub paid_subscription_id: Option<String>,
+    pub status: String,
+    pub title: String,
+    pub currency: String,
+    pub renew_interval: String,
+    pub inactive_renew_interval: Option<String>,
+    pub renewal_price: f64,
+    pub start_date: WpGmtDateTime,
+    pub end_date: WpGmtDateTime,
+}
+
 #[derive(Debug, Default, PartialEq, Eq, uniffi::Record)]
 pub struct SubscribersListParams {
     // The current page.
@@ -131,7 +157,9 @@ impl AppendUrlQueryPairs for SubscribersListParams {
 #[strum(serialize_all = "snake_case")]
 pub enum ListSubscribersSortField {
     DateSubscribed,
+    #[strum(serialize = "email")]
     EmailAddress,
+    #[strum(serialize = "name")]
     DisplayName,
     Plan,
     SubscriptionStatus,
@@ -153,10 +181,10 @@ pub struct ListSubscribersResponse {
 #[derive(Debug, uniffi::Enum)]
 pub enum GetSubscriberQuery {
     // Return subscribers that receive notifications via WordPress.com for new posts.
-    WpCom(u64),
+    WpCom(UserId),
 
     // Return subscribers that receive notifications via email for new posts.
-    Email(u64),
+    Email(SubscriptionId),
 }
 
 impl AppendUrlQueryPairs for GetSubscriberQuery {
@@ -270,6 +298,25 @@ impl AppendUrlQueryPairs for SubscriberImportJobsListParams {
     }
 }
 
+impl_as_query_value_for_new_type!(SubscriptionId);
+uniffi::custom_newtype!(SubscriptionId, u64);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SubscriptionId(pub u64);
+
+impl std::str::FromStr for SubscriptionId {
+    type Err = std::num::ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.parse().map(Self)
+    }
+}
+
+impl std::fmt::Display for SubscriptionId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl_as_query_value_for_new_type!(UploadId);
 uniffi::custom_newtype!(UploadId, u64);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -398,7 +445,7 @@ mod tests {
         .expect("Failed to parse url");
 
         let mut query_pairs = url.query_pairs_mut();
-        GetSubscriberQuery::WpCom(123).append_query_pairs(&mut query_pairs);
+        GetSubscriberQuery::WpCom(UserId(123)).append_query_pairs(&mut query_pairs);
         assert_eq!(
             query_pairs.finish().as_str(),
             "https://public-api.wordpress.com/wpcom/v2/sites/1234/subscribers/individual?user_id=123&type=wpcom"
@@ -413,7 +460,7 @@ mod tests {
         .expect("Failed to parse url");
 
         let mut query_pairs = url.query_pairs_mut();
-        GetSubscriberQuery::Email(123).append_query_pairs(&mut query_pairs);
+        GetSubscriberQuery::Email(SubscriptionId(123)).append_query_pairs(&mut query_pairs);
         assert_eq!(
             query_pairs.finish().as_str(),
             "https://public-api.wordpress.com/wpcom/v2/sites/1234/subscribers/individual?subscription_id=123&type=email"
@@ -508,4 +555,15 @@ mod tests {
         assert_eq!(response.counts.email_subscribers, 26);
         assert_eq!(response.aggregate.len(), 60);
     }
+
+    #[test]
+    fn test_get_subscriber_with_paid_plans_response_deserialization() {
+        let json_file_path = "tests/wpcom/subscribers/subscriber-with-paid-plans.json";
+        let file = std::fs::File::open(json_file_path).expect("Failed to open file");
+        let subscriber: Subscriber = serde_json::from_reader(file).expect("Unable to parse JSON");
+
+        let plans = subscriber.plans.expect("JSON file includes plans");
+        assert_eq!(plans.len(), 2);
+        assert_eq!(plans[0].start_date.to_string(), "2025-01-13T18:51:55+00:00");
+    }
 }

wp_api/tests/wpcom/subscribers/subscriber-with-paid-plans.json

@@ -0,0 +1,43 @@
+{
+    "user_id": 123,
+    "subscription_id": 123,
+    "email_address": "[email protected]",
+    "date_subscribed": "2025-04-17T14:40:00+00:00",
+    "is_email_subscriber": false,
+    "subscription_status": "Subscribed",
+    "avatar": "https://example.com/avatar",
+    "display_name": "Foo",
+    "url": "http://example.wordpress.com",
+    "country": {
+        "code": "US",
+        "name": "United States"
+    },
+    "plans": [
+        {
+            "is_gift": false,
+            "gift_id": null,
+            "paid_subscription_id": "12422686",
+            "status": "active",
+            "title": "Newsletter Tier",
+            "currency": "USD",
+            "renew_interval": "1 month",
+            "inactive_renew_interval": null,
+            "renewal_price": 0.5,
+            "start_date": "2025-01-13T18:51:55+00:00",
+            "end_date": "2025-02-13T18:51:55+00:00"
+        },
+        {
+            "is_gift": true,
+            "gift_id": 31,
+            "paid_subscription_id": null,
+            "status": "active",
+            "title": "Newsletter Tier 3",
+            "currency": "USD",
+            "renew_interval": "one-time",
+            "inactive_renew_interval": null,
+            "renewal_price": 0,
+            "start_date": "2025-05-08T14:50:28+00:00",
+            "end_date": "2025-06-07T14:50:28+00:00"
+        }
+    ]
+}

wp_api_integration_tests/build.rs

@@ -7,39 +7,49 @@ use std::{
 };
 
 fn main() -> Result<(), Box<dyn Error>> {
-    generate_test_credentials_file()
-}
-
-fn generate_test_credentials_file() -> Result<(), Box<dyn Error>> {
-    // Tell Cargo to rerun if the test credentials file changes
-    println!("cargo::rerun-if-changed=../test_credentials");
-
     let out_dir = env::var("OUT_DIR")?;
     let dest_path = Path::new(&out_dir).join("generated_test_credentials.rs");
     let mut buf_writer = BufWriter::new(File::create(dest_path)?);
 
-    let instance = if let Ok(file) = fs::File::open("../test_credentials.json") {
+    generate_test_credentials("test_credentials", "TestCredentials", &mut buf_writer)?;
+    generate_test_credentials(
+        "wp_com_test_credentials",
+        "WpComTestCredentials",
+        &mut buf_writer,
+    )
+}
+
+fn generate_test_credentials(
+    file_name: &str,
+    test_credentials_type: &str,
+    buf_writer: &mut BufWriter<File>,
+) -> Result<(), Box<dyn Error>> {
+    let test_credential_json_file_path = format!("../{file_name}.json");
+    // Tell Cargo to rerun if the test credentials file changes
+    println!("cargo::rerun-if-changed={test_credential_json_file_path}");
+
+    let instance = if let Ok(file) = fs::File::open(&test_credential_json_file_path) {
         let fields = serde_json::from_reader::<File, serde_json::Value>(file)
-            .expect("test_credentials.json should be a valid JSON file")
+            .expect("{test_credential_json_file_path} should be a valid JSON file")
             .as_object()
-            .expect("test_credentials.json should be a valid JSON Object")
+            .expect("{test_credential_json_file_path} should be a valid JSON Object")
             .into_iter()
             .map(|(k, v)| format!("{}: {},", k, v))
             .collect::<Vec<String>>()
             .join("\n");
-        format!("TestCredentials {{ {} }}", fields)
+        format!("{test_credentials_type} {{ {} }}", fields)
     } else {
-        "TestCredentials::default()".to_string()
+        format!("{test_credentials_type}::default()")
     };
     let generated_content = format!(
         r#"
-            impl TestCredentials {{
+            impl {} {{
                 pub fn instance() -> Self {{
                     {}
                 }}
             }}
         "#,
-        instance
+        test_credentials_type, instance
     );
 
     write!(buf_writer, "{}", generated_content)?;

wp_api_integration_tests/src/lib.rs

@@ -1,4 +1,5 @@
 use crate::prelude::*;
+use wp_api::wp_com::client::WpComApiClient;
 
 pub mod mock;
 pub mod prelude;
@@ -35,6 +36,14 @@ impl TestCredentials {
     }
 }
 
+#[derive(Debug, Default)]
+pub struct WpComTestCredentials {
+    pub bearer_token: &'static str,
+    pub site_id: u64,
+    pub wp_com_subscriber_user_id: i64,
+    pub email_subscriber_subscription_id: u64,
+}
+
 pub mod backend;
 
 // The first user is also the current user
@@ -128,6 +137,18 @@ pub fn api_client_with_auth_provider(auth_provider: Arc<WpAuthenticationProvider
     )
 }
 
+pub fn wp_com_client() -> WpComApiClient {
+    WpComApiClient::new(WpApiClientDelegate {
+        auth_provider: WpAuthenticationProvider::static_with_auth(WpAuthentication::Bearer {
+            token: WpComTestCredentials::instance().bearer_token.to_string(),
+        })
+        .into(),
+        request_executor: Arc::new(ReqwestRequestExecutor::default()),
+        middleware_pipeline: Arc::new(WpApiMiddlewarePipeline::default()),
+        app_notifier: Arc::new(EmptyAppNotifier),
+    })
+}
+
 pub fn test_site_url() -> ParsedUrl {
     let mut url: Url = TestCredentials::instance()
         .site_url

wp_api_integration_tests/tests/test_wp_com_subscribers_immut.rs

@@ -0,0 +1,60 @@
+use wp_api::wp_com::{
+    WpComSiteId,
+    subscribers::{
+        GetSubscriberQuery, ListSubscribersSortField, SubscribersListParams, SubscriptionId,
+    },
+};
+use wp_api_integration_tests::{WpComTestCredentials, prelude::*, wp_com_client};
+
+#[tokio::test]
+#[apply(list_cases)]
+#[parallel]
+#[ignore]
+async fn list_subscribers(#[case] params: SubscribersListParams) {
+    let subscribers = wp_com_client()
+        .subscribers()
+        .list_subscribers(
+            &WpComSiteId(WpComTestCredentials::instance().site_id),
+            &params,
+        )
+        .await
+        .assert_response();
+    assert!(
+        subscribers.data.total > 0,
+        "Retrieved no subscribers: {:#?}",
+        subscribers
+    );
+}
+
+#[tokio::test]
+#[apply(retrieve_cases)]
+#[parallel]
+#[ignore]
+async fn retrieve_subscriber(#[case] query: GetSubscriberQuery) {
+    wp_com_client()
+        .subscribers()
+        .get_subscriber(
+            &WpComSiteId(WpComTestCredentials::instance().site_id),
+            &query,
+        )
+        .await
+        .assert_response();
+}
+
+#[template]
+#[rstest]
+#[case::default(SubscribersListParams::default())]
+#[case::sort_date_subscribed(generate!(SubscribersListParams, (sort, Some(ListSubscribersSortField::DateSubscribed))))]
+#[case::sort_email_address(generate!(SubscribersListParams, (sort, Some(ListSubscribersSortField::EmailAddress))))]
+#[case::sort_display_name(generate!(SubscribersListParams, (sort, Some(ListSubscribersSortField::DisplayName))))]
+#[case::sort_plan(generate!(SubscribersListParams, (sort, Some(ListSubscribersSortField::Plan))))]
+#[case::sort_subscription_status(generate!(SubscribersListParams, (sort, Some(ListSubscribersSortField::SubscriptionStatus))))]
+pub fn list_cases(#[case] params: SubscribersListParams) {}
+
+#[template]
+#[rstest]
+#[case::wp_com_subscriber(GetSubscriberQuery::WpCom(UserId(WpComTestCredentials::instance().wp_com_subscriber_user_id)))]
+#[case::email_subscriber(GetSubscriberQuery::Email(SubscriptionId(
+    WpComTestCredentials::instance().email_subscriber_subscription_id
+)))]
+pub fn retrieve_cases(#[case] query: GetSubscriberQuery) {}

wp_com_test_credentials.json-example

@@ -0,0 +1,6 @@
+{
+   "bearer_token": "replace_with_your_oauth2_token",
+   "site_id": 0,
+   "wp_com_subscriber_user_id": 0,
+   "email_subscriber_subscription_id": 0
+}