Add markers

Author: NayeemJohnY

.github/workflows/test-execution.yml

@@ -7,6 +7,17 @@ on:
         description: Run Tests in Parallel
         default: false
 
+      test_name:
+        description: Test File / Test Class / Test function Name
+        required: false
+        type: string
+
+      test_group:
+        description: Test Group (e.g., smoke,regression or smoke)
+        required: false
+        type: string
+
+
 permissions:
   id-token: write
   contents: read
@@ -47,11 +58,22 @@ jobs:
 
       - name: Execute Test
         run: |
-          if [ "${{ github.event.inputs.parallel }}" = "true" ]; then
-            pytest -n 5 --dist loadfile
-          else
-            pytest
-          fi 
+          EXTRA_PARAMS=""
+      
+          if ${{ inputs.parallel }} ; then
+            EXTRA_PARAMS+=" -n 5 --dist loadfile";
+          fi
+
+          if [ "${{ inputs.test_name }}" != "" ]; then
+            EXTRA_PARAMS+=' -k ${{ inputs.test_name }}';
+          fi
+
+          if [ "${{ inputs.test_group }}" != "" ]; then
+            EXTRA_PARAMS+=' -m ${{ inputs.test_group }}';
+          fi
+
+          echo "Running with: pytest ${EXTRA_PARAMS}"
+          pytest ${EXTRA_PARAMS}
 
       - name: Stop Book NodeJS App
         if: always()

README.md

@@ -111,6 +111,74 @@ class TestCreateBook(BaseTest):
         validator.validate_response_book(response, book)
 ```
 
+## Parallel Test Execution
+
+This framework supports parallel test execution using pytest-xdist for faster test runs:
+
+### Basic Parallel Execution
+```bash
+# Run tests in parallel with verbose output
+pytest -n auto --dist loadfile -v
+```
+
+### Parallel Execution Modes
+- **`--dist loadfile`**: All tests in a file run sequentially, files run in parallel (recommended)
+- **`--dist loadscope`**: Tests grouped by scope (class/module) run together
+- **`--dist worksteal`**: Dynamic work distribution (fastest but less predictable)
+
+### Parallel Safety Features
+- **Unique Test Data**: Test data is made unique per worker to avoid collisions
+- **Worker-Safe Fixtures**: API client and test setup fixtures are worker-safe
+- **Isolated Test Runs**: Each worker operates independently with separate test data
+
+
+## Pytest Markers
+
+This project uses pytest markers to organize and categorize tests for flexible execution:
+
+### Available Markers
+- **smoke**: Quick smoke tests for core functionality
+- **regression**: Comprehensive regression tests for business logic
+- **negative**: Error handling and negative scenario tests
+
+### Usage Examples
+
+Run only regression tests:
+```bash
+pytest -m regression
+```
+
+Run both smoke and regression tests:
+```bash
+pytest -m "smoke or regression"
+```
+Run regression tests but exclude negative scenarios:
+```bash
+pytest -m "regression and not negative"
+```
+Run smoke tests in parallel:
+```bash
+pytest -m smoke -n auto --dist loadfile
+```
+
+
+### Marker Usage in Tests
+Each test function is decorated with appropriate markers:
+```python
+@pytest.mark.smoke
+@pytest.mark.regression
+@allure.title("Should create book successfully")
+def test_should_create_book_successfully(self):
+    # Test implementation
+```
+
+### Test Organization by Marker
+- **Smoke Tests**: Core functionality validation (create, get, update, delete basic scenarios)
+- **Regression Tests**: Complex business scenarios, pagination, search functionality, edge cases
+- **Negative Tests**: Error handling, invalid authentication, resource not found scenarios
+
+This marker system enables flexible test execution strategies, from quick smoke tests during development to comprehensive regression testing in CI/CD pipelines.
+
 ## Troubleshooting
 - **Connection errors**: Ensure the Book API server is running at the correct URL.
 - **Parallel test issues**: Make sure test data is unique per worker or run tests serially.

github-pages/index.html

@@ -54,6 +54,7 @@ <h2><i class="fas fa-rocket"></i> Quick Start</h2>
                     <li>Start your Book API server:<br><code>http://localhost:3000</code></li>
                     <li>Run all tests:<br><code>pytest</code></li>
                     <li>Run tests in parallel:<br><code>pytest -n auto --dist loadfile</code></li>
+                    <li>Run smoke tests quickly:<br><code>pytest -m smoke -n auto --dist loadfile</code></li>
                     <li>Generate Allure report:<br><code>allure serve test-results/allure-results</code></li>
                     <li>To generate a static Allure HTML report:<br><code>allure generate test-results/allure-results --clean -o test-results/allure-report</code></li>
                 </ol>
@@ -81,6 +82,23 @@ <h2><i class="fas fa-tools"></i> Tech Stack</h2>
                     <li><strong>pytest-xdist</strong> - Parallel test execution</li>
                 </ul>
             </div>
+
+            <div class="card">
+                <h2><i class="fas fa-tags"></i> Pytest Markers</h2>
+                <ul>
+                    <li><strong>smoke</strong>: Quick smoke tests for core functionality</li>
+                    <li><strong>regression</strong>: Comprehensive regression tests for business logic</li>
+                    <li><strong>negative</strong>: Error handling and negative scenario tests</li>
+                </ul>
+                <p><strong>Run specific test types:</strong></p>
+                <code>pytest -m regression</code><br>
+                <p><strong>Combine markers for flexible execution:</strong></p>
+                <code>pytest -m "smoke or regression"</code><br>
+                <code>pytest -m "regression and not negative"</code><br>
+                <p><strong>Parallel execution with markers:</strong></p>
+                <code>pytest -m smoke -n auto --dist loadfile</code><br>
+            </div>
+            </div>
         </div>
 
         <footer class="footer">

pytest.ini

@@ -4,6 +4,9 @@ filterwarnings =
 
 markers =
     description: Adds a description to the test for documentation or reporting
+    smoke: Quick smoke tests for core functionality
+    regression: Comprehensive regression tests for business logic
+    negative: Error handling and negative scenario tests
 
 addopts = -v -s --html=test-results/report.html --self-contained-html --alluredir=test-results/allure-results
 testpaths = tests

tests/test_create_book.py

@@ -29,6 +29,8 @@ def create_and_validate_book(
             validator.validate_error_message(response, expected_message)
         return response
 
+    @pytest.mark.smoke
+    @pytest.mark.regression
     @allure.title("Should create book when title and author are valid")
     def test_should_create_book_when_title_and_author_are_valid(self):
         """Test creating a book with valid title and author."""
@@ -38,6 +40,8 @@ def test_should_create_book_when_title_and_author_are_valid(self):
         }
         self.create_and_validate_book(book)
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should reject duplicate book creation")
     def test_should_reject_duplicate_book_creation(self):
         """Test duplicate book creation returns 409."""
@@ -51,6 +55,7 @@ def test_should_reject_duplicate_book_creation(self):
             expected_message="A book with the same title and author already exists",
         )
 
+    @pytest.mark.regression
     @allure.title("Should create book when title is different for same author")
     def test_should_create_book_when_title_is_different_for_same_author(self):
         """Test creating a book with a different title for the same author."""
@@ -60,6 +65,7 @@ def test_should_create_book_when_title_is_different_for_same_author(self):
         }
         self.create_and_validate_book(book)
 
+    @pytest.mark.regression
     @allure.title("Should create book when author is different for same book")
     def test_should_create_book_when_author_is_different_for_same_book(self):
         """Test creating a book with a different author for the same title."""
@@ -69,6 +75,8 @@ def test_should_create_book_when_author_is_different_for_same_book(self):
         }
         self.create_and_validate_book(book)
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should return 401 when no auth token provided")
     def test_should_return_401_when_no_auth_token_provided(self):
         """Test creating a book without authentication returns 401."""
@@ -77,6 +85,8 @@ def test_should_return_401_when_no_auth_token_provided(self):
         validator.validate_status_code(response, 401)
         validator.validate_error_message(response, "Unauthorized. No token provided.")
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @pytest.mark.parametrize(
         "payload,expected_message",
         [
@@ -92,6 +102,8 @@ def test_should_reject_book_with_missing_fields(self, payload, expected_message)
             payload, expected_status=400, expected_message=expected_message
         )
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should reject book creation with client-provided ID")
     def test_should_reject_book_creation_with_client_provided_id(self):
         """Test creating a book with a client-provided ID returns 400."""

tests/test_delete_book.py

@@ -30,13 +30,17 @@ def test_create_book_before_delete_book_test(self, init_api_client):
         validator.validate_response_book(response, book)
         self.__class__.book_id = response.json()["id"]
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should return 401 when no auth token provided on delete")
     def test_should_return_401_when_no_auth_token_provided_on_delete(self):
         """Test deleting a book without authentication returns 401."""
         response = self.client.delete(self.client.build_url(f"/{self.book_id}"))
         validator.validate_status_code(response, 401)
         validator.validate_error_message(response, "Unauthorized. No token provided.")
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should return 403 when user auth token is provided on delete")
     def test_should_return_403_when_user_auth_token_is_provided_on_delete(self):
         """Test deleting a book with a user token returns 403."""
@@ -46,6 +50,8 @@ def test_should_return_403_when_user_auth_token_is_provided_on_delete(self):
         validator.validate_status_code(response, 403)
         validator.validate_error_message(response, "Forbidden. Admin access required.")
 
+    @pytest.mark.smoke
+    @pytest.mark.regression
     @pytest.mark.dependency(name="delete_valid_book")
     @allure.title("Should delete book when book ID is valid")
     def test_should_delete_book_when_book_id_is_valid(self):
@@ -55,6 +61,8 @@ def test_should_delete_book_when_book_id_is_valid(self):
         )
         validator.validate_status_code(response, 204)
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @pytest.mark.dependency(depends=["delete_valid_book"])
     @allure.title("Should return 404 when book is already deleted or does not exist")
     def test_should_return_404_when_book_is_already_deleted_or_not_exists(self):

tests/test_get_book.py

@@ -50,6 +50,8 @@ def create_book_before_test(self, init_api_client, get_books):
             validator.validate_status_code(response, 201)
             validator.validate_response_book(response, book)
 
+    @pytest.mark.smoke
+    @pytest.mark.regression
     @allure.title("Should return books for default page 1")
     def test_should_return_books_for_default_page1(self):
         """Test Should return Book For Default page 1"""
@@ -59,6 +61,7 @@ def test_should_return_books_for_default_page1(self):
             len(response.json()) >= 10, "Number Of Books should greater or equal to 10"
         )
 
+    @pytest.mark.regression
     @allure.title("Should return books by page number")
     def test_should_return_books_by_page_number(self):
         """Test Should return book by page number"""
@@ -69,6 +72,7 @@ def test_should_return_books_by_page_number(self):
             "Page 2 Book ids should greater than 10",
         )
 
+    @pytest.mark.regression
     @pytest.mark.parametrize(
         "params,expected_count,message",
         [
@@ -85,6 +89,8 @@ def test_pagination_cases(self, params, expected_count, message):
         validator.validate_status_code(response, 200)
         validator.assert_true(len(response.json()) == expected_count, message)
 
+    @pytest.mark.regression
+    @pytest.mark.negative
     @allure.title("Should return books excluding last limit on negative limit")
     def test_should_return_books_excluding_last_limit_on_negative_limit(self):
         """Test Should return book exlcuding last limit on negative limit"""
@@ -94,27 +100,34 @@ def test_should_return_books_excluding_last_limit_on_negative_limit(self):
             len(response.json()) != 0, "Books size with negative limt should be 0"
         )
 
+    @pytest.mark.smoke
+    @pytest.mark.regression
     @allure.title("Should return single book by ID")
     def test_should_return_single_book_by_id(self):
         """Test Should return Single Book by ID"""
         response = self.client.get(self.client.build_url("/10"))
         validator.validate_status_code(response, 200)
         validator.assert_equals(response.json()["id"], 10, "Retrieve Book by book ID")
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should not return book when book ID is invalid string")
     def test_should_not_return_book_when_book_id_is_invalid_string(self):
         """Test should not return book when Book Id is invalid String"""
         response = self.client.get(self.client.build_url("/invalid-string"))
         validator.validate_status_code(response, 404)
         validator.validate_error_message(response, "Book not found")
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @allure.title("Should not return book when book ID does not exist")
     def test_should_not_return_book_when_book_id_not_exists(self):
         """Test Should not return book when book id not exists"""
         response = self.client.get(self.client.build_url("/999999"))
         validator.validate_status_code(response, 404)
         validator.validate_error_message(response, "Book not found")
 
+    @pytest.mark.regression
     @allure.title("Should return all books when book ID is empty")
     def test_should_return_all_books_when_book_id_is_empty(self):
         """Test should return all books when book id is empty"""
@@ -124,6 +137,7 @@ def test_should_return_all_books_when_book_id_is_empty(self):
             len(response.json()) >= 10, "Number Of Books should greater or equal to 10"
         )
 
+    @pytest.mark.regression
     @allure.title("Should return books containing author")
     def test_should_return_books_contains_author(self):
         """Test should return book contains author"""
@@ -133,6 +147,7 @@ def test_should_return_books_contains_author(self):
         )
         self.assert_search_results(response, author="Book Author")
 
+    @pytest.mark.regression
     @allure.title("Should return books containing title")
     def test_should_return_books_contains_title(self):
         """Test should return book contains title"""
@@ -141,6 +156,7 @@ def test_should_return_books_contains_title(self):
         )
         self.assert_search_results(response, title="Book Title")
 
+    @pytest.mark.regression
     @allure.title("Should return books containing title and author")
     def test_should_return_books_contains_title_and_author(self):
         """Test should return book contains title and author"""
@@ -150,6 +166,7 @@ def test_should_return_books_contains_title_and_author(self):
         )
         self.assert_search_results(response, title="Book Title", author="book author")
 
+    @pytest.mark.regression
     @allure.title("Should return single book with title and author")
     def test_should_return_single_book_with_title_and_author(self):
         """Test should return single book for author and title"""
@@ -161,6 +178,8 @@ def test_should_return_single_book_with_title_and_author(self):
             response, title="Book Title 7", author="book author 7"
         )
 
+    @pytest.mark.negative
+    @pytest.mark.regression
     @pytest.mark.parametrize(
         "params,status_code,expected_message",
         [