active_mocker 1.3.2 → 1.4.1

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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,145 @@
+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

data/spec/lib/model.rb

@@ -4,7 +4,8 @@ class Model < ActiveRecord::Base
 
   include ModelCore::PlanService::Dah
 
-  belongs_to :company, class_name: 'PlanServiceCategory'
+  belongs_to :company, class_name: 'PlanServiceCategory', foreign_key: 'category_id'
+  belongs_to :person, through: 'customer'
   has_many :users
   has_one :account
   has_and_belongs_to_many :disclosures

data/spec/lib/reparameterize_spec.rb

@@ -0,0 +1,202 @@
+require 'rspec'
+require 'rspec/given'
+$:.unshift File.expand_path('../../../lib', __FILE__)
+require 'active_mocker/reparameterize'
+
+describe ActiveMocker::Reparameterize do
+
+  describe '::call' do
+
+    describe 'create parameter arguments' do
+
+      context 'keyreq' do
+
+        Given(:parameters) { [[:keyreq, 'named_param']] }
+
+        When(:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('named_param:') }
+
+      end
+
+      context 'key' do
+
+        Given(:parameters) { [[:key, 'named_param']] }
+
+        When (:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('named_param: nil') }
+
+      end
+
+      context 'req' do
+
+        Given(:parameters) { [[:req, 'req_param']] }
+
+        When (:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('req_param') }
+
+      end
+
+      context 'rest' do
+
+        Given(:parameters) { [[:rest, 'rest_param']] }
+
+        When (:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('*rest_param') }
+
+      end
+
+
+      context 'opt' do
+
+        Given(:parameters) { [[:opt, 'opt_param']] }
+
+        When(:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('opt_param=nil') }
+
+      end
+
+      context 'req, rest' do
+
+        Given(:parameters) { [[:req, 'req_param'], [:rest, 'rest_param']] }
+
+        When(:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('req_param, *rest_param') }
+
+      end
+
+      context 'req, opt' do
+
+        Given(:parameters) { [[:req, 'req_param'], [:opt, 'opt_param']] }
+
+        When(:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('req_param, opt_param=nil') }
+
+      end
+
+      context 'key, keyreq' do
+
+        Given(:parameters) { [[:key, 'named_param'], [:keyreq, 'named_param']] }
+
+        When(:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('named_param: nil, named_param:') }
+
+      end
+
+      context 'rep, key' do
+
+        Given(:parameters) { [[:key, 'key_param'], [:req, 'req_param']] }
+
+        When (:call) { described_class.call(parameters) }
+
+        Then { expect(call).to eq('key_param: nil, req_param') }
+
+      end
+
+    end
+
+    context 'create a parameter passable list' do
+
+      context 'keyreq' do
+
+        Given(:parameters) { [[:keyreq, 'named_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('named_param: named_param') }
+
+      end
+
+      context 'key' do
+
+        Given(:parameters) { [[:key, 'named_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('named_param: named_param') }
+
+      end
+
+      context 'req' do
+
+        Given(:parameters) { [[:req, 'req_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('req_param') }
+
+      end
+
+      context 'rest' do
+
+        Given(:parameters) { [[:rest, 'rest_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('rest_param') }
+
+      end
+
+
+      context 'opt' do
+
+        Given(:parameters) { [[:opt, 'opt_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('opt_param') }
+
+      end
+
+      context 'req, rest' do
+
+        Given(:parameters) { [[:req, 'req_param'], [:rest, 'rest_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('req_param, rest_param') }
+
+      end
+
+      context 'req, opt' do
+
+        Given(:parameters) { [[:req, 'req_param'], [:opt, 'opt_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('req_param, opt_param') }
+
+      end
+
+      context 'key, keyreq' do
+
+        Given(:parameters) { [[:key, 'key_param'], [:keyreq, 'keyreq_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('key_param: key_param, keyreq_param: keyreq_param') }
+
+      end
+
+      context 'rep, key' do
+
+        Given(:parameters) { [[:key, 'key_param'], [:req, 'req_param']] }
+
+        When (:call) { described_class.call(parameters, param_list: true) }
+
+        Then { expect(call).to eq('key_param: key_param, req_param') }
+
+      end
+
+    end
+
+  end
+
+end