active_mocker 1.1.23 → 1.2.pre

data/spec/mocks/relationship_mock.rb

@@ -0,0 +1,100 @@
+require 'active_mocker/mock_requires'
+
+Object.send(:remove_const, 'RelationshipMock') if class_exists? 'RelationshipMock'
+
+class RelationshipMock < ::ActiveHash::Base
+  include ActiveMocker::ActiveHash::ARApi
+  include ActiveMocker::MockInstanceMethods
+  extend  ActiveMocker::MockClassMethods
+
+  def self.column_names
+    ["id", "follower_id", "followed_id", "created_at", "updated_at"]
+  end
+
+  def self.association_names
+    @association_names = [:follower, :followed]
+  end
+
+  def self.attribute_names
+    @attribute_names = [:id, :follower_id, :followed_id, :created_at, :updated_at]
+  end
+
+
+  def id
+    attributes['id']
+  end
+
+  def id=(val)
+    attributes['id'] = val
+  end
+
+  def follower_id
+    attributes['follower_id']
+  end
+
+  def follower_id=(val)
+    attributes['follower_id'] = val
+  end
+
+  def followed_id
+    attributes['followed_id']
+  end
+
+  def followed_id=(val)
+    attributes['followed_id'] = val
+  end
+
+  def created_at
+    attributes['created_at']
+  end
+
+  def created_at=(val)
+    attributes['created_at'] = val
+  end
+
+  def updated_at
+    attributes['updated_at']
+  end
+
+  def updated_at=(val)
+    attributes['updated_at'] = val
+  end
+
+
+
+  def follower
+    associations['follower']
+  end
+
+  def follower=(val)
+    associations['follower'] = val
+  end
+
+  def followed
+    associations['followed']
+  end
+
+  def followed=(val)
+    associations['followed'] = val
+  end
+
+
+
+
+  def self.model_instance_methods
+    return @model_instance_methods if @model_instance_methods
+    @model_instance_methods = {}
+    @model_instance_methods
+  end
+
+  def self.model_class_methods
+    return @model_class_methods if @model_class_methods
+    @model_class_methods = {}
+    @model_class_methods
+  end
+
+
+
+
+
+end

data/spec/mocks/user_mock.rb

@@ -0,0 +1,196 @@
+require 'active_mocker/mock_requires'
+
+Object.send(:remove_const, 'UserMock') if class_exists? 'UserMock'
+
+class UserMock < ::ActiveHash::Base
+  include ActiveMocker::ActiveHash::ARApi
+  include ActiveMocker::MockInstanceMethods
+  extend  ActiveMocker::MockClassMethods
+
+  def self.column_names
+    ["id", "name", "email", "created_at", "updated_at", "password_digest", "remember_token", "admin"]
+  end
+
+  def self.association_names
+    @association_names = [:microposts, :relationships, :followed_users, :reverse_relationships, :followers]
+  end
+
+  def self.attribute_names
+    @attribute_names = [:id, :name, :email, :created_at, :updated_at, :password_digest, :remember_token, :admin]
+  end
+
+
+  def id
+    attributes['id']
+  end
+
+  def id=(val)
+    attributes['id'] = val
+  end
+
+  def name
+    attributes['name']
+  end
+
+  def name=(val)
+    attributes['name'] = val
+  end
+
+  def email
+    attributes['email']
+  end
+
+  def email=(val)
+    attributes['email'] = val
+  end
+
+  def created_at
+    attributes['created_at']
+  end
+
+  def created_at=(val)
+    attributes['created_at'] = val
+  end
+
+  def updated_at
+    attributes['updated_at']
+  end
+
+  def updated_at=(val)
+    attributes['updated_at'] = val
+  end
+
+  def password_digest
+    attributes['password_digest']
+  end
+
+  def password_digest=(val)
+    attributes['password_digest'] = val
+  end
+
+  def remember_token
+    attributes['remember_token']
+  end
+
+  def remember_token=(val)
+    attributes['remember_token'] = val
+  end
+
+  def admin
+    attributes['admin']
+  end
+
+  def admin=(val)
+    attributes['admin'] = val
+  end
+
+
+
+
+
+  def microposts
+    associations['microposts']
+  end
+
+  def microposts=(val)
+    associations['microposts'] = ActiveMocker::CollectionAssociation.new(val)
+  end
+
+  def relationships
+    associations['relationships']
+  end
+
+  def relationships=(val)
+    associations['relationships'] = ActiveMocker::CollectionAssociation.new(val)
+  end
+
+  def followed_users
+    associations['followed_users']
+  end
+
+  def followed_users=(val)
+    associations['followed_users'] = ActiveMocker::CollectionAssociation.new(val)
+  end
+
+  def reverse_relationships
+    associations['reverse_relationships']
+  end
+
+  def reverse_relationships=(val)
+    associations['reverse_relationships'] = ActiveMocker::CollectionAssociation.new(val)
+  end
+
+  def followers
+    associations['followers']
+  end
+
+  def followers=(val)
+    associations['followers'] = ActiveMocker::CollectionAssociation.new(val)
+  end
+
+
+  def self.model_instance_methods
+    return @model_instance_methods if @model_instance_methods
+    @model_instance_methods = {}
+      @model_instance_methods[:feed] = :not_implemented
+    
+      @model_instance_methods[:following?] = :not_implemented
+    
+      @model_instance_methods[:follow!] = :not_implemented
+    
+      @model_instance_methods[:unfollow!] = :not_implemented
+    
+    @model_instance_methods
+  end
+
+  def self.model_class_methods
+    return @model_class_methods if @model_class_methods
+    @model_class_methods = {}
+    @model_class_methods[:new_remember_token] = :not_implemented
+  
+    @model_class_methods[:digest] = :not_implemented
+  
+    @model_class_methods
+  end
+
+
+  def feed()
+    block =  model_instance_methods[:feed]
+    self.class.is_implemented(block, "#feed")
+    instance_exec(*[], &block)
+  end
+
+  def following?(other_user)
+    block =  model_instance_methods[:following?]
+    self.class.is_implemented(block, "#following?")
+    instance_exec(*[other_user], &block)
+  end
+
+  def follow!(other_user)
+    block =  model_instance_methods[:follow!]
+    self.class.is_implemented(block, "#follow!")
+    instance_exec(*[other_user], &block)
+  end
+
+  def unfollow!(other_user)
+    block =  model_instance_methods[:unfollow!]
+    self.class.is_implemented(block, "#unfollow!")
+    instance_exec(*[other_user], &block)
+  end
+
+
+
+  def self.new_remember_token()
+    block =  model_class_methods[:new_remember_token]
+    is_implemented(block, "::new_remember_token")
+    instance_exec(*[], &block)
+  end
+
+  def self.digest(token)
+    block =  model_class_methods[:digest]
+    is_implemented(block, "::digest")
+    instance_exec(*[token], &block)
+  end
+
+
+end

data/spec/mocks/user_mock_spec.rb

@@ -0,0 +1,173 @@
+require 'rspec'
+$:.unshift File.expand_path('../', __FILE__)
+load 'spec/mocks/user_mock.rb'
+
+describe UserMock do
+
+  let(:mock_class){described_class}
+
+  describe '::column_names' do
+
+    it 'returns an array of column names found from the schema.rb file' do
+      expect(mock_class.column_names).to eq(["id", "name", "email", "created_at", "updated_at", "password_digest", "remember_token", "admin"])
+    end
+
+  end
+
+  describe 'mass_assignment' do
+
+    it "can pass any or all attributes from schema in initializer" do
+      result = mock_class.new(name: "Sam", email: 'Walton')
+      expect(result.name).to eq 'Sam'
+      expect(result.email).to eq 'Walton'
+    end
+
+    it 'will raise error if not an attribute or association' do
+      expect{mock_class.new(baz: "Hello")}.to raise_error('Rejected params: {"baz"=>"Hello"} for UserMock')
+    end
+
+  end
+
+  describe 'relationships' do
+
+    it 'add instance methods from model relationships' do
+      result = mock_class.new(followers: [1])
+      expect(result.followers).to eq [1]
+    end
+
+    it 'add has_many relationship' do
+
+      expect(mock_class.new.microposts.class).to eq ActiveMocker::CollectionAssociation
+      expect(mock_class.new.microposts.count).to eq 0
+      mock_inst = mock_class.new
+      mock_inst.microposts << 1
+      expect(mock_inst.microposts.count).to eq 1
+
+    end
+
+  end
+
+  describe 'instance methods' do
+
+    it 'will raise exception for unimplemented methods' do
+      expect(mock_class.new.method(:following?).parameters).to eq  [[:req, :other_user]]
+      expect{mock_class.new.following?}.to raise_error ArgumentError
+      expect{mock_class.new.following?('foo')}.to raise_error(RuntimeError, '#following? is not Implemented for Class: UserMock')
+    end
+
+    it 'can be implemented dynamically' do
+
+      mock_class.mock_instance_method(:follow!) do  |other_user|
+        "Now implemented with #{other_user}"
+      end
+      result = mock_class.new
+      result = result.follow!('foo')
+      expect(result).to eq "Now implemented with foo"
+
+    end
+
+    it 'can reference another mock' do
+
+      mock_class.mock_instance_method(:following?) do  |person|
+        true
+      end
+
+      mock_class.mock_instance_method(:follow!) do |person|
+        following?(person)
+      end
+
+      expect(mock_class.new.follow!("name")).to eq true
+      expect(mock_class.new.following?(1)).to eq true
+    end
+
+  end
+
+  describe 'class methods' do
+
+    it 'will raise exception for unimplemented methods' do
+      expect{mock_class.new_remember_token}.to raise_error('::new_remember_token is not Implemented for Class: UserMock')
+    end
+
+    it 'can be implemented as follows' do
+
+      mock_class.mock_class_method(:new_remember_token) do
+        "Now implemented"
+      end
+      expect{mock_class.new_remember_token}.to_not raise_error
+      expect(mock_class.new_remember_token).to eq("Now implemented")
+
+    end
+
+  end
+
+  context 'active_hash' do
+
+    it 'uses active_hash::base as superclass' do
+      expect(mock_class.superclass.name).to eq 'ActiveHash::Base'
+    end
+
+    it 'can save to class and then find instance by attribute' do
+      record = mock_class.create(name: "Sam")
+      expect(mock_class.find_by(name:"Sam")).to eq record
+
+    end
+
+    it '#update' do
+
+      person = mock_class.create(name: 'Justin')
+
+      expect(UserMock.first.name).to eq 'Justin'
+      person.update(name: 'Dustin')
+      expect(UserMock.first.name).to eq 'Dustin'
+
+      expect(person.name).to eq 'Dustin'
+
+    end
+
+    it '::destroy_all' do
+
+      mock_class.create
+
+      expect(mock_class.count).to eq 1
+
+      mock_class.destroy_all
+
+      expect(mock_class.count).to eq 0
+
+    end
+
+    it '::find_by' do
+      person = mock_class.create(name: 'dustin')
+      expect(mock_class.find_by(name: 'dustin')).to eq person
+    end
+
+    it '::find_or_create_by' do
+      person = mock_class.find_or_create_by(name: 'dustin')
+      expect(mock_class.find_by(name: 'dustin')).to eq person
+      person = mock_class.find_or_create_by(name: 'dustin')
+      expect(mock_class.count).to eq 1
+    end
+
+    it '::find_or_create_by with update' do
+      mock_class.create(name: 'dustin')
+      person = mock_class.find_or_create_by(name: 'dustin')
+      person.update(email: 'Zeisler')
+      expect(mock_class.first.attributes).to eq person.attributes
+      expect(mock_class.count).to eq 1
+    end
+
+    it '::find_or_initialize_by' do
+      person = mock_class.find_or_initialize_by(name: 'dustin')
+      expect(person.persisted?).to eq false
+      mock_class.create(name: 'dustin')
+      person = mock_class.find_or_initialize_by(name: 'dustin')
+      expect(person.persisted?).to eq true
+    end
+
+    after(:each) do
+      mock_class.delete_all
+    end
+
+  end
+
+end