scriptorium 0.0.3 → 0.7.2

data/test/unit/asset_management.rb

@@ -0,0 +1,219 @@
+# Test file for asset management functionality
+# Tests the $$asset and $$image Livetext functions
+
+require 'minitest/autorun'
+require_relative '../../lib/scriptorium'
+require_relative '../test_helpers'
+require 'fileutils'
+
+class TestAssetManagement < Minitest::Test
+  include TestHelpers
+
+  def setup
+    @repo_name = "test/scriptorium-TEST"
+    @view_name = "asset_test_view"
+    
+    # Create test repo and API
+    @api = Scriptorium::API.new
+    @api.create_repo(@repo_name)
+    @api.open_repo(@repo_name)
+    
+    # Create a view for testing
+    @api.create_view(@view_name, "Asset Test View")
+    
+    # Create test posts
+    @api.create_post("Test Post 1", "This is the first test post for asset testing.")
+    @api.create_post("Test Post 2", "This is the second test post for asset testing.")
+    
+    # Generate the view to create output directory structure
+    @api.generate_view(@view_name)
+  end
+
+  def teardown
+    FileUtils.rm_rf("test/scriptorium-TEST")  # Commented out for debugging
+  end
+  
+  def test_001_asset_function_basic_functionality
+    # Test that asset() function returns correct paths for existing assets
+    # Create a global asset
+    global_file = Tempfile.new(['global-image', '.jpg'])
+    global_file.write("global image content")
+    global_file.close
+    @api.upload_asset(global_file.path, filename: "global-image.jpg")
+    
+    # Update existing post 0001 with asset reference
+    source_file = "test/scriptorium-TEST/posts/0001/source.lt3"
+    File.write(source_file, "Global asset: $$asset[global-image.jpg]")
+    
+    # Generate the view
+    @api.generate_view(@view_name)
+    
+    # Check that the asset path is correct in generated HTML
+    html_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0001-test-post-1.html"
+    html_content = File.read(html_file)
+    
+    assert_includes_concise_string html_content, "Global asset: ../assets/global-image.jpg", "Asset function should return correct path"
+  end
+  
+  def test_002_asset_function_missing_asset
+    # Test that asset() function returns fallback for missing assets
+    # Update existing post 0002 with missing asset reference
+    source_file = "test/scriptorium-TEST/posts/0002/source.lt3"
+    File.write(source_file, "Missing asset: $$asset[missing-image.jpg]")
+    
+    # Generate the view
+    @api.generate_view(@view_name)
+    
+    # Check that the fallback path is used
+    html_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0002-test-post-2.html"
+    html_content = File.read(html_file)
+    
+    assert_includes_concise_string html_content, "Missing asset: ../assets/imagenotfound.jpg", "Asset function should return fallback for missing assets"
+  end
+  
+  def test_003_image_function_basic_functionality
+    # Test that image() function generates correct HTML
+    # Create a global asset
+    global_file = Tempfile.new(['global-image', '.jpg'])
+    global_file.write("global image content")
+    global_file.close
+    @api.upload_asset(global_file.path, filename: "global-image.jpg")
+    
+    # Update existing post 0001 with image reference
+    source_file = "test/scriptorium-TEST/posts/0001/source.lt3"
+    File.write(source_file, "Image:\n.image global-image.jpg")
+    
+    # Generate the view
+    @api.generate_view(@view_name)
+    
+    # Check that the image tag is correct
+    html_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0001-test-post-1.html"
+    html_content = File.read(html_file)
+    
+    assert_includes_concise_string html_content, "<img src=../assets/global-image.jpg alt='No alt text'></img>", "Image function should generate correct HTML"
+  end
+  
+  def test_004_image_function_with_real_asset
+    # Test that image() function works with actual test assets
+    # Upload a real test asset
+    @api.upload_asset("test/assets/testbanner.jpg", filename: "testbanner.jpg")
+    
+    # Update existing post 0002 with image reference
+    source_file = "test/scriptorium-TEST/posts/0002/source.lt3"
+    File.write(source_file, "Real asset:\n.image testbanner.jpg")
+    
+    # Generate the view
+    @api.generate_view(@view_name)
+    
+    # Check that the image tag is correct
+    html_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0002-test-post-2.html"
+    html_content = File.read(html_file)
+    
+    assert_includes_concise_string html_content, "<img src=../assets/testbanner.jpg alt='No alt text'></img>", "Image function should work with real assets"
+  end
+  
+  def test_005_global_asset_copied_to_view
+    # Test that global assets are automatically copied to view assets during generation
+    # First, create a global asset file directly in the repo
+    global_asset_path = "test/scriptorium-TEST/assets/global-copy-test.jpg"
+    FileUtils.cp("test/assets/testbanner.jpg", global_asset_path)
+    
+    # Update existing post 0001 to reference the global asset
+    source_file = "test/scriptorium-TEST/posts/0001/source.lt3"
+    File.write(source_file, "Global asset copy test:\n.image global-copy-test.jpg")
+    
+    # Assert initial state before generation
+    view_assets_dir = "test/scriptorium-TEST/views/#{@view_name}/assets"
+    
+    # The global asset we just created should NOT be in view assets yet
+    view_asset_path = "#{view_assets_dir}/global-copy-test.jpg"
+    refute File.exist?(view_asset_path), "Global asset should not be in view assets before generation"
+    
+    # Generate the view (this should copy the global asset to the view)
+    @api.generate_view(@view_name)
+    
+    # Check that the global asset was copied to the view assets directory
+    view_asset_path = "test/scriptorium-TEST/views/#{@view_name}/assets/global-copy-test.jpg"
+    assert File.exist?(view_asset_path), "Global asset should be copied to view assets directory"
+    
+    # Check that the image tag references the correct path
+    html_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0001-test-post-1.html"
+    html_content = File.read(html_file)
+    assert_includes_concise_string html_content, "<img src=../assets/global-copy-test.jpg alt='No alt text'></img>", "Image should reference the copied asset"
+  end
+  
+  def test_006_asset_priority_hierarchy
+    # Test that post assets take precedence over view assets with same filename
+    # 1. Create a file with specific contents and upload to view assets
+    view_file = Tempfile.new(['priority-test', '.txt'])
+    view_file.write("File 1, view asset")
+    view_file.close
+    @api.upload_asset(view_file.path, 'view', @view_name, filename: "priority-test.txt")
+    
+    # 2. Create another file with SAME NAME but different contents and upload to post 2 assets
+    post_file = Tempfile.new(['priority-test', '.txt'])
+    post_file.write("File 2, post asset")
+    post_file.close
+    @api.upload_asset(post_file.path, 'post', 2, filename: "priority-test.txt")
+    
+    # 3. Update both posts to reference the asset
+    source_file_1 = "test/scriptorium-TEST/posts/0001/source.lt3"
+    File.write(source_file_1, "Asset priority test:\n$$asset[priority-test.txt]")
+    
+    source_file_2 = "test/scriptorium-TEST/posts/0002/source.lt3"
+    File.write(source_file_2, "Asset priority test:\n$$asset[priority-test.txt]")
+    
+    # 4. Generate the view
+    @api.generate_view(@view_name)
+    
+    # 5. Check that post 1 refers to the view asset (since it has no post asset)
+    html_file_1 = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0001-test-post-1.html"
+    html_content_1 = File.read(html_file_1)
+    assert_includes_concise_string html_content_1, "../assets/priority-test.txt", "Post 1 should reference the view asset"
+    
+    # 6. Check that post 2 refers to its own post asset (post assets take precedence)
+    html_file_2 = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0002-test-post-2.html"
+    html_content_2 = File.read(html_file_2)
+    assert_includes_concise_string html_content_2, "../assets/posts/0002/priority-test.txt", "Post 2 should reference its post asset"
+    
+    # 7. Verify the actual files exist in the correct locations
+    view_asset_path = "test/scriptorium-TEST/views/#{@view_name}/assets/priority-test.txt"
+    post_asset_path = "test/scriptorium-TEST/posts/0002/assets/priority-test.txt"
+    
+    assert File.exist?(view_asset_path), "View asset should exist"
+    assert File.exist?(post_asset_path), "Post asset should exist"
+    
+    # 8. Check that the files have the correct contents
+    view_content = File.read(view_asset_path)
+    post_content = File.read(post_asset_path)
+    
+    assert_includes view_content, "File 1, view asset", "View asset should have correct content"
+    assert_includes post_content, "File 2, post asset", "Post asset should have correct content"
+  end
+
+  def test_007_asset_paths_in_post_context
+    # Test that asset paths work correctly in post page context (subdirectory)
+    
+    # 1. Create a test asset
+    test_file = Tempfile.new(['path-test', '.txt'])
+    test_file.write("Path test asset")
+    test_file.close
+    @api.upload_asset(test_file.path, 'post', 1, filename: "path-test.txt")
+    
+    # 2. Update post 1 to reference the asset
+    source_file_1 = "test/scriptorium-TEST/posts/0001/source.lt3"
+    File.write(source_file_1, "Asset path test:\n$$asset[path-test.txt]")
+    
+    # 3. Generate the view
+    @api.generate_view(@view_name)
+    
+    # 4. Check post page - should have ../assets/posts/0001/path-test.txt
+    post_file = "test/scriptorium-TEST/views/#{@view_name}/output/posts/0001-test-post-1.html"
+    post_content = File.read(post_file)
+    assert_includes_concise_string post_content, "../assets/posts/0001/path-test.txt", "Post page should reference assets with ../ prefix"
+    
+    # 5. Verify the asset file exists in the output directory
+    asset_file = "test/scriptorium-TEST/views/#{@view_name}/output/assets/posts/0001/path-test.txt"
+    assert File.exist?(asset_file), "Asset should be copied to output directory"
+  end
+end

data/test/unit/backup_test.rb

@@ -0,0 +1,451 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'fileutils'
+require 'json'
+require_relative '../../lib/scriptorium'
+require_relative '../test_helpers'
+
+class BackupTestFixed < Minitest::Test
+  include Scriptorium::Exceptions
+  include Scriptorium::Helpers
+
+  def setup
+    @test_dir = "test/scriptorium-TEST"
+    # Clean up any existing test directory first
+    FileUtils.rm_rf(@test_dir) if Dir.exist?(@test_dir)
+    @api = Scriptorium::API.new(testmode: true)
+    @api.create_repo(@test_dir)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@test_dir) if Dir.exist?(@test_dir)
+    # Clean up backup directory too
+    if @api
+      backup_dir = @api.get_backup_directory
+      FileUtils.rm_rf(backup_dir) if Dir.exist?(backup_dir)
+    end
+    @api = nil
+  end
+  
+  private def count_posts_in_compressed_backup(backup_dir)
+    tar_gz_path = backup_dir/"data.tar.gz"
+    return 0 unless File.exist?(tar_gz_path)
+    
+    # Use tar -tf to list files and count posts directories
+    output = `tar -tf '#{tar_gz_path}' 2>/dev/null`
+    return 0 unless $?.success?
+    
+    # Count unique post directories (tar output has ./ prefix)
+    post_dirs = output.lines.select { |line| line.strip.match(/^\.\/posts\/\d+\//) }
+    post_dirs.map { |line| line.strip.split('/')[2] }.uniq.length
+  end
+
+  def test_001_create_full_backup
+    # Create some test content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Test Post", "This is a test post", views: "test-view")
+    
+    # Create a full backup
+    backup_name = @api.create_backup(type: :full, label: "test-backup")
+    
+    # Verify backup was created
+    assert_match(/^\d{8}-\d{6}-full$/, backup_name)
+    
+    backup_dir = @api.get_backup_directory/"data"/backup_name
+    assert Dir.exist?(backup_dir), "Backup directory should exist"
+    
+    # Verify compressed backup structure
+    assert File.exist?(backup_dir/"data.tar.gz"), "Compressed backup data should exist"
+    
+    # Verify backup info file exists (uncompressed)
+    assert File.exist?(backup_dir/"backup-info.txt"), "Backup info file should exist"
+    
+    # Verify manifest was created
+    manifest_file = @api.get_backup_directory/"manifest.txt"
+    assert File.exist?(manifest_file), "Backup manifest should exist"
+    
+    manifest_content = File.read(manifest_file)
+    assert_includes manifest_content, backup_name, "Backup should be in manifest"
+    assert_includes manifest_content, "test-backup", "Label should be in manifest"
+    
+    # Verify backup info file was created
+    backup_info_file = backup_dir/"backup-info.txt"
+    assert File.exist?(backup_info_file), "Backup info file should exist"
+    
+    info_content = File.read(backup_info_file)
+    assert_includes info_content, "scriptorium_version:", "Should contain scriptorium version"
+    assert_includes info_content, "livetext_version:", "Should contain livetext version"
+    assert_includes info_content, "ruby_version:", "Should contain ruby version"
+    assert_includes info_content, "backup_type: full", "Should contain backup type"
+  end
+
+  def test_002_create_incremental_backup
+    # Create some test content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Test Post", "This is a test post", views: "test-view")
+    
+    # Create an incremental backup
+    backup_name = @api.create_backup(type: :incremental, label: "incremental-test")
+    
+    # Verify backup was created
+    assert_match(/^\d{8}-\d{6}-incr$/, backup_name)
+    
+    backup_dir = @api.get_backup_directory/"data"/backup_name
+    assert Dir.exist?(backup_dir), "Backup directory should exist"
+    
+    # Verify compressed backup structure
+    assert File.exist?(backup_dir/"data.tar.gz"), "Compressed backup data should exist"
+    
+    # Verify manifest was created
+    manifest_file = @api.get_backup_directory/"manifest.txt"
+    assert File.exist?(manifest_file), "Backup manifest should exist"
+    
+    manifest_content = File.read(manifest_file)
+    assert_includes manifest_content, backup_name, "Backup should be in manifest"
+    assert_includes manifest_content, "incremental-test", "Label should be in manifest"
+    
+    # Verify backup info file was created
+    backup_info_file = backup_dir/"backup-info.txt"
+    assert File.exist?(backup_info_file), "Backup info file should exist"
+    
+    info_content = File.read(backup_info_file)
+    assert_includes info_content, "scriptorium_version:", "Should contain scriptorium version"
+    assert_includes info_content, "livetext_version:", "Should contain livetext version"
+    assert_includes info_content, "ruby_version:", "Should contain ruby version"
+    assert_includes info_content, "backup_type: incremental", "Should contain backup type"
+  end
+
+  def test_003_list_backups
+    # Create multiple backups
+    backup1 = @api.create_backup(type: :full, label: "first")
+    sleep(1) # Ensure different timestamps
+    backup2 = @api.create_backup(type: :incremental, label: "second")
+    
+    # List backups
+    backups = @api.list_backups
+    
+    assert_equal 2, backups.length, "Should have 2 backups"
+    
+    # Should be sorted by creation time, newest first
+    assert_equal backup2, backups[0][:name], "Newest backup should be first"
+    assert_equal backup1, backups[1][:name], "Older backup should be second"
+    
+    # Verify backup info
+    backup_info = backups[0]
+    assert_equal backup2, backup_info[:name]
+    assert_equal :incremental, backup_info[:type]
+    assert_equal "second", backup_info[:description]
+    assert backup_info[:timestamp].is_a?(Time)
+    assert backup_info[:size].is_a?(Integer)
+    assert backup_info[:file_count].is_a?(Integer)
+  end
+
+  def test_004_restore_backup_safe_strategy
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Modify content
+    @api.create_post("New Post", "New content", views: "test-view")
+    
+    # Restore from backup using safe strategy (default)
+    result = @api.restore_backup(backup_name, strategy: :safe)
+    assert result.is_a?(Hash), "Restore should return a hash"
+    assert_equal backup_name, result[:restored], "Should return the restored backup name"
+    assert result[:pre_restore], "Should have created a pre-restore backup"
+    
+    # Verify content was restored
+    posts = @api.posts("test-view")
+    assert_equal 1, posts.length, "Should have only 1 post after restore"
+    assert_equal "Original Post", posts[0].title, "Should have original post"
+    
+    # Verify pre-restore backup was created
+    backups = @api.list_backups
+    pre_restore = backups.find { |b| b[:description]&.include?("pre-restore") }
+    assert pre_restore, "Should have created a pre-restore backup"
+  end
+
+  def test_004b_restore_backup_destroy_strategy
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Modify content
+    @api.create_post("New Post", "New content", views: "test-view")
+    
+    # Restore from backup using destroy strategy
+    result = @api.restore_backup(backup_name, strategy: :destroy)
+    assert result.is_a?(Hash), "Restore should return a hash"
+    assert_equal backup_name, result[:restored], "Should return the restored backup name"
+    assert_equal :destroy, result[:strategy], "Should indicate destroy strategy"
+    
+    # Verify content was restored
+    posts = @api.posts("test-view")
+    assert_equal 1, posts.length, "Should have only 1 post after restore"
+    assert_equal "Original Post", posts[0].title, "Should have original post"
+  end
+
+  def test_004c_restore_backup_merge_strategy
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Modify content
+    @api.create_post("New Post", "New content", views: "test-view")
+    
+    # Restore from backup using merge strategy
+    result = @api.restore_backup(backup_name, strategy: :merge)
+    assert result.is_a?(Hash), "Restore should return a hash"
+    assert_equal backup_name, result[:restored], "Should return the restored backup name"
+    assert_equal :merge, result[:strategy], "Should indicate merge strategy"
+    
+    # Verify content was restored (merge should keep existing files)
+    posts = @api.posts("test-view")
+    assert_equal 2, posts.length, "Should have 2 posts after merge restore"
+    post_titles = posts.map(&:title).sort
+    assert_equal ["New Post", "Original Post"], post_titles, "Should have both posts"
+  end
+
+  def test_005_delete_backup
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "to-delete")
+    
+    # Verify it exists
+    backups = @api.list_backups
+    assert_equal 1, backups.length, "Should have 1 backup"
+    
+    # Delete the backup
+    result = @api.delete_backup(backup_name)
+    assert result, "Delete should succeed"
+    
+    # Verify it's gone
+    backups = @api.list_backups
+    assert_equal 0, backups.length, "Should have 0 backups after delete"
+    
+    # Verify directory is gone
+    backup_dir = @api.get_backup_directory/"data"/backup_name
+    assert !Dir.exist?(backup_dir), "Backup directory should be deleted"
+  end
+
+  def test_006_incremental_backup_tracks_changes
+    # Create initial content and full backup first
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Post 1", "Content 1", views: "test-view")
+    
+    
+    backup1 = @api.create_backup(type: :full, label: "initial")
+    
+    # Now add new content and create incremental backup
+    @api.create_post("Post 2", "Content 2", views: "test-view")
+    backup2 = @api.create_backup(type: :incremental, label: "after-changes")
+    
+    # Verify backups contain expected content
+    backup1_dir = @api.get_backup_directory/"data"/backup1
+    backup2_dir = @api.get_backup_directory/"data"/backup2
+    
+    # Full backup should have 1 post (check compressed content)
+    backup1_posts = count_posts_in_compressed_backup(backup1_dir)
+    assert_equal 1, backup1_posts, "Full backup should have 1 post"
+    
+    # Incremental backup should have 2 posts (both posts, since post creation modifies existing files)
+    backup2_posts = count_posts_in_compressed_backup(backup2_dir)
+    assert_equal 2, backup2_posts, "Incremental backup should have 2 posts (both posts, since post creation modifies existing files)"
+    
+    # Verify the incremental backup contains the new post
+    # Extract and check compressed content
+    temp_extract_dir = backup2_dir/"temp_extract"
+    FileUtils.mkdir_p(temp_extract_dir)
+    
+    begin
+      # Extract tar.gz to temporary directory
+      system("tar -xzf '#{backup2_dir}/data.tar.gz' -C '#{temp_extract_dir}'")
+      assert $?.success?, "Should successfully extract compressed backup"
+      
+      # Check for post directories
+      backup2_post_dirs = Dir.glob("#{temp_extract_dir}/posts/*")
+      assert_equal 2, backup2_post_dirs.length, "Should have exactly two post directories"
+      
+      # The incremental backup should contain both posts
+      # Check that both post directories exist and contain the expected content
+      post_dirs = backup2_post_dirs.sort
+      
+      # Check first post (0001)
+      source_file_1 = "#{post_dirs[0]}/source.lt3"
+      assert File.exist?(source_file_1), "Source file should exist for post 1"
+      content_1 = File.read(source_file_1)
+      assert_includes content_1, "Post 1", "Should contain Post 1"
+      
+      # Check second post (0002)
+      source_file_2 = "#{post_dirs[1]}/source.lt3"
+      assert File.exist?(source_file_2), "Source file should exist for post 2"
+      content_2 = File.read(source_file_2)
+      assert_includes content_2, "Post 2", "Should contain Post 2"
+    ensure
+      # Clean up temporary directory
+      FileUtils.rm_rf(temp_extract_dir) if Dir.exist?(temp_extract_dir)
+    end
+  end
+
+  def test_007_backup_validation
+    # Temporarily enable contracts for this test
+    original_dbc = ENV['DBC_DISABLED']
+    ENV['DBC_DISABLED'] = nil
+    
+    begin
+      # Test invalid backup type - this should fail the assume check
+      assert_raises(RuntimeError) do
+        @api.create_backup(type: :invalid)
+      end
+      
+      # Test with nil repo - this should fail the assume check
+      api_no_repo = Scriptorium::API.new(testmode: true)
+      assert_raises(RuntimeError) do
+        api_no_repo.create_backup(type: :full)
+      end
+    ensure
+      # Restore original contract setting
+      ENV['DBC_DISABLED'] = original_dbc
+    end
+  end
+
+  def test_008_restore_nonexistent_backup
+    # Try to restore a backup that doesn't exist
+    assert_raises(BackupNotFound) do
+      @api.restore_backup("nonexistent-backup")
+    end
+  end
+
+  def test_009_delete_nonexistent_backup
+    # Try to delete a backup that doesn't exist
+    assert_raises(BackupNotFound) do
+      @api.delete_backup("nonexistent-backup")
+    end
+  end
+
+  def test_010_restore_incremental_backup_with_dependencies
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Post 1", "Content 1", views: "test-view")
+    
+    # Create full backup
+    full_backup = @api.create_backup(type: :full, label: "initial")
+    sleep(1) # Ensure different timestamps
+    
+    # Add more content
+    @api.create_post("Post 2", "Content 2", views: "test-view")
+    
+    # Create incremental backup
+    incr_backup = @api.create_backup(type: :incremental, label: "after-post-2")
+    sleep(1) # Ensure different timestamps
+    
+    # Add more content
+    @api.create_post("Post 3", "Content 3", views: "test-view")
+    
+    # Restore from incremental backup using safe strategy
+    result = @api.restore_backup(incr_backup, strategy: :safe)
+    assert result.is_a?(Hash), "Restore should return a hash"
+    assert_equal incr_backup, result[:restored], "Should return the restored backup name"
+    assert result[:pre_restore], "Should have created a pre-restore backup"
+    
+    # Verify content was restored correctly (should have Post 1 and Post 2)
+    posts = @api.posts("test-view")
+    assert_equal 2, posts.length, "Should have 2 posts after restore"
+    post_titles = posts.map(&:title).sort
+    assert_equal ["Post 1", "Post 2"], post_titles, "Should have correct posts"
+  end
+
+  def test_011_restore_invalid_strategy
+    # Create a backup first
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Test Post", "Test content", views: "test-view")
+    backup_name = @api.create_backup(type: :full, label: "test")
+    
+    # Try to restore with invalid strategy
+    assert_raises(ArgumentError) do
+      @api.restore_backup(backup_name, strategy: :invalid)
+    end
+  end
+
+  def test_012_restore_default_strategy_is_safe
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Modify content
+    @api.create_post("New Post", "New content", views: "test-view")
+    
+    # Restore from backup without specifying strategy (should default to :safe)
+    result = @api.restore_backup(backup_name)
+    assert result.is_a?(Hash), "Restore should return a hash"
+    assert_equal backup_name, result[:restored], "Should return the restored backup name"
+    assert result[:pre_restore], "Should have created a pre-restore backup (default is safe)"
+    
+    # Verify content was restored
+    posts = @api.posts("test-view")
+    assert_equal 1, posts.length, "Should have only 1 post after restore"
+    assert_equal "Original Post", posts[0].title, "Should have original post"
+  end
+
+  def test_013_restore_with_pre_restore_backup_timestamp_handling
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Modify content
+    @api.create_post("New Post", "New content", views: "test-view")
+    
+    # Restore from backup using safe strategy
+    result = @api.restore_backup(backup_name, strategy: :safe)
+    
+    # Verify that the pre-restore backup was created and is not used as the base for restore
+    backups = @api.list_backups
+    pre_restore = backups.find { |b| b[:description]&.include?("pre-restore") }
+    assert pre_restore, "Should have created a pre-restore backup"
+    
+    # The pre-restore backup should not be the same as the original backup
+    refute_equal backup_name, pre_restore[:name], "Pre-restore backup should be different from original"
+    
+    # Verify content was restored correctly
+    posts = @api.posts("test-view")
+    assert_equal 1, posts.length, "Should have only 1 post after restore"
+    assert_equal "Original Post", posts[0].title, "Should have original post"
+  end
+
+  def test_014_merge_strategy_preserves_existing_files
+    # Create initial content
+    @api.create_view("test-view", "Test View", "A test view")
+    @api.create_post("Original Post", "Original content", views: "test-view")
+    
+    # Create a backup
+    backup_name = @api.create_backup(type: :full, label: "before-changes")
+    
+    # Add content that should be preserved
+    @api.create_post("Keep This Post", "This should be kept", views: "test-view")
+    
+    # Restore from backup using merge strategy
+    result = @api.restore_backup(backup_name, strategy: :merge)
+    
+    # Verify both posts exist (merge should preserve existing files)
+    posts = @api.posts("test-view")
+    assert_equal 2, posts.length, "Should have 2 posts after merge restore"
+    post_titles = posts.map(&:title).sort
+    assert_equal ["Keep This Post", "Original Post"], post_titles, "Should have both posts"
+  end
+
+end