challah 0.9.1.beta → 0.9.1.beta.2

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/active_record/have_db_column_matcher_spec.rb

@@ -1,185 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
-  context "have_db_column" do
-    before do
-      @matcher = have_db_column(:nickname)
-    end
-
-    it "should accept an existing database column" do
-      create_table 'superheros' do |table|
-        table.string :nickname
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a nonexistent database column" do
-      define_model :superhero
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column of type string" do
-    before do
-      @matcher = have_db_column(:nickname).of_type(:string)
-    end
-
-    it "should accept a column of correct type" do
-      create_table 'superheros' do |table|
-        table.string :nickname
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a nonexistent database column" do
-      define_model :superhero
-      Superhero.new.should_not @matcher
-    end
-
-    it "should reject a column of wrong type" do
-      create_table 'superheros' do |table|
-        table.integer :nickname
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with precision option" do
-    before do
-      @matcher = have_db_column(:salary).with_options(:precision => 5)
-    end
-
-    it "should accept a column of correct precision" do
-      create_table 'superheros' do |table|
-        table.decimal :salary, :precision => 5
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a column of wrong precision" do
-      create_table 'superheros' do |table|
-        table.decimal :salary, :precision => 15
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with limit option" do
-    before do
-      @matcher = have_db_column(:email).
-                   of_type(:string).
-                   with_options(:limit => 255)
-    end
-
-    it "should accept a column of correct limit" do
-      create_table 'superheros' do |table|
-        table.string :email, :limit => 255
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a column of wrong limit" do
-      create_table 'superheros' do |table|
-        table.string :email, :limit => 500
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with default option" do
-    before do
-      @matcher = have_db_column(:admin).
-                   of_type(:boolean).
-                   with_options(:default => false)
-    end
-
-    it "should accept a column of correct default" do
-      create_table 'superheros' do |table|
-        table.boolean :admin, :default => false
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a column of wrong default" do
-      create_table 'superheros' do |table|
-        table.boolean :admin, :default => true
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with null option" do
-    before do
-      @matcher = have_db_column(:admin).
-                   of_type(:boolean).
-                   with_options(:null => false)
-    end
-
-    it "should accept a column of correct null" do
-      create_table 'superheros' do |table|
-        table.boolean :admin, :null => false
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a column of wrong null" do
-      create_table 'superheros' do |table|
-        table.boolean :admin, :null => true
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with scale option" do
-    before do
-      @matcher = have_db_column(:salary).
-                   of_type(:decimal).
-                   with_options(:scale => 2)
-    end
-
-    it "should accept a column of correct scale" do
-      create_table 'superheros' do |table|
-        table.decimal :salary, :precision => 10, :scale => 2
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a column of wrong scale" do
-      create_table 'superheros' do |table|
-        table.decimal :salary, :precision => 10, :scale => 4
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_column with primary option" do
-    it "should accept a column that is primary" do
-      create_table 'superheros' do |table|
-        table.integer :id, :primary => true
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should have_db_column(:id).with_options(:primary => true)
-    end
-
-    it "should reject a column that is not primary" do
-      create_table 'superheros' do |table|
-        table.integer :primary
-      end
-      define_model_class 'Superhero'
-      Superhero.new.should_not have_db_column(:primary).with_options(:primary => true)
-    end
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/active_record/have_db_index_matcher_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
-  context "have_db_index" do
-    before do
-      @matcher = have_db_index(:age)
-    end
-
-    it "should accept an existing index" do
-      db_connection = create_table 'superheros' do |table|
-        table.integer :age
-      end
-      db_connection.add_index :superheros, :age
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject a nonexistent index" do
-      define_model :superhero
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_index with unique option" do
-    before do
-      @matcher = have_db_index(:ssn).unique(true)
-    end
-
-    it "should accept an index of correct unique" do
-      db_connection = create_table 'superheros' do |table|
-        table.integer :ssn
-      end
-      db_connection.add_index :superheros, :ssn, :unique => true
-      define_model_class 'Superhero'
-      Superhero.new.should @matcher
-    end
-
-    it "should reject an index of wrong unique" do
-      db_connection = create_table 'superheros' do |table|
-        table.integer :ssn
-      end
-      db_connection.add_index :superheros, :ssn, :unique => false
-      define_model_class 'Superhero'
-      Superhero.new.should_not @matcher
-    end
-  end
-
-  context "have_db_index on multiple columns" do
-    before do
-      @matcher = have_db_index([:geocodable_type, :geocodable_id])
-    end
-
-    it "should accept an existing index" do
-      db_connection = create_table 'geocodings' do |table|
-        table.integer :geocodable_id
-        table.string  :geocodable_type
-      end
-      db_connection.add_index :geocodings, [:geocodable_type, :geocodable_id]
-      define_model_class 'Geocoding'
-      Geocoding.new.should @matcher
-    end
-
-    it "should reject a nonexistant index" do
-      db_connection = create_table 'geocodings' do |table|
-        table.integer :geocodable_id
-        table.string  :geocodable_type
-      end
-      define_model_class 'Geocoding'
-      Geocoding.new.should_not @matcher
-    end
-  end
-
-  it "should join columns with and describing multiple columns" do
-    have_db_index([:user_id, :post_id]).description.should =~ /on columns user_id and post_id/
-  end
-
-  it "should context a unique index as unique" do
-    have_db_index(:user_id).unique(true).description.should =~ /a unique index/
-  end
-
-  it "should context a non-unique index as non-unique" do
-    have_db_index(:user_id).unique(false).description.should =~ /a non-unique index/
-  end
-
-  it "should not context an index's uniqueness when it isn't important" do
-    have_db_index(:user_id).description.should_not =~ /unique/
-  end
-
-  it "allows an IndexDefinition to have a truthy value for unique" do
-    db_connection = create_table 'superheros' do |table|
-      table.integer :age
-    end
-    db_connection.add_index :superheros, :age
-    define_model_class 'Superhero'
-
-    @matcher = have_db_index(:age).unique(true)
-
-    index_definition = stub("ActiveRecord::ConnectionAdapters::IndexDefinition",
-                            :unique => 7,
-                            :name => :age)
-    @matcher.stubs(:matched_index => index_definition)
-
-    Superhero.new.should @matcher
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/active_record/have_readonly_attributes_matcher_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
-  context "an attribute that cannot be set after being saved" do
-    before do
-      define_model :example, :attr => :string do
-        attr_readonly :attr
-      end
-      @model = Example.new
-    end
-
-    it "should accept being read-only" do
-      @model.should have_readonly_attribute(:attr)
-    end
-  end
-
-  context "an attribute not included in the readonly set" do
-    before do
-      define_model :example, :attr => :string, :other => :string do
-        attr_readonly :other
-      end
-      @model = Example.new
-    end
-
-    it "should not accept being read-only" do
-      @model.should_not have_readonly_attribute(:attr)
-    end
-  end
-
-  context "an attribute on a class with no readonly attributes" do
-    before do
-      define_model :example, :attr => :string
-      @model = Example.new
-    end
-
-    it "should not accept being read-only" do
-      @model.should_not have_readonly_attribute(:attr)
-    end
-
-    it "should assign a failure message" do
-      matcher = have_readonly_attribute(:attr)
-      matcher.matches?(@model).should == false
-      matcher.failure_message.should_not be_nil
-    end
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/active_record/query_the_database_matcher_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::QueryTheDatabaseMatcher do
-  before do
-    @parent = define_model :litter do
-      has_many :kittens
-    end
-    @child = define_model :kitten, :litter_id => :integer do
-      belongs_to :litter
-    end
-  end
-
-  it "accepts the correct number of queries when there is a single query" do
-    @parent.should query_the_database(1.times).when_calling(:count)
-  end
-
-  it "accepts any number of queries when no number is specified" do
-    @parent.should query_the_database.when_calling(:count)
-  end
-
-  it "rejects any number of queries when no number is specified" do
-    @parent.should_not query_the_database.when_calling(:to_s)
-  end
-
-  it "accepts the correct number of queries when there are two queries" do
-    nonsense = lambda do
-      @parent.create.kittens.create
-    end
-    nonsense.should query_the_database(2.times).when_calling(:call)
-  end
-
-  it "rejects the wrong number of queries" do
-    @parent.should_not query_the_database(10.times).when_calling(:count)
-  end
-
-  it "accepts fewer than the specified maximum" do
-    @parent.should query_the_database(5.times).or_less.when_calling(:count)
-  end
-
-  it "passes arguments to the method to examine" do
-    model = stub("Model", :count => nil)
-    model.should_not query_the_database.when_calling(:count).with("arguments")
-    model.should have_received(:count).with("arguments")
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/active_record/serialize_matcher_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
-  context "an attribute that should be serialized" do
-    let(:model) do
-      define_model(:example, :attr => :string) do
-        serialize :attr
-      end.new
-    end
-
-    it "should be serialized" do
-      model.should serialize(:attr)
-    end
-  end
-
-  context "an attribute that should be serialized with a type of Hash" do
-    let(:model) do
-      define_model(:example, :attr => :string) do
-        serialize :attr, Hash
-      end.new
-    end
-
-    it "should be serialized" do
-      model.should serialize(:attr).as(Hash)
-    end
-
-    it "should not match when using as_instance_of" do
-      model.should_not serialize(:attr).as_instance_of(Hash)
-    end
-  end
-
-  context "an attribute that should be serialized with a type of Array" do
-    let(:model) do
-      define_model(:example, :attr => :string, :attr2 => :string) do
-        serialize :attr, Array
-        serialize :attr2, Array
-      end.new
-    end
-
-    it "should be serialized" do
-      model.should serialize(:attr).as(Array)
-    end
-  end
-
-  context "an attribute that should be serialized but isn't" do
-    let(:model) { define_model(:example, :attr => :string).new }
-
-    it "should assign a failure message" do
-      matcher = serialize(:attr)
-      matcher.matches?(model).should == false
-      matcher.failure_message.should_not be_nil
-    end
-
-    it "should assign a failure message with 'as'" do
-      matcher = serialize(:attr).as(Hash)
-      matcher.matches?(model).should == false
-      matcher.failure_message.should_not be_nil
-    end
-
-    context "a serializer that is an instance of a class" do
-      before do
-        define_class(:ExampleSerializer) do
-          def load(*); end
-          def dump(*); end
-        end
-        define_model :example, :attr => :string do
-          serialize :attr, ExampleSerializer.new
-        end
-        @model = Example.new
-      end
-
-      it "should match when using as_instance_of" do
-        @model.should serialize(:attr).as_instance_of(ExampleSerializer)
-      end
-
-      it "should not match when using as" do
-        @model.should_not serialize(:attr).as(ExampleSerializer)
-      end
-    end
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/shoulda/independent/delegate_matcher_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::Independent::DelegateMatcher do
-  it 'supports chaining on #to' do
-    matcher = delegate_method(:method)
-    matcher.to(:another_method).should == matcher
-  end
-
-  it 'supports chaining on #with_arguments' do
-    matcher = delegate_method(:method)
-    matcher.with_arguments(1, 2, 3).should == matcher
-  end
-
-  it 'supports chaining on #as' do
-    matcher = delegate_method(:method)
-    matcher.as(:some_other_method).should == matcher
-  end
-
-  it 'should raise an error if no delegation target is defined' do
-    object = Object.new
-    expect {
-      object.should delegate_method(:name)
-    }.to raise_exception Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError
-  end
-
-  it 'should raise an error if called with #should_not' do
-    object = Object.new
-    expect {
-      object.should_not delegate_method(:name).to(:anyone)
-    }.to raise_exception Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher
-  end
-
-  context 'given a method that does not delegate' do
-    before do
-      define_class(:post_office) do
-        def deliver_mail
-          :delivered
-        end
-      end
-    end
-
-    it 'does not match' do
-      post_office = PostOffice.new
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-      matcher.matches?(post_office).should be_false
-    end
-
-    it 'has a failure message that indicates which method should have been delegated' do
-      post_office = PostOffice.new
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      matcher.matches?(post_office)
-
-      message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman'
-      matcher.failure_message.should == message
-    end
-
-    it 'uses the proper syntax for class methods in errors' do
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      matcher.matches?(PostOffice)
-
-      message = 'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman'
-      matcher.failure_message.should == message
-    end
-  end
-
-  context 'given a method that delegates properly' do
-    before do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    it 'matches' do
-      post_office = PostOffice.new
-      post_office.should delegate_method(:deliver_mail).to(:mailman)
-    end
-  end
-
-  context 'given a method that delegates properly with certain arguments' do
-    before do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail('221B Baker St.', :hastily => true)
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct arguments' do
-      it 'matches' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('221B Baker St.', :hastily => true)
-        post_office.should matcher
-      end
-    end
-
-    context 'when not given the correct arguments' do
-      it 'does not match' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('123 Nowhere Ln.')
-        matcher.matches?(post_office).should be_false
-      end
-
-      it 'has a failure message that indicates which arguments were expected' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('123 Nowhere Ln.')
-
-        matcher.matches?(post_office)
-
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]'
-        matcher.failure_message.should == message
-      end
-    end
-  end
-
-  context 'given a method that delegates properly to a method of a different name' do
-    before do
-      define_class(:mailman)
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail_and_avoid_dogs
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'when given the correct method name' do
-      it 'matches' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:deliver_mail_and_avoid_dogs)
-        post_office.should matcher
-      end
-    end
-
-    context 'when given an incorrect method name' do
-      it 'does not match' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-        matcher.matches?(post_office).should be_false
-      end
-
-      it 'has a failure message that indicates which method was expected' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-
-        matcher.matches?(post_office)
-
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as :watch_tv'
-        matcher.failure_message.should == message
-      end
-    end
-  end
-end
-
-describe Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError do
-  it 'has a useful message' do
-    error = Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError.new
-    error.message.should include 'Delegation needs a target'
-  end
-end
-
-describe Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher do
-  it 'has a useful message' do
-    error = Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher.new
-    error.message.should include 'does not support #should_not'
-  end
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# Create Rails environment based on the version given from Appraisal
-TESTAPP_ROOT = File.join(File.dirname(__FILE__), '..', 'tmp', 'aruba', 'testapp')
-FileUtils.rm_rf(TESTAPP_ROOT) if File.exists?(TESTAPP_ROOT)
-`rails new #{TESTAPP_ROOT}`
-
-ENV['RAILS_ENV'] = 'test'
-ENV['BUNDLE_GEMFILE'] ||= TESTAPP_ROOT + '/Gemfile'
-
-require "#{TESTAPP_ROOT}/config/environment"
-require 'rspec'
-require 'bourne'
-require 'shoulda-matchers'
-require 'rspec/rails'
-
-PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..')).freeze
-
-$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
-
-Dir[File.join(PROJECT_ROOT, 'spec', 'support', '**', '*.rb')].each { |file| require(file) }
-
-# Run the migrations
-ActiveRecord::Migration.verbose = false
-ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
-
-RSpec.configure do |config|
-  config.mock_with :mocha
-  config.include Shoulda::Matchers::ActionController,
-                 :example_group => { :file_path => /action_controller/ }
-  config.include Shoulda::Matchers::ActionMailer,
-                 :example_group => { :file_path => /action_mailer/ }
-end

data/vendor/bundle/gems/shoulda-matchers-1.4.2/spec/support/active_model_versions.rb

@@ -1,9 +0,0 @@
-RSpec.configure do |c|
-  def active_model_3_1?
-    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1
-  end
-
-  def active_model_3_2?
-    ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2
-  end
-end