protobuf-activerecord 1.2.6 → 2.0.0.beta

data/spec/protoable/serialization_spec.rb

@@ -3,6 +3,60 @@ require 'spec_helper'
 describe Protoable::Serialization do
   let(:protobuf_message) { UserMessage }
 
+  describe "._protobuf_convert_attributes_to_fields" do
+    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_attributes_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_attributes_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_attributes_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_attributes_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_attributes_to_fields(:foo, value).should eq value
+      end
+    end
+  end
+
   describe ".field_from_record" do
     context "when the given converter is a symbol" do
       let(:callable) { lambda { |value| User.__send__(:extract_first_name) } }
@@ -35,87 +89,117 @@ describe Protoable::Serialization do
     end
   end
 
-  describe ".protoable_attribute" do
-    context "when the given converter is a hash" do
-      let(:method) { lambda { |value| User.__send__(:convert_base64_to_string, value) } }
+  describe ".protobuf_message" do
+    let(:options) { { :only => [] } }
 
-      before { User.protoable_attribute :public_key, :from => :base64, :to => :string }
+    before { User.protobuf_message(protobuf_message, options) }
+    after { User.protobuf_message(protobuf_message, {}) }
 
-      it "determines the method using the hash's :to and :from keys" do
-        User.should_receive(:convert_base64_to_string)
-        User._protobuf_attribute_converters[:public_key].call(1)
+    context "given a value" do
+      it "defines #to_proto" do
+        User.allocate.should respond_to :to_proto
       end
     end
 
-    context "when the given converter is a symbol" do
-      let(:callable) { lambda { |value| User.__send__(:convert_email_to_lowercase, value) } }
+    context "given options" do
+      it "merges them with protobuf field options" do
+        User._protobuf_field_options.should eq options
+      end
+    end
+
+    it "returns the protobuf message for this object" do
+      User.protobuf_message.should eq protobuf_message
+    end
+  end
 
-      before { User.protoable_attribute :email, :convert_email_to_lowercase }
+  context "when protobuf_message is defined" do
+    let(:attributes) { Hash.new }
+    let(:user) { User.new(attributes) }
 
-      it "creates a callable method object from the converter" do
-        User.should_receive(:convert_email_to_lowercase)
-        User._protobuf_attribute_converters[:email].call(1)
+    before { User.protobuf_message(protobuf_message) }
+
+    describe "#_filter_field_attributes" do
+      context "when options has :only" do
+        it "only returns the given field(s)" do
+          fields = user._filter_field_attributes(:only => :name).should
+          fields.should eq [ :name ]
+        end
       end
-    end
 
-    context "when the given converter is not callable" do
-      it "raises an exception" do
-        expect { User.protoable_attribute :email, nil }.to raise_exception(Protoable::AttributeConverterError)
+      context "when options has :except" do
+        it "returns all except the given field(s)" do
+          fields = user._filter_field_attributes(:except => :name).should
+          fields.should eq [ :guid, :email, :email_domain ]
+        end
       end
     end
 
-    context "when the given converter is callable" do
-      let(:callable) { lambda { |value| value } }
-
-      before { User.protoable_attribute :email, callable }
+    describe "#_filtered_fields" do
+      it "returns protobuf fields" do
+        user._filtered_fields.should eq [ :guid, :name, :email, :email_domain ]
+      end
 
-      it "adds the given converter to list of attribute converters" do
-        User._protobuf_attribute_converters[:email].should eq callable
+      context "given :deprecated => false" do
+        it "filters all deprecated fields" do
+          fields = user._filtered_fields(:deprecated => false).should
+          fields.should eq [ :guid, :name, :email ]
+        end
       end
     end
-  end
 
-  describe ".protobuf_message" do
-    before { User.protobuf_message(protobuf_message) }
+    describe "#_normalize_options" do
+      let(:options) { { :only => [ :name ] } }
 
-    context "given a value" do
-      let(:protobuf_fields) { [ :guid, :name, :email, :email_domain ] }
+      context "given empty options" do
+        before { User.protobuf_message(protobuf_message, options) }
 
-      it "sets .protobuf_fields" do
-        User.protobuf_fields.should =~ protobuf_fields
+        it "returns the class's protobuf field options" do
+          User.allocate._normalize_options({}).should eq options
+        end
       end
 
-      it "defines #to_proto" do
-        User.allocate.should respond_to :to_proto
+      context "given options" do
+        before { User.protobuf_message(protobuf_message, {}) }
+
+        it "merges them with the class's protobuf field options" do
+          normalized_options = User.allocate._normalize_options(options)
+          normalized_options[:only].should eq options[:only]
+        end
       end
 
-      it "defines #to_proto_hash" do
-        User.allocate.should respond_to :to_proto_hash
+      context "given options with :only" do
+        before { User.protobuf_message(protobuf_message, {}) }
+
+        it "ensures that :except exists" do
+          normalized_options = User.allocate._normalize_options(options)
+          normalized_options[:except].should eq []
+        end
       end
-    end
 
-    it "returns the protobuf message for this object" do
-      User.protobuf_message.should eq protobuf_message
-    end
-  end
+      context "given options with :except" do
+        let(:options) { { :except => [ :name ] } }
 
-  context "when protobuf_message is defined" do
-    let(:attributes) { Hash.new }
-    let(:user) { User.new(attributes) }
+        before { User.protobuf_message(protobuf_message, {}) }
 
-    before { User.protobuf_message(protobuf_message) }
+        it "ensures that :only exists" do
+          normalized_options = User.allocate._normalize_options(options)
+          normalized_options[:only].should eq []
+        end
+      end
+    end
 
-    describe "#protoable_attributes" do
-      context "when a transformer is defined for the field" do
-        let(:attributes) {
-          {
-            :guid => "foo",
-            :first_name => "bar",
-            :last_name => "baz",
-            :email => "foo@test.co"
-          }
+    describe "#fields_from_record" do
+      let(:attributes) {
+        {
+          :guid => "foo",
+          :first_name => "bar",
+          :last_name => "baz",
+          :email => "foo@test.co"
         }
-        let(:protoable_attributes) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => 'test.co' } }
+      }
+
+      context "when a transformer is defined for the field" do
+        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => 'test.co' } }
         let(:transformer) { { :email_domain => lambda { |record| record.email.split('@').last } } }
 
         before {
@@ -123,28 +207,27 @@ describe Protoable::Serialization do
         }
 
         it "gets the field from the transformer" do
-          user.protoable_attributes.should eq protoable_attributes
+          user.fields_from_record.should eq fields_from_record
         end
       end
 
       context "when a transformer is not defined for the field" do
-        let(:attributes) {
-          {
-            :guid => "foo",
-            :first_name => "bar",
-            :last_name => "baz",
-            :email => "foo@test.co"
-          }
-        }
-        let(:protoable_attributes) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => nil } }
+        let(:fields_from_record) { { :guid => user.guid, :name => user.name, :email => user.email, :email_domain => nil } }
 
         it "returns a hash of protobuf fields that this object has getters for" do
-          user.protoable_attributes.should eq protoable_attributes
+          user.fields_from_record.should eq fields_from_record
         end
 
         it "converts attributes values for protobuf messages" do
           user.should_receive(:_protobuf_convert_attributes_to_fields).any_number_of_times
-          user.protoable_attributes
+          user.fields_from_record
+        end
+      end
+
+      context "given options with :include" do
+        it "adds the given field to the list of serialized fields" do
+          fields = user.fields_from_record(:include => :token)
+          fields.include?(:token).should be_true
         end
       end
     end
@@ -153,21 +236,11 @@ describe Protoable::Serialization do
       let(:proto) { protobuf_message.new(proto_hash) }
       let(:proto_hash) { { :name => "foo" } }
 
-      before { user.stub(:to_proto_hash).and_return(proto_hash) }
+      before { user.stub(:fields_from_record).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/protoable/transformation_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe Protoable::Transformation 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) { UserMessage.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 "includes attributes that aren't fields, but have attribute transformers" do
+      User.stub(:_protobuf_attribute_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 "._protobuf_convert_fields_to_columns" do
+    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
+
+  describe ".attributes_from_proto" do
+    context "when a transformer is defined for the attribute" 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 a transformer is a callable that returns nil" do
+      before do
+        transformers = User._protobuf_attribute_transformers
+        User.stub(:_protobuf_attribute_transformers).and_return(
+          {:account_id => lambda { |proto| nil }}.merge(transformers)
+        )
+      end
+
+      it "does not set the attribute" do
+        attribute_fields = User.attributes_from_proto(proto)
+        attribute_fields.should eq user_attributes
+      end
+    end
+
+    context "when a transformer is a callable that returns a value" do
+      before do
+        transformers = User._protobuf_attribute_transformers
+        User.stub(:_protobuf_attribute_transformers).and_return(
+          {:account_id => lambda { |proto| 1 }}.merge(transformers)
+        )
+      end
+
+      it "sets the attribute" do
+        attribute_fields = User.attributes_from_proto(proto)
+        attribute_fields.should eq user_attributes.merge(:account_id => 1)
+      end
+    end
+
+    context "when a transformer is not defined for the attribute" 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 ".attribute_from_proto" do
+    context "when the given transformer is a symbol" do
+      let(:callable) { lambda { |value| User.__send__(:extract_first_name) } }
+
+      before { User.attribute_from_proto :first_name, :extract_first_name }
+
+      it "creates a callable method object from the converter" do
+        User.should_receive(:extract_first_name)
+        User._protobuf_attribute_transformers[:first_name].call(1)
+      end
+    end
+
+    context "when the given transformer is not callable" do
+      it "raises an exception" do
+        expect { User.attribute_from_proto :name, nil }.to raise_exception(Protoable::AttributeTransformerError)
+      end
+    end
+
+    context "when the given transformer is callable" do
+      let(:callable) { lambda { |proto| nil } }
+
+      before {
+        User.stub(:_protobuf_attribute_transformers).and_return(Hash.new)
+        User.attribute_from_proto :account_id, callable
+      }
+
+      it "adds the given converter to the list of protobuf field transformers" do
+        User._protobuf_attribute_transformers[:account_id] = callable
+      end
+    end
+  end
+  
+  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 "#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
+end