flex_columns 1.0.0

data/spec/flex_columns/unit/errors_spec.rb

@@ -0,0 +1,297 @@
+require 'flex_columns'
+
+describe FlexColumns::Errors do
+  def should_be_a_subclass(klass, expected_superclass)
+    current = klass
+
+    while current != expected_superclass && current != Object
+      current = current.superclass
+    end
+
+    if current == Object
+      raise "Expected #{klass} to have #{expected_superclass} as a superclass, but it doesn't"
+    end
+  end
+
+  before :each do
+    @data_source = double("data_source")
+    allow(@data_source).to receive(:describe_flex_column_data_source).with().and_return("dfcds")
+  end
+
+  describe FlexColumns::Errors::FieldError do
+    it "should inherit from Base" do
+      should_be_a_subclass(FlexColumns::Errors::FieldError, FlexColumns::Errors::Base)
+    end
+  end
+
+  describe FlexColumns::Errors::NoSuchFieldError do
+    it "should inherit from FieldError" do
+      should_be_a_subclass(FlexColumns::Errors::NoSuchFieldError, FlexColumns::Errors::FieldError)
+    end
+
+    it "should take data_source, data_name, and all_field_names, and use them in its message" do
+      instance = FlexColumns::Errors::NoSuchFieldError.new(@data_source, :foo, [ :bar, :baz, :quux ])
+      instance.message.should match(/dfcds/i)
+      instance.message.should match(/foo/i)
+      instance.message.should match(/bar.*baz.*quux/i)
+
+      instance.data_source.should be(@data_source)
+      instance.field_name.should == :foo
+      instance.all_field_names.should == [ :bar, :baz, :quux ]
+    end
+  end
+
+  describe FlexColumns::Errors::ConflictingJsonStorageNameError do
+    it "should inherit from FieldError" do
+      should_be_a_subclass(FlexColumns::Errors::ConflictingJsonStorageNameError, FlexColumns::Errors::FieldError)
+    end
+
+    it "should take model_class, column_name, new_field_name, existing_field_name, and json_storage_name" do
+      model_class = double("model_class")
+      allow(model_class).to receive(:name).with().and_return("mcname")
+
+      instance = FlexColumns::Errors::ConflictingJsonStorageNameError.new(model_class, :foo, :bar, :baz, :quux)
+      instance.model_class.should be(model_class)
+      instance.column_name.should == :foo
+      instance.new_field_name.should == :bar
+      instance.existing_field_name.should == :baz
+      instance.json_storage_name.should == :quux
+
+      instance.message.should match(/mcname/i)
+      instance.message.should match(/foo/i)
+      instance.message.should match(/bar/i)
+      instance.message.should match(/baz/i)
+      instance.message.should match(/quux/i)
+    end
+  end
+
+  describe FlexColumns::Errors::DefinitionError do
+    it "should inherit from Base" do
+      should_be_a_subclass(FlexColumns::Errors::DefinitionError, FlexColumns::Errors::Base)
+    end
+  end
+
+  describe FlexColumns::Errors::NoSuchColumnError do
+    it "should inherit from DefinitionError" do
+      should_be_a_subclass(FlexColumns::Errors::NoSuchColumnError, FlexColumns::Errors::DefinitionError)
+    end
+  end
+
+  describe FlexColumns::Errors::InvalidColumnTypeError do
+    it "should inherit from DefinitionError" do
+      should_be_a_subclass(FlexColumns::Errors::InvalidColumnTypeError, FlexColumns::Errors::DefinitionError)
+    end
+  end
+
+  describe FlexColumns::Errors::DataError do
+    it "should inherit from Base" do
+      should_be_a_subclass(FlexColumns::Errors::DataError, FlexColumns::Errors::Base)
+    end
+  end
+
+  describe FlexColumns::Errors::JsonTooLongError do
+    it "should inherit from DataError" do
+      should_be_a_subclass(FlexColumns::Errors::JsonTooLongError, FlexColumns::Errors::DataError)
+    end
+
+    it "should take data_source, limit, and json_string" do
+      instance = FlexColumns::Errors::JsonTooLongError.new(@data_source, 123, "a" * 10_000)
+      instance.data_source.should be(@data_source)
+      instance.limit.should == 123
+      instance.json_string.should == "a" * 10_000
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/123/)
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 30)
+    end
+  end
+
+  describe FlexColumns::Errors::InvalidDataInDatabaseError do
+    it "should inherit from DataError" do
+      should_be_a_subclass(FlexColumns::Errors::InvalidDataInDatabaseError, FlexColumns::Errors::DataError)
+    end
+
+    it "should take data_source, raw_string, and additional_message" do
+      instance = FlexColumns::Errors::InvalidDataInDatabaseError.new(@data_source, "aaa" * 1_000, "holy hell")
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == "aaa" * 1_000
+      instance.additional_message.should == "holy hell"
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 20)
+      instance.message.should match(/holy hell/)
+    end
+  end
+
+  describe FlexColumns::Errors::InvalidCompressedDataInDatabaseError do
+    it "should inherit from InvalidDataInDatabaseError" do
+      should_be_a_subclass(FlexColumns::Errors::InvalidCompressedDataInDatabaseError, FlexColumns::Errors::InvalidDataInDatabaseError)
+    end
+
+    it "should take data_source, raw_string, and source_exception" do
+      source_exception = double("source_exception")
+      source_exception_class = double("source_exception_class")
+      allow(source_exception_class).to receive(:name).with().and_return("secname")
+      allow(source_exception).to receive(:class).with().and_return(source_exception_class)
+      allow(source_exception).to receive(:to_s).with().and_return("seto_s")
+
+      instance = FlexColumns::Errors::InvalidCompressedDataInDatabaseError.new(@data_source, "a" * 1_000, source_exception)
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == "a" * 1_000
+      instance.source_exception.should be(source_exception)
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 20)
+      instance.message.should match(/secname/)
+      instance.message.should match(/seto_s/)
+    end
+  end
+
+  describe FlexColumns::Errors::InvalidFlexColumnsVersionNumberInDatabaseError do
+    it "should inherit from InvalidDataInDatabaseError" do
+      should_be_a_subclass(FlexColumns::Errors::InvalidFlexColumnsVersionNumberInDatabaseError, FlexColumns::Errors::InvalidDataInDatabaseError)
+    end
+
+    it "should take data_source, raw_string, version_number_in_database, max_version_number_supported" do
+      instance = FlexColumns::Errors::InvalidFlexColumnsVersionNumberInDatabaseError.new(@data_source, "a" * 1_000, 17, 15)
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == "a" * 1_000
+      instance.version_number_in_database.should == 17
+      instance.max_version_number_supported.should == 15
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 20)
+      instance.message.should match(/17/)
+      instance.message.should match(/15/)
+    end
+  end
+
+  describe FlexColumns::Errors::UnparseableJsonInDatabaseError do
+    it "should inherit from InvalidDataInDatabaseError" do
+      should_be_a_subclass(FlexColumns::Errors::UnparseableJsonInDatabaseError, FlexColumns::Errors::InvalidDataInDatabaseError)
+    end
+
+    it "should take data_source, raw_string, and source_exception" do
+      source_exception = double("source_exception")
+      source_exception_class = double("source_exception_class")
+      allow(source_exception_class).to receive(:name).with().and_return("secname")
+      allow(source_exception).to receive(:class).with().and_return(source_exception_class)
+      allow(source_exception).to receive(:message).with().and_return("semessage")
+
+      instance = FlexColumns::Errors::UnparseableJsonInDatabaseError.new(@data_source, "a" * 1_000, source_exception)
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == "a" * 1_000
+      instance.source_exception.should be(source_exception)
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 20)
+      instance.message.should match(/secname/)
+      instance.message.should match(/semessage/)
+    end
+
+    it "should strip out characters that aren't of a valid encoding" do
+      source_exception = double("source_exception")
+      source_exception_class = double("source_exception_class")
+      allow(source_exception_class).to receive(:name).with().and_return("secname")
+      allow(source_exception).to receive(:class).with().and_return(source_exception_class)
+
+      source_message = double("source_message")
+      expect(source_message).to receive(:force_encoding).once.with("UTF-8")
+      chars = [ double("char-a"), double("char-b"), double("char-c") ]
+      allow(chars[0]).to receive(:valid_encoding?).with().and_return(true)
+      allow(chars[0]).to receive(:to_s).with().and_return("X")
+      allow(chars[0]).to receive(:inspect).with().and_return("X")
+      allow(chars[1]).to receive(:valid_encoding?).with().and_return(false)
+      allow(chars[2]).to receive(:valid_encoding?).with().and_return(true)
+      allow(chars[2]).to receive(:to_s).with().and_return("Z")
+      allow(chars[2]).to receive(:inspect).with().and_return("Z")
+      allow(source_message).to receive(:chars).with().and_return(chars)
+
+      allow(source_exception).to receive(:message).with().and_return(source_message)
+
+      instance = FlexColumns::Errors::UnparseableJsonInDatabaseError.new(@data_source, "a" * 1_000, source_exception)
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == "a" * 1_000
+      instance.source_exception.should be(source_exception)
+
+      instance.message.length.should < 1_000
+      instance.message.should match(/dfcds/)
+      instance.message.should match("a" * 20)
+      instance.message.should match(/secname/)
+      instance.message.should match(/XZ/)
+    end
+  end
+
+  describe FlexColumns::Errors::IncorrectlyEncodedStringInDatabaseError do
+    it "should inherit from InvalidDataInDatabaseError" do
+      should_be_a_subclass(FlexColumns::Errors::IncorrectlyEncodedStringInDatabaseError, FlexColumns::Errors::InvalidDataInDatabaseError)
+    end
+
+    it "should take data_source and raw_string, and analyze the string" do
+      chars = [ ]
+      200.times { |i| chars << double("char-#{i}") }
+      chars.each_with_index do |char, i|
+        allow(char).to receive(:valid_encoding?).with().and_return(true)
+        allow(char).to receive(:to_s).with().and_return((65 + (i % 26)).chr)
+        allow(char).to receive(:inspect).with().and_return((65 + (i % 26)).chr)
+      end
+
+      [ 53, 68, 95 ].each do |bad_char_pos|
+        allow(chars[bad_char_pos]).to receive(:valid_encoding?).with().and_return(false)
+        allow(chars[bad_char_pos]).to receive(:unpack).with("H*").and_return("UPC#{bad_char_pos}")
+      end
+
+      allow(chars[53]).to receive(:valid_encoding?).with().and_return(false)
+      allow(chars[68]).to receive(:valid_encoding?).with().and_return(false)
+      allow(chars[95]).to receive(:valid_encoding?).with().and_return(false)
+
+      raw_string = double("raw_string")
+      allow(raw_string).to receive(:chars).with().and_return(chars)
+
+      instance = FlexColumns::Errors::IncorrectlyEncodedStringInDatabaseError.new(@data_source, raw_string)
+
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should match(/^ABCDEF/)
+      instance.raw_string.length.should == 197
+      instance.raw_string[52..54].should == "ACD"
+      instance.raw_string[66..68].should == "PRS"
+      instance.raw_string[91..93].should == "PQS"
+
+      instance.invalid_chars_as_array.should == [ chars[53], chars[68], chars[95] ]
+      instance.raw_data_as_array.should == chars
+      instance.first_bad_position.should == 53
+
+      instance.message.should match(/dfcds/)
+      instance.message.should match(/3/)
+      instance.message.should match(/200/)
+      instance.message.should match(/53/)
+      instance.message.should match(/UPC53.*UPC68.*UPC95/)
+    end
+  end
+
+  describe FlexColumns::Errors::InvalidJsonInDatabaseError do
+    it "should inherit from InvalidDataInDatabaseError" do
+      should_be_a_subclass(FlexColumns::Errors::InvalidJsonInDatabaseError, FlexColumns::Errors::InvalidDataInDatabaseError)
+    end
+
+    it "should take a data_source, raw_string, and returned_data" do
+      raw_string = " [ 1, 2, 3 ] "
+      returned_data = [ 9, 12, 15 ]
+      instance = FlexColumns::Errors::InvalidJsonInDatabaseError.new(@data_source, raw_string, returned_data)
+
+      instance.data_source.should be(@data_source)
+      instance.raw_string.should == raw_string
+      instance.returned_data.should be(returned_data)
+
+      instance.message.should match(/dfcds/)
+      instance.message.should match(raw_string)
+      instance.message.should match(/Array/)
+      instance.message.should match(/9\s*,\s*12\s*,\s*15\s*/)
+    end
+  end
+end

data/spec/flex_columns/unit/has_flex_columns_spec.rb

@@ -0,0 +1,365 @@
+require 'flex_columns'
+require 'flex_columns/helpers/exception_helpers'
+
+describe FlexColumns::HasFlexColumns do
+  include FlexColumns::Helpers::ExceptionHelpers
+
+  before :each do
+    @superclass = Class.new
+
+    @klass = Class.new(@superclass) do
+      class << self
+        def before_validation(*args)
+          @_before_validation_calls ||= [ ]
+          @_before_validation_calls << args
+        end
+
+        def before_save(*args)
+          @_before_save_calls ||= [ ]
+          @_before_save_calls << args
+        end
+
+        def before_validation_calls
+          @_before_validation_calls
+        end
+
+        def before_save_calls
+          @_before_save_calls
+        end
+      end
+    end
+
+    @klass_name = "HasFlexColumnsSpec_#{rand(1_000_000_000)}"
+    ::Object.const_set(@klass_name, @klass)
+
+    @klass.send(:include, FlexColumns::HasFlexColumns)
+  end
+
+  it "should call before_validation and before_save to set up hooks properly" do
+    @klass.before_validation_calls.length.should == 1
+    @klass.before_validation_calls[0].should == [ :_flex_columns_before_validation! ]
+    @klass.before_save_calls.length.should == 1
+    @klass.before_save_calls[0].should == [ :_flex_columns_before_save! ]
+  end
+
+  it "should normalize names properly" do
+    @klass._flex_column_normalize_name(" FoO ").should == :foo
+    @klass._flex_column_normalize_name(:fOo).should == :foo
+  end
+
+  it "should say it has flex columns" do
+    @klass.has_any_flex_columns?.should be
+  end
+
+  describe "#flex_column" do
+    it "should normalize the name of the column" do
+      fcc = double("fcc")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc)
+      expect(fcc).to receive(:setup!).once.with(@klass, :foo, { })
+      allow(fcc).to receive(:sync_methods!).with()
+
+      @klass.flex_column(' fOo ')
+    end
+
+    it "should replace existing columns, call #remove_all_methods! and #sync_methods! appropriately, and define a method that returns the right object" do
+      fcc_foo = double("fcc_foo")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc_foo)
+      expect(fcc_foo).to receive(:quux).once.with(:a, :z, :q)
+
+      passed_block = nil
+      expect(fcc_foo).to receive(:setup!).once.with(@klass, :foo, { }) do |*args, &block|
+        passed_block = block
+      end
+      allow(fcc_foo).to receive(:column_name).with().and_return(:foo)
+
+      dmm = double("dmm")
+      expect(FlexColumns::Util::DynamicMethodsModule).to receive(:new).once.with(@klass, :FlexColumnsDynamicMethods).and_return(dmm)
+
+      expect(dmm).to receive(:remove_all_methods!).once.with()
+      expect(fcc_foo).to receive(:sync_methods!).once.with()
+      @klass.flex_column(:foo) do
+        quux(:a, :z, :q)
+      end
+      fcc_foo.instance_eval(&passed_block)
+
+      @klass._flex_column_class_for(:foo).should be(fcc_foo)
+
+      instance = @klass.new
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance.foo.should be(fcc_foo_instance)
+
+
+
+      fcc_bar = double("fcc_bar")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc_bar)
+      expect(fcc_bar).to receive(:setup!).once.with(@klass, :bar, { })
+      allow(fcc_bar).to receive(:column_name).with().and_return(:bar)
+
+      expect(dmm).to receive(:remove_all_methods!).once.with()
+      expect(fcc_foo).to receive(:sync_methods!).once.with()
+      expect(fcc_bar).to receive(:sync_methods!).once.with()
+      @klass.flex_column(:bar)
+
+      @klass._flex_column_class_for(:foo).should be(fcc_foo)
+      @klass._flex_column_class_for(:bar).should be(fcc_bar)
+
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance.foo.should be(fcc_foo_instance)
+      instance.bar.should be(fcc_bar_instance)
+
+
+      fcc_foo_2 = double("fcc_foo_2")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc_foo_2)
+      expect(fcc_foo_2).to receive(:setup!).once.with(@klass, :foo, { :a => :b, :c => :d })
+      allow(fcc_foo_2).to receive(:column_name).with().and_return(:foo)
+
+      expect(dmm).to receive(:remove_all_methods!).once.with()
+      expect(fcc_foo_2).to receive(:sync_methods!).once.with()
+      expect(fcc_bar).to receive(:sync_methods!).once.with()
+
+      @klass.flex_column(:foo, :a => :b, :c => :d)
+
+      @klass._flex_column_class_for(:foo).should be(fcc_foo_2)
+      @klass._flex_column_class_for(:bar).should be(fcc_bar)
+
+      instance = @klass.new
+      fcc_foo_2_instance = double("fcc_foo_2_instance")
+      expect(fcc_foo_2).to receive(:new).once.with(instance).and_return(fcc_foo_2_instance)
+      instance.foo.should be(fcc_foo_2_instance)
+
+      instance = @klass.new
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance.bar.should be(fcc_bar_instance)
+    end
+  end
+
+  context "with two declared flex columns" do
+    before :each do
+      @fcc_foo = double("fcc_foo")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(@fcc_foo)
+      expect(@fcc_foo).to receive(:setup!).once.with(@klass, :foo, { :aaa => :bbb, :ccc => :ddd })
+      expect(@fcc_foo).to receive(:sync_methods!).once
+
+      allow(@fcc_foo).to receive(:column_name).with().and_return(:foo)
+
+      @dmm = double("dmm")
+      expect(FlexColumns::Util::DynamicMethodsModule).to receive(:new).once.with(@klass, :FlexColumnsDynamicMethods).and_return(@dmm)
+      expect(@dmm).to receive(:remove_all_methods!).once.with()
+
+      @klass.flex_column(:foo, :aaa => :bbb, :ccc => :ddd)
+
+      @fcc_bar = double("fcc_bar")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(@fcc_bar)
+      expect(@fcc_bar).to receive(:setup!).once.with(@klass, :bar, { })
+      expect(@fcc_bar).to receive(:sync_methods!).once
+
+      allow(@fcc_bar).to receive(:column_name).with().and_return(:bar)
+
+      expect(@dmm).to receive(:remove_all_methods!).once.with()
+      expect(@fcc_foo).to receive(:sync_methods!).once
+      @klass.flex_column(:bar)
+    end
+
+    it "should return the same DynamicMethodsModule every time" do
+      @klass._flex_column_dynamic_methods_module.should be(@dmm)
+      @klass._flex_column_dynamic_methods_module.should be(@dmm)
+    end
+
+    it "should call through on before_validation to only flex column objects that have been touched" do
+      instance = @klass.new
+      instance._flex_columns_before_validation!
+
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+      allow(fcc_foo_instance).to receive(:touched?).with().and_return(false)
+
+      instance._flex_columns_before_validation!
+
+
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
+      allow(fcc_bar_instance).to receive(:touched?).with().and_return(true)
+
+      expect(fcc_bar_instance).to receive(:before_validation!).once.with()
+      instance._flex_columns_before_validation!
+
+      allow(fcc_foo_instance).to receive(:touched?).with().and_return(true)
+      allow(fcc_bar_instance).to receive(:touched?).with().and_return(true)
+
+      expect(fcc_foo_instance).to receive(:before_validation!).once.with()
+      expect(fcc_bar_instance).to receive(:before_validation!).once.with()
+      instance._flex_columns_before_validation!
+    end
+
+    it "should call through on before_save to only flex column objects that say they need it" do
+      instance = @klass.new
+      allow(@fcc_foo).to receive(:requires_serialization_on_save?).with(instance).and_return(false)
+      allow(@fcc_bar).to receive(:requires_serialization_on_save?).with(instance).and_return(false)
+      instance._flex_columns_before_save!
+
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+      allow(@fcc_foo).to receive(:requires_serialization_on_save?).with(instance).and_return(false)
+
+      instance._flex_columns_before_save!
+
+
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
+      allow(@fcc_bar).to receive(:requires_serialization_on_save?).with(instance).and_return(true)
+
+      expect(fcc_bar_instance).to receive(:before_save!).once.with()
+      instance._flex_columns_before_save!
+
+      allow(@fcc_foo).to receive(:requires_serialization_on_save?).with(instance).and_return(true)
+      allow(@fcc_bar).to receive(:requires_serialization_on_save?).with(instance).and_return(true)
+
+      expect(fcc_foo_instance).to receive(:before_save!).once.with()
+      expect(fcc_bar_instance).to receive(:before_save!).once.with()
+      instance._flex_columns_before_save!
+    end
+
+    it "should return the flex-column class from #_flex_column_class_for" do
+      @klass._flex_column_class_for(:foo).should be(@fcc_foo)
+      @klass._flex_column_class_for(:bar).should be(@fcc_bar)
+      @klass._flex_column_class_for(:foo).should be(@fcc_foo)
+
+      e = capture_exception(FlexColumns::Errors::NoSuchColumnError) { @klass._flex_column_class_for(:baz) }
+      e.message.should match(/baz/)
+      e.message.should match(/foo/)
+      e.message.should match(/bar/)
+      e.message.should match(@klass_name)
+    end
+
+    it "should create a method that returns a new instance, but only once" do
+      instance = @klass.new
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance.foo.should be(fcc_foo_instance)
+      instance.foo.should be(fcc_foo_instance)
+    end
+
+    it "should overwrite previous columns with new ones" do
+      fcc_conflicting = double("fcc_conflicting")
+      expect(Class).to receive(:new).once.with(FlexColumns::Contents::FlexColumnContentsBase).and_return(fcc_conflicting)
+      expect(fcc_conflicting).to receive(:setup!).once.with(@klass, :foo, { })
+      expect(fcc_conflicting).to receive(:sync_methods!).once
+      allow(fcc_conflicting).to receive(:column_name).with().and_return(:foo)
+
+      expect(@dmm).to receive(:remove_all_methods!).once.with()
+
+      expect(@fcc_bar).to receive(:sync_methods!).once
+      @klass.flex_column(:foo)
+
+      instance = @klass.new
+      fcc_instance = double("fcc_instance")
+      expect(fcc_conflicting).to receive(:new).once.with(instance).and_return(fcc_instance)
+      instance.foo.should be(fcc_instance)
+      instance.foo.should be(fcc_instance)
+    end
+
+    it "should create, and hold on to, flex-column objects properly" do
+      instance = @klass.new
+
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
+
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+      instance._flex_column_object_for(' bAr ').should be(fcc_bar_instance)
+    end
+
+    it "should re-create flex-column objects on reload, and call super" do
+      @superclass.class_eval do
+        def reload
+          @reloads ||= 0
+          @reloads += 1
+        end
+
+        def reloads
+          @reloads ||= 0
+        end
+      end
+
+      instance = @klass.new
+
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance)
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+
+      fcc_bar_instance = double("fcc_bar_instance")
+      expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
+
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance)
+
+      instance.reloads.should == 0
+      instance.reload
+      instance.reloads.should == 1
+
+      fcc_foo_instance_2 = double("fcc_foo_instance_2")
+      expect(@fcc_foo).to receive(:new).once.with(instance).and_return(fcc_foo_instance_2)
+      instance._flex_column_object_for(:foo).should be(fcc_foo_instance_2)
+
+      fcc_bar_instance_2 = double("fcc_bar_instance_2")
+      expect(@fcc_bar).to receive(:new).once.with(instance).and_return(fcc_bar_instance_2)
+      instance._flex_column_object_for(:bar).should be(fcc_bar_instance_2)
+    end
+
+    it "should tell you what flex-column names have been defined" do
+      @klass._all_flex_column_names.sort_by(&:to_s).should == [ :foo, :bar ].sort_by(&:to_s)
+    end
+
+    it "should normalize column names properly" do
+      @klass._flex_column_normalize_name(:baz).should == :baz
+      @klass._flex_column_normalize_name(:' bAz ').should == :baz
+      @klass._flex_column_normalize_name('   bAZ ').should == :baz
+    end
+
+    it "should create flex-column objects upon request that aren't attached to a model instance" do
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(nil).and_return(fcc_foo_instance)
+      @klass.create_flex_object_from(:foo, nil).should be(fcc_foo_instance)
+
+      fcc_foo_instance = double("fcc_foo_instance")
+      expect(@fcc_foo).to receive(:new).once.with(" JSON string ").and_return(fcc_foo_instance)
+      @klass.create_flex_object_from(:foo, " JSON string ").should be(fcc_foo_instance)
+
+      fcc_bar_instance_1 = double("fcc_bar_instance_1")
+      expect(@fcc_bar).to receive(:new).once.with(nil).and_return(fcc_bar_instance_1)
+      fcc_bar_instance_2 = double("fcc_bar_instance_2")
+      expect(@fcc_bar).to receive(:new).once.with(" JSON string ").and_return(fcc_bar_instance_2)
+      @klass.create_flex_objects_from(:bar, [ nil, " JSON string " ]).should == [ fcc_bar_instance_1, fcc_bar_instance_2 ]
+    end
+  end
+
+  describe "flex-column objects" do
+    it "should prefer to just return super from _flex_column_object_for" do
+      superclass = Class.new do
+        def _flex_column_object_for(x)
+          "A_#{x}_Z"
+        end
+      end
+
+      subclass = Class.new(superclass)
+      allow(subclass).to receive(:before_validation).with(:_flex_columns_before_validation!)
+      allow(subclass).to receive(:before_save).with(:_flex_columns_before_save!)
+      subclass.send(:include, FlexColumns::HasFlexColumns)
+
+      instance = subclass.new
+      instance._flex_column_object_for(:foo).should == "A_foo_Z"
+    end
+  end
+end