simple_enum 1.4.1 → 1.5.0

data/test/orm/mongoid.rb

@@ -0,0 +1,101 @@
+require 'mongoid/version'
+require 'simple_enum/mongoid'
+
+def orm_version
+  Mongoid::VERSION
+end
+
+def setup_db
+  # create database connection
+  Mongoid.configure do |config|
+    config.master = Mongo::Connection.new('localhost').db("simple-enum-test-suite")
+    config.use_utc = true
+    config.include_root_in_json = true
+  end
+end
+
+
+# Reload database
+def reload_db(options = {})
+
+  # clear collections except system
+  Mongoid.master.collections.select do |collection|
+    collection.name !~ /system/
+  end.each(&:drop)
+
+  fill_db(options)
+end
+
+# models
+def anonymous_dummy(&block)
+  Class.new do
+    include Mongoid::Document
+    include SimpleEnum::Mongoid
+    self.collection_name = 'dummies'
+    instance_eval &block
+  end
+end
+
+def extend_computer(current_i18n_name = "Computer", &block)
+  Class.new(Computer) do
+    self.collection_name = 'computers'
+    instance_eval &block
+    instance_eval <<-RUBY
+      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
+    RUBY
+  end
+end
+
+def named_dummy(class_name, &block)
+  begin
+    return class_name.constantize
+  rescue NameError
+    klass = Object.const_set(class_name, Class.new)
+    klass.module_eval do
+      include Mongoid::Document
+      include SimpleEnum::Mongoid
+
+      self.collection_name = 'dummies'
+      instance_eval &block
+    end
+
+    klass
+  end
+
+end
+
+class Dummy
+  include Mongoid::Document
+  include SimpleEnum::Mongoid
+
+  as_enum :gender, [:male, :female]
+  as_enum :word, { :alpha => 'alpha', :beta => 'beta', :gamma => 'gamma'}
+  as_enum :didum, [ :foo, :bar, :foobar ], :column => 'other'
+
+  before_save :check_typed
+
+  def check_typed
+    attributes['_type'] = nil unless (self.hereditary? || self.polymorphic?)
+  end
+
+end
+
+class Gender
+  include Mongoid::Document
+  include SimpleEnum::Mongoid
+
+  field :name, :type => String
+end
+
+class Computer
+  include Mongoid::Document
+  include SimpleEnum::Mongoid
+
+  field :name, :type => String
+
+  as_enum :manufacturer, [:dell, :compaq, :apple]
+  as_enum :operating_system, [:windows, :osx, :linux, :bsd]
+end
+
+# Used to test STI stuff
+class SpecificDummy < Dummy; end

data/test/poro_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class POROTest < MiniTest::Unit::TestCase
+  class MyPORO
+    include SimpleEnum
+
+    attr_accessor :gender_cd
+    as_enum :gender, [:male, :female]
+  end
+
+  def test_reading_and_writing
+    poro = POROTest::MyPORO.new
+    poro.gender_cd = 1
+    assert_equal :female, poro.gender
+
+    poro.male!
+    assert_equal 0, poro.gender_cd
+    assert_equal :male, poro.gender
+  end
+end

data/test/prefixes_test.rb

@@ -1,13 +1,12 @@
 require 'test_helper'
 
-class PrefixesTest < ActiveSupport::TestCase  
+class PrefixesTest < MiniTest::Unit::TestCase
   def setup
     reload_db
   end
 
-  test "set :prefix => true and ensure that 'gender' is prefixed to <symbol>? and <symbol>! methods" do
-    with_prefix = Class.new(ActiveRecord::Base) do
-      set_table_name 'dummies'
+  def test_that_gender_is_prefixed_in_getters_and_setters
+    with_prefix = anonymous_dummy do
       as_enum :gender, [:male, :female], :prefix => true
     end
     
@@ -21,9 +20,8 @@ class PrefixesTest < ActiveSupport::TestCase
     assert !d.respond_to?(:male!)
   end
   
-  test "set :prefix => 'didum' and ensure that 'didum' is prefix to <symbol>? and <symbol>! methods" do
-    with_string_prefix = Class.new(ActiveRecord::Base) do
-      set_table_name 'dummies'
+  def test_that_custom_prefix_is_applied_to_getters_and_setters
+    with_string_prefix = anonymous_dummy do
       as_enum :gender, [:male, :female], :prefix => 'didum'
     end
     

data/test/simple_enum_test.rb

@@ -1,51 +1,76 @@
 require 'test_helper'
 
-class SimpleEnumTest < ActiveSupport::TestCase
+class SimpleEnumTest < MiniTest::Unit::TestCase
   def setup
     reload_db
   end
 
-  test "reading public enum_definitions" do
+  def test_reading_public_enum_definitions
     assert_equal "gender_cd", Dummy.enum_definitions[:gender][:column]
   end
 
-  test "get the correct integer values when setting to symbol" do
+  def test_getting_the_correct_integer_values_when_setting_to_symbol
     d = Dummy.new
     d.gender = :male
     assert_equal(0, d.gender_cd)
   end
 
-  test "get the correct symbol when setting the integer value" do
+  def test_getting_the_correct_symbold_when_setting_the_integer_value
     d = Dummy.new
     d.gender_cd = 1
     assert_equal(:female, d.gender)
   end
 
-  test "verify that <symbol>? returns correct result" do
+  def test_that_checker_returns_correct_result
     d = Dummy.new
     d.gender = :male
     assert_equal(true, d.male?)
     assert_equal(false, d.female?)
   end
 
-  test "get symbol when rows are fetched from db" do
+  def test_enum_comparisons
+    d = Dummy.new
+    assert_equal(false, d.gender?)
+    d.gender = :male
+    assert_equal(true, d.gender?)
+    assert_equal(true, d.gender?(:male))
+    assert_equal(false, d.gender?(:female))
+    assert_equal(false, d.gender?(:whot))
+    d.gender = :female
+    assert_equal(true, d.gender?(:female))
+    assert_equal(false, d.gender?(:male))
+  end
+
+  def test_enum_comparisons_with_strings
+    d = Dummy.new(:gender => :male)
+    assert_equal(true, d.gender?("male"))
+  end
+
+  def test_enum_comparisons_with_nil_always_returns_false
+    d = Dummy.new(:gender => :male)
+    assert_equal(false, d.gender?(nil))
+  end
+
+  def test_getting_symbol_when_data_is_fetched_from_datasource
+    dummies = Dummy.all
+
     # Anna
-    assert_equal(:female, Dummy.find(1).gender)
-    assert_equal(:alpha, Dummy.find(1).word)
-    assert_equal(:foo, Dummy.find(1).didum)
+    assert_equal(:female, dummies[0].gender)
+    assert_equal(:alpha, dummies[0].word)
+    assert_equal(:foo, dummies[0].didum)
 
     # Bella
-    assert_equal(true, Dummy.find(2).female?)
-    assert_equal(true, Dummy.find(2).beta?)
-    assert_equal(:bar, Dummy.find(2).didum)
+    assert_equal(true, dummies[1].female?)
+    assert_equal(true, dummies[1].beta?)
+    assert_equal(:bar, dummies[1].didum)
 
     # Chris
-    assert_equal(false, Dummy.find(3).female?)
-    assert_equal(:gamma, Dummy.find(3).word)
-    assert_equal(:foobar, Dummy.find(3).didum)
+    assert_equal(false, dummies[2].female?)
+    assert_equal(:gamma, dummies[2].word)
+    assert_equal(:foobar, dummies[2].didum)
   end
 
-  test "create and save new record then test symbols" do
+  def test_creating_and_saving_a_new_datasource_object_then_test_symbols
     d = Dummy.create({ :name => 'Dummy', :gender_cd => 0 }) # :gender => male
     assert_equal(true, d.male?)
 
@@ -55,16 +80,14 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(true, Dummy.find(d.id).female?)
   end
 
-  test "validation :if" do
-    class ValidateIfComputer < Computer
-      set_table_name 'computers'
-
+  def test_validation_if
+    validate_if_comp = extend_computer do
       validates_as_enum :manufacturer, :if => lambda { |computer|
         computer.name == "Fred"
       }
     end
 
-    computer = ValidateIfComputer.new(:manufacturer_cd => 48328432)
+    computer = validate_if_comp.new(:manufacturer_cd => 48328432)
 
     computer.name = nil
     assert_equal(true, computer.save)
@@ -73,16 +96,14 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(false, computer.save)
   end
 
-  test "validation :unless" do
-    class ValidateUnlessComputer < Computer
-      set_table_name 'computers'
-
+  def test_validation_unless
+    validate_unless_comp = extend_computer do
       validates_as_enum :manufacturer, :unless => lambda { |computer|
         computer.name == "Unless"
       }
     end
 
-    computer = ValidateUnlessComputer.new(:manufacturer_cd => 48328432)
+    computer = validate_unless_comp.new(:manufacturer_cd => 48328432)
 
     computer.name = nil
     assert_equal(false, computer.save)
@@ -92,14 +113,12 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(true, computer.save)
   end
 
-  test "validation :on => :update" do
-    class ValidateOnUpdateComputer < Computer
-      set_table_name 'computers'
-
+  def test_validation_on_update
+    validate_update_comp = extend_computer do
       validates_as_enum :manufacturer, :on => :update
     end
 
-    computer = ValidateOnUpdateComputer.new(:manufacturer_cd => nil)
+    computer = validate_update_comp.new(:manufacturer_cd => nil)
     assert_equal(true, computer.save)
 
     computer.name = 'Something else'
@@ -107,14 +126,12 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(1, computer.errors[:manufacturer].size)
   end
 
-  test "validation :on => :create" do
-    class ValidateOnCreateComputer < Computer
-      set_table_name 'computers'
-
+  def test_validation_on_create
+    validate_create_comp = extend_computer do
       validates_as_enum :manufacturer, :on => :create
     end
 
-    computer = ValidateOnCreateComputer.new(:manufacturer_cd => nil)
+    computer = validate_create_comp.new(:manufacturer_cd => nil)
     assert_equal(false, computer.save)
     assert_equal(1, computer.errors[:manufacturer].size)
 
@@ -125,14 +142,12 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(true, computer.save)
   end
 
-  test "validation :allow_nil" do
-    class ValidateAllowNilComputer < Computer
-      set_table_name 'computers'
-
+  def test_validation_allow_nil
+    validate_nil_comp = extend_computer do
       validates_as_enum :manufacturer, :allow_nil => true
     end
 
-    computer = ValidateAllowNilComputer.new(:manufacturer_cd => nil)
+    computer = validate_nil_comp.new(:manufacturer_cd => nil)
     assert_equal(true, computer.save)
 
     computer.manufacturer = :apple
@@ -143,37 +158,35 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_equal(1, computer.errors[:manufacturer].size)
   end
 
-  test "default error messages using translations" do
-    class ValidatedComputer < Computer
-      set_table_name 'computers'
+  def test_default_error_messages_using_translations
+    validated_comp = extend_computer("ValidatedComputer") do
       validates_as_enum :manufacturer
       validates_as_enum :operating_system
     end
 
-    computer = ValidatedComputer.new
+    computer = validated_comp.new
     assert !computer.save, "save should return false"
     assert_equal "invalid option supplied.", computer.errors[:manufacturer].first
     assert_equal "y u no os?", computer.errors[:operating_system].first
   end
 
-  test "allow setting custom error via :message" do
-    class ValidateMessageComputer < Computer
-      set_table_name 'computers'
+  def test_allow_setting_custom_error_via_message
+    validate_msg_comp = extend_computer do
       validates_as_enum :manufacturer, :message => "invalid manufacturer"
     end
 
-    computer = ValidateMessageComputer.new
+    computer = validate_msg_comp.new
     assert !computer.valid?, "valid? should return false"
     assert_equal "invalid manufacturer", computer.errors[:manufacturer].first
   end
 
-  test "raises ArgumentError if invalid symbol is passed" do
-    assert_raise ArgumentError do
+  def test_that_argumenterror_is_raised_if_invalid_symbol_is_passed
+    assert_raises ArgumentError do
       Dummy.new :gender => :foo
     end
   end
 
-  test "raises NO ArgumentError if :whiny => false is defined" do
+  def test_that_no_argumenterror_is_raised_if_whiny_is_false
     not_whiny = Class.new(Dummy) do
       as_enum :gender, [:male, :female], :whiny => false
     end
@@ -184,7 +197,7 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_nil(d.gender)
   end
 
-  test "ensure that setting to 'nil' works if :whiny => true and :whiny => false" do
+  def test_that_setting_to_nil_works_if_whiny_is_true_or_false
     d = Dummy.new :gender => :male
     assert_equal(:male, d.gender)
     d.gender = nil
@@ -204,13 +217,13 @@ class SimpleEnumTest < ActiveSupport::TestCase
     assert_nil(d.gender)
   end
 
-  test "deprecation warning when using enum name == column name" do
+  def test_deprecation_warning_when_using_enum_name_eq_column_name
     original_behavior = ActiveSupport::Deprecation.behavior
     begin
       expected = 0
       ActiveSupport::Deprecation.silenced = false
       ActiveSupport::Deprecation.behavior = Proc.new { |msg, cb| expected += 1 if msg =~ /\[simple_enum\].+gender_cd/ }
-      invalid_dummy = Class.new(ActiveRecord::Base) do
+      invalid_dummy = anonymous_dummy do
         as_enum :gender_cd, [:male, :female], :column => "gender_cd"
       end
 

data/test/test_helper.rb

@@ -8,65 +8,38 @@ require 'bundler/setup'
 
 require 'test/unit'
 require 'active_support'
-require 'active_record'
 require 'active_support/version'
-require 'active_record/version'
+require 'minitest/autorun'
 
-# create database connection (in memory db!)
-ActiveRecord::Base.establish_connection({
-  :adapter => RUBY_PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3',
-  :database => ':memory:'})
+# setup fake rails env
+ROOT       = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+RAILS_ENV  = 'test'
 
-# load simple_enum
-require 'simple_enum'
-
-# load dummy class
-require File.join(File.dirname(__FILE__), 'models')
-
-# Test environment info
-puts "Testing against: activesupport-#{ActiveSupport::VERSION::STRING}, activerecord-#{ActiveRecord::VERSION::STRING}"
+# load orms
+ORM = ENV['ORM'] || 'active_record'
 
-# Add test locales
-I18n.load_path << File.join(File.dirname(__FILE__), 'locales.yml')
+def mongoid?; return ORM == 'mongoid';end
+def activerecord?; return ORM == 'active_record';end
 
-# Reload database
-def reload_db(options = {})
-  options = { :fill => true, :genders => false }.merge(options)
-  ActiveRecord::Base.connection.create_table :dummies, :force => true do |t|
-    t.column :name, :string
-    t.column :gender_cd, :integer
-    t.column :word_cd, :string, :limit => 5
-    t.column :other, :integer
-  end
+# load database implemntation
+require ORM
 
-  ActiveRecord::Base.connection.create_table :computers, :force => true do |t|
-    t.column :name, :string
-    t.column :operating_system_cd, :integer
-    t.column :manufacturer_cd, :integer
-  end
+# load simple enum
+require 'simple_enum'
 
-  # Create ref-data table and fill with records
-  ActiveRecord::Base.connection.create_table :genders, :force => true do |t|
-    t.column :name, :string
-  end
+# load ORM specific stuff
+require 'orm/common'
+require "orm/#{ORM}"
 
-  if options[:fill]
-    # fill db with some rows
-    Dummy.create({ :name => 'Anna',  :gender_cd => 1, :word_cd => 'alpha', :other => 0})
-    Dummy.create({ :name => 'Bella', :gender_cd => 1, :word_cd => 'beta', :other => 1})
-    Dummy.create({ :name => 'Chris', :gender_cd => 0, :word_cd => 'gamma', :other => 2})
-  end
+# Add test locales
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales.yml')
 
-  if options[:genders]
-    male = Gender.new({ :name => 'male' })
-    male.id = 0;
-    male.save!
+# setup db
+setup_db
 
-    female = Gender.new({ :name => 'female' })
-    female.id = 1;
-    female.save!
-  end
-end
+# Test environment info
+puts "Testing against: activesupport-#{ActiveSupport::VERSION::STRING}, #{ORM.to_s}-#{orm_version}"
 
 # do some magic to initialze DB for IRB session
 if Object.const_defined?('IRB')