scriptorium 0.0.3 → 0.7.2

data/test/web_integration_test.rb

@@ -0,0 +1,231 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require_relative '../lib/scriptorium'
+require_relative 'web_test_helper'
+
+class WebIntegrationTest < Minitest::Test
+  include Scriptorium::Helpers
+  include WebTestHelper
+  
+  # Test repository path and web server config are now in WebTestHelper
+  
+  def setup
+    cleanup_test_repo
+    # Don't create repo here - let the web app create it interactively
+    # Disable DBC contracts in tests
+    ENV['DBC_DISABLED'] = 'true'
+    
+    # rbenv hack to ensure correct Ruby version
+    ENV['PATH'] = "#{ENV['HOME']}/.rbenv/shims:#{ENV['PATH']}"
+    ENV['RBENV_VERSION'] = '3.2.3'
+  end
+
+  def teardown
+    cleanup_test_repo
+    stop_web_server
+  end
+
+  # Test basic web app functionality
+  def test_001_basic_web_interaction
+    start_web_server
+    
+    # Test that web app starts and responds
+    response = get("/status")
+    assert_response_success(response, "Status endpoint should work")
+    
+    # Verify test mode is working
+    data = parse_json_response(response)
+    assert data, "Should have status data"
+    assert_nil data["current_view"], "Should not have current view (test repo empty)"
+    assert_equal false, data["repo_loaded"], "Should not have repo loaded (test repo empty)"
+    
+    # Basic web interaction working
+  end
+
+  # Test view creation workflow via web
+  def test_002_view_creation_workflow
+    start_web_server
+    
+    # Test view creation form
+    response = get("/")
+    assert_response_success(response, "Dashboard should load")
+    assert_includes_concise response, "Create Repository", "Should show create repository option"
+    
+    # Test repository creation (this would be a POST request in real usage)
+    # For now, we'll test that the form elements exist
+    assert_includes_concise response, "create_repo", "Should have repository creation form"
+    
+    # View creation workflow accessible
+  end
+
+  # Test asset management via web
+  def test_003_asset_management_web
+    start_web_server
+    
+    # Setup test environment first
+    setup_test_environment
+    
+    # Test asset management page
+    response = get("/asset_management")
+    assert_response_success(response, "Asset management page should load")
+    assert_includes_concise response, "Asset Management", "Should show asset management interface"
+    
+    # Asset management accessible
+  end
+
+  # Test view configuration via web
+  def test_004_view_configuration_web
+    start_web_server
+    
+    # Setup test environment first
+    setup_test_environment
+    
+    # Test view configuration page
+    response = get("/advanced_config")
+    assert_response_success(response, "Advanced config page should load")
+    assert_includes_concise response, "Advanced Configuration", "Should show configuration interface"
+    
+    # View configuration accessible
+  end
+
+  # Test deployment configuration via web
+  def test_005_deployment_configuration_web
+    start_web_server
+    
+    # Setup test environment first
+    setup_test_environment
+    
+    # Test deployment configuration page
+    response = get("/deploy_config")
+    assert_response_success(response, "Deploy config page should load")
+    assert_includes_concise response, "Deployment Configuration", "Should show deployment interface"
+    
+    # Deployment configuration accessible
+  end
+
+  # Test view generation via web
+  def test_006_view_generation_web
+    start_web_server
+    
+    # Setup test environment first
+    setup_test_environment
+    
+    # Test view generation
+    response = post("/generate_view", { 'view_name' => 'test-view' })
+    assert_response_success(response, "View generation should succeed")
+    
+    # Check that the generated HTML has valid JavaScript
+    index_file = "ui/web/scriptorium-TEST/views/test-view/output/index.html"
+    assert File.exist?(index_file), "Index file should exist after generation"
+    
+    html_content = File.read(index_file)
+    
+    # Check that load_main function is defined
+    assert_match /function load_main/, html_content, "load_main function should be defined"
+    
+    # Check that the SVG script loads properly (functional test)
+    assert_match /console\.log\('SVG script loaded'\)/, html_content,
+                 "Should have SVG script loaded message"
+  end
+
+  # Test generated HTML has clickable posts
+  def test_007_generated_html_has_clickable_posts
+    start_web_server
+    
+    # Setup test environment first
+    setup_test_environment
+    
+    # Create a test post
+    post("/create_post", {
+      title: "Test Post",
+      body: "This is a test post body",
+      views: "test-view",
+      blurb: "Test post blurb"
+    })
+    
+    # Generate the view first
+    post("/generate_view", { 'view_name' => 'test-view' })
+    
+    # Check the generated HTML
+    index_file = "ui/web/scriptorium-TEST/views/test-view/output/index.html"
+    html_content = File.read(index_file)
+    
+    # Should have onclick handlers for posts
+    assert_match /onclick="load_main\('index\.html\?post=/, html_content,
+                 "Should have onclick handlers for posts"
+    
+    # Should have post files
+    posts_dir = "ui/web/scriptorium-TEST/views/test-view/output/posts"
+    assert Dir.exist?(posts_dir), "Posts directory should exist"
+    
+    post_files = Dir.glob("#{posts_dir}/*.html")
+    assert post_files.length > 0, "Should have generated post files"
+  end
+
+  def test_008_collapsible_create_post_form
+    start_web_server
+    setup_test_environment
+    
+    # Get the view dashboard
+    response = get("/view/test-view")
+    assert_response_success(response, "View dashboard should load")
+    
+    # Check that the form is hidden by default
+    assert_match(/id="createPostSection".*style="[^"]*display: none[^"]*"/, response.body, "Create post form should be hidden by default")
+    
+    # Check that the Create Post button exists
+    assert_match(/id="createPostButton".*Create Post/, response.body, "Create Post button should exist")
+    
+    # Check that the form has Edit and Cancel buttons
+    assert_match(/button.*Edit/, response.body, "Form should have Edit button")
+    assert_match(/button.*Cancel/, response.body, "Form should have Cancel button")
+    
+    # Check that view checkboxes exist
+    assert_match(/name="views\[\]"/, response.body, "Form should have view checkboxes")
+  end
+
+  def test_009_create_post_with_modal_redirect
+    start_web_server
+    setup_test_environment
+    
+    # Create a post with the new form
+    response = post("/create_post", {
+      title: "Modal Test Post",
+      blurb: "Test post for modal",
+      tags: "test, modal",
+      views: ["test-view"]
+    })
+    
+    # Should redirect to view with edit_post parameter
+    assert_response_redirect(response, "Should redirect after creating post")
+    assert_match(/edit_post=/, response['Location'], "Should redirect with edit_post parameter")
+    assert_match(/view\/test-view/, response['Location'], "Should redirect to view dashboard")
+  end
+
+  def test_010_post_content_api_endpoint
+    start_web_server
+    setup_test_environment
+    
+    # Create a post first
+    create_response = post("/create_post", {
+      title: "API Test Post",
+      blurb: "Test post for API",
+      views: ["test-view"]
+    })
+    
+    # Extract post ID from redirect
+    redirect_location = create_response['Location']
+    post_id = redirect_location.match(/edit_post=(\d+)/)[1]
+    
+    # Test the API endpoint
+    api_response = get("/api/post_content/#{post_id}")
+    assert_response_success(api_response, "API endpoint should work")
+    
+    # Should return the post content
+    assert_match(/API Test Post/, api_response.body, "API should return post content")
+  end
+
+    private
+  # All helper methods are now in WebTestHelper
+end

data/test/web_test_helper.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'json'
+require 'fileutils'
+
+module WebTestHelper
+  # Web server configuration
+  WEB_SERVER_PORT = 4567
+  WEB_SERVER_URL = "http://localhost:#{WEB_SERVER_PORT}"
+  
+  # Test repository path
+  TEST_REPO_PATH = "ui/web/scriptorium-TEST"
+  
+  # Start web server in test mode
+  def start_web_server
+    # Check if server is already running
+    return if server_running?
+    
+    # Kill any existing server on the port first
+    system("lsof -ti:#{WEB_SERVER_PORT} | xargs kill -9 2>/dev/null")
+    sleep(1) # Give it time to release the port
+    
+    # Start the server
+    system("rbenv exec ruby ui/web/bin/scriptorium-web start --test")
+    wait_for_server
+  end
+
+  # Check if server is already running
+  def server_running?
+    begin
+      response = Net::HTTP.get_response(URI("#{WEB_SERVER_URL}/status"))
+      response.code == "200"
+    rescue
+      false
+    end
+  end
+
+  # Stop web server
+  def stop_web_server
+    system("rbenv exec ruby ui/web/bin/scriptorium-web stop")
+  end
+
+  # Wait for server to be ready
+  def wait_for_server(timeout = 15)
+    start_time = Time.now
+    last_error = nil
+    
+    while Time.now - start_time < timeout
+      begin
+        response = Net::HTTP.get_response(URI("#{WEB_SERVER_URL}/status"))
+        if response.code == "200"
+          return true
+        end
+      rescue => e
+        last_error = e
+        # Server not ready yet
+      end
+      sleep 0.5
+    end
+    
+    # If we get here, the server didn't start
+    error_msg = "Web server did not start within #{timeout} seconds"
+    if last_error
+      error_msg += " (last error: #{last_error.message})"
+    end
+    flunk error_msg
+  end
+
+  # Make GET request
+  def get(path, params = {})
+    uri = URI("#{WEB_SERVER_URL}#{path}")
+    uri.query = URI.encode_www_form(params) unless params.empty?
+    
+    response = Net::HTTP.get_response(uri)
+    response
+  rescue => e
+    flunk "GET request failed: #{e.message}"
+  end
+
+  # Make POST request
+  def post(path, data = {})
+    uri = URI("#{WEB_SERVER_URL}#{path}")
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Post.new(uri)
+    request.set_form_data(data)
+    
+    response = http.request(request)
+    response
+  rescue => e
+    flunk "POST request failed: #{e.message}"
+  end
+
+  # Make PUT request
+  def put(path, data = {})
+    uri = URI("#{WEB_SERVER_URL}#{path}")
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Put.new(uri)
+    request.set_form_data(data)
+    
+    response = http.request(request)
+    response
+  rescue => e
+    flunk "PUT request failed: #{e.message}"
+  end
+
+  # Make DELETE request
+  def delete(path)
+    uri = URI("#{WEB_SERVER_URL}#{path}")
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Delete.new(uri)
+    
+    response = http.request(request)
+    response
+  rescue => e
+    flunk "DELETE request failed: #{e.message}"
+  end
+
+  # Assert response is successful (200)
+  def assert_response_success(response, description)
+    assert response, "Response should exist"
+    assert_equal "200", response.code, "#{description}: Expected 200, got #{response.code}"
+  end
+
+  # Assert response is redirect (302 or 303)
+  def assert_response_redirect(response, description)
+    assert response, "Response should exist"
+    assert ["302", "303"].include?(response.code), "#{description}: Expected 302 or 303, got #{response.code}"
+  end
+
+  # Assert response is not found (404)
+  def assert_response_not_found(response, description)
+    assert response, "Response should exist"
+    assert_equal "404", response.code, "#{description}: Expected 404, got #{response.code}"
+  end
+
+  # Assert that response body includes text, with concise error message
+  def assert_includes_concise(response, text, description)
+    unless response.body.include?(text)
+      # Show response size and a snippet for debugging
+      size = response.body.size
+      snippet = response.body[0, 300].gsub(/\s+/, ' ').strip
+      flunk "#{description} - Expected to find '#{text}' in response (#{size} bytes). Response snippet: #{snippet}..."
+    end
+  end
+
+  # Assert that a string includes text, with concise error message
+  def assert_includes_concise_string(content, text, description)
+    unless content.include?(text)
+      # Show content size and a snippet for debugging
+      size = content.size
+      snippet = content[0, 300].gsub(/\s+/, ' ').strip
+      flunk "#{description} - Expected to find '#{text}' in content (#{size} bytes). Content snippet: #{snippet}..."
+    end
+  end
+
+  # Parse JSON response
+  def parse_json_response(response)
+    return nil unless response.body
+    JSON.parse(response.body)
+  rescue JSON::ParserError => e
+    flunk "Failed to parse JSON response: #{e.message}"
+  end
+
+  # Clean up test repository
+  def cleanup_test_repo
+    FileUtils.rm_rf(TEST_REPO_PATH) if Dir.exist?(TEST_REPO_PATH)
+    # Also clean up backup directory for test repo
+    backup_dir = File.dirname(TEST_REPO_PATH) + "/backup-scriptorium-TEST"
+    FileUtils.rm_rf(backup_dir) if Dir.exist?(backup_dir)
+  end
+
+  # Setup basic test environment (repo + view)
+  def setup_test_environment
+    # Create repository
+    post("/create_repo", {})
+    
+    # Create test view
+    post("/create_view", {
+      name: "test-view",
+      title: "Test View",
+      subtitle: "A test view for web testing"
+    })
+  end
+
+  # Wait for a specific condition with timeout
+  def wait_for_condition(timeout = 10, &block)
+    start_time = Time.now
+    while Time.now - start_time < timeout
+      if block.call
+        return true
+      end
+      sleep 0.5
+    end
+    flunk "Condition not met within #{timeout} seconds"
+  end
+
+  # Check if web app is in test mode
+  def assert_test_mode_active
+    response = get("/status")
+    data = parse_json_response(response)
+    assert data, "Should have status data"
+    assert_nil data["current_view"], "Should not have current view (test mode active)"
+    assert_equal false, data["repo_loaded"], "Should not have repo loaded (test mode active)"
+  end
+
+  # Verify test repository path is being used
+  def assert_test_repository_path
+    # This would require checking the web app's internal state
+    # For now, we verify by checking that no production data is visible
+    response = get("/")
+    assert_response_success(response, "Dashboard should load")
+    assert_includes_concise response, "No repository found", "Should show no repository (test mode)"
+  end
+end