require 'test_helper'

class MockLoggingAdapterTest < Minitest::Test

  def setup
    @default_repo = Adalog::InMemoryRepo.new
  end


  def default_repo
    @default_repo ||= Adalog::InMemoryRepo.new
  end


  def tg_service_adapter
    stub_methods  = { generate: Object.new, toggle: true }
    adapter_class = Adalog::MockLoggingAdapter.new('TGService', default_repo, **stub_methods)
  end


  def build_tg_service_adapter
    tg_service_adapter.new
  end


################################################################################
## The first tests are identical to those for StubLoggingAdapter.             ##
## This is because MockLoggingAdapter is a superset of that functionality.    ##
## A future refactoring may involve unifying these tests more elegantly,      ##
## either in terms of the classes themselves, or by just unifying the tests   ##
## as they are presented in test files themselves.                            ##
################################################################################


  test "new creates a logging adapter class" do
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo)
    assert_kind_of(Class, adapter_class)
  end


  test "class accessors for service_name and repo" do
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo)
    assert_respond_to(adapter_class, :service_name)
    assert_respond_to(adapter_class, :repo)
    adapter = adapter_class.new
    assert_equal('SomeService', adapter.service_name)
    assert_equal(default_repo, adapter.repo)
  end


  test "instance methods are created for stubs specified in new" do
    stub_methods  = { foo: 'bar', one: 1, two: 2 }
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
    adapter       = adapter_class.new
    assert_respond_to(adapter, :foo)
    assert_respond_to(adapter, :one)
    assert_respond_to(adapter, :two)
  end


  test "stubbed instance methods return provided stubbed values" do
    stub_methods  = { foo: 'bar', one: 1, two: 2 }
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
    adapter       = adapter_class.new
    assert_equal('bar', adapter.foo)
    assert_equal(1,     adapter.one)
    assert_equal(2,     adapter.two)
  end


  test "new stubs can be added at instantiation" do
    stub_methods  = { foo: 'bar', one: 1, two: 2 }
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
    adapter       = adapter_class.new(baz: 'bim')
    assert_respond_to(adapter, :baz)
    assert_equal('bim', adapter.baz)
  end


  test "stubs can be overridden at instantiation" do
    stub_methods  = { foo: 'bar', one: 1, two: 2 }
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
    adapter       = adapter_class.new(foo: 'rofl')
    assert_respond_to(adapter, :foo)
    assert_equal('rofl', adapter.foo)
  end


  test "calls to stubs are stored in the repo" do
    stub_methods  = { foo: 'bar', one: 1, two: 2 }
    adapter_class = Adalog::MockLoggingAdapter.new('SomeService', default_repo, **stub_methods)
    adapter       = adapter_class.new

    adapter.foo('rofl', 'copter')
    entry = default_repo.all.first
    assert_equal("'foo', which has been stubbed with 'bar'.", entry.message)
    assert_equal(['rofl', 'copter'], entry.details)
    assert_equal('SomeService', entry.title)

    adapter.one
    entry = default_repo.all.first
    assert_equal("'one', which has been stubbed with '1'.", entry.message)
    assert_equal([], entry.details)
    assert_equal('SomeService', entry.title)
  end


################################################################################


  test "messages records stubbed method calls" do
    adapter = build_tg_service_adapter
    adapter.generate
    adapter.toggle
    message_names = adapter.messages.map(&:name)
    assert_includes(message_names, :generate)
    assert_includes(message_names, :toggle)
  end


  test "messages is an alias for _received_messages" do
    adapter = build_tg_service_adapter
    adapter.generate
    adapter.toggle
    assert_equal(adapter.messages, adapter._received_messages)
  end


  test "elements in messages record args" do
    adapter = build_tg_service_adapter
    adapter.generate(1, 'two', :three, 4, foo: :bar) { |can_do| "a thing" }
    assert_equal([1, 'two', :three, 4], adapter.messages.first.args)
  end


  test "elements in messages record kwargs" do
    adapter = build_tg_service_adapter
    adapter.generate(1, 2, 3, foo: :bar, baz: ['bim']) { |can_do| "a thing" }
    assert_equal({ foo: :bar, baz: ['bim'] }, adapter.messages.first.kwargs)
  end


  test "elements in messages record blocks" do
    adapter = build_tg_service_adapter
    sent_block = Proc.new { |can_do| "a thing" }
    adapter.generate(1, 2, 3, foo: :bar, &sent_block)
    assert_equal(sent_block, adapter.messages.first.block)
  end


  test "elements in messages have a summary arguments method" do
    adapter = build_tg_service_adapter
    sent_block = Proc.new { |can_do| "a thing" }
    adapter.generate(1, 2, 3, foo: :bar, &sent_block)
    assert_equal([1, 2, 3, { foo: :bar }], adapter.messages.first.arguments)
  end


  test "stubs call the blocks passed" do
    canary = "alive"
    adapter = build_tg_service_adapter
    adapter.generate(1, 2, 3, foo: :bar) { canary = "dead" }
    assert_equal("dead", canary)
  end


  test "can be asked if messages are received at least n times" do
    adapter = build_tg_service_adapter
    assert(adapter.received?(:toggle,   at_least: 0))
    refute(adapter.received?(:toggle,   at_least: 1))
    assert(adapter.received?(:generate, at_least: 0))
    refute(adapter.received?(:generate, at_least: 1))

    adapter.generate
    assert(adapter.received?(:toggle,   at_least: 0))
    refute(adapter.received?(:toggle,   at_least: 1))
    assert(adapter.received?(:generate, at_least: 0))
    assert(adapter.received?(:generate, at_least: 1))
    refute(adapter.received?(:generate, at_least: 2))

    adapter.generate
    assert(adapter.received?(:toggle,   at_least: 0))
    refute(adapter.received?(:toggle,   at_least: 1))
    assert(adapter.received?(:generate, at_least: 0))
    assert(adapter.received?(:generate, at_least: 1))
    assert(adapter.received?(:generate, at_least: 2))
    refute(adapter.received?(:generate, at_least: 3))

    adapter.toggle
    assert(adapter.received?(:toggle,   at_least: 0))
    assert(adapter.received?(:toggle,   at_least: 1))
    refute(adapter.received?(:toggle,   at_least: 2))
    assert(adapter.received?(:generate, at_least: 0))
    assert(adapter.received?(:generate, at_least: 1))
    assert(adapter.received?(:generate, at_least: 2))
    refute(adapter.received?(:generate, at_least: 3))
  end


  test "can be asked if messages are received at most n times" do
    adapter = build_tg_service_adapter
    assert(adapter.received?(:toggle,   at_most: 0))
    assert(adapter.received?(:generate, at_most: 0))

    adapter.generate
    assert(adapter.received?(:toggle,   at_most: 0))
    assert(adapter.received?(:generate, at_most: 1))
    refute(adapter.received?(:generate, at_most: 0))

    adapter.generate
    assert(adapter.received?(:toggle,   at_most: 0))
    assert(adapter.received?(:generate, at_most: 2))
    refute(adapter.received?(:generate, at_most: 1))
    refute(adapter.received?(:generate, at_most: 0))

    adapter.toggle
    assert(adapter.received?(:toggle,   at_most: 1))
    refute(adapter.received?(:toggle,   at_most: 0))
    assert(adapter.received?(:generate, at_most: 2))
    refute(adapter.received?(:generate, at_most: 1))
    refute(adapter.received?(:generate, at_most: 0))
  end


  test "can be asked if messages are received exactly n times" do
    adapter = build_tg_service_adapter
    assert(adapter.received?(:toggle,   exactly: 0))
    assert(adapter.received?(:generate, exactly: 0))

    adapter.generate
    assert(adapter.received?(:toggle,   exactly: 0))
    assert(adapter.received?(:generate, exactly: 1))
    refute(adapter.received?(:generate, exactly: 2))

    adapter.generate
    assert(adapter.received?(:toggle,   exactly: 0))
    assert(adapter.received?(:generate, exactly: 2))
    refute(adapter.received?(:generate, exactly: 1))

    adapter.toggle
    assert(adapter.received?(:toggle,   exactly: 1))
    assert(adapter.received?(:generate, exactly: 2))
  end


  test "can be asked if messages are received amount within bounds" do
    adapter = build_tg_service_adapter
    assert(adapter.received?(:generate, at_least: 0, at_most: 0))

    adapter.generate
    refute(adapter.received?(:generate, at_least: 0, at_most: 0))
    assert(adapter.received?(:generate, at_least: 0, at_most: 1))
    assert(adapter.received?(:generate, at_least: 1, at_most: 1))
    # Test even an invalid range:
    refute(adapter.received?(:generate, at_least: 1, at_most: 0))

    adapter.generate
    assert(adapter.received?(:generate, at_least: 0, at_most: 2))
    assert(adapter.received?(:generate, at_least: 1, at_most: 2))
    assert(adapter.received?(:generate, at_least: 2, at_most: 2))
    # Test even an invalid range:
    refute(adapter.received?(:generate, at_least: 3, at_most: 2))
  end


  test "when asked if messages are received, defaults to at least once" do
    adapter = build_tg_service_adapter
    assert_equal_to_at_least_once = ->() {
      assert_equal(
        adapter.received?(:generate),
        adapter.received?(:generate, at_least: 1)
      )
    }
    # For zero calls
    assert_equal_to_at_least_once.call
    # One call case
    adapter.generate
    assert_equal_to_at_least_once
    # More-than-one call case
    adapter.generate
    assert_equal_to_at_least_once
  end


end

# flips = ->(a) { [!a, flips] }