jinda 0.7.7.4 → 1.0.0

data/test/TEST_INFRASTRUCTURE.md

@@ -0,0 +1,412 @@
+# Jinda Test Infrastructure Summary
+
+## Overview
+
+The Jinda gem now has a comprehensive test infrastructure that works both **locally** during development and in **CI** environments.
+
+### Key Principle
+**Tests work the same way locally and in CI** - both use Rake tasks, making local testing match CI exactly.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────┐
+│          Rake Tasks (Rakefile)          │
+│  - Modular test groups                  │
+│  - Can run individually or together     │
+│  - Same interface for local and CI      │
+└─────────────────────────────────────────┘
+                    │
+        ┌───────────┴───────────┐
+        │                       │
+┌───────▼────────┐    ┌────────▼──────────┐
+│  Local Testing │    │    CI (Jenkins)    │
+│                │    │                    │
+│  - test/dummy  │    │  - Parallel stages │
+│  - Quick iters │    │  - Rake tasks      │
+│  - Manual test │    │  - Artifacts       │
+└────────────────┘    └────────────────────┘
+```
+
+## File Structure
+
+```
+jinda/
+├── Rakefile                              # ✨ Enhanced with test groups
+├── ci/
+│   ├── Jenkinsfile                       # Original (complex)
+│   └── Jenkinsfile.simple                # ✨ NEW: Simple, Rake-based
+├── test/
+│   ├── jenkins_stage_test.rb             # ✨ NEW: Tests Jenkinsfile
+│   ├── note_model_test.rb                # ✨ NEW: Tests Note model
+│   ├── api_notes_controller_test.rb      # ✨ NEW: Tests API filtering
+│   ├── note_validation_integration_test.rb # ✨ NEW: Tests validations
+│   ├── installation_test.rb              # Existing: Full install flow
+│   ├── integration_test.rb               # Existing: HTTP/login tests
+│   ├── generated_app_test.rb             # ✨ NEW: Tests generated apps
+│   ├── UNIT_TESTS_README.md              # ✨ NEW: Unit test documentation
+│   ├── LOCAL_DEVELOPMENT.md              # ✨ NEW: Local workflow guide
+│   ├── TEST_INFRASTRUCTURE.md            # ✨ NEW: This file
+│   ├── run_unit_tests.sh                 # ✨ NEW: Simple test runner
+│   └── dummy/                            # Created locally (not in git)
+│       └── [Rails app for testing]       # Regenerated by generator
+```
+
+## Test Categories
+
+### 1. Unit Tests (Fast - ~2 seconds)
+**Command**: `rake test:unit`
+
+**Files**:
+- `jenkins_stage_test.rb` - Verify Jenkinsfile structure
+- `note_model_test.rb` - Verify Note model templates
+- `api_notes_controller_test.rb` - Verify API controller filtering
+- `note_validation_integration_test.rb` - Verify validation logic
+
+**Purpose**: Static analysis of gem templates, no app generation
+
+### 2. Installation Tests (Slow - ~2-3 min)
+**Command**: `rake test:installation`
+
+**File**: `installation_test.rb`
+
+**Purpose**: Generate full Rails app, test installation flow
+
+### 3. Integration Tests (Slow - ~2-3 min)
+**Command**: `rake test:integration`
+
+**File**: `integration_test.rb`
+
+**Purpose**: Test HTTP endpoints, login, in generated app
+
+### 4. Generated App Tests (Manual)
+**Command**: `rake test:generated_app`
+
+**Location**: `test/dummy/`
+
+**Purpose**: Run tests **inside** the generated app itself
+
+## Rake Tasks
+
+### Quick Reference
+```bash
+# Fast feedback (2 seconds)
+rake test:unit
+
+# Complete gem tests
+rake test:gem              # unit + installation
+
+# Full test suite
+rake test:all              # unit + installation + integration
+
+# Individual tests
+rake test:installation
+rake test:integration
+rake test:generated_app    # Only if test/dummy exists
+```
+
+### Task Definitions (Rakefile)
+
+```ruby
+namespace :test do
+  task :unit            # Fast static analysis
+  task :installation    # Generate and test app
+  task :integration     # HTTP/login tests
+  task :generated_app   # Run tests in test/dummy
+  task :gem             # unit + installation
+  task :all             # Everything
+end
+```
+
+## CI Integration
+
+### Jenkins (Simplified)
+
+**File**: `ci/Jenkinsfile.simple`
+
+**Structure**:
+```groovy
+stage('Tests') {
+  parallel {
+    stage('RuboCop') { sh 'bundle exec rake rubocop' }
+    stage('Unit Tests') { sh 'bundle exec rake test:unit' }
+  }
+}
+stage('Installation Tests') { sh 'bundle exec rake test:installation' }
+stage('Integration Tests') { sh 'bundle exec rake test:integration' }
+```
+
+**Key Points**:
+- Uses same Rake tasks as local development
+- Parallel execution for speed
+- Simple stage definitions
+- Follows pattern from ~/jenkins/template.txt
+
+### Migration Path
+
+1. **Current**: Use existing `ci/Jenkinsfile` (works fine)
+2. **Future**: Switch to `ci/Jenkinsfile.simple` when ready
+3. **Both**: Can coexist during transition
+
+## Local Development Workflow
+
+### Option A: Quick Iteration (No test/dummy)
+```bash
+# 1. Edit gem templates
+vim lib/generators/jinda/templates/app/models/note.rb
+
+# 2. Run unit tests (fast)
+rake test:unit
+
+# 3. If pass, run installation test
+rake test:installation
+
+# 4. Push to GitHub
+git push
+```
+
+### Option B: Full Testing (With test/dummy)
+```bash
+# 1. Create test/dummy
+cd test
+rails new dummy -BOTJ
+cd dummy
+echo "gem 'jinda', path: '../../'" >> Gemfile
+bundle install
+rails g jinda:install
+bundle install
+rails g jinda:config
+bundle install
+cd ../..
+
+# 2. Edit and test
+vim lib/generators/jinda/templates/app/models/note.rb
+rake test:unit
+
+# 3. Test in dummy
+cd test/dummy
+rails s  # Manual testing
+cd ../..
+
+# 4. Full test suite
+rake test:all
+
+# 5. Push
+git push
+```
+
+### Option C: Minimal (Just unit tests)
+```bash
+# For template-only changes
+rake test:unit
+git push
+# Let CI run full tests
+```
+
+## test/dummy vs CI Test Apps
+
+### test/dummy (Local)
+- **Created**: Manually by developer
+- **Location**: `test/dummy/`
+- **Purpose**: Interactive development, manual testing
+- **Lifecycle**: Regenerated when needed
+- **Git**: NOT committed (.gitignore)
+
+### CI Test Apps
+- **Created**: Automatically by `installation_test.rb`
+- **Location**: `tmp/jinda_tests/jinda_test_<timestamp>`
+- **Purpose**: Automated testing in CI
+- **Lifecycle**: Cleaned up after tests
+- **Git**: Never committed
+
+### Why Both?
+
+| Need | Use |
+|------|-----|
+| Quick template changes | Unit tests only |
+| Interactive testing | test/dummy |
+| Full validation | installation + integration tests |
+| CI testing | Automated test apps |
+
+## Best Practices
+
+### Before Every Commit
+```bash
+rake test:unit  # Takes 2 seconds, catches template issues
+```
+
+### Before Every Push
+```bash
+rake test:gem   # unit + installation, full validation
+```
+
+### Before Release
+```bash
+rake test:all   # Everything including integration
+```
+
+### During Active Development
+- Keep `test/dummy` updated
+- Run `rake test:unit` frequently
+- Regenerate `test/dummy` after generator changes
+
+## Environment Variables
+
+### All Tests
+```bash
+MONGODB_PORT=27888 rake test:installation  # Custom MongoDB port
+SKIP_CLEANUP=true rake test:installation   # Keep test artifacts
+TEST_DIR=/tmp/tests rake test:installation # Custom test location
+```
+
+### Test-Specific
+```bash
+# Installation test
+JINDA_GEM_SOURCE=git rake test:installation  # Test with git version
+JINDA_GIT_BRANCH=main rake test:installation # Test specific branch
+
+# Integration test
+TEST_PORT=3001 rake test:integration         # Custom HTTP port
+KEEP_SERVER=true rake test:integration       # Keep server running
+```
+
+## Comparison: Before vs After
+
+### Before (No Unit Tests)
+```bash
+# Developer workflow
+1. Edit template
+2. Wait 3+ minutes for full test suite
+3. Fix issues
+4. Repeat
+```
+
+### After (With Unit Tests)
+```bash
+# Developer workflow
+1. Edit template
+2. Run unit tests (2 seconds) ← NEW
+3. Fix obvious issues immediately
+4. Run full tests when confident
+5. Much faster iteration
+```
+
+### CI Improvements
+```bash
+# Before: Monolithic stages
+- All tests run sequentially
+- No parallelization
+- Hard to identify failure points
+
+# After: Modular stages
+- Unit tests run in parallel with RuboCop
+- Clear stage separation
+- Easy to see which stage failed
+```
+
+## Coverage
+
+### Test Coverage by Category
+
+| Category | Files Tested | Tests | Assertions | Runtime |
+|----------|--------------|-------|------------|---------|
+| Unit Tests | 4 files | 83 | 313 | ~2s |
+| Installation | 1 file | 12 | ~40 | ~2-3min |
+| Integration | 1 file | 12 | ~35 | ~2-3min |
+| **Total** | **6 files** | **107** | **~388** | **~5min** |
+
+### What's Tested
+
+✅ Jenkinsfile structure and stages  
+✅ Note model templates and validations  
+✅ API controller filtering by user  
+✅ User association requirements  
+✅ Full installation flow  
+✅ Server startup  
+✅ HTTP endpoints  
+✅ Authentication and login  
+✅ MongoDB connectivity  
+
+## Future Enhancements
+
+### Short Term
+1. Add rake task to sync test/dummy → templates
+2. Add more unit tests for other models
+3. Add RSpec template tests
+
+### Medium Term
+1. Parallel test execution locally
+2. Test coverage reporting
+3. Performance benchmarks
+
+### Long Term
+1. Automated template sync
+2. Visual regression testing
+3. Load testing for generated apps
+
+## Troubleshooting
+
+### Common Issues
+
+**MongoDB not running**:
+```bash
+docker run -d -p 27017:27017 mongo
+```
+
+**Port conflict**:
+```bash
+lsof -i :3000
+kill -9 <PID>
+```
+
+**Stale test/dummy**:
+```bash
+cd test && rm -rf dummy
+# Recreate fresh
+```
+
+**Bundle issues**:
+```bash
+bundle clean --force
+bundle install
+```
+
+## Documentation
+
+- `test/UNIT_TESTS_README.md` - Detailed unit test documentation
+- `test/LOCAL_DEVELOPMENT.md` - Local development guide
+- `ci/Jenkinsfile.simple` - Simplified CI configuration
+- `Rakefile` - Test task definitions
+
+## Migration Guide
+
+### From Old CI to New CI
+
+1. **Test locally first**:
+   ```bash
+   rake test:all  # Verify all tests pass
+   ```
+
+2. **Update Jenkinsfile** (when ready):
+   ```bash
+   mv ci/Jenkinsfile ci/Jenkinsfile.old
+   mv ci/Jenkinsfile.simple ci/Jenkinsfile
+   ```
+
+3. **Verify CI**:
+   - Push to branch
+   - Verify Jenkins runs correctly
+   - Compare timing with old pipeline
+
+4. **Rollback if needed**:
+   ```bash
+   mv ci/Jenkinsfile ci/Jenkinsfile.simple
+   mv ci/Jenkinsfile.old ci/Jenkinsfile
+   ```
+
+---
+
+**Created**: 2026-01-04  
+**Ruby Version**: 3.3.x  
+**Rails Version**: 7.0+  
+**Test Framework**: Minitest

data/test/TEST_INSTALLATION_SH_FIXES.md

@@ -0,0 +1,205 @@
+# test_jinda_installation.sh - Fixes Applied
+
+## Issues Fixed
+
+### 1. ✅ Interactive Prompts (Conflict Issue)
+**Problem**: `rails generate` commands prompted for user input (overwrite files? Y/N)
+
+**Solution**: Added `--force --quiet` flags
+```bash
+# Before:
+rails generate jinda:install
+
+# After:
+rails generate jinda:install --force --quiet
+```
+
+### 2. ✅ MongoDB Conflicts
+**Problem**: Script didn't handle existing MongoDB containers or port conflicts
+
+**Solution**: Intelligent MongoDB detection
+```bash
+1. Find existing MongoDB container → Use it
+2. Check if port in use → Use existing MongoDB
+3. No MongoDB found → Start new container with unique name
+4. Cleanup → Only stop container if we created it
+```
+
+### 3. ✅ MongoDB Auto-Start
+**Problem**: Required manual MongoDB start before running script
+
+**Solution**: Script now handles MongoDB automatically
+- Detects existing MongoDB (any container with "mongo" in name)
+- Uses existing container's port
+- Starts new container only if needed
+- Unique container names to avoid conflicts: `jinda_test_mongodb_${TEST_APP_NAME}`
+
+### 4. ✅ Output Noise
+**Problem**: Too much output made it hard to see what's happening
+
+**Solution**: Quieter output with status messages
+```bash
+bundle install > /dev/null 2>&1  # Quiet unless error
+print_info "Installing gems (this may take a minute)..."
+```
+
+## How It Works Now
+
+### MongoDB Detection Logic
+
+```bash
+# Step 1: Check for existing MongoDB container
+EXISTING_MONGO=$(docker ps --format '{{.Names}}' | grep mongo | head -1)
+
+if [ found ]; then
+    → Use existing container
+    → Detect its port
+    → Skip cleanup (don't stop it)
+else
+    # Step 2: Check if port in use
+    if port_in_use; then
+        → Use non-Docker MongoDB
+    else
+        # Step 3: Start new container
+        → docker run with unique name
+        → Set NEW_MONGO_CONTAINER flag
+        → Cleanup will stop this container
+    fi
+fi
+```
+
+### Generator Commands
+
+```bash
+# Non-interactive mode
+rails generate jinda:install --force --quiet
+rails generate jinda:config --force --quiet
+
+# If error occurs, re-run with output for debugging
+if [ $? -ne 0 ]; then
+    rails generate jinda:install  # Show errors
+fi
+```
+
+## Usage
+
+### Basic Usage
+```bash
+# Uses existing MongoDB or starts new one
+./test_jinda_installation.sh
+```
+
+### Keep Test Files
+```bash
+# Don't cleanup after test
+SKIP_CLEANUP=true ./test_jinda_installation.sh
+```
+
+### Custom MongoDB Port
+```bash
+# Use specific port (only if starting new container)
+MONGODB_PORT=27999 ./test_jinda_installation.sh
+```
+
+## Benefits
+
+### ✅ No More Conflicts
+- Uses existing MongoDB if available
+- Creates unique container names
+- Doesn't interfere with development MongoDB
+
+### ✅ Works During Development
+- Safe to run while your dev MongoDB is running
+- Won't stop your development containers
+- Won't conflict with ports
+
+### ✅ Works in CI
+- Starts MongoDB automatically if not present
+- Cleans up containers it creates
+- Deterministic behavior
+
+### ✅ No Manual Steps
+- No need to start MongoDB first
+- No prompts to answer
+- Fully automated
+
+## Output Example
+
+```
+==========================================
+Jinda Gem Installation Test Suite
+==========================================
+
+Test 1: Checking prerequisites...
+-----------------------------------
+[i] Checking MongoDB setup...
+[✓] Using existing MongoDB container: mongodb
+[✓] MongoDB running on port: 27017
+[✓] Ruby version: 3.3.0
+[✓] Rails version: 7.1.0
+
+Test 2: Creating new Rails application...
+-----------------------------------
+[i] Creating Rails app (this may take a minute)...
+[✓] Rails app created: jinda_test_app_1736028592
+
+Test 3: Adding Jinda gem to Gemfile...
+-----------------------------------
+[✓] Jinda gem added to Gemfile
+
+Test 4: Running bundle install...
+-----------------------------------
+[i] Installing gems (this may take a minute)...
+[✓] Bundle install successful
+[✓] Jinda gem is available in bundle
+
+Test 5: Running rails generate jinda:install...
+-----------------------------------
+[i] Running generator (auto-accepting prompts)...
+[✓] jinda:install generator completed
+
+...
+```
+
+## Comparison
+
+### Before (Had Issues)
+```bash
+# Manual steps required:
+1. Start MongoDB manually
+2. Run script
+3. Answer Y/N prompts during generators
+4. Hope port doesn't conflict
+5. Manually cleanup MongoDB if needed
+```
+
+### After (Fixed)
+```bash
+# Just run:
+./test_jinda_installation.sh
+
+# Everything is automatic:
+✅ MongoDB detection/start
+✅ No prompts
+✅ No conflicts
+✅ Auto cleanup
+```
+
+## Environment Variables
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `SKIP_CLEANUP` | `false` | Keep test files and containers |
+| `MONGODB_PORT` | `27888` | Port for new MongoDB (if started) |
+| `JINDA_GEM_PATH` | `$HOME/mygem/jinda` | Path to Jinda gem |
+
+## Related Files
+
+- `test_jinda_installation.sh` - This script (fixed)
+- `test/installation_test.rb` - Ruby minitest version
+- `test/LOCAL_DEVELOPMENT.md` - Development testing guide
+
+---
+
+**Fixed**: 2026-01-04
+**Issues Resolved**: Interactive prompts, MongoDB conflicts, auto-start MongoDB