dm_preferences 0.5.6 → 1.0

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.order = "random"
+end
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!

data/spec/support/assert_queries.rb

@@ -0,0 +1,36 @@
+#------------------------------------------------------------------------------
+def assert_queries(num = 1, &block)
+  expect(ActiveRecord::Base.count_queries(&block)).to eq num
+end
+
+# http://stackoverflow.com/questions/5490411/counting-the-number-of-queries-performed
+#------------------------------------------------------------------------------
+module ActiveRecord
+  class QueryCounter
+    cattr_accessor :query_count do
+      0
+    end
+
+    IGNORED_SQL = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/]
+
+    def call(name, start, finish, message_id, values)
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      unless 'CACHE' == values[:name]
+        self.class.query_count += 1 unless IGNORED_SQL.any? { |r| values[:sql] =~ r }
+      end
+    end
+  end
+end
+
+ActiveSupport::Notifications.subscribe('sql.active_record', ActiveRecord::QueryCounter.new)
+
+module ActiveRecord
+  class Base
+    def self.count_queries(&block)
+      ActiveRecord::QueryCounter.query_count = 0
+      yield
+      ActiveRecord::QueryCounter.query_count
+    end
+  end
+end

data/{test → spec/support}/factory.rb

@@ -21,7 +21,7 @@ module Factory
   def new_record(model, *args)
     attributes = valid_attributes_for(model, *args)
     record = model.new(attributes)
-    attributes.each {|attr, value| record.send("#{attr}=", value) if model.accessible_attributes && !model.accessible_attributes.include?(attr) || model.protected_attributes && model.protected_attributes.include?(attr)}
+    attributes.each {|attr, value| record.send("#{attr}=", value)}
     record
   end
   

data/spec/unit/preference_definition_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+#------------------------------------------------------------------------------
+describe 'PreferenceDefinitionByDefaultTest' do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications)
+  end
+
+  it 'test_should_have_a_name' do
+    # assert_equal 'notifications2', @definition.name
+    expect('notifications').to eq @definition.name
+  end
+
+  it "test_should_not_have_a_default_value" do
+    expect(nil).to eq @definition.default_value
+  end
+
+  it "test_should_have_a_type" do
+    assert_equal :boolean, @definition.type
+  end
+
+  it "test_should_type_cast_values_as_booleans" do
+    assert_equal nil, @definition.type_cast(nil)
+    assert_equal true, @definition.type_cast(true)
+    assert_equal false, @definition.type_cast(false)
+    assert_equal false, @definition.type_cast(0)
+    assert_equal true, @definition.type_cast(1)
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionTest" do
+  it "test_should_raise_exception_if_invalid_option_specified" do
+    expect {
+      Preferences::PreferenceDefinition.new(:notifications, :invalid => true)
+    }.to raise_error(ArgumentError)
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithDefaultValueTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :boolean, :default => 1)
+  end
+
+  it "test_should_type_cast_default_values" do
+    assert_equal true, @definition.default_value
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithGroupDefaultsTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :boolean, :default => 1, :group_defaults => {:chat => 0})
+  end
+
+  it "test_should_use_default_for_default_group" do
+    assert_equal true, @definition.default_value
+  end
+
+  it "test_should_use_default_for_unknown_group" do
+    assert_equal true, @definition.default_value('email')
+  end
+
+  it "test_should_use_group_default_for_known_group" do
+    assert_equal false, @definition.default_value('chat')
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithStringifiedTypeTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :any)
+  end
+
+  it "test_should_symbolize_type" do
+    assert_equal :any, @definition.type
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithAnyTypeTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :any)
+  end
+
+  it "test_use_custom_type" do
+    assert_equal :any, @definition.type
+  end
+
+  it "test_should_not_be_number" do
+    assert !@definition.number?
+  end
+
+  it "test_should_not_type_cast" do
+    assert_equal nil, @definition.type_cast(nil)
+    assert_equal 0, @definition.type_cast(0)
+    assert_equal 1, @definition.type_cast(1)
+    assert_equal false, @definition.type_cast(false)
+    assert_equal true, @definition.type_cast(true)
+    assert_equal '', @definition.type_cast('')
+  end
+
+  it "test_should_query_false_if_value_is_nil" do
+    assert_equal false, @definition.query(nil)
+  end
+
+  it "test_should_query_true_if_value_is_zero" do
+    assert_equal true, @definition.query(0)
+  end
+
+  it "test_should_query_true_if_value_is_not_zero" do
+    assert_equal true, @definition.query(1)
+    assert_equal true, @definition.query(-1)
+  end
+
+  it "test_should_query_false_if_value_is_blank" do
+    assert_equal false, @definition.query('')
+  end
+
+  it "test_should_query_true_if_value_is_not_blank" do
+    assert_equal true, @definition.query('hello')
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithBooleanTypeTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications)
+  end
+
+  it "test_should_not_be_number" do
+    assert !@definition.number?
+  end
+
+  it "test_should_not_type_cast_if_value_is_nil" do
+    assert_equal nil, @definition.type_cast(nil)
+  end
+
+  it "test_should_type_cast_to_false_if_value_is_zero" do
+    assert_equal false, @definition.type_cast(0)
+  end
+
+  it "test_should_type_cast_to_true_if_value_is_not_zero" do
+    assert_equal true, @definition.type_cast(1)
+  end
+
+  it "test_should_type_cast_to_true_if_value_is_true_string" do
+    assert_equal true, @definition.type_cast('true')
+  end
+
+  it "test_should_type_cast_to_nil_if_value_is_not_true_string" do
+    assert_nil @definition.type_cast('')
+  end
+
+  it "test_should_query_false_if_value_is_nil" do
+    assert_equal false, @definition.query(nil)
+  end
+
+  it "test_should_query_true_if_value_is_one" do
+    assert_equal true, @definition.query(1)
+  end
+
+  it "test_should_query_false_if_value_not_one" do
+    assert_equal false, @definition.query(0)
+  end
+
+  it "test_should_query_true_if_value_is_true_string" do
+    assert_equal true, @definition.query('true')
+  end
+
+  it "test_should_query_false_if_value_is_not_true_string" do
+    assert_equal false, @definition.query('')
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "PreferenceDefinitionWithNumericTypeTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :integer)
+  end
+
+  it "test_should_be_number" do
+    assert @definition.number?
+  end
+
+  it "test_should_type_cast_true_to_integer" do
+    assert_equal 1, @definition.type_cast(true)
+  end
+
+  # it "test_should_type_cast_false_to_integer" do
+  #   assert_equal 0, @definition.type_cast(false)
+  # end
+
+  it "test_should_type_cast_string_to_integer" do
+    assert_equal 0, @definition.type_cast('hello')
+  end
+
+  it "test_should_query_false_if_value_is_nil" do
+    assert_equal false, @definition.query(nil)
+  end
+
+  it "test_should_query_true_if_value_is_one" do
+    assert_equal true, @definition.query(1)
+  end
+
+  it "test_should_query_false_if_value_is_zero" do
+    assert_equal false, @definition.query(0)
+  end
+end
+
+#------------------------------------------------------------------------------
+describe "> PreferenceDefinitionWithStringTypeTest" do
+  before do
+    @definition = Preferences::PreferenceDefinition.new(:notifications, :string)
+  end
+
+  it "test_should_not_be_number" do
+    assert !@definition.number?
+  end
+
+  it "test_should_type_cast_integers_to_strings" do
+    assert_equal '1', @definition.type_cast('1')
+  end
+
+  it "test_should_not_type_cast_booleans" do
+    assert_equal 't', @definition.type_cast(true)
+  end
+
+  it "test_should_query_false_if_value_is_nil" do
+    assert_equal false, @definition.query(nil)
+  end
+
+  it "test_should_query_true_if_value_is_one" do
+    assert_equal true, @definition.query(1)
+  end
+
+  it "test_should_query_true_if_value_is_zero" do
+    assert_equal true, @definition.query(0)
+  end
+
+  it "test_should_query_false_if_value_is_blank" do
+    assert_equal false, @definition.query('')
+  end
+
+  it "test_should_query_true_if_value_is_not_blank" do
+    assert_equal true, @definition.query('hello')
+  end
+end

data/{test/unit/preference_test.rb → spec/unit/preference_spec.rb}

@@ -1,259 +1,251 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require 'spec_helper'
 
-class PreferenceByDefaultTest < ActiveSupport::TestCase
-  def setup
+include Factory
+
+#------------------------------------------------------------------------------
+describe "PreferenceByDefaultTest" do
+  before do
     @preference = Preference.new
   end
-  
-  def test_should_not_have_a_name
+
+  it "test_should_not_have_a_name" do
     assert @preference.name.blank?
   end
-  
-  def test_should_not_have_an_owner
+
+  it "test_should_not_have_an_owner" do
     assert_nil @preference.owner_id
   end
-  
-  def test_should_not_have_an_owner_type
+
+  it "test_should_not_have_an_owner_type" do
     assert @preference.owner_type.blank?
   end
-  
-  def test_should_not_have_a_group_association
+
+  it "test_should_not_have_a_group_association" do
     assert_nil @preference.group_id
   end
-  
-  def test_should_not_have_a_group_type
+
+  it "test_should_not_have_a_group_type" do
     assert @preference.group_type.nil?
   end
-  
-  def test_should_not_have_a_value
+
+  it "test_should_not_have_a_value" do
     assert @preference.value.blank?
   end
-  
-  def test_should_not_have_a_definition
+
+  it "test_should_not_have_a_definition" do
     assert_nil @preference.definition
   end
 end
 
-class PreferenceTest < ActiveSupport::TestCase
-  def test_should_be_valid_with_a_set_of_valid_attributes
+#------------------------------------------------------------------------------
+describe "PreferenceTest" do
+  
+  it "test_should_be_valid_with_a_set_of_valid_attributes" do
     preference = new_preference
     assert preference.valid?
   end
-  
-  def test_should_require_a_name
+
+  it "test_should_require_a_name" do
     preference = new_preference(:name => nil)
     assert !preference.valid?
-    assert preference.errors.invalid?(:name)
+    assert preference.errors.include?(:name)
   end
-  
-  def test_should_require_an_owner_id
+
+  it "test_should_require_an_owner_id" do
     preference = new_preference(:owner => nil)
     assert !preference.valid?
-    assert preference.errors.invalid?(:owner_id)
+    assert preference.errors.include?(:owner_id)
   end
-  
-  def test_should_require_an_owner_type
+
+  it "test_should_require_an_owner_type" do
     preference = new_preference(:owner => nil)
     assert !preference.valid?
-    assert preference.errors.invalid?(:owner_type)
+    assert preference.errors.include?(:owner_type)
   end
-  
-  def test_should_not_require_a_group_id
+
+  it "test_should_not_require_a_group_id" do
     preference = new_preference(:group => nil)
     assert preference.valid?
   end
-  
-  def test_should_not_require_a_group_id_if_type_specified
+
+  it "test_should_not_require_a_group_id_if_type_specified" do
     preference = new_preference(:group => nil)
     preference.group_type = 'Car'
     assert preference.valid?
   end
-  
-  def test_should_not_require_a_group_type
+
+  it "test_should_not_require_a_group_type" do
     preference = new_preference(:group => nil)
     assert preference.valid?
   end
-  
-  def test_should_require_a_group_type_if_id_specified
+
+  it "test_should_require_a_group_type_if_id_specified" do
     preference = new_preference(:group => nil)
     preference.group_id = 1
     assert !preference.valid?
-    assert preference.errors.invalid?(:group_type)
-  end
-  
-  def test_should_protect_attributes_from_mass_assignment
-    preference = Preference.new(
-      :id => 1,
-      :name => 'notifications',
-      :value => '123',
-      :owner_id => 1,
-      :owner_type => 'User',
-      :group_id => 1,
-      :group_type => 'Car'
-    )
-    
-    assert_nil preference.id
-    assert_equal 'notifications', preference.name
-    assert_equal '123', preference.value
-    assert_equal 1, preference.owner_id
-    assert_equal 'User', preference.owner_type
-    assert_equal 1, preference.group_id
-    assert_equal 'Car', preference.group_type
+    assert preference.errors.include?(:group_type)
   end
 end
 
-class PreferenceAsAClassTest < ActiveSupport::TestCase
-  def test_should_be_able_to_split_nil_groups
+#------------------------------------------------------------------------------
+describe "PreferenceAsAClassTest" do
+  it "test_should_be_able_to_split_nil_groups" do
     group_id, group_type = Preference.split_group(nil)
     assert_nil group_id
     assert_nil group_type
   end
-  
-  def test_should_be_able_to_split_non_active_record_groups
+
+  it "test_should_be_able_to_split_non_active_record_groups" do
     group_id, group_type = Preference.split_group('car')
     assert_nil group_id
     assert_equal 'car', group_type
-    
+
     group_id, group_type = Preference.split_group(:car)
     assert_nil group_id
     assert_equal 'car', group_type
-    
+
     group_id, group_type = Preference.split_group(10)
     assert_nil group_id
     assert_equal 10, group_type
   end
-  
-  def test_should_be_able_to_split_active_record_groups
+
+  it "test_should_be_able_to_split_active_record_groups" do
     car = create_car
-    
+
     group_id, group_type = Preference.split_group(car)
     assert_equal 1, group_id
     assert_equal 'Car', group_type
   end
 end
 
-class PreferenceAfterBeingCreatedTest < ActiveSupport::TestCase
-  def setup
+#------------------------------------------------------------------------------
+describe "PreferenceAfterBeingCreatedTest" do
+  before do
     User.preference :notifications, :boolean
-    
+
     @preference = create_preference(:name => 'notifications')
   end
-  
-  def test_should_have_an_owner
-    assert_not_nil @preference.owner
+
+  it "test_should_have_an_owner" do
+    expect(@preference.owner.nil?).to eq false
   end
-  
-  def test_should_have_a_definition
-    assert_not_nil @preference.definition
+
+  it "test_should_have_a_definition" do
+    expect(@preference.definition.nil?).to eq false
   end
-  
-  def test_should_have_a_value
-    assert_not_nil @preference.value
+
+  it "test_should_have_a_value" do
+    expect(@preference.value.nil?).to eq false
   end
-  
-  def test_should_not_have_a_group_association
+
+  it "test_should_not_have_a_group_association" do
     assert_nil @preference.group
   end
-  
-  def teardown
+
+  after do
     User.preference_definitions.delete('notifications')
   end
 end
 
-class PreferenceWithBasicGroupTest < ActiveSupport::TestCase
-  def setup
+#------------------------------------------------------------------------------
+describe "PreferenceWithBasicGroupTest" do
+  before do
     @preference = create_preference(:group_type => 'car')
   end
-  
-  def test_should_have_a_group_association
+
+  it "test_should_have_a_group_association" do
     assert_equal 'car', @preference.group
   end
 end
 
-class PreferenceWithActiveRecordGroupTest < ActiveSupport::TestCase
-  def setup
+#------------------------------------------------------------------------------
+describe "PreferenceWithActiveRecordGroupTest" do
+  before do
     @car = create_car
     @preference = create_preference(:group => @car)
   end
-  
-  def test_should_have_a_group_association
+
+  it "test_should_have_a_group_association" do
     assert_equal @car, @preference.group
   end
 end
 
-class PreferenceWithBooleanTypeTest < ActiveSupport::TestCase
-  def setup
+#------------------------------------------------------------------------------
+describe "PreferenceWithBooleanTypeTest" do
+  before do
     User.preference :notifications, :boolean
   end
-  
-  def test_should_type_cast_nil_values
+
+  it "test_should_type_cast_nil_values" do
     preference = new_preference(:name => 'notifications', :value => nil)
     assert_nil preference.value
   end
-  
-  def test_should_type_cast_numeric_values
+
+  it "test_should_type_cast_numeric_values" do
     preference = new_preference(:name => 'notifications', :value => 0)
     assert_equal false, preference.value
-    
+
     preference.value = 1
     assert_equal true, preference.value
   end
-  
-  def test_should_type_cast_boolean_values
+
+  it "test_should_type_cast_boolean_values" do
     preference = new_preference(:name => 'notifications', :value => false)
     assert_equal false, preference.value
-    
+
     preference.value = true
     assert_equal true, preference.value
   end
-  
-  def teardown
+
+  after do
     User.preference_definitions.delete('notifications')
   end
 end
 
-class PreferenceWithFloatTypeTest < ActiveSupport::TestCase
-  def setup
+#------------------------------------------------------------------------------
+describe "PreferenceWithFloatTypeTest" do
+  before do
     User.preference :rate, :float, :default => 10.0
   end
-  
-  def test_should_type_cast_nil_values
+
+  it "test_should_type_cast_nil_values" do
     preference = new_preference(:name => 'rate', :value => nil)
     assert_nil preference.value
   end
-  
-  def test_should_type_cast_numeric_values
+
+  it "test_should_type_cast_numeric_values" do
     preference = new_preference(:name => 'rate', :value => 1.0)
     assert_equal 1.0, preference.value
-    
+
     preference.value = "1.1"
     assert_equal 1.1, preference.value
   end
 
-  def teardown
+  after do
     User.preference_definitions.delete('rate')
   end
 end
- 
-class PreferenceWithSTIOwnerTest < ActiveSupport::TestCase
-  def setup
+
+#------------------------------------------------------------------------------
+describe "PreferenceWithSTIOwnerTest" do
+  before do
     @manager = create_manager
     @preference = create_preference(:owner => @manager, :name => 'health_insurance', :value => true)
   end
-  
-  def test_should_have_an_owner
+
+  it "test_should_have_an_owner" do
     assert_equal @manager, @preference.owner
   end
-  
-  def test_should_have_an_owner_type
+
+  it "test_should_have_an_owner_type" do
     assert_equal 'Employee', @preference.owner_type
   end
-  
-  def test_should_have_a_definition
-    assert_not_nil @preference.definition
+
+  it "test_should_have_a_definition" do
+    expect(@preference.definition.nil?).to eq false
   end
-  
-  def test_should_have_a_value
+
+  it "test_should_have_a_value" do
     assert_equal true, @preference.value
   end
 end