simple_enum 1.6.9 → 2.3.2

data/spec/simple_enum/accessors_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+describe SimpleEnum::Accessors do
+  let(:enum) { SimpleEnum::Enum.new(:gender, "male" => 0, "female" => 1) }
+  fake_model(:klass)
+  let(:object) { klass.new }
+
+  context '.accessor' do
+    it 'returns Accessor instance' do
+      expect(described_class.accessor(:gender, enum)).to be_a(described_class::Accessor)
+    end
+
+    it 'returns a WhinyAccessor instance if accessor: :whiny' do
+      expect(described_class.accessor(:gender, enum, accessor: :whiny)).to be_a(described_class::WhinyAccessor)
+    end
+
+    it 'sets source to "gender" if source: :gender' do
+      expect(described_class.accessor(:gender, enum, source: :gender).source).to eq 'gender'
+    end
+  end
+
+  context '.register_accessor' do
+    let(:accessor) { Class.new { def initialize(*args); end } }
+    subject { described_class.accessor(:gender, "enum", accessor: :would_be) }
+
+    before { SimpleEnum.register_accessor :would_be, accessor }
+    after { SimpleEnum::Accessors::ACCESSORS.delete(:would_be) }
+
+    it 'adds accessor to ACCESSORS' do
+      expect(SimpleEnum::Accessors::ACCESSORS[:would_be]).to eq accessor
+    end
+
+    it 'allows to create an instance of our WouldBeAccessor' do
+      expect(subject).to be_a accessor
+    end
+  end
+
+  context 'Accessor' do
+    subject { described_class::Accessor.new(:gender, enum) }
+
+    context '#name' do
+      it 'returns the enum name as string' do
+        expect(subject.name).to eq 'gender'
+      end
+    end
+
+    context '#to_s' do
+      it 'returns the name' do
+        expect(subject.to_s).to eq 'gender'
+      end
+    end
+
+    context '#prefix' do
+      it 'returns empty string when prefix is nil' do
+        expect(described_class::Accessor.new(:gender, enum).prefix).to eq ''
+      end
+
+      it 'returns gender_ when prefix is true' do
+        expect(described_class::Accessor.new(:gender, enum, nil, true).prefix).to eq 'gender_'
+      end
+
+      it 'returns other_ when prefix is "other"' do
+        expect(described_class::Accessor.new(:gender, hash, nil, 'other').prefix).to eq 'other_'
+      end
+    end
+
+    context '#source' do
+      it 'returns gender_cd when source is nil' do
+        expect(described_class::Accessor.new(:gender, hash, nil).source).to eq 'gender_cd'
+      end
+
+      it 'returns "some_column" when source is set to :some_column' do
+        expect(described_class::Accessor.new(:gender, hash, :some_column).source).to eq 'some_column'
+      end
+
+      it 'returns "gender" when source is set to "gender"' do
+        expect(described_class::Accessor.new(:gender, hash, 'gender').source).to eq 'gender'
+      end
+    end
+
+    context '#read' do
+      shared_examples_for 'reading an enum' do
+        it 'returns nil then gender_cd is nil' do
+          expect(subject.read(object)).to be_nil
+        end
+
+        it 'returns :male when gender_cd is 0' do
+          expect(subject.read(klass.new(0))).to eq :male
+        end
+
+        it 'returns :female when gender_cd is 1' do
+          expect(subject.read(klass.new(1))).to eq :female
+        end
+      end
+
+      it_behaves_like 'reading an enum'
+
+      context 'with name == source' do
+        subject { described_class::Accessor.new(:gender_cd, enum, :gender_cd) }
+        it_behaves_like 'reading an enum'
+      end
+    end
+
+    context '#write' do
+      shared_examples_for 'writing an enum' do
+        it 'writes nil to object' do
+          object = klass.new(0)
+          expect(subject.write(object, nil)).to be_nil
+          expect(object.gender_cd).to be_nil
+        end
+
+        it 'writes 1 to object with :female' do
+          expect(subject.write(object, :female)).to eq :female
+          expect(object.gender_cd).to eq 1
+        end
+
+        it 'writes 0 to object with "male"' do
+          expect(subject.write(object, 'male')).to eq 'male'
+          expect(object.gender_cd).to eq 0
+        end
+
+        it 'writes 1 to object with 1' do
+          expect(subject.write(object, 1)).to eq 1
+          expect(object.gender_cd).to eq 1
+        end
+
+        it 'writes nil to object with :other' do
+          object = klass.new(1)
+          expect(subject.write(object, :other)).to be_nil
+          expect(object.gender_cd).to be_nil
+        end
+      end
+
+      it_behaves_like 'writing an enum'
+
+      context 'with name == source' do
+        subject { described_class::Accessor.new(:gender_cd, enum, :gender_cd) }
+        it_behaves_like 'writing an enum'
+      end
+    end
+
+    context '#selected?' do
+      it 'returns false when gender_cd is nil' do
+        expect(subject.selected?(object)).to be_falsey
+        expect(subject.selected?(object, :male)).to be_falsey
+      end
+
+      it 'returns true when gender_cd is != nil' do
+        expect(subject.selected?(klass.new(0))).to be_truthy
+        expect(subject.selected?(klass.new(1))).to be_truthy
+      end
+
+      it 'returns true when gender_cd is 0 and :male is passed' do
+        expect(subject.selected?(klass.new(0), :male)).to be_truthy
+      end
+
+      it 'returns false when gender_cd is 0 and :female is passed' do
+        expect(subject.selected?(klass.new(0), :female)).to be_falsey
+      end
+
+      it 'returns false when gender_cd is 1 and :other is passed' do
+        expect(subject.selected?(klass.new(0), :other)).to be_falsey
+      end
+    end
+
+    context '#changed?' do
+      it 'delegates to attribute_changed?' do
+        expect(object).to receive(:attribute_changed?).with('gender_cd') { true }
+        expect(subject.changed?(object)).to be_truthy
+      end
+    end
+
+    context '#was' do
+      let(:changes) do
+        { 'gender_cd' => 1 }
+      end
+
+      it 'delegates to changed_attributes and resolves symbol' do
+        expect(object).to receive(:changed_attributes) { changes }
+        expect(subject.was(object)).to eq :female
+      end
+    end
+  end
+
+  context 'dirty attributes on ActiveModel', active_record: true do
+    fake_active_record(:klass) { as_enum :gender, %w{male female} }
+    let(:object) { klass.create(gender: :male) }
+
+    it 'does not raise error "private method attribute_was called"' do
+      object.gender = :female
+      expect do
+        expect(object.gender_changed?).to be_truthy
+        expect(object.gender_was).to eq :male
+      end.to_not raise_error
+    end
+
+    context 'github.com/lwe/simple_enum/issues/109' do
+      fake_active_record(:klass) {
+        as_enum(:gender_cd, %w{female male}, source: :gender_cd)
+        as_enum(:role_cd, %w{completed cap dnf dns}, map: :string, source: :role_cd)
+      }
+      let(:object) { klass.create(role_cd: "cap", gender_cd: :female) }
+
+      context '#gender_cd_was' do
+        it 'returns nil when nil' do
+          expect(klass.create.gender_cd_was).to be_nil
+        end
+
+        it 'returns the current gender' do
+          expect(object.gender_cd_was).to eq :female
+        end
+
+        it 'returns the old gender' do
+          object.gender_cd = :male
+          expect(object.gender_cd_was).to eq :female
+        end
+      end
+
+      context '#role_cd_was' do
+        it 'returns nil when nil' do
+          expect(klass.create.role_cd_was).to be_nil
+        end
+
+        it 'returns the current role' do
+          expect(object.role_cd_was).to eq :cap
+        end
+
+        it 'returns completed when changed' do
+          object.role_cd = :completed
+          expect(object.role_cd_was).to eq :cap
+        end
+      end
+    end
+  end
+
+  context '#scope' do
+    fake_active_record(:klass) { as_enum :gender, [:male, :female] }
+    let(:accessor) { described_class::Accessor.new(:gender, enum) }
+    subject { accessor.scope(klass, 1) }
+
+    it 'returns an ActiveRecord::Relation' do
+      expect(subject).to be_a(ActiveRecord::Relation)
+    end
+
+    it "queries for gender_cd = 1" do
+      values_hash = { "gender_cd" => 1 }
+      expect(subject.where_values_hash).to eq values_hash
+    end
+  end
+
+  context 'IgnoreAccessor' do
+    subject { described_class::IgnoreAccessor.new(:gender, enum) }
+
+    it 'sets gender_cd to 0 with symbol' do
+      expect(subject.write(object, :male)).to_not be_falsey
+      expect(object.gender_cd).to eq 0
+    end
+
+    it 'sets gender_cd to 1 via value (1)' do
+      expect(subject.write(object, 1)).to_not be_falsey
+      expect(object.gender_cd).to eq 1
+    end
+
+    it 'sets gender_cd to nil' do
+      expect(subject.write(object, nil)).to be_falsey
+      expect(object.gender_cd).to be_nil
+    end
+
+    it 'keeps existing value when unknown value is passed' do
+      object.gender_cd = 1
+      expect(subject.write(object, :other)).to be_falsey
+      expect(object.gender_cd).to eq 1
+    end
+  end
+
+  context 'WhinyAccessor' do
+    subject { described_class::WhinyAccessor.new(:gender, enum) }
+
+    it 'raises no error when setting existing key' do
+      expect { subject.write(object, :male) }.to_not raise_error
+      expect(object.gender_cd).to eq 0
+    end
+
+    it 'raises no error when setting with existing value' do
+      expect { subject.write(object, 1) }.to_not raise_error
+      expect(object.gender_cd).to eq 1
+    end
+
+    it 'raises no error when setting to nil' do
+      expect { subject.write(object, nil) }.to_not raise_error
+      expect(object.gender_cd).to be_nil
+    end
+
+    it 'raises ArgumentError when setting invalid key' do
+      expect { subject.write(object, :other) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/simple_enum/attribute_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+
+describe SimpleEnum::Attribute do
+  fake_model(:klass) { as_enum :gender, %w{male female}, with: [] }
+  let(:accessor) { subject.class.genders_accessor }
+
+  context '.as_enum' do
+    it 'returns a SimpleEnum::Enum' do
+      expect(klass.as_enum(:gender, %w{male female})).to be_a(SimpleEnum::Enum)
+    end
+  end
+
+  context '.register_generator' do
+    let(:mod) {
+      Module.new do
+        def generate_enum_spec_extension_for(enum, accessor)
+          module_eval { attr_accessor :some_reader }
+          simple_enum_module.module_eval do
+            define_method("extension_method") { "as_enum(#{enum.name})" }
+          end
+        end
+      end
+    }
+
+    before { SimpleEnum.register_generator :spec, mod }
+    after { described_class::EXTENSIONS.clear }
+
+    subject { klass.new }
+
+    it 'adds "spec" to EXTENSIONS' do
+      expect(described_class::EXTENSIONS).to eq %w{spec}
+    end
+
+    it 'calls generate_enum_spec_extension_for during as_enum' do
+      expect(subject.extension_method).to eq "as_enum(gender)"
+    end
+
+    it 'allows to add behavior to class itself (e.g. attr_accessor)' do
+      subject.some_reader = "some value"
+      expect(subject.some_reader).to eq "some value"
+    end
+  end
+
+  context 'generate_enum_class_accessors_for' do
+    context '.genders' do
+      subject { klass.genders }
+
+      it 'returns a SimpleEnum::Enum' do
+        expect(subject).to be_a(SimpleEnum::Enum)
+      end
+    end
+
+    context '.genders_accessor' do
+      subject { klass.genders_accessor }
+
+      it 'returns a SimpleEnum::Accessor' do
+        expect(subject).to be_a(SimpleEnum::Accessors::Accessor)
+      end
+    end
+  end
+
+  context 'generate_enum_instance_accessors_for' do
+    subject { klass.new(1) }
+
+    context '#gender' do
+      it 'delegates to accessor' do
+        expect(accessor).to receive(:read).with(subject) { :female }
+        expect(subject.gender).to eq :female
+      end
+    end
+
+    context '#gender=' do
+      it 'delegates to accessor' do
+        expect(accessor).to receive(:write).with(subject, :male) { 0 }
+        subject.gender = :male
+      end
+    end
+
+    context '#gender?' do
+      it 'delegates to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, nil) { nil }
+        expect(subject.gender?).to be_falsey
+      end
+    end
+  end
+
+  context 'generate_enum_dirty_methods_for' do
+    subject { klass.new }
+
+    it 'does not respond to #gender_changed?' do
+      expect(subject).to_not respond_to(:gender_changed?)
+    end
+
+    it 'does not responds to #gender_was' do
+      expect(subject).to_not respond_to(:gender_was)
+    end
+
+    context 'with: :dirty' do
+      fake_model(:klass_with_dirty) { as_enum :gender, %w{male female}, with: [:dirty] }
+      subject { klass_with_dirty.new }
+
+      it 'delegates #gender_changed? to accessor' do
+        expect(accessor).to receive(:changed?).with(subject) { true }
+        expect(subject.gender_changed?).to be_truthy
+      end
+
+      it 'delegates #gender_was to accesso' do
+        expect(accessor).to receive(:was).with(subject) { :female }
+        expect(subject.gender_was).to eq :female
+      end
+    end
+  end
+
+  context 'generate_enum_attribute_methods_for' do
+    subject { klass.new }
+
+    it 'does not respond to #male? or #female?' do
+      expect(subject).to_not respond_to(:male?)
+      expect(subject).to_not respond_to(:female?)
+    end
+
+    it 'does not respond to #male! or #female!' do
+      expect(subject).to_not respond_to(:male!)
+      expect(subject).to_not respond_to(:female!)
+    end
+
+    context 'with: :attribute' do
+      fake_model(:klass_with_attributes) { as_enum :gender, %w{male female}, with: [:attribute] }
+      subject { klass_with_attributes.new }
+
+      it 'delegates #gender? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, nil) { :female }
+        expect(subject.gender?).to be_truthy
+      end
+
+      it 'delegates #male? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'male') { true }
+        expect(subject.male?).to be_truthy
+      end
+
+      it 'delegates #female? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'female') { false }
+        expect(subject.female?).to be_falsey
+      end
+
+      it 'delegates #male! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'male') { 0 }
+        expect(subject.male!).to eq 0
+      end
+
+      it 'delegates #female! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'female') { 1 }
+        expect(subject.female!).to eq 1
+      end
+    end
+
+    context 'with a prefix' do
+      fake_model(:klass_with_prefix) { as_enum :gender, %w{male female}, with: [:attribute], prefix: true }
+      subject { klass_with_prefix.new }
+
+      it 'delegates #gender? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, nil) { :female }
+        expect(subject.gender?).to be_truthy
+      end
+
+      it 'delegates #gender_male? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'male') { true }
+        expect(subject.gender_male?).to be_truthy
+      end
+
+      it 'delegates #gender_female? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'female') { false }
+        expect(subject.gender_female?).to be_falsey
+      end
+
+      it 'delegates #gender_male! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'male') { 0 }
+        expect(subject.gender_male!).to eq 0
+      end
+
+      it 'delegates #gender_female! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'female') { 1 }
+        expect(subject.gender_female!).to eq 1
+      end
+    end
+  end
+
+  context 'generate_enum_scope_methods_for', active_record: true do
+    fake_active_record(:klass) {
+      as_enum :gender, [:male, :female], with: [:scope]
+    }
+
+    let(:accessor) { klass.genders_accessor }
+
+    shared_examples_for 'delegates to accessor#scope' do |value|
+      it 'delegates to #scope' do
+        expect(accessor).to receive(:scope).with(klass, value)
+        subject
+      end
+    end
+
+    context '.males' do
+      subject { klass.males }
+      it_behaves_like 'delegates to accessor#scope', 0
+    end
+
+    context '.females' do
+      subject { klass.females }
+      it_behaves_like 'delegates to accessor#scope', 1
+    end
+
+    context 'with prefix' do
+      fake_active_record(:klass) {
+        as_enum :gender, [:male, :female], with: [:scope], prefix: true
+      }
+
+      context '.gender_males' do
+        subject { klass.gender_males }
+        it_behaves_like 'delegates to accessor#scope', 0
+      end
+
+      context '.gender_females' do
+        subject { klass.gender_females }
+        it_behaves_like 'delegates to accessor#scope', 1
+      end
+
+      context 'and pluralize scopes option is set to false' do
+        fake_active_record(:klass) {
+          as_enum :gender, [:male, :female], with: [:scope], prefix: true, pluralize_scopes: false
+        }
+
+        context '.gender_male' do
+          subject { klass.gender_male }
+          it_behaves_like 'delegates to accessor#scope', 0
+        end
+
+        context '.gender_female' do
+          subject { klass.gender_female }
+          it_behaves_like 'delegates to accessor#scope', 1
+        end
+      end
+    end
+
+    context 'when pluralize scopes option is set to false' do
+      fake_active_record(:klass) {
+        as_enum :gender, [:male, :female], with: [:scope], pluralize_scopes: false
+      }
+
+      context '.male' do
+        subject { klass.male }
+        it_behaves_like 'delegates to accessor#scope', 0
+      end
+
+      context '.female' do
+        subject { klass.female }
+        it_behaves_like 'delegates to accessor#scope', 1
+      end
+    end
+
+    context 'without scope method' do
+      fake_model(:klass_without_scope_method) {
+        as_enum :gender, [:male, :female], with: [:scope]
+      }
+      subject { klass_without_scope_method }
+
+      it 'does not add .males nor .females' do
+        expect(subject).to_not respond_to(:males)
+        expect(subject).to_not respond_to(:females)
+      end
+    end
+  end
+end

data/spec/simple_enum/enum_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe SimpleEnum::Enum do
+  let(:hash) do
+    { "male" => 0, "female" => 1 }
+  end
+
+  fake_model(:klass)
+  let(:object) { klass.new }
+
+  subject { described_class.new(:gender, hash) }
+
+  context '#name' do
+    it 'returns the enum name as string' do
+      expect(subject.name).to eq 'gender'
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the name' do
+      expect(subject.to_s).to eq 'gender'
+    end
+  end
+
+  context '#hash' do
+    subject { described_class.new(:gender, hash).hash }
+
+    it 'returns hash that was set in the constructor' do
+      expect(subject).to be_a(Hash)
+      expect(subject.keys).to eq %w{male female}
+      expect(subject.values).to eq [0, 1]
+    end
+  end
+
+  context '#keys' do
+    it 'returns the keys in the order added' do
+      expect(subject.keys).to eq %w{male female}
+    end
+  end
+
+  context '#values' do
+    it 'returns the values in the order added' do
+      expect(subject.values).to eq [0, 1]
+    end
+  end
+
+  context '#each_pair (aliased to #each)' do
+    it 'yields twice with #each_pair' do
+      expect { |b| subject.each_pair(&b) }.to yield_control.exactly(2).times
+    end
+
+    it 'yields twice with #each' do
+      expect { |b| subject.each(&b) }.to yield_control.exactly(2).times
+    end
+  end
+
+  context '#value (aliased to #[])' do
+    it 'looks up by string' do
+      expect(subject.value('male')).to eq 0
+      expect(subject['male']).to eq 0
+    end
+
+    it 'looks up by symbol' do
+      expect(subject.value(:female)).to eq 1
+      expect(subject[:female]).to eq 1
+    end
+
+    it 'looks up by value' do
+      expect(subject.value(0)).to be 0
+      expect(subject[0]).to be 0
+    end
+
+    it 'returns nil when key is not found' do
+      expect(subject.value(:inexistent)).to be_nil
+      expect(subject[:inexistent]).to be_nil
+    end
+  end
+
+  context '#fetch' do
+    it 'looks up by string' do
+      expect(subject.fetch('male')).to eq 0
+    end
+
+    it 'looks up by symbol' do
+      expect(subject.fetch(:female)).to eq 1
+    end
+
+    it 'looks up by value' do
+      expect(subject.fetch(0)).to be 0
+    end
+
+    it 'throws exception when key is not found' do
+      expect{subject.fetch(:inexistent)}.to raise_error(/not found/i)
+    end
+  end
+
+  context '#key' do
+    it 'returns symbolized key for supplied value' do
+      expect(subject.key(0)).to eq :male
+      expect(subject.key(1)).to eq :female
+    end
+
+    it 'returns nil if value is not found' do
+      expect(subject.key(12)).to be_nil
+    end
+  end
+
+  context '#include?' do
+    it 'returns true by string' do
+      expect(subject.include?('male')).to be_truthy
+    end
+
+    it 'returns true by symbol' do
+      expect(subject.include?(:female)).to be_truthy
+    end
+
+    it 'returns true by checking actual value' do
+      expect(subject.include?(1)).to be_truthy
+    end
+
+    it 'returns false when neither in keys nor values' do
+      expect(subject.include?(:other)).to be_falsey
+      expect(subject.include?(2)).to be_falsey
+    end
+  end
+
+  context '#values_at' do
+    it 'fetches multiple values by string' do
+      expect(subject.values_at("male", "female")).to eq [0, 1]
+    end
+
+    it 'fetches multiple values by symbol' do
+      expect(subject.values_at(:male)).to eq [0]
+    end
+  end
+end