# encoding: utf-8

require 'spec_helper'

[:union, :|].each do |method|
  describe Relation::Header, "##{method}" do
    subject { object.send(method, other) }

    let(:object)           { described_class.coerce(attributes, options)             }
    let(:other)            { described_class.coerce(other_attributes, other_options) }
    let(:attributes)       { [[:id, Integer], [:name, String]]                       }
    let(:other_attributes) { attributes                                              }
    let(:options)          { {}                                                      }
    let(:other_options)    { options                                                 }
    let(:keys)             { Relation::Keys.coerce([[[:id, Integer]]])               }
    let(:other_keys)       { keys                                                    }

    context 'when the attributes are equivalent' do
      it { should be_instance_of(described_class) }

      its(:to_ary) { should == attributes }

      its(:keys) { should be_empty }
    end

    context 'when the attributes intersect' do
      let(:other_attributes) { [[:id, Integer]] }

      it { should be_instance_of(described_class) }

      its(:to_ary) { should == [[:id, Integer], [:name, String]] }

      its(:keys) { should be_empty }
    end

    context 'when the attributes do not intersect' do
      let(:other_attributes) { [[:age, Integer]] }

      it { should be_instance_of(described_class) }

      its(:to_ary) { should == [[:id, Integer], [:name, String], [:age, Integer]] }

      its(:keys) { should be_empty }
    end

    context 'when the keys are equivalent' do
      let(:other_attributes) { [[:id, Integer], [:name, String], [:age, Integer]] }
      let(:options)          { { keys: keys }                                     }

      it { should be_instance_of(described_class) }

      its(:to_ary) { should == other_attributes }

      its(:keys) { should eql(keys) }
    end

    context 'when the keys intersect' do
      let(:other_attributes) { [[:id, Integer], [:name, String], [:age, Integer]] }
      let(:options)          { { keys: keys }                                     }
      let(:other_options)    { { keys: other_keys }                               }

      let(:other_keys) do
        Relation::Keys.coerce([
          [[:id,  Integer]],
          [[:age, Integer]],
        ])
      end

      it { should be_instance_of(described_class) }

      its(:to_ary) { should == other_attributes }

      its(:keys) { should == [[[:id, Integer]]] }
    end

    context 'when the keys do not intersect' do
      let(:other_attributes) { [[:id, Integer], [:name, String], [:age, Integer]] }
      let(:options)          { { keys: keys }                                     }
      let(:other_options)    { { keys: other_keys }                               }

      let(:other_keys) do
        Relation::Keys.coerce([[[:name, String], [:age, Integer]]])
      end

      it { should be_instance_of(described_class) }

      its(:to_ary) { should == other_attributes }

      its(:keys) { should be_empty }
    end

    context 'when the other can be coerced into a Header' do
      let(:other) { other_attributes }

      its(:to_ary) { should == attributes }

      its(:keys) { should be_empty }
    end
  end
end