# frozen_string_literal: true

require 'spec_helper'

describe 'ActiveRecord behaviors' do
  describe 'a temporary ActiveRecord model created with with_model' do
    context 'that has a named scope' do
      before do
        @regular_model = Class.new ActiveRecord::Base do
          scope :title_is_foo, -> { where(title: 'foo') }
        end

        @regular_model.connection.create_table(@regular_model.table_name, force: true) do |t|
          t.string 'title'
          t.text 'content'
          t.timestamps null: false
        end
      end

      after do
        @regular_model.connection.drop_table(@regular_model.table_name)
      end

      with_model :BlogPost do
        table do |t|
          t.string 'title'
          t.text 'content'
          t.timestamps null: false
        end

        model do
          scope :title_is_foo, -> { where(title: 'foo') }
        end
      end

      describe 'the named scope' do
        it 'works like a regular named scope' do
          included = @regular_model.create!(title: 'foo', content: 'Include me!')
          @regular_model.create!(title: 'bar', content: 'Include me!')

          expect(@regular_model.title_is_foo).to eq [included]

          included = BlogPost.create!(title: 'foo', content: 'Include me!')
          BlogPost.create!(title: 'bar', content: 'Include me!')

          expect(BlogPost.title_is_foo).to eq [included]
        end
      end
    end

    context 'that has a polymorphic belongs_to' do
      before do
        animal = Class.new ActiveRecord::Base do
          has_many :tea_cups, as: :pet
        end
        stub_const 'Animal', animal
      end

      with_model :TeaCup do
        table do |t|
          t.belongs_to :pet, polymorphic: true, index: false
        end
        model do
          belongs_to :pet, polymorphic: true
        end
      end

      with_table :animals

      with_model :StuffedAnimal do
        model do
          has_many :tea_cups, as: :pet
        end
      end

      describe 'the polymorphic belongs_to' do
        it 'works like a regular polymorphic belongs_to' do
          animal = Animal.create!
          stuffed_animal = StuffedAnimal.create!

          tea_cup_for_animal = TeaCup.create!(pet: animal)
          expect(tea_cup_for_animal.pet_type).to eq 'Animal'
          expect(animal.tea_cups).to include(tea_cup_for_animal)

          tea_cup_for_stuffed_animal = TeaCup.create!(pet: stuffed_animal)
          expect(tea_cup_for_stuffed_animal.pet_type).to eq 'StuffedAnimal'
          expect(stuffed_animal.tea_cups).to include(tea_cup_for_stuffed_animal)
        end
      end
    end
  end

  context 'with an association' do
    with_model :Province do
      table do |t|
        t.belongs_to :country
      end
      model do
        belongs_to :country
      end
    end

    with_model :Country

    context 'in earlier examples' do
      it 'works as normal' do
        Province.create!(country: Country.create!)
      end
    end

    context 'in later examples' do
      it "does not hold a reference to earlier example groups' classes" do
        expect(Province.reflect_on_association(:country).klass).to eq Country
      end
    end
  end
end