csvops 0.4.0.alpha → 0.5.0.alpha

data/test/csvtool/interface/cli/workflows/presenters/row_randomization_presenter_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/presenters/row_randomization_presenter"
+
+class RowRandomizationPresenterTest < Minitest::Test
+  def test_prints_console_start_and_rows
+    out = StringIO.new
+    presenter = Csvtool::Interface::CLI::Workflows::Presenters::RowRandomizationPresenter.new(
+      stdout: out,
+      headers: ["name", "city"],
+      col_sep: ","
+    )
+
+    presenter.print_console_start
+    presenter.print_row(["Alice", "London"])
+
+    assert_equal "\nname,city\nAlice,London\n", out.string
+  end
+
+  def test_prints_file_written_message
+    out = StringIO.new
+    presenter = Csvtool::Interface::CLI::Workflows::Presenters::RowRandomizationPresenter.new(
+      stdout: out,
+      headers: nil,
+      col_sep: ","
+    )
+
+    presenter.print_file_written("/tmp/out.csv")
+
+    assert_includes out.string, "Wrote output to /tmp/out.csv"
+  end
+end

data/test/csvtool/interface/cli/workflows/run_extraction_workflow_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_extraction_workflow"
+require "tmpdir"
+
+class RunExtractionWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_missing_file_path_reports_error
+    out = StringIO.new
+    workflow = Csvtool::Interface::CLI::Workflows::RunExtractionWorkflow.new(
+      stdin: StringIO.new("/tmp/not-present.csv\n\n"),
+      stdout: out
+    )
+
+    workflow.call
+
+    assert_includes out.string, "File not found: /tmp/not-present.csv"
+  end
+
+  def test_workflow_can_run_console_happy_path
+    out = StringIO.new
+    fixture = fixture_path("sample_people.csv")
+    input = ["#{fixture}", "1", "", "1", "", "y", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunExtractionWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Alice"
+    assert_includes out.string, "Bob"
+    assert_includes out.string, "Cara"
+  end
+
+  def test_workflow_can_write_output_file
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "names.csv")
+      fixture = fixture_path("sample_people.csv")
+      input = ["#{fixture}", "1", "", "1", "", "y", "2", output_path].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunExtractionWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Wrote output to #{output_path}"
+      assert_equal "name\nAlice\nBob\nCara\n", File.read(output_path)
+    end
+  end
+end

data/test/csvtool/interface/cli/workflows/run_row_extraction_workflow_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_row_extraction_workflow"
+require "tmpdir"
+
+class RunRowExtractionWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_missing_file_path_reports_error
+    out = StringIO.new
+    workflow = Csvtool::Interface::CLI::Workflows::RunRowExtractionWorkflow.new(
+      stdin: StringIO.new("/tmp/not-present.csv\n\n"),
+      stdout: out
+    )
+
+    workflow.call
+
+    assert_includes out.string, "File not found: /tmp/not-present.csv"
+  end
+
+  def test_workflow_can_run_console_happy_path
+    out = StringIO.new
+    fixture = fixture_path("sample_people.csv")
+    input = [fixture, "", "2", "3", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunRowExtractionWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "name,city"
+    assert_includes out.string, "Bob,Paris"
+    assert_includes out.string, "Cara,Berlin"
+    refute_includes out.string, "Alice,London"
+  end
+
+  def test_workflow_can_write_output_file
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "rows.csv")
+      fixture = fixture_path("sample_people.csv")
+      input = [fixture, "", "2", "3", "2", output_path].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunRowExtractionWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Wrote output to #{output_path}"
+      assert_equal "name,city\nBob,Paris\nCara,Berlin\n", File.read(output_path)
+    end
+  end
+
+  def test_rejects_non_numeric_start_row
+    out = StringIO.new
+    fixture = fixture_path("sample_people.csv")
+    input = [fixture, "", "abc", "3", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunRowExtractionWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Start row must be a positive integer."
+  end
+
+  def test_reports_out_of_bounds_range
+    out = StringIO.new
+    fixture = fixture_path("sample_people.csv")
+    input = [fixture, "", "10", "12", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunRowExtractionWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Row range is out of bounds. File has 3 data rows."
+  end
+end

data/test/csvtool/interface/cli/workflows/run_row_randomization_workflow_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_row_randomization_workflow"
+require "tmpdir"
+
+class RunRowRandomizationWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_missing_file_shows_friendly_error
+    output = StringIO.new
+    input = StringIO.new("/tmp/does-not-exist.csv\n\n")
+
+    Csvtool::Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: input, stdout: output).call
+
+    assert_includes output.string, "File not found: /tmp/does-not-exist.csv"
+  end
+
+  def test_workflow_prints_header_then_all_randomized_rows
+    output = StringIO.new
+    input = StringIO.new([fixture_path("sample_people.csv"), "", "", "", ""].join("\n") + "\n")
+
+    Csvtool::Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: input, stdout: output).call
+
+    assert_includes output.string, "name,city"
+    assert_includes output.string, "Alice,London"
+    assert_includes output.string, "Bob,Paris"
+    assert_includes output.string, "Cara,Berlin"
+  end
+
+  def test_workflow_can_write_randomized_rows_to_file
+    output = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "randomized.csv")
+      input = StringIO.new([fixture_path("sample_people.csv"), "", "", "", "2", output_path].join("\n") + "\n")
+
+      Csvtool::Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: input, stdout: output).call
+
+      written = File.read(output_path).lines.map(&:strip)
+      assert_equal "name,city", written.first
+      assert_equal ["Alice,London", "Bob,Paris", "Cara,Berlin"].sort, written[1..].sort
+      assert_includes output.string, "Wrote output to #{output_path}"
+    end
+  end
+
+  def test_workflow_supports_headerless_mode
+    output = StringIO.new
+    input = StringIO.new([fixture_path("sample_people_no_headers.csv"), "", "n", "", ""].join("\n") + "\n")
+
+    Csvtool::Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: input, stdout: output).call
+
+    refute_includes output.string, "name,city"
+    assert_includes output.string, "Alice,London"
+    assert_includes output.string, "Bob,Paris"
+    assert_includes output.string, "Cara,Berlin"
+  end
+
+  def test_invalid_seed_shows_friendly_error
+    output = StringIO.new
+    input = StringIO.new([fixture_path("sample_people.csv"), "", "", "abc"].join("\n") + "\n")
+
+    Csvtool::Interface::CLI::Workflows::RunRowRandomizationWorkflow.new(stdin: input, stdout: output).call
+
+    assert_includes output.string, "Seed must be an integer."
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/cross_csv_dedupe/collect_options_step_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/cross_csv_dedupe/collect_options_step"
+require "csvtool/domain/cross_csv_dedupe_session/csv_profile"
+
+class CrossCsvDedupeCollectOptionsStepTest < Minitest::Test
+  class FakeErrors
+    attr_reader :column_not_found_called
+
+    def column_not_found
+      @column_not_found_called = true
+    end
+  end
+
+  def test_halts_when_source_selector_invalid
+    selector_prompt = Object.new
+    yes_no_prompt = Object.new
+    output_destination_prompt = Object.new
+    session_builder = Object.new
+    mapper = Object.new
+    errors = FakeErrors.new
+
+    def selector_prompt.call(label:, headers_present:) = nil
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::CrossCsvDedupe::CollectOptionsStep.new(
+      selector_prompt: selector_prompt,
+      yes_no_prompt: yes_no_prompt,
+      output_destination_prompt: output_destination_prompt,
+      errors: errors
+    )
+
+    source = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(path: "/tmp/a.csv", separator: ",", headers_present: true)
+    reference = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(path: "/tmp/b.csv", separator: ",", headers_present: true)
+
+    result = step.call(source: source, reference: reference, session_builder: session_builder, output_destination_mapper: mapper)
+
+    assert_equal :halt, result
+    assert_equal true, errors.column_not_found_called
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/extraction/collect_inputs_step_test.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/extraction/collect_inputs_step"
+
+class ExtractionCollectInputsStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def initialize(result)
+      @result = result
+    end
+
+    def read_headers(file_path:, col_sep:)
+      @result
+    end
+  end
+
+  def test_halts_when_separator_missing
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    selector_prompt = Object.new
+    skip_prompt = Object.new
+    def file_prompt.call = "/tmp/data.csv"
+    def separator_prompt.call = nil
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::Extraction::CollectInputsStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt,
+      column_selector_prompt: selector_prompt,
+      skip_blanks_prompt: skip_prompt
+    )
+
+    assert_equal :halt, step.call(
+      use_case: FakeUseCase.new(Result.new(true, { headers: [] })),
+      session_builder: Object.new,
+      handle_error: ->(_r) {}
+    )
+  end
+
+  def test_halts_when_header_read_fails
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    selector_prompt = Object.new
+    skip_prompt = Object.new
+    builder = Object.new
+    handled = []
+    def file_prompt.call = "/tmp/data.csv"
+    def separator_prompt.call = ","
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::Extraction::CollectInputsStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt,
+      column_selector_prompt: selector_prompt,
+      skip_blanks_prompt: skip_prompt
+    )
+
+    fail_result = Result.new(false, {})
+    result = step.call(use_case: FakeUseCase.new(fail_result), session_builder: builder, handle_error: ->(r) { handled << r })
+
+    assert_equal :halt, result
+    assert_equal [fail_result], handled
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/row_extraction/collect_source_step_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/row_extraction/collect_source_step"
+
+class CollectSourceStepTest < Minitest::Test
+  def test_collects_file_and_separator
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    def file_prompt.call = "/tmp/data.csv"
+    def separator_prompt.call = ","
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::CollectSourceStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt
+    )
+    context = {}
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/data.csv", context[:file_path]
+    assert_equal ",", context[:col_sep]
+  end
+
+  def test_halts_when_separator_missing
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    def file_prompt.call = "/tmp/data.csv"
+    def separator_prompt.call = nil
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::CollectSourceStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt
+    )
+
+    assert_equal :halt, step.call({})
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/row_extraction/execute_step_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/row_extraction/execute_step"
+
+class ExecuteStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def initialize(result)
+      @result = result
+    end
+
+    def extract(session:, headers:, on_row:)
+      @called = true
+      on_row.call(["Bob", "Paris"]) if @result.ok?
+      @result
+    end
+
+    attr_reader :called
+  end
+
+  class FakePresenter
+    attr_reader :rows, :written
+
+    def initialize(stdout:, headers:, col_sep:)
+      @rows = []
+      @written = nil
+    end
+
+    def print_row(fields)
+      @rows << fields
+    end
+
+    def print_file_written(path)
+      @written = path
+    end
+  end
+
+  class FakeErrors
+    attr_reader :out_of_bounds
+
+    def row_range_out_of_bounds(count)
+      @out_of_bounds = count
+    end
+  end
+
+  def test_prints_rows_and_reports_out_of_bounds
+    errors = FakeErrors.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::ExecuteStep.new(
+      stdout: StringIO.new,
+      errors: errors,
+      presenter_class: FakePresenter
+    )
+    use_case = FakeUseCase.new(Result.new(true, { matched: false, row_count: 3, wrote_rows: false }))
+    context = {
+      session: Object.new,
+      headers: ["name", "city"],
+      use_case: use_case,
+      handle_error: ->(_r) { raise "unexpected" }
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal 3, errors.out_of_bounds
+  end
+
+  def test_halts_on_use_case_failure
+    handled = []
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::ExecuteStep.new(
+      stdout: StringIO.new,
+      errors: FakeErrors.new,
+      presenter_class: FakePresenter
+    )
+    fail_result = Result.new(false, {})
+    use_case = FakeUseCase.new(fail_result)
+
+    result = step.call(
+      session: Object.new,
+      headers: ["name", "city"],
+      use_case: use_case,
+      handle_error: ->(r) { handled << r }
+    )
+
+    assert_equal :halt, result
+    assert_equal [fail_result], handled
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/row_extraction/read_headers_step_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/row_extraction/read_headers_step"
+
+class ReadHeadersStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def initialize(result)
+      @result = result
+    end
+
+    def read_headers(file_path:, col_sep:)
+      @file_path = file_path
+      @col_sep = col_sep
+      @result
+    end
+
+    attr_reader :file_path, :col_sep
+  end
+
+  def test_sets_headers_on_success
+    use_case = FakeUseCase.new(Result.new(true, { headers: ["name", "city"] }))
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::ReadHeadersStep.new
+    context = {
+      use_case: use_case,
+      file_path: "/tmp/data.csv",
+      col_sep: ",",
+      handle_error: ->(_result) { raise "should not be called" }
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal ["name", "city"], context[:headers]
+  end
+
+  def test_halts_and_routes_error_when_failure
+    failing_result = Result.new(false, {})
+    use_case = FakeUseCase.new(failing_result)
+    handled = []
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowExtraction::ReadHeadersStep.new
+
+    result = step.call(
+      use_case: use_case,
+      file_path: "/tmp/data.csv",
+      col_sep: ",",
+      handle_error: ->(r) { handled << r }
+    )
+
+    assert_equal :halt, result
+    assert_equal [failing_result], handled
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/row_randomization/collect_inputs_step_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/row_randomization/collect_inputs_step"
+require "csvtool/interface/cli/prompts/seed_prompt"
+
+class RowRandomizationCollectInputsStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def read_headers(file_path:, col_sep:, headers_present:)
+      Result.new(true, { headers: ["name"] })
+    end
+  end
+
+  def test_halts_when_seed_invalid
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    headers_prompt = Object.new
+    seed_prompt = Object.new
+    def file_prompt.call = "/tmp/data.csv"
+    def separator_prompt.call = ","
+    def headers_prompt.call = true
+    def seed_prompt.call = Csvtool::Interface::CLI::Prompts::SeedPrompt::INVALID
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::RowRandomization::CollectInputsStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt,
+      headers_present_prompt: headers_prompt,
+      seed_prompt: seed_prompt
+    )
+
+    assert_equal :halt, step.call(use_case: FakeUseCase.new, handle_error: ->(_r) {})
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/workflow_step_pipeline_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/workflow_step_pipeline"
+
+class WorkflowStepPipelineTest < Minitest::Test
+  def test_runs_all_steps_when_no_halt
+    calls = []
+    step_1 = ->(_ctx) { calls << :one; nil }
+    step_2 = ->(_ctx) { calls << :two; nil }
+    pipeline = Csvtool::Interface::CLI::Workflows::Steps::WorkflowStepPipeline.new(steps: [step_1, step_2])
+
+    result = pipeline.call({})
+
+    assert_equal true, result
+    assert_equal %i[one two], calls
+  end
+
+  def test_stops_on_halt
+    calls = []
+    step_1 = ->(_ctx) { calls << :one; :halt }
+    step_2 = ->(_ctx) { calls << :two; nil }
+    pipeline = Csvtool::Interface::CLI::Workflows::Steps::WorkflowStepPipeline.new(steps: [step_1, step_2])
+
+    result = pipeline.call({})
+
+    assert_equal false, result
+    assert_equal [:one], calls
+  end
+end

data/test/csvtool/interface/cli/workflows/support/output_destination_mapper_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/support/output_destination_mapper"
+
+class OutputDestinationMapperTest < Minitest::Test
+  def test_maps_console_destination
+    mapper = Csvtool::Interface::CLI::Workflows::Support::OutputDestinationMapper.new
+
+    destination = mapper.call({ mode: :console })
+
+    assert_equal true, destination.console?
+  end
+
+  def test_maps_file_destination
+    mapper = Csvtool::Interface::CLI::Workflows::Support::OutputDestinationMapper.new
+
+    destination = mapper.call({ mode: :file, path: "/tmp/out.csv" })
+
+    assert_equal true, destination.file?
+    assert_equal "/tmp/out.csv", destination.path
+  end
+end

data/test/csvtool/interface/cli/workflows/support/result_error_handler_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/support/result_error_handler"
+
+class ResultErrorHandlerTest < Minitest::Test
+  Result = Struct.new(:error)
+
+  def test_dispatches_mapped_error_action
+    calls = []
+    errors = Object.new
+    handler = Csvtool::Interface::CLI::Workflows::Support::ResultErrorHandler.new(errors: errors)
+    result = Result.new(:no_headers)
+
+    handler.call(result, {
+      no_headers: ->(_r, _e) { calls << :called }
+    })
+
+    assert_equal [:called], calls
+  end
+
+  def test_ignores_unmapped_error
+    calls = []
+    errors = Object.new
+    handler = Csvtool::Interface::CLI::Workflows::Support::ResultErrorHandler.new(errors: errors)
+    result = Result.new(:unknown)
+
+    handler.call(result, {
+      no_headers: ->(_r, _e) { calls << :called }
+    })
+
+    assert_empty calls
+  end
+end