csvops 0.5.0.alpha → 0.7.0.alpha

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/workflows/run_csv_split_workflow"
+require "tmpdir"
+require "fileutils"
+
+class RunCsvSplitWorkflowTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_workflow_splits_into_chunk_files
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Split complete."
+      assert_includes out.string, "Chunk size: 10"
+      assert_includes out.string, "Chunks written: 3"
+      assert File.file?(File.join(dir, "people_part_001.csv"))
+      assert File.file?(File.join(dir, "people_part_002.csv"))
+      assert File.file?(File.join(dir, "people_part_003.csv"))
+    end
+  end
+
+  def test_workflow_supports_tsv_separator
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.tsv")
+      FileUtils.cp(fixture_path("sample_people.tsv"), source_path)
+      input = [source_path, "2", "", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.tsv")
+      assert File.file?(chunk_path)
+      assert_includes File.read(chunk_path), "name\tcity"
+    end
+  end
+
+  def test_workflow_supports_headerless_mode
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("sample_people_no_headers.csv"), source_path)
+      input = [source_path, "", "n", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.csv")
+      lines = File.read(chunk_path).lines.map(&:strip)
+      assert_equal "Alice,London", lines.first
+      assert_equal "Bob,Paris", lines.last
+    end
+  end
+
+  def test_workflow_supports_custom_separator
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.txt")
+      FileUtils.cp(fixture_path("sample_people_colon.txt"), source_path)
+      input = [source_path, "5", ":", "", "2", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      chunk_path = File.join(dir, "people_part_001.txt")
+      assert File.file?(chunk_path)
+      assert_includes File.read(chunk_path), "name:city"
+    end
+  end
+
+  def test_workflow_uses_custom_output_directory_and_prefix
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      output_dir = File.join(dir, "chunks")
+      Dir.mkdir(output_dir)
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", output_dir, "batch", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert File.file?(File.join(output_dir, "batch_part_001.csv"))
+      assert File.file?(File.join(output_dir, "batch_part_002.csv"))
+      assert File.file?(File.join(output_dir, "batch_part_003.csv"))
+    end
+  end
+
+  def test_workflow_does_not_overwrite_existing_file_without_confirmation
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      existing = File.join(dir, "people_part_001.csv")
+      File.write(existing, "sentinel\n")
+      input = [source_path, "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert_includes out.string, "Output file already exists: #{existing}"
+      assert_equal "sentinel\n", File.read(existing)
+    end
+  end
+
+  def test_workflow_reports_missing_file
+    out = StringIO.new
+    input = ["/tmp/does-not-exist.csv", "", "", "10", "", "", "", ""].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "File not found: /tmp/does-not-exist.csv"
+  end
+
+  def test_workflow_rejects_invalid_chunk_size
+    out = StringIO.new
+    input = [fixture_path("sample_people.csv"), "", "", "abc"].join("\n") + "\n"
+
+    Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+      stdin: StringIO.new(input),
+      stdout: out
+    ).call
+
+    assert_includes out.string, "Chunk size must be a positive integer."
+  end
+
+  def test_workflow_creates_output_directory_when_missing
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      output_dir = File.join(dir, "chunks")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      input = [source_path, "", "", "10", output_dir, "people", "", ""].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert Dir.exist?(output_dir)
+      assert File.file?(File.join(output_dir, "people_part_001.csv"))
+    end
+  end
+
+  def test_workflow_can_write_manifest_when_enabled
+    out = StringIO.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "people.csv")
+      FileUtils.cp(fixture_path("split_people_25.csv"), source_path)
+      manifest_path = File.join(dir, "manifest.csv")
+      input = [source_path, "", "", "10", "", "", "", "y", manifest_path].join("\n") + "\n"
+
+      Csvtool::Interface::CLI::Workflows::RunCsvSplitWorkflow.new(
+        stdin: StringIO.new(input),
+        stdout: out
+      ).call
+
+      assert File.file?(manifest_path)
+      lines = File.read(manifest_path).lines.map(&:strip)
+      assert_equal "chunk_index,chunk_path,row_count", lines.first
+      assert_includes lines[1], ",10"
+      assert_includes lines[2], ",10"
+      assert_includes lines[3], ",5"
+      assert_includes out.string, "Manifest: #{manifest_path}"
+    end
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/build_session_step_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/build_session_step"
+
+class BuildSessionStepTest < Minitest::Test
+  class FakeBuilder
+    attr_reader :params
+
+    def call(**params)
+      @params = params
+      :session
+    end
+  end
+
+  def test_builds_session_from_context
+    builder = FakeBuilder.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::BuildSessionStep.new
+    context = {
+      session_builder: builder,
+      file_path: "/tmp/data.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      output_directory: "/tmp/out",
+      file_prefix: "batch",
+      overwrite_existing: true,
+      write_manifest: true,
+      manifest_path: "/tmp/out/manifest.csv"
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal :session, context[:session]
+    assert_equal "/tmp/data.csv", builder.params[:file_path]
+    assert_equal true, builder.params[:write_manifest]
+    assert_equal "/tmp/out/manifest.csv", builder.params[:manifest_path]
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_inputs_step"
+
+class CollectInputsStepTest < Minitest::Test
+  class FakePrompt
+    def initialize(value)
+      @value = value
+    end
+
+    def call(label: nil)
+      @value
+    end
+  end
+
+  class FakeErrors
+    attr_reader :invalid_chunk_size_calls
+
+    def initialize
+      @invalid_chunk_size_calls = 0
+    end
+
+    def invalid_chunk_size
+      @invalid_chunk_size_calls += 1
+    end
+  end
+
+  def test_collects_inputs_into_context
+    errors = FakeErrors.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectInputsStep.new(
+      file_path_prompt: FakePrompt.new("/tmp/data.csv"),
+      separator_prompt: FakePrompt.new(","),
+      headers_present_prompt: FakePrompt.new(true),
+      chunk_size_prompt: FakePrompt.new("10"),
+      errors: errors
+    )
+    context = {}
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/data.csv", context[:file_path]
+    assert_equal ",", context[:col_sep]
+    assert_equal true, context[:headers_present]
+    assert_equal 10, context[:chunk_size]
+  end
+
+  def test_halts_on_invalid_chunk_size
+    errors = FakeErrors.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectInputsStep.new(
+      file_path_prompt: FakePrompt.new("/tmp/data.csv"),
+      separator_prompt: FakePrompt.new(","),
+      headers_present_prompt: FakePrompt.new(true),
+      chunk_size_prompt: FakePrompt.new("abc"),
+      errors: errors
+    )
+
+    result = step.call({})
+
+    assert_equal :halt, result
+    assert_equal 1, errors.invalid_chunk_size_calls
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_manifest_step"
+
+class CollectManifestStepTest < Minitest::Test
+  class FakeSplitManifestPrompt
+    attr_reader :default_path
+
+    def call(default_path:)
+      @default_path = default_path
+      { write_manifest: true, manifest_path: "/tmp/out/custom_manifest.csv" }
+    end
+  end
+
+  def test_sets_manifest_values_in_context
+    prompt = FakeSplitManifestPrompt.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectManifestStep.new(
+      split_manifest_prompt: prompt
+    )
+    context = { output_directory: "/tmp/out", file_prefix: "batch" }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/out/batch_manifest.csv", prompt.default_path
+    assert_equal true, context[:write_manifest]
+    assert_equal "/tmp/out/custom_manifest.csv", context[:manifest_path]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/csv_split/collect_output_step_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/collect_output_step"
+
+class CollectOutputStepTest < Minitest::Test
+  class FakeSplitOutputPrompt
+    attr_reader :received
+
+    def call(default_directory:, default_prefix:)
+      @received = { default_directory: default_directory, default_prefix: default_prefix }
+      { output_directory: "/tmp/out", file_prefix: "batch", overwrite_existing: true }
+    end
+  end
+
+  def test_sets_output_values_in_context
+    prompt = FakeSplitOutputPrompt.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::CollectOutputStep.new(
+      split_output_prompt: prompt
+    )
+    context = { file_path: "/tmp/people.csv" }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp", prompt.received[:default_directory]
+    assert_equal "people", prompt.received[:default_prefix]
+    assert_equal "/tmp/out", context[:output_directory]
+    assert_equal "batch", context[:file_prefix]
+    assert_equal true, context[:overwrite_existing]
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/csv_split/execute_step"
+
+class SplitExecuteStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    def initialize(headers_result:, run_result:)
+      @headers_result = headers_result
+      @run_result = run_result
+    end
+
+    def read_headers(file_path:, col_sep:, headers_present:)
+      @headers_called = [file_path, col_sep, headers_present]
+      @headers_result
+    end
+
+    def call(session:)
+      @session = session
+      @run_result
+    end
+
+    attr_reader :headers_called, :session
+  end
+
+  class FakePresenter
+    attr_reader :summary
+
+    def print_summary(data)
+      @summary = data
+    end
+  end
+
+  def test_handles_header_failure
+    headers_fail = Result.new(false, { path: "/tmp/missing.csv" })
+    use_case = FakeUseCase.new(headers_result: headers_fail, run_result: Result.new(true, {}))
+    handled = []
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::ExecuteStep.new
+
+    result = step.call(
+      file_path: "/tmp/missing.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      use_case: use_case,
+      session: Object.new,
+      presenter: FakePresenter.new,
+      handle_error: ->(r) { handled << r }
+    )
+
+    assert_equal :halt, result
+    assert_equal [headers_fail], handled
+  end
+
+  def test_prints_summary_on_success
+    use_case = FakeUseCase.new(
+      headers_result: Result.new(true, { headers: %w[name city] }),
+      run_result: Result.new(true, { chunk_count: 3, chunk_paths: ["/tmp/a.csv"], data_rows: 25 })
+    )
+    presenter = FakePresenter.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::CsvSplit::ExecuteStep.new
+
+    result = step.call(
+      file_path: "/tmp/people.csv",
+      col_sep: ",",
+      headers_present: true,
+      chunk_size: 10,
+      use_case: use_case,
+      session: :session,
+      presenter: presenter,
+      handle_error: ->(_r) { raise "unexpected" }
+    )
+
+    assert_nil result
+    assert_equal :session, use_case.session
+    assert_equal 10, presenter.summary[:chunk_size]
+    assert_equal 3, presenter.summary[:chunk_count]
+  end
+end

data/test/csvtool/interface/cli/workflows/steps/parity/build_session_step_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/parity/build_session_step"
+
+class ParityBuildSessionStepTest < Minitest::Test
+  class FakeBuilder
+    attr_reader :args
+
+    def call(left_path:, right_path:, col_sep:, headers_present:)
+      @args = {
+        left_path: left_path,
+        right_path: right_path,
+        col_sep: col_sep,
+        headers_present: headers_present
+      }
+      :session
+    end
+  end
+
+  def test_builds_session_from_context
+    builder = FakeBuilder.new
+    step = Csvtool::Interface::CLI::Workflows::Steps::Parity::BuildSessionStep.new
+    context = {
+      session_builder: builder,
+      left_path: "/tmp/left.csv",
+      right_path: "/tmp/right.csv",
+      col_sep: "\t",
+      headers_present: false
+    }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal :session, context[:session]
+    assert_equal "/tmp/left.csv", builder.args[:left_path]
+    assert_equal "/tmp/right.csv", builder.args[:right_path]
+    assert_equal "\t", builder.args[:col_sep]
+    assert_equal false, builder.args[:headers_present]
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/parity/collect_inputs_step"
+
+class ParityCollectInputsStepTest < Minitest::Test
+  def test_collects_inputs_into_context
+    file_prompt = Object.new
+    separator_prompt = Object.new
+    headers_prompt = Object.new
+    def file_prompt.call(label:) = label.include?("Left") ? "/tmp/left.csv" : "/tmp/right.csv"
+    def separator_prompt.call = ","
+    def headers_prompt.call = true
+
+    step = Csvtool::Interface::CLI::Workflows::Steps::Parity::CollectInputsStep.new(
+      file_path_prompt: file_prompt,
+      separator_prompt: separator_prompt,
+      headers_present_prompt: headers_prompt
+    )
+    context = {}
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal "/tmp/left.csv", context[:left_path]
+    assert_equal "/tmp/right.csv", context[:right_path]
+    assert_equal ",", context[:col_sep]
+    assert_equal true, context[:headers_present]
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../../test_helper"
+require "csvtool/interface/cli/workflows/steps/parity/execute_step"
+
+class ParityExecuteStepTest < Minitest::Test
+  Result = Struct.new(:ok, :data) do
+    def ok? = ok
+  end
+
+  class FakeUseCase
+    attr_reader :session
+
+    def call(session:)
+      @session = session
+      Result.new(true, { match: true })
+    end
+  end
+
+  class FakePresenter
+    attr_reader :data
+
+    def print_summary(data)
+      @data = data
+    end
+  end
+
+  def test_calls_use_case_and_presenter
+    step = Csvtool::Interface::CLI::Workflows::Steps::Parity::ExecuteStep.new
+    use_case = FakeUseCase.new
+    presenter = FakePresenter.new
+    context = { use_case: use_case, session: :session, presenter: presenter, handle_error: ->(_r) {} }
+
+    result = step.call(context)
+
+    assert_nil result
+    assert_equal :session, use_case.session
+    assert_equal true, presenter.data[:match]
+  end
+end

data/test/fixtures/parity_duplicates_left.csv

@@ -0,0 +1,4 @@
+id,name
+1,Alice
+1,Alice
+2,Bob

data/test/fixtures/parity_duplicates_right.csv

@@ -0,0 +1,3 @@
+id,name
+1,Alice
+2,Bob

data/test/fixtures/parity_people_header_mismatch.csv

@@ -0,0 +1,4 @@
+full_name,city
+Alice,London
+Bob,Paris
+Cara,Berlin

data/test/fixtures/parity_people_many_reordered.csv

@@ -0,0 +1,13 @@
+name
+Name12
+Name11
+Name10
+Name09
+Name08
+Name07
+Name06
+Name05
+Name04
+Name03
+Name02
+Name01

data/test/fixtures/parity_people_mismatch.csv

@@ -0,0 +1,4 @@
+name,city
+Alice,London
+Bob,Paris
+Dina,Rome

data/test/fixtures/parity_people_reordered.csv

@@ -0,0 +1,4 @@
+name,city
+Cara,Berlin
+Alice,London
+Bob,Paris

data/test/fixtures/parity_people_reordered.tsv

@@ -0,0 +1,4 @@
+name	city
+Cara	Berlin
+Alice	London
+Bob	Paris

data/test/fixtures/split_people_25.csv

@@ -0,0 +1,26 @@
+name,city
+Name01,City01
+Name02,City02
+Name03,City03
+Name04,City04
+Name05,City05
+Name06,City06
+Name07,City07
+Name08,City08
+Name09,City09
+Name10,City10
+Name11,City11
+Name12,City12
+Name13,City13
+Name14,City14
+Name15,City15
+Name16,City16
+Name17,City17
+Name18,City18
+Name19,City19
+Name20,City20
+Name21,City21
+Name22,City22
+Name23,City23
+Name24,City24
+Name25,City25