require "helper"
require "twirl/cluster"

class ClusterIntegrationTest < Minitest::Test
  def test_set
    cluster = build(:cluster, queues: %w(testing))
    client = cluster[0]
    cluster.set("testing", "data")
    assert_equal "data", client.get("testing")
  end

  def test_set_rotates
    cluster = build(:cluster, commands_per_client: 1, queues: %w(testing))
    client1 = cluster[0]
    client2 = cluster[1]
    cluster.set("testing", "data1")
    cluster.set("testing", "data2")
    cluster.set("testing", "data3")
    cluster.set("testing", "data4")

    results = []
    assert_equal "data1", client1.get("testing")
    assert_equal "data2", client2.get("testing")
    assert_equal "data3", client1.get("testing")
    assert_equal "data4", client2.get("testing")
  end

  def test_get
    cluster = build(:cluster, queues: %w(testing))
    client1 = cluster[0]
    client2 = cluster[1]

    client1.set("testing", "data1")
    client1.set("testing", "data2")
    client2.set("testing", "data3")

    results = []
    results << cluster.get("testing")
    results << cluster.get("testing")
    results << cluster.get("testing")
    results << cluster.get("testing")
    results << cluster.get("testing")

    assert_equal ["data1", "data2", nil, "data3", nil], results.map { |result| result.value if result }
  end

  def test_get_when_item_reserved_raises_error
    cluster = build(:cluster, queues: %w(testing))
    client1 = cluster[0]

    client1.set("testing", "data1")
    cluster.get("testing", open: true)

    assert_raises KJess::ClientError do
      cluster.get("testing")
    end
  end

  def test_reserve_with_item_close_and_item_abort
    cluster = build(:cluster, queues: %w(testing))
    client1 = cluster[0]
    client2 = cluster[1]

    client1.set("testing", "data1")
    client2.set("testing", "data2")

    item = cluster.reserve("testing")
    assert_equal "data1", item.value

    item.abort
    item = cluster.reserve("testing")
    assert_equal "data1", item.value

    item.close
    cluster.reserve("testing") # => nil, then rotate
    item = cluster.reserve("testing")
    assert_equal "data2", item.value

    cluster.rotate_for_next_op             # force rotation to client1
    assert_nil cluster.reserve("testing")  # client1 returns nil
    item.close                             # close item hopefully with client2
    assert_nil client2.get("testing")      # make sure that client2 queue is empty
  end

  def test_peek
    cluster = build(:cluster, queues: %w(testing))
    client1 = cluster[0]
    client2 = cluster[1]

    client1.set("testing", "data")

    item = Twirl::Item.new("testing", "data", client1)
    assert_equal item, cluster.peek("testing")
    assert_equal "data", client1.get("testing")
  end

  def test_peek_with_no_items
    cluster = build(:cluster, queues: %w(testing))
    assert_nil cluster.peek("testing")
  end

  def test_version
    cluster = build(:cluster)
    expected = {
      "localhost:9444" => "2.4.1",
      "localhost:9544" => "2.4.1",
    }

    assert_equal expected, cluster.version
  end

  def test_flush
    cluster = build(:cluster, queues: %w(testing))
    cluster.each do |client|
      client.set("testing", "data")
    end
    cluster.flush("testing")

    cluster.each do |client|
      assert_nil client.get("testing")
    end
  end

  def test_flush
    cluster = build(:cluster, queues: %w(testing))
    cluster.each { |client| client.set("testing", "data") }
    cluster.flush("testing")

    cluster.each do |client|
      assert_nil client.get("testing")
    end
  end

  def test_flush_all
    cluster = build(:cluster, queues: %w(testing))
    cluster.each { |client| client.set("testing", "data") }
    cluster.flush_all

    cluster.each do |client|
      assert_nil client.get("testing")
    end
  end

  def test_disconnect
    cluster = build(:cluster)
    cluster.each(&:ping)
    expected = [true] * cluster.size
    assert_equal expected, cluster.map(&:connected?)
    cluster.disconnect
    expected = [false] * cluster.size
    assert_equal expected, cluster.map(&:connected?)
  end

  def test_quit
    cluster = build(:cluster)
    cluster.each(&:ping)
    expected = [true] * cluster.size
    assert_equal expected, cluster.map(&:connected?)
    cluster.quit
    expected = [false] * cluster.size
    assert_equal expected, cluster.map(&:connected?)
  end

  def test_delete
    cluster = build(:cluster)
    cluster.each do |client|
      client.delete("testing")
      client.set("testing", "data")
      assert_instance_of Hash, client.queue_stats("testing")
    end
    cluster.delete("testing")
    cluster.each do |client|
      assert_nil client.queue_stats("testing")
    end
  end

  def test_ping
    cluster = build(:cluster)
    expected = {
      "localhost:9444" => true,
      "localhost:9544" => true,
    }

    assert_equal expected, cluster.ping
  end

  def test_stats
    cluster = build(:cluster)
    result = cluster.stats
    assert_equal [
      "localhost:9444",
      "localhost:9544",
    ], result.keys.sort

    result.values.each do |value|
      assert_instance_of Hash, value
    end
  end
end