flex_columns 1.0.0

data/spec/flex_columns/system/performance_system_spec.rb

@@ -0,0 +1,218 @@
+require 'flex_columns'
+require 'flex_columns/helpers/system_helpers'
+
+describe "FlexColumns performance" do
+  include FlexColumns::Helpers::SystemHelpers
+
+  before :each do
+    @dh = FlexColumns::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes do
+        field :wants_email
+      end
+    end
+
+    @deserializations = [ ]
+    @serializations = [ ]
+
+    ds = @deserializations
+    s = @serializations
+
+    ActiveSupport::Notifications.subscribe('flex_columns.deserialize') do |name, start, finish, id, payload|
+      ds << payload
+    end
+
+    ActiveSupport::Notifications.subscribe('flex_columns.serialize') do |name, start, finish, id, payload|
+      s << payload
+    end
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  it "should fire a notification when deserializing and serializing" do
+    user = ::User.new
+    user.name = 'User 1'
+    user.wants_email = 'foo'
+
+    @serializations.length.should == 0
+    user.save!
+
+    @serializations.length.should == 1
+    @serializations[0].class.should == Hash
+    @serializations[0].keys.sort_by(&:to_s).should == [ :model_class, :model, :column_name ].sort_by(&:to_s)
+    @serializations[0][:model_class].should be(::User)
+    @serializations[0][:model].should be(user)
+    @serializations[0][:column_name].should == :user_attributes
+
+    user_again = ::User.find(user.id)
+
+    @deserializations.length.should == 0
+    user_again.wants_email.should == 'foo'
+    @deserializations.length.should == 1
+    @deserializations[0].class.should == Hash
+    @deserializations[0].keys.sort_by(&:to_s).should == [ :model_class, :model, :column_name, :raw_data ].sort_by(&:to_s)
+    @deserializations[0][:model_class].should be(::User)
+    @deserializations[0][:model].should be(user_again)
+    @deserializations[0][:column_name].should == :user_attributes
+    @deserializations[0][:raw_data].should == user_again.user_attributes.to_json
+  end
+
+  it "should not deserialize columns if they aren't touched" do
+    user = ::User.new
+    user.name = 'User 1'
+    user.wants_email = 'foo'
+    user.save!
+
+    user_again = ::User.find(user.id)
+    user_again.user_attributes.should be
+
+    @deserializations.length.should == 0
+  end
+
+  it "should not deserialize columns to run validations if there aren't any" do
+    user = ::User.new
+    user.name = 'User 1'
+    user.wants_email = 'foo'
+    user.save!
+
+    user_again = ::User.find(user.id)
+    user_again.user_attributes.should be
+    user_again.valid?.should be
+    user_again.user_attributes.valid?.should be
+
+    @deserializations.length.should == 0
+  end
+
+  it "should deserialize columns to run validations if there are any" do
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes do
+        field :wants_email, :integer
+      end
+    end
+
+    user = ::User.new
+    user.name = 'User 1'
+    user.wants_email = 12345
+    user.save!
+
+    user_again = ::User.find(user.id)
+    user_again.user_attributes.should be
+
+    @deserializations.length.should == 0
+
+    user_again.valid?.should be
+    user_again.user_attributes.valid?.should be
+
+    @deserializations.length.should == 1
+  end
+
+  context "with NULLable and non-NULLable text and binary columns" do
+    def check_text_column_data(text_data, key, value)
+      parsed = JSON.parse(text_data)
+      parsed.keys.should == [ key.to_s ]
+      parsed[key.to_s].should == value
+    end
+
+    def check_binary_column_data(binary_data, key, value)
+      if binary_data =~ /^FC:01,0,/
+        without_header = binary_data[8..-1]
+        parsed = JSON.parse(without_header)
+        parsed.keys.should == [ key.to_s ]
+        parsed[key.to_s].should == value
+      end
+    end
+
+    before :each do
+      migrate do
+        drop_table :flexcols_spec_users rescue nil
+        create_table :flexcols_spec_users do |t|
+          t.string :name, :null => false
+          t.text :text_attrs_nonnull, :null => false
+          t.text :text_attrs_null
+          t.binary :binary_attrs_nonnull, :null => false
+          t.binary :binary_attrs_null
+        end
+      end
+
+      ::User.reset_column_information
+
+      define_model_class(:User, 'flexcols_spec_users') do
+        flex_column :text_attrs_nonnull do
+          field :aaa
+        end
+        flex_column :text_attrs_null do
+          field :bbb
+        end
+        flex_column :binary_attrs_nonnull do
+          field :ccc
+        end
+        flex_column :binary_attrs_null do
+          field :ddd
+        end
+      end
+
+      define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
+
+      ::UserBackdoor.reset_column_information
+    end
+
+    it "should be smart enough to store an empty JSON string to the database, if necessary, if the column is non-NULL" do
+      # JRuby with the ActiveRecord-JDB adapter and MySQL seems to have the following issue: if you define a column as
+      # non-NULL, and create a new model instance, then ask that model instance for the value of that column, you get
+      # back empty string (""), not nil. Yet when trying to save that instance, you get an exception because it's not
+      # specifying that column at all. Only setting that column to a string with spaces in it (or something else) works,
+      # not even just setting it to the empty string again; as such, we're just going to give up on this example under
+      # those circumstances, rather than trying to work around this (pretty broken) behavior that's also a pretty rare
+      # edge case for us.
+      unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && @dh.database_type == :mysql
+        my_user = ::User.new
+        my_user.name = 'User 1'
+        my_user.save!
+
+        user_bd = ::UserBackdoor.find(my_user.id)
+        user_bd.name.should == 'User 1'
+        user_bd.text_attrs_nonnull.should == ""
+        user_bd.text_attrs_null.should == nil
+        user_bd.binary_attrs_nonnull.should == ""
+        user_bd.binary_attrs_null.should == nil
+      end
+    end
+
+    it "should store NULL or the empty string in the database, as appropriate, if there's no data left any more" do
+      my_user = ::User.new
+      my_user.name = 'User 1'
+      my_user.aaa = 'aaa1'
+      my_user.bbb = 'bbb1'
+      my_user.ccc = 'ccc1'
+      my_user.ddd = 'ddd1'
+      my_user.save!
+
+      user_bd = ::UserBackdoor.find(my_user.id)
+      user_bd.name.should == 'User 1'
+      check_text_column_data(user_bd.text_attrs_nonnull, 'aaa', 'aaa1')
+      check_text_column_data(user_bd.text_attrs_null, 'bbb', 'bbb1')
+      check_binary_column_data(user_bd.binary_attrs_nonnull, 'ccc', 'ccc1')
+      check_binary_column_data(user_bd.binary_attrs_null, 'ddd', 'ddd1')
+
+      user_again = ::User.find(my_user.id)
+      user_again.aaa = nil
+      user_again.bbb = nil
+      user_again.ccc = nil
+      user_again.ddd = nil
+      user_again.save!
+
+      user_bd_again = ::UserBackdoor.find(my_user.id)
+      user_bd_again.name.should == 'User 1'
+      user_bd_again.text_attrs_nonnull.should == ""
+      user_bd_again.text_attrs_null.should == nil
+      user_bd_again.binary_attrs_nonnull.should == ""
+      user_bd_again.binary_attrs_null.should == nil
+    end
+  end
+end

data/spec/flex_columns/system/postgres_json_column_type_system_spec.rb

@@ -0,0 +1,85 @@
+require 'flex_columns'
+require 'flex_columns/helpers/system_helpers'
+
+describe "FlexColumns PostgreSQL JSON column type support" do
+  include FlexColumns::Helpers::SystemHelpers
+
+  before :each do
+    @dh = FlexColumns::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+  end
+
+  dbtype = FlexColumns::Helpers::DatabaseHelper.new.database_type
+
+  if dbtype == :postgres
+    before :each do
+      create_table_error = nil
+
+      migrate do
+        drop_table :flexcols_spec_users rescue nil
+
+        begin
+          create_table :flexcols_spec_users do |t|
+            t.string :name, :null => false
+            t.column :user_attributes, :json
+          end
+        rescue ActiveRecord::StatementInvalid => si
+          create_table_error = si
+        end
+      end
+
+      @create_table_error = create_table_error
+    end
+
+    after :each do
+      migrate do
+        # drop_table :flexcols_spec_users rescue nil
+      end
+    end
+
+    it "should store JSON, without a binary header or compression, in a column typed of JSON" do
+      if @create_table_error
+        $stderr.puts "Skipping PostgreSQL test of JSON type, because PostgreSQL didn't seem to create our table successfully -- likely because its version is < 9.2, and thus has no support for the JSON type: #{@create_table_error.message} (#{@create_table_error.class.name})"
+      else
+        define_model_class(:User, 'flexcols_spec_users') do
+          flex_column :user_attributes do
+            field :wants_email
+          end
+        end
+
+        define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
+
+        user = ::User.new
+        user.name = 'User 1'
+        user.wants_email = 'foo' * 10_000
+        user.save!
+
+        user_again = ::User.find(user.id)
+        user_again.name.should == 'User 1'
+        user_again.wants_email.should == 'foo' * 10_000
+
+        user_bd = ::UserBackdoor.find(user.id)
+        raw = user_bd.user_attributes
+
+        parsed = nil
+        if raw.kind_of?(String)
+          string.length.should > 30_000
+          string.should match(/^\s*\{/i)
+          parsed = JSON.parse(string)
+        elsif raw.kind_of?(Hash)
+          parsed = raw
+        else
+          raise "Unknown raw: #{raw.inspect}"
+        end
+
+        parsed['wants_email'].should == "foo" * 10_000
+        parsed.keys.should == [ 'wants_email' ]
+
+        if raw.kind_of?(Hash)
+          as_stored = user.user_attributes.to_stored_data
+          as_stored.class.should == Hash
+        end
+      end
+    end
+  end
+end

data/spec/flex_columns/system/types_system_spec.rb

@@ -0,0 +1,93 @@
+require 'flex_columns'
+require 'flex_columns/helpers/system_helpers'
+
+describe "FlexColumns basic operations" do
+  include FlexColumns::Helpers::SystemHelpers
+
+  before :each do
+    @dh = FlexColumns::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  def should_fail_validation(field, value, pattern = nil)
+    object = ::User.new
+    object.some_integer = 123
+
+    object.send("#{field}=", value)
+
+    object.valid?.should_not be
+
+    full_name = "user_attributes.#{field}".to_sym
+    object.errors.keys.should == [ full_name ]
+
+    if pattern
+      object.errors[full_name].length.should == 1
+      object.errors[full_name][0].should match(pattern)
+    end
+  end
+
+  it "should allow 'types' as shorthand for validations" do
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes do
+        field :some_integer, :integer, :null => false
+        field :some_string, :string, :limit => 100
+        field :some_string_2, :text
+        field :some_float, :float
+        field :some_float_2, :decimal
+        field :some_date, :date
+        field :some_time, :time
+        field :some_datetime, :datetime
+        field :some_timestamp, :timestamp
+        field :some_boolean, :boolean
+        field :some_enum, :enum => [ 'foo', 'bar', 'baz', nil ]
+      end
+    end
+
+    should_fail_validation(:some_integer, "foo", /is not a number/i)
+    should_fail_validation(:some_string, 12345, /must be a String/i)
+    should_fail_validation(:some_string_2, 12345, /must be a String/i)
+    should_fail_validation(:some_string, "foobar" * 100, /is too long/i)
+    should_fail_validation(:some_float, "foo", /is not a number/i)
+    should_fail_validation(:some_float_2, "foo", /is not a number/i)
+    should_fail_validation(:some_time, "foo", /must be a Time/i)
+    should_fail_validation(:some_datetime, "foo", /must be a Time/i)
+    should_fail_validation(:some_timestamp, "foo", /must be a Time/i)
+    should_fail_validation(:some_boolean, "true", /is not included in the list/i)
+    should_fail_validation(:some_enum, "quux", /is not included in the list/i)
+
+    user = ::User.new
+    user.name = 'User 1'
+
+    user.user_attributes.some_integer = 12345
+    user.user_attributes.some_string = "foo"
+    user.user_attributes.some_string_2 = "bar"
+    user.user_attributes.some_float = 5.2
+    user.user_attributes.some_float_2 = 10.7
+    user.user_attributes.some_date = Date.today
+    user.user_attributes.some_time = Time.now
+    user.user_attributes.some_datetime = 1.day.from_now
+    user.user_attributes.some_timestamp = 1.minute.from_now
+    user.user_attributes.some_boolean = true
+    user.user_attributes.some_enum = 'foo'
+
+    user.valid?.should be
+
+    user.user_attributes.some_string = ''
+    user.valid?.should be
+
+    user.user_attributes.some_float = 15
+    user.valid?.should be
+
+    user.user_attributes.some_boolean = nil
+    user.valid?.should be
+
+    user.user_attributes.some_string = :bonk
+    user.valid?.should be
+  end
+end

data/spec/flex_columns/system/unknown_fields_system_spec.rb

@@ -0,0 +1,126 @@
+require 'flex_columns'
+require 'flex_columns/helpers/system_helpers'
+
+describe "FlexColumns unknown fields" do
+  include FlexColumns::Helpers::SystemHelpers
+
+  before :each do
+    @dh = FlexColumns::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+
+    define_model_class(:UserBackdoor, 'flexcols_spec_users') do
+      flex_column :user_attributes do
+        field :wants_email
+        field :some_unknown_attribute
+      end
+    end
+
+    @user_bd = ::UserBackdoor.new
+    @user_bd.name = 'User 1'
+    @user_bd.some_unknown_attribute = 'bongo'
+    @user_bd.save!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  it "should preserve unknown fields by default" do
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes do
+        field :wants_email
+      end
+    end
+
+    user = ::User.find(@user_bd.id)
+    user.name.should == 'User 1'
+    user.wants_email.should be_nil
+    user.wants_email = 'does_want'
+
+    user.respond_to?(:some_unknown_attribute).should_not be
+    lambda { user.send(:some_unknown_attribute) }.should raise_error(NoMethodError)
+    lambda { user.user_attributes[:some_unknown_attribute] }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+    lambda { user.user_attributes[:some_unknown_attribute] = 123 }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+
+    user.save!
+
+    user_bd_again = ::UserBackdoor.find(@user_bd.id)
+    user_bd_again.wants_email.should == 'does_want'
+    user_bd_again.some_unknown_attribute.should == 'bongo'
+  end
+
+  it "should delete unknown fields if asked to" do
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes, :unknown_fields => :delete do
+        field :wants_email
+      end
+    end
+
+    user = ::User.find(@user_bd.id)
+    user.name.should == 'User 1'
+    user.wants_email.should be_nil
+    user.wants_email = 'does_want'
+
+    user.respond_to?(:some_unknown_attribute).should_not be
+    lambda { user.send(:some_unknown_attribute) }.should raise_error(NoMethodError)
+    lambda { user.user_attributes[:some_unknown_attribute] }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+    lambda { user.user_attributes[:some_unknown_attribute] = 123 }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+
+    user.save!
+
+    user_bd_again = ::UserBackdoor.find(@user_bd.id)
+    user_bd_again.wants_email.should == 'does_want'
+    user_bd_again.some_unknown_attribute.should be_nil
+  end
+
+  it "should not delete unknown fields if asked to, but we only read from the model" do
+    @user_bd.wants_email = 'foo'
+    @user_bd.save!
+
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes, :unknown_fields => :delete do
+        field :wants_email
+      end
+    end
+
+    user = ::User.find(@user_bd.id)
+    user.name.should == 'User 1'
+    user.wants_email.should == 'foo'
+
+    user.respond_to?(:some_unknown_attribute).should_not be
+    lambda { user.send(:some_unknown_attribute) }.should raise_error(NoMethodError)
+    lambda { user.user_attributes[:some_unknown_attribute] }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+    lambda { user.user_attributes[:some_unknown_attribute] = 123 }.should raise_error(FlexColumns::Errors::NoSuchFieldError)
+
+    user.save!
+
+    user_bd_again = ::UserBackdoor.find(@user_bd.id)
+    user_bd_again.wants_email.should == 'foo'
+    user_bd_again.some_unknown_attribute.should == 'bongo'
+  end
+
+  it "should have a method that explicitly will purge unknown methods, even if deserialization hasn't happened for any other reason, but not before then" do
+    define_model_class(:User, 'flexcols_spec_users') do
+      flex_column :user_attributes, :unknown_fields => :delete do
+        field :wants_email
+      end
+    end
+
+    user = ::User.find(@user_bd.id)
+    user.save!
+
+    user_bd_again = ::UserBackdoor.find(@user_bd.id)
+    user_bd_again.wants_email.should be_nil
+    user_bd_again.some_unknown_attribute.should == 'bongo'
+
+    user = ::User.find(@user_bd.id)
+    user.user_attributes.touch!
+    user.save!
+
+    user_bd_again = ::UserBackdoor.find(@user_bd.id)
+    user_bd_again.wants_email.should be_nil
+    user_bd_again.some_unknown_attribute.should be_nil
+  end
+end