flex_columns 1.0.0

data/spec/flex_columns/unit/contents/flex_column_contents_base_spec.rb

@@ -0,0 +1,253 @@
+require 'flex_columns'
+require 'flex_columns/helpers/exception_helpers'
+
+describe FlexColumns::Contents::FlexColumnContentsBase do
+  include FlexColumns::Helpers::ExceptionHelpers
+
+  before :each do
+    @klass = Class.new(FlexColumns::Contents::FlexColumnContentsBase)
+  end
+
+  it "should include ActiveModel::Validations" do
+    @klass.included_modules.map(&:name).include?("ActiveModel::Validations").should be
+  end
+
+  it "should extend FlexColumnContentsClass" do
+    @klass.respond_to?(:is_flex_column_class?).should be
+    @klass.is_flex_column_class?.should be
+  end
+
+  context "with a set-up class" do
+    before :each do
+      @model_class = Class.new
+      allow(@klass).to receive(:model_class).with().and_return(@model_class)
+      allow(@klass).to receive(:column_name).with().and_return(:fcn)
+
+      @json_string = '{"foo":"bar","bar":"baz"}'
+
+      @model_instance = @model_class.new
+      allow(@model_instance).to receive(:[]).with(:fcn).and_return(@json_string)
+
+      @column_data = double("column_data")
+    end
+
+    def expect_column_data_creation(input)
+      expect(@klass).to receive(:_flex_columns_create_column_data).once do |*args|
+        args.length.should == 2
+        args[0].should == input
+        args[1].class.should be(@klass)
+
+        @column_data
+      end
+    end
+
+    describe "#initialize" do
+      it "should accept nil" do
+        expect_column_data_creation(nil)
+        @klass.new(nil)
+      end
+
+      it "should accept a String" do
+        source_string = " foo "
+        expect_column_data_creation(source_string)
+        @klass.new(source_string)
+      end
+
+      it "should accept a model of the right class" do
+        expect_column_data_creation(@json_string)
+        @klass.new(@model_instance)
+      end
+
+      it "should not accept a model of the wrong class" do
+        wrong_model_class = Class.new
+        allow(@model_class).to receive(:name).and_return("bongo")
+        wrong_model_instance = wrong_model_class.new
+        class << wrong_model_instance
+          def to_s
+            "whatevs"
+          end
+          def inspect
+            "whatevs"
+          end
+        end
+        e = capture_exception(ArgumentError) { @klass.new(wrong_model_instance) }
+        e.message.should match(/bongo/i)
+        e.message.should match(/whatevs/i)
+      end
+    end
+
+    describe "#describe_flex_column_data_source" do
+      it "should work with a model instance" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@model_instance)
+
+        allow(@model_class).to receive(:name).with().and_return("mcname")
+        allow(@model_instance).to receive(:id).with().and_return("mcid")
+        s = @instance.describe_flex_column_data_source
+
+        s.should match(/mcname/)
+        s.should match(/mcid/)
+        s.should match(/fcn/)
+      end
+
+      it "should work with a raw string" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@json_string)
+
+        allow(@model_class).to receive(:name).with().and_return("mcname")
+        s = @instance.describe_flex_column_data_source
+        s.should match(/mcname/)
+        s.should match(/fcn/)
+      end
+    end
+
+    describe "#notification_hash_for_flex_column_data_source" do
+      it "should work with a model instance" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@model_instance)
+
+        h = @instance.notification_hash_for_flex_column_data_source
+        h.keys.sort_by(&:to_s).should == [ :model_class, :column_name, :model ].sort_by(&:to_s)
+        h[:model_class].should be(@model_class)
+        h[:column_name].should == :fcn
+        h[:model].should be(@model_instance)
+      end
+
+      it "should work with a raw string" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@json_string)
+
+        h = @instance.notification_hash_for_flex_column_data_source
+        h.keys.sort_by(&:to_s).should == [ :model_class, :column_name, :source ].sort_by(&:to_s)
+        h[:model_class].should be(@model_class)
+        h[:column_name].should == :fcn
+        h[:source].should == @json_string
+      end
+    end
+
+    describe "#before_validation!" do
+      it "should do nothing if created with a raw string" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@json_string)
+        @instance.before_validation!
+      end
+
+      it "should do nothing if the instance is valid" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@model_instance)
+
+        expect(@instance).to receive(:valid?).once.with().and_return(true)
+        @instance.before_validation!
+      end
+
+      it "should copy errors over if the instance is invalid" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@model_instance)
+
+        expect(@instance).to receive(:valid?).once.with().and_return(false)
+        allow(@instance).to receive(:errors).with().and_return({ :e1 => :m1, :e2 => :m2 })
+
+        errors = Object.new
+        class << errors
+          def add(k, v)
+            @_errors ||= [ ]
+            @_errors << [ k, v ]
+          end
+
+          def all_errors
+            @_errors
+          end
+        end
+
+        allow(@model_instance).to receive(:errors).with().and_return(errors)
+
+        @instance.before_validation!
+        all_errors = errors.all_errors
+        all_errors.length.should == 2
+
+        e1 = all_errors.detect { |e| e[0] == "fcn.e1" }
+        e1[1].should == :m1
+
+        e2 = all_errors.detect { |e| e[0] == "fcn.e2" }
+        e2[1].should == :m2
+      end
+    end
+
+    describe "#before_save!" do
+      it "should do nothing if created with a raw string" do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@json_string)
+
+        @instance.before_save!
+      end
+
+      context "with a valid instance" do
+        before :each do
+          expect_column_data_creation(@json_string)
+          @instance = @klass.new(@model_instance)
+          allow(@model_instance).to receive(:_flex_column_object_for).with(:fcn, false).and_return(@instance)
+        end
+
+        it "should tell you if it's been touched" do
+          expect(@column_data).to receive(:touched?).once.with().and_return(true)
+          @instance.touched?.should be
+          expect(@column_data).to receive(:touched?).once.with().and_return(false)
+          @instance.touched?.should_not be
+        end
+
+        it "should save if the class tells it to" do
+          expect(@klass).to receive(:requires_serialization_on_save?).once.with(@model_instance).and_return(true)
+          expect(@column_data).to receive(:to_stored_data).once.with().and_return("somestoreddata")
+          expect(@model_instance).to receive(:[]=).once.with(:fcn, "somestoreddata")
+          @instance.before_save!
+        end
+
+        it "should not save if the class tells it not to" do
+          expect(@klass).to receive(:requires_serialization_on_save?).once.with(@model_instance).and_return(false)
+          @instance.before_save!
+        end
+      end
+    end
+
+    context "with a valid instance" do
+      before :each do
+        expect_column_data_creation(@json_string)
+        @instance = @klass.new(@model_instance)
+      end
+
+      it "should return itself for #to_model" do
+        @instance.to_model.should be(@instance)
+      end
+
+      it "should delegate to the column data on []" do
+        expect(@column_data).to receive(:[]).once.with(:xxx).and_return(:yyy)
+        @instance[:xxx].should == :yyy
+      end
+
+      it "should delegate to the column data on []=" do
+        expect(@column_data).to receive(:[]=).once.with(:xxx, :yyy).and_return(:zzz)
+        (@instance[:xxx] = :yyy).should == :yyy
+      end
+
+      it "should delegate to the column data on #touch!" do
+        expect(@column_data).to receive(:touch!).once.with()
+        @instance.touch!
+      end
+
+      it "should delegate to the column data on #to_json" do
+        expect(@column_data).to receive(:to_json).once.with().and_return("somejsondata")
+        @instance.to_json.should == "somejsondata"
+      end
+
+      it "should delegate to the column data on #to_stored_data" do
+        expect(@column_data).to receive(:to_stored_data).once.with().and_return("somestoreddata")
+        @instance.to_stored_data.should == "somestoreddata"
+      end
+
+      it "should delegate to the column data on #keys" do
+        expect(@column_data).to receive(:keys).once.with().and_return([ :a, :z, :q ])
+        @instance.keys.should == [ :a, :z, :q ]
+      end
+    end
+  end
+end

data/spec/flex_columns/unit/definition/field_definition_spec.rb

@@ -0,0 +1,617 @@
+require 'flex_columns'
+require 'flex_columns/helpers/exception_helpers'
+
+describe FlexColumns::Definition::FieldDefinition do
+  include FlexColumns::Helpers::ExceptionHelpers
+
+  def klass
+    FlexColumns::Definition::FieldDefinition
+  end
+
+  it "should normalize names properly" do
+    lambda { klass.normalize_name(nil) }.should raise_error(ArgumentError)
+    lambda { klass.normalize_name(123) }.should raise_error(ArgumentError)
+    klass.normalize_name("  FoO ").should == :foo
+    klass.normalize_name(:foo).should == :foo
+  end
+
+  before :each do
+    @flex_column_class = double("flex_column_class")
+    allow(@flex_column_class).to receive(:is_flex_column_class?).with().and_return(true)
+  end
+
+  describe "#initialize" do
+    it "should validate its arguments" do
+      non_fcc = double("flex_column_class")
+      lambda { klass.new(non_fcc, :foo, [ ], { }) }.should raise_error(ArgumentError)
+
+      non_fcc = double("flex_column_class")
+      allow(non_fcc).to receive(:is_flex_column_class?).with().and_return(false)
+      lambda { klass.new(non_fcc, :foo, [ ], { }) }.should raise_error(ArgumentError)
+
+      lambda { klass.new(@flex_column_class, :foo, [ ], { :foo => :bar }) }.should raise_error(ArgumentError)
+
+      lambda { klass.new(@flex_column_class, :foo, [ ], { :visibility => 123 }) }.should raise_error(ArgumentError)
+      lambda { klass.new(@flex_column_class, :foo, [ ], { :visibility => true }) }.should raise_error(ArgumentError)
+
+      lambda { klass.new(@flex_column_class, :foo, [ ], { :json => 123 }) }.should raise_error(ArgumentError)
+
+      lambda { klass.new(@flex_column_class, :foo, [ ], { :null => 123 }) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if there are additional arguments" do
+      expect(@flex_column_class).to receive(:validates).once.with(:foo, { :numericality => { :only_integer => true }})
+      lambda { klass.new(@flex_column_class, :foo, [ :integer, :bar ], { }) }.should raise_error(ArgumentError)
+    end
+
+    describe "types support" do
+      it "should raise an error if given an invalid type" do
+        lambda { klass.new(@flex_column_class, :foo, [ :bar ], { }) }.should raise_error(ArgumentError)
+      end
+
+      it "should force a value to be present if :null => false" do
+        expect(@flex_column_class).to receive(:validates).once.with(:foo, { :presence => true })
+        klass.new(@flex_column_class, :foo, [ ], { :null => false })
+      end
+
+      it "should force a value to be in an :enum list" do
+        expect(@flex_column_class).to receive(:validates).once.with(:foo, { :inclusion => { :in => %w{a b c} } })
+        klass.new(@flex_column_class, :foo, [ ], { :enum => %w{a b c} })
+      end
+
+      it "should force a value to be of a maximum length" do
+        expect(@flex_column_class).to receive(:validates).once.with(:foo, { :length => { :maximum => 123 } })
+        klass.new(@flex_column_class, :foo, [ ], { :limit => 123 })
+      end
+
+      def expect_validation(type, arguments)
+        expect(@flex_column_class).to receive(:validates).once.with(:foo, arguments)
+        klass.new(@flex_column_class, :foo, [ type ], { })
+      end
+
+      it "should validate integers properly" do
+        expect_validation(:integer, { :numericality => { :only_integer => true } })
+      end
+
+      it "should validate floats properly" do
+        expect_validation(:float, { :numericality => true, :allow_nil => true })
+      end
+
+      it "should validate decimals properly" do
+        expect_validation(:decimal, { :numericality => true, :allow_nil => true })
+      end
+
+      it "should validate booleans properly" do
+        expect_validation(:boolean, { :inclusion => { :in => [ true, false, nil ] }})
+      end
+
+      def check_validation_block(type, input, expected_error)
+        validation_block = nil
+        expect(@flex_column_class).to receive(:validates_each).once.with(:foo) do |&block|
+          validation_block = block
+        end
+
+        klass.new(@flex_column_class, :foo, [ type.to_sym ], { })
+
+        record = double("record")
+        errors = double("errors")
+
+        allow(record).to receive(:errors).with().and_return(errors)
+
+        if expected_error
+          expect(errors).to receive(:add).once.with(:foo, expected_error)
+        end
+
+        validation_block.call(record, :foo, input)
+      end
+
+      %w{string text}.each do |type|
+        it "should validate fields of type #{type} properly" do
+          check_validation_block(type, "aaa", nil)
+          check_validation_block(type, :aaa, nil)
+          check_validation_block(type, nil, nil)
+          check_validation_block(type, 123, "must be a String")
+        end
+      end
+
+      it "should validate dates correctly" do
+        check_validation_block(:date, nil, nil)
+        check_validation_block(:date, Date.today, nil)
+        check_validation_block(:date, Time.now, "must be a Date")
+        check_validation_block(:date, DateTime.now, nil)
+        check_validation_block(:date, 123, "must be a Date")
+      end
+
+      it "should validate times correctly" do
+        check_validation_block(:time, nil, nil)
+        check_validation_block(:time, Date.today, "must be a Time")
+        check_validation_block(:time, Time.now, nil)
+        check_validation_block(:time, DateTime.now, "must be a Time")
+        check_validation_block(:time, 123, "must be a Time")
+      end
+
+      %w{timestamp datetime}.each do |type|
+        it "should validate fields of type #{type} properly" do
+          check_validation_block(type, nil, nil)
+          check_validation_block(type, Time.now, nil)
+
+          check_validation_block(type, DateTime.now, nil)
+
+          check_validation_block(type, 123, "must be a Time or DateTime")
+          check_validation_block(type, Date.today, "must be a Time or DateTime")
+        end
+      end
+    end
+  end
+
+  it "should return the JSON storage name from #json_storage_name" do
+    klass.new(@flex_column_class, :foo, [ ], { }).json_storage_name.should == :foo
+    klass.new(@flex_column_class, :foo, [ ], { :json => :bar }).json_storage_name.should == :bar
+  end
+
+  describe "#add_methods_to_flex_column_class!" do
+    before :each do
+      @dmm = Class.new do
+        class << self; public :define_method, :private; end
+
+        def initialize(h)
+          @h = h
+        end
+
+        def [](x)
+          @h[x]
+        end
+
+        def []=(x, y)
+          @h[x] = y
+        end
+      end
+    end
+
+    it "should define methods on the flex-column class" do
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(false)
+      klass.new(@flex_column_class, :foo, [ ], { :json => :bar }).add_methods_to_flex_column_class!(@dmm)
+
+      instance = @dmm.new(:foo => 123)
+      instance.foo.should == 123
+      instance.foo = 234
+      instance.foo.should == 234
+    end
+
+    it "should define methods on the flex-column class privately if the flex-column says to" do
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(true)
+      klass.new(@flex_column_class, :foo, [ ], { :json => :bar }).add_methods_to_flex_column_class!(@dmm)
+
+      instance = @dmm.new(:foo => 123)
+
+      lambda { instance.foo }.should raise_error(NoMethodError)
+      lambda { instance.foo = 123 }.should raise_error(NoMethodError)
+
+      instance.send(:foo).should == 123
+      instance.send(:foo=, 234)
+      instance.send(:foo).should == 234
+    end
+
+    it "should define methods on the flex-column class privately if the field says to" do
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(false)
+      klass.new(@flex_column_class, :foo, [ ], { :json => :bar, :visibility => :private }).add_methods_to_flex_column_class!(@dmm)
+
+      instance = @dmm.new(:foo => 123)
+
+      lambda { instance.foo }.should raise_error(NoMethodError)
+      lambda { instance.foo = 123 }.should raise_error(NoMethodError)
+
+      instance.send(:foo).should == 123
+      instance.send(:foo=, 234)
+      instance.send(:foo).should == 234
+    end
+
+    it "should define methods on the flex-column class publicly if the field says to" do
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(true)
+      klass.new(@flex_column_class, :foo, [ ], { :json => :bar, :visibility => :public }).add_methods_to_flex_column_class!(@dmm)
+
+      instance = @dmm.new(:foo => 123)
+      instance.foo.should == 123
+      instance.foo = 234
+      instance.foo.should == 234
+    end
+  end
+
+  describe "#add_methods_to_model_class!" do
+    before :each do
+      @dmm = Class.new do
+        class << self; public :define_method, :private; end
+      end
+
+      @model_class = double("model_class")
+    end
+
+    def check_add_methods_to_model_class(options)
+      create_options = options[:create_options]
+      fields_are_private_by_default = options[:fields_are_private_by_default] || false
+      safe_to_define = if options.has_key?(:safe_to_define) then options[:safe_to_define] else true end
+      delegation_type = options[:delegation_type]
+      delegation_prefix = options[:delegation_prefix]
+      method_name = options[:method_name]
+      should_be_private = options[:should_be_private]
+      method_should_exist = if options.has_key?(:method_should_exist) then options[:method_should_exist] else true end
+
+      flex_instance = { }
+      field = klass.new(@flex_column_class, :foo, [ ], create_options)
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(fields_are_private_by_default)
+
+      allow(@model_class).to receive(:_flex_columns_safe_to_define_method?).with(method_name.to_sym).and_return(safe_to_define)
+      allow(@model_class).to receive(:_flex_columns_safe_to_define_method?).with("#{method_name}=".to_sym).and_return(safe_to_define)
+      allow(@flex_column_class).to receive(:delegation_type).with().and_return(delegation_type)
+      allow(@flex_column_class).to receive(:delegation_prefix).with().and_return(delegation_prefix)
+
+      field.add_methods_to_model_class!(@dmm, @model_class)
+
+      instance = @dmm.new
+      allow(@flex_column_class).to receive(:object_for).with(instance).and_return(flex_instance)
+
+      if (! method_should_exist)
+        lambda { instance.send(method_name) }.should raise_error(NoMethodError)
+        lambda { instance.send("#{method_name}=", 123) }.should raise_error(NoMethodError)
+      elsif should_be_private
+        lambda { eval("instance.#{method_name}") }.should raise_error(NoMethodError)
+        lambda { eval("instance.#{method_name} = 123") }.should raise_error(NoMethodError)
+        instance.send(method_name).should be_nil
+        instance.send("#{method_name}=", 123).should == 123
+        instance.send(method_name).should == 123
+      else
+        eval("instance.#{method_name}").should be_nil
+        eval("instance.#{method_name} = 123").should == 123
+        eval("instance.#{method_name}").should == 123
+      end
+    end
+
+    it "should define a very standard public method just fine" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :safe_to_define => true,
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => false
+      )
+    end
+
+    it "should define a private method if asked to on the field" do
+      check_add_methods_to_model_class(
+        :create_options => { :visibility => :private },
+        :fields_are_private_by_default => false,
+        :safe_to_define => true,
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => true
+      )
+    end
+
+    it "should define a private method if fields are private by default" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => true,
+        :safe_to_define => true,
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => true
+      )
+    end
+
+    it "should define a private method if fields are private by default, but the specific field is public" do
+      check_add_methods_to_model_class(
+        :create_options => { :visibility => :public },
+        :fields_are_private_by_default => true,
+        :safe_to_define => true,
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => false
+      )
+    end
+
+    it "should define a private method if delegation is private" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :safe_to_define => true,
+        :delegation_type => :private,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => true
+      )
+    end
+
+    it "should not define a method if delegation is off" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :safe_to_define => true,
+        :delegation_type => nil,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => false,
+        :method_should_exist => false
+      )
+    end
+
+    it "should not define a method if it's not safe to do so" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :safe_to_define => false,
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :method_name => :foo,
+        :should_be_private => false,
+        :method_should_exist => false
+      )
+    end
+
+    it "should prefix the method if requested" do
+      check_add_methods_to_model_class(
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :safe_to_define => true,
+        :delegation_type => :public,
+        :delegation_prefix => :aaa,
+        :method_name => :aaa_foo,
+        :should_be_private => false,
+        :method_should_exist => true
+      )
+    end
+  end
+
+  describe "#add_methods_to_included_class!" do
+    def check_add_methods_to_included_class(options)
+      delegation_type = options[:delegation_type]
+      delegation_prefix = options[:delegation_prefix]
+      create_options = options[:create_options]
+      fields_are_private_by_default = options[:fields_are_private_by_default] || false
+      method_name = options[:method_name]
+      safe_to_define = options[:safe_to_define]
+      include_options = options[:include_options]
+      method_should_exist = options[:method_should_exist]
+      should_be_private = options[:should_be_private]
+
+      allow(@flex_column_class).to receive(:delegation_type).with().and_return(delegation_type)
+      allow(@flex_column_class).to receive(:delegation_prefix).with().and_return(delegation_prefix)
+      allow(@flex_column_class).to receive(:fields_are_private_by_default?).with().and_return(fields_are_private_by_default)
+
+      @model_class = double("model_class")
+      allow(@model_class).to receive(:name).with().and_return("mcname")
+      allow(@flex_column_class).to receive(:model_class).with().and_return(@model_class)
+      allow(@flex_column_class).to receive(:column_name).with().and_return(:colname)
+
+      target_class = double("target_class")
+      allow(target_class).to receive(:_flex_columns_safe_to_define_method?).with(method_name.to_sym).and_return(safe_to_define)
+      allow(target_class).to receive(:_flex_columns_safe_to_define_method?).with("#{method_name}=".to_sym).and_return(safe_to_define)
+
+      associated_object = double("associated_object")
+
+      @dmm = Class.new do
+        def ao=(x)
+          @associated_object = x
+        end
+
+        def ao
+          @associated_object
+        end
+
+        def bao=(x)
+          @build_associated_object = x
+        end
+
+        def build_ao
+          @build_associated_object
+        end
+
+        class << self; public :define_method, :private; end
+      end
+
+      field = klass.new(@flex_column_class, :foo, [ ], create_options)
+      field.add_methods_to_included_class!(@dmm, :ao, target_class, include_options)
+
+      instance = @dmm.new
+
+      if options[:use_build]
+        instance.bao = associated_object
+      else
+        instance.ao = associated_object
+      end
+
+      flex_instance = Object.new
+      class << flex_instance
+        def foo=(x)
+          @foo = x
+        end
+
+        def foo
+          @foo
+        end
+      end
+
+      allow(associated_object).to receive(:colname).and_return(flex_instance)
+
+      if (! method_should_exist)
+        lambda { instance.send(method_name) }.should raise_error(NoMethodError)
+        lambda { instance.send("#{method_name}=", 123) }.should raise_error(NoMethodError)
+      elsif should_be_private
+        lambda { eval("instance.#{method_name}") }.should raise_error(NoMethodError)
+        lambda { eval("instance.#{method_name} = 123") }.should raise_error(NoMethodError)
+        instance.send(method_name).should be_nil
+        instance.send("#{method_name}=", 123).should == 123
+        instance.send(method_name).should == 123
+      else
+        eval("instance.#{method_name}").should be_nil
+        eval("instance.#{method_name} = 123").should == 123
+        eval("instance.#{method_name}").should == 123
+      end
+    end
+
+    it "should define a very standard public method just fine" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => false
+      )
+    end
+
+    it "should define a private method if the field is private" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { :visibility => :private },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => true
+      )
+    end
+
+    it "should define a private method if the flex column is private" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { },
+        :fields_are_private_by_default => true,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => true
+      )
+    end
+
+    it "should define a public method if the flex column is private but the field is public" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { :visibility => :public },
+        :fields_are_private_by_default => true,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => false
+      )
+    end
+
+    it "should default to the flex-column prefix" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => :aaa,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :aaa_foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => false
+      )
+    end
+
+    it "should override to the flex-column prefix if requested" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => :aaa,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :bbb_foo,
+        :safe_to_define => true,
+        :include_options => { :prefix => :bbb },
+        :method_should_exist => true,
+        :should_be_private => false
+      )
+    end
+
+    it "should override to the flex-column prefix with no prefix if requested" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => :aaa,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { :prefix => nil },
+        :method_should_exist => true,
+        :should_be_private => false
+      )
+    end
+
+    it "should raise if you ask for public methods from a private field" do
+      e = capture_exception(ArgumentError) do
+        check_add_methods_to_included_class(
+          :delegation_type => :public,
+          :delegation_prefix => nil,
+          :create_options => { },
+          :fields_are_private_by_default => true,
+          :method_name => :foo,
+          :safe_to_define => true,
+          :include_options => { :visibility => :public },
+          :method_should_exist => true,
+          :should_be_private => true
+        )
+      end
+
+      e.message.should match(/ao/i)
+      e.message.should match(/mcname/i)
+      e.message.should match(/colname/i)
+    end
+
+    it "should skip defining methods if there's no delegation" do
+      check_add_methods_to_included_class(
+        :delegation_type => nil,
+        :delegation_prefix => nil,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => false,
+        :should_be_private => false
+      )
+    end
+
+    it "should skip defining methods if it's not safe" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => false,
+        :include_options => { },
+        :method_should_exist => false,
+        :should_be_private => false
+      )
+    end
+
+    it "should build the association if needed" do
+      check_add_methods_to_included_class(
+        :delegation_type => :public,
+        :delegation_prefix => nil,
+        :create_options => { },
+        :fields_are_private_by_default => false,
+        :method_name => :foo,
+        :safe_to_define => true,
+        :include_options => { },
+        :method_should_exist => true,
+        :should_be_private => false,
+        :use_build => true
+      )
+    end
+  end
+end