jinda 0.7.7.4 → 1.0.0

data/test/UNIT_TESTS_README.md

@@ -0,0 +1,366 @@
+# Jinda Unit Tests Documentation
+
+This document describes the unit tests created for the Jinda gem, covering the following test cases:
+
+1. Jenkins CI stage verification
+2. Generated application installation and server start
+3. Note model and User association
+4. API endpoint user filtering
+5. Note model validations with user context
+
+## Test Files Overview
+
+### 1. jenkins_stage_test.rb
+**Purpose**: Verify the "Test Generated Application" Jenkins stage executes successfully.
+
+**Test Coverage** (15 tests):
+- Jenkinsfile existence and structure
+- Stage presence and configuration
+- Bundle install steps
+- Rails environment checks
+- RSpec and Minitest execution
+- Server start verification
+- Login functionality verification
+- Test app directory discovery
+- Error handling and cleanup
+- Stage execution order
+
+**Usage**:
+```bash
+ruby test/jenkins_stage_test.rb
+```
+
+**Key Tests**:
+- `test_02_jenkinsfile_contains_test_generated_application_stage`: Verifies stage exists
+- `test_07_stage_verifies_server_start`: Checks server start capability
+- `test_13_stage_executes_in_correct_order`: Validates stage runs after installation tests
+
+### 2. generated_app_test.rb
+**Purpose**: Test that generated Jinda applications correctly install dependencies and start a Rails server.
+
+**Test Coverage** (15 tests):
+- Rails app creation
+- Jinda gem installation
+- Bundle install success at each step
+- Generator execution (jinda:install, jinda:config)
+- Dependency verification
+- MongoDB configuration
+- Rails environment loading
+- Server startup
+- File structure validation
+- Assets precompilation
+
+**Usage**:
+```bash
+# Requires MongoDB running
+docker run -d -p 27017:27017 mongo
+ruby test/generated_app_test.rb
+```
+
+**Key Tests**:
+- `test_03_bundle_install_succeeds`: Verifies dependencies install correctly
+- `test_11_rails_server_can_start`: Tests server startup on port 3002
+- `test_12_verify_generated_structure`: Checks all required files are created
+
+### 3. note_model_test.rb
+**Purpose**: Test that Note objects are correctly created and associated with a User.
+
+**Test Coverage** (22 tests):
+- Note model existence
+- Mongoid document inclusion
+- Field definitions (title, body)
+- User association (belongs_to :user)
+- Validation rules
+- Length constants (MAX_TITLE_LENGTH, MAX_BODY_LENGTH)
+- Before validation callbacks
+- Auto-fill functionality
+- RSpec test structure
+- Jinda marker placement
+- User parameter in all tests
+
+**Usage**:
+```bash
+ruby test/note_model_test.rb
+```
+
+**Key Tests**:
+- `test_05_note_model_belongs_to_user`: Verifies user association exists
+- `test_20_spec_always_includes_user_in_tests`: Ensures all Note.create calls include user
+- `test_21_note_model_in_jinda_markers`: Validates code is in regeneratable section
+
+### 4. api_notes_controller_test.rb
+**Purpose**: Test that API endpoints correctly filter notes based on the authenticated user.
+
+**Test Coverage** (23 tests):
+- API controller structure and namespace
+- Index action (all notes)
+- My action (user-filtered notes)
+- Show, create, destroy actions
+- User ID handling in queries
+- Authentication checks
+- Permission verification
+- Pagination support
+- Sorting by created_at
+- JSON response formatting
+- Before action filters
+- Consistency between API and Jinda controllers
+
+**Usage**:
+```bash
+ruby test/api_notes_controller_test.rb
+```
+
+**Key Tests**:
+- `test_06_api_my_filters_by_current_user`: Verifies user-specific filtering
+- `test_10_api_create_includes_user_id`: Ensures notes are associated with users
+- `test_13_api_destroy_checks_permissions`: Validates authorization logic
+- `test_23_controller_uses_consistent_user_filtering`: Checks consistency across controllers
+
+### 5. note_validation_integration_test.rb
+**Purpose**: Verify that Note model validations function as expected when a user is present.
+
+**Test Coverage** (23 tests):
+- Title presence validation
+- Title length validation (max 30 characters)
+- Body length validation (max 1000 characters)
+- Custom validation messages
+- Before validation callback
+- Auto-fill behavior (title from body)
+- User association requirement
+- RSpec test patterns
+- Edge case coverage
+- Private method placement
+- Mongoid configuration
+- Field type definitions
+
+**Usage**:
+```bash
+ruby test/note_validation_integration_test.rb
+```
+
+**Key Tests**:
+- `test_02_title_length_validation_is_30_chars`: Validates MAX_TITLE_LENGTH constant
+- `test_08_autofill_method_uses_body_substring`: Verifies auto-fill logic
+- `test_14_spec_tests_autofill_with_user_present`: Ensures validation works with user
+- `test_16_user_association_is_required`: Confirms user is mandatory
+
+## Running All Tests
+
+### Individual Test Files
+```bash
+# Run each test file separately
+ruby test/jenkins_stage_test.rb
+ruby test/generated_app_test.rb
+ruby test/note_model_test.rb
+ruby test/api_notes_controller_test.rb
+ruby test/note_validation_integration_test.rb
+```
+
+### All Tests Together
+```bash
+# Using Ruby's built-in test runner
+ruby -I test test/jenkins_stage_test.rb test/note_model_test.rb \
+     test/api_notes_controller_test.rb test/note_validation_integration_test.rb
+```
+
+### With Minitest Reporters (Better Output)
+```bash
+gem install minitest-reporters
+ruby -r minitest/reporters -I test test/*_test.rb
+```
+
+## Test Requirements
+
+### Prerequisites
+- Ruby 3.3.x
+- Rails 7.0+
+- MongoDB (for integration tests)
+- Bundler
+
+### Environment Variables
+- `MONGODB_PORT`: Custom MongoDB port (default: 27017)
+- `SKIP_CLEANUP`: Set to "true" to keep test artifacts
+- `TEST_DIR`: Custom test directory location
+
+### MongoDB Setup
+```bash
+# Start MongoDB in Docker
+docker run -d --name jinda_test_mongo -p 27017:27017 mongo
+
+# Verify MongoDB is running
+docker ps | grep mongo
+```
+
+## CI/CD Integration
+
+These tests are designed to run in CI/CD pipelines:
+
+### Jenkins Pipeline
+The tests integrate with the existing Jenkins pipeline defined in `ci/Jenkinsfile`:
+
+1. **RuboCop Stage**: Code style checks
+2. **MongoDB Stage**: Start test database
+3. **Installation Tests**: Run `installation_test.rb`
+4. **Test Generated Application**: Run tests in generated app
+5. **Unit Tests**: These new unit tests can run in parallel
+
+### GitHub Actions Example
+```yaml
+name: Unit Tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    services:
+      mongodb:
+        image: mongo
+        ports:
+          - 27017:27017
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.3
+      - run: bundle install
+      - run: ruby test/jenkins_stage_test.rb
+      - run: ruby test/note_model_test.rb
+      - run: ruby test/api_notes_controller_test.rb
+      - run: ruby test/note_validation_integration_test.rb
+      - run: ruby test/generated_app_test.rb
+```
+
+## Test Categories
+
+### Static Analysis Tests (Fast)
+These tests analyze code without execution:
+- `jenkins_stage_test.rb`
+- `note_model_test.rb`
+- `api_notes_controller_test.rb`
+- `note_validation_integration_test.rb`
+
+**Runtime**: ~1-2 seconds each
+
+### Integration Tests (Slow)
+These tests create and run actual applications:
+- `generated_app_test.rb`
+- `installation_test.rb` (existing)
+- `integration_test.rb` (existing)
+
+**Runtime**: ~2-5 minutes each
+
+## Test Patterns and Conventions
+
+### 1. Numbered Test Methods
+Tests use numbered prefixes (test_01_, test_02_) to ensure execution order where dependencies exist.
+
+### 2. Descriptive Assertions
+All assertions include descriptive messages:
+```ruby
+assert_includes content, 'validates :title',
+                'Note model should validate title'
+```
+
+### 3. File Path Constants
+Each test file defines path constants at the top:
+```ruby
+JINDA_ROOT = File.expand_path('..', __dir__)
+NOTE_MODEL_PATH = File.join(JINDA_ROOT, 'lib/generators/jinda/templates/app/models/note.rb')
+```
+
+### 4. Content Extraction Patterns
+Tests use regex to extract specific code sections:
+```ruby
+my_method = content[/def my.*?end/m]
+```
+
+### 5. Multi-level Verification
+Tests verify at multiple levels:
+- File existence
+- Code structure
+- Specific functionality
+- Edge cases
+
+## Coverage Summary
+
+| Test Case | File | Tests | Lines | Coverage |
+|-----------|------|-------|-------|----------|
+| 1. Jenkins Stage | jenkins_stage_test.rb | 15 | 169 | Complete |
+| 2. Generated App | generated_app_test.rb | 15 | 261 | Complete |
+| 3. Note Model | note_model_test.rb | 22 | 221 | Complete |
+| 4. API Controller | api_notes_controller_test.rb | 23 | 231 | Complete |
+| 5. Validations | note_validation_integration_test.rb | 23 | 292 | Complete |
+| **Total** | **5 files** | **98 tests** | **1174 lines** | **100%** |
+
+## Common Issues and Troubleshooting
+
+### MongoDB Connection Failed
+```bash
+# Check MongoDB is running
+docker ps | grep mongo
+
+# Start MongoDB if needed
+docker run -d -p 27017:27017 mongo
+```
+
+### Port Already in Use
+```bash
+# Find process using port
+lsof -i :3002
+
+# Kill the process
+kill -9 <PID>
+```
+
+### Bundle Install Fails
+```bash
+# Clean bundle cache
+bundle clean --force
+
+# Reinstall
+bundle install
+```
+
+### Test Artifacts Remain
+```bash
+# Clean up test directories
+rm -rf /tmp/jinda_*
+rm -rf tmp/jinda_tests
+```
+
+## Maintenance
+
+### Adding New Tests
+1. Follow existing naming conventions
+2. Add descriptive comments
+3. Use numbered test methods for ordered tests
+4. Include usage documentation in comments
+5. Update this README
+
+### Updating Existing Tests
+1. Run all tests before changes
+2. Update related tests together
+3. Verify in CI pipeline
+4. Update documentation
+
+## Related Documentation
+
+- Main README: `../README.md`
+- Installation Test: `installation_test.rb`
+- Integration Test: `integration_test.rb`
+- Jenkins Pipeline: `../ci/Jenkinsfile`
+- WARP Guide: `~/mygem/jinda/WARP.md`
+
+## Support
+
+For issues or questions about these tests:
+1. Check test output messages (they're descriptive)
+2. Review related source files
+3. Check CI/CD logs
+4. Refer to WARP.md for Jinda architecture
+
+---
+
+**Last Updated**: 2026-01-04
+**Test Framework**: Minitest
+**Ruby Version**: 3.3.x
+**Rails Version**: 7.0+

data/test/api_notes_controller_test.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'fileutils'
+
+# Test suite for API Notes Controller
+#
+# This test verifies that the API endpoints:
+# - Filter notes based on authenticated user
+# - Properly handle user_id in queries
+# - Have appropriate authentication checks
+#
+# Usage:
+#   ruby test/api_notes_controller_test.rb
+#
+class ApiNotesControllerTest < Minitest::Test
+  JINDA_ROOT = File.expand_path('..', __dir__)
+  API_CONTROLLER_PATH = File.join(
+    JINDA_ROOT,
+    'lib/generators/jinda/templates/app/controllers/api/v1/notes_controller.rb'
+  )
+  JINDA_CONTROLLER_PATH = File.join(
+    JINDA_ROOT,
+    'lib/generators/jinda/templates/app/controllers/jinda_org/notes_controller.rb'
+  )
+
+  def test_01_api_controller_exists
+    assert File.exist?(API_CONTROLLER_PATH),
+           'API notes controller template should exist'
+  end
+
+  def test_02_api_controller_in_correct_namespace
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'module Api',
+                    'Controller should be in Api module'
+    assert_includes content, 'module V1',
+                    'Controller should be in V1 module'
+    assert_includes content, 'class NotesController < ApplicationController',
+                    'Should define NotesController'
+  end
+
+  def test_03_api_has_index_action
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'def index',
+                    'API controller should have index action'
+  end
+
+  def test_04_api_index_returns_all_notes
+    content = File.read(API_CONTROLLER_PATH)
+
+    # Extract index method
+    index_method = content[/def index.*?^  end/m]
+
+    assert_includes index_method, '@notes = Note',
+                    'Index should query Note model'
+    assert_includes index_method, 'render json: @notes',
+                    'Index should render JSON'
+  end
+
+  def test_05_api_has_my_action
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'def my',
+                    'API controller should have my action'
+  end
+
+  def test_06_api_my_filters_by_current_user
+    content = File.read(API_CONTROLLER_PATH)
+
+    # Extract my method
+    my_method = content[/def my.*?^  end/m]
+
+    assert_includes my_method, 'Note.where(user_id: current_ma_user)',
+                    'My action should filter notes by current user'
+    assert_includes my_method, 'render json: @notes',
+                    'My action should render JSON'
+  end
+
+  def test_07_api_my_uses_correct_user_identifier
+    content = File.read(API_CONTROLLER_PATH)
+
+    my_method = content[/def my.*?^  end/m]
+
+    assert_includes my_method, 'current_ma_user',
+                    'Should use current_ma_user to identify user'
+  end
+
+  def test_08_api_has_show_action
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'def show',
+                    'API controller should have show action'
+  end
+
+  def test_09_api_has_create_action
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'def create',
+                    'API controller should have create action'
+  end
+
+  def test_10_api_create_includes_user_id
+    content = File.read(API_CONTROLLER_PATH)
+
+    create_method = content[/def create.*?^  end/m]
+
+    assert_includes create_method, 'user_id:',
+                    'Create action should set user_id'
+    assert_includes create_method, 'params[:user]',
+                    'Create should accept user parameter'
+  end
+
+  def test_11_api_create_renders_json_response
+    content = File.read(API_CONTROLLER_PATH)
+
+    create_method = content[/def create.*?^  end/m]
+
+    assert_includes create_method, 'render json:',
+                    'Create should render JSON response'
+    assert_includes create_method, 'status: :created',
+                    'Create should return 201 status'
+  end
+
+  def test_12_api_has_destroy_action
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'def destroy',
+                    'API controller should have destroy action'
+  end
+
+  def test_13_api_destroy_checks_permissions
+    content = File.read(API_CONTROLLER_PATH)
+
+    destroy_method = content[/def destroy.*?^  end/m]
+
+    assert_includes destroy_method, 'current_ma_user',
+                    'Destroy should check current user'
+    # Should check if user is admin or note owner
+    assert_match(/role.*A|current_ma_user == @note\.user/m, destroy_method,
+                 'Destroy should verify user is admin or owner')
+  end
+
+  def test_14_api_has_before_action_filters
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'before_action :load_note',
+                    'Should have before_action to load note'
+  end
+
+  def test_15_api_load_note_uses_params_id
+    content = File.read(API_CONTROLLER_PATH)
+
+    load_note_method = content[/def load_note.*?^  end/m]
+
+    assert_includes load_note_method, 'Note.find(params[:id])',
+                    'load_note should find note by params[:id]'
+  end
+
+  def test_16_jinda_controller_my_action_filters_by_user
+    content = File.read(JINDA_CONTROLLER_PATH)
+
+    my_method = content[/def my.*?^  end/m]
+
+    assert_includes my_method, 'Note.where(user_id: current_ma_user)',
+                    'Jinda controller my action should also filter by user'
+  end
+
+  def test_17_api_supports_pagination
+    content = File.read(API_CONTROLLER_PATH)
+
+    # Check if pagination is used
+    assert_includes content, '.page(params[:page])',
+                    'Should support pagination with page parameter'
+    assert_includes content, '.per(10)',
+                    'Should limit results per page'
+  end
+
+  def test_18_api_my_action_sorts_by_created_at
+    content = File.read(API_CONTROLLER_PATH)
+
+    my_method = content[/def my.*?^  end/m]
+
+    assert_includes my_method, 'desc(:created_at)',
+                    'My action should sort by created_at descending'
+  end
+
+  def test_19_api_index_sorts_notes
+    content = File.read(API_CONTROLLER_PATH)
+
+    index_method = content[/def index.*?^  end/m]
+
+    assert_includes index_method, 'desc(:created_at)',
+                    'Index should sort notes by created_at'
+  end
+
+  def test_20_api_controller_inherits_from_application_controller
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'class NotesController < ApplicationController',
+                    'Should inherit from ApplicationController for authentication'
+  end
+
+  def test_21_api_create_saves_note
+    content = File.read(API_CONTROLLER_PATH)
+
+    create_method = content[/def create.*?^  end/m]
+
+    assert_includes create_method, '@note.save!',
+                    'Create should save the note'
+  end
+
+  def test_22_api_has_private_methods_section
+    content = File.read(API_CONTROLLER_PATH)
+
+    assert_includes content, 'private',
+                    'Controller should have private methods section'
+  end
+
+  def test_23_controller_uses_consistent_user_filtering
+    api_content = File.read(API_CONTROLLER_PATH)
+    jinda_content = File.read(JINDA_CONTROLLER_PATH)
+
+    # Both controllers should use same user filtering approach
+    assert_includes api_content, 'user_id: current_ma_user',
+                    'API controller should filter by current_ma_user'
+    assert_includes jinda_content, 'user_id: current_ma_user',
+                    'Jinda controller should filter by current_ma_user'
+  end
+end