ro 4.4.0 → 5.0.0

data/test/unit/collection_test.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# Unit tests for Ro::Collection with new structure support
+
+require_relative '../test_helper'
+
+class CollectionTest < RoTestCase
+  def setup
+    @root = Ro::Root.new(new_structure_path)
+    @collection = Ro::Collection.new(new_structure_path / 'posts')
+  end
+
+  # T011: Test Collection#metadata_files
+  def test_metadata_files_returns_yml_and_json_files
+    files = @collection.metadata_files
+
+    assert_not_nil files, "metadata_files should not be nil"
+    assert files.is_a?(Array), "metadata_files should return an Array"
+
+    # Should find .yml and .json files
+    yml_files = files.select { |f| f.to_s.end_with?('.yml') }
+    assert yml_files.any?, "Should find at least one .yml file"
+
+    # Should be Pathname or Ro::Path objects
+    assert files.all? { |f| f.is_a?(Pathname) || f.is_a?(Ro::Path) }, "All files should be Pathname or Ro::Path objects"
+  end
+
+  def test_metadata_files_excludes_directories
+    files = @collection.metadata_files
+
+    # Should only return files, not directories
+    assert files.all?(&:file?), "metadata_files should only return files, not directories"
+  end
+
+  def test_metadata_files_sorted
+    files = @collection.metadata_files
+
+    # Should be sorted
+    assert_equal files.sort.map(&:to_s), files.map(&:to_s), "metadata_files should be sorted"
+  end
+
+  # T012: Test Collection#each with new structure
+  def test_each_iterates_nodes_from_metadata_files
+    nodes = []
+    @collection.each do |node|
+      nodes << node
+    end
+
+    assert nodes.any?, "Collection should have at least one node"
+    assert nodes.all? { |n| n.is_a?(Ro::Node) }, "All items should be Node instances"
+  end
+
+  def test_each_creates_nodes_from_metadata_files
+    node_ids = []
+    @collection.each do |node|
+      node_ids << node.id
+    end
+
+    # Should find nodes based on metadata files
+    assert node_ids.include?('sample-post'), "Should find sample-post node"
+    assert node_ids.include?('metadata-only'), "Should find metadata-only node"
+    assert node_ids.include?('nested-test'), "Should find nested-test node"
+  end
+
+  def test_each_without_block_returns_enumerator
+    enum = @collection.each
+
+    assert enum.is_a?(Enumerator), "each without block should return Enumerator"
+
+    nodes = enum.to_a
+    assert nodes.any?, "Enumerator should yield nodes"
+  end
+end
+
+# Run the tests
+if __FILE__ == $0
+  test = CollectionTest.new
+
+  puts "Running Collection unit tests..."
+
+  begin
+    test.setup
+    test.test_metadata_files_returns_yml_and_json_files
+    puts "✓ test_metadata_files_returns_yml_and_json_files"
+  rescue => e
+    puts "✗ test_metadata_files_returns_yml_and_json_files: #{e.message}"
+  end
+
+  begin
+    test.setup
+    test.test_metadata_files_excludes_directories
+    puts "✓ test_metadata_files_excludes_directories"
+  rescue => e
+    puts "✗ test_metadata_files_excludes_directories: #{e.message}"
+  end
+
+  begin
+    test.setup
+    test.test_metadata_files_sorted
+    puts "✓ test_metadata_files_sorted"
+  rescue => e
+    puts "✗ test_metadata_files_sorted: #{e.message}"
+  end
+
+  begin
+    test.setup
+    test.test_each_iterates_nodes_from_metadata_files
+    puts "✓ test_each_iterates_nodes_from_metadata_files"
+  rescue => e
+    puts "✗ test_each_iterates_nodes_from_metadata_files: #{e.message}"
+  end
+
+  begin
+    test.setup
+    test.test_each_creates_nodes_from_metadata_files
+    puts "✓ test_each_creates_nodes_from_metadata_files"
+  rescue => e
+    puts "✗ test_each_creates_nodes_from_metadata_files: #{e.message}"
+  end
+
+  begin
+    test.setup
+    test.test_each_without_block_returns_enumerator
+    puts "✓ test_each_without_block_returns_enumerator"
+  rescue => e
+    puts "✗ test_each_without_block_returns_enumerator: #{e.message}"
+  end
+end

data/test/unit/migrator_test.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+# Unit tests for Ro::Migrator with asset structure migration
+
+require_relative '../test_helper'
+
+class MigratorTest < RoTestCase
+  def setup
+    @old_root = Ro::Root.new(old_structure_path)
+    @temp_dir = create_temp_dir('migration_test')
+
+    # Copy old structure fixtures to temp for migration testing
+    FileUtils.cp_r(old_structure_path.to_s + '/.', @temp_dir.to_s)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@temp_dir) if @temp_dir && @temp_dir.exist?
+  end
+
+  # T042: Test Migrator#initialize
+  def test_initialize_with_root_path
+    migrator = Ro::Migrator.new(@temp_dir)
+
+    assert_not_nil migrator, "Migrator should be created"
+    assert_equal @temp_dir.to_s, migrator.root_path.to_s, "Migrator should store root path"
+  end
+
+  def test_initialize_with_options
+    migrator = Ro::Migrator.new(@temp_dir, dry_run: true, backup: true, verbose: true)
+
+    assert migrator.dry_run?, "Migrator should be in dry-run mode"
+    assert migrator.backup?, "Migrator should have backup enabled"
+    assert migrator.verbose?, "Migrator should be verbose"
+  end
+
+  # T043: Test Migrator#validate detecting old structure
+  def test_validate_detects_old_structure
+    migrator = Ro::Migrator.new(@temp_dir)
+    result = migrator.validate
+
+    assert result[:has_old_structure], "Should detect old structure"
+    assert result[:old_nodes].any?, "Should find old structure nodes"
+  end
+
+  # T044: Test Migrator#validate detecting new structure
+  def test_validate_detects_new_structure
+    new_dir = create_temp_dir('new_structure_test')
+    FileUtils.cp_r(new_structure_path.to_s + '/.', new_dir.to_s)
+
+    migrator = Ro::Migrator.new(new_dir)
+    result = migrator.validate
+
+    assert result[:has_new_structure], "Should detect new structure"
+    assert result[:new_nodes].any?, "Should find new structure nodes"
+
+    FileUtils.rm_rf(new_dir)
+  end
+
+  # T045: Test Migrator#preview generating migration plan
+  def test_preview_generates_migration_plan
+    migrator = Ro::Migrator.new(@temp_dir)
+    plan = migrator.preview
+
+    assert plan.is_a?(Array), "Preview should return array of migration steps"
+    assert plan.any?, "Preview should have migration steps"
+
+    # Check that plan includes details about what will be migrated
+    first_step = plan.first
+    assert first_step.key?(:node_id), "Step should include node_id"
+    assert first_step.key?(:old_path), "Step should include old_path"
+    assert first_step.key?(:new_metadata_file), "Step should include new_metadata_file"
+    assert first_step.key?(:new_asset_dir), "Step should include new_asset_dir"
+  end
+
+  # T046: Test Migrator#migrate_node for single node
+  def test_migrate_node_single_node
+    migrator = Ro::Migrator.new(@temp_dir)
+    posts_dir = @temp_dir / 'posts'
+    old_node_dir = posts_dir / 'sample-post'
+
+    result = migrator.migrate_node('posts', 'sample-post')
+
+    assert result[:success], "Migration should succeed"
+
+    # Check new structure was created
+    metadata_file = posts_dir / 'sample-post.yml'
+    asset_dir = posts_dir / 'sample-post'
+
+    assert metadata_file.exist?, "Metadata file should exist at collection level"
+    assert asset_dir.directory?, "Asset directory should exist"
+
+    # Check old attributes file was removed, but assets/ directory remains
+    old_attributes_file = asset_dir / 'attributes.yml'
+    assets_dir = asset_dir / 'assets'
+
+    assert !old_attributes_file.exist?, "Old attributes.yml should be removed"
+    assert assets_dir.exist?, "Assets/ directory should still exist (not moved)"
+  end
+
+  # T047: Test Migrator#migrate_collection for entire collection
+  def test_migrate_collection
+    migrator = Ro::Migrator.new(@temp_dir)
+
+    result = migrator.migrate_collection('posts')
+
+    assert result[:success], "Collection migration should succeed"
+    assert result[:migrated_count] > 0, "Should migrate at least one node"
+  end
+
+  # T048: Test Migrator#migrate for full migration
+  def test_migrate_full_root
+    migrator = Ro::Migrator.new(@temp_dir)
+
+    result = migrator.migrate
+
+    assert result[:success], "Full migration should succeed"
+    assert result[:collections_migrated] > 0, "Should migrate at least one collection"
+    assert result[:nodes_migrated] > 0, "Should migrate at least one node"
+  end
+
+  # T049: Test Migrator#backup creating backup
+  def test_backup_creates_backup
+    migrator = Ro::Migrator.new(@temp_dir, backup: true)
+
+    backup_path = migrator.backup
+
+    assert backup_path.exist?, "Backup should be created"
+    assert backup_path.to_s.include?('.backup.'), "Backup should have .backup. in name"
+  end
+
+  # T050: Test Migrator#rollback restoring from backup
+  def test_rollback_restores_from_backup
+    migrator = Ro::Migrator.new(@temp_dir, backup: true)
+
+    # Create backup, migrate, then rollback
+    backup_path = migrator.backup
+    migrator.migrate
+    result = migrator.rollback
+
+    assert result[:success], "Rollback should succeed"
+    assert result[:restored_from].to_s == backup_path.to_s, "Should restore from backup"
+  end
+
+  # T051: Test Migrator finds nodes without attributes.yml
+  def test_validate_finds_nodes_without_attributes
+    migrator = Ro::Migrator.new(@temp_dir)
+    validation = migrator.validate
+
+    # Should find both sample-post (with attributes) and assets-only (without)
+    assert validation[:old_nodes].size >= 2, "Should find at least 2 nodes"
+
+    assets_only_node = validation[:old_nodes].find { |n| n[:node_id] == 'assets-only' }
+    assert_not_nil assets_only_node, "Should find assets-only node"
+    assert !assets_only_node[:has_attributes], "assets-only should not have attributes"
+  end
+
+  # T052: Test migration creates empty metadata for nodes without attributes
+  def test_migrate_node_without_attributes
+    migrator = Ro::Migrator.new(@temp_dir)
+    posts_dir = @temp_dir / 'posts'
+
+    result = migrator.migrate_node('posts', 'assets-only')
+
+    assert result[:success], "Migration should succeed"
+    assert !result[:had_attributes], "Node should not have had attributes"
+
+    # Check metadata file was created
+    metadata_file = posts_dir / 'assets-only.yml'
+    assert metadata_file.exist?, "Empty metadata file should be created"
+
+    # Check it contains empty hash
+    content = YAML.load_file(metadata_file.to_s)
+    assert content.is_a?(Hash), "Metadata should be a hash"
+  end
+end
+
+# Run the tests
+if __FILE__ == $0
+  test = MigratorTest.new
+
+  puts "Running Migrator unit tests..."
+
+  tests = [
+    :test_initialize_with_root_path,
+    :test_initialize_with_options,
+    :test_validate_detects_old_structure,
+    :test_validate_detects_new_structure,
+    :test_preview_generates_migration_plan,
+    :test_migrate_node_single_node,
+    :test_migrate_collection,
+    :test_migrate_full_root,
+    :test_backup_creates_backup,
+    :test_rollback_restores_from_backup,
+    :test_validate_finds_nodes_without_attributes,
+    :test_migrate_node_without_attributes
+  ]
+
+  tests.each do |test_method|
+    begin
+      test.setup
+      test.send(test_method)
+      test.teardown
+      puts "✓ #{test_method}"
+    rescue => e
+      puts "✗ #{test_method}: #{e.message}"
+      puts "  #{e.backtrace.first}"
+      test.teardown rescue nil
+    end
+  end
+end

data/test/unit/node_test.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+# Unit tests for Ro::Node with new structure support
+
+require_relative '../test_helper'
+
+class NodeTest < RoTestCase
+  def setup
+    @root = Ro::Root.new(new_structure_path)
+    @collection = Ro::Collection.new(new_structure_path / 'posts')
+    @metadata_file = new_structure_path / 'posts' / 'sample-post.yml'
+  end
+
+  # T013: Test Node initialization with metadata_file parameter
+  def test_initialize_with_metadata_file
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert_not_nil node, "Node should be created"
+    assert_equal @collection, node.collection, "Node should store collection reference"
+  end
+
+  def test_initialize_stores_metadata_file
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert_not_nil node.metadata_file, "Node should store metadata_file"
+    assert_equal @metadata_file.to_s, node.metadata_file.to_s, "metadata_file path should match constructor parameter"
+  end
+
+  def test_initialize_raises_error_for_missing_file
+    missing_file = new_structure_path / 'posts' / 'nonexistent.yml'
+
+    assert_raises(Errno::ENOENT) do
+      Ro::Node.new(@collection, missing_file)
+    end
+  end
+
+  # T014: Test Node#id derived from metadata filename
+  def test_id_derived_from_metadata_filename
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert_equal 'sample-post', node.id, "Node ID should be derived from metadata filename (without extension)"
+  end
+
+  def test_id_strips_yml_extension
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert !node.id.end_with?('.yml'), "Node ID should not include .yml extension"
+  end
+
+  def test_id_handles_json_extension
+    json_file = new_structure_path / 'mixed' / 'test-json.json'
+    collection = Ro::Collection.new(new_structure_path / 'mixed')
+    node = Ro::Node.new(collection, json_file)
+
+    assert_equal 'test-json', node.id, "Node ID should be derived from .json filename"
+    assert !node.id.end_with?('.json'), "Node ID should not include .json extension"
+  end
+
+  # T015: Test Node#asset_dir returns assets/ subdirectory
+  def test_asset_dir_returns_assets_subdirectory
+    node = Ro::Node.new(@collection, @metadata_file)
+    expected_dir = new_structure_path / 'posts' / 'sample-post' / 'assets'
+
+    assert_equal expected_dir.to_s, node.asset_dir.to_s, "asset_dir should return assets/ subdirectory"
+  end
+
+  def test_asset_dir_ends_with_assets
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert node.asset_dir.to_s.end_with?('/assets'), "asset_dir should end with /assets"
+  end
+
+  def test_asset_dir_for_metadata_only_node
+    metadata_only_file = new_structure_path / 'posts' / 'metadata-only.yml'
+    node = Ro::Node.new(@collection, metadata_only_file)
+    expected_dir = new_structure_path / 'posts' / 'metadata-only' / 'assets'
+
+    # asset_dir should still return the expected path even if directory doesn't exist
+    assert_equal expected_dir.to_s, node.asset_dir.to_s
+  end
+
+  # T016: Test Node#_load_base_attributes loading from external metadata file
+  def test_load_base_attributes_from_metadata_file
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    # Trigger attribute loading (happens in initialize)
+    attrs = node.attributes
+
+    assert_not_nil attrs, "Attributes should be loaded"
+    assert attrs.is_a?(Hash), "Attributes should be a Hash"
+  end
+
+  def test_attributes_loaded_from_correct_file
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    assert_equal 'Sample Post (New Structure)', node[:title], "Should load title from metadata file"
+    assert_equal 'Test Author', node[:author], "Should load author from metadata file"
+  end
+
+  def test_attributes_support_symbol_and_string_keys
+    node = Ro::Node.new(@collection, @metadata_file)
+
+    # Should work with both symbol and string keys
+    assert_equal node[:title], node['title'], "Attributes should work with both symbol and string keys"
+  end
+end
+
+# Run the tests
+if __FILE__ == $0
+  test = NodeTest.new
+
+  puts "Running Node unit tests..."
+
+  tests = [
+    :test_initialize_with_metadata_file,
+    :test_initialize_stores_metadata_file,
+    :test_initialize_raises_error_for_missing_file,
+    :test_id_derived_from_metadata_filename,
+    :test_id_strips_yml_extension,
+    :test_id_handles_json_extension,
+    :test_asset_dir_returns_assets_subdirectory,
+    :test_asset_dir_ends_with_assets,
+    :test_asset_dir_for_metadata_only_node,
+    :test_load_base_attributes_from_metadata_file,
+    :test_attributes_loaded_from_correct_file,
+    :test_attributes_support_symbol_and_string_keys
+  ]
+
+  tests.each do |test_method|
+    begin
+      test.setup
+      test.send(test_method)
+      puts "✓ #{test_method}"
+    rescue => e
+      puts "✗ #{test_method}: #{e.message}"
+      puts "  #{e.backtrace.first}"
+    end
+  end
+end