# Copyright (c) 2020 Jerome Arbez-Gindre
# frozen_string_literal: true

require('defmastership')

RSpec.describe(DefMastership::BatchChanger) do
  subject(:batchchanger) { described_class.new }

  describe '.new' do
    it { is_expected.not_to(be(nil)) }
    it { is_expected.to(have_attributes(refchangers: {})) }
  end

  describe '.from_h' do
    before do
      allow(DefMastership::RefChanger).to(receive(:from_h).once
                                           .with(:whatever_a).and_return(:toto_a))
    end

    it { expect(described_class.from_h(a: :whatever_a)).not_to(be(nil)) }

    it {
      batchchanger = described_class.from_h(a: :whatever_a)
      expect(batchchanger).to(have_attributes(refchangers: { a: :toto_a }))
    }
  end

  describe '#from_h' do
    before do
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:whatever_a).and_return(:one))
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:whatever_b).and_return(:two))
      batchchanger.from_h(a: :whatever_a, b: :whatever_b)
    end

    it { expect(DefMastership::RefChanger).to(have_received(:from_h).with(:whatever_a)) }

    it { expect(DefMastership::RefChanger).to(have_received(:from_h).with(:whatever_b)) }

    it { expect(batchchanger).to(have_attributes(refchangers: { a: :one, b: :two })) }
  end

  describe '#to_h' do
    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }

    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }

    before do
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
      allow(refchanger_a).to(receive(:to_h).and_return(a_a: :a_a))
      allow(refchanger_b).to(receive(:to_h).and_return(b_b: :b_b))
      batchchanger.to_h
    end

    it { expect(refchanger_a).to(have_received(:to_h)) }

    it { expect(refchanger_b).to(have_received(:to_h)) }

    it do
      expect(batchchanger.to_h).to(eq(
                                     a: { a_a: :a_a },
                                     b: { b_b: :b_b }
                                   ))
    end
  end

  describe 'replace' do
    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }

    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }

    before do
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
      allow(refchanger_a).to(receive(:public_send).with(:replace_toto, 'a line').and_return('b line'))
      allow(refchanger_b).to(receive(:public_send).with(:replace_toto, 'b line').and_return('c line'))
      batchchanger.replace(:toto, 'a line')
    end

    it { expect(refchanger_a).to(have_received(:public_send).with(:replace_toto, 'a line')) }

    it { expect(refchanger_b).to(have_received(:public_send).with(:replace_toto, 'b line')) }

    it { expect(batchchanger.replace(:toto, 'a line')).to(eq('c line')) }
  end

  describe 'changes' do
    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }

    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }

    before do
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
      allow(refchanger_a).to(receive(:changes).and_return([%w[a1 a2]]))
      allow(refchanger_b).to(receive(:changes).and_return([%w[b1 b2]]))
    end

    it do
      expect(batchchanger.changes).to(eq([
                                           %w[a1 a2],
                                           %w[b1 b2]
                                         ]))
    end
  end
end