dm_preferences 1.0 → 1.5

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NGU0NzUwOWQ4MGQ2ZGZmZWM4OWNmNjAwNmNmZjU1MmEyMmVkYzkxZA==
-  data.tar.gz: !binary |-
-    MzE1ZGI3ZDU1MWE4MDI5MmI5ZmY1YTFlM2I2MDkxZTQzYmVlNTdjOQ==
+SHA1:
+  metadata.gz: 49d213a6e7ac0f8c5ba3a6f8e6e4632d6464e6be
+  data.tar.gz: 59c090fd0fbbbcec663186af3b6f247bdcd659f9
 SHA512:
-  metadata.gz: !binary |-
-    ZmFlY2JjODc2NDViNGVkMmY0MmNiNzQwMGRhNDkyZmY3NGFhZjllZjU5OTk1
-    YmRlNTMzZTQ5YzJkNTZiZDVkNzNkMWY5ZGJkZDY1ODBkNjM2MTdmZGNkNjcw
-    NTE1NjEzOWJiYjM5Yjk3MmM4ZmIzOTM0MjJiZWNhNGE0NGIyYzQ=
-  data.tar.gz: !binary |-
-    MmVlNjc1MTk5NDE0Mzg0MDZiZDJjYmRjMTM1ZjNmMjU5MTY0NzA2MzliMjc4
-    OWJkNTk1OTQ4Y2VkMzkzODc3YjY1MzM1ZTIxMzJiN2YxMjIwNWU1ZDRlYzBk
-    ZDc3YjZhYTBjMWJlN2NiNGQ4OWFiMjM4ODE2ZDY3NjdkYTA4ZmM=
+  metadata.gz: dc16349648397c51ce37ecfae41f4f58cd9fbf24b387e90f38b253b0810b754f31c20e62670ebc8aa51358b307c6a68fceca0c05fafc056ec31e81da135b84ab
+  data.tar.gz: 34d8971768549155dc184c509f21eb24d06c8f013ece976a37f2a8ba1b7386b762420d73aaa7aa8ebaa394166711ce0afc2d1a941bfcd79e5a7e669d0614f72c

data/.gitignore

@@ -7,3 +7,5 @@ test/app_root/script
 Gemfile.lock
 spec/dummy/db/test.sqlite3
 spec/dummy/log
+.DS_Store
+.byebug_history

data/.travis.yml

@@ -1,3 +1,7 @@
+env:
+  - "RAILS_VERSION=4.2.0"
+  - "RAILS_VERSION=5.0.0"
+
 rvm:
-  - 1.9.3
-  - 2.1
+  - 2.2.2
+  - 2.3.1

data/Gemfile

@@ -1,3 +1,25 @@
 source "http://www.rubygems.org"
  
+rails_version = ENV["RAILS_VERSION"] || "default"
+
+rails = case rails_version
+when "master"
+  {github: "rails/rails"}
+when "default"
+  ">= 3.2.0"
+else
+  "~> #{rails_version}"
+end
+
+gem "rails", rails
+
 gemspec
+
+group :development, :test do
+  gem 'sqlite3'
+  gem 'byebug'
+
+  gem 'mocha', '~> 1.1.0', :require => false
+  gem 'rspec-rails', '~> 3.5.0'
+  gem 'factory_girl_rails', '~> 4.4.1'
+end

data/README.md

@@ -5,7 +5,7 @@
 
 **Preferences** adds support for easily creating custom preferences for models.
 
-This gem is a fork of the original [preferences gem by Aaron Pfeifer](https://github.com/pluginaweek/preferences).  It supports Rails 4.2, and all tests are working.  The gem has been renamed to [dm_preferences](https://rubygems.org/gems/dm_preferences) so as not to conflict with the original.
+This gem is a fork of the original [preferences gem by Aaron Pfeifer](https://github.com/pluginaweek/preferences).  It supports Rails 5 and 4.2, and all tests are working.  The gem has been renamed to [dm_preferences](https://rubygems.org/gems/dm_preferences) so as not to conflict with the original.
 
 ## Description
 
@@ -32,7 +32,7 @@ a separate table and making it dead-simple to define and manage preferences.
 
 Add the following to your gem file:
 
-    gem 'dm_preferences', '~> 1.0'
+    gem 'dm_preferences', '~> 1.5'
 
 _preferences_ requires an additional database table to work.  You can generate
 a migration for this table like so:
@@ -268,5 +268,6 @@ Mailing List
 
 ## Dependencies
 
+* 1.5.x for Rails 5
 * 1.0.x for Rails 4.2
 * 0.5.6 for Rails 4.1

data/app/models/preference.rb

@@ -52,10 +52,11 @@ class Preference < ActiveRecord::Base
   end
   
   # Only searches for the group record if the group id is specified
-  def group_with_optional_lookup
-    group_id ? group_without_optional_lookup : group_type
+  alias_method :original_group, :group
+  def group
+    group_id ? original_group : group_type
   end
-  alias_method_chain :group, :optional_lookup
+  
   
   private
     # Finds the definition for this preference in the given owner class.

data/dm_preferences.gemspec

@@ -17,7 +17,5 @@ Gem::Specification.new do |s|
   s.rdoc_options      = %w(--line-numbers --inline-source --title preferences --main README.rdoc)
   s.extra_rdoc_files  = %w(README.md CHANGELOG.md LICENSE)
   
-  s.add_development_dependency "rails", "~> 4.2"
-  s.add_development_dependency "sqlite3", '~> 0'
-  s.add_development_dependency 'rspec-rails', '~> 3.0'
+  s.add_dependency "rails", ">= 4.2"
  end

data/lib/preferences.rb

@@ -230,7 +230,7 @@ module Preferences
     # Generates the scope for looking under records with a specific set of
     # preferences associated with them.
     #
-    # Note thate this is a bit more complicated than usual since the preference
+    # Note that this is a bit more complicated than usual since the preference
     # definitions aren't in the database for joins, defaults need to be accounted
     # for, and querying for the the presence of multiple preferences requires
     # multiple joins.
@@ -260,7 +260,7 @@ module Preferences
 
         # Since each preference is a different record, they need their own
         # join so that the proper conditions can be set
-        joins << "LEFT JOIN preferences AS #{table} ON #{table}.owner_id = #{table_name}.#{primary_key} AND " + 
+        joins << "LEFT JOIN preferences AS #{table} ON #{table}.owner_id = #{table_name}.#{primary_key} AND " +
           sanitize_sql_hash_for_conditions(
             "#{table}.owner_type" => base_class.name.to_s,
             "#{table}.group_id" => group_id,
@@ -280,17 +280,15 @@ module Preferences
       joins(joins).where(values.unshift(sql))
     end
 
-    # this function is deprecated in 4.2 and to be removed in 5.0.
-    # but it's useful, particularly how it can handle conditions that are nil.
-    # so keep it for now.
-    def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
-      attrs = ActiveRecord::PredicateBuilder.resolve_column_aliases self, attrs
-      attrs = expand_hash_conditions_for_aggregates(attrs)
-
-      table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
-      ActiveRecord::PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-        connection.visitor.compile b
-      }.join(' AND ')
+    # The Rails version of this function was removed in 5.0. So use this instead.
+    # It properly handles the 'IS NULL' case
+    def sanitize_sql_hash_for_conditions(attrs)
+      return '' unless attrs.is_a? Hash
+      conditions = []
+      attrs.each do |key, value|
+        conditions << (value ? sanitize_sql_for_conditions(["#{key} = ?", value]) : "#{key} IS NULL")
+      end
+      conditions.join(' AND ')
     end
 
   end

data/lib/preferences/preference_definition.rb

@@ -3,13 +3,13 @@ module Preferences
   class PreferenceDefinition
     # The data type for the content stored in this preference type
     attr_reader :type
-    
+
     def initialize(name, *args) #:nodoc:
       options = args.extract_options!
       options.assert_valid_keys(:default, :group_defaults)
       
       @type = args.first ? args.first.to_sym : :boolean
-      
+
       case @type
       when :any
         @klass = "ActiveRecord::Type::Value".constantize.new
@@ -27,32 +27,38 @@ module Preferences
         defaults
       end
     end
-    
+
     # The name of the preference
     def name
       @column.name
     end
-    
+
     # The default value to use for the preference in case none have been
     # previously defined
     def default_value(group = nil)
       @group_defaults.include?(group) ? @group_defaults[group] : type_cast(@column.default)
     end
-    
+
     # Determines whether column backing this preference stores numberic values
     def number?
-      @column.number?
+      @column.type == :integer || @column.type == :float
     end
-    
+
     # Typecasts the value based on the type of preference that was defined.
     # This uses ActiveRecord's typecast functionality so the same rules for
     # typecasting a model's columns apply here.
     def type_cast(value)
-      return 1 if @type == :integer && value == true
-      return 0 if @type == :integer && value == false
-      @type == :any ? value : @column.type_cast_from_database(value)
+      return 1      if @type == :integer && value == true
+      return 0      if @type == :integer && value == false
+      return true   if @type == :boolean && (value == 't' || value == true)
+      return false  if @type == :boolean && (value == 'f' || value == false)
+      if @type == :any
+        value
+      else
+        @klass.respond_to?(:deserialize) ? @klass.deserialize(value) : @column.type_cast_from_database(value)
+      end
     end
-    
+
     # Typecasts the value to true/false depending on the type of preference
     def query(value)
       if !(value = type_cast(value))

data/lib/preferences/version.rb

@@ -1,3 +1,3 @@
 module Preferences
-  VERSION = '1.0'
+  VERSION = '1.5'
 end

data/spec/dummy/app/models/user.rb

@@ -1,8 +1,8 @@
 class User < ActiveRecord::Base
-#  preference :hot_salsa
-#  preference :dark_chocolate, :default => true
-#  preference :color, :string
-#  preference :car, :integer
-#  preference :language, :string, :default => 'English'
-#  preference :data, :any
+ preference :hot_salsa
+ preference :dark_chocolate, :default => true
+ preference :color, :string
+ preference :car, :integer
+ preference :language, :string, :default => 'English'
+ preference :data, :any
 end

data/spec/dummy/config/application.rb

@@ -24,9 +24,6 @@ module Dummy
     # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
     # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
     # config.i18n.default_locale = :de
-
-    # Do not swallow errors in after_commit/after_rollback callbacks.
-    config.active_record.raise_in_transactional_callbacks = true
   end
 end
 

data/spec/dummy/config/environments/test.rb

@@ -13,8 +13,8 @@ Rails.application.configure do
   config.eager_load = false
 
   # Configure static file server for tests with Cache-Control for performance.
-  config.serve_static_files   = true
-  config.static_cache_control = 'public, max-age=3600'
+  # config.public_file_server.enabled = true
+  # config.public_file_server.headers = { 'Cache-Control' => 'public, max-age=3600' }
 
   # Show full error reports and disable caching.
   config.consider_all_requests_local       = true

data/spec/dummy/db/schema.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
@@ -31,10 +30,9 @@ ActiveRecord::Schema.define(version: 4) do
     t.string   "value"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.index ["owner_id", "owner_type", "name", "group_id", "group_type"], name: "index_preferences_on_owner_and_name_and_preference", unique: true
   end
 
-  add_index "preferences", ["owner_id", "owner_type", "name", "group_id", "group_type"], name: "index_preferences_on_owner_and_name_and_preference", unique: true
-
   create_table "users", force: :cascade do |t|
     t.string "login", null: false
   end

data/spec/factories/car_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :car do
+    name 'Porsche'
+  end
+end

data/spec/factories/employee_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :employee do
+    name 'John Smith'
+
+    trait :manager do
+    end
+  end
+
+  factory :manager, parent: :employee, class: 'Manager' do
+  end
+end

data/spec/factories/preference_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :preference do
+    name          'notifications'
+    value         false
+    association   :owner, factory: :user
+  end
+end

data/spec/factories/users_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :user do
+    login 'admin'
+  end
+end

data/spec/functional/preferences_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
 describe "ModelPreferenceTest" do
-  after do
+  after :each do
     User.preference_definitions.clear
   end
 
   #------------------------------------------------------------------------------
   describe "ModelWithoutPreferencesTest" do
     it "test_should_not_create_preference_definitions" do
-      assert !Car.respond_to?(:preference_definitions)
+      expect(!Car.respond_to?(:preference_definitions)).to eq true
     end
 
     it "test_should_not_create_stored_preferences_association" do
-      assert !Car.new.respond_to?(:stored_preferences)
+      expect(!Car.new.respond_to?(:stored_preferences)).to eq true
     end
 
     it "test_should_not_create_preference_scopes" do
-      assert !Car.respond_to?(:with_preferences)
-      assert !Car.respond_to?(:without_preferences)
+      expect(!Car.respond_to?(:with_preferences)).to eq true
+      expect(!Car.respond_to?(:without_preferences)).to eq true
     end
   end
 
@@ -25,20 +25,20 @@ describe "ModelPreferenceTest" do
   describe "PreferencesAfterFirstBeingDefinedTest" do
     before do
       User.preference :notifications
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_create_preference_definitions" do
-      assert User.respond_to?(:preference_definitions)
+      expect(User.respond_to?(:preference_definitions)).to eq true
     end
 
     it "test_should_create_preference_scopes" do
-      assert User.respond_to?(:with_preferences)
-      assert User.respond_to?(:without_preferences)
+      expect(User.respond_to?(:with_preferences)).to eq true
+      expect(User.respond_to?(:without_preferences)).to eq true
     end
 
     it "test_should_create_stored_preferences_associations" do
-      assert @user.respond_to?(:stored_preferences)
+      expect(@user.respond_to?(:stored_preferences)).to eq true
     end
   end
 
@@ -46,7 +46,7 @@ describe "ModelPreferenceTest" do
   describe "PreferencesAfterBeingDefinedTest" do
     before do
       @definition = User.preference :notifications
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_raise_exception_if_invalid_options_specified" do
@@ -60,75 +60,75 @@ describe "ModelPreferenceTest" do
 
     it "test_should_create_definition" do
       expect(@definition.nil?).to eq false
-      assert_equal 'notifications', @definition.name
+      expect(@definition.name).to eq 'notifications'
     end
 
     it "test_should_create_preferred_query_method" do
-      assert @user.respond_to?(:preferred_notifications?)
+      expect(@user.respond_to?(:preferred_notifications?)).to eq true
     end
 
     it "test_should_create_prefers_query_method" do
-      assert @user.respond_to?(:prefers_notifications?)
+      expect(@user.respond_to?(:prefers_notifications?)).to eq true
     end
 
     it "test_should_create_preferred_reader" do
-      assert @user.respond_to?(:preferred_notifications)
+      expect(@user.respond_to?(:preferred_notifications)).to eq true
     end
 
     it "test_should_create_prefers_reader" do
-      assert @user.respond_to?(:prefers_notifications)
+      expect(@user.respond_to?(:prefers_notifications)).to eq true
     end
 
     it "test_should_create_preferred_writer" do
-      assert @user.respond_to?(:preferred_notifications=)
+      expect(@user.respond_to?(:preferred_notifications=)).to eq true
     end
 
     it "test_should_create_prefers_writer" do
-      assert @user.respond_to?(:prefers_notifications=)
+      expect(@user.respond_to?(:prefers_notifications=)).to eq true
     end
 
     it "test_should_create_preferred_changed_query" do
-      assert @user.respond_to?(:preferred_notifications_changed?)
+      expect(@user.respond_to?(:preferred_notifications_changed?)).to eq true
     end
 
     it "test_should_create_prefers_changed_query" do
-      assert @user.respond_to?(:prefers_notifications_changed?)
+      expect(@user.respond_to?(:prefers_notifications_changed?)).to eq true
     end
 
     it "test_should_create_preferred_was" do
-      assert @user.respond_to?(:preferred_notifications_was)
+      expect(@user.respond_to?(:preferred_notifications_was)).to eq true
     end
 
     it "test_should_create_prefers_was" do
-      assert @user.respond_to?(:prefers_notifications_was)
+      expect(@user.respond_to?(:prefers_notifications_was)).to eq true
     end
 
     it "test_should_create_preferred_change" do
-      assert @user.respond_to?(:preferred_notifications_change)
+      expect(@user.respond_to?(:preferred_notifications_change)).to eq true
     end
 
     it "test_should_create_prefers_change" do
-      assert @user.respond_to?(:prefers_notifications_change)
+      expect(@user.respond_to?(:prefers_notifications_change)).to eq true
     end
 
     it "test_should_create_preferred_will_change" do
-      assert @user.respond_to?(:preferred_notifications_will_change!)
+      expect(@user.respond_to?(:preferred_notifications_will_change!)).to eq true
     end
 
     it "test_should_create_prefers_will_change" do
-      assert @user.respond_to?(:prefers_notifications_will_change!)
+      expect(@user.respond_to?(:prefers_notifications_will_change!)).to eq true
     end
 
     it "test_should_create_preferred_reset" do
-      assert @user.respond_to?(:reset_preferred_notifications!)
+      expect(@user.respond_to?(:reset_preferred_notifications!)).to eq true
     end
 
     it "test_should_create_prefers_reset" do
-      assert @user.respond_to?(:reset_prefers_notifications!)
+      expect(@user.respond_to?(:reset_prefers_notifications!)).to eq true
     end
 
     it "test_should_include_new_definitions_in_preference_definitions" do
-      assert_equal User.preference_definitions['notifications'], @definition
+      expect(@definition).to eq User.preference_definitions['notifications']
     end
   end
 
@@ -136,67 +136,64 @@ describe "ModelPreferenceTest" do
   describe "PreferencesTypeCasted" do
     before do
       @definition = User.preference :rate, :float, :default => 1.0
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_have_float_type" do
-      assert_equal :float, @definition.type
+      expect(@definition.type).to eq :float
     end
 
     it "test_should_only_have_default_preferences" do
-      assert_equal e = {'rate' => 1.0}, @user.preferences
+      expect(@user.preferences).to eq ({'rate' => 1.0})
     end
 
     it "test_should_type_cast_changed_values" do
       @user.write_preference(:rate, "1.1")
-      assert_equal e = {'rate' => 1.1}, @user.preferences
+      expect(@user.preferences).to eq ({'rate' => 1.1})
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesByDefaultTest" do
     before do
-      include Factory
-
       @definition = User.preference :notifications
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_have_boolean_type" do
-      assert_equal :boolean, @definition.type
+      expect(@definition.type).to eq :boolean
     end
 
     it "test_should_not_have_default_value" do
-      assert_nil @definition.default_value
+      expect(@definition.default_value).to eq nil
     end
 
     it "test_should_only_have_default_preferences" do
-      # assert_equal e = {'notifications' => nil}, @user.preferences
-      assert_equal e = {'notifications' => nil}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => nil})
     end
 
     it "test_should_not_query_preferences_changed" do
-      assert_equal false, @user.preferences_changed?
+      expect(@user.preferences_changed?).to eq false
     end
 
     it "test_should_not_query_group_preferences_changed" do
-      assert_equal false, @user.preferences_changed?(:chat)
+      expect(@user.preferences_changed?(:chat)).to eq false
     end
 
     it "test_should_not_have_preferences_changed" do
-      assert_equal [], @user.preferences_changed
+      expect(@user.preferences_changed).to eq []
     end
 
     it "test_should_not_have_group_preferences_changed" do
-      assert_equal [], @user.preferences_changed(:chat)
+      expect(@user.preferences_changed(:chat)).to eq []
     end
 
     it "test_should_not_have_preference_changes" do
-      assert_equal e = {}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({})
     end
 
     it "test_should_not_have_group_preference_changes" do
-      assert_equal e = {}, @user.preference_changes(:chat)
+      expect(@user.preference_changes(:chat)).to eq ({})
     end
   end
 
@@ -204,19 +201,19 @@ describe "ModelPreferenceTest" do
   describe "PreferencesWithCustomTypeTest" do
     before do
       @definition = User.preference :vehicle_id, :integer
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_have_integer_type" do
-      assert_equal :integer, @definition.type
+      expect(@definition.type).to eq :integer
     end
 
     it "test_should_not_have_default_value" do
-      assert_nil @definition.default_value
+      expect(@definition.default_value).to eq nil
     end
 
     it "test_should_only_have_default_preferences" do
-      assert_equal e = {'vehicle_id' => nil}, @user.preferences
+      expect(@user.preferences).to eq ({'vehicle_id' => nil})
     end
   end
 
@@ -224,44 +221,45 @@ describe "ModelPreferenceTest" do
   describe "PreferencesWithCustomDefaultTest" do
     before do
       @definition = User.preference :color, :string, :default => 'red'
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_have_boolean_type" do
-      assert_equal :string, @definition.type
+      expect(@definition.type).to eq :string
     end
 
     it "test_should_have_default_value" do
-      assert_equal 'red', @definition.default_value
+      expect(@definition.default_value).to eq 'red'
     end
 
     it "test_should_only_have_default_preferences" do
-      assert_equal e = {'color' => 'red'}, @user.preferences
+      expect(@user.preferences).to eq ({'color' => 'red'})
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesWithMultipleDefinitionsTest" do
     before do
+      User.preference_definitions.clear
       User.preference :notifications, :default => true
       User.preference :color, :string, :default => 'red'
-      @user = new_user
+      @user = build(:user)
     end
 
     it "test_should_only_have_default_preferences" do
-      assert_equal e = {'notifications' => true, 'color' => 'red'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true, 'color' => 'red'})
     end
   end
 
-#------------------------------------------------------------------------------
+  #------------------------------------------------------------------------------
   describe "PreferencesAfterBeingCreatedTest" do
     before do
       User.preference :notifications, :default => true
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_not_have_any_stored_preferences" do
-      assert @user.stored_preferences.empty?
+      expect(@user.stored_preferences.empty?).to eq true
     end
   end
 
@@ -270,7 +268,7 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :default => true
       User.preference :rate, :float, :default => 1.0
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_raise_exception_if_invalid_preference_read" do
@@ -280,28 +278,28 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_use_default_value_if_not_stored" do
-      assert_equal true, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq true
     end
 
     it "test_should_use_group_default_value_if_not_stored" do
       User.preference :language, :string, :default => 'English', :group_defaults => {:chat => 'Latin'}
-      assert_equal 'English', @user.preferred(:language)
+      expect(@user.preferred(:language)).to eq 'English'
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
-      assert_equal false, @user.preferred(:notifications)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
+      expect(@user.preferred(:notifications)).to eq false
     end
 
     it "test_should_type_cast_based_on_preference_definition" do
       @user.write_preference(:notifications, 'false')
-      assert_equal false, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq false
       @user.write_preference(:rate, "1.2")
-      assert_equal 1.2, @user.preferred(:rate)
+      expect(@user.preferred(:rate)).to eq 1.2
     end
 
     it "test_should_cache_stored_values" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
       assert_queries(1) { @user.preferred(:notifications) }
       assert_queries(0) { @user.preferred(:notifications) }
     end
@@ -312,18 +310,18 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_use_value_from_preferences_lookup" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
       @user.preferences
 
       assert_queries(0) { assert_equal false, @user.preferred(:notifications) }
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal true, @user.prefers_notifications
+      expect(@user.prefers_notifications).to eq true
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal true, @user.preferred_notifications
+      expect(@user.preferred_notifications).to eq true
     end
   end
 
@@ -331,25 +329,25 @@ describe "ModelPreferenceTest" do
   describe "PreferencesGroupReaderTest" do
     before do
       User.preference :notifications, :default => true
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_use_default_value_if_not_stored" do
-      assert_equal true, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq true
     end
 
     it "test_should_use_group_default_value_if_not_stored" do
       User.preference :language, :string, :default => 'English', :group_defaults => {:chat => 'Latin'}
-      assert_equal 'Latin', @user.preferred(:language, :chat)
+      expect(@user.preferred(:language, :chat)).to eq 'Latin'
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
-      assert_equal false, @user.preferred(:notifications, :chat)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      expect(@user.preferred(:notifications, :chat)).to eq false
     end
 
     it "test_should_cache_stored_values" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
       assert_queries(1) { @user.preferred(:notifications, :chat) }
       assert_queries(0) { @user.preferred(:notifications, :chat) }
     end
@@ -360,52 +358,52 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_use_value_from_preferences_lookup" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
       @user.preferences(:chat)
 
       assert_queries(0) { assert_equal false, @user.preferred(:notifications, :chat) }
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal true, @user.prefers_notifications(:chat)
+      expect(@user.prefers_notifications(:chat)).to eq true
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal true, @user.preferred_notifications(:chat)
+      expect(@user.preferred_notifications(:chat)).to eq true
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesARGroupReaderTest" do
     before do
-      @car = create_car
+      @car = create(:car)
 
       User.preference :notifications, :default => true
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_use_default_value_if_not_stored" do
-      assert_equal true, @user.preferred(:notifications, @car)
+      expect(@user.preferred(:notifications, @car)).to eq true
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
-      assert_equal false, @user.preferred(:notifications, @car)
+      create(:preference, :owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
+      expect(@user.preferred(:notifications, @car)).to eq false
     end
 
     it "test_should_use_value_from_preferences_lookup" do
-      create_preference(:owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
       @user.preferences(@car)
 
       assert_queries(0) { assert_equal false, @user.preferred(:notifications, @car) }
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal true, @user.prefers_notifications(@car)
+      expect(@user.prefers_notifications(@car)).to eq true
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal true, @user.preferred_notifications(@car)
+      expect(@user.preferred_notifications(@car)).to eq true
     end
   end
 
@@ -413,7 +411,7 @@ describe "ModelPreferenceTest" do
   describe "PreferencesQueryTest" do
     before do
       User.preference :language, :string
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_raise_exception_if_invalid_preference_queried" do
@@ -424,30 +422,30 @@ describe "ModelPreferenceTest" do
 
     it "test_should_be_true_if_present" do
       @user.preferred_language = 'English'
-      assert_equal true, @user.preferred?(:language)
+      expect(@user.preferred?(:language)).to eq true
     end
 
     it "test_should_be_false_if_not_present" do
-      assert_equal false, @user.preferred?(:language)
+      expect(@user.preferred?(:language)).to eq false
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :name => 'language', :value => 'English')
-      assert_equal true, @user.preferred?(:language)
+      create(:preference, :owner => @user, :name => 'language', :value => 'English')
+      expect(@user.preferred?(:language)).to eq true
     end
 
     it "test_should_cache_stored_values" do
-      create_preference(:owner => @user, :name => 'language', :value => 'English')
+      create(:preference, :owner => @user, :name => 'language', :value => 'English')
       assert_queries(1) { @user.preferred?(:language) }
       assert_queries(0) { @user.preferred?(:language) }
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal false, @user.prefers_language?
+      expect(@user.prefers_language?).to eq false
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal false, @user.preferred_language?
+      expect(@user.preferred_language?).to eq false
     end
   end
 
@@ -455,67 +453,67 @@ describe "ModelPreferenceTest" do
   describe "PreferencesGroupQueryTest" do
     before do
       User.preference :language, :string
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_be_true_if_present" do
       @user.preferred_language = 'English', :chat
-      assert_equal true, @user.preferred?(:language, :chat)
+      expect(@user.preferred?(:language, :chat)).to eq true
     end
 
     it "test_should_be_false_if_not_present" do
-      assert_equal false, @user.preferred?(:language, :chat)
+      expect(@user.preferred?(:language, :chat)).to eq false
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'language', :value => 'English')
-      assert_equal true, @user.preferred?(:language, :chat)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'language', :value => 'English')
+      expect(@user.preferred?(:language, :chat)).to eq true
     end
 
     it "test_should_cache_stored_values" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'language', :value => 'English')
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'language', :value => 'English')
       assert_queries(1) { @user.preferred?(:language, :chat) }
       assert_queries(0) { @user.preferred?(:language, :chat) }
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal false, @user.prefers_language?(:chat)
+      expect(@user.prefers_language?(:chat)).to eq false
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal false, @user.preferred_language?(:chat)
+      expect(@user.preferred_language?(:chat)).to eq false
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesARGroupQueryTest" do
     before do
-      @car = create_car
+      @car = create(:car)
 
       User.preference :language, :string
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_be_true_if_present" do
       @user.preferred_language = 'English', @car
-      assert_equal true, @user.preferred?(:language, @car)
+      expect(@user.preferred?(:language, @car)).to eq true
     end
 
     it "test_should_be_false_if_not_present" do
-      assert_equal false, @user.preferred?(:language, @car)
+      expect(@user.preferred?(:language, @car)).to eq false
     end
 
     it "test_should_use_stored_value_if_stored" do
-      create_preference(:owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'language', :value => 'English')
-      assert_equal true, @user.preferred?(:language, @car)
+      create(:preference, :owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'language', :value => 'English')
+      expect(@user.preferred?(:language, @car)).to eq true
     end
 
     it "test_should_be_able_to_use_prefers_reader" do
-      assert_equal false, @user.prefers_language?(@car)
+      expect(@user.prefers_language?(@car)).to eq false
     end
 
     it "test_should_be_able_to_use_preferred_reader" do
-      assert_equal false, @user.preferred_language?(@car)
+      expect(@user.preferred_language?(@car)).to eq false
     end
   end
 
@@ -524,7 +522,7 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
-      @user = create_user(:login => 'admin')
+      @user = create(:user, :login => 'admin')
     end
 
     it "test_should_raise_exception_if_invalid_preference_written" do
@@ -535,31 +533,31 @@ describe "ModelPreferenceTest" do
 
     it "test_should_have_same_value_if_not_changed" do
       @user.write_preference(:notifications, true)
-      assert_equal true, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq true
     end
 
     it "test_should_use_new_value_if_changed" do
       @user.write_preference(:notifications, false)
-      assert_equal false, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq false
     end
 
     it "test_should_not_save_record_after_changing_preference" do
       @user.login = 'test'
       @user.write_preference(:notifications, false)
 
-      assert_equal 'admin', User.find(@user.id).login
+      expect(User.find(@user.id).login).to eq 'admin'
     end
 
     it "test_should_not_create_stored_preferences_immediately" do
       @user.write_preference(:notifications, false)
-      assert @user.stored_preferences.empty?
+      expect(@user.stored_preferences.empty?).to eq true
     end
 
     it "test_should_not_create_stored_preference_if_value_not_changed" do
       @user.write_preference(:notifications, true)
       @user.save!
 
-      assert_equal 0, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 0
     end
 
     it "test_should_not_create_stored_integer_preference_if_typecast_not_changed" do
@@ -568,7 +566,7 @@ describe "ModelPreferenceTest" do
       @user.write_preference(:age, '')
       @user.save!
 
-      assert_equal 0, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 0
     end
 
     it "test_should_create_stored_integer_preference_if_typecast_changed" do
@@ -577,49 +575,49 @@ describe "ModelPreferenceTest" do
       @user.write_preference(:age, '')
       @user.save!
 
-      assert_nil @user.preferred(:age)
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.preferred(:age)).to eq nil
+      expect(@user.stored_preferences.count).to eq 1
     end
 
     it "test_should_create_stored_preference_if_value_changed" do
       @user.write_preference(:notifications, false)
       @user.save!
 
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 1
     end
 
     it "test_should_overwrite_existing_stored_preference_if_value_changed" do
-      preference = create_preference(:owner => @user, :name => 'notifications', :value => true)
+      preference = create(:preference, :owner => @user, :name => 'notifications', :value => true)
 
       @user.write_preference(:notifications, false)
       @user.save!
 
       preference.reload
-      assert_equal false, preference.value
+      expect(preference.value).to eq false
     end
 
     it "test_should_not_remove_preference_if_set_to_default" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
 
       @user.write_preference(:notifications, true)
       @user.save!
       @user.reload
 
-      assert_equal 1, @user.stored_preferences.size
+      expect(@user.stored_preferences.size).to eq 1
       preference = @user.stored_preferences.first
-      assert_equal true, preference.value
+      expect(preference.value).to eq true
     end
 
     it "test_should_not_remove_preference_if_set_to_nil" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
 
       @user.write_preference(:notifications, nil)
       @user.save!
       @user.reload
 
-      assert_equal 1, @user.stored_preferences.size
+      expect(@user.stored_preferences.size).to eq 1
       preference = @user.stored_preferences.first
-      assert_nil preference.value
+      expect(preference.value).to eq nil
     end
 
     it "test_should_not_query_for_old_value_if_preferences_loaded" do
@@ -634,31 +632,31 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
-      @user = create_user(:login => 'admin')
+      @user = create(:user, :login => 'admin')
     end
 
     it "test_should_have_same_value_if_not_changed" do
       @user.write_preference(:notifications, true, :chat)
-      assert_equal true, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq true
     end
 
     it "test_should_use_new_value_if_changed" do
       @user.write_preference(:notifications, false, :chat)
-      assert_equal false, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq false
     end
 
     it "test_should_not_create_stored_preference_if_value_not_changed" do
       @user.write_preference(:notifications, true, :chat)
       @user.save!
 
-      assert_equal 0, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 0
     end
 
     it "test_should_create_stored_preference_if_value_changed" do
       @user.write_preference(:notifications, false, :chat)
       @user.save!
 
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 1
     end
 
     it "test_should_set_group_attributes_on_stored_preferences" do
@@ -666,53 +664,53 @@ describe "ModelPreferenceTest" do
       @user.save!
 
       preference = @user.stored_preferences.first
-      assert_equal 'chat', preference.group_type
-      assert_nil preference.group_id
+      expect(preference.group_type).to eq 'chat'
+      expect(preference.group_id).to eq nil
     end
 
     it "test_should_overwrite_existing_stored_preference_if_value_changed" do
-      preference = create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => true)
+      preference = create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => true)
 
       @user.write_preference(:notifications, false, :chat)
       @user.save!
 
       preference.reload
-      assert_equal false, preference.value
+      expect(preference.value).to eq false
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesARGroupWriterTest" do
     before do
-      @car = create_car
+      @car = create(:car)
 
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
-      @user = create_user(:login => 'admin')
+      @user = create(:user, :login => 'admin')
     end
 
     it "test_should_have_same_value_if_not_changed" do
       @user.write_preference(:notifications, true, @car)
-      assert_equal true, @user.preferred(:notifications, @car)
+      expect(@user.preferred(:notifications, @car)).to eq true
     end
 
     it "test_should_use_new_value_if_changed" do
       @user.write_preference(:notifications, false, @car)
-      assert_equal false, @user.preferred(:notifications, @car)
+      expect(@user.preferred(:notifications, @car)).to eq false
     end
 
     it "test_should_not_create_stored_preference_if_value_not_changed" do
       @user.write_preference(:notifications, true, @car)
       @user.save!
 
-      assert_equal 0, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 0
     end
 
     it "test_should_create_stored_preference_if_value_changed" do
       @user.write_preference(:notifications, false, @car)
       @user.save!
 
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 1
     end
 
     it "test_should_set_group_attributes_on_stored_preferences" do
@@ -720,8 +718,8 @@ describe "ModelPreferenceTest" do
       @user.save!
 
       preference = @user.stored_preferences.first
-      assert_equal 'Car', preference.group_type
-      assert_equal @car.id, preference.group_id
+      expect(preference.group_type).to eq 'Car'
+      expect(preference.group_id).to eq @car.id
     end
   end
 
@@ -730,29 +728,29 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
-      @user = create_user
+      @user = create(:user)
 
       @user.write_preference(:notifications, false)
     end
 
     it "test_should_query_preferences_changed" do
-      assert_equal true, @user.preferences_changed?
+      expect(@user.preferences_changed?).to eq true
     end
 
     it "test_should_query_preference_changed" do
-      assert_equal true, @user.prefers_notifications_changed?
+      expect(@user.prefers_notifications_changed?).to eq true
     end
 
     it "test_should_not_query_preferences_changed_for_group" do
-      assert_equal false, @user.preferences_changed?(:chat)
+      expect(@user.preferences_changed?(:chat)).to eq false
     end
 
     it "test_should_not_query_preference_changed_for_group" do
-      assert_equal false, @user.prefers_notifications_changed?(:chat)
+      expect(@user.prefers_notifications_changed?(:chat)).to eq false
     end
 
     it "test_should_have_preferences_changed" do
-      assert_equal ['notifications'], @user.preferences_changed
+      expect(@user.preferences_changed).to eq ['notifications']
     end
 
     it "test_should_not_build_same_preferences_changed_result" do
@@ -760,16 +758,16 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_not_have_preferences_changed_for_group" do
-      assert_equal [], @user.preferences_changed(:chat)
+      expect(@user.preferences_changed(:chat)).to eq []
     end
 
     it "test_should_track_multiple_preferences_changed" do
       @user.write_preference(:language, 'Latin')
-      assert_equal ['language', 'notifications'], @user.preferences_changed.sort
+      expect(@user.preferences_changed.sort).to eq ['language', 'notifications']
     end
 
     it "test_should_have_preference_changes" do
-      assert_equal e = {'notifications' => [true, false]}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({'notifications' => [true, false]})
     end
 
     it "test_should_not_build_same_preference_changes_result" do
@@ -777,28 +775,28 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_have_preference_change" do
-      assert_equal [true, false], @user.prefers_notifications_change
+      expect(@user.prefers_notifications_change).to eq [true, false]
     end
 
     it "test_should_have_preference_was" do
-      assert_equal true, @user.prefers_notifications_was
+      expect(@user.prefers_notifications_was).to eq true
     end
 
     it "test_should_not_have_preference_changes_for_group" do
-      assert_equal e = {}, @user.preference_changes(:chat)
+      expect(@user.preference_changes(:chat)).to eq ({})
     end
 
     it "test_should_not_have_preference_change_for_group" do
-      assert_nil @user.prefers_notifications_change(:chat)
+      expect(@user.prefers_notifications_change(:chat)).to eq nil
     end
 
     it "test_should_have_preference_was_for_group" do
-      assert_equal true, @user.prefers_notifications_was(:chat)
+      expect(@user.prefers_notifications_was(:chat)).to eq true
     end
 
     it "test_should_use_latest_value_for_preference_changes" do
       @user.write_preference(:notifications, nil)
-      assert_equal e = {'notifications' => [true, nil]}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({'notifications' => [true, nil]})
     end
 
     it "test_should_use_cloned_old_value_for_preference_changes" do
@@ -806,13 +804,13 @@ describe "ModelPreferenceTest" do
       @user.write_preference(:language, 'Latin')
 
       tracked_old_value = @user.preference_changes['language'][0]
-      assert_equal old_value, tracked_old_value
+      expect(tracked_old_value).to eq old_value
       expect(old_value).to_not be tracked_old_value
     end
 
     it "test_should_track_multiple_preference_changes" do
       @user.write_preference(:language, 'Latin')
-      assert_equal e = {'notifications' => [true, false], 'language' => ['English', 'Latin']}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({'notifications' => [true, false], 'language' => ['English', 'Latin']})
     end
   end
 
@@ -821,57 +819,57 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
-      @user = create_user
+      @user = create(:user)
 
       @user.write_preference(:notifications, false, :chat)
     end
 
     it "test_should_not_query_preferences_changed" do
-      assert_equal false, @user.preferences_changed?
+      expect(@user.preferences_changed?).to eq false
     end
 
     it "test_not_should_query_preference_changed" do
-      assert_equal false, @user.prefers_notifications_changed?
+      expect(@user.prefers_notifications_changed?).to eq false
     end
 
     it "test_should_query_preferences_changed_for_group" do
-      assert_equal true, @user.preferences_changed?(:chat)
+      expect(@user.preferences_changed?(:chat)).to eq true
     end
 
     it "test_should_query_preference_changed_for_group" do
-      assert_equal true, @user.prefers_notifications_changed?(:chat)
+      expect(@user.prefers_notifications_changed?(:chat)).to eq true
     end
 
     it "test_should_have_preferences_changed" do
-      assert_equal [], @user.preferences_changed
+      expect(@user.preferences_changed).to eq []
     end
 
     it "test_should_not_have_preferences_changed_for_group" do
-      assert_equal ['notifications'], @user.preferences_changed(:chat)
+      expect(@user.preferences_changed(:chat)).to eq ['notifications']
     end
 
     it "test_should_have_preference_changes" do
-      assert_equal e = {}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({})
     end
 
     it "test_should_not_have_preference_change" do
-      assert_nil @user.prefers_notifications_change
+      expect(@user.prefers_notifications_change).to eq nil
     end
 
     it "test_should_have_preference_was" do
-      assert_equal true, @user.prefers_notifications_was
+      expect(@user.prefers_notifications_was).to eq true
     end
 
     it "test_should_not_have_preference_changes_for_group" do
-      assert_equal e = {'notifications' => [true, false]}, @user.preference_changes(:chat)
+      expect(@user.preference_changes(:chat)).to eq ({'notifications' => [true, false]})
     end
 
     it "test_should_have_preference_change_for_group" do
-      assert_equal [true, false], @user.prefers_notifications_change(:chat)
+      expect(@user.prefers_notifications_change(:chat)).to eq [true, false]
     end
 
     it "test_should_have_preference_was_for_group" do
-      assert_equal true, @user.prefers_notifications_was(:chat)
+      expect(@user.prefers_notifications_was(:chat)).to eq true
     end
   end
 
@@ -880,21 +878,21 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.write_preference(:notifications, false)
       @user.write_preference(:notifications, true)
     end
 
     it "test_should_not_query_preferences_changed" do
-      assert_equal false, @user.preferences_changed?
+      expect(@user.preferences_changed?).to eq false
     end
 
     it "test_should_not_have_preferences_changed" do
-      assert_equal [], @user.preferences_changed
+      expect(@user.preferences_changed).to eq []
     end
 
     it "test_should_not_have_preference_changes" do
-      assert_equal e = {}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({})
     end
   end
 
@@ -903,18 +901,18 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.prefers_notifications_will_change!
       @user.save
     end
 
     it "test_should_store_preference" do
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 1
 
       preference = @user.stored_preferences.first
-      assert_equal nil, preference.group_type
-      assert_equal nil, preference.group_id
-      assert_equal true, preference.value
+      expect(preference.group_type).to eq nil
+      expect(preference.group_id).to eq nil
+      expect(preference.value).to eq true
     end
   end
 
@@ -924,18 +922,18 @@ describe "ModelPreferenceTest" do
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
 
-      @user = create_user
+      @user = create(:user)
       @user.prefers_notifications_will_change!(:chat)
       @user.save
     end
 
     it "test_should_store_preference" do
-      assert_equal 1, @user.stored_preferences.count
+      expect(@user.stored_preferences.count).to eq 1
 
       preference = @user.stored_preferences.first
-      assert_equal 'chat', preference.group_type
-      assert_equal nil, preference.group_id
-      assert_equal true, preference.value
+      expect(preference.group_type).to eq 'chat'
+      expect(preference.group_id).to eq nil
+      expect(preference.value).to eq true
     end
 
     it "test_should_use_cloned_value_for_tracking_old_value" do
@@ -943,7 +941,7 @@ describe "ModelPreferenceTest" do
       @user.preferred_language_will_change!
 
       tracked_old_value = @user.preferred_language_was
-      assert_equal old_value, tracked_old_value
+      expect(tracked_old_value).to eq old_value
       expect(old_value).to_not be tracked_old_value
     end
   end
@@ -953,18 +951,18 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.write_preference(:notifications, false)
       @user.write_preference(:notifications, false, :chat)
       @user.reset_prefers_notifications!
     end
 
     it "test_should_revert_to_original_value" do
-      assert_equal true, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq true
     end
 
     it "test_should_not_reset_groups" do
-      assert_equal false, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq false
     end
   end
 
@@ -973,59 +971,60 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.write_preference(:notifications, false)
       @user.write_preference(:notifications, false, :chat)
       @user.reset_prefers_notifications!(:chat)
     end
 
     it "test_should_revert_to_original_value" do
-      assert_equal true, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq true
     end
 
     it "test_should_not_reset_default_group" do
-      assert_equal false, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq false
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesLookupTest" do
     before do
+      User.preference_definitions.clear
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English', :group_defaults => {:chat => 'Latin'}
 
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_only_have_defaults_if_nothing_customized" do
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_unsaved_changes" do
       @user.write_preference(:notifications, false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_saved_changes" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
+      expect(@user.preferences).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_stored_preferences_with_unsaved_changes" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
       @user.write_preference(:language, 'Latin')
-      assert_equal e = {'notifications' => false, 'language' => 'Latin'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => false, 'language' => 'Latin'})
     end
 
     it "test_should_use_unsaved_changes_over_stored_preferences" do
-      create_preference(:owner => @user, :name => 'notifications', :value => true)
+      create(:preference, :owner => @user, :name => 'notifications', :value => true)
       @user.write_preference(:notifications, false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_typecast_unsaved_changes" do
       @user.write_preference(:notifications, 'true')
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true, 'language' => 'English'})
     end
 
     it "test_should_cache_results" do
@@ -1034,10 +1033,10 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_not_query_if_stored_preferences_eager_loaded" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
       user = User.includes(:stored_preferences).where(id: @user.id).first
       assert_queries(0) do
-        assert_equal e = {'notifications' => false, 'language' => 'English'}, user.preferences
+        expect(user.preferences).to eq ({'notifications' => false, 'language' => 'English'})
       end
     end
 
@@ -1046,42 +1045,43 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_use_preferences_for_prefs" do
-      assert_equal @user.preferences, @user.prefs
+      expect(@user.prefs).to eq @user.preferences
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesGroupLookupTest" do
     before do
+      User.preference_definitions.clear
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English', :group_defaults => {:chat => 'Latin'}
 
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_only_have_defaults_if_nothing_customized" do
-      assert_equal e = {'notifications' => true, 'language' => 'Latin'}, @user.preferences(:chat)
+      expect(@user.preferences(:chat)).to eq ({'notifications' => true, 'language' => 'Latin'})
     end
 
     it "test_should_merge_defaults_with_unsaved_changes" do
       @user.write_preference(:notifications, false, :chat)
-      assert_equal e = {'notifications' => false, 'language' => 'Latin'}, @user.preferences(:chat)
+      expect(@user.preferences(:chat)).to eq ({'notifications' => false, 'language' => 'Latin'})
     end
 
     it "test_should_merge_defaults_with_saved_changes" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
-      assert_equal e = {'notifications' => false, 'language' => 'Latin'}, @user.preferences(:chat)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      expect(@user.preferences(:chat)).to eq ({'notifications' => false, 'language' => 'Latin'})
     end
 
     it "test_should_merge_stored_preferences_with_unsaved_changes" do
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
       @user.write_preference(:language, 'Spanish', :chat)
-      assert_equal e = {'notifications' => false, 'language' => 'Spanish'}, @user.preferences(:chat)
+      expect(@user.preferences(:chat)).to eq ({'notifications' => false, 'language' => 'Spanish'})
     end
 
     it "test_should_typecast_unsaved_changes" do
       @user.write_preference(:notifications, 'true', :chat)
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true, 'language' => 'English'})
     end
 
     it "test_should_cache_results" do
@@ -1104,79 +1104,82 @@ describe "ModelPreferenceTest" do
   #------------------------------------------------------------------------------
   describe "PreferencesARGroupLookupTest" do
     before do
-      @car = create_car
+      @car = create(:car)
 
+      User.preference_definitions.clear
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
 
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_only_have_defaults_if_nothing_customized" do
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences(@car)
+      expect(@user.preferences(@car)).to eq ({'notifications' => true, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_unsaved_changes" do
       @user.write_preference(:notifications, false, @car)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences(@car)
+      expect(@user.preferences(@car)).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_saved_changes" do
-      create_preference(:owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences(@car)
+      create(:preference, :owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
+      expect(@user.preferences(@car)).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_stored_preferences_with_unsaved_changes" do
-      create_preference(:owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :group_type => 'Car', :group_id => @car.id, :name => 'notifications', :value => false)
       @user.write_preference(:language, 'Latin', @car)
-      assert_equal e = {'notifications' => false, 'language' => 'Latin'}, @user.preferences(@car)
+      expect(@user.preferences(@car)).to eq ({'notifications' => false, 'language' => 'Latin'})
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesNilGroupLookupTest" do
     before do
-      @car = create_car
+      @car = create(:car)
 
+      User.preference_definitions.clear
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
 
-      @user = create_user
+      @user = create(:user)
     end
 
     it "test_should_only_have_defaults_if_nothing_customized" do
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences(nil)
+      expect(@user.preferences(nil)).to eq ({'notifications' => true, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_unsaved_changes" do
       @user.write_preference(:notifications, false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences(nil)
+      expect(@user.preferences(nil)).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_defaults_with_saved_changes" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
-      assert_equal e = {'notifications' => false, 'language' => 'English'}, @user.preferences(nil)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
+      expect(@user.preferences(nil)).to eq ({'notifications' => false, 'language' => 'English'})
     end
 
     it "test_should_merge_stored_preferences_with_unsaved_changes" do
-      create_preference(:owner => @user, :name => 'notifications', :value => false)
+      create(:preference, :owner => @user, :name => 'notifications', :value => false)
       @user.write_preference(:language, 'Latin')
-      assert_equal e = {'notifications' => false, 'language' => 'Latin'}, @user.preferences(nil)
+      expect(@user.preferences(nil)).to eq ({'notifications' => false, 'language' => 'Latin'})
     end
   end
 
   #------------------------------------------------------------------------------
   describe "PreferencesLookupWithGroupsTest" do
     before do
+      User.preference_definitions.clear
       User.preference :notifications, :boolean, :default => true
       User.preference :language, :string, :default => 'English'
 
-      @user = create_user
-      create_preference(:owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
+      @user = create(:user)
+      create(:preference, :owner => @user, :group_type => 'chat', :name => 'notifications', :value => false)
     end
 
     it "test_not_include_group_preferences_by_default" do
-      assert_equal e = {'notifications' => true, 'language' => 'English'}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true, 'language' => 'English'})
     end
   end
 
@@ -1185,22 +1188,22 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.write_preference(:notifications, false)
       @user.reload
     end
 
     it "test_should_reset_unsaved_preferences" do
-      assert_equal true, @user.preferred(:notifications)
+      expect(@user.preferred(:notifications)).to eq true
     end
 
     it "test_should_not_save_reset_preferences" do
       @user.save!
-      assert @user.stored_preferences.empty?
+      expect(@user.stored_preferences.empty?).to eq true
     end
 
     it "test_should_reset_preferences" do
-      assert_equal e = {'notifications' => true}, @user.preferences
+      expect(@user.preferences).to eq ({'notifications' => true})
     end
 
     it "test_should_clear_query_cache_for_preferences" do
@@ -1208,15 +1211,15 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_reset_preferences_changed_query" do
-      assert_equal false, @user.preferences_changed?
+      expect(@user.preferences_changed?).to eq false
     end
 
     it "test_should_reset_preferences_changed" do
-      assert_equal [], @user.preferences_changed
+      expect(@user.preferences_changed).to eq []
     end
 
     it "test_should_reset_preference_changes" do
-      assert_equal e = {}, @user.preference_changes
+      expect(@user.preference_changes).to eq ({})
     end
   end
 
@@ -1225,17 +1228,17 @@ describe "ModelPreferenceTest" do
     before do
       User.preference :notifications, :boolean, :default => true
 
-      @user = create_user
+      @user = create(:user)
       @user.write_preference(:notifications, false, :chat)
       @user.reload
     end
 
     it "test_should_reset_unsaved_preferences" do
-      assert_equal true, @user.preferred(:notifications, :chat)
+      expect(@user.preferred(:notifications, :chat)).to eq true
     end
 
     it "test_should_reset_preferences" do
-      assert_equal e = {'notifications' => true}, @user.preferences(:chat)
+      expect(@user.preferences(:chat)).to eq ({'notifications' => true})
     end
 
     it "test_should_clear_query_cache_for_preferences" do
@@ -1243,15 +1246,15 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_reset_preferences_changed_query" do
-      assert_equal false, @user.preferences_changed?(:chat)
+      expect(@user.preferences_changed?(:chat)).to eq false
     end
 
     it "test_should_reset_preferences_changed" do
-      assert_equal [], @user.preferences_changed(:chat)
+      expect(@user.preferences_changed(:chat)).to eq []
     end
 
     it "test_should_reset_preference_changes" do
-      assert_equal e = {}, @user.preference_changes(:chat)
+      expect(@user.preference_changes(:chat)).to eq ({})
     end
   end
 
@@ -1262,8 +1265,8 @@ describe "ModelPreferenceTest" do
       User.preference :language, :string, :default => 'English'
       User.preference :color, :string, :default => 'red'
 
-      @user = create_user
-      @customized_user = create_user(:login => 'customized',
+      @user = create(:user)
+      @customized_user = create(:user,:login => 'customized',
         :prefers_notifications => false,
         :preferred_language => 'Latin'
       )
@@ -1273,35 +1276,35 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_not_find_if_no_preference_matched" do
-      assert_equal [], User.with_preferences(:language => 'Italian')
+      expect(User.with_preferences(:language => 'Italian')).to eq []
     end
 
     it "test_should_find_with_null_preference" do
-      assert_equal [@user], User.with_preferences(:notifications => nil)
+      expect(User.with_preferences(:notifications => nil)).to eq [@user]
     end
 
     it "test_should_find_with_default_preference" do
-      assert_equal [@user], User.with_preferences(:language => 'English')
+      expect(User.with_preferences(:language => 'English')).to eq [@user]
     end
 
     it "test_should_find_with_multiple_default_preferences" do
-      assert_equal [@user], User.with_preferences(:notifications => nil, :language => 'English')
+      expect(User.with_preferences(:notifications => nil, :language => 'English')).to eq [@user]
     end
 
     it "test_should_find_with_custom_preference" do
-      assert_equal [@customized_user], User.with_preferences(:language => 'Latin')
+      expect(User.with_preferences(:language => 'Latin')).to eq [@customized_user]
     end
 
     it "test_should_find_with_multiple_custom_preferences" do
-      assert_equal [@customized_user], User.with_preferences(:notifications => false, :language => 'Latin')
+      expect(User.with_preferences(:notifications => false, :language => 'Latin')).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_default_and_custom_preferences" do
-      assert_equal [@customized_user], User.with_preferences(:color => 'red', :language => 'Latin')
+      expect(User.with_preferences(:color => 'red', :language => 'Latin')).to eq [@customized_user]
     end
 
     it "test_should_find_with_default_group_preference" do
-      assert_equal [@user], User.with_preferences(:chat => {:language => 'English'})
+      expect(User.with_preferences(:chat => {:language => 'English'})).to eq [@user]
     end
 
     it "test_should_find_with_customized_default_group_preference" do
@@ -1309,34 +1312,34 @@ describe "ModelPreferenceTest" do
       @customized_user.preferred_country = 'US', :chat
       @customized_user.save!
 
-      assert_equal [@user], User.with_preferences(:chat => {:country => 'UK'})
+      expect(User.with_preferences(:chat => {:country => 'UK'})).to eq [@user]
     end
 
     it "test_should_find_with_multiple_default_group_preferences" do
-      assert_equal [@user], User.with_preferences(:chat => {:notifications => nil, :language => 'English'})
+      expect(User.with_preferences(:chat => {:notifications => nil, :language => 'English'})).to eq [@user]
     end
 
     it "test_should_find_with_custom_group_preference" do
-      assert_equal [@customized_user], User.with_preferences(:chat => {:language => 'Latin'})
+      expect(User.with_preferences(:chat => {:language => 'Latin'})).to eq [@customized_user]
     end
 
     it "test_should_find_with_multiple_custom_group_preferences" do
-      assert_equal [@customized_user], User.with_preferences(:chat => {:notifications => false, :language => 'Latin'})
+      expect(User.with_preferences(:chat => {:notifications => false, :language => 'Latin'})).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_default_and_custom_group_preferences" do
-      assert_equal [@customized_user], User.with_preferences(:chat => {:color => 'red', :language => 'Latin'})
+      expect(User.with_preferences(:chat => {:color => 'red', :language => 'Latin'})).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_basic_and_group_preferences" do
       @customized_user.preferred_language = 'English'
       @customized_user.save!
 
-      assert_equal [@customized_user], User.with_preferences(:language => 'English', :chat => {:language => 'Latin'})
+      expect(User.with_preferences(:language => 'English', :chat => {:language => 'Latin'})).to eq [@customized_user]
     end
 
     it "test_should_allow_chaining" do
-      assert_equal [@user], User.with_preferences(:language => 'English').with_preferences(:color => 'red')
+      expect(User.with_preferences(:language => 'English').with_preferences(:color => 'red')).to eq [@user]
     end
   end
 
@@ -1347,8 +1350,8 @@ describe "ModelPreferenceTest" do
       User.preference :language, :string, :default => 'English'
       User.preference :color, :string, :default => 'red'
 
-      @user = create_user
-      @customized_user = create_user(:login => 'customized',
+      @user = create(:user)
+      @customized_user = create(:user, :login => 'customized',
         :prefers_notifications => false,
         :preferred_language => 'Latin'
       )
@@ -1358,35 +1361,35 @@ describe "ModelPreferenceTest" do
     end
 
     it "test_should_not_find_if_no_preference_matched" do
-      assert_equal [], User.without_preferences(:color => 'red')
+      expect(User.without_preferences(:color => 'red')).to eq []
     end
 
     it "test_should_find_with_null_preference" do
-      assert_equal [@user], User.without_preferences(:notifications => false)
+      expect(User.without_preferences(:notifications => false)).to eq [@user]
     end
 
     it "test_should_find_with_default_preference" do
-      assert_equal [@user], User.without_preferences(:language => 'Latin')
+      expect(User.without_preferences(:language => 'Latin')).to eq [@user]
     end
 
     it "test_should_find_with_multiple_default_preferences" do
-      assert_equal [@user], User.without_preferences(:language => 'Latin', :notifications => false)
+      expect(User.without_preferences(:language => 'Latin', :notifications => false)).to eq [@user]
     end
 
     it "test_should_find_with_custom_preference" do
-      assert_equal [@customized_user], User.without_preferences(:language => 'English')
+      expect(User.without_preferences(:language => 'English')).to eq [@customized_user]
     end
 
     it "test_should_find_with_multiple_custom_preferences" do
-      assert_equal [@customized_user], User.without_preferences(:language => 'English', :notifications => nil)
+      expect(User.without_preferences(:language => 'English', :notifications => nil)).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_default_and_custom_preferences" do
-      assert_equal [@customized_user], User.without_preferences(:language => 'English', :color => 'blue')
+      expect(User.without_preferences(:language => 'English', :color => 'blue')).to eq [@customized_user]
     end
 
     it "test_should_find_with_default_group_preference" do
-      assert_equal [@user], User.without_preferences(:chat => {:language => 'Latin'})
+      expect(User.without_preferences(:chat => {:language => 'Latin'})).to eq [@user]
     end
 
     it "test_should_find_with_customized_default_group_preference" do
@@ -1394,34 +1397,34 @@ describe "ModelPreferenceTest" do
       @customized_user.preferred_country = 'US', :chat
       @customized_user.save!
 
-      assert_equal [@user], User.without_preferences(:chat => {:country => 'US'})
+      expect(User.without_preferences(:chat => {:country => 'US'})).to eq [@user]
     end
 
     it "test_should_find_with_multiple_default_group_preferences" do
-      assert_equal [@user], User.without_preferences(:chat => {:language => 'Latin', :notifications => false})
+      expect(User.without_preferences(:chat => {:language => 'Latin', :notifications => false})).to eq [@user]
     end
 
     it "test_should_find_with_custom_group_preference" do
-      assert_equal [@customized_user], User.without_preferences(:chat => {:language => 'English'})
+      expect(User.without_preferences(:chat => {:language => 'English'})).to eq [@customized_user]
     end
 
     it "test_should_find_with_multiple_custom_group_preferences" do
-      assert_equal [@customized_user], User.without_preferences(:chat => {:language => 'English', :notifications => nil})
+      expect(User.without_preferences(:chat => {:language => 'English', :notifications => nil})).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_default_and_custom_group_preferences" do
-      assert_equal [@customized_user], User.without_preferences(:chat => {:language => 'English', :color => 'blue'})
+      expect(User.without_preferences(:chat => {:language => 'English', :color => 'blue'})).to eq [@customized_user]
     end
 
     it "test_should_find_with_mixed_basic_and_group_preferences" do
       @customized_user.preferred_language = 'English'
       @customized_user.save!
 
-      assert_equal [@customized_user], User.without_preferences(:language => 'Latin', :chat => {:language => 'English'})
+      expect(User.without_preferences(:language => 'Latin', :chat => {:language => 'English'})).to eq [@customized_user]
     end
 
     it "test_should_allow_chaining" do
-      assert_equal [@user], User.without_preferences(:language => 'Latin').without_preferences(:color => 'blue')
+      expect(User.without_preferences(:language => 'Latin').without_preferences(:color => 'blue')).to eq [@user]
     end
   end
 end