csvops 0.6.0.alpha → 0.7.0.alpha

data/test/csvtool/interface/cli/prompts/split_manifest_prompt_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/prompts/split_manifest_prompt"
+
+class SplitManifestPromptTest < Minitest::Test
+  class FakeYesNoPrompt
+    def initialize(value)
+      @value = value
+    end
+
+    def call(label:, default:)
+      @value.nil? ? default : @value
+    end
+  end
+
+  def test_returns_disabled_when_user_declines_manifest
+    prompt = Csvtool::Interface::CLI::Prompts::SplitManifestPrompt.new(
+      stdin: StringIO.new,
+      stdout: StringIO.new,
+      yes_no_prompt: FakeYesNoPrompt.new(false)
+    )
+
+    result = prompt.call(default_path: "/tmp/manifest.csv")
+
+    assert_equal false, result[:write_manifest]
+    assert_nil result[:manifest_path]
+  end
+
+  def test_uses_default_manifest_path_when_blank
+    prompt = Csvtool::Interface::CLI::Prompts::SplitManifestPrompt.new(
+      stdin: StringIO.new("\n"),
+      stdout: StringIO.new,
+      yes_no_prompt: FakeYesNoPrompt.new(true)
+    )
+
+    result = prompt.call(default_path: "/tmp/manifest.csv")
+
+    assert_equal true, result[:write_manifest]
+    assert_equal "/tmp/manifest.csv", result[:manifest_path]
+  end
+end

data/test/csvtool/interface/cli/prompts/split_output_prompt_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../../../../test_helper"
+require "csvtool/interface/cli/prompts/split_output_prompt"
+require "csvtool/interface/cli/prompts/yes_no_prompt"
+
+class SplitOutputPromptTest < Minitest::Test
+  def test_uses_defaults_for_blank_values
+    out = StringIO.new
+    prompt = Csvtool::Interface::CLI::Prompts::SplitOutputPrompt.new(
+      stdin: StringIO.new("\n\n\n"),
+      stdout: out,
+      yes_no_prompt: Csvtool::Interface::CLI::Prompts::YesNoPrompt.new(stdin: StringIO.new("\n"), stdout: StringIO.new)
+    )
+
+    result = prompt.call(default_directory: "/tmp/out", default_prefix: "people")
+
+    assert_equal "/tmp/out", result[:output_directory]
+    assert_equal "people", result[:file_prefix]
+    assert_equal false, result[:overwrite_existing]
+  end
+end

data/test/csvtool/interface/cli/workflows/builders/csv_split_session_builder_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/builders/csv_split_session_builder"
+
+class CsvSplitSessionBuilderTest < Minitest::Test
+  def test_builds_split_session
+    session = Csvtool::Interface::CLI::Workflows::Builders::CsvSplitSessionBuilder.new.call(
+      file_path: "/tmp/people.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"
+    )
+
+    assert_equal "/tmp/people.csv", session.source.path
+    assert_equal ",", session.source.separator
+    assert_equal true, session.source.headers_present
+    assert_equal 10, session.options.chunk_size
+    assert_equal "/tmp/out", session.options.output_directory
+    assert_equal "batch", session.options.file_prefix
+    assert_equal true, session.options.overwrite_existing
+    assert_equal true, session.options.write_manifest
+    assert_equal "/tmp/out/manifest.csv", session.options.manifest_path
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../../../../test_helper"
+require "csvtool/interface/cli/workflows/presenters/csv_split_presenter"
+
+class CsvSplitPresenterTest < Minitest::Test
+  def test_prints_summary_and_chunk_paths
+    out = StringIO.new
+    presenter = Csvtool::Interface::CLI::Workflows::Presenters::CsvSplitPresenter.new(stdout: out)
+
+    presenter.print_summary(
+      chunk_size: 10,
+      data_rows: 25,
+      chunk_count: 3,
+      manifest_path: "/tmp/manifest.csv",
+      chunk_paths: ["/tmp/people_part_001.csv", "/tmp/people_part_002.csv", "/tmp/people_part_003.csv"]
+    )
+
+    assert_includes out.string, "Split complete."
+    assert_includes out.string, "Chunk size: 10"
+    assert_includes out.string, "Data rows: 25"
+    assert_includes out.string, "Chunks written: 3"
+    assert_includes out.string, "Manifest: /tmp/manifest.csv"
+    assert_includes out.string, "/tmp/people_part_001.csv"
+  end
+end

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/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