scriptorium 0.6.1 → 0.7.2

data/test/unit/view.rb

@@ -12,7 +12,7 @@ class TestScriptoriumView < Minitest::Test
     @test_dir = "test/view_test_files"
     make_dir(@test_dir)
     # Use a unique test repo path to avoid conflicts
-    @repo_path = "scriptorium-TEST"
+    @repo_path = "scriptorium-TEST-#{Time.now.to_i}-#{rand(1000)}"
     FileUtils.rm_rf(@repo_path) if Dir.exist?(@repo_path)
     @repo = Scriptorium::Repo.create(@repo_path, testmode: true)
     @view = @repo.create_view("test_view", "Test View", "A test view", theme: "standard")
@@ -34,43 +34,43 @@ class TestScriptoriumView < Minitest::Test
   end
 
   def test_002_initialize_with_nil_name
-    assert_raises(CannotCreateViewNameNil) do
+    assert_raises(ViewNameNil) do
       Scriptorium::View.new(nil, "Title", "Subtitle")
     end
   end
 
   def test_003_initialize_with_empty_name
-    assert_raises(CannotCreateViewNameEmpty) do
+    assert_raises(ViewNameEmpty) do
       Scriptorium::View.new("", "Title", "Subtitle")
     end
   end
 
   def test_004_initialize_with_whitespace_name
-    assert_raises(CannotCreateViewNameEmpty) do
+    assert_raises(ViewNameEmpty) do
       Scriptorium::View.new("   ", "Title", "Subtitle")
     end
   end
 
   def test_005_initialize_with_invalid_name_format
-    assert_raises(CannotCreateViewNameInvalid) do
+    assert_raises(ViewNameInvalid) do
       Scriptorium::View.new("invalid@name", "Title", "Subtitle")
     end
   end
 
   def test_006_initialize_with_nil_title
-    assert_raises(CannotCreateViewTitleNil) do
+    assert_raises(ViewTitleNil) do
       Scriptorium::View.new("valid_name", nil, "Subtitle")
     end
   end
 
   def test_007_initialize_with_empty_title
-    assert_raises(CannotCreateViewTitleEmpty) do
+    assert_raises(ViewTitleEmpty) do
       Scriptorium::View.new("valid_name", "", "Subtitle")
     end
   end
 
   def test_008_initialize_with_whitespace_title
-    assert_raises(CannotCreateViewTitleEmpty) do
+    assert_raises(ViewTitleEmpty) do
       Scriptorium::View.new("valid_name", "   ", "Subtitle")
     end
   end
@@ -95,25 +95,25 @@ class TestScriptoriumView < Minitest::Test
   def test_012_build_widgets_with_valid_widget
     # This test would need actual widget classes to be available
     # For now, we'll test the validation logic
-    assert_raises(CannotBuildWidgetsArgNil) do
+    assert_raises(WidgetsArgNil) do
       @view.build_widgets(nil)
     end
   end
 
   def test_013_build_widgets_with_empty_arg
-    assert_raises(CannotBuildWidgetsArgEmpty) do
+    assert_raises(WidgetsArgEmpty) do
       @view.build_widgets("")
     end
   end
 
   def test_014_build_widgets_with_whitespace_arg
-    assert_raises(CannotBuildWidgetsArgEmpty) do
+    assert_raises(WidgetsArgEmpty) do
       @view.build_widgets("   ")
     end
   end
 
   def test_015_build_widgets_with_invalid_widget_name
-    assert_raises(CannotBuildWidgetNameInvalid) do
+    assert_raises(WidgetNameInvalid) do
       @view.build_widgets("invalid@widget")
     end
   end
@@ -428,4 +428,71 @@ class TestScriptoriumView < Minitest::Test
     output_permissions = File.stat(output_file).mode & 0777
     assert output_permissions > 0, "Expected reasonable file permissions"
   end
+
+  # ========================================
+  # View Validation Error Tests
+  # ========================================
+
+  def test_036_view_target_validation_exceptions
+    # Test that exception classes exist
+    assert ViewTargetNil
+    assert ViewTargetEmpty
+    assert ViewTargetInvalid
+  end
+
+  def test_037_view_creation_exceptions
+    # Test that exception classes exist
+    assert CannotCreateView
+    
+    # Test actual exception raising for view creation failures
+    # This is harder to test since we'd need to simulate file system failures
+    # For now, just verify the class exists
+    assert CannotCreateView
+  end
+
+  def test_038_widget_building_exceptions
+    # Test that exception classes exist
+    assert CannotBuildWidget
+    assert WidgetsArgNil
+    assert WidgetsArgEmpty
+    assert WidgetNameNil
+    assert WidgetNameInvalid
+    
+    # Test actual exception raising for widget building
+    assert_raises(WidgetsArgNil) do
+      @view.build_widgets(nil)
+    end
+    
+    assert_raises(WidgetsArgEmpty) do
+      @view.build_widgets("")
+    end
+    
+    assert_raises(WidgetNameInvalid) do
+      @view.build_widgets("invalid@widget")
+    end
+  end
+
+  def test_039_view_target_validation_scenarios
+    # Test actual exception raising for view target validation
+    # These would need methods that actually raise these exceptions
+    # For now, just verify the classes exist
+    assert ViewTargetNil
+    assert ViewTargetEmpty
+    assert ViewTargetInvalid
+    
+    # Test actual exception raising for view target validation
+    # We can test these by calling lookup_view with invalid targets
+    assert_raises(ViewTargetNil) do
+      @repo.lookup_view(nil)
+    end
+    
+    assert_raises(ViewTargetEmpty) do
+      @repo.lookup_view("")
+    end
+    
+    assert_raises(ViewTargetInvalid) do
+      @repo.lookup_view("invalid@name")
+    end
+  end
+
 end 

data/test/unit/widgets.rb

@@ -179,9 +179,9 @@ class TestScriptoriumWidgets < Minitest::Test
 
   def test_008_list_widget_load_data_missing_file
     # Should raise error when list.txt doesn't exist
-    assert_raises(CannotReadFileNotFound) do
-      TestListWidget2.new(@repo, @view)
-    end
+            assert_raises(ReadFileNotFound) do
+          TestListWidget2.new(@repo, @view)
+        end
   end
 
   def test_009_list_widget_load_data_empty_file
@@ -309,9 +309,9 @@ class TestScriptoriumWidgets < Minitest::Test
 
   def test_016_links_widget_missing_list_file
     # Should raise error when list.txt doesn't exist
-    assert_raises(CannotReadFileNotFound) do
-      Scriptorium::Widget::Links.new(@repo, @view)
-    end
+            assert_raises(ReadFileNotFound) do
+          Scriptorium::Widget::Links.new(@repo, @view)
+        end
   end
 
   # ========================================
@@ -355,13 +355,13 @@ class TestScriptoriumWidgets < Minitest::Test
   end
 
   def test_019_build_widgets_invalid_widget_name
-    assert_raises(NameError) do
+    assert_raises(CannotBuildWidget) do
       @view.build_widgets("nonexistent")
     end
   end
 
   def test_020_build_widgets_with_special_characters
-    assert_raises(CannotBuildWidgetNameInvalid) do
+    assert_raises(WidgetNameInvalid) do
       @view.build_widgets("invalid@widget")
     end
   end

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