Testing selectors (#1047)

* add easy selectors to html testing

* add easy selectors to html testing

* fmt

* fix worker testing import

* update docs

Cargo.toml

@@ -33,7 +33,7 @@ default = [
 ]
 auth_jwt = ["dep:jsonwebtoken"]
 cli = ["dep:clap"]
-testing = ["dep:axum-test"]
+testing = ["dep:axum-test", "dep:scraper"]
 with-db = ["dep:sea-orm", "dep:sea-orm-migration", "loco-gen/with-db"]
 # Storage features
 all_storage = ["storage_aws_s3", "storage_azure", "storage_gcp"]
@@ -143,6 +143,8 @@ ulid = { version = "1", optional = true }
 rusty-sidekiq = { version = "0.11.0", default-features = false, optional = true }
 bb8 = { version = "0.8.1", optional = true }
 
+scraper = { version = "0.21.0", optional = true }
+
 [workspace.dependencies]
 
 chrono = { version = "0.4", features = ["serde"] }

docs-site/content/docs/infrastructure/storage.md

@@ -190,10 +190,12 @@ async fn upload_file(
 By testing file storage in your controller you can follow this example:
 
 ```rust
+use loco_rs::testing::prelude::*;
+
 #[tokio::test]
 #[serial]
 async fn can_register() {
-    testing::request::<App, _, _>(|request, ctx| async move {
+    request::<App, _, _>(|request, ctx| async move {
         let file_content = "loco file upload";
         let file_part = Part::bytes(file_content.as_bytes()).file_name("loco.txt");
 

docs-site/content/docs/processing/mailers.md

@@ -218,18 +218,19 @@ Test Description:
 - Retrieve the mailer instance from the context and call the deliveries() function, which contains information about the number of sent emails and their content.
 
 ```rust
+use loco_rs::testing::prelude::*;
 
 #[tokio::test]
 #[serial]
 async fn can_register() {
     configure_insta!();
 
-    testing::request::<App, Migrator, _, _>(|request, ctx| async move {
+    request::<App, Migrator, _, _>(|request, ctx| async move {
         // Create a request for user registration.
 
         // Now you can call the context mailer and use the deliveries function.
         with_settings!({
-            filters => testing::cleanup_email()
+            filters => cleanup_email()
         }, {
             assert_debug_snapshot!(ctx.mailer.unwrap().deliveries());
         });

docs-site/content/docs/processing/workers.md

@@ -199,11 +199,13 @@ Here's an example of how the test should be structured:
 
 
 ```rust
+use loco_rs::testing::prelude::*;
+
 #[tokio::test]
 #[serial]
 async fn test_run_report_worker_worker() {
     // Set up the test environment
-    let boot = testing::boot_test::<App, Migrator>().await.unwrap();
+    let boot = boot_test::<App, Migrator>().await.unwrap();
 
     // Execute the worker in 'ForegroundBlocking' mode, preventing it from running asynchronously
     assert!(

docs-site/content/docs/the-app/controller.md

@@ -858,18 +858,19 @@ impl PaginationResponse {
 # Testing 
 When testing controllers, the goal is to call the router's controller endpoint and verify the HTTP response, including the status code, response content, headers, and more.
 
-To initialize a test request, use `testing::request`, which prepares your app routers, providing the request instance and the application context.
+To initialize a test request, use `use loco_rs::testing::prelude::*;`, which prepares your app routers, providing the request instance and the application context.
 
 In the following example, we have a POST endpoint that returns the data sent in the POST request.
 
 ```rust
+use loco_rs::testing::prelude::*;
 
 #[tokio::test]
 #[serial]
 async fn can_print_echo() {
     configure_insta!();
 
-    testing::request::<App, _, _>(|request, _ctx| async move {
+    request::<App, _, _>(|request, _ctx| async move {
         let response = request
             .post("/example")
             .json(&serde_json::json!({"site": "Loco"}))

docs-site/content/docs/the-app/models.md

@@ -572,12 +572,14 @@ impl Task for SeedData {
 2. In your test section, follow the example below:
 
 ```rust
+use loco_rs::testing::prelude::*;
+
 #[tokio::test]
 #[serial]
 async fn handle_create_with_password_with_duplicate() {
 
-    let boot = testing::boot_test::<App, Migrator>().await;
-    testing::seed::<App>(&boot.app_context.db).await.unwrap();
+    let boot = boot_test::<App, Migrator>().await;
+    seed::<App>(&boot.app_context.db).await.unwrap();
     assert!(get_user_by_id(1).ok());
 }
 ```
@@ -695,11 +697,13 @@ If you used the generator to crate a model migration, you should also have an au
 A typical test contains everything you need to set up test data, boot the app, and reset the database automatically before the testing code runs. It looks like this:
 
 ```rust
+use loco_rs::testing::prelude::*;
+
 async fn can_find_by_pid() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App, Migrator>().await;
-    testing::seed::<App>(&boot.app_context.db).await.unwrap();
+    let boot = boot_test::<App, Migrator>().await;
+    seed::<App>(&boot.app_context.db).await.unwrap();
 
     let existing_user =
         Model::find_by_pid(&boot.app_context.db, "11111111-1111-1111-1111-111111111111").await;
@@ -747,13 +751,15 @@ impl Hooks for App {
 ## Seeding
 
 ```rust
+use loco_rs::testing::prelude::*;
+
 #[tokio::test]
 #[serial]
 async fn is_user_exists() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App, Migrator>().await;
-    testing::seed::<App>(&boot.app_context.db).await.unwrap();
+    let boot = boot_test::<App, Migrator>().await;
+    seed::<App>(&boot.app_context.db).await.unwrap();
     assert!(get_user_by_id(1).ok());
 
 }
@@ -770,14 +776,15 @@ Example using [insta](https://crates.io/crates/insta) for snapshots.
 in the following example you can use `cleanup_user_model` which clean all user model data.
 
 ```rust
+use loco_rs::testing::prelude::*;
 
 #[tokio::test]
 #[serial]
 async fn can_create_user() {
-    testing::request::<App, Migrator, _, _>(|request, _ctx| async move {
+    request::<App, Migrator, _, _>(|request, _ctx| async move {
         // create user test
         with_settings!({
-            filters => testing::cleanup_user_model()
+            filters => cleanup_user_model()
         }, {
             assert_debug_snapshot!(current_user_request.text());
         });

examples/demo/src/models/roles.rs

@@ -1,5 +1,4 @@
 use loco_rs::prelude::*;
-use sea_orm::entity::prelude::*;
 
 pub use super::_entities::roles::{self, ActiveModel, Entity, Model};
 use crate::models::{_entities::sea_orm_active_enums::RolesName, users, users_roles};

examples/demo/tests/models/roles.rs

@@ -1,9 +1,8 @@
 use demo_app::{
     app::App,
-    models::{roles, sea_orm_active_enums, users, users::RegisterParams, users_roles},
+    models::{roles, sea_orm_active_enums, users, users::RegisterParams},
 };
-use loco_rs::{prelude::*, testing};
-use sea_orm::DatabaseConnection;
+use loco_rs::testing::prelude::*;
 use serial_test::serial;
 
 macro_rules! configure_insta {
@@ -20,17 +19,17 @@ macro_rules! configure_insta {
 async fn can_add_user_to_admin() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App>().await.unwrap();
-    let new_user: Result<users::Model, ModelError> = users::Model::create_with_password(
+    let boot = boot_test::<App>().await.unwrap();
+    let new_user = users::Model::create_with_password(
         &boot.app_context.db,
         &RegisterParams {
             email: "[email protected]".to_string(),
             password: "1234".to_string(),
             name: "framework".to_string(),
         },
     )
-    .await;
-    let new_user = new_user.unwrap();
+    .await
+    .unwrap();
     let role = roles::Model::add_user_to_admin_role(&boot.app_context.db, &new_user)
         .await
         .unwrap();
@@ -42,17 +41,17 @@ async fn can_add_user_to_admin() {
 async fn can_add_user_to_user() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App>().await.unwrap();
-    let new_user: Result<users::Model, ModelError> = users::Model::create_with_password(
+    let boot = boot_test::<App>().await.unwrap();
+    let new_user = users::Model::create_with_password(
         &boot.app_context.db,
         &RegisterParams {
             email: "[email protected]".to_string(),
             password: "1234".to_string(),
             name: "framework".to_string(),
         },
     )
-    .await;
-    let new_user = new_user.unwrap();
+    .await
+    .unwrap();
     let role = roles::Model::add_user_to_user_role(&boot.app_context.db, &new_user)
         .await
         .unwrap();
@@ -64,17 +63,17 @@ async fn can_add_user_to_user() {
 async fn can_convert_between_user_and_admin() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App>().await.unwrap();
-    let new_user: Result<users::Model, ModelError> = users::Model::create_with_password(
+    let boot = boot_test::<App>().await.unwrap();
+    let new_user = users::Model::create_with_password(
         &boot.app_context.db,
         &RegisterParams {
             email: "[email protected]".to_string(),
             password: "1234".to_string(),
             name: "framework".to_string(),
         },
     )
-    .await;
-    let new_user = new_user.unwrap();
+    .await
+    .unwrap();
     let role = roles::Model::add_user_to_user_role(&boot.app_context.db, &new_user)
         .await
         .unwrap();
@@ -94,17 +93,17 @@ async fn can_convert_between_user_and_admin() {
 async fn can_find_user_roles() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App>().await.unwrap();
-    let new_user: Result<users::Model, ModelError> = users::Model::create_with_password(
+    let boot = boot_test::<App>().await.unwrap();
+    let new_user = users::Model::create_with_password(
         &boot.app_context.db,
         &RegisterParams {
             email: "[email protected]".to_string(),
             password: "1234".to_string(),
             name: "framework".to_string(),
         },
     )
-    .await;
-    let new_user = new_user.unwrap();
+    .await
+    .unwrap();
     let role = roles::Model::add_user_to_user_role(&boot.app_context.db, &new_user)
         .await
         .unwrap();
@@ -131,17 +130,17 @@ async fn can_find_user_roles() {
 async fn cannot_find_user_before_conversation() {
     configure_insta!();
 
-    let boot = testing::boot_test::<App>().await.unwrap();
-    let new_user: Result<users::Model, ModelError> = users::Model::create_with_password(
+    let boot = boot_test::<App>().await.unwrap();
+    let new_user = users::Model::create_with_password(
         &boot.app_context.db,
         &RegisterParams {
             email: "[email protected]".to_string(),
             password: "1234".to_string(),
             name: "framework".to_string(),
         },
     )
-    .await;
-    let new_user = new_user.unwrap();
+    .await
+    .unwrap();
     let role = roles::Model::find_by_user(&boot.app_context.db, &new_user).await;
     assert!(role.is_err());
 }