tapsoob 0.8.6-java → 0.8.7-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 507d0809e6ce3577c927ca3403a84702cd81737987535709ea1ac9d946001727
-  data.tar.gz: 42eac9c4f181ddcb29d046267715d367ba05b65cdef9c6a427eb8181b37b7190
+  metadata.gz: 146ca85995071f912509d794d2436fd26f3c9adfcef5f72178af08025578fd94
+  data.tar.gz: 8d96d10769f796ba102dda47893625450dcd73ca73eb94bca0f302ff03fdcc12
 SHA512:
-  metadata.gz: d4a69103da5d43b36acc62bbf186dcc0d3864eeea09ed74fba8c9cbf9807676cdac8ea3bd0bbd66a681661ae9fdc072abad07029f50d2ccb1519cc1a9679f24b
-  data.tar.gz: 191cb27f4048d18c3df96013f7c3275965e348c7a169a928b605901e6d296d6fcd0689717dcd788c9b2539ec6138380ddca33bab916f9484016280b17b5c074b
+  metadata.gz: f7ab5c568c2c2c51356fab7aacce84f6fc41fcc898ed5f38d6bcef3f8e59b94452cac19a5fdcb9fa84e68d3084775deb4e50ef2a73834a9e066a40b15203c094
+  data.tar.gz: ea9d5d6185def0e29bc686ed088558df1098d8d99ac49312f1e33a8c3e484df8897c1b5bab76e49dc7aa9a35a43c4c63c7e2a7c5bd401862247a2beb9a31e426

data/lib/tapsoob/cli/schema.rb

@@ -29,7 +29,7 @@ module Tapsoob
 
       desc "dump_table DATABASE_URL TABLE", "Dump a table from a database using a database URL"
       def dump_table(database_url, table)
-        puts Tapsoob::Schema.dump_table(database_url, table)
+        puts Tapsoob::Schema.dump_table(database_url, table, {})
       end
 
       desc "foreign_keys DATABASE_URL", "Dump foreign_keys from a database using a database URL"

data/lib/tapsoob/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module Tapsoob
-  VERSION = "0.8.6".freeze
+  VERSION = "0.8.7".freeze
 end

data/spec/spec_helper.rb

@@ -45,6 +45,7 @@ RSpec.configure do |config|
   # Integration tests require a real DB — skip unless env vars are set.
   config.filter_run_excluding :integration unless ENV['INTEGRATION_TESTS'] || ENV['SRC_DATABASE_URL']
 
-  config.include DbHelpers,       :integration
-  config.include RoundTripHelper, :integration
+  config.include DbHelpers,        :integration
+  config.include RoundTripHelper,  :integration
+  config.include OperationHelpers
 end

data/spec/support/operation_helpers.rb

@@ -0,0 +1,43 @@
+require 'tapsoob/operation/pull'
+require 'tapsoob/operation/push'
+
+# Shared helpers for unit specs that exercise Pull / Push / Base.
+# Included automatically via spec_helper for all unit specs.
+module OperationHelpers
+  # Default opts used across pull/push/base unit tests.
+  UNIT_OPTS = {
+    data:              true,
+    schema:            true,
+    indexes:           false,
+    progress:          false,
+    default_chunksize: 1000,
+    no_split:          true,
+  }.freeze
+
+  # A pre-seeded in-memory SQLite DB with :users (5 rows) and :widgets (3 rows).
+  # Returns a new connection each call — callers own disconnection.
+  def seeded_sqlite_db
+    d = connect_sqlite
+    d.create_table(:users)   { primary_key :id; String :name }
+    d.create_table(:widgets) { primary_key :id; Integer :qty }
+    5.times { |i| d[:users].insert(name: "user_#{i}") }
+    3.times { |i| d[:widgets].insert(qty: i * 10) }
+    d
+  end
+
+  def build_pull(db, dump_dir, extra_opts = {})
+    op = Tapsoob::Operation::Pull.new(sqlite_memory_url, dump_dir, UNIT_OPTS.merge(extra_opts))
+    op.instance_variable_set(:@db, db)
+    op
+  end
+
+  def build_push(db_url, dump_dir, extra_opts = {})
+    Tapsoob::Operation::Push.new(db_url, dump_dir, UNIT_OPTS.merge(extra_opts))
+  end
+
+  def build_base(db, dump_dir, extra_opts = {})
+    op = Tapsoob::Operation::Pull.new(sqlite_memory_url, dump_dir, UNIT_OPTS.merge(extra_opts))
+    op.instance_variable_set(:@db, db)
+    op
+  end
+end

data/spec/unit/tapsoob/base_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+require 'tapsoob/operation/base'
+require 'tapsoob/operation/pull'
+require 'tapsoob/operation/push'
+
+RSpec.describe Tapsoob::Operation::Base do
+  let(:db)       { seeded_sqlite_db }
+  let(:dump_dir) { Dir.mktmpdir("tapsoob_base_") }
+
+  after do
+    db.disconnect
+    FileUtils.rm_rf(dump_dir)
+  end
+
+  # ── format_number ────────────────────────────────────────────────────────────
+
+  describe '#format_number' do
+    it 'formats numbers with commas' do
+      op = build_base(db, dump_dir)
+      expect(op.format_number(1_000_000)).to eq("1,000,000")
+      expect(op.format_number(1234)).to eq("1,234")
+      expect(op.format_number(999)).to eq("999")
+    end
+  end
+
+  # ── resuming? ────────────────────────────────────────────────────────────────
+
+  describe '#resuming?' do
+    it 'returns false by default' do
+      expect(build_base(db, dump_dir).resuming?).to be false
+    end
+
+    it 'returns true when :resume is set' do
+      expect(build_base(db, dump_dir, resume: true).resuming?).to be true
+    end
+  end
+
+  # ── parallel? / parallel_workers ─────────────────────────────────────────────
+
+  describe '#parallel?' do
+    it 'returns false when parallel is 1' do
+      expect(build_base(db, dump_dir, parallel: 1).parallel?).to be false
+    end
+
+    it 'returns true when parallel > 1' do
+      expect(build_base(db, dump_dir, parallel: 2).parallel?).to be true
+    end
+  end
+
+  describe '#parallel_workers' do
+    it 'defaults to 1' do
+      expect(build_base(db, dump_dir).parallel_workers).to eq(1)
+    end
+
+    it 'returns the requested count' do
+      expect(build_base(db, dump_dir, parallel: 4).parallel_workers).to eq(4)
+    end
+  end
+
+  # ── table_parallel_workers ───────────────────────────────────────────────────
+
+  describe '#table_parallel_workers' do
+    it 'returns 1 when no_split is set' do
+      expect(build_base(db, dump_dir, no_split: true).table_parallel_workers(:users, 5_000_000)).to eq(1)
+    end
+
+    it 'returns 1 when dump_path is nil' do
+      op = Tapsoob::Operation::Pull.new(sqlite_memory_url, nil, { default_chunksize: 1000 })
+      expect(op.table_parallel_workers(:users, 5_000_000)).to eq(1)
+    end
+
+    it 'returns 1 when row_count is below threshold' do
+      expect(build_base(db, dump_dir, no_split: false).table_parallel_workers(:users, 50_000)).to eq(1)
+    end
+
+    it 'returns >= 2 for a very large table' do
+      expect(build_base(db, dump_dir, no_split: false).table_parallel_workers(:users, 5_000_000)).to be >= 2
+    end
+
+    it 'returns >= 2 for a 1M+ row table' do
+      expect(build_base(db, dump_dir, no_split: false).table_parallel_workers(:users, 1_000_000)).to be >= 2
+    end
+
+    it 'returns >= 2 for a 500K+ row table' do
+      expect(build_base(db, dump_dir, no_split: false).table_parallel_workers(:users, 500_000)).to be >= 2
+    end
+
+    it 'returns 2 for a table just over the 100K threshold' do
+      expect(build_base(db, dump_dir, no_split: false).table_parallel_workers(:users, 150_000)).to eq(2)
+    end
+  end
+
+  # ── stream_state ─────────────────────────────────────────────────────────────
+
+  describe '#stream_state / #stream_state=' do
+    it 'defaults to empty hash' do
+      expect(build_base(db, dump_dir).stream_state).to eq({})
+    end
+
+    it 'stores and retrieves state' do
+      op = build_base(db, dump_dir)
+      op.stream_state = { table_name: :users }
+      expect(op.stream_state).to eq({ table_name: :users })
+    end
+  end
+
+  # ── add_completed_table ──────────────────────────────────────────────────────
+
+  describe '#add_completed_table' do
+    it 'appends to completed_tables thread-safely' do
+      op = build_base(db, dump_dir)
+      op.add_completed_table(:users)
+      op.add_completed_table(:widgets)
+      expect(op.completed_tables).to include("users", "widgets")
+    end
+  end
+
+  # ── max_intra_table_workers ──────────────────────────────────────────────────
+
+  describe '#max_intra_table_workers' do
+    it 'returns at least 2' do
+      expect(build_base(db, dump_dir).max_intra_table_workers).to be >= 2
+    end
+  end
+
+  # ── catch_errors ─────────────────────────────────────────────────────────────
+
+  describe '#catch_errors' do
+    it 'yields and returns the block result' do
+      expect(build_base(db, dump_dir).send(:catch_errors) { 42 }).to eq(42)
+    end
+
+    it 're-raises exceptions' do
+      op = build_base(db, dump_dir)
+      expect { op.send(:catch_errors) { raise ArgumentError, "boom" } }.to raise_error(ArgumentError, "boom")
+    end
+  end
+
+  # ── apply_table_filter (array form) ──────────────────────────────────────────
+
+  describe '#apply_table_filter' do
+    it 'filters an array by table_filter' do
+      op = build_base(db, dump_dir, tables: ["users"])
+      expect(op.apply_table_filter(["users", "widgets"])).to eq(["users"])
+    end
+
+    it 'excludes tables from an array' do
+      op = build_base(db, dump_dir, exclude_tables: ["widgets"])
+      expect(op.apply_table_filter(["users", "widgets"])).to eq(["users"])
+    end
+  end
+
+  # ── Base.factory ─────────────────────────────────────────────────────────────
+
+  describe '.factory' do
+    it 'returns a Pull instance for :pull type' do
+      expect(described_class.factory(:pull, sqlite_memory_url, dump_dir, { default_chunksize: 1000 })).to be_a(Tapsoob::Operation::Pull)
+    end
+
+    it 'returns a Push instance for :push type' do
+      expect(described_class.factory(:push, sqlite_memory_url, dump_dir, { default_chunksize: 1000 })).to be_a(Tapsoob::Operation::Push)
+    end
+
+    it 'raises for unknown type' do
+      expect { described_class.factory(:unknown, sqlite_memory_url, dump_dir, {}) }
+        .to raise_error(RuntimeError, /Unknown Operation Type/)
+    end
+
+    it 'returns a resume instance when opts[:resume] is true' do
+      op = build_pull(db, dump_dir)
+      op.initialize_dump_directory
+      op.pull_schema
+
+      # Pull#to_hash calls remote_tables_info which requires an active pull run;
+      # use the base to_hash binding to get just the serializable fields.
+      hash = Tapsoob::Operation::Base.instance_method(:to_hash).bind(op).call
+      resumed = described_class.factory(:pull, sqlite_memory_url, dump_dir,
+        hash.merge(resume: true, klass: "Tapsoob::Operation::Pull", default_chunksize: 1000))
+      expect(resumed).to be_a(Tapsoob::Operation::Pull)
+    end
+  end
+
+  # ── exiting? / setup_signal_trap ─────────────────────────────────────────────
+
+  describe '#exiting?' do
+    it 'returns false initially' do
+      expect(build_base(db, dump_dir).exiting?).to be false
+    end
+  end
+
+  describe '#setup_signal_trap' do
+    it 'registers signal handlers without error' do
+      op = build_base(db, dump_dir)
+      expect { op.setup_signal_trap }.not_to raise_error
+    end
+  end
+
+  # ── can_use_pk_partitioning? ─────────────────────────────────────────────────
+
+  describe '#can_use_pk_partitioning?' do
+    it 'returns true for a table with a single integer PK' do
+      op = build_base(db, dump_dir)
+      expect(op.can_use_pk_partitioning?(:users)).to be true
+    end
+  end
+
+  # ── db / default_chunksize ───────────────────────────────────────────────────
+
+  describe '#default_chunksize' do
+    it 'returns the value from opts' do
+      expect(build_base(db, dump_dir, default_chunksize: 500).default_chunksize).to eq(500)
+    end
+  end
+
+  describe '#table_filter / #exclude_tables' do
+    it 'returns empty arrays by default' do
+      op = build_base(db, dump_dir)
+      expect(op.table_filter).to eq([])
+      expect(op.exclude_tables).to eq([])
+    end
+  end
+end

data/spec/unit/tapsoob/cli_pipeline_spec.rb

@@ -0,0 +1,380 @@
+require 'spec_helper'
+require 'tapsoob/cli'
+
+# CLI pipeline specs — invoke Thor commands the same way clients do in rake tasks:
+#
+#   tapsoob schema dump    <src_url>
+#   tapsoob schema load    <dst_url>
+#   tapsoob schema indexes <src_url>
+#   tapsoob schema load_indexes <dst_url>
+#   tapsoob schema foreign_keys <src_url>
+#   tapsoob schema load_foreign_keys <dst_url>
+#   tapsoob data   pull    <src_url>  [dump_path]
+#   tapsoob data   push    <dst_url>  [dump_path]
+#   tapsoob schema reset_db_sequences <dst_url>
+#   tapsoob pull   <dump_path> <src_url>
+#   tapsoob push   <dump_path> <dst_url>
+#   tapsoob version
+
+RSpec.describe "CLI pipelines" do
+  # ── helpers ──────────────────────────────────────────────────────────────────
+
+  def make_db(path)
+    url = DbHelpers.adapt_url("sqlite://#{path}")
+    db  = Sequel.connect(url)
+    db.extension :schema_dumper
+    db
+  end
+
+  def seed_db(db)
+    db.create_table(:users)   { primary_key :id; String :name, null: false }
+    db.create_table(:widgets) { primary_key :id; Integer :qty, default: 0 }
+    3.times { |i| db[:users].insert(name: "user_#{i}") }
+    2.times { |i| db[:widgets].insert(qty: i * 5) }
+  end
+
+  # Invoke a Thor subclass with argv, swallowing stdout/stderr output.
+  def run_cli(klass, argv)
+    klass.start(argv, debug: false)
+  end
+
+  # ── shared setup ─────────────────────────────────────────────────────────────
+
+  let(:tmp)      { Dir.mktmpdir("tapsoob_cli_") }
+  let(:src_path) { File.join(tmp, "src.db") }
+  let(:dst_path) { File.join(tmp, "dst.db") }
+  let(:dump_dir) { File.join(tmp, "dump") }
+  let(:src_url)  { DbHelpers.adapt_url("sqlite://#{src_path}") }
+  let(:dst_url)  { DbHelpers.adapt_url("sqlite://#{dst_path}") }
+
+  let(:src_db) do
+    db = make_db(src_path)
+    seed_db(db)
+    db
+  end
+
+  # Ensure src_db is created before tests run and everything is cleaned up after.
+  before { src_db }
+  after  do
+    src_db.disconnect rescue nil
+    FileUtils.rm_rf(tmp)
+  end
+
+  # ── tapsoob version ───────────────────────────────────────────────────────────
+
+  describe "tapsoob version" do
+    it 'prints the version string' do
+      expect { run_cli(Tapsoob::CLI::Root, ["version"]) }.to output(/\d+\.\d+/).to_stdout
+    end
+  end
+
+  # ── schema dump | schema load pipeline ───────────────────────────────────────
+
+  describe "schema dump → load pipeline" do
+    it 'dumps schema to stdout and loads it into a fresh DB' do
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      expect(schema_text).to include("users", "widgets")
+
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+
+      dst_db = make_db(dst_path)
+      begin
+        run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+        expect(dst_db.table_exists?(:users)).to be true
+        expect(dst_db.table_exists?(:widgets)).to be true
+      ensure
+        dst_db.disconnect
+      end
+    end
+
+    it 'schema load is idempotent when destination is fresh' do
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+
+      dst_db = make_db(dst_path)
+      begin
+        run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+        expect(dst_db.table_exists?(:users)).to be true
+        expect(dst_db.table_exists?(:widgets)).to be true
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── indexes pipeline ──────────────────────────────────────────────────────────
+
+  describe "schema indexes → load_indexes pipeline" do
+    it 'dumps indexes and loads them without error' do
+      index_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["indexes", src_url]) }
+      index_file = File.join(tmp, "indexes.rb")
+      File.write(index_file, index_text)
+
+      # Load schema first so destination tables exist
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      expect { run_cli(Tapsoob::CLI::Schema, ["load_indexes", dst_url, index_file]) }.not_to raise_error
+    end
+  end
+
+  # ── foreign_keys pipeline ─────────────────────────────────────────────────────
+
+  describe "schema foreign_keys → load_foreign_keys pipeline" do
+    it 'dumps foreign keys and loads them without error' do
+      fk_text  = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["foreign_keys", src_url]) }
+      fk_file  = File.join(tmp, "fk.rb")
+      File.write(fk_file, fk_text)
+
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      expect { run_cli(Tapsoob::CLI::Schema, ["load_foreign_keys", dst_url, fk_file]) }.not_to raise_error
+    end
+  end
+
+  # ── reset_db_sequences ────────────────────────────────────────────────────────
+
+  describe "schema reset_db_sequences" do
+    it 'resets sequences on the destination DB without error' do
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      expect { run_cli(Tapsoob::CLI::Schema, ["reset_db_sequences", dst_url]) }.not_to raise_error
+    end
+  end
+
+  # ── data pull → push pipeline (dump_path mode) ───────────────────────────────
+
+  describe "data pull → push pipeline" do
+    before do
+      %w[data schemas indexes].each { |d| FileUtils.mkdir_p(File.join(dump_dir, d)) }
+      ordered = src_db.send(:sort_dumped_tables, src_db.tables, {}).map(&:to_s)
+      File.write(File.join(dump_dir, "table_order.txt"), ordered.join("\n") + "\n")
+    end
+
+    it 'pulls data into dump_dir and pushes it to destination' do
+      # Load schema into dst first
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      run_cli(Tapsoob::CLI::DataStream, ["pull", src_url, dump_dir, "--progress=false", "--chunksize=1000"])
+      run_cli(Tapsoob::CLI::DataStream, ["push", dst_url, dump_dir, "--progress=false", "--chunksize=1000"])
+
+      dst_db = make_db(dst_path)
+      begin
+        expect(dst_db[:users].count).to eq(3)
+        expect(dst_db[:widgets].count).to eq(2)
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── tapsoob pull → push (Root command, full round-trip) ──────────────────────
+
+  describe "tapsoob pull → push (Root commands)" do
+    it 'performs a full schema+data round-trip via pull/push commands' do
+      run_cli(Tapsoob::CLI::Root, ["pull", dump_dir, src_url,
+        "--progress=false", "--chunksize=1000", "--no-split"])
+      run_cli(Tapsoob::CLI::Root, ["push", dump_dir, dst_url,
+        "--progress=false", "--chunksize=1000"])
+
+      dst_db = make_db(dst_path)
+      begin
+        expect(dst_db.table_exists?(:users)).to be true
+        expect(dst_db[:users].count).to eq(3)
+        expect(dst_db[:widgets].count).to eq(2)
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── schema dump_table ─────────────────────────────────────────────────────────
+
+  describe "schema dump_table" do
+    it 'dumps a single table schema to stdout' do
+      output = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump_table", src_url, "users"]) }
+      expect(output).to include("users")
+    end
+  end
+
+  # ── data push --purge flag ────────────────────────────────────────────────────
+
+  describe "data push --purge" do
+    before do
+      %w[data schemas indexes].each { |d| FileUtils.mkdir_p(File.join(dump_dir, d)) }
+      ordered = src_db.send(:sort_dumped_tables, src_db.tables, {}).map(&:to_s)
+      File.write(File.join(dump_dir, "table_order.txt"), ordered.join("\n") + "\n")
+    end
+
+    it 'truncates destination tables before inserting' do
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      run_cli(Tapsoob::CLI::DataStream, ["pull", src_url, dump_dir, "--progress=false"])
+      run_cli(Tapsoob::CLI::DataStream, ["push", dst_url, dump_dir, "--progress=false", "--purge"])
+
+      dst_db = make_db(dst_path)
+      begin
+        expect(dst_db[:users].count).to eq(3)
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── schema indexes_individual ─────────────────────────────────────────────────
+
+  describe "schema indexes_individual" do
+    it 'dumps per-table index JSON without error' do
+      expect {
+        capture_stdout { run_cli(Tapsoob::CLI::Schema, ["indexes_individual", src_url]) }
+      }.not_to raise_error
+    end
+  end
+
+  # ── schema load via STDIN ────────────────────────────────────────────────────
+
+  describe "schema load via STDIN" do
+    it 'reads schema from STDIN when no filename is given' do
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+
+      stub_const("STDIN", StringIO.new(schema_text))
+
+      dst_db = make_db(dst_path)
+      begin
+        run_cli(Tapsoob::CLI::Schema, ["load", dst_url])
+        expect(dst_db.table_exists?(:users)).to be true
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── schema load_foreign_keys via STDIN ───────────────────────────────────────
+
+  describe "schema load_foreign_keys via STDIN" do
+    it 'reads foreign keys from STDIN when no filename is given' do
+      fk_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["foreign_keys", src_url]) }
+
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      stub_const("STDIN", StringIO.new(fk_text))
+      expect { run_cli(Tapsoob::CLI::Schema, ["load_foreign_keys", dst_url]) }.not_to raise_error
+    end
+  end
+
+  # ── schema load_indexes via STDIN ────────────────────────────────────────────
+
+  describe "schema load_indexes via STDIN" do
+    it 'reads indexes from STDIN when no filename is given' do
+      index_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["indexes", src_url]) }
+
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      stub_const("STDIN", StringIO.new(index_text))
+      expect { run_cli(Tapsoob::CLI::Schema, ["load_indexes", dst_url]) }.not_to raise_error
+    end
+  end
+
+  # ── root pull --resume with missing file (parse_opts error path) ─────────────
+
+  describe "root pull --resume with non-existent file" do
+    it 'raises when the resume file does not exist' do
+      expect {
+        run_cli(Tapsoob::CLI::Root, ["pull", dump_dir, src_url,
+          "--resume=/tmp/nonexistent_tapsoob_#{Process.pid}.dat",
+          "--progress=false"])
+      }.to raise_error(RuntimeError, /Unable to find resume file/)
+    end
+  end
+
+  # ── root pull --config option ─────────────────────────────────────────────────
+
+  describe "root pull --config with a YAML config file" do
+    it 'loads options from a config YAML file' do
+      config_file = File.join(tmp, "tapsoob.yml")
+      File.write(config_file, { "progress" => false }.to_yaml)
+
+      expect {
+        run_cli(Tapsoob::CLI::Root, ["pull", dump_dir, src_url,
+          "--config=#{config_file}", "--progress=false", "--chunksize=1000", "--no-split"])
+      }.not_to raise_error
+    end
+  end
+
+  # ── data push via STDIN ───────────────────────────────────────────────────────
+
+  describe "data push via STDIN" do
+    it 'imports rows from STDIN JSON when no dump_path is given' do
+      # Set up schema in destination first
+      schema_text = capture_stdout { run_cli(Tapsoob::CLI::Schema, ["dump", src_url]) }
+      schema_file = File.join(tmp, "schema.rb")
+      File.write(schema_file, schema_text)
+      run_cli(Tapsoob::CLI::Schema, ["load", dst_url, schema_file])
+
+      # Generate valid NDJSON for the users table
+      ndjson_line = JSON.generate({
+        table_name: "users",
+        header: ["id", "name"],
+        types: ["integer", "string"],
+        data: [[100, "stdin_user"]]
+      })
+
+      fake_stdin = StringIO.new(ndjson_line + "\n")
+      stub_const("STDIN", fake_stdin)
+
+      run_cli(Tapsoob::CLI::DataStream, ["push", dst_url, "--progress=false"])
+
+      dst_db = make_db(dst_path)
+      begin
+        expect(dst_db[:users].where(id: 100).first).not_to be_nil
+      ensure
+        dst_db.disconnect
+      end
+    end
+  end
+
+  # ── data pull --parallel warning ──────────────────────────────────────────────
+
+  describe "data pull parallel-to-STDOUT warning" do
+    it 'falls back to serial (no error) when parallel > 1 and no dump_path' do
+      # The code emits a warning to STDERR and resets parallel to 1, then runs serial pull.
+      expect {
+        capture_stdout { run_cli(Tapsoob::CLI::DataStream, ["pull", src_url, "--parallel=2", "--progress=false"]) }
+      }.not_to raise_error
+    end
+  end
+
+  # ── helper ───────────────────────────────────────────────────────────────────
+
+  def capture_stdout(&block)
+    old = $stdout
+    $stdout = StringIO.new
+    block.call
+    $stdout.string
+  ensure
+    $stdout = old
+  end
+
+end