Create /templates endpoint

Author: oguzkocer

wp_api/src/api_error.rs

@@ -278,6 +278,8 @@ pub enum WpErrorCode {
     TaxonomyInvalid,
     #[serde(rename = "rest_template_already_trashed")]
     TemplateAlreadyTrashed,
+    #[serde(rename = "rest_template_insert_error")]
+    TemplateInsertError,
     #[serde(rename = "rest_template_not_found")]
     TemplateNotFound,
     #[serde(rename = "rest_term_invalid")]

wp_api/src/request/endpoint/templates_endpoint.rs

@@ -12,6 +12,8 @@ enum TemplatesRequest {
     List,
     #[contextual_get(url = "/templates/<template_id>", output = crate::templates::SparseTemplate, filter_by = crate::templates::SparseTemplateField)]
     Retrieve,
+    #[post(url = "/templates", params = &crate::templates::TemplateCreateParams, output = crate::templates::TemplateWithEditContext)]
+    Create,
     #[delete(url = "/templates/<template_id>", output = crate::templates::TemplateDeleteResponse)]
     Delete,
     #[delete(url = "/templates/<template_id>", output = crate::templates::TemplateWithEditContext)]
@@ -80,6 +82,11 @@ mod tests {
     use rstest::*;
     use std::sync::Arc;
 
+    #[rstest]
+    fn create_template(endpoint: TemplatesRequestEndpoint) {
+        validate_wp_v2_endpoint(endpoint.create(), "/templates");
+    }
+
     #[rstest]
     #[case(TemplateListParams::default(), "")]
     #[case(generate!(TemplateListParams, (post_id, Some(PostId(2)))), "wp_id=2")]

wp_api/src/templates.rs

@@ -232,3 +232,53 @@ pub struct TemplateUpdateParams {
     // don't seem to take place when they are included in the request. So, we decided not to
     // include them until we figure out under which conditions they'll be allowed to update.
 }
+
+#[derive(Debug, Serialize, uniffi::Record)]
+pub struct TemplateCreateParams {
+    // Unique slug identifying the template.
+    pub slug: String,
+    // Theme identifier for the template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub theme: Option<String>,
+    // Type of template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub template_type: Option<String>,
+    // Content of template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    // Title of template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    // Description of template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    // Status of template.
+    // One of: publish, future, draft, pending, private
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status: Option<TemplateStatus>,
+    // The ID for the author of the template.
+    #[uniffi(default = None)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub author: Option<UserId>,
+}
+
+impl TemplateCreateParams {
+    pub fn new(slug: String) -> Self {
+        Self {
+            slug,
+            theme: None,
+            template_type: None,
+            content: None,
+            title: None,
+            description: None,
+            status: None,
+            author: None,
+        }
+    }
+}

wp_api_integration_tests/tests/test_templates_err.rs

@@ -1,10 +1,21 @@
 use serial_test::parallel;
 use wp_api::{
     WpErrorCode,
-    templates::{TemplateId, TemplateUpdateParams},
+    templates::{TemplateCreateParams, TemplateId, TemplateUpdateParams},
 };
 use wp_api_integration_tests::{AssertWpError, TEMPLATE_TWENTY_TWENTY_FOUR_SINGLE, api_client};
 
+#[tokio::test]
+#[parallel]
+async fn create_template_err_empty_content() {
+    // Creating a template requires `title` or `content`
+    api_client()
+        .templates()
+        .create(&TemplateCreateParams::new("foo".to_string()))
+        .await
+        .assert_wp_error(WpErrorCode::EmptyContent)
+}
+
 #[tokio::test]
 #[parallel]
 async fn delete_template_err_invalid_template() {

wp_api_integration_tests/tests/test_templates_mut.rs

@@ -2,13 +2,111 @@ use macro_helper::generate_update_test;
 use serial_test::serial;
 use wp_api::templates::{
     SparseTemplateContent, SparseTemplateContentWrapper, SparseTemplateTitle,
-    SparseTemplateTitleWrapper, TemplateId, TemplateStatus, TemplateUpdateParams,
-    TemplateWithEditContext,
+    SparseTemplateTitleWrapper, TemplateCreateParams, TemplateId, TemplateStatus,
+    TemplateUpdateParams, TemplateWithEditContext,
 };
 use wp_api_integration_tests::{
     AssertResponse, SECOND_USER_ID, TestCredentials, api_client, backend::RestoreServer,
 };
 
+const TEST_SLUG: &str = "foo_template_slug";
+const TEST_TITLE: &str = "foo template title";
+
+#[tokio::test]
+#[serial]
+async fn create_template_with_slug_and_content() {
+    let content = "foo template content";
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.content = Some(content.to_string());
+    test_create_template(&params, |created_template| {
+        assert_slug(&created_template);
+        assert_eq!(
+            created_template.content,
+            SparseTemplateContentWrapper::Object(SparseTemplateContent {
+                raw: Some(content.to_string()),
+                rendered: None,
+                protected: None,
+                block_version: None
+            })
+        );
+    })
+    .await;
+}
+
+#[tokio::test]
+#[serial]
+async fn create_template_with_slug_and_title() {
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.title = Some(TEST_TITLE.to_string());
+    test_create_template(&params, |created_template| {
+        assert_slug(&created_template);
+        assert_title(&created_template);
+    })
+    .await;
+}
+
+#[tokio::test]
+#[serial]
+async fn create_template_with_slug_title_and_theme() {
+    let theme = "foo template theme";
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.title = Some(TEST_TITLE.to_string());
+    params.theme = Some(theme.to_string());
+    test_create_template(&params, |created_template| {
+        assert_slug(&created_template);
+        assert_title(&created_template);
+        assert_eq!(created_template.theme, theme);
+    })
+    .await;
+}
+
+#[tokio::test]
+#[serial]
+async fn create_template_with_slug_title_and_author() {
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.title = Some(TEST_TITLE.to_string());
+    params.author = Some(SECOND_USER_ID);
+    test_create_template(&params, |created_template| {
+        assert_title(&created_template);
+        assert_eq!(created_template.author, SECOND_USER_ID);
+    })
+    .await;
+}
+
+#[tokio::test]
+#[serial]
+// TODO: `template_type` parameter doesn't seem to be working. It either requires the template type
+// to be set up in advance or the parameter is always ignored.
+#[ignore]
+async fn create_template_with_slug_title_and_template_type() {
+    let template_type = "foo template type";
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.title = Some(TEST_TITLE.to_string());
+    params.template_type = Some(template_type.to_string());
+    test_create_template(&params, |created_template| {
+        assert_title(&created_template);
+        assert_eq!(created_template.template_type, template_type);
+    })
+    .await;
+}
+
+#[tokio::test]
+#[serial]
+// TODO: `status` parameter seems to be ignored as the server is always responding with
+// `TemplateStatus::Publish`
+#[ignore]
+async fn create_template_with_slug_title_and_template_status_future() {
+    let status = TemplateStatus::Future;
+    let mut params = TemplateCreateParams::new(TEST_SLUG.to_string());
+    params.title = Some(TEST_TITLE.to_string());
+    params.status = Some(status.clone());
+    test_create_template(&params, |created_template| {
+        assert_title(&created_template);
+        assert_eq!(created_template.status, status);
+    })
+    .await;
+}
+
 #[tokio::test]
 #[serial]
 async fn delete_template() {
@@ -116,6 +214,33 @@ where
     RestoreServer::db().await;
 }
 
+async fn test_create_template<F>(params: &TemplateCreateParams, assert: F)
+where
+    F: Fn(TemplateWithEditContext),
+{
+    let response = api_client()
+        .templates()
+        .create(params)
+        .await
+        .assert_response();
+    assert(response.data);
+    RestoreServer::db().await;
+}
+
+fn assert_slug(template: &TemplateWithEditContext) {
+    assert_eq!(template.slug, TEST_SLUG);
+}
+
+fn assert_title(template: &TemplateWithEditContext) {
+    assert_eq!(
+        template.title,
+        SparseTemplateTitleWrapper::Object(SparseTemplateTitle {
+            raw: Some(TEST_TITLE.to_string()),
+            rendered: Some(TEST_TITLE.to_string())
+        })
+    );
+}
+
 mod macro_helper {
     macro_rules! generate_update_test {
         ($ident:ident, $field:ident, $new_value:expr, $assertion:expr) => {