require 'spec_helper'

module RailsBestPractices
  module Prepares
    describe ModelPrepare do
      let(:runner) { Core::Runner.new(prepares: ModelPrepare.new) }

      context 'models' do
        it 'class_name with modules ::' do
          content =<<-EOF
          class Blog::Post < ActiveRecord::Base
          end
          EOF
          runner.prepare('app/models/admin/post.rb', content)
          models = Prepares.models
          expect(models.map(&:to_s)).to eq(['Blog::Post'])
        end

        it 'class_name with modules' do
          content =<<-EOF
          module Blog
            class Post < ActiveRecord::Base
            end
          end
          EOF
          runner.prepare('app/models/admin/post.rb', content)
          models = Prepares.models
          expect(models.map(&:to_s)).to eq(['Blog::Post'])
        end
      end

      context 'associations' do
        it 'should parse model associations' do
          content =<<-EOF
          class Project < ActiveRecord::Base
            belongs_to              :portfolio
            has_one                 :project_manager
            has_many                :milestones
            has_and_belongs_to_many :categories
          end
          EOF
          runner.prepare('app/models/project.rb', content)
          model_associations = Prepares.model_associations
          expect(model_associations.get_association('Project', 'portfolio')).to eq({'meta' => 'belongs_to', 'class_name' => 'Portfolio'})
          expect(model_associations.get_association('Project', 'project_manager')).to eq({'meta' => 'has_one', 'class_name' => 'ProjectManager'})
          expect(model_associations.get_association('Project', 'milestones')).to eq({'meta' => 'has_many', 'class_name' => 'Milestone'})
          expect(model_associations.get_association('Project', 'categories')).to eq({'meta' => 'has_and_belongs_to_many', 'class_name' => 'Category'})
        end

        context 'with class_name option' do
          it 'should parse belongs_to' do
            content =<<-EOF
            class Post < ActiveRecord::Base
              belongs_to :author, "class_name" => "Person"
            end
            EOF
            runner.prepare('app/models/post.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Post', 'author')).to eq({'meta' => 'belongs_to', 'class_name' => 'Person'})
          end

          it 'should parse has_one' do
            content =<<-EOF
            class Project < ActiveRecord::Base
              has_one :project_manager, "class_name" => "Person"
            end
            EOF
            runner.prepare('app/models/post.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Project', 'project_manager')).to eq({'meta' => 'has_one', 'class_name' => 'Person'})
          end

          it 'should parse has_many' do
            content =<<-EOF
            class Project < ActiveRecord::Base
              has_many :people, "class_name" => "Person"
            end
            EOF
            runner.prepare('app/models/project.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Project', 'people')).to eq({'meta' => 'has_many', 'class_name' => 'Person'})
          end

          it 'should parse has_and_belongs_to_many' do
            content =<<-EOF
            class Citizen < ActiveRecord::Base
              has_and_belongs_to_many :nations, "class_name" => "Country"
            end
            EOF
            runner.prepare('app/models/citizen.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Citizen', 'nations')).to eq({'meta' => 'has_and_belongs_to_many', 'class_name' => 'Country'})
          end

          context 'namespace' do
            it 'should parse with namespace' do
              content =<<-EOF
              class Community < ActiveRecord::Base
                has_many :members
              end
              EOF
              runner.prepare('app/models/community.rb', content)
              content =<<-EOF
              class Community::Member < ActiveRecord::Base
                belongs_to :community
              end
              EOF
              runner.prepare('app/models/community/member.rb', content)
              runner.after_prepare
              model_associations = Prepares.model_associations
              expect(model_associations.get_association('Community', 'members')).to eq({'meta' => 'has_many', 'class_name' => 'Community::Member'})
              expect(model_associations.get_association('Community::Member', 'community')).to eq({'meta' => 'belongs_to', 'class_name' => 'Community'})
            end

            it 'should parse without namespace' do
              content =<<-EOF
              class Community::Member::Rating < ActiveRecord::Base
                belongs_to :member
              end
              EOF
              runner.prepare('app/models/community/member/rating.rb', content)
              content =<<-EOF
              class Community::Member < ActiveRecord::Base
                has_many :ratings
              end
              EOF
              runner.prepare('app/models/community/member.rb', content)
              runner.after_prepare
              model_associations = Prepares.model_associations
              expect(model_associations.get_association('Community::Member::Rating', 'member')).to eq({'meta' => 'belongs_to', 'class_name' => 'Community::Member'})
              expect(model_associations.get_association('Community::Member', 'ratings')).to eq({'meta' => 'has_many', 'class_name' => 'Community::Member::Rating'})
            end
          end
        end

        context 'mongoid embeds' do
          it 'should parse embeds_many' do
            content =<<-EOF
            class Person
              include Mongoid::Document
              embeds_many :addresses
            end
            EOF
            runner.prepare('app/models/person.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Person', 'addresses')).to eq({'meta' => 'embeds_many', 'class_name' => 'Address'})
          end

          it 'should parse embeds_one' do
            content =<<-EOF
            class Lush
              include Mongoid::Document
              embeds_one :whiskey, class_name: "Drink", inverse_of: :alcoholic
            end
            EOF
            runner.prepare('app/models/lush.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Lush', 'whiskey')).to eq({'meta' => 'embeds_one', 'class_name' => 'Drink'})
          end

          it 'should parse embedded_in' do
            content =<<-EOF
            class Drink
              include Mongoid::Document
              embedded_in :alcoholic, class_name: "Lush", inverse_of: :whiskey
            end
            EOF
            runner.prepare('app/models/drink.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Drink', 'alcoholic')).to eq({'meta' => 'embedded_in', 'class_name' => 'Lush'})
          end
        end

        context 'mongomapper many/one' do
          it 'should parse one' do
            content =<<-EOF
            class Employee
              include MongoMapper::Document
              one :desk
            end
            EOF
            runner.prepare('app/models/employee.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Employee', 'desk')).to eq({'meta' => 'one', 'class_name' => 'Desk'})
          end

          it 'should parse many' do
            content =<<-EOF
            class Tree
              include MongoMapper::Document
              many :birds
            end
            EOF
            runner.prepare('app/models/tree.rb', content)
            model_associations = Prepares.model_associations
            expect(model_associations.get_association('Tree', 'birds')).to eq({'meta' => 'many', 'class_name' => 'Bird'})
          end
        end
      end

      context 'methods' do
        it 'should parse model methods' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            def save; end
            def find; end
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['save', 'find'])
        end

        it 'should parse model methods with access control' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            def save; end
            def find; end
            protected
            def create_or_update; end
            private
            def find_by_sql; end
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['save', 'find', 'create_or_update', 'find_by_sql'])
          expect(methods.get_methods('Post', 'public').map(&:method_name)).to eq(['save', 'find'])
          expect(methods.get_methods('Post', 'protected').map(&:method_name)).to eq(['create_or_update'])
          expect(methods.get_methods('Post', 'private').map(&:method_name)).to eq(['find_by_sql'])
        end

        it 'should parse model methods with module ::' do
          content =<<-EOF
          class Admin::Blog::Post < ActiveRecord::Base
            def save; end
            def find; end
          end
          EOF
          runner.prepare('app/models/admin/blog/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Admin::Blog::Post').map(&:method_name)).to eq(['save', 'find'])
        end

        it 'should parse model methods with module' do
          content =<<-EOF
          module Admin
            module Blog
              class Post < ActiveRecord::Base
                def save; end
                def find; end
              end
            end
          end
          EOF
          runner.prepare('app/models/admin/blog/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Admin::Blog::Post').map(&:method_name)).to eq(['save', 'find'])
        end

        it 'should not add methods from module' do
          content =<<-EOF
            class Model < ActiveRecord::Base
            end
          EOF
          runner.prepare('app/models/model.rb', content)
          content =<<-EOF
            module Mixin
              def mixed_method
              end
            end
          EOF
          runner.prepare('app/models/mixins/mixin.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Model')).to be_empty
        end
      end

      context 'scope' do
        it 'should treat named_scope as method' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            named_scope :active, conditions: {active: true}
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['active'])
        end

        it 'should treat scope as method' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            scope :active, where(active: true)
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['active'])
        end
      end

      context 'alias' do
        it 'should treat alias as method' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            alias :new :old
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['new'])
        end

        it 'should treat alias_method as method' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            alias_method :new, :old
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['new'])
        end

        it 'should treat alias_method_chain as method' do
          content =<<-EOF
          class Post < ActiveRecord::Base
            alias_method_chain :method, :feature
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          methods = Prepares.model_methods
          expect(methods.get_methods('Post').map(&:method_name)).to eq(['method_with_feature', 'method'])
        end
      end

      context 'attributes' do
        it 'should parse mongoid field' do
          content =<<-EOF
          class Post
            include Mongoid::Document
            field :title
            field :tags, type: Array
            field :comments_count, type: Integer
            field :deleted_at, type: DateTime
            field :active, type: Boolean
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          model_attributes = Prepares.model_attributes
          expect(model_attributes.get_attribute_type('Post', 'title')).to eq('String')
          expect(model_attributes.get_attribute_type('Post', 'tags')).to eq('Array')
          expect(model_attributes.get_attribute_type('Post', 'comments_count')).to eq('Integer')
          expect(model_attributes.get_attribute_type('Post', 'deleted_at')).to eq('DateTime')
          expect(model_attributes.get_attribute_type('Post', 'active')).to eq('Boolean')
        end

        it 'should parse mongomapper field' do
          content =<<-EOF
          class Post
            include MongoMapper::Document
            key :first_name,  String
            key :last_name,   String
            key :age,         Integer
            key :born_at,     Time
            key :active,      Boolean
            key :fav_colors,  Array
          end
          EOF
          runner.prepare('app/models/post.rb', content)
          model_attributes = Prepares.model_attributes
          expect(model_attributes.get_attribute_type('Post', 'first_name')).to eq('String')
          expect(model_attributes.get_attribute_type('Post', 'last_name')).to eq('String')
          expect(model_attributes.get_attribute_type('Post', 'age')).to eq('Integer')
          expect(model_attributes.get_attribute_type('Post', 'born_at')).to eq('Time')
          expect(model_attributes.get_attribute_type('Post', 'active')).to eq('Boolean')
          expect(model_attributes.get_attribute_type('Post', 'fav_colors')).to eq('Array')
        end
      end

      context 'no error' do
        it 'should raised for finder_sql option' do
          content =<<-EOF
          class EventSubscription < ActiveRecord::Base
            has_many :event_notification_template, finder_sql: ?
          end
          EOF
          content.sub!('?', '\'SELECT event_notification_templates.* from event_notification_templates where event_type_id=#{event_type_id} and delivery_method_id=#{delivery_method_id}\'')
          expect { runner.prepare('app/models/event_subscription.rb', content) }.not_to raise_error
        end
      end
    end
  end
end