protobuf-activerecord 1.0.1

data/spec/protoable/convert_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+describe Protoable::Convert do
+  describe ".convert_int64_to_date" do
+    let(:date) { Date.current }
+    let(:int64) { date.to_time.to_i }
+
+    it "initializes a new Date object from the value" do
+      Timecop.freeze(Date.current) do
+        User.convert_int64_to_date(int64).should eq date
+      end
+    end
+  end
+
+  describe ".convert_int64_to_datetime" do
+    let(:datetime) { DateTime.current }
+    let(:int64) { datetime.to_time.to_i }
+
+    it "initializes a new DateTime object from the value" do
+      Timecop.freeze(DateTime.current) do
+        User.convert_int64_to_datetime(int64).should eq datetime
+      end
+    end
+  end
+
+  describe ".convert_int64_to_time" do
+    let(:time) { Time.current }
+    let(:int64) { time.to_time.to_i }
+
+    it "initializes a new Time object from the value" do
+      Timecop.freeze(Time.current) do
+        User.convert_int64_to_time(int64).should be_within(1).of(time)
+      end
+    end
+  end
+
+  describe "._protobuf_convert_columns_to_fields" do
+    context "when there is a column converter for the field" do
+      let(:email_value) { "foo@test.co" }
+      let(:email_converter) { User.method(:convert_email_to_lowercase) }
+
+      before { User.stub(:_protobuf_column_converters).and_return({ :email => email_converter }) }
+
+      it "calls the column converter with the given value" do
+        email_converter.should_receive(:call).with(email_value)
+        User._protobuf_convert_columns_to_fields(:email, email_value)
+      end
+
+      context "and it's corresponding column type has a default converter" do
+        before { User.stub(:_protobuf_date_column?).and_return(true) }
+
+        it "calls the column converter with the given value" do
+          email_converter.should_receive(:call).with(email_value)
+          User._protobuf_convert_columns_to_fields(:email, email_value)
+        end
+      end
+    end
+
+    context "when the column type is :date" do
+      let(:date) { Date.current }
+      let(:integer) { date.to_time.to_i }
+
+      before { User.stub(:_protobuf_date_column?).and_return(true) }
+
+      it "converts the given value to an integer" do
+        User._protobuf_convert_columns_to_fields(:foo_date, date).should eq integer
+      end
+    end
+
+    context "when the column type is :datetime" do
+      let(:datetime) { DateTime.current }
+      let(:integer) { datetime.to_time.to_i }
+
+      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
+
+      it "converts the given value to an integer" do
+        User._protobuf_convert_columns_to_fields(:foo_datetime, datetime).should eq integer
+      end
+    end
+
+    context "when the column type is :time" do
+      let(:time) { Time.current }
+      let(:integer) { time.to_time.to_i }
+
+      before { User.stub(:_protobuf_time_column?).and_return(true) }
+
+      it "converts the given value to an integer" do
+        User._protobuf_convert_columns_to_fields(:foo_time, time).should eq integer
+      end
+    end
+
+    context "when the column type is :timestamp" do
+      let(:timestamp) { Time.current }
+      let(:integer) { timestamp.to_time.to_i }
+
+      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
+
+      it "converts the given value to an integer" do
+        User._protobuf_convert_columns_to_fields(:foo_timestamp, timestamp).should eq integer
+      end
+    end
+
+    context "when no conversion is necessary" do
+      let(:value) { "Foo" }
+
+      it "returns the given value" do
+        User._protobuf_convert_columns_to_fields(:foo, value).should eq value
+      end
+    end
+  end
+
+  describe "._protobuf_convert_fields_to_columns" do
+    let(:email_value) { "foo@test.co" }
+    let(:email_converter) { lambda { |value| value } }
+
+    before { User.stub(:_protobuf_field_converters).and_return({ :email => email_converter }) }
+
+    it "calls the field converter with the given value" do
+      email_converter.should_receive(:call).with(email_value)
+      User._protobuf_convert_fields_to_columns(:email, email_value)
+    end
+
+    context "and it's corresponding column type has a default converter" do
+      before { User.stub(:_protobuf_date_column?).and_return(true) }
+
+      it "calls the field converter with the given value" do
+        email_converter.should_receive(:call).with(email_value)
+        User._protobuf_convert_fields_to_columns(:email, email_value)
+      end
+    end
+
+    context "when the given field's corresponding column type is :date" do
+      let(:date) { Date.current }
+      let(:value) { date.to_time.to_i }
+
+      before { User.stub(:_protobuf_date_column?).and_return(true) }
+
+      it "converts the given value to a Date object" do
+        User._protobuf_convert_fields_to_columns(:foo_date, value).should eq date
+      end
+    end
+
+    context "when given field's corresponding the column type is :datetime" do
+      let(:datetime) { DateTime.current }
+      let(:value) { datetime.to_i }
+
+      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
+
+      it "converts the given value to a DateTime object" do
+        User._protobuf_convert_fields_to_columns(:foo_datetime, value).should be_a(DateTime)
+      end
+
+      it "converts the given value to a DateTime object of the same value" do
+        User._protobuf_convert_fields_to_columns(:foo_datetime, value).should be_within(1).of(datetime)
+      end
+    end
+
+    context "when given field's corresponding the column type is :time" do
+      let(:time) { Time.current }
+      let(:value) { time.to_i }
+
+      before { User.stub(:_protobuf_time_column?).and_return(true) }
+
+      it "converts the given value to a Time object" do
+        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_a(Time)
+      end
+
+      it "converts the given value to a Time object of the same value" do
+        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_within(1).of(time)
+      end
+    end
+
+    context "when given field's corresponding the column type is :timestamp" do
+      let(:time) { Time.current }
+      let(:value) { time.to_i }
+
+      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
+
+      it "converts the given value to a Time object" do
+        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_a(Time)
+      end
+
+      it "converts the given value to a Time object of the same value" do
+        User._protobuf_convert_fields_to_columns(:foo_timestamp, value).should be_within(1).of(time)
+      end
+    end
+
+    context "when no conversion is necessary" do
+      let(:value) { "Foo" }
+
+      it "returns the given value" do
+        User._protobuf_convert_fields_to_columns(:foo, value).should eq value
+      end
+    end
+  end
+
+  context "column type predicates" do
+    before { User.stub(:_protobuf_column_types).and_return(Hash.new) }
+    after { User.unstub(:_protobuf_column_types) }
+
+    describe "._protobuf_date_column?" do
+      before { User._protobuf_column_types[:date] = [ :foo_date ] }
+
+      context "when the column type is :date" do
+        it "is true" do
+          User._protobuf_date_column?(:foo_date).should be_true
+        end
+      end
+
+      context "when the column type is not :date" do
+        it "is false" do
+          User._protobuf_date_column?(:bar_date).should be_false
+        end
+      end
+    end
+
+    describe "._protobuf_datetime_column?" do
+      before { User._protobuf_column_types[:datetime] = [ :foo_datetime ] }
+
+      context "when the column type is :datetime" do
+        it "is true" do
+          User._protobuf_datetime_column?(:foo_datetime).should be_true
+        end
+      end
+
+      context "when the column type is not :datetime" do
+        it "is false" do
+          User._protobuf_datetime_column?(:bar_datetime).should be_false
+        end
+      end
+    end
+
+    describe "._protobuf_time_column?" do
+      before { User._protobuf_column_types[:time] = [ :foo_time ] }
+
+      context "when the column type is :time" do
+        it "is true" do
+          User._protobuf_time_column?(:foo_time).should be_true
+        end
+      end
+
+      context "when the column type is not :time" do
+        it "is false" do
+          User._protobuf_time_column?(:bar_time).should be_false
+        end
+      end
+    end
+
+    describe "._protobuf_timestamp_column?" do
+      before { User._protobuf_column_types[:timestamp] = [ :foo_timestamp ] }
+
+      context "when the column type is :timestamp" do
+        it "is true" do
+          User._protobuf_timestamp_column?(:foo_timestamp).should be_true
+        end
+      end
+
+      context "when the column type is not :timestamp" do
+        it "is false" do
+          User._protobuf_timestamp_column?(:bar_timestamp).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/protoable/fields_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Protoable::Fields do
+  describe "._protobuf_map_columns" do
+    context "when the class has a table" do
+      let(:expected_column_names) {
+        User.columns.inject({}) do |hash, column|
+          hash[column.name.to_sym] = column
+          hash
+        end
+      }
+
+      let(:expected_column_types) {
+        User.columns.inject({}) do |hash, column|
+          hash[column.type.to_sym] ||= []
+          hash[column.type.to_sym] << column.name.to_sym
+          hash
+        end
+      }
+
+      it "maps columns by name" do
+        User._protobuf_columns.should eq expected_column_names
+      end
+
+      it "maps column names by column type" do
+        User._protobuf_column_types.should eq expected_column_types
+      end
+    end
+  end
+
+  describe ".convert_field" do
+    context "when the given converter is a hash" do
+      let(:method) { User.method(:convert_base64_to_string) }
+
+      before { User.convert_field :public_key, :from => :base64, :to => :string }
+
+      it "determines the method using the hash's :to and :from keys" do
+        User._protobuf_field_converters[:public_key].should eq method
+      end
+    end
+
+    context "when the given converter is a symbol" do
+      context "when the converter is not a defined method" do
+        let(:callable) { User.method(:convert_base64_to_string) }
+
+        before { User.convert_field :email, :base64 }
+
+        it "determines the method using the converter as the 'from' and the column type as the 'to'" do
+          User._protobuf_field_converters[:email].should eq callable
+        end
+      end
+
+      context "when the converter is a defined method" do
+        let(:callable) { User.method(:convert_email_to_lowercase) }
+
+        before { User.convert_field :email, :convert_email_to_lowercase }
+
+        it "creates a callable method object from the converter" do
+          User._protobuf_field_converters[:email].should eq callable
+        end
+      end
+    end
+
+    context "when the given converter is nil" do
+      it "raises an exception" do
+        expect { User.convert_field :email, nil }.to raise_exception(Protoable::FieldConverterError)
+      end
+    end
+
+    context "when the given converter is not callable" do
+      it "raises an exception" do
+        expect { User.convert_field :email, :foo }.to raise_exception(Protoable::FieldConverterError)
+      end
+    end
+
+    context "when the given converter is callable" do
+      let(:callable) { lambda { |value| value } }
+
+      before { User.convert_field :email, callable }
+
+      it "adds the given converter to list of field converters" do
+        User._protobuf_field_converters[:email].should eq callable
+      end
+    end
+  end
+
+  describe ".transform_column" do
+    context "when the given converter is a symbol" do
+      context "when the converter is not a defined method" do
+        it "raises an exception" do
+          expect { User.transform_column :name, :foo }.to raise_exception(Protoable::ColumnTransformerError)
+        end
+      end
+
+      context "when the converter is a defined method" do
+        let(:callable) { User.method(:extract_first_name) }
+
+        before { User.transform_column :first_name, :extract_first_name }
+
+        it "creates a callable method object from the converter" do
+          User._protobuf_column_transformers[:first_name].should eq callable
+        end
+      end
+    end
+
+    context "when the given converter is nil" do
+      it "raises an exception" do
+        expect { User.transform_column :name, nil }.to raise_exception(Protoable::ColumnTransformerError)
+      end
+    end
+
+    context "when the given converter is not callable" do
+      it "raises an exception" do
+        expect { User.transform_column :name, double(:not_callable) }.to raise_exception(Protoable::ColumnTransformerError)
+      end
+    end
+
+    context "when the given transformer is callable" do
+      let(:callable) { lambda { |proto| nil } }
+
+      before {
+        User.stub(:_protobuf_column_transformers).and_return(Hash.new)
+        User.transform_column :account_id, callable
+      }
+
+      it "adds the given converter to the list of protobuf field transformers" do
+        User._protobuf_column_transformers[:account_id] = callable
+      end
+    end
+  end
+end

data/spec/protoable/inheritable_class_instance_variables_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Protoable::InheritableClassInstanceVariables do
+  pending
+end

data/spec/protoable/persistence_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Protoable::Persistence do
+  let(:user) { User.new(user_attributes) }
+  let(:user_attributes) { { :first_name => 'foo', :last_name => 'bar', :email => 'foo@test.co' } }
+  let(:proto_hash) { { :name => 'foo bar', :email => 'foo@test.co' } }
+  let(:proto) { Proto::User.new(proto_hash) }
+
+  describe "._filter_attribute_fields" do
+    it "includes fields that have values" do
+      attribute_fields = User._filter_attribute_fields(proto)
+      attribute_fields[:email].should eq proto_hash[:email]
+    end
+
+    it "filters repeated fields" do
+      attribute_fields = User._filter_attribute_fields(proto)
+      attribute_fields.has_key?(:tags).should be_false
+    end
+
+    it "filters fields that map to protected attributes" do
+      User.stub(:protected_attributes).and_return([ "email" ])
+      attribute_fields = User._filter_attribute_fields(proto)
+      attribute_fields.has_key?(:email).should be_false
+    end
+
+    it "includes attributes that aren't fields, but have column transformers" do
+      User.stub(:_protobuf_column_transformers).and_return({ :account_id => :fetch_account_id })
+      attribute_fields = User._filter_attribute_fields(proto)
+      attribute_fields.has_key?(:account_id).should be_true
+    end
+  end
+
+  describe ".attributes_from_proto" do
+    context "when a column transformer is defined for the field" do
+      it "transforms the field value" do
+        attribute_fields = User.attributes_from_proto(proto)
+        attribute_fields[:first_name].should eq user_attributes[:first_name]
+      end
+    end
+
+    context "when column transformer is not defined for the field" do
+      before {
+        User.stub(:_protobuf_convert_fields_to_columns) do |key, value|
+          value
+        end
+      }
+
+      it "converts the field value" do
+        attribute_fields = User.attributes_from_proto(proto)
+        attribute_fields.should eq user_attributes
+      end
+    end
+  end
+
+  describe ".create_from_proto" do
+    it "initializes a new object with attributes from the given protobuf message" do
+      user = User.create_from_proto(proto)
+      attributes = user.attributes.slice("first_name", "last_name", "email")
+      attributes.should eq user_attributes.stringify_keys
+    end
+
+    context "when a block is given" do
+      it "yields to the block with attributes from the given protobuf message" do
+        yielded = nil
+
+        User.create_from_proto(proto) do |attributes|
+          yielded = "boom!"
+        end
+
+        yielded.should eq "boom!"
+      end
+    end
+
+    context "when the object is valid" do
+      it "saves the record" do
+        user = User.create_from_proto(proto)
+        user.persisted?.should be_true
+      end
+
+      context "when an error occurs while saving" do
+        before { User.any_instance.stub(:save!).and_raise(RuntimeError) }
+
+        it "raises an exception" do
+          expect { User.create_from_proto(proto) }.to raise_exception
+        end
+      end
+    end
+
+    context "when the object is not valid" do
+      before { User.any_instance.stub(:valid?).and_return(false) }
+
+      it "returns the new object, unsaved" do
+        user = User.create_from_proto(proto)
+        user.persisted?.should be_false
+      end
+    end
+  end
+
+  describe "#attributes_from_proto" do
+    it "gets attributes from the given protobuf message" do
+      User.should_receive(:attributes_from_proto).with(proto)
+      user.attributes_from_proto(proto)
+    end
+  end
+
+  describe "#destroy_from_proto" do
+    it "destroys the object" do
+      user.should_receive(:destroy)
+      user.destroy_from_proto
+    end
+  end
+
+  describe "#update_from_proto" do
+    it "updates the object with attributes from the given protobuf message" do
+      user.should_receive(:assign_attributes).with(user_attributes)
+      user.update_from_proto(proto)
+    end
+
+    context "when a block is given" do
+      it "yields to the block with attributes from the given protobuf message" do
+        yielded = nil
+
+        user.update_from_proto(proto) do |attributes|
+          yielded = "boom!"
+        end
+
+        yielded.should eq "boom!"
+      end
+    end
+
+    context "when the object is valid" do
+      before { user.stub(:valid?).and_return(true) }
+
+      context "when saving is successful" do
+        it "returns true" do
+          user.stub(:save!).and_return(true)
+          user.update_from_proto(proto).should be_true
+        end
+      end
+
+      context "when an error occurs while saving" do
+        before { user.stub(:save!).and_raise(RuntimeError) }
+
+        it "raises an exception" do
+          expect { user.update_from_proto }.to raise_exception
+        end
+      end
+    end
+
+    context "when the object is invalid" do
+      before { user.stub(:valid?).and_return(false) }
+
+      it "returns false" do
+        user.update_from_proto(proto).should be_false
+      end
+    end
+  end
+end

data/spec/protoable/serialization_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Protoable::Serialization do
+  let(:protobuf_message) { ::Proto::User }
+
+  describe ".convert_column" do
+    context "when the given converter is a hash" do
+      let(:method) { User.method(:convert_base64_to_string) }
+
+      before { User.convert_column :public_key, :from => :base64, :to => :string }
+
+      it "determines the method using the hash's :to and :from keys" do
+        User._protobuf_column_converters[:public_key].should eq method
+      end
+    end
+
+    context "when the given converter is a symbol" do
+      context "when the converter is not a defined method" do
+        let(:callable) { User.method(:convert_base64_to_string) }
+
+        before { User.convert_column :email, :base64 }
+
+        it "determines the method using the converter as the 'from' and the column type as the 'to'" do
+          User._protobuf_column_converters[:email].should eq callable
+        end
+      end
+
+      context "when the converter is a defined method" do
+        let(:callable) { User.method(:convert_email_to_lowercase) }
+
+        before { User.convert_column :email, :convert_email_to_lowercase }
+
+        it "creates a callable method object from the converter" do
+          User._protobuf_column_converters[:email].should eq callable
+        end
+      end
+    end
+
+    context "when the given converter is nil" do
+      it "raises an exception" do
+        expect { User.convert_column :email, nil }.to raise_exception(Protoable::ColumnConverterError)
+      end
+    end
+
+    context "when the given converter is not callable" do
+      it "raises an exception" do
+        expect { User.convert_column :email, :foo }.to raise_exception(Protoable::ColumnConverterError)
+      end
+    end
+
+    context "when the given converter is callable" do
+      let(:callable) { lambda { |value| value } }
+
+      before { User.convert_column :email, callable }
+
+      it "adds the given converter to list of column converters" do
+        User._protobuf_column_converters[:email].should eq callable
+      end
+    end
+  end
+
+  describe ".protobuf_message" do
+    before { User.protobuf_message(protobuf_message) }
+
+    context "given a value" do
+      let(:protobuf_fields) { [ :name, :email, :tags ] }
+
+      it "sets .protobuf_fields" do
+        User.protobuf_fields.should =~ protobuf_fields
+      end
+
+      it "defines #to_proto" do
+        User.allocate.should respond_to :to_proto
+      end
+
+      it "defines #to_proto_hash" do
+        User.allocate.should respond_to :to_proto_hash
+      end
+    end
+
+    it "returns the protobuf message for this object" do
+      User.protobuf_message.should eq protobuf_message
+    end
+  end
+
+  context "when protobuf_message is defined" do
+    let(:attributes) { Hash.new }
+    let(:user) { User.new(attributes) }
+
+    before { User.protobuf_message(protobuf_message) }
+
+    describe "#protoable_attributes" do
+      let(:attributes) {
+        {
+          :first_name => "foo",
+          :last_name => "bar",
+          :email => "foo@test.co"
+        }
+      }
+      let(:protoable_attributes) { { :name => user.name, :email => user.email, :tags => nil } }
+
+      it "returns a hash of protobuf fields that this object has getters for" do
+        user.protoable_attributes.should eq protoable_attributes
+      end
+
+      it "converts attributes values for protobuf messages" do
+        user.should_receive(:_protobuf_convert_columns_to_fields).any_number_of_times
+        user.protoable_attributes
+      end
+    end
+
+    describe "#to_proto" do
+      let(:proto) { protobuf_message.new(proto_hash) }
+      let(:proto_hash) { { :name => "foo" } }
+
+      before { user.stub(:to_proto_hash).and_return(proto_hash) }
+
+      it "intializes a new protobuf message with attributes from #to_proto_hash" do
+        user.to_proto.should eq proto
+      end
+    end
+
+    describe "#to_proto_hash" do
+      let(:proto_hash) { { :name => "foo" } }
+
+      before { user.stub(:protoable_attributes).and_return(proto_hash) }
+
+      it "returns #protoable_attributes" do
+        user.to_proto_hash.should eq proto_hash
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler'
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+Bundler.require(:default, :development, :test)
+
+require 'support/db'
+require 'support/models'
+require 'support/protobuf'