csvops 0.3.0.alpha → 0.5.0.alpha

data/test/csvtool/domain/cross_csv_dedupe_session/cross_csv_dedupe_session_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/cross_csv_dedupe_session/cross_csv_dedupe_session"
+require "csvtool/domain/cross_csv_dedupe_session/csv_profile"
+require "csvtool/domain/cross_csv_dedupe_session/column_selector"
+require "csvtool/domain/cross_csv_dedupe_session/key_mapping"
+require "csvtool/domain/cross_csv_dedupe_session/match_options"
+require "csvtool/domain/shared/output_destination"
+
+class CrossCsvDedupeSessionTest < Minitest::Test
+  def test_start_and_with_output_destination
+    source = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: "/tmp/source.csv",
+      separator: ",",
+      headers_present: true
+    )
+    reference = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: "/tmp/reference.csv",
+      separator: ",",
+      headers_present: true
+    )
+    key_mapping = Csvtool::Domain::CrossCsvDedupeSession::KeyMapping.new(
+      source_selector: Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "source_id"),
+      reference_selector: Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "reference_id")
+    )
+    match_options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: true,
+      case_insensitive: false
+    )
+
+    session = Csvtool::Domain::CrossCsvDedupeSession::CrossCsvDedupeSession.start(
+      source: source,
+      reference: reference,
+      key_mapping: key_mapping,
+      match_options: match_options
+    )
+
+    destination = Csvtool::Domain::Shared::OutputDestination.console
+    updated = session.with_output_destination(destination)
+
+    assert_equal source, updated.source
+    assert_equal reference, updated.reference
+    assert_equal key_mapping, updated.key_mapping
+    assert_equal match_options, updated.match_options
+    assert_equal destination, updated.output_destination
+  end
+
+  def test_rejects_invalid_source_type
+    reference = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: "/tmp/reference.csv",
+      separator: ",",
+      headers_present: true
+    )
+    key_mapping = Csvtool::Domain::CrossCsvDedupeSession::KeyMapping.new(
+      source_selector: Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "source_id"),
+      reference_selector: Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "reference_id")
+    )
+    match_options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: true,
+      case_insensitive: false
+    )
+
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::CrossCsvDedupeSession::CrossCsvDedupeSession.start(
+        source: "bad",
+        reference: reference,
+        key_mapping: key_mapping,
+        match_options: match_options
+      )
+    end
+
+    assert_equal "source must be CsvProfile", error.message
+  end
+end

data/test/csvtool/domain/cross_csv_dedupe_session/csv_profile_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/cross_csv_dedupe_session/csv_profile"
+
+class CrossCsvDedupeCsvProfileTest < Minitest::Test
+  def test_initializes_with_expected_fields
+    profile = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: "/tmp/source.csv",
+      separator: ",",
+      headers_present: true
+    )
+
+    assert_equal "/tmp/source.csv", profile.path
+    assert_equal ",", profile.separator
+    assert_equal true, profile.headers_present?
+  end
+
+  def test_requires_path
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(path: "", separator: ",", headers_present: true)
+    end
+
+    assert_equal "path cannot be empty", error.message
+  end
+end

data/test/csvtool/domain/cross_csv_dedupe_session/key_mapping_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/cross_csv_dedupe_session/key_mapping"
+require "csvtool/domain/cross_csv_dedupe_session/column_selector"
+
+class CrossCsvDedupeKeyMappingTest < Minitest::Test
+  def test_holds_source_and_reference_selectors
+    source_selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "source_id")
+    reference_selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: "ref_id")
+
+    mapping = Csvtool::Domain::CrossCsvDedupeSession::KeyMapping.new(
+      source_selector: source_selector,
+      reference_selector: reference_selector
+    )
+
+    assert_equal source_selector, mapping.source_selector
+    assert_equal reference_selector, mapping.reference_selector
+  end
+
+  def test_rejects_non_selector_inputs
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::CrossCsvDedupeSession::KeyMapping.new(
+        source_selector: "id",
+        reference_selector: "external_id"
+      )
+    end
+
+    assert_equal "selectors must be ColumnSelector", error.message
+  end
+end

data/test/csvtool/domain/cross_csv_dedupe_session/match_options_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/cross_csv_dedupe_session/match_options"
+
+class CrossCsvDedupeMatchOptionsTest < Minitest::Test
+  def test_predicates_return_boolean_flags
+    options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: true,
+      case_insensitive: false
+    )
+
+    assert_equal true, options.trim_whitespace?
+    assert_equal false, options.case_insensitive?
+  end
+
+  def test_normalize_trim_on_case_off
+    options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: true,
+      case_insensitive: false
+    )
+
+    assert_equal "AbC", options.normalize(" AbC ")
+  end
+
+  def test_normalize_trim_on_case_on
+    options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: true,
+      case_insensitive: true
+    )
+
+    assert_equal "abc", options.normalize(" AbC ")
+  end
+
+  def test_normalize_trim_off_case_on
+    options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: false,
+      case_insensitive: true
+    )
+
+    assert_equal " abc ", options.normalize(" AbC ")
+  end
+
+  def test_normalize_trim_off_case_off
+    options = Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: false,
+      case_insensitive: false
+    )
+
+    assert_equal " AbC ", options.normalize(" AbC ")
+  end
+end

data/test/csvtool/domain/row_randomization_session/randomization_session_test.rb

@@ -4,7 +4,7 @@ require_relative "../../../test_helper"
 require "csvtool/domain/row_randomization_session/randomization_session"
 require "csvtool/domain/row_randomization_session/randomization_source"
 require "csvtool/domain/row_randomization_session/randomization_options"
-require "csvtool/domain/row_randomization_session/randomization_output_destination"
+require "csvtool/domain/shared/output_destination"
 
 class RandomizationSessionTest < Minitest::Test
   def test_with_output_destination_returns_updated_session
@@ -15,7 +15,7 @@ class RandomizationSessionTest < Minitest::Test
     )
     options = Csvtool::Domain::RowRandomizationSession::RandomizationOptions.new(seed: 7)
     session = Csvtool::Domain::RowRandomizationSession::RandomizationSession.start(source: source, options: options)
-    destination = Csvtool::Domain::RowRandomizationSession::RandomizationOutputDestination.console
+    destination = Csvtool::Domain::Shared::OutputDestination.console
 
     updated = session.with_output_destination(destination)
 

data/test/csvtool/domain/row_randomization_session/randomization_source_test.rb

@@ -17,12 +17,26 @@ class RandomizationSourceTest < Minitest::Test
   end
 
   def test_rejects_empty_separator
-    assert_raises(ArgumentError) do
+    error = assert_raises(ArgumentError) do
       Csvtool::Domain::RowRandomizationSession::RandomizationSource.new(
         path: "/tmp/a.csv",
         separator: "",
         headers_present: true
       )
     end
+
+    assert_equal "separator cannot be empty", error.message
+  end
+
+  def test_rejects_empty_path
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::RowRandomizationSession::RandomizationSource.new(
+        path: "",
+        separator: ",",
+        headers_present: true
+      )
+    end
+
+    assert_equal "path cannot be empty", error.message
   end
 end

data/test/csvtool/domain/row_session/row_session_test.rb

@@ -4,7 +4,7 @@ require_relative "../../../test_helper"
 require "csvtool/domain/row_session/row_session"
 require "csvtool/domain/row_session/row_source"
 require "csvtool/domain/row_session/row_range"
-require "csvtool/domain/row_session/row_output_destination"
+require "csvtool/domain/shared/output_destination"
 
 class RowSessionTest < Minitest::Test
   def test_starts_and_sets_output_destination
@@ -12,7 +12,7 @@ class RowSessionTest < Minitest::Test
     row_range = Csvtool::Domain::RowSession::RowRange.new(start_row: 1, end_row: 2)
 
     session = Csvtool::Domain::RowSession::RowSession.start(source: source, row_range: row_range)
-    destination = Csvtool::Domain::RowSession::RowOutputDestination.console
+    destination = Csvtool::Domain::Shared::OutputDestination.console
     updated = session.with_output_destination(destination)
 
     assert_equal source, updated.source

data/test/csvtool/domain/row_session/row_source_test.rb

@@ -9,4 +9,20 @@ class RowSourceTest < Minitest::Test
     assert_equal "/tmp/a.csv", source.path
     assert_equal "\t", source.separator
   end
+
+  def test_rejects_empty_path
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::RowSession::RowSource.new(path: "", separator: ",")
+    end
+
+    assert_equal "path cannot be empty", error.message
+  end
+
+  def test_rejects_empty_separator
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::RowSession::RowSource.new(path: "/tmp/a.csv", separator: "")
+    end
+
+    assert_equal "separator cannot be empty", error.message
+  end
 end

data/test/csvtool/domain/shared/output_destination_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/domain/shared/output_destination"
+
+class SharedOutputDestinationTest < Minitest::Test
+  def test_builds_console_and_file_destinations
+    console = Csvtool::Domain::Shared::OutputDestination.console
+    file = Csvtool::Domain::Shared::OutputDestination.file(path: "/tmp/out.csv")
+
+    assert_equal true, console.console?
+    assert_equal false, console.file?
+    assert_equal true, file.file?
+    assert_equal "/tmp/out.csv", file.path
+  end
+
+  def test_rejects_empty_file_path
+    error = assert_raises(ArgumentError) do
+      Csvtool::Domain::Shared::OutputDestination.file(path: "")
+    end
+
+    assert_equal "file output path cannot be empty", error.message
+  end
+end

data/test/csvtool/infrastructure/csv/cross_csv_deduper_test.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/csv/cross_csv_deduper"
+require "csvtool/domain/cross_csv_dedupe_session/column_selector"
+require "csvtool/domain/cross_csv_dedupe_session/match_options"
+require "tmpdir"
+
+class InfrastructureCrossCsvDeduperTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_filters_source_rows_by_reference_column_values
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    result = deduper.call(
+      source_path: fixture_path("dedupe_source.csv"),
+      reference_path: fixture_path("dedupe_reference.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id"),
+      source_col_sep: ",",
+      reference_col_sep: ","
+    )
+
+    assert_equal ["customer_id", "name"], result[:headers]
+    assert_equal 5, result[:source_rows]
+    assert_equal 3, result[:removed_rows]
+    assert_equal 2, result[:kept_rows_count]
+    assert_equal [%w[1 Alice], %w[3 Cara]], result[:kept_rows]
+  end
+
+  def test_normalization_trim_on_case_off
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    result = deduper.call(
+      source_path: fixture_path("dedupe_source_normalization.csv"),
+      reference_path: fixture_path("dedupe_reference_normalization.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id"),
+      match_options: match_options(trim_whitespace: true, case_insensitive: false)
+    )
+
+    assert_equal 3, result[:kept_rows_count]
+  end
+
+  def test_normalization_trim_on_case_on
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    result = deduper.call(
+      source_path: fixture_path("dedupe_source_normalization.csv"),
+      reference_path: fixture_path("dedupe_reference_normalization.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id"),
+      match_options: match_options(trim_whitespace: true, case_insensitive: true)
+    )
+
+    assert_equal 1, result[:kept_rows_count]
+    assert_equal [%w[B2 Bob]], result[:kept_rows]
+  end
+
+  def test_normalization_trim_off_case_on
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    result = deduper.call(
+      source_path: fixture_path("dedupe_source_normalization.csv"),
+      reference_path: fixture_path("dedupe_reference_normalization.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id"),
+      match_options: match_options(trim_whitespace: false, case_insensitive: true)
+    )
+
+    assert_equal 2, result[:kept_rows_count]
+    assert_equal [[" A1 ", "Alice"], %w[B2 Bob]], result[:kept_rows]
+  end
+
+  def test_normalization_trim_off_case_off
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    result = deduper.call(
+      source_path: fixture_path("dedupe_source_normalization.csv"),
+      reference_path: fixture_path("dedupe_reference_normalization.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id"),
+      match_options: match_options(trim_whitespace: false, case_insensitive: false)
+    )
+
+    assert_equal 3, result[:kept_rows_count]
+  end
+
+  def test_each_retained_streams_rows_and_reports_stats
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+    yielded_rows = []
+
+    result = deduper.each_retained(
+      source_path: fixture_path("dedupe_source.csv"),
+      reference_path: fixture_path("dedupe_reference.csv"),
+      source_selector: header_selector("customer_id"),
+      reference_selector: header_selector("external_id")
+    ) { |fields| yielded_rows << fields }
+
+    assert_equal [%w[1 Alice], %w[3 Cara]], yielded_rows
+    assert_equal 5, result[:source_rows]
+    assert_equal 3, result[:removed_rows]
+    assert_equal 2, result[:kept_rows_count]
+    refute_includes result.keys, :kept_rows
+  end
+
+  def test_each_retained_supports_large_inputs_with_streaming
+    deduper = Csvtool::Infrastructure::CSV::CrossCsvDeduper.new
+
+    Dir.mktmpdir do |dir|
+      source_path = File.join(dir, "source.csv")
+      reference_path = File.join(dir, "reference.csv")
+
+      File.open(source_path, "w") do |file|
+        file.puts "id,name"
+        10_000.times { |index| file.puts "#{index},name#{index}" }
+      end
+
+      File.open(reference_path, "w") do |file|
+        file.puts "external_id"
+        10_000.times do |index|
+          file.puts index.to_s if (index % 2).zero?
+        end
+      end
+
+      yielded_count = 0
+      result = deduper.each_retained(
+        source_path: source_path,
+        reference_path: reference_path,
+        source_selector: header_selector("id"),
+        reference_selector: header_selector("external_id")
+      ) { |_fields| yielded_count += 1 }
+
+      assert_equal 10_000, result[:source_rows]
+      assert_equal 5_000, result[:removed_rows]
+      assert_equal 5_000, result[:kept_rows_count]
+      assert_equal 5_000, yielded_count
+    end
+  end
+
+  private
+
+  def header_selector(name)
+    Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(headers_present: true, input: name)
+  end
+
+  def match_options(trim_whitespace:, case_insensitive:)
+    Csvtool::Domain::CrossCsvDedupeSession::MatchOptions.new(
+      trim_whitespace: trim_whitespace,
+      case_insensitive: case_insensitive
+    )
+  end
+end

data/test/csvtool/infrastructure/csv/selector_validator_test.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/csv/selector_validator"
+require "csvtool/domain/cross_csv_dedupe_session/csv_profile"
+require "csvtool/domain/cross_csv_dedupe_session/column_selector"
+
+class InfrastructureSelectorValidatorTest < Minitest::Test
+  def fixture_path(name)
+    File.expand_path("../../../fixtures/#{name}", __dir__)
+  end
+
+  def test_accepts_header_selector_when_column_exists
+    validator = Csvtool::Infrastructure::CSV::SelectorValidator.new
+    profile = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: fixture_path("dedupe_source.csv"),
+      separator: ",",
+      headers_present: true
+    )
+    selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(
+      headers_present: true,
+      input: "customer_id"
+    )
+
+    assert_equal true, validator.valid?(profile: profile, selector: selector)
+  end
+
+  def test_rejects_header_selector_when_column_missing
+    validator = Csvtool::Infrastructure::CSV::SelectorValidator.new
+    profile = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: fixture_path("dedupe_source.csv"),
+      separator: ",",
+      headers_present: true
+    )
+    selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(
+      headers_present: true,
+      input: "missing"
+    )
+
+    assert_equal false, validator.valid?(profile: profile, selector: selector)
+  end
+
+  def test_accepts_index_selector_when_in_range
+    validator = Csvtool::Infrastructure::CSV::SelectorValidator.new
+    profile = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: fixture_path("dedupe_source_no_headers.csv"),
+      separator: ",",
+      headers_present: false
+    )
+    selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(
+      headers_present: false,
+      input: "2"
+    )
+
+    assert_equal true, validator.valid?(profile: profile, selector: selector)
+  end
+
+  def test_rejects_index_selector_when_out_of_range
+    validator = Csvtool::Infrastructure::CSV::SelectorValidator.new
+    profile = Csvtool::Domain::CrossCsvDedupeSession::CsvProfile.new(
+      path: fixture_path("dedupe_source_no_headers.csv"),
+      separator: ",",
+      headers_present: false
+    )
+    selector = Csvtool::Domain::CrossCsvDedupeSession::ColumnSelector.from_input(
+      headers_present: false,
+      input: "9"
+    )
+
+    assert_equal false, validator.valid?(profile: profile, selector: selector)
+  end
+end

data/test/csvtool/infrastructure/output/csv_cross_csv_dedupe_file_writer_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/output/csv_cross_csv_dedupe_file_writer"
+require "tmpdir"
+
+class InfrastructureCsvCrossCsvDedupeFileWriterTest < Minitest::Test
+  class FakeDeduper
+    def each_retained(**_kwargs)
+      yield %w[1 Alice]
+      yield %w[3 Cara]
+      { source_rows: 5, removed_rows: 3, kept_rows_count: 2 }
+    end
+  end
+
+  def test_writes_retained_rows_and_returns_stats
+    writer = Csvtool::Infrastructure::Output::CsvCrossCsvDedupeFileWriter.new(deduper: FakeDeduper.new)
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "deduped.csv")
+      stats = writer.call(
+        path: output_path,
+        headers: ["customer_id", "name"],
+        col_sep: ",",
+        dedupe_options: { source_path: "source.csv", reference_path: "reference.csv" }
+      )
+
+      assert_equal "customer_id,name\n1,Alice\n3,Cara\n", File.read(output_path)
+      assert_equal 2, stats[:kept_rows_count]
+    end
+  end
+end

data/test/csvtool/infrastructure/output/csv_file_writer_test.rb

@@ -2,7 +2,6 @@
 
 require_relative "../../../test_helper"
 require "csvtool/infrastructure/output/csv_file_writer"
-require "csvtool/interface/cli/errors/presenter"
 require "tmpdir"
 
 class InfrastructureCsvFileWriterTest < Minitest::Test
@@ -13,10 +12,7 @@ class InfrastructureCsvFileWriterTest < Minitest::Test
   end
 
   def test_writes_header_and_values
-    stdout = StringIO.new
     writer = Csvtool::Infrastructure::Output::CsvFileWriter.new(
-      stdout: stdout,
-      errors: Csvtool::Interface::CLI::Errors::Presenter.new(stdout: stdout),
       value_streamer: FakeStreamer.new
     )
 

data/test/csvtool/infrastructure/output/csv_randomized_row_file_writer_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../test_helper"
+require "csvtool/infrastructure/output/csv_randomized_row_file_writer"
+require "tmpdir"
+
+class InfrastructureCsvRandomizedRowFileWriterTest < Minitest::Test
+  class FakeRandomizer
+    def each(file_path:, col_sep:, headers:, seed:)
+      yield ["Bob", "Paris"]
+      yield ["Cara", "Berlin"]
+    end
+  end
+
+  def test_writes_randomized_rows_with_headers
+    writer = Csvtool::Infrastructure::Output::CsvRandomizedRowFileWriter.new(row_randomizer: FakeRandomizer.new)
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, "randomized.csv")
+      writer.call(
+        path: output_path,
+        headers: ["name", "city"],
+        file_path: "ignored.csv",
+        col_sep: ",",
+        headers_present: true,
+        seed: 123
+      )
+
+      assert_equal "name,city\nBob,Paris\nCara,Berlin\n", File.read(output_path)
+    end
+  end
+end

data/test/csvtool/infrastructure/output/csv_row_file_writer_test.rb

@@ -2,7 +2,6 @@
 
 require_relative "../../../test_helper"
 require "csvtool/infrastructure/output/csv_row_file_writer"
-require "csvtool/interface/cli/errors/presenter"
 require "tmpdir"
 
 class InfrastructureCsvRowFileWriterTest < Minitest::Test
@@ -15,10 +14,7 @@ class InfrastructureCsvRowFileWriterTest < Minitest::Test
   end
 
   def test_writes_header_and_rows_to_file
-    stdout = StringIO.new
     writer = Csvtool::Infrastructure::Output::CsvRowFileWriter.new(
-      stdout: stdout,
-      errors: Csvtool::Interface::CLI::Errors::Presenter.new(stdout: stdout),
       row_streamer: FakeRowStreamer.new
     )
 
@@ -35,6 +31,7 @@ class InfrastructureCsvRowFileWriterTest < Minitest::Test
 
       assert_equal "name,city\nBob,Paris\nCara,Berlin\n", File.read(output_path)
       assert_equal true, stats[:matched]
+      assert_equal true, stats[:wrote_rows]
     end
   end
 end