From 1220a5a3fe93164aef4f5b4c341ee20345b53193 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Fri, 24 May 2024 15:37:14 -0400 Subject: [PATCH 1/3] Implements WpRequestBuilder --- .../kotlin/UsersEndpointTest.kt | 1 - .../rs/wordpress/api/kotlin/UsersEndpoint.kt | 4 +- .../rs/wordpress/api/kotlin/WpApiClient.kt | 6 +-- .../wordpress/api/kotlin/WpUsersEndpoint.kt | 54 +++++++++---------- wp_api/src/lib.rs | 33 ++++++++++++ wp_api/src/request/plugins_request_builder.rs | 9 ++-- wp_api/src/request/users_request_builder.rs | 9 ++-- 7 files changed, 77 insertions(+), 39 deletions(-) diff --git a/native/kotlin/api/kotlin/src/integrationTest/kotlin/UsersEndpointTest.kt b/native/kotlin/api/kotlin/src/integrationTest/kotlin/UsersEndpointTest.kt index 6983d955e..74bd13cb7 100644 --- a/native/kotlin/api/kotlin/src/integrationTest/kotlin/UsersEndpointTest.kt +++ b/native/kotlin/api/kotlin/src/integrationTest/kotlin/UsersEndpointTest.kt @@ -5,7 +5,6 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertNull import org.junit.Test import uniffi.wp_api.SparseUserField -import uniffi.wp_api.WpApiHelper import uniffi.wp_api.WpContext import uniffi.wp_api.wpAuthenticationFromUsernameAndPassword diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/UsersEndpoint.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/UsersEndpoint.kt index b8b5f00c2..d505dc451 100644 --- a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/UsersEndpoint.kt +++ b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/UsersEndpoint.kt @@ -60,10 +60,10 @@ interface UsersEndpointCreate { interface UsersEndpointUpdate { suspend fun withId(userId: UserId, params: UserUpdateParams): WpRequestResult - suspend fun current(params: UserUpdateParams): WpRequestResult + suspend fun me(params: UserUpdateParams): WpRequestResult } interface UsersEndpointDelete { suspend fun withId(userId: UserId, params: UserDeleteParams): WpRequestResult - suspend fun current(params: UserDeleteParams): WpRequestResult + suspend fun me(params: UserDeleteParams): WpRequestResult } diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt index 93620db0c..1fe856017 100644 --- a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt +++ b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpApiClient.kt @@ -2,8 +2,8 @@ package rs.wordpress.api.kotlin import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.Dispatchers -import uniffi.wp_api.WpApiHelper import uniffi.wp_api.WpAuthentication +import uniffi.wp_api.WpRequestBuilder class WpApiClient( siteUrl: String, @@ -11,8 +11,8 @@ class WpApiClient( networkHandler: NetworkHandler = WpNetworkHandler(), dispatcher: CoroutineDispatcher = Dispatchers.IO ) { - private val apiHelper = WpApiHelper(siteUrl, authentication) + private val requestBuilder = WpRequestBuilder(siteUrl, authentication) val users: UsersEndpoint by lazy { - WpUsersEndpoint(apiHelper, networkHandler, dispatcher) + WpUsersEndpoint(requestBuilder.users(), networkHandler, dispatcher) } } diff --git a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpUsersEndpoint.kt b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpUsersEndpoint.kt index 15c9199f7..68857d068 100644 --- a/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpUsersEndpoint.kt +++ b/native/kotlin/api/kotlin/src/main/kotlin/rs/wordpress/api/kotlin/WpUsersEndpoint.kt @@ -13,7 +13,7 @@ import uniffi.wp_api.UserUpdateParams import uniffi.wp_api.UserWithEditContext import uniffi.wp_api.UserWithEmbedContext import uniffi.wp_api.UserWithViewContext -import uniffi.wp_api.WpApiHelper +import uniffi.wp_api.UsersRequestBuilder import uniffi.wp_api.WpContext import uniffi.wp_api.WpNetworkResponse import uniffi.wp_api.parseDeleteUserResponse @@ -27,35 +27,35 @@ import uniffi.wp_api.parseRetrieveUserResponseWithEmbedContext import uniffi.wp_api.parseRetrieveUserResponseWithViewContext internal class WpUsersEndpoint( - apiHelper: WpApiHelper, + usersRequestBuilder: UsersRequestBuilder, networkHandler: NetworkHandler, dispatcher: CoroutineDispatcher ) : UsersEndpoint { private val requestHandler = WpRequestHandler(networkHandler, dispatcher) override val list: UsersEndpointList by lazy { - WpUsersEndpointList(requestHandler, apiHelper, dispatcher) + WpUsersEndpointList(requestHandler, usersRequestBuilder, dispatcher) } override val retrieve: UsersEndpointRetrieve by lazy { - WpUsersEndpointRetrieve(requestHandler, apiHelper, dispatcher) + WpUsersEndpointRetrieve(requestHandler, usersRequestBuilder, dispatcher) } override val me: UsersEndpointRetrieveMe by lazy { - WpUsersEndpointRetrieveMe(requestHandler, apiHelper, dispatcher) + WpUsersEndpointRetrieveMe(requestHandler, usersRequestBuilder, dispatcher) } override val create: UsersEndpointCreate by lazy { - WpUsersEndpointCreate(requestHandler, apiHelper, dispatcher) + WpUsersEndpointCreate(requestHandler, usersRequestBuilder, dispatcher) } override val update: UsersEndpointUpdate by lazy { - WpUsersEndpointUpdate(requestHandler, apiHelper, dispatcher) + WpUsersEndpointUpdate(requestHandler, usersRequestBuilder, dispatcher) } override val delete: UsersEndpointDelete by lazy { - WpUsersEndpointDelete(requestHandler, apiHelper, dispatcher) + WpUsersEndpointDelete(requestHandler, usersRequestBuilder, dispatcher) } } private class WpUsersEndpointList( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointList { override suspend fun withEditContext(params: UserListParams?): WpRequestResult> = @@ -73,7 +73,7 @@ private class WpUsersEndpointList( fields: List ): WpRequestResult> = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.filterListUsersRequest(context, params, fields), + request = usersRequestBuilder.filterList(context, params, fields), ::parseFilterUsersResponse ) } @@ -84,7 +84,7 @@ private class WpUsersEndpointList( parser: (response: WpNetworkResponse) -> T ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.listUsersRequest(context, params), + request = usersRequestBuilder.list(context, params), parser ) } @@ -92,7 +92,7 @@ private class WpUsersEndpointList( private class WpUsersEndpointRetrieve( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointRetrieve { override suspend fun withEditContext(userId: UserId): WpRequestResult = @@ -110,7 +110,7 @@ private class WpUsersEndpointRetrieve( fields: List ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.filterRetrieveUserRequest(userId, context, fields), + request = usersRequestBuilder.filterRetrieve(userId, context, fields), ::parseFilterRetrieveUserResponse ) } @@ -121,7 +121,7 @@ private class WpUsersEndpointRetrieve( parser: (response: WpNetworkResponse) -> T ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.retrieveUserRequest(userId, context), + request = usersRequestBuilder.retrieve(userId, context), parser ) } @@ -129,7 +129,7 @@ private class WpUsersEndpointRetrieve( private class WpUsersEndpointRetrieveMe( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointRetrieveMe { override suspend fun withEditContext(): WpRequestResult = @@ -146,7 +146,7 @@ private class WpUsersEndpointRetrieveMe( fields: List ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.filterRetrieveCurrentUserRequest(context, fields), + request = usersRequestBuilder.filterRetrieveMe(context, fields), ::parseFilterRetrieveUserResponse ) } @@ -156,7 +156,7 @@ private class WpUsersEndpointRetrieveMe( parser: (response: WpNetworkResponse) -> T ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.retrieveCurrentUserRequest(context), + request = usersRequestBuilder.retrieveMe(context), parser ) } @@ -164,13 +164,13 @@ private class WpUsersEndpointRetrieveMe( private class WpUsersEndpointCreate( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointCreate { override suspend fun new(params: UserCreateParams): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.createUserRequest(params), + request = usersRequestBuilder.create(params), ::parseRetrieveUserResponseWithEditContext ) } @@ -178,7 +178,7 @@ private class WpUsersEndpointCreate( private class WpUsersEndpointUpdate( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointUpdate { override suspend fun withId( @@ -186,15 +186,15 @@ private class WpUsersEndpointUpdate( params: UserUpdateParams ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.updateUserRequest(userId, params), + request = usersRequestBuilder.update(userId, params), ::parseRetrieveUserResponseWithEditContext ) } - override suspend fun current(params: UserUpdateParams): WpRequestResult = + override suspend fun me(params: UserUpdateParams): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.updateCurrentUserRequest(params), + request = usersRequestBuilder.updateMe(params), ::parseRetrieveUserResponseWithEditContext ) } @@ -202,7 +202,7 @@ private class WpUsersEndpointUpdate( private class WpUsersEndpointDelete( private val requestHandler: WpRequestHandler, - private val apiHelper: WpApiHelper, + private val usersRequestBuilder: UsersRequestBuilder, private val dispatcher: CoroutineDispatcher ) : UsersEndpointDelete { override suspend fun withId( @@ -210,15 +210,15 @@ private class WpUsersEndpointDelete( params: UserDeleteParams ): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.deleteUserRequest(userId, params), + request = usersRequestBuilder.delete(userId, params), ::parseDeleteUserResponse ) } - override suspend fun current(params: UserDeleteParams): WpRequestResult = + override suspend fun me(params: UserDeleteParams): WpRequestResult = withContext(dispatcher) { requestHandler.execute( - request = apiHelper.deleteCurrentUserRequest(params), + request = usersRequestBuilder.deleteMe(params), ::parseDeleteUserResponse ) } diff --git a/wp_api/src/lib.rs b/wp_api/src/lib.rs index 884b69ac8..fd856b143 100644 --- a/wp_api/src/lib.rs +++ b/wp_api/src/lib.rs @@ -26,6 +26,39 @@ mod unit_test_common; const CONTENT_TYPE_JSON: &str = "application/json"; +#[derive(Debug, uniffi::Object)] +pub struct WpRequestBuilder { + users: Arc, + plugins: Arc, +} + +#[uniffi::export] +impl WpRequestBuilder { + #[uniffi::constructor] + pub fn new(site_url: String, authentication: WPAuthentication) -> Self { + let url = Url::parse(site_url.as_str()).unwrap(); + // TODO: Handle the url parse error + let api_base_url = Arc::new(ApiBaseUrl::new(site_url.as_str()).unwrap()); + let request_builder = Arc::new(RequestBuilder { + authentication: authentication.clone(), + }); + + Self { + users: UsersRequestBuilder::new(api_base_url.clone(), request_builder.clone()).into(), + plugins: PluginsRequestBuilder::new(api_base_url.clone(), request_builder.clone()) + .into(), + } + } + + pub fn users(&self) -> Arc { + self.users.clone() + } + + pub fn plugins(&self) -> Arc { + self.plugins.clone() + } +} + #[derive(Debug, uniffi::Object)] pub struct WPApiHelper { request_builder: Arc, diff --git a/wp_api/src/request/plugins_request_builder.rs b/wp_api/src/request/plugins_request_builder.rs index e974e8e39..3c4cc42da 100644 --- a/wp_api/src/request/plugins_request_builder.rs +++ b/wp_api/src/request/plugins_request_builder.rs @@ -10,20 +10,23 @@ use super::{ WPNetworkRequest, }; -#[derive(Debug)] -pub(crate) struct PluginsRequestBuilder { +#[derive(Debug, uniffi::Object)] +pub struct PluginsRequestBuilder { endpoint: PluginsEndpoint, request_builder: Arc, } impl PluginsRequestBuilder { - pub fn new(api_base_url: Arc, request_builder: Arc) -> Self { + pub(crate) fn new(api_base_url: Arc, request_builder: Arc) -> Self { Self { endpoint: PluginsEndpoint::new(api_base_url), request_builder, } } +} +#[uniffi::export] +impl PluginsRequestBuilder { pub fn list( &self, context: WPContext, diff --git a/wp_api/src/request/users_request_builder.rs b/wp_api/src/request/users_request_builder.rs index b1a25eefa..48ff52786 100644 --- a/wp_api/src/request/users_request_builder.rs +++ b/wp_api/src/request/users_request_builder.rs @@ -10,20 +10,23 @@ use super::{ WPNetworkRequest, }; -#[derive(Debug)] -pub(crate) struct UsersRequestBuilder { +#[derive(Debug, uniffi::Object)] +pub struct UsersRequestBuilder { endpoint: UsersEndpoint, request_builder: Arc, } impl UsersRequestBuilder { - pub fn new(api_base_url: Arc, request_builder: Arc) -> Self { + pub(crate) fn new(api_base_url: Arc, request_builder: Arc) -> Self { Self { endpoint: UsersEndpoint::new(api_base_url), request_builder, } } +} +#[uniffi::export] +impl UsersRequestBuilder { pub fn list( &self, context: WPContext, From 9f5542ee5f7ba8f1a04c61f066c5e664d04525e7 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Mon, 27 May 2024 14:08:48 -0400 Subject: [PATCH 2/3] Remove WPApiHelper --- wp_api/src/lib.rs | 156 ------------------------ wp_api/tests/integration_test_common.rs | 11 +- wp_api/tests/test_plugins_err.rs | 34 +++--- wp_api/tests/test_plugins_immut.rs | 22 ++-- wp_api/tests/test_plugins_mut.rs | 19 +-- wp_api/tests/test_users_err.rs | 111 ++++++++++------- wp_api/tests/test_users_immut.rs | 52 ++++---- wp_api/tests/test_users_mut.rs | 32 +++-- 8 files changed, 167 insertions(+), 270 deletions(-) diff --git a/wp_api/src/lib.rs b/wp_api/src/lib.rs index fd856b143..ae8ae0edb 100644 --- a/wp_api/src/lib.rs +++ b/wp_api/src/lib.rs @@ -59,13 +59,6 @@ impl WpRequestBuilder { } } -#[derive(Debug, uniffi::Object)] -pub struct WPApiHelper { - request_builder: Arc, - users_request: UsersRequestBuilder, - plugins_request: PluginsRequestBuilder, -} - #[uniffi::export] fn wp_authentication_from_username_and_password( username: String, @@ -74,155 +67,6 @@ fn wp_authentication_from_username_and_password( WPAuthentication::from_username_and_password(username, password) } -#[uniffi::export] -impl WPApiHelper { - #[uniffi::constructor] - pub fn new(site_url: String, authentication: WPAuthentication) -> Self { - let url = Url::parse(site_url.as_str()).unwrap(); - // TODO: Handle the url parse error - let api_base_url = Arc::new(ApiBaseUrl::new(site_url.as_str()).unwrap()); - let request_builder = Arc::new(RequestBuilder { - authentication: authentication.clone(), - }); - - Self { - request_builder: request_builder.clone(), - users_request: UsersRequestBuilder::new(api_base_url.clone(), request_builder.clone()), - plugins_request: PluginsRequestBuilder::new( - api_base_url.clone(), - request_builder.clone(), - ), - } - } - - // TODO: Remove this because we want to build all requests within the crate - pub fn raw_request(&self, url: String) -> WPNetworkRequest { - self.request_builder - .get(ApiEndpointUrl::new(Url::parse(url.as_str()).unwrap())) - } - - pub fn list_users_request( - &self, - context: WPContext, - params: &Option, // UniFFI doesn't support Option<&T> - ) -> WPNetworkRequest { - self.users_request.list(context, params) - } - - pub fn filter_list_users_request( - &self, - context: WPContext, - params: &Option, // UniFFI doesn't support Option<&T> - fields: &[SparseUserField], - ) -> WPNetworkRequest { - self.users_request.filter_list(context, params, fields) - } - - pub fn retrieve_user_request(&self, user_id: UserId, context: WPContext) -> WPNetworkRequest { - self.users_request.retrieve(user_id, context) - } - - pub fn filter_retrieve_user_request( - &self, - user_id: UserId, - context: WPContext, - fields: &[SparseUserField], - ) -> WPNetworkRequest { - self.users_request.filter_retrieve(user_id, context, fields) - } - - pub fn retrieve_current_user_request(&self, context: WPContext) -> WPNetworkRequest { - self.users_request.retrieve_me(context) - } - - pub fn filter_retrieve_current_user_request( - &self, - context: WPContext, - fields: &[SparseUserField], - ) -> WPNetworkRequest { - self.users_request.filter_retrieve_me(context, fields) - } - - pub fn create_user_request(&self, params: &UserCreateParams) -> WPNetworkRequest { - self.users_request.create(params) - } - - pub fn update_user_request( - &self, - user_id: UserId, - params: &UserUpdateParams, - ) -> WPNetworkRequest { - self.users_request.update(user_id, params) - } - - pub fn update_current_user_request(&self, params: &UserUpdateParams) -> WPNetworkRequest { - self.users_request.update_me(params) - } - - pub fn delete_user_request( - &self, - user_id: UserId, - params: &UserDeleteParams, - ) -> WPNetworkRequest { - self.users_request.delete(user_id, params) - } - - pub fn delete_current_user_request(&self, params: &UserDeleteParams) -> WPNetworkRequest { - self.users_request.delete_me(params) - } - - pub fn list_plugins_request( - &self, - context: WPContext, - params: &Option, // UniFFI doesn't support Option<&T> - ) -> WPNetworkRequest { - self.plugins_request.list(context, params) - } - - pub fn filter_list_plugins_request( - &self, - context: WPContext, - params: &Option, // UniFFI doesn't support Option<&T> - fields: &[SparsePluginField], - ) -> WPNetworkRequest { - self.plugins_request.filter_list(context, params, fields) - } - - pub fn create_plugin_request(&self, params: &PluginCreateParams) -> WPNetworkRequest { - self.plugins_request.create(params) - } - - pub fn retrieve_plugin_request( - &self, - context: WPContext, - plugin: &PluginSlug, - ) -> WPNetworkRequest { - self.plugins_request.retrieve(context, plugin) - } - - pub fn filter_retrieve_plugin_request( - &self, - context: WPContext, - plugin: &PluginSlug, - fields: &[SparsePluginField], - ) -> WPNetworkRequest { - self.plugins_request - .filter_retrieve(context, plugin, fields) - } - - pub fn update_plugin_request( - &self, - plugin: &PluginSlug, - params: &PluginUpdateParams, - ) -> WPNetworkRequest { - self.plugins_request.update(plugin, params) - } - - pub fn delete_plugin_request(&self, plugin: &PluginSlug) -> WPNetworkRequest { - self.plugins_request.delete(plugin) - } -} - #[derive(Debug)] struct RequestBuilder { authentication: WPAuthentication, diff --git a/wp_api/tests/integration_test_common.rs b/wp_api/tests/integration_test_common.rs index f25a34fbb..0bef5d9ee 100644 --- a/wp_api/tests/integration_test_common.rs +++ b/wp_api/tests/integration_test_common.rs @@ -4,7 +4,8 @@ use std::{fs::read_to_string, process::Command}; use wp_api::{ request::{RequestMethod, WPNetworkRequest, WPNetworkResponse}, users::UserId, - WPApiError, WPApiHelper, WPAuthentication, WPRestError, WPRestErrorCode, WPRestErrorWrapper, + WPApiError, WPAuthentication, WPRestError, WPRestErrorCode, WPRestErrorWrapper, + WpRequestBuilder, }; // The first user is also the current user @@ -16,22 +17,22 @@ pub const HELLO_DOLLY_PLUGIN_SLUG: &str = "hello-dolly/hello"; pub const CLASSIC_EDITOR_PLUGIN_SLUG: &str = "classic-editor/classic-editor"; pub const WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS: &str = "classic-widgets"; -pub fn api() -> WPApiHelper { +pub fn request_builder() -> WpRequestBuilder { let credentials = read_test_credentials_from_file(); let authentication = WPAuthentication::from_username_and_password( credentials.admin_username, credentials.admin_password, ); - WPApiHelper::new(credentials.site_url, authentication) + WpRequestBuilder::new(credentials.site_url, authentication) } -pub fn api_as_subscriber() -> WPApiHelper { +pub fn request_builder_as_subscriber() -> WpRequestBuilder { let credentials = read_test_credentials_from_file(); let authentication = WPAuthentication::from_username_and_password( credentials.subscriber_username, credentials.subscriber_password, ); - WPApiHelper::new(credentials.site_url, authentication) + WpRequestBuilder::new(credentials.site_url, authentication) } pub trait WPNetworkRequestExecutor { diff --git a/wp_api/tests/test_plugins_err.rs b/wp_api/tests/test_plugins_err.rs index 62e856840..408766fd0 100644 --- a/wp_api/tests/test_plugins_err.rs +++ b/wp_api/tests/test_plugins_err.rs @@ -2,16 +2,17 @@ use wp_api::plugins::{PluginCreateParams, PluginStatus, PluginUpdateParams}; use wp_api::{WPContext, WPRestErrorCode}; use crate::integration_test_common::{ - api, api_as_subscriber, AssertWpError, WPNetworkRequestExecutor, HELLO_DOLLY_PLUGIN_SLUG, - WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS, + request_builder, request_builder_as_subscriber, AssertWpError, WPNetworkRequestExecutor, + HELLO_DOLLY_PLUGIN_SLUG, WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS, }; pub mod integration_test_common; #[tokio::test] async fn create_plugin_err_cannot_install_plugin() { - api_as_subscriber() - .create_plugin_request(&PluginCreateParams { + request_builder_as_subscriber() + .plugins() + .create(&PluginCreateParams { slug: WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS.into(), status: PluginStatus::Active, }) @@ -24,8 +25,9 @@ async fn create_plugin_err_cannot_install_plugin() { #[tokio::test] async fn delete_plugin_err_cannot_delete_active_plugin() { - api() - .delete_plugin_request(&HELLO_DOLLY_PLUGIN_SLUG.into()) + request_builder() + .plugins() + .delete(&HELLO_DOLLY_PLUGIN_SLUG.into()) .execute() .await .unwrap() @@ -35,8 +37,9 @@ async fn delete_plugin_err_cannot_delete_active_plugin() { #[tokio::test] async fn list_plugins_err_cannot_view_plugins() { - api_as_subscriber() - .list_plugins_request(WPContext::Edit, &None) + request_builder_as_subscriber() + .plugins() + .list(WPContext::Edit, &None) .execute() .await .unwrap() @@ -46,8 +49,9 @@ async fn list_plugins_err_cannot_view_plugins() { #[tokio::test] async fn retrieve_plugin_err_cannot_view_plugin() { - api_as_subscriber() - .retrieve_plugin_request(WPContext::Edit, &HELLO_DOLLY_PLUGIN_SLUG.into()) + request_builder_as_subscriber() + .plugins() + .retrieve(WPContext::Edit, &HELLO_DOLLY_PLUGIN_SLUG.into()) .execute() .await .unwrap() @@ -57,8 +61,9 @@ async fn retrieve_plugin_err_cannot_view_plugin() { #[tokio::test] async fn update_plugin_err_plugin_not_found() { - api() - .update_plugin_request( + request_builder() + .plugins() + .update( &"foo".into(), &PluginUpdateParams { status: PluginStatus::Active, @@ -73,8 +78,9 @@ async fn update_plugin_err_plugin_not_found() { #[tokio::test] async fn update_plugin_err_cannot_manage_plugins() { - api_as_subscriber() - .update_plugin_request( + request_builder_as_subscriber() + .plugins() + .update( &HELLO_DOLLY_PLUGIN_SLUG.into(), &PluginUpdateParams { status: PluginStatus::Active, diff --git a/wp_api/tests/test_plugins_immut.rs b/wp_api/tests/test_plugins_immut.rs index fe952e723..eb2d2f9b8 100644 --- a/wp_api/tests/test_plugins_immut.rs +++ b/wp_api/tests/test_plugins_immut.rs @@ -7,7 +7,7 @@ use wp_api::{ }; use crate::integration_test_common::{ - api, WPNetworkRequestExecutor, CLASSIC_EDITOR_PLUGIN_SLUG, HELLO_DOLLY_PLUGIN_SLUG, + request_builder, WPNetworkRequestExecutor, CLASSIC_EDITOR_PLUGIN_SLUG, HELLO_DOLLY_PLUGIN_SLUG, }; pub mod integration_test_common; @@ -23,8 +23,9 @@ async fn filter_plugins( )] params: PluginListParams, ) { - let parsed_response = api() - .filter_list_plugins_request(WPContext::Edit, &Some(params), fields) + let parsed_response = request_builder() + .plugins() + .filter_list(WPContext::Edit, &Some(params), fields) .execute() .await .unwrap() @@ -42,8 +43,9 @@ async fn filter_retrieve_plugin( #[case] fields: &[SparsePluginField], #[values(CLASSIC_EDITOR_PLUGIN_SLUG, HELLO_DOLLY_PLUGIN_SLUG)] slug: &str, ) { - let plugin_result = api() - .filter_retrieve_plugin_request(WPContext::Edit, &slug.into(), fields) + let plugin_result = request_builder() + .plugins() + .filter_retrieve(WPContext::Edit, &slug.into(), fields) .execute() .await .unwrap() @@ -63,8 +65,9 @@ async fn plugin_list_params_parametrized( #[case] params: PluginListParams, #[values(WPContext::Edit, WPContext::Embed, WPContext::View)] context: WPContext, ) { - let response = api() - .list_plugins_request(context, &Some(params)) + let response = request_builder() + .plugins() + .list(context, &Some(params)) .execute() .await .unwrap(); @@ -109,8 +112,9 @@ async fn retrieve_plugin_with_edit_context( #[case] expected_author: &str, #[values(WPContext::Edit, WPContext::Embed, WPContext::View)] context: WPContext, ) { - let parsed_response = api() - .retrieve_plugin_request(context, &plugin_slug) + let parsed_response = request_builder() + .plugins() + .retrieve(context, &plugin_slug) .execute() .await .unwrap() diff --git a/wp_api/tests/test_plugins_mut.rs b/wp_api/tests/test_plugins_mut.rs index 3fe20a32c..d48fd504e 100644 --- a/wp_api/tests/test_plugins_mut.rs +++ b/wp_api/tests/test_plugins_mut.rs @@ -1,8 +1,8 @@ use wp_api::plugins::{PluginCreateParams, PluginStatus, PluginUpdateParams}; use crate::integration_test_common::{ - api, run_and_restore_wp_content_plugins, WPNetworkRequestExecutor, CLASSIC_EDITOR_PLUGIN_SLUG, - HELLO_DOLLY_PLUGIN_SLUG, WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS, + request_builder, run_and_restore_wp_content_plugins, WPNetworkRequestExecutor, + CLASSIC_EDITOR_PLUGIN_SLUG, HELLO_DOLLY_PLUGIN_SLUG, WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS, }; pub mod integration_test_common; @@ -17,8 +17,9 @@ async fn create_plugin() { slug: WP_ORG_PLUGIN_SLUG_CLASSIC_WIDGETS.into(), status, }; - let created_plugin = api() - .create_plugin_request(¶ms) + let created_plugin = request_builder() + .plugins() + .create(¶ms) .execute() .await .unwrap() @@ -35,8 +36,9 @@ async fn update_plugin() { run_and_restore_wp_content_plugins(|| { wp_db::run_and_restore(|mut _db| async move { let status = PluginStatus::Active; - let updated_plugin = api() - .update_plugin_request( + let updated_plugin = request_builder() + .plugins() + .update( &HELLO_DOLLY_PLUGIN_SLUG.into(), &PluginUpdateParams { status }, ) @@ -55,8 +57,9 @@ async fn update_plugin() { async fn delete_plugin() { run_and_restore_wp_content_plugins(|| { wp_db::run_and_restore(|mut _db| async move { - let deleted_plugin = api() - .delete_plugin_request(&CLASSIC_EDITOR_PLUGIN_SLUG.into()) + let deleted_plugin = request_builder() + .plugins() + .delete(&CLASSIC_EDITOR_PLUGIN_SLUG.into()) .execute() .await .unwrap() diff --git a/wp_api/tests/test_users_err.rs b/wp_api/tests/test_users_err.rs index dbec0a757..2419b76bb 100644 --- a/wp_api/tests/test_users_err.rs +++ b/wp_api/tests/test_users_err.rs @@ -5,20 +5,21 @@ use wp_api::{ UserCreateParams, UserDeleteParams, UserId, UserListParams, UserUpdateParams, WPApiParamUsersOrderBy, WPApiParamUsersWho, }, - WPApiHelper, WPAuthentication, WPContext, WPRestErrorCode, + WPAuthentication, WPContext, WPRestErrorCode, }; use crate::integration_test_common::{ - api, api_as_subscriber, AssertWpError, WPNetworkRequestExecutor, FIRST_USER_ID, SECOND_USER_ID, - SECOND_USER_SLUG, + request_builder, request_builder_as_subscriber, AssertWpError, WPNetworkRequestExecutor, + FIRST_USER_ID, SECOND_USER_ID, SECOND_USER_SLUG, }; pub mod integration_test_common; #[tokio::test] async fn create_user_err_cannot_create_user() { - api_as_subscriber() - .create_user_request(&valid_user_create_params()) + request_builder_as_subscriber() + .users() + .create(&valid_user_create_params()) .execute() .await .unwrap() @@ -28,8 +29,9 @@ async fn create_user_err_cannot_create_user() { #[tokio::test] async fn delete_user_err_user_cannot_delete() { - api_as_subscriber() - .delete_user_request( + request_builder_as_subscriber() + .users() + .delete( FIRST_USER_ID, &UserDeleteParams { reassign: SECOND_USER_ID, @@ -44,8 +46,9 @@ async fn delete_user_err_user_cannot_delete() { #[tokio::test] async fn delete_user_err_user_invalid_reassign() { - api() - .delete_user_request( + request_builder() + .users() + .delete( FIRST_USER_ID, &UserDeleteParams { reassign: UserId(987654321), @@ -60,8 +63,9 @@ async fn delete_user_err_user_invalid_reassign() { #[tokio::test] async fn delete_current_user_err_user_invalid_reassign() { - api() - .delete_current_user_request(&UserDeleteParams { + request_builder() + .users() + .delete_me(&UserDeleteParams { reassign: UserId(987654321), }) .execute() @@ -73,8 +77,9 @@ async fn delete_current_user_err_user_invalid_reassign() { #[tokio::test] async fn list_users_err_forbidden_context() { - api_as_subscriber() - .list_users_request(WPContext::Edit, &None) + request_builder_as_subscriber() + .users() + .list(WPContext::Edit, &None) .execute() .await .unwrap() @@ -88,8 +93,9 @@ async fn list_users_err_forbidden_orderby_email() { orderby: Some(WPApiParamUsersOrderBy::Email), ..Default::default() }; - api_as_subscriber() - .list_users_request(WPContext::View, &Some(params)) + request_builder_as_subscriber() + .users() + .list(WPContext::View, &Some(params)) .execute() .await .unwrap() @@ -103,8 +109,9 @@ async fn list_users_err_forbidden_who() { who: Some(WPApiParamUsersWho::Authors), ..Default::default() }; - api_as_subscriber() - .list_users_request(WPContext::View, &Some(params)) + request_builder_as_subscriber() + .users() + .list(WPContext::View, &Some(params)) .execute() .await .unwrap() @@ -118,8 +125,9 @@ async fn list_users_with_capabilities_err_user_cannot_view() { capabilities: vec!["foo".to_string()], ..Default::default() }; - api_as_subscriber() - .list_users_request(WPContext::Edit, &Some(params)) + request_builder_as_subscriber() + .users() + .list(WPContext::Edit, &Some(params)) .execute() .await .unwrap() @@ -133,8 +141,9 @@ async fn list_users_with_roles_err_user_cannot_view() { roles: vec!["foo".to_string()], ..Default::default() }; - api_as_subscriber() - .list_users_request(WPContext::Edit, &Some(params)) + request_builder_as_subscriber() + .users() + .list(WPContext::Edit, &Some(params)) .execute() .await .unwrap() @@ -148,8 +157,9 @@ async fn list_users_orderby_registered_date_err_forbidden_orderby() { orderby: Some(WPApiParamUsersOrderBy::RegisteredDate), ..Default::default() }; - api_as_subscriber() - .list_users_request(WPContext::View, &Some(params)) + request_builder_as_subscriber() + .users() + .list(WPContext::View, &Some(params)) .execute() .await .unwrap() @@ -159,8 +169,9 @@ async fn list_users_orderby_registered_date_err_forbidden_orderby() { #[tokio::test] async fn retrieve_user_err_user_invalid_id() { - api() - .retrieve_user_request(UserId(987654321), WPContext::Edit) + request_builder() + .users() + .retrieve(UserId(987654321), WPContext::Edit) .execute() .await .unwrap() @@ -170,11 +181,12 @@ async fn retrieve_user_err_user_invalid_id() { #[tokio::test] async fn retrieve_user_err_unauthorized() { - WPApiHelper::new( + wp_api::WpRequestBuilder::new( integration_test_common::read_test_credentials_from_file().site_url, WPAuthentication::None, ) - .retrieve_current_user_request(WPContext::Edit) + .users() + .retrieve_me(WPContext::Edit) .execute() .await .unwrap() @@ -189,8 +201,9 @@ async fn update_user_err_cannot_edit() { ..Default::default() }; // Subscribers can't update someone else's slug - api_as_subscriber() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder_as_subscriber() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -200,7 +213,9 @@ async fn update_user_err_cannot_edit() { #[tokio::test] async fn update_user_err_user_invalid_argument() { - let mut request = api().update_user_request(FIRST_USER_ID, &UserUpdateParams::default()); + let mut request = request_builder() + .users() + .update(FIRST_USER_ID, &UserUpdateParams::default()); request.body = Some( serde_json::json!({ "username": "new_username", @@ -224,8 +239,9 @@ async fn update_user_err_cannot_edit_roles() { ..Default::default() }; // Subscribers can't update their roles - api_as_subscriber() - .update_user_request(SECOND_USER_ID, ¶ms) + request_builder_as_subscriber() + .users() + .update(SECOND_USER_ID, ¶ms) .execute() .await .unwrap() @@ -240,8 +256,9 @@ async fn update_user_err_user_invalid_email() { ..Default::default() }; // Can't update user's email to an email that's already in use - api() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -255,8 +272,9 @@ async fn update_user_email_err_invalid_param() { email: Some("not_valid".to_string()), ..Default::default() }; - api() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -270,8 +288,9 @@ async fn update_user_password_err_invalid_param() { password: Some("".to_string()), ..Default::default() }; - api() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -286,8 +305,9 @@ async fn update_user_err_user_invalid_role() { ..Default::default() }; // Can't update user's email to a role that doesn't exist - api() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -302,8 +322,9 @@ async fn update_user_err_user_invalid_slug() { ..Default::default() }; // Can't update user's slug to a slug that's already in use - api() - .update_user_request(FIRST_USER_ID, ¶ms) + request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await .unwrap() @@ -317,7 +338,9 @@ async fn update_user_err_user_invalid_slug() { #[tokio::test] async fn create_user_err_user_exists() { - let mut request = api().create_user_request(&valid_user_create_params()); + let mut request = request_builder() + .users() + .create(&valid_user_create_params()); request.url.0.push_str("?id=1"); request .execute() @@ -329,7 +352,7 @@ async fn create_user_err_user_exists() { #[tokio::test] async fn delete_user_err_trash_not_supported() { - let mut request = api().delete_user_request( + let mut request = request_builder().users().delete( FIRST_USER_ID, &UserDeleteParams { reassign: SECOND_USER_ID, diff --git a/wp_api/tests/test_users_immut.rs b/wp_api/tests/test_users_immut.rs index 5ee6796f1..45446cf20 100644 --- a/wp_api/tests/test_users_immut.rs +++ b/wp_api/tests/test_users_immut.rs @@ -9,7 +9,7 @@ use wp_api::{ }; use crate::integration_test_common::{ - api, WPNetworkRequestExecutor, FIRST_USER_ID, SECOND_USER_ID, + request_builder, WPNetworkRequestExecutor, FIRST_USER_ID, SECOND_USER_ID, }; pub mod integration_test_common; @@ -17,8 +17,9 @@ pub mod integration_test_common; #[apply(filter_fields_cases)] #[tokio::test] async fn filter_users(#[case] fields: &[SparseUserField]) { - let parsed_response = api() - .filter_list_users_request(WPContext::Edit, &None, fields) + let parsed_response = request_builder() + .users() + .filter_list(WPContext::Edit, &None, fields) .execute() .await .unwrap() @@ -33,8 +34,9 @@ async fn filter_users(#[case] fields: &[SparseUserField]) { #[apply(filter_fields_cases)] #[tokio::test] async fn filter_retrieve_user(#[case] fields: &[SparseUserField]) { - let user_result = api() - .filter_retrieve_user_request(FIRST_USER_ID, WPContext::Edit, fields) + let user_result = request_builder() + .users() + .filter_retrieve(FIRST_USER_ID, WPContext::Edit, fields) .execute() .await .unwrap() @@ -46,8 +48,9 @@ async fn filter_retrieve_user(#[case] fields: &[SparseUserField]) { #[apply(filter_fields_cases)] #[tokio::test] async fn filter_retrieve_current_user(#[case] fields: &[SparseUserField]) { - let user_result = api() - .filter_retrieve_current_user_request(WPContext::Edit, fields) + let user_result = request_builder() + .users() + .filter_retrieve_me(WPContext::Edit, fields) .execute() .await .unwrap() @@ -80,8 +83,9 @@ async fn test_user_list_params_parametrized( #[case] params: UserListParams, #[values(WPContext::Edit, WPContext::Embed, WPContext::View)] context: WPContext, ) { - let response = api() - .list_users_request(context, &Some(params)) + let response = request_builder() + .users() + .list(context, &Some(params)) .execute() .await .unwrap(); @@ -118,8 +122,9 @@ async fn test_user_list_params_parametrized( #[tokio::test] async fn retrieve_user_with_edit_context() { - assert!(api() - .retrieve_user_request(FIRST_USER_ID, WPContext::Edit) + assert!(request_builder() + .users() + .retrieve(FIRST_USER_ID, WPContext::Edit) .execute() .await .unwrap() @@ -129,8 +134,9 @@ async fn retrieve_user_with_edit_context() { #[tokio::test] async fn retrieve_user_with_embed_context() { - assert!(api() - .retrieve_user_request(FIRST_USER_ID, WPContext::Embed) + assert!(request_builder() + .users() + .retrieve(FIRST_USER_ID, WPContext::Embed) .execute() .await .unwrap() @@ -140,8 +146,9 @@ async fn retrieve_user_with_embed_context() { #[tokio::test] async fn retrieve_user_with_view_context() { - assert!(api() - .retrieve_user_request(FIRST_USER_ID, WPContext::View) + assert!(request_builder() + .users() + .retrieve(FIRST_USER_ID, WPContext::View) .execute() .await .unwrap() @@ -151,8 +158,9 @@ async fn retrieve_user_with_view_context() { #[tokio::test] async fn retrieve_current_user_with_edit_context() { - assert!(api() - .retrieve_current_user_request(WPContext::Edit) + assert!(request_builder() + .users() + .retrieve_me(WPContext::Edit) .execute() .await .unwrap() @@ -162,8 +170,9 @@ async fn retrieve_current_user_with_edit_context() { #[tokio::test] async fn retrieve_current_user_with_embed_context() { - assert!(api() - .retrieve_current_user_request(WPContext::Embed) + assert!(request_builder() + .users() + .retrieve_me(WPContext::Embed) .execute() .await .unwrap() @@ -173,8 +182,9 @@ async fn retrieve_current_user_with_embed_context() { #[tokio::test] async fn retrieve_current_user_with_view_context() { - assert!(api() - .retrieve_current_user_request(WPContext::View) + assert!(request_builder() + .users() + .retrieve_me(WPContext::View) .execute() .await .unwrap() diff --git a/wp_api/tests/test_users_mut.rs b/wp_api/tests/test_users_mut.rs index 42cdbfcb0..9defc9293 100644 --- a/wp_api/tests/test_users_mut.rs +++ b/wp_api/tests/test_users_mut.rs @@ -2,7 +2,7 @@ use wp_api::users::{UserCreateParams, UserDeleteParams, UserUpdateParams}; use wp_db::{DbUser, DbUserMeta}; use crate::integration_test_common::{ - api, WPNetworkRequestExecutor, FIRST_USER_ID, SECOND_USER_ID, + request_builder, WPNetworkRequestExecutor, FIRST_USER_ID, SECOND_USER_ID, }; pub mod integration_test_common; @@ -21,8 +21,9 @@ async fn create_user() { email.to_string(), password.to_string(), ); - let created_user = api() - .create_user_request(¶ms) + let created_user = request_builder() + .users() + .create(¶ms) .execute() .await .unwrap() @@ -44,8 +45,9 @@ async fn delete_user() { let user_delete_params = UserDeleteParams { reassign: FIRST_USER_ID, }; - let user_delete_response = api() - .delete_user_request(SECOND_USER_ID, &user_delete_params) + let user_delete_response = request_builder() + .users() + .delete(SECOND_USER_ID, &user_delete_params) .execute() .await; assert!(user_delete_response.is_ok()); @@ -66,8 +68,9 @@ async fn delete_current_user() { let user_delete_params = UserDeleteParams { reassign: SECOND_USER_ID, }; - let deleted_user = api() - .delete_current_user_request(&user_delete_params) + let deleted_user = request_builder() + .users() + .delete_me(&user_delete_params) .execute() .await .unwrap() @@ -198,8 +201,9 @@ async fn update_user_roles() { roles: vec![new_role.to_string()], ..Default::default() }; - let user_update_response = api() - .update_user_request(FIRST_USER_ID, ¶ms) + let user_update_response = request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await; // It's quite tricky to validate the roles from DB, so we just ensure the request was @@ -217,8 +221,9 @@ async fn update_user_password() { password: Some(new_password.to_string()), ..Default::default() }; - let user_update_response = api() - .update_user_request(FIRST_USER_ID, ¶ms) + let user_update_response = request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await; // It's quite tricky to validate the password from DB, so we just ensure the request was @@ -233,8 +238,9 @@ where F: Fn(DbUser, Vec), { wp_db::run_and_restore(|mut db| async move { - let user_update_response = api() - .update_user_request(FIRST_USER_ID, ¶ms) + let user_update_response = request_builder() + .users() + .update(FIRST_USER_ID, ¶ms) .execute() .await; assert!(user_update_response.is_ok()); From c05161712357b609290b86b8b39e552a1f6b5777 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Mon, 27 May 2024 14:21:48 -0400 Subject: [PATCH 3/3] Update Swift layer to use WpApiRequestBuilder --- .../wordpress-api/Endpoints/Users.swift | 40 +++++++++---------- .../Sources/wordpress-api/Namespace.swift | 20 +++++----- .../Sources/wordpress-api/WordPressAPI.swift | 4 +- .../wordpress-api/WordPressAPITests.swift | 4 +- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/native/swift/Sources/wordpress-api/Endpoints/Users.swift b/native/swift/Sources/wordpress-api/Endpoints/Users.swift index abbdfcaf5..40f4ce133 100644 --- a/native/swift/Sources/wordpress-api/Endpoints/Users.swift +++ b/native/swift/Sources/wordpress-api/Endpoints/Users.swift @@ -7,24 +7,24 @@ extension SparseUser: Contextual { public typealias EditContext = UserWithEditContext public typealias EmbedContext = UserWithEmbedContext - public static func retrieveRequest(id: UserId, using helper: WpApiHelperProtocol, context: WpContext) -> WpNetworkRequest { - helper.retrieveUserRequest(userId: id, context: context) + public static func retrieveRequest(id: UserId, using requestBuilder: WpRequestBuilderProtocol, context: WpContext) -> WpNetworkRequest { + requestBuilder.users().retrieve(userId: id, context: context) } - public static func listRequest(params: UserListParams?, using helper: WpApiHelperProtocol, context: WpContext) -> WpNetworkRequest { - helper.listUsersRequest(context: context, params: params) + public static func listRequest(params: UserListParams?, using requestBuilder: WpRequestBuilderProtocol, context: WpContext) -> WpNetworkRequest { + requestBuilder.users().list(context: context, params: params) } - public static func updateRequest(id: UserId, params: UserUpdateParams, using helper: any WpApiHelperProtocol) -> WpNetworkRequest { - helper.updateUserRequest(userId: id, params: params) + public static func updateRequest(id: UserId, params: UserUpdateParams, using requestBuilder: any WpRequestBuilderProtocol) -> WpNetworkRequest { + requestBuilder.users().update(userId: id, params: params) } - public static func createRequest(params: UserCreateParams, using helper: any WpApiHelperProtocol) -> WpNetworkRequest { - helper.createUserRequest(params: params) + public static func createRequest(params: UserCreateParams, using requestBuilder: any WpRequestBuilderProtocol) -> WpNetworkRequest { + requestBuilder.users().create(params: params) } - public static func deleteRequest(id: ID, params: UserDeleteParams, using helper: WpApiHelperProtocol) -> WpNetworkRequest { - helper.deleteUserRequest(userId: id, params: params) + public static func deleteRequest(id: ID, params: UserDeleteParams, using requestBuilder: WpRequestBuilderProtocol) -> WpNetworkRequest { + requestBuilder.users().delete(userId: id, params: params) } public static func parseResponse(_ response: WpNetworkResponse) throws -> UserWithViewContext { @@ -63,8 +63,8 @@ extension WordPressAPI { } extension ContextualNamespace where T == SparseUser { - public func getCurrent() async throws -> R { - let request = self.api.helper.retrieveCurrentUserRequest(context: context) + public func getMe() async throws -> R { + let request = self.api.requestBuilder.users().retrieveMe(context: context) let response = try await api.perform(request: request) return try parseResponse(response) } @@ -78,14 +78,14 @@ extension AnyNamespace where T == SparseUser { try await self.delete(id: id, params: .init(reassign: userID)) } - public func deleteCurrent(reassignTo userID: T.ID) async throws -> T.DeleteResult { - let request = self.api.helper.deleteCurrentUserRequest(params: .init(reassign: userID)) + public func deleteMe(reassignTo userID: T.ID) async throws -> T.DeleteResult { + let request = self.api.requestBuilder.users().deleteMe(params: .init(reassign: userID)) let response = try await api.perform(request: request) return try T.parseDeletionResponse(response) } - public func updateCurrent(with params: UserUpdateParams) async throws -> T.EditContext { - let request = self.api.helper.updateCurrentUserRequest(params: params) + public func updateMe(with params: UserUpdateParams) async throws -> T.EditContext { + let request = self.api.requestBuilder.users().updateMe(params: params) let response = try await self.api.perform(request: request) return try parseRetrieveUserResponseWithEditContext(response: response) } @@ -99,19 +99,19 @@ extension AnyNamespace where T == SparseUser { extension ContextualNamespace where T == SparseUser { public func list(with params: T.ListParams, fields: [SparseUserField]) async throws -> [T] { - let request = api.helper.filterListUsersRequest(context: context, params: params, fields: fields) + let request = api.requestBuilder.users().filterList(context: context, params: params, fields: fields) let response = try await api.perform(request: request) return try parseFilterUsersResponse(response: response) } public func get(id: T.ID, fields: [SparseUserField]) async throws -> T { - let request = api.helper.filterRetrieveUserRequest(userId: id, context: context, fields: fields) + let request = api.requestBuilder.users().filterRetrieve(userId: id, context: context, fields: fields) let response = try await api.perform(request: request) return try parseFilterRetrieveUserResponse(response: response) } - public func getCurrent(fields: [SparseUserField]) async throws -> T { - let request = api.helper.filterRetrieveCurrentUserRequest(context: context, fields: fields) + public func getMe(fields: [SparseUserField]) async throws -> T { + let request = api.requestBuilder.users().filterRetrieveMe(context: context, fields: fields) let response = try await api.perform(request: request) return try parseFilterRetrieveUserResponse(response: response) } diff --git a/native/swift/Sources/wordpress-api/Namespace.swift b/native/swift/Sources/wordpress-api/Namespace.swift index 787e33f46..5b2d2a0b7 100644 --- a/native/swift/Sources/wordpress-api/Namespace.swift +++ b/native/swift/Sources/wordpress-api/Namespace.swift @@ -24,11 +24,11 @@ public protocol Contextual { associatedtype CreateParams associatedtype DeleteParams - static func retrieveRequest(id: ID, using helper: WpApiHelperProtocol, context: WpContext) -> WpNetworkRequest - static func listRequest(params: ListParams, using helper: WpApiHelperProtocol, context: WpContext) -> WpNetworkRequest - static func updateRequest(id: ID, params: UpdateParams, using helper: WpApiHelperProtocol) -> WpNetworkRequest - static func createRequest(params: CreateParams, using helper: WpApiHelperProtocol) -> WpNetworkRequest - static func deleteRequest(id: ID, params: DeleteParams, using helper: WpApiHelperProtocol) -> WpNetworkRequest + static func retrieveRequest(id: ID, using requestBuilder: WpRequestBuilderProtocol, context: WpContext) -> WpNetworkRequest + static func listRequest(params: ListParams, using requestBuilder: WpRequestBuilderProtocol, context: WpContext) -> WpNetworkRequest + static func updateRequest(id: ID, params: UpdateParams, using requestBuilder: WpRequestBuilderProtocol) -> WpNetworkRequest + static func createRequest(params: CreateParams, using requestBuilder: WpRequestBuilderProtocol) -> WpNetworkRequest + static func deleteRequest(id: ID, params: DeleteParams, using requestBuilder: WpRequestBuilderProtocol) -> WpNetworkRequest static func parseResponse(_ response: WpNetworkResponse) throws -> ViewContext static func parseResponse(_ response: WpNetworkResponse) throws -> EditContext @@ -108,13 +108,13 @@ public struct EmbedNamespace: ContextualNamespace { extension ContextualNamespace { public func get(id: T.ID) async throws -> R { - let request = T.retrieveRequest(id: id, using: api.helper, context: context) + let request = T.retrieveRequest(id: id, using: api.requestBuilder, context: context) let response = try await api.perform(request: request) return try parseResponse(response) } public func list(with params: T.ListParams) async throws -> [R] { - let request = T.listRequest(params: params, using: api.helper, context: context) + let request = T.listRequest(params: params, using: api.requestBuilder, context: context) let response = try await api.perform(request: request) return try parseResponse(response) } @@ -126,19 +126,19 @@ extension ContextualNamespace { extension AnyNamespace where T: Contextual { public func update(id: T.ID, with params: T.UpdateParams) async throws -> T.EditContext { - let request = T.updateRequest(id: id, params: params, using: api.helper) + let request = T.updateRequest(id: id, params: params, using: api.requestBuilder) let response = try await self.api.perform(request: request) return try T.parseResponse(response) } public func create(using params: T.CreateParams) async throws -> T.EditContext { - let request = T.createRequest(params: params, using: api.helper) + let request = T.createRequest(params: params, using: api.requestBuilder) let response = try await self.api.perform(request: request) return try T.parseResponse(response) } public func delete(id: T.ID, params: T.DeleteParams) async throws -> T.DeleteResult { - let request = T.deleteRequest(id: id, params: params, using: api.helper) + let request = T.deleteRequest(id: id, params: params, using: api.requestBuilder) let response = try await api.perform(request: request) return try T.parseDeletionResponse(response) } diff --git a/native/swift/Sources/wordpress-api/WordPressAPI.swift b/native/swift/Sources/wordpress-api/WordPressAPI.swift index d924b7bc6..64d7a8233 100644 --- a/native/swift/Sources/wordpress-api/WordPressAPI.swift +++ b/native/swift/Sources/wordpress-api/WordPressAPI.swift @@ -12,11 +12,11 @@ public struct WordPressAPI { } private let urlSession: URLSession - package let helper: WpApiHelperProtocol + package let requestBuilder: WpRequestBuilderProtocol public init(urlSession: URLSession, baseUrl: URL, authenticationStategy: WpAuthentication) { self.urlSession = urlSession - self.helper = WpApiHelper(siteUrl: baseUrl.absoluteString, authentication: authenticationStategy) + self.requestBuilder = WpRequestBuilder(siteUrl: baseUrl.absoluteString, authentication: authenticationStategy) } package func perform(request: WpNetworkRequest) async throws -> WpNetworkResponse { diff --git a/native/swift/Tests/wordpress-api/WordPressAPITests.swift b/native/swift/Tests/wordpress-api/WordPressAPITests.swift index 67fef3eb2..073510026 100644 --- a/native/swift/Tests/wordpress-api/WordPressAPITests.swift +++ b/native/swift/Tests/wordpress-api/WordPressAPITests.swift @@ -6,8 +6,8 @@ import WordPressAPIInternal final class WordPressAPITests: XCTestCase { func testExample() { - let request = WpApiHelper(siteUrl: "https://wordpress.org", authentication: .none) - .listUsersRequest(context: .view, params: nil) + let request = WpRequestBuilder(siteUrl: "https://wordpress.org", authentication: .none) + .users().list(context: .view, params: nil) XCTAssertTrue(request.url.hasPrefix("https://wordpress.org/wp-json/wp/v2/users")) } }