feat(newsletter): support public double opt-in

src/api/api_v1.rs

@@ -1,4 +1,6 @@
-use crate::api::newsletter::{is_subscribed, subscribe_handler, unsubscribe_handler};
+use crate::api::newsletter::{
+    is_subscribed, subscribe_anonymous_handler, subscribe_handler, unsubscribe_handler,
+};
 use crate::api::ping::ping;
 use crate::api::root::root_service;
 use crate::api::search::search;
@@ -22,5 +24,6 @@ pub fn api_v1_service() -> impl HttpServiceFactory {
         .service(web::resource("/search").route(web::get().to(search)))
         .service(web::resource("/whoami").route(web::get().to(whoami)))
         .service(web::resource("/ping").route(web::post().to(ping)))
+        .service(web::resource("/newsletter").route(web::post().to(subscribe_anonymous_handler)))
         .service(root_service())
 }

src/api/newsletter.rs

@@ -1,6 +1,9 @@
 use actix_identity::Identity;
-use actix_web::{web::Data, HttpResponse};
-use basket::{Basket, YesNo};
+use actix_web::{
+    web::{self, Data},
+    HttpResponse,
+};
+use basket::{Basket, SubscribeOpts, YesNo};
 use diesel::PgConnection;
 use serde::{Deserialize, Serialize};
 
@@ -12,6 +15,7 @@ use crate::{
         users::get_user,
         Pool,
     },
+    settings::SETTINGS,
 };
 
 const MDN_PLUS_LIST: &str = "mdnplus";
@@ -27,6 +31,11 @@ struct Subscribed {
     pub subscribed: bool,
 }
 
+#[derive(Deserialize, Serialize)]
+pub struct SubscriptionRequest {
+    pub email: String,
+}
+
 pub async fn subscribe_handler(
     pool: Data<Pool>,
     user_id: Identity,
@@ -40,13 +49,48 @@ pub async fn subscribe_handler(
     Ok(HttpResponse::NotImplemented().finish())
 }
 
+pub async fn subscribe_anonymous_handler(
+    basket: Data<Option<Basket>>,
+    subscription_req: web::Json<SubscriptionRequest>,
+) -> Result<HttpResponse, ApiError> {
+    if let Some(basket) = &**basket {
+        basket
+            .subscribe(
+                &subscription_req.email,
+                vec![MDN_PLUS_LIST.into()],
+                Some(SubscribeOpts {
+                    source_url: Some(format!(
+                        "{}/en-US/newsletter",
+                        &SETTINGS.application.document_base_url
+                    )),
+                    ..Default::default()
+                }),
+            )
+            .await?;
+
+        return Ok(HttpResponse::Created().json(Subscribed { subscribed: true }));
+    }
+    Ok(HttpResponse::NotImplemented().finish())
+}
+
 pub async fn subscribe(
     conn: &mut PgConnection,
     user: &UserQuery,
     basket: &Basket,
 ) -> Result<HttpResponse, ApiError> {
     basket
-        .subscribe_private(&user.email, vec![MDN_PLUS_LIST.into()], None)
+        .subscribe_private(
+            &user.email,
+            vec![MDN_PLUS_LIST.into()],
+            Some(SubscribeOpts {
+                optin: Some(YesNo::Y),
+                source_url: Some(format!(
+                    "{}/en-US/settings",
+                    &SETTINGS.application.document_base_url
+                )),
+                ..Default::default()
+            }),
+        )
         .await?;
     db::settings::create_or_update_settings(
         conn,

tests/api/newsletter.rs

@@ -1,14 +1,15 @@
-use crate::helpers::app::test_app_with_login;
+use crate::helpers::app::{init_test, test_app_with_login};
 use crate::helpers::db::reset;
 use crate::helpers::http_client::TestHttpClient;
 use crate::helpers::{read_json, wait_for_stubr};
 use actix_web::test;
 use anyhow::Error;
+use serde_json::json;
 use stubr::{Config, Stubr};
 
 #[actix_rt::test]
 #[stubr::mock(port = 4321)]
-async fn whoami_settings_test() -> Result<(), Error> {
+async fn settings_newsletter_test() -> Result<(), Error> {
     let pool = reset()?;
     wait_for_stubr().await?;
     let app = test_app_with_login(&pool).await?;
@@ -41,7 +42,10 @@ async fn whoami_settings_test() -> Result<(), Error> {
 
     drop(stubr);
     let stubr = Stubr::start_blocking_with(
-        vec!["tests/stubs", "tests/test_specific_stubs/newsletter"],
+        vec![
+            "tests/stubs",
+            "tests/test_specific_stubs/newsletter/basket_lookup_user.json",
+        ],
         Config {
             port: Some(4321),
             latency: None,
@@ -67,3 +71,45 @@ async fn whoami_settings_test() -> Result<(), Error> {
     drop(stubr);
     Ok(())
 }
+
+#[actix_rt::test]
+#[stubr::mock(port = 4321)]
+async fn anonymous_newsletter_test() -> Result<(), Error> {
+    let pool = reset()?;
+    wait_for_stubr().await?;
+    let app = test_app_with_login(&pool).await.unwrap();
+    let service = test::init_service(app).await;
+    let request = test::TestRequest::post()
+        .set_json(json!({ "email": "[email protected]"}))
+        .uri("/api/v1/newsletter")
+        .to_request();
+    let newsletter_res = test::call_service(&service, request).await;
+
+    assert!(newsletter_res.status().is_success());
+
+    drop(stubr);
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn anonymous_newsletter_error_test() -> Result<(), Error> {
+    let (_, stubr) = init_test(vec![
+        "tests/stubs",
+        "tests/test_specific_stubs/newsletter/basket_subscribe_error.json",
+    ])
+    .await?;
+
+    let pool = reset()?;
+    let app = test_app_with_login(&pool).await.unwrap();
+    let service = test::init_service(app).await;
+    let request = test::TestRequest::post()
+        .set_json(json!({ "email": "[email protected]"}))
+        .uri("/api/v1/newsletter")
+        .to_request();
+    let newsletter_res = test::call_service(&service, request).await;
+
+    assert!(newsletter_res.status().is_server_error());
+
+    drop(stubr);
+    Ok(())
+}

tests/test_specific_stubs/newsletter/basket_subscribe_error.json

@@ -0,0 +1,17 @@
+{
+  "uuid": "basket_subscribe",
+  "priority": 1,
+  "request": {
+    "method": "POST",
+    "url": "/news/subscribe/"
+  },
+  "response": {
+    "status": 500,
+    "headers": {
+      "Content-Type": "application/json"
+    },
+    "jsonBody": {
+      "status": "error"
+    }
+  }
+}