scriptorium 0.6.1 → 0.7.2

data/test/unit/deploy_config_test.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+
+require_relative '../../lib/scriptorium'
+require_relative '../test_helpers'
+
+class TestDeployConfig < Minitest::Test
+  include Scriptorium::Exceptions
+  include Scriptorium::Helpers
+  include TestHelpers
+
+  def setup
+    # Clean up any existing test directory first
+    test_dir = "test/scriptorium-TEST"
+    FileUtils.rm_rf(test_dir) if Dir.exist?(test_dir)
+    
+    @repo = Scriptorium::Repo.create(test_dir, testmode: true)
+    @view = @repo.create_view("testview", "Test View", "Test Subtitle")
+    @api = Scriptorium::API.new(testmode: true)
+    @api.open_repo(@repo.root)
+    
+    # Set up deployment configuration for tests
+    setup_deployment_config
+  end
+
+  def teardown
+    # Clean up any test directories that were created
+    Dir.glob("test/scriptorium-TEST*").each do |dir|
+      system("rm -rf #{dir}")
+    end
+  end
+
+  def set_deploy_status(status = "y")
+    status_file = @view.dir/:config/"status.txt"
+    status_content = read_file(status_file)
+    status_content = status_content.gsub(/deploy\s+n/, "deploy #{status}")
+    write_file(status_file, status_content)
+  end
+
+  def test_001_deploy_config_availability
+    @view = @api.current_view
+    set_deploy_status
+    # Test that deployment tests can check for configuration availability
+    unless @api.testing
+      skip "Deployment tests require test mode"
+      return
+    end
+    
+    # Check if deployment config exists
+    config_file = "test/config/deployment.txt"
+    unless File.exist?(config_file)
+      skip "Deployment not configured - add deployment.txt to test/config/"
+      return
+    end
+    
+    # If we get here, config exists and we can run deployment tests
+    # This test just verifies the configuration is available
+    assert File.exist?(config_file), "Deployment config should exist for testing"
+    
+    # Parse the config to make sure it's valid
+    config_content = read_file(config_file)
+    config = @api.parse_deploy_config(config_content)
+    
+    # Verify required fields are present
+    required_fields = %w[user server docroot path]
+    required_fields.each do |field|
+      assert config.key?(field), "Deployment config missing required field: #{field}"
+      assert !config[field].to_s.empty?, "Deployment config field #{field} cannot be empty"
+    end
+    
+    # Verify we can build a valid rsync destination
+    destination = @api.build_rsync_destination(config)
+    assert destination, "Should be able to build rsync destination from valid config"
+    assert destination.match(/^.+@.+:.+$/), "Rsync destination should match user@server:path format"
+  end
+
+  def test_002_deploy_config_format_validation
+    @view = @api.current_view
+    set_deploy_status
+    # Test that deployment config follows expected format
+    unless @api.testing
+      skip "Deployment tests require test mode"
+      return
+    end
+    
+    config_file = "test/config/deployment.txt"
+    unless File.exist?(config_file)
+      skip "Deployment not configured - add deployment.txt to test/config/"
+      return
+    end
+    
+    # Test various config formats
+    config_content = read_file(config_file)
+    config = @api.parse_deploy_config(config_content)
+    
+    # Test that user field doesn't contain @ (should be separate from server)
+    user = config["user"]
+    assert !user.include?("@"), "User field should not contain @ symbol"
+    
+    # Test that server field is a valid hostname/IP
+    server = config["server"]
+    assert server, "Server field should be present"
+    assert server.length > 0, "Server field should not be empty"
+    
+    # Test that docroot field is a valid Unix path
+    docroot = config["docroot"]
+    assert docroot, "Docroot field should be present"
+    assert docroot.start_with?("/"), "Docroot should be absolute (start with /)"
+    
+    # Test that path field is present (can be relative)
+    path = config["path"]
+    assert path, "Path field should be present"
+    assert !path.empty?, "Path field should not be empty"
+  end
+
+  def test_003_real_deployment_workflow
+    @view = @api.current_view
+    set_deploy_status
+    # Skip if not in test mode or no deployment config
+    unless @api.testing
+      skip "Deployment tests require test mode"
+      return
+    end
+    
+    config_file = "test/config/deployment.txt"
+    unless File.exist?(config_file)
+      skip "Deployment not configured - add deployment.txt to test/config/"
+      return
+    end
+    
+    # Create some test content
+    @api.create_post("Test Post 1", "Test content here", blurb: "This is a test post for deployment")
+    @api.create_post("Test Post 2", "More test content", blurb: "Another test post")
+    # Generate the view
+    @api.generate_view(@view.name)
+    # Verify output was created
+    output_dir = @view.dir/:output
+    assert Dir.exist?(output_dir), "Output directory should exist"
+    assert File.exist?(output_dir/"index.html"), "Index should be generated"
+    assert Dir.exist?(output_dir/:posts), "Posts directory should exist"
+    # Test deployment (this will actually try to deploy)
+    deploy_config = @api.parse_deploy_config(read_file(config_file))
+    assert deploy_config, "Should be able to parse deployment config"
+    # Verify we can build deployment destination
+    destination = @api.build_rsync_destination(deploy_config)
+    assert destination, "Should be able to build rsync destination"
+    # Test actual deployment
+    result = @api.deploy(@view.name)
+    assert result, "Deployment should succeed"
+  end
+
+  def test_004_deployment_with_assets
+    @view = @api.current_view
+    set_deploy_status
+    # Skip if not configured
+    unless @api.testing && File.exist?("test/config/deployment.txt")
+      skip "Deployment not configured"
+      return
+    end
+    
+    # Create post with assets
+    post = @api.create_post("Asset Test Post", "Content with assets", blurb: "Testing asset deployment")
+    
+    # Add some test assets
+    assets_dir = post.dir/:assets
+    make_dir(assets_dir)
+    write_file(assets_dir/"test-image.jpg", "fake image data")
+    write_file(assets_dir/"test.css", "body { color: red; }")
+    
+    # Generate and deploy
+    @api.generate_view(@view.name)
+    result = @api.deploy(@view.name)
+    
+    assert result, "Deployment with assets should succeed"
+  end
+
+  def test_005_deployment_verification
+    @view = @api.current_view
+    set_deploy_status
+    # Skip if not configured
+    unless @api.testing && File.exist?("test/config/deployment.txt")
+      skip "Deployment not configured"
+      return
+    end
+    
+    # Create and deploy content
+    @api.create_post("Verification Post", "Content to verify", blurb: "Testing deployment verification")
+    @api.generate_view(@view.name)
+    result = @api.deploy(@view.name)
+    
+    # Verify deployment succeeded
+    assert result, "Deployment should succeed"
+    
+    # Verify deployed content via HTTP
+    # Get deployment config for domain construction
+    config = @api.parse_deploy_config(read_file("test/config/deployment.txt"))
+    domain = config["proto"] + "://" + config["server"]
+    base_url = "#{domain}/#{config["path"]}"
+    
+    # Test main page
+    main_page = `curl -s #{base_url}/`
+    assert main_page.include?("Test View"), "Main page should contain view title"
+    assert main_page.include?("Test Subtitle"), "Main page should contain view subtitle"
+    assert main_page.include?("Verification Post"), "Main page should contain deployed post title"
+    # assert main_page.include?("Testing deployment verification"), "Main page should contain post blurb"  # May not be on main page
+    
+    # Test post page - posts are numbered, so try 0001
+    post_url = "#{base_url}/posts/0001-verification-post.html"
+    post_page = `curl -s #{post_url} 2>/dev/null`
+    assert post_page.include?("Verification Post"), "Post page should contain post title"
+    assert post_page.include?("Content to verify"), "Post page should contain post body"
+    
+    # Test clean permalink URL (should work now with copying instead of symlinking)
+    clean_post_url = "#{base_url}/permalink/verification-post.html"
+    clean_post_page = `curl -s #{clean_post_url} 2>/dev/null`
+    assert clean_post_page.include?("Verification Post"), "Clean permalink should contain post title"
+    assert clean_post_page.include?("Content to verify"), "Clean permalink should contain post body"
+    
+    # Test basic structure elements that are likely to be present
+    # assert post_page.include?("<html"), "Post page should have HTML structure"  # May be fragment
+    # assert post_page.include?("<head"), "Post page should have head section"    # May be fragment
+    # assert post_page.include?("<body"), "Post page should have body section"    # May be fragment
+    
+    # Test navigation elements on main page
+    # assert main_page.include?("permalink"), "Main page should have permalink links"  # May not be present
+    # assert main_page.include?("copy link"), "Main page should have copy link buttons"  # May not be present
+    
+    # Test basic functionality that should be present
+    assert main_page.include?("bootstrap"), "Main page should include Bootstrap CSS/JS"
+    assert main_page.length > 100, "Main page should have substantial content"
+    assert post_page.length > 50, "Post page should have content"
+  end
+
+  private
+
+  def setup_deployment_config
+    # Copy deployment config to the view if it exists
+    config_source = "test/config/deployment.txt"
+    if File.exist?(config_source)
+      deploy_file = @view.dir/:config/"deploy.txt"
+      write_file(deploy_file, read_file(config_source))
+    else
+      raise "Deployment config source not found: #{config_source}"
+    end
+  end
+
+end

data/test/unit/deploy_test.rb

@@ -11,12 +11,23 @@ class TestDeploy < Minitest::Test
   include TestHelpers
 
   def setup
-    @repo = Scriptorium::Repo.create("test/scriptorium-TEST", testmode: true)
+    # Clean up any existing test directory first
+    test_dir = "test/scriptorium-TEST"
+    FileUtils.rm_rf(test_dir) if Dir.exist?(test_dir)
+    
+    @repo = Scriptorium::Repo.create(test_dir, testmode: true)
     @view = @repo.create_view("testview", "Test View", "Test Subtitle")
+    @api = Scriptorium::API.new(testmode: true)
+    @api.open_repo(@repo.root)
   end
 
   def teardown
-    system("rm -rf test/scriptorium-TEST")
+    # Clean up any test directories that were created
+    Dir.glob("test/scriptorium-TEST*").each do |dir|
+      system("rm -rf #{dir}")
+    end
+    # Clean up any root directory created during deployment testing
+    # FileUtils.rm_rf("root") if Dir.exist?("root")
   end
 
   def test_001_deploy_config_file_creation
@@ -118,18 +129,18 @@ class TestDeploy < Minitest::Test
     # Create the target file
     write_file(target_file, "<html><body>Test post</body></html>")
     
-    # Create the symlink
-    File.symlink("0001-test-post.html", symlink_file)
+    # Create the copy
+    FileUtils.cp(target_file, symlink_file)
     
-    # Verify symlink exists
-    assert File.exist?(symlink_file), "Symlink should exist"
-    assert File.symlink?(symlink_file), "Should be a symlink"
+    # Verify copy exists
+    assert File.exist?(symlink_file), "Copy should exist"
+    assert !File.symlink?(symlink_file), "Should not be a symlink"
     
-    # Test that rsync command includes symlink preservation
-    expected_cmd = "rsync -r -z -l #{output_dir}/ user@server:/path/"
-    actual_cmd = "rsync -r -z -l #{output_dir}/ user@server:/path/"
+    # Test that rsync command works with regular files (no symlink preservation needed)
+    expected_cmd = "rsync -r -z #{output_dir}/ user@server:/path/"
+    actual_cmd = "rsync -r -z #{output_dir}/ user@server:/path/"
     
-    assert_equal expected_cmd, actual_cmd, "Rsync command should preserve symlinks"
+    assert_equal expected_cmd, actual_cmd, "Rsync command should work with regular files"
   end
 
   def test_008_deploy_symlink_target_verification
@@ -144,18 +155,17 @@ class TestDeploy < Minitest::Test
     # Create the target file
     write_file(target_file, "<html><body>Another test post</body></html>")
     
-    # Create the symlink
-    File.symlink("0001-another-post.html", symlink_file)
-    
-    # Verify symlink points to existing target
-    assert File.exist?(symlink_file), "Symlink should exist"
-    assert File.symlink?(symlink_file), "Should be a symlink"
+    # Create the copy
+    FileUtils.cp(target_file, symlink_file)
     
-    symlink_target = File.readlink(symlink_file)
-    target_path = output_dir/:permalink/symlink_target
+    # Verify copy exists and has same content
+    assert File.exist?(symlink_file), "Copy should exist"
+    assert !File.symlink?(symlink_file), "Should not be a symlink"
     
-    assert File.exist?(target_path), "Symlink target should exist"
-    assert_equal "0001-another-post.html", symlink_target, "Symlink should point to correct target"
+    # Verify copy has same content as target
+    copy_content = File.read(symlink_file)
+    target_content = File.read(target_file)
+    assert_equal target_content, copy_content, "Copy should have same content as target"
   end
 
   def test_009_domain_extraction_from_deploy_config
@@ -184,4 +194,285 @@ class TestDeploy < Minitest::Test
     
     assert_equal "https://example.com/last-deployed.txt", expected_url, "Verification URL should be correctly formatted"
   end
+
+  # New API deployment method tests
+  
+  def test_011_can_deploy_status_check
+    # Test can_deploy? with various status configurations
+    
+    # Test with deploy status 'n' (should fail)
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy n")
+    
+    refute @api.can_deploy?("testview"), "Should not deploy when status is 'n'"
+    
+    # Test with deploy status 'y' (should pass status check)
+    write_file(status_file, "deploy y")
+    
+    # This will still fail because deploy.txt doesn't exist, but status check passes
+    refute @api.can_deploy?("testview"), "Should fail when deploy.txt is missing"
+  end
+  
+  def test_012_can_deploy_config_validation
+    # Test can_deploy? with various deploy.txt configurations
+    
+    # Set deploy status to 'y'
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy y")
+    
+    # Test with missing deploy.txt
+    refute @api.can_deploy?("testview"), "Should fail when deploy.txt is missing"
+    
+    # Test with incomplete deploy.txt
+    deploy_file = @repo.root/"views"/"testview"/"config"/"deploy.txt"
+    write_file(deploy_file, "user root\nserver example.com")
+    
+    refute @api.can_deploy?("testview"), "Should fail when required fields are missing"
+    
+    # Test with complete deploy.txt
+    write_file(deploy_file, "user root\nserver.example.com\ndocroot /var/www/html\npath testview")
+    
+    # This will fail SSH test, but we'll skip that for now
+    # The method should at least pass the config validation
+    begin
+      result = @api.can_deploy?("testview")
+      # If SSH test passes, result should be true
+      # If SSH test fails, result should be false
+      assert result == false || result == true, "Should return boolean result"
+    rescue => e
+      # SSH test might fail, which is expected in test environment
+      skip "SSH test failed (expected in test environment): #{e.message}"
+    end
+  end
+  
+  def test_013_deploy_dry_run_mode
+    # Test deploy method in dry-run mode
+    
+    # Set up deployment configuration
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy y")
+    
+    deploy_file = @repo.root/"views"/"testview"/"config"/"deploy.txt"
+    write_file(deploy_file, "user root\nserver.example.com\ndocroot /var/www/html\npath testview")
+    
+    # Create some output content
+    output_dir = @repo.root/"views"/"testview"/"output"
+    make_dir(output_dir)
+    write_file(output_dir/"index.html", "<html><body>Test content</body></html>")
+    
+    # Test that the deploy method can be called (deployment test will fail, but that's expected)
+    begin
+      result = @api.deploy("testview", dry_run: true)
+      assert result, "Dry-run should succeed"
+    rescue DeploymentNotReady => e
+      # Deployment not ready, which is expected in test environment
+      skip "Deployment not ready (expected in test environment): #{e.message}"
+    rescue => e
+      raise e
+    end
+  end
+  
+  def test_014_deploy_missing_configuration
+    # Test deploy method with missing configuration
+    
+    # Test with no status file
+    assert_raises(DeploymentNotReady, "Should fail when status is not ready") do
+      @api.deploy("testview")
+    end
+    
+    # Test with deploy status 'n'
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy n")
+    
+    assert_raises(DeploymentNotReady, "Should fail when status is not ready") do
+      @api.deploy("testview")
+    end
+  end
+  
+  def test_015_deploy_invalid_configuration
+    # Test deploy method with invalid configuration
+    
+    # Set deploy status to 'y'
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy y")
+    
+    # Test with missing deploy.txt
+    assert_raises(DeploymentNotReady, "Should fail when deploy.txt is missing") do
+      @api.deploy("testview")
+    end
+    
+    # Test with incomplete deploy.txt
+    deploy_file = @repo.root/"views"/"testview"/"config"/"deploy.txt"
+    write_file(deploy_file, "user root\nserver example.com")
+    
+    assert_raises(DeploymentNotReady, "Should fail when required fields are missing") do
+      @api.deploy("testview")
+    end
+  end
+  
+  def test_016_deploy_rsync_command_construction
+    # Test that deploy method constructs correct rsync command
+    
+    # Set up deployment configuration
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy y")
+    
+    deploy_file = @repo.root/"views"/"testview"/"config"/"deploy.txt"
+    write_file(deploy_file, "user root\nserver example.com\ndocroot /var/www/html\npath testview")
+    
+    # Create output content
+    output_dir = @repo.root/"views"/"testview"/"output"
+    make_dir(output_dir)
+    write_file(output_dir/"index.html", "<html><body>Test content</body></html>")
+    
+    # Test dry-run to see the command that would be executed
+    begin
+      result = @api.deploy("testview", dry_run: true)
+      assert result, "Dry-run should succeed"
+    rescue DeploymentNotReady => e
+      # Deployment not ready, which is expected in test environment
+      skip "Deployment not ready (expected in test environment): #{e.message}"
+    rescue => e
+      raise e
+    end
+    
+    # The dry-run should output the rsync command to stdout
+    # We can't easily capture this in the test, but we can verify the method runs
+    # The actual command format is: "rsync -r -z -l #{output_dir}/ #{remote_path}/"
+  end
+  
+
+  
+  def test_018_deploy_ssh_keys_test
+    # Test SSH key validation (will likely be skipped in test environment)
+    
+    # Set up deployment configuration
+    status_file = @repo.root/"views"/"testview"/"config"/"status.txt"
+    write_file(status_file, "deploy y")
+    
+    deploy_file = @repo.root/"views"/"testview"/"config"/"deploy.txt"
+    write_file(deploy_file, "user root\nserver example.com\ndocroot /var/www/html\npath testview")
+    
+    # Test SSH key validation
+    begin
+      result = @api.can_deploy?("testview")
+      # This might pass or fail depending on SSH configuration
+      assert result == false || result == true, "Should return boolean result"
+    rescue => e
+      # SSH test might fail, which is expected in test environment
+      skip "SSH test failed (expected in test environment): #{e.message}"
+    end
+  end
+
+  def test_020_deploy_config_parsing
+    # Test various deployment config formats
+    test_cases = [
+      # Valid space-separated format
+      {
+        input: "user      root\nserver    example.com\npath      sample",
+        expected: {"user" => "root", "server" => "example.com", "path" => "sample"},
+        description: "valid space-separated format"
+      },
+      # Config with comments
+      {
+        input: "# This is a comment\nuser      root\nserver    example.com\npath      sample",
+        expected: {"user" => "root", "server" => "example.com", "path" => "sample"},
+        description: "config with comments"
+      },
+      # Missing required fields
+      {
+        input: "user      root\nserver    example.com",
+        expected: {"user" => "root", "server" => "example.com"},
+        description: "missing path field"
+      },
+      # Empty config
+      {
+        input: "",
+        expected: {},
+        description: "empty config"
+      },
+      # Config with junk lines
+      {
+        input: "user      root\njunk line here\nserver    example.com\npath      sample",
+        expected: {"user" => "root", "junk" => "line here", "server" => "example.com", "path" => "sample"},
+        description: "config with junk lines"
+      },
+      # Config with extra whitespace
+      {
+        input: "  user      root  \n  server    example.com  \n  path      sample  ",
+        expected: {"user" => "root", "server" => "example.com", "path" => "sample"},
+        description: "config with extra whitespace"
+      }
+    ]
+
+    test_cases.each do |test_case|
+      result = @api.parse_deploy_config(test_case[:input])
+      assert_equal test_case[:expected], result, 
+                   "Failed for #{test_case[:description]}: expected '#{test_case[:expected]}', got '#{result}'"
+    end
+  end
+
+  def test_020b_build_rsync_destination
+    # Test building rsync destinations from config hashes
+    test_cases = [
+      {
+        config: {"user" => "root", "server" => "example.com", "path" => "sample"},
+        expected: "root@example.com:sample",
+        description: "complete config"
+      },
+      {
+        config: {"user" => "root", "server" => "example.com"},
+        expected: nil,
+        description: "missing path"
+      },
+      {
+        config: {},
+        expected: nil,
+        description: "empty config"
+      }
+    ]
+
+    test_cases.each do |test_case|
+      result = @api.build_rsync_destination(test_case[:config])
+      if test_case[:expected].nil?
+        assert_nil result, "Failed for #{test_case[:description]}: expected nil, got '#{result}'"
+      else
+        assert_equal test_case[:expected], result, 
+                     "Failed for #{test_case[:description]}: expected '#{test_case[:expected]}', got '#{result}'"
+      end
+    end
+  end
+
+
+
+  def test_022_deploy_config_edge_cases
+    # Test edge cases that could cause issues
+    edge_cases = [
+      # Config with only junk
+      {
+        input: "this is not a config\nneither is this\nor this",
+        expected: {"this" => "is not a config", "neither" => "is this", "or" => "this"},
+        description: "only junk lines"
+      },
+      # Config with empty lines
+      {
+        input: "user      root\n\nserver    example.com\n\npath      sample\n",
+        expected: {"user" => "root", "server" => "example.com", "path" => "sample"},
+        description: "config with empty lines"
+      },
+      # Config with special characters
+      {
+        input: "user      root\nserver    example.com\npath      /var/www/html",
+        expected: {"user" => "root", "server" => "example.com", "path" => "/var/www/html"},
+        description: "path with special characters"
+      }
+    ]
+
+    edge_cases.each do |test_case|
+      result = @api.parse_deploy_config(test_case[:input])
+      assert_equal test_case[:expected], result, 
+                   "Failed for #{test_case[:description]}: expected '#{test_case[:expected]}', got '#{result}'"
+    end
+  end
+
 end