active_mocker 1.4.2 → 1.5

data/spec/lib/active_mocker/logger_spec.rb

@@ -1,32 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_mocker/logger'
-
-describe ActiveMocker::Logger do
-
-  describe '::set' do
-
-    let(:logger){double()}
-
-    around do
-      described_class.class_variable_set(:@@logger, nil)
-    end
-
-    it 'set the logger to be used by the mock class' do
-      described_class.set(logger)
-      expect(described_class.class_variable_get(:@@logger)).to eq(logger)
-    end
-
-    it 'will pass any methods to the set logger' do
-      described_class.set(logger)
-      expect(logger).to receive(:info)
-      described_class.info
-    end
-
-    it 'will return nil if no logger is set' do
-      expect(described_class.any_method).to eq nil
-    end
-
-  end
-
-end

data/spec/lib/active_mocker/model_reader_spec.rb

@@ -1,206 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_support/core_ext/hash/indifferent_access'
-require 'singleton'
-require 'logger'
-require 'active_mocker/logger'
-require 'string_reader'
-require 'file_reader'
-require 'active_mocker/logger'
-require 'active_mocker/active_record'
-require 'active_mocker/model_reader'
-require 'active_mocker/reparameterize'
-require_relative '../../unit_logger'
-
-describe ActiveMocker::ModelReader do
-
-  before(:all) do
-    ActiveMocker::Logger.set(UnitLogger)
-  end
-
-  let(:model_reader){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}).parse('model') }
-
-  let(:subject){ model_reader}
-
-  describe '#parse' do
-
-    let(:subject){ described_class.new({model_dir: File.expand_path('../../', __FILE__)}) }
-
-    it 'takes a model name to the active_record model class' do
-      subject.parse('model')
-    end
-
-  end
-
-  describe '#class_methods' do
-
-    it 'returns all public class methods' do
-      expect(subject.class_methods).to eq([:duper, :named, :foo, :bang!])
-    end
-
-  end
-
-  describe '#instance methods' do
-
-    it 'returns all public instance methods' do
-      expect(subject.instance_methods).to eq([:foo, :super])
-    end
-
-  end
-
-  describe '#instance_methods_with_arguments' do
-
-    it 'returns all public instance methods' do
-      expect(subject.instance_methods_with_arguments).to eq([{:foo=>[[:req, :foobar], [:req, :value]]}, {:super=>[]}])
-    end
-
-  end
-
-  describe '#class_methods_with_arguments' do
-
-    it 'returns all public instance methods' do
-      expect(subject.class_methods_with_arguments).to eq( [{:duper=>[[:req, :value], [:rest, :args]]}, {:named=>[[:req, :name], [:opt, :value], [:opt, :options]]}, {:foo=>[]}, {:bang! =>[]}])
-    end
-
-  end
-
-  describe '#belongs_to' do
-
-    let(:subject){model_reader.belongs_to}
-
-    it 'name of association' do
-      expect(subject.first.name).to eq(:company)
-    end
-
-    it 'class_name override' do
-      expect(subject.first.class_name).to eq('PlanServiceCategory')
-    end
-
-    it 'infer class_name' do
-      expect(subject.last.class_name).to eq('Person')
-    end
-
-    it 'infer foreign key' do
-      expect(subject.last.foreign_key).to eq('person_id')
-    end
-
-    it 'foreign key override' do
-      expect(subject.first.foreign_key).to eq('category_id')
-    end
-
-    it 'through' do
-      expect(subject.last.through).to eq('customer')
-    end
-
-  end
-
-  describe '#has_one' do
-
-    let(:subject) { model_reader.has_one }
-
-    it 'name of association' do
-      expect(subject.first.name).to eq(:account)
-    end
-
-  end
-
-  describe '#has_many' do
-
-    let(:subject) { model_reader.has_many }
-
-    it 'name of association' do
-      expect(subject.first.name).to eq(:users)
-    end
-
-  end
-
-  describe '#has_and_belongs_to_many' do
-
-    let(:subject) { model_reader.has_and_belongs_to_many }
-
-    it 'name of association' do
-      expect(subject.first.name).to eq(:disclosures)
-    end
-
-  end
-
-# TODO JoinTable
-#     class Assembly < ActiveRecord::Base
-#       has_and_belongs_to_many :parts
-#     end
-#
-#     class Part < ActiveRecord::Base
-#       has_and_belongs_to_many :assemblies
-#     end
-#     These need to be backed up by a migration to create the assemblies_parts table.This table should be created without a primary key:
-
-#     class CreateAssembliesPartsJoinTable < ActiveRecord::Migration
-#       def change
-#         create_table :assemblies_parts, id: false do |t|
-#           t.integer :assembly_id
-#           t.integer :part_id
-#         end
-#       end
-#     end
-
-#   TODO Polymorphic Associations
-#   A slightly more advanced twist on associations is the polymorphic association.With polymorphic associations, a model can belong to more than one other model, on a single association.For example, you might have a picture model that belongs to either an employee model or a product model.Here 's how this could be declared:
-#
-#     class Picture < ActiveRecord::Base
-#       belongs_to :imageable, polymorphic: true
-#     end
-#
-#     class Employee < ActiveRecord::Base
-#       has_many :pictures, as: :imageable
-#     end
-#
-#     class Product < ActiveRecord::Base
-#       has_many :pictures, as: :imageable
-#     end
-
-#     class CreatePictures < ActiveRecord::Migration
-#       def change
-#         create_table :pictures do |t|
-#           t.string :name
-#           t.integer :imageable_id
-#           t.string :imageable_type
-#           t.timestamps
-#         end
-#       end
-#     end
-
-
-
-  context 'inject string_reader as file_reader' do
-
-    let(:example_model){
-      StringReader.new(
-          <<-eos
-            class Person < ActiveRecord::Base
-
-              belongs_to :zip_code
-
-              def full_name(first_name, last_name)
-
-              end
-
-            end
-          eos
-      )
-    }
-
-    let(:subject){described_class.new({model_dir: File.expand_path('../../', __FILE__), file_reader: example_model})}
-
-    let(:search){subject.parse('person')}
-
-    it 'let not read a file but return a string instead to be evaluated' do
-      expect(search.relationships_types.belongs_to.first.name).to eq :zip_code
-      expect(subject.instance_methods).to eq([:full_name])
-      expect(subject.instance_methods_with_arguments).to eq([{:full_name=>[[:req, :first_name], [:req, :last_name]]}])
-    end
-
-  end
-
-
-end
-

data/spec/lib/active_mocker/model_schema/generate_spec.rb

@@ -1,111 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../../../../lib', __FILE__)
-require 'active_mocker'
-require 'json'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/deep_dup.rb'
-require 'active_mocker/model_schema'
-require 'active_mocker/model_schema'
-require 'active_mocker/model_schema/generate'
-require_relative '../../../unit_logger'
-
-describe ActiveMocker::ModelSchema::Generate do
-
-  let(:app_root) { File.expand_path('../../../../../', __FILE__) }
-  let(:schema_file){ File.join(app_root, 'sample_app_rails_4/db/schema.rb') }
-  # let(:schema_file){ '/Users/zeisler/dev/fbi/db/schema.rb' }
-  let(:models_dir){ File.join(app_root, 'sample_app_rails_4/app/models') }
-  # let(:models_dir){'/Users/zeisler/dev/fbi/app/models' }
-  let(:run){described_class.new(schema_file: schema_file, models_dir: models_dir, logger: UnitLogger.unit).run.sort_by{|m| m.class_name}
-  }
-
-  it 'test' do
-    result = described_class.new(schema_file: schema_file, models_dir: models_dir, logger: UnitLogger.unit).run
-    expect(result.count).to eq 3
-  end
-
-  it 'relationships' do
-    expect(run[-1].relationships.map{ |r| JSON.parse(r.to_json)})
-      .to eq [{"name" => "microposts", "class_name" => "Micropost", "type" => "has_many", "foreign_key" => "user_id"},
-              {"name" => "relationships", "class_name" => "Relationship", "type" => "has_many", "foreign_key" => "follower_id"},
-              {"name" => "followed_users", "class_name" => "FollowedUser", "type" => "has_many", "foreign_key" => "user_id", "through" => "relationships"},
-              {"name" => "reverse_relationships", "class_name" => "Relationship", "type" => "has_many", "foreign_key" => "followed_id"},
-              {"name" => "followers", "class_name" => "Follower", "type" => "has_many", "foreign_key" => "user_id", "through" => "reverse_relationships"}]
-  end
-
-  it 'methods' do
-    expect(run[-1].methods.map { |r| JSON.parse(r.to_json) })
-      .to eq([{"name" => "feed",       "arguments" => [],                     "type" => "instance"},
-              {"name" => "following?", "arguments" => [["req", "other_user"]], "type" => "instance"},
-              {"name" => "follow!",    "arguments" => [["req", "other_user"]], "type" => "instance"},
-              {"name" => "unfollow!",  "arguments" => [["req", "other_user"]], "type" => "instance"},
-              {"name" => "new_remember_token", "arguments" => [],             "type" => "class"},
-              {"name" => "digest",     "arguments" => [["req", "token"]],      "type" => "class"}])
-  end
-
-  it 'arguments' do
-    expect(run[-1].methods.last.arguments.passable).to eq('token')
-  end
-
-  it 'attributes' do
-    expect(run[-1].attributes.map { |r| JSON.parse(r.to_json) })
-    .to eq([{"name" => "id",              "type" => "integer", "primary_key" => true},
-            {"name" => "name",            "type" => "string"},
-            {"name" => "email",           "type" => "string", "default_value" => ""},
-            {"name" => "credits",         "type" => "decimal", "precision" => 19, "scale" => 6},
-            {"name" => "created_at",      "type" => "datetime"},
-            {"name" => "updated_at",      "type" => "datetime"},
-            {"name" => "password_digest", "type" => "string"},
-            {"name" => "remember_token",  "type" => "boolean", "default_value" => true},
-            {"name" => "admin",           "type" => "boolean", "default_value" => false}])
-  end
-
-  describe '#primary_key' do
-
-    context 'when primary model has a primary key' do
-
-      let(:given_model){OpenStruct.new(primary_key: 'user_id')}
-      let(:given_attributes){ [OpenStruct.new(name: 'user_id'), OpenStruct.new(name: 'name')] }
-
-      it 'will return attributes with that name' do
-        expect(described_class.new.primary_key(given_attributes, given_model)).to eq(given_attributes.first)
-      end
-
-    end
-
-    context 'when attributes has a primary key' do
-
-      let(:given_model) { OpenStruct.new(primary_key: false) }
-      let(:given_attributes) { [OpenStruct.new(name: 'user_id', primary_key: true), OpenStruct.new(name: 'name')] }
-
-      it 'will return attributes with that name' do
-        expect(described_class.new.primary_key(given_attributes, given_model)).to eq(given_attributes.first)
-      end
-
-    end
-
-    context 'when attributes or model has no primary key' do
-
-      let(:given_model) { OpenStruct.new(primary_key: false) }
-      let(:given_attributes) { [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')] }
-
-      it 'will default to attribute with id' do
-        expect(described_class.new.primary_key(given_attributes, given_model)).to eq(given_attributes.first)
-      end
-
-    end
-
-    context 'when attributes or model has no primary key and there is no id attribute' do
-
-      let(:given_model) { OpenStruct.new(primary_key: false) }
-      let(:given_attributes) { [OpenStruct.new(name: 'something'), OpenStruct.new(name: 'name')] }
-
-      it 'will return nil' do
-        expect(described_class.new.primary_key(given_attributes, given_model)).to eq(nil)
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/active_mocker/model_schema_spec.rb

@@ -1,145 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../../../lib', __FILE__)
-require 'json'
-require_relative '../../unit_logger'
-require 'active_mocker/model_schema'
-
-describe ActiveMocker::ModelSchema do
-
-  subject{described_class.new(class_name: 'Model',
-                              table_name: 'models'
-                              )
-          }
-
-  it '#class_name' do
-    expect(subject.class_name).to eq 'Model'
-  end
-
-  it '#table_name' do
-    expect(subject.table_name).to eq 'models'
-  end
-
-  describe '#primary_key' do
-
-    let(:a_primary_key_attribute){ ActiveMocker::ModelSchema::Attributes.new(name: 'key', primary_key: true, type: nil)}
-
-    it 'will return the first attribute that is a primary key' do
-      subject = described_class.new(attributes: [a_primary_key_attribute])
-      expect(subject.primary_key).to eq a_primary_key_attribute
-    end
-
-    let(:a_non_primary_key_attribute){ ActiveMocker::ModelSchema::Attributes.new(name: 'key', primary_key: false, type: nil)}
-
-    it 'will create a default primary_key of id if non is found' do
-      subject = described_class.new(attributes: [a_non_primary_key_attribute])
-      expect(subject.primary_key.name).to eq 'id'
-      expect(subject.attributes.count).to eq 2
-    end
-
-  end
-
-  describe '#attributes -> Array' do
-
-    subject { described_class.new(
-                   attributes: [ActiveMocker::ModelSchema::Attributes.new(name: 'name',
-                                                             type: :string,
-                                                             precision: nil,
-                                                             scale: nil,
-                                                             default_value: 'default'
-                                                            )]
-                                  ).attributes.first
-    }
-
-    it 'name' do
-      expect(subject.name).to eq 'name'
-    end
-
-    it 'type' do
-      expect(subject.type).to eq :string
-    end
-
-    it 'precision' do
-      expect(subject.precision).to eq nil
-    end
-
-    it 'scale' do
-      expect(subject.scale).to eq nil
-    end
-
-    it 'default_value' do
-      expect(subject.default_value).to eq 'default'
-    end
-
-  end
-
-  describe '#relationships -> Array' do
-
-    subject { described_class.new(
-                relationships:
-                    [
-                      ActiveMocker::ModelSchema::Relationships.new(name:       'name',
-                                                      class_name: 'ClassName',
-                                                      type:       'Relationship Type',
-                                                      through:    'link',
-                                                      foreign_key:'relationship_id',
-                                                      join_table: 'join_table'
-                                                      )
-                    ]
-             ).relationships.first
-    }
-
-    it 'name' do
-      expect(subject.name).to eq 'name'
-    end
-
-    it 'class_name' do
-      expect(subject.class_name).to eq 'ClassName'
-    end
-
-    it 'type' do
-      expect(subject.type).to eq 'Relationship Type'
-    end
-
-    it 'through' do
-      expect(subject.through).to eq 'link'
-    end
-
-    it 'foreign_key' do
-      expect(subject.foreign_key).to eq 'relationship_id'
-    end
-
-    it 'join_table' do
-      expect(subject.join_table).to eq 'join_table'
-    end
-
-  end
-
-  describe '#methods -> Array' do
-
-    subject { described_class.new(
-            methods:
-            [
-              ActiveMocker::ModelSchema::Methods.new(name:      'method_name',
-                                                     arguments: 'argument_array',
-                                                     type:      'class_method'
-                                                    )
-            ]
-            ).methods.first
-    }
-
-    it 'name' do
-      expect(subject.name).to eq 'method_name'
-    end
-
-    it 'arguments' do
-      expect(subject.arguments.class).to eq ActiveMocker::ModelSchema::Methods::Arguments
-      expect(subject.arguments.arguments).to eq 'argument_array'
-    end
-
-    it 'type' do
-      expect(subject.type).to eq 'class_method'
-    end
-
-  end
-
-end