require "#{File.dirname(__FILE__)}/helper.rb"

###################################################################
# make changes in lib/bt1/store.rb and use rake to run the tests #
###################################################################

class TestBT1Store < Test::Unit::TestCase

  setup do
    @store = BT1::Store.new
  end

  context "Updating the store" do
    test "Store starts off empty" do
      assert_equal 0, @store.size
    end

    test "After the first update, Store#size is the number of records" do
      records = (1..10).map { BT1::Record.new(%w[random crapola]) }
      @store.update(records)

      assert_equal 10, @store.size
    end

    test "Old records that aren't in new snapshot are discarded" do
      old_records = (1..5).map { BT1::Record.new(%w[not shared at all]) }

      shared_records = (1..3).map do
        BT1::Record.new(%w[shared between old and new])
      end

      @store.update(old_records + shared_records)

      assert_equal 8, @store.size

      @store.update(shared_records)
      assert_equal 3, @store.size
    end

    test "New records not in old snapshot are still added on update" do
      old_records = (1..5).map { BT1::Record.new(%w[not shared at all]) }

      shared_records = (1..3).map do
        BT1::Record.new(%w[shared between old and new])
      end

      new_records = (1..9).map do
        BT1::Record.new(%w[only in new snapshot])
      end

      @store.update(old_records + shared_records)
      @store.update(shared_records + new_records)

      assert_equal 12, @store.size
    end

    test "Update preserves old reported status for shared records" do
      old_records = (1..5).map { BT1::Record.new(%w[not shared at all]) }

      shared_records = (1..3).map do |i|
        rec = BT1::Record.new([:shared, i])
        rec.mark_reported
        rec
      end

      @store.update(old_records + shared_records)

      new_shared_records = (1..3).map do |i|
        rec = BT1::Record.new([:shared, i])
      end

      new_records = (1..9).map do |i|
        BT1::Record.new([:new_only, i])
      end


      @store.update(new_shared_records + new_records)

      assert_equal 12, @store.size
      assert @store.data[0..2].all? { |e| e.reported? }
      assert @store.data[3..-1].all? { |e| ! e.reported? }
    end

  end

  context "Fetching records from the store" do

    test "Fetch grabs a specified amount of records and returns them in a collection" do
      records = (1..7).map do |i|
        BT1::Record.new(%w[A few records])
      end

      @store.update(records)

      fetched_records = @store.fetch(5)
      assert_equal 5, fetched_records.size
    end

    test "Fetch should only return number of items in the collection when asked for more" do
      records = (1..7).map do |i|
        BT1::Record.new(%w[a bunch of records])
      end

      @store.update(records)

      fetched_records = @store.fetch(20)
      assert_equal 7, fetched_records.size
    end

    test "Fetch should only pull up unreported records" do
      reported_records = (1..5).map do |i|
        rec = BT1::Record.new(%w[reported records])
        rec.mark_reported
        rec
      end

      unreported_records = (1..7).map do |i|
        BT1::Record.new(%w[unreported records])
      end

      @store.update(reported_records + unreported_records)

      fetched_records = @store.fetch(10)
      assert_equal 7, fetched_records.size
      fetched_records.each do |r|
        assert_equal false, r.reported?
      end
    end

    test "Fetch should mark records reported once it has pulled them up" do

      unreported_records = (1..10).map do |i|
        BT1::Record.new(%w[a bunch of new records])
      end

      @store.update(unreported_records)
      @store.fetch(7)

      reported = []
      unreported = []

      @store.each do |r|
        if r.reported?
          reported << r
        else
          unreported << r
        end
      end

      assert_equal 3, unreported.size
      assert_equal 7, reported.size

    end

  end
end