tapsoob 0.8.5 → 0.8.7

data/spec/unit/tapsoob/keyed_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'tapsoob/data_stream/keyed'
+
+Sequel.extension :core_extensions
+
+RSpec.describe Tapsoob::DataStream::Keyed do
+  let(:db) do
+    d = connect_sqlite
+    d.extension :schema_dumper
+    d.create_table(:keyed_items) { primary_key :id; String :label }
+    10.times { |i| d[:keyed_items].insert(label: "item_#{i}") }
+    d
+  end
+
+  after { db.disconnect }
+
+  subject(:stream) { described_class.new(db, { table_name: :keyed_items, chunksize: 4 }) }
+
+  # ── primary_key / buffer_limit ───────────────────────────────────────────────
+
+  describe '#primary_key' do
+    it 'returns :id for this table' do
+      expect(stream.primary_key).to eq(:id)
+    end
+  end
+
+  describe '#buffer_limit' do
+    it 'returns filter when buffer is non-empty' do
+      stream.state[:filter] = 5
+      stream.buffer << { id: 1 }
+      expect(stream.buffer_limit).to eq(5)
+    end
+
+    it 'returns last_fetched when it is less than filter and buffer is empty' do
+      stream.state[:filter] = 10
+      stream.state[:last_fetched] = 3
+      stream.buffer.clear
+      expect(stream.buffer_limit).to eq(3)
+    end
+
+    it 'returns filter when last_fetched >= filter' do
+      stream.state[:filter] = 5
+      stream.state[:last_fetched] = 5
+      stream.buffer.clear
+      expect(stream.buffer_limit).to eq(5)
+    end
+  end
+
+  # ── calc_limit ───────────────────────────────────────────────────────────────
+
+  describe '#calc_limit' do
+    it 'returns chunksize * 3 outside Sinatra' do
+      expect(stream.calc_limit(100)).to eq(300)
+    end
+  end
+
+  # ── load_buffer ──────────────────────────────────────────────────────────────
+
+  describe '#load_buffer' do
+    it 'loads rows into the buffer' do
+      stream.load_buffer(4)
+      expect(stream.buffer.size).to be >= 4
+    end
+
+    it 'updates state[:filter] to the last PK in the buffer' do
+      stream.load_buffer(4)
+      expect(stream.state[:filter]).to eq(stream.buffer.last[:id])
+    end
+
+    it 'stops early when the table is exhausted' do
+      stream.load_buffer(1000)
+      expect(stream.buffer.size).to eq(10)
+    end
+  end
+
+  # ── fetch_buffered ───────────────────────────────────────────────────────────
+
+  describe '#fetch_buffered' do
+    it 'returns up to chunksize rows' do
+      rows = stream.fetch_buffered(4)
+      expect(rows.size).to eq(4)
+    end
+
+    it 'records last_fetched as the PK of the last returned row' do
+      rows = stream.fetch_buffered(4)
+      expect(stream.state[:last_fetched]).to eq(rows.last[:id])
+    end
+
+    it 'returns nil last_fetched when no rows available' do
+      # drain the table
+      stream.load_buffer(100)
+      stream.buffer.clear
+      rows = stream.fetch_buffered(4)
+      expect(rows).to be_empty
+      expect(stream.state[:last_fetched]).to be_nil
+    end
+  end
+
+  # ── increment ────────────────────────────────────────────────────────────────
+
+  describe '#increment' do
+    it 'removes n rows from the front of the buffer' do
+      stream.load_buffer(6)
+      original_fourth = stream.buffer[3]
+      stream.increment(3)
+      expect(stream.buffer.first).to eq(original_fourth)
+    end
+  end
+
+  # ── verify_stream ────────────────────────────────────────────────────────────
+
+  describe '#verify_stream' do
+    it 'sets filter to the max PK and clears last_fetched' do
+      stream.state[:last_fetched] = 3
+      stream.verify_stream
+      max_id = db[:keyed_items].max(:id)
+      expect(stream.state[:filter]).to eq(max_id)
+      expect(stream.state[:last_fetched]).to be_nil
+    end
+  end
+end

data/spec/unit/tapsoob/progress_event_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'tapsoob/progress_event'
+
+RSpec.describe Tapsoob::ProgressEvent do
+  before do
+    described_class.enabled = true
+    # Reset throttle state between examples
+    described_class.instance_variable_set(:@last_progress_time, {})
+  end
+
+  after { described_class.enabled = false }
+
+  # ── enabled? ─────────────────────────────────────────────────────────────────
+
+  describe '.enabled?' do
+    it 'reflects the value set by .enabled=' do
+      described_class.enabled = false
+      expect(described_class.enabled?).to be false
+      described_class.enabled = true
+      expect(described_class.enabled?).to be true
+    end
+  end
+
+  # ── emit ─────────────────────────────────────────────────────────────────────
+
+  describe '.emit' do
+    it 'writes a PROGRESS: JSON line to STDERR when enabled' do
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.emit('test_event', foo: 'bar')
+      output = err.string
+      expect(output).to include('PROGRESS:')
+      data = JSON.parse(output.sub('PROGRESS: ', ''))
+      expect(data['event']).to eq('test_event')
+      expect(data['foo']).to eq('bar')
+    end
+
+    it 'does nothing when disabled' do
+      described_class.enabled = false
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.emit('ignored')
+      expect(err.string).to be_empty
+    end
+  end
+
+  # ── throttle helpers ─────────────────────────────────────────────────────────
+
+  describe '.should_emit_progress?' do
+    it 'returns true on the first call for a table' do
+      expect(described_class.should_emit_progress?(:my_table)).to be true
+    end
+
+    it 'returns false when called again immediately' do
+      described_class.should_emit_progress?(:my_table)
+      expect(described_class.should_emit_progress?(:my_table)).to be false
+    end
+  end
+
+  describe '.clear_throttle' do
+    it 'resets state so the next call returns true' do
+      described_class.should_emit_progress?(:my_table)
+      described_class.clear_throttle(:my_table)
+      expect(described_class.should_emit_progress?(:my_table)).to be true
+    end
+  end
+
+  # ── high-level event helpers ──────────────────────────────────────────────────
+
+  {
+    schema_start:     [3],
+    schema_complete:  [3],
+    data_start:       [3, 100],
+    data_complete:    [3, 100],
+    indexes_start:    [3],
+    indexes_complete: [3],
+    sequences_start:  [],
+    sequences_complete: [],
+  }.each do |method, args|
+    describe ".#{method}" do
+      it 'does not raise' do
+        expect { described_class.send(method, *args) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '.table_start' do
+    it 'resets throttle and emits without error' do
+      expect { described_class.table_start(:users, 500, workers: 2) }.not_to raise_error
+    end
+  end
+
+  describe '.table_progress' do
+    it 'emits when throttle allows' do
+      described_class.clear_throttle(:users)
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.table_progress(:users, 50, 200)
+      expect(err.string).to include('table_progress')
+    end
+
+    it 'skips emission when throttled' do
+      described_class.should_emit_progress?(:users)  # consume the token
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.table_progress(:users, 50, 200)
+      expect(err.string).to be_empty
+    end
+
+    it 'emits 0% when total is 0' do
+      described_class.clear_throttle(:empty_table)
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.table_progress(:empty_table, 0, 0)
+      data = JSON.parse(err.string.sub('PROGRESS: ', '').strip)
+      expect(data['percentage']).to eq(0)
+    end
+  end
+
+  describe '.table_complete' do
+    it 'clears throttle and emits without error' do
+      expect { described_class.table_complete(:users, 500) }.not_to raise_error
+    end
+  end
+
+  describe '.error' do
+    it 'emits an error event with the message' do
+      err = StringIO.new
+      stub_const('STDERR', err)
+      described_class.error('something broke', table: 'users')
+      data = JSON.parse(err.string.sub('PROGRESS: ', '').strip)
+      expect(data['event']).to eq('error')
+      expect(data['message']).to eq('something broke')
+    end
+  end
+end

data/spec/unit/tapsoob/progress_spec.rb

@@ -0,0 +1,335 @@
+require 'spec_helper'
+require 'tapsoob/progress'
+
+RSpec.describe Tapsoob::Progress do
+  # All output is redirected to StringIO so nothing hits stdout/terminal.
+
+  let(:out) { StringIO.new }
+
+  # ── Bar ──────────────────────────────────────────────────────────────────────
+
+  describe Tapsoob::Progress::Bar do
+    subject(:bar) { described_class.new("Test", 100, out) }
+
+    describe '#initialize' do
+      it 'starts at 0' do
+        expect(bar.current).to eq(0)
+      end
+
+      it 'stores total' do
+        expect(bar.total).to eq(100)
+      end
+
+      it 'stores title' do
+        expect(bar.title).to eq("Test")
+      end
+    end
+
+    describe '#inc' do
+      it 'advances current by 1 by default' do
+        bar.inc
+        expect(bar.current).to eq(1)
+      end
+
+      it 'advances current by a custom step' do
+        bar.inc(10)
+        expect(bar.current).to eq(10)
+      end
+
+      it 'clamps current to total' do
+        bar.inc(200)
+        expect(bar.current).to eq(100)
+      end
+    end
+
+    describe '#set' do
+      it 'sets current to the given value' do
+        bar.set(42)
+        expect(bar.current).to eq(42)
+      end
+
+      it 'raises on negative value' do
+        expect { bar.set(-1) }.to raise_error(RuntimeError)
+      end
+
+      it 'raises when value exceeds total' do
+        expect { bar.set(101) }.to raise_error(RuntimeError)
+      end
+    end
+
+    describe '#finish' do
+      it 'sets current to total and marks finished' do
+        bar.finish
+        expect(bar.current).to eq(100)
+        expect(bar.finished?).to be true
+      end
+    end
+
+    describe '#halt' do
+      it 'marks finished without changing current' do
+        bar.inc(30)
+        bar.halt
+        expect(bar.finished?).to be true
+        expect(bar.current).to eq(30)
+      end
+    end
+
+    describe '#inspect' do
+      it 'includes current/total' do
+        expect(bar.inspect).to include('0/100')
+      end
+    end
+
+    describe '#file_transfer_mode' do
+      it 'switches format_arguments to stat_for_file_transfer' do
+        bar.file_transfer_mode
+        expect(bar.instance_variable_get(:@format_arguments)).to include(:stat_for_file_transfer)
+      end
+    end
+
+    describe '#format=' do
+      it 'updates the format string' do
+        bar.format = "custom %s"
+        expect(bar.instance_variable_get(:@format)).to eq("custom %s")
+      end
+    end
+
+    describe '#format_arguments=' do
+      it 'updates format arguments' do
+        bar.format_arguments = [:title, :percentage]
+        expect(bar.instance_variable_get(:@format_arguments)).to eq([:title, :percentage])
+      end
+    end
+
+    describe 'convert_bytes (via fmt_stat_for_file_transfer)' do
+      it 'renders correctly in file_transfer_mode after finishing' do
+        bar.file_transfer_mode
+        bar.inc(50)
+        bar.finish
+        expect(out.string).not_to be_empty
+      end
+
+      it 'renders KB range correctly' do
+        b = described_class.new("KB", 2048, out)
+        b.file_transfer_mode
+        b.inc(2048)
+        b.finish
+        expect(out.string).to match(/KB/)
+      end
+
+      it 'renders MB range correctly' do
+        b = described_class.new("MB", 2 * 1024 * 1024, out)
+        b.file_transfer_mode
+        b.inc(2 * 1024 * 1024)
+        b.finish
+        expect(out.string).to match(/MB/)
+      end
+    end
+
+    describe 'zero total' do
+      subject(:bar) { described_class.new("Empty", 0, out) }
+
+      it 'does not raise on init' do
+        expect { bar }.not_to raise_error
+      end
+
+      it 'finish does not raise' do
+        expect { bar.finish }.not_to raise_error
+      end
+    end
+  end
+
+  # ── ReversedBar ──────────────────────────────────────────────────────────────
+
+  describe Tapsoob::Progress::ReversedBar do
+    subject(:bar) { described_class.new("Rev", 100, out) }
+
+    it 'inherits from Bar' do
+      expect(bar).to be_a(Tapsoob::Progress::Bar)
+    end
+
+    it 'reports inverted percentage internally (100 at start)' do
+      # do_percentage is private; test via inspect indirectly - just ensure no raise
+      expect { bar.inc(10) }.not_to raise_error
+    end
+  end
+
+  # ── ThreadSafeBar ────────────────────────────────────────────────────────────
+
+  describe Tapsoob::Progress::ThreadSafeBar do
+    let(:multi) do
+      mb = instance_double(Tapsoob::Progress::MultiBar)
+      allow(mb).to receive(:update)
+      allow(mb).to receive(:finish_bar)
+      allow(mb).to receive(:max_title_width).and_return(14)
+      mb
+    end
+
+    subject(:bar) { described_class.new("Worker", 50, multi) }
+
+    describe '#initialize' do
+      it 'stores title and total' do
+        expect(bar.title).to eq("Worker")
+        expect(bar.total).to eq(50)
+      end
+    end
+
+    describe '#inc' do
+      it 'increments current and notifies multi' do
+        expect(multi).to receive(:update)
+        bar.inc(5)
+        expect(bar.current).to eq(5)
+      end
+    end
+
+    describe '#finish' do
+      it 'sets current to total and calls finish_bar on multi' do
+        expect(multi).to receive(:finish_bar).with(bar)
+        bar.finish
+        expect(bar.current).to eq(50)
+      end
+    end
+
+    describe '#mark_finished / #finished?' do
+      it 'returns true after mark_finished' do
+        bar.mark_finished
+        expect(bar.finished?).to be true
+      end
+    end
+
+    describe '#render_to' do
+      it 'writes something to the given output' do
+        io = StringIO.new
+        bar.render_to(io)
+        expect(io.string).not_to be_empty
+      end
+    end
+
+    describe '#clear' do
+      it 'is a no-op (does not raise)' do
+        expect { bar.send(:clear) }.not_to raise_error
+      end
+    end
+  end
+
+  # ── MultiBar ─────────────────────────────────────────────────────────────────
+
+  describe Tapsoob::Progress::MultiBar do
+    subject(:multi) { described_class.new(2) }
+
+    describe '#initialize' do
+      it 'starts with no bars' do
+        expect(multi.instance_variable_get(:@bars)).to be_empty
+      end
+    end
+
+    describe '#create_bar' do
+      it 'returns a ThreadSafeBar' do
+        bar = multi.create_bar("Table1", 100)
+        expect(bar).to be_a(Tapsoob::Progress::ThreadSafeBar)
+      end
+
+      it 'does not create duplicate bars for the same title' do
+        multi.create_bar("Table1", 100)
+        multi.create_bar("Table1", 200)
+        bars = multi.instance_variable_get(:@bars)
+        expect(bars.count { |b| b.title == "Table1" }).to eq(1)
+      end
+    end
+
+    describe '#set_info' do
+      it 'does not raise' do
+        expect { multi.set_info("Processing...") }.not_to raise_error
+      end
+    end
+
+    describe '#stop' do
+      it 'deactivates the multi bar' do
+        multi.stop
+        expect(multi.instance_variable_get(:@active)).to be false
+      end
+
+      it 'is idempotent' do
+        multi.stop
+        expect { multi.stop }.not_to raise_error
+      end
+    end
+
+    describe '#max_title_width' do
+      it 'grows to accommodate longer titles' do
+        multi.create_bar("ShortTitle", 10)
+        multi.create_bar("A Much Longer Title Here", 10)
+        expect(multi.max_title_width).to be >= "A Much Longer Title Here".length
+      end
+    end
+
+    # ── rendering paths (drive render_active_display / redraw_all) ──────────────
+
+    describe '#update' do
+      it 'does not raise when active and initialized with bars' do
+        out = StringIO.new
+        multi.instance_variable_set(:@out, out)
+        multi.instance_variable_set(:@initialized, true)
+        multi.instance_variable_set(:@total_lines, 4)
+        multi.instance_variable_set(:@last_update, Time.now - 1)
+        bar = multi.create_bar("UpdateTable", 10)
+        expect { multi.update }.not_to raise_error
+      end
+
+      it 'is a no-op when @active is false' do
+        multi.stop
+        expect { multi.update }.not_to raise_error
+      end
+    end
+
+    describe '#finish_bar' do
+      it 'marks the bar as finished without raising' do
+        out = StringIO.new
+        multi.instance_variable_set(:@out, out)
+        multi.instance_variable_set(:@initialized, true)
+        multi.instance_variable_set(:@total_lines, 4)
+        multi.instance_variable_set(:@last_update, Time.now - 1)
+        bar = multi.create_bar("FinishTable", 5)
+        expect { multi.finish_bar(bar) }.not_to raise_error
+        expect(bar.instance_variable_get(:@finished_p)).to be true
+      end
+    end
+
+    describe '#set_info (with rendering)' do
+      it 'triggers redraw when initialized and a bar exists' do
+        out = StringIO.new
+        multi.instance_variable_set(:@out, out)
+        multi.instance_variable_set(:@initialized, true)
+        multi.instance_variable_set(:@total_lines, 4)
+        multi.instance_variable_set(:@last_update, Time.now - 1)
+        multi.create_bar("InfoTable", 10)
+        expect { multi.set_info("doing things") }.not_to raise_error
+      end
+    end
+
+    describe '#stop (initialized)' do
+      it 'clears terminal lines when previously initialized' do
+        out = StringIO.new
+        multi.instance_variable_set(:@out, out)
+        multi.instance_variable_set(:@initialized, true)
+        multi.instance_variable_set(:@total_lines, 4)
+        multi.stop
+        expect(out.string).to include("\e[")
+      end
+    end
+
+    describe 'render_active_display (via update)' do
+      it 'writes escape sequences to output when bars exist' do
+        out = StringIO.new
+        multi.instance_variable_set(:@out, out)
+        multi.instance_variable_set(:@initialized, true)
+        multi.instance_variable_set(:@total_lines, 4)
+        multi.instance_variable_set(:@last_update, Time.now - 1)
+        multi.instance_variable_set(:@info_message, "some info")
+        multi.create_bar("RenderTable", 10)
+        multi.update
+        expect(out.string).not_to be_empty
+      end
+    end
+  end
+end