active_mocker 1.4.2 → 1.5

data/sample_app_rails_4/spec/mocks/user_mock.rb

@@ -1,215 +0,0 @@
-require 'active_mocker/active_mock'
-Object.send(:remove_const, "UserMock") if Object.const_defined?("UserMock")
-
-class UserMock < ActiveMock::Base
-
-  class << self
-
-    def attributes
-      @attributes ||= HashWithIndifferentAccess.new({"id"=>nil, "name"=>nil, "email"=>"", "credits"=>nil, "created_at"=>nil, "updated_at"=>nil, "password_digest"=>nil, "remember_token"=>true, "admin"=>false})
-    end
-
-    def types
-      @types ||= { id: build_type(Fixnum), name: build_type(String), email: build_type(String), credits: build_type(BigDecimal), created_at: build_type(DateTime), updated_at: build_type(DateTime), password_digest: build_type(String), remember_token: build_type(Axiom::Types::Boolean), admin: build_type(Axiom::Types::Boolean) }
-    end
-
-    def associations
-      @associations ||= {:microposts=>nil, :relationships=>nil, :followed_users=>nil, :reverse_relationships=>nil, :followers=>nil}
-    end
-
-    def model_instance_methods
-      @model_instance_methods ||= {"feed"=>:not_implemented, "following?"=>:not_implemented, "follow!"=>:not_implemented, "unfollow!"=>:not_implemented}
-    end
-
-    def model_class_methods
-      @model_class_methods ||= {"new_remember_token"=>:not_implemented, "digest"=>:not_implemented}
-    end
-
-    def mocked_class
-      'User'
-    end
-
-    def column_names
-      attribute_names
-    end
-
-    def attribute_names
-      @attribute_names ||= ["id", "name", "email", "credits", "created_at", "updated_at", "password_digest", "remember_token", "admin"]
-    end
-
-    def primary_key
-      "id"
-    end
-
-  end
-
-  ##################################
-  #   Attributes getter/setters    #
-  ##################################
-
-  def id
-    read_attribute(:id)
-  end
-
-  def id=(val)
-    write_attribute(:id, val)
-  end
-
-  def name
-    read_attribute(:name)
-  end
-
-  def name=(val)
-    write_attribute(:name, val)
-  end
-
-  def email
-    read_attribute(:email)
-  end
-
-  def email=(val)
-    write_attribute(:email, val)
-  end
-
-  def credits
-    read_attribute(:credits)
-  end
-
-  def credits=(val)
-    write_attribute(:credits, val)
-  end
-
-  def created_at
-    read_attribute(:created_at)
-  end
-
-  def created_at=(val)
-    write_attribute(:created_at, val)
-  end
-
-  def updated_at
-    read_attribute(:updated_at)
-  end
-
-  def updated_at=(val)
-    write_attribute(:updated_at, val)
-  end
-
-  def password_digest
-    read_attribute(:password_digest)
-  end
-
-  def password_digest=(val)
-    write_attribute(:password_digest, val)
-  end
-
-  def remember_token
-    read_attribute(:remember_token)
-  end
-
-  def remember_token=(val)
-    write_attribute(:remember_token, val)
-  end
-
-  def admin
-    read_attribute(:admin)
-  end
-
-  def admin=(val)
-    write_attribute(:admin, val)
-  end
-
-  ##################################
-  #         Associations           #
-  ##################################
-
-
-# has_many
-  def microposts
-    @associations[:microposts] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('Micropost'))
-  end
-
-  def microposts=(val)
-    @associations[:microposts] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('Micropost'))
-  end
-
-  def relationships
-    @associations[:relationships] ||= ActiveMock::HasMany.new([],'follower_id', @attributes['id'], classes('Relationship'))
-  end
-
-  def relationships=(val)
-    @associations[:relationships] ||= ActiveMock::HasMany.new(val,'follower_id', @attributes['id'], classes('Relationship'))
-  end
-
-  def followed_users
-    @associations[:followed_users] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('FollowedUser'))
-  end
-
-  def followed_users=(val)
-    @associations[:followed_users] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('FollowedUser'))
-  end
-
-  def reverse_relationships
-    @associations[:reverse_relationships] ||= ActiveMock::HasMany.new([],'followed_id', @attributes['id'], classes('Relationship'))
-  end
-
-  def reverse_relationships=(val)
-    @associations[:reverse_relationships] ||= ActiveMock::HasMany.new(val,'followed_id', @attributes['id'], classes('Relationship'))
-  end
-
-  def followers
-    @associations[:followers] ||= ActiveMock::HasMany.new([],'user_id', @attributes['id'], classes('Follower'))
-  end
-
-  def followers=(val)
-    @associations[:followers] ||= ActiveMock::HasMany.new(val,'user_id', @attributes['id'], classes('Follower'))
-  end
-
-  ##################################
-  #  Model Methods getter/setters  #
-  ##################################
-
-
-  def feed()
-    block =  model_instance_methods['feed']
-    self.class.is_implemented(block, '#feed')
-    block.call(*[])
-  end
-
-  def following?(other_user)
-    block =  model_instance_methods['following?']
-    self.class.is_implemented(block, '#following?')
-    block.call(*[other_user])
-  end
-
-  def follow!(other_user)
-    block =  model_instance_methods['follow!']
-    self.class.is_implemented(block, '#follow!')
-    block.call(*[other_user])
-  end
-
-  def unfollow!(other_user)
-    block =  model_instance_methods['unfollow!']
-    self.class.is_implemented(block, '#unfollow!')
-    block.call(*[other_user])
-  end
-
-  def self.new_remember_token()
-    block =  model_class_methods['new_remember_token']
-    is_implemented(block, '::new_remember_token')
-    block.call(*[])
-  end
-
-  def self.digest(token)
-    block =  model_class_methods['digest']
-    is_implemented(block, '::digest')
-    block.call(*[token])
-  end
-
-  private
-
-  def self.reload
-    load __FILE__
-  end
-
-end

data/sample_app_rails_4/spec/reload_spec.rb

@@ -1,45 +0,0 @@
-require 'rspec'
-
-RSpec.configure do |config|
-  config.after(:all) do
-    ActiveMocker::LoadedMocks.clear_all
-  end
-
-  config.before(:all) do
-    ActiveMocker::LoadedMocks.clear_all
-  end
-end
-
-$:.unshift File.expand_path('../../', __FILE__)
-APP_ROOT = File.expand_path('../../', __FILE__) unless defined? APP_ROOT
-require 'config/initializers/active_mocker.rb'
-load 'mocks/user_mock.rb'
-
-describe 'Should change state of mock'do
-
-    before(:each) do
-      UserMock.create
-
-      UserMock.mock_class_method(:digest) do |token|
-        token
-      end
-    end
-
-    it 'should change record count and digest should be implemented' do
-      expect(UserMock.count).to eq 1
-      expect(UserMock.digest('token')).to eq 'token'
-    end
-
-end
-
-describe 'should have fresh mock' do
-
-  it 'should have record count of zero' do
-    expect(UserMock.count).to eq 0
-  end
-
-  it 'should raise error when calling digest' do
-    expect{UserMock.digest(nil)}.to raise_error(RuntimeError, '::digest is not Implemented for Class: UserMock')
-  end
-
-end

data/sample_app_rails_4/spec/spec_helper.rb

@@ -1,46 +0,0 @@
-ENV["RAILS_ENV"] ||= 'test'
-
-require File.expand_path("../../config/environment", __FILE__)
-require 'rspec/rails'
-require 'rspec/autorun'
-
-  # Requires supporting ruby files with custom matchers and macros, etc,
-  # in spec/support/ and its subdirectories.
-  Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
-
-  # Checks for pending migrations before tests are run.
-  # If you are not using ActiveRecord, you can remove this line.
-ActiveRecord::Migration.maintain_test_schema!
-
-RSpec.configure do |config|
-    # ## Mock Framework
-    #
-    # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
-    #
-    # config.mock_with :mocha
-    # config.mock_with :flexmock
-    # config.mock_with :rr
-
-    # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-
-    # If you're not using ActiveRecord, or you'd prefer not to run each of your
-    # examples within a transaction, remove the following line or assign false
-    # instead of true.
-    config.use_transactional_fixtures = true
-
-    # If true, the base class of anonymous controllers will be inferred
-    # automatically. This will be the default behavior in future versions of
-    # rspec-rails.
-    config.infer_base_class_for_anonymous_controllers = false
-
-    # Run specs in random order to surface order dependencies. If you find an
-    # order dependency and want to debug it, you can fix the order by providing
-    # the seed, which is printed after each run.
-    #     --seed 1234
-    config.order = "random"
-    # Include the Capybara DSL so that specs in spec/requests still work.
-    # Disable the old-style object.should syntax.
-    config.expect_with :rspec do |c|
-      c.syntax = :expect
-    end
-  end

data/sample_app_rails_4/spec/user_mock_spec.rb

@@ -1,197 +0,0 @@
-require 'rspec'
-$:.unshift File.expand_path('../../', __FILE__)
-require 'active_support'
-require 'spec/mocks/user_mock.rb'
-APP_ROOT =  File.expand_path('../../', __FILE__) unless defined? APP_ROOT
-require 'config/initializers/active_mocker.rb'
-require 'forwardable'
-
-describe 'UserMock' do
-
-  before(:each){
-    ActiveMocker::Generate.new
-    UserMock.clear_mock
-  }
-
-  describe '::mocked_class' do
-
-    it 'returns the name of the class being mocked' do
-      expect(UserMock.mocked_class).to eq 'User'
-    end
-
-  end
-
-  describe 'ActiveMocker::LoadedMocks' do
-
-    it 'will be added when sub classed' do
-      expect(ActiveMocker::LoadedMocks.all.keys.include?('UserMock')).to eq true
-    end
-
-  end
-
-
-  describe '::column_names' do
-
-    it 'returns an array of column names found from the schema.rb file' do
-      expect(UserMock.column_names).to eq(["id", "name", "email", "credits", "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 = UserMock.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{UserMock.new(baz: "Hello")}.to raise_error(ActiveMock::RejectedParams, '{:baz=>"Hello"} for UserMock')
-    end
-
-  end
-
-  describe 'relationships' do
-
-    it 'add instance methods from model relationships' do
-      result = UserMock.new(followers: [1])
-      expect(result.followers).to eq [1]
-    end
-
-    it 'add has_many relationship' do
-      expect(UserMock.new.microposts.count).to eq 0
-      mock_inst = UserMock.new
-      mock_inst.microposts << 1
-      expect(mock_inst.microposts.count).to eq 1
-      mock_inst.microposts << 1
-      expect(mock_inst.microposts.count).to eq 2
-      expect(mock_inst.microposts.to_a).to eq [1, 1]
-    end
-
-  end
-
-  describe 'instance methods' do
-
-    it 'will raise exception for unimplemented methods' do
-      expect(UserMock.new.method(:following?).parameters).to eq  [[:req, :other_user]]
-      expect{UserMock.new.following?}.to raise_error ArgumentError
-      expect{UserMock.new.following?('foo')}.to raise_error(RuntimeError, '#following? is not Implemented for Class: UserMock')
-    end
-
-    it 'can be implemented dynamically' do
-
-      UserMock.mock_instance_method(:follow!) do  |other_user|
-        "Now implemented with #{other_user}"
-      end
-      result = UserMock.new
-      result = result.follow!('foo')
-      expect(result).to eq "Now implemented with foo"
-
-    end
-
-    it 'can not reference another method within the mock' do
-
-      UserMock.mock_instance_method(:following?) do  |person|
-        true
-      end
-
-      UserMock.mock_instance_method(:follow!) do |person|
-        following?(person)
-      end
-
-      expect{UserMock.new.follow!("name") }.to raise_error
-      expect(UserMock.new.following?(1)).to eq true
-    end
-
-  end
-
-  describe 'class methods' do
-
-    it 'will raise exception for unimplemented methods' do
-      expect{UserMock.new_remember_token}.to raise_error('::new_remember_token is not Implemented for Class: UserMock')
-    end
-
-    it 'can be implemented as follows' do
-
-      UserMock.mock_class_method(:new_remember_token) do
-        "Now implemented"
-      end
-      expect{UserMock.new_remember_token}.to_not raise_error
-      expect(UserMock.new_remember_token).to eq("Now implemented")
-
-    end
-
-  end
-
-  context 'active_mock' do
-
-    it 'uses active_mock::base as superclass' do
-      expect(UserMock.superclass.name).to eq 'ActiveMock::Base'
-    end
-
-    it 'can save to class and then find instance by attribute' do
-      record = UserMock.create(name: "Sam")
-      expect(UserMock.find_by(name:"Sam")).to eq record
-
-    end
-
-    it '#update' do
-
-      person = UserMock.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
-
-      UserMock.create
-
-      expect(UserMock.count).to eq 1
-
-      UserMock.destroy_all
-
-      expect(UserMock.count).to eq 0
-
-    end
-
-    it '::find_by' do
-      person = UserMock.create(name: 'dustin')
-      expect(UserMock.find_by(name: 'dustin')).to eq person
-    end
-
-    it '::find_or_create_by' do
-      person = UserMock.find_or_create_by(name: 'dustin')
-      expect(UserMock.find_by(name: 'dustin')).to eq person
-      person = UserMock.find_or_create_by(name: 'dustin')
-      expect(UserMock.count).to eq 1
-    end
-
-    it '::find_or_create_by with update' do
-      UserMock.create(name: 'dustin')
-      person = UserMock.find_or_create_by(name: 'dustin')
-      person.update(email: 'Zeisler')
-      expect(UserMock.first.attributes).to eq person.attributes
-      expect(UserMock.count).to eq 1
-    end
-
-    it '::find_or_initialize_by' do
-      person = UserMock.find_or_initialize_by(name: 'dustin')
-      expect(person.persisted?).to eq false
-      UserMock.create(name: 'dustin')
-      person = UserMock.find_or_initialize_by(name: 'dustin')
-      expect(person.persisted?).to eq true
-    end
-
-
-    after(:each) do
-      UserMock.delete_all
-    end
-
-  end
-
-end