protobuf-activerecord 6.1.0 → 7.1.0

data/spec/protobuf/active_record/scope_spec.rb

@@ -1,201 +0,0 @@
-require "spec_helper"
-
-describe Protobuf::ActiveRecord::Scope do
-  before do
-    @field_parsers = User.instance_variable_get("@_searchable_field_parsers")
-    @fields = User.instance_variable_get("@_searchable_fields")
-  end
-
-  after do
-    User.instance_variable_set("@_searchable_field_parsers", @field_parsers)
-    User.instance_variable_set("@_searchable_fields", @fields)
-    User.instance_variable_set("@_upsert_keys", [])
-  end
-
-  describe ".search_scope" do
-    let(:request) { UserSearchMessage.new(:guid => ["foo"], :email => ["foo@test.co"]) }
-
-    before {
-      allow(User).to receive(:searchable_field_parsers).and_return(:email => proc { |val| val })
-    }
-
-    it "builds scopes for searchable fields" do
-      allow(User).to receive(:searchable_fields).and_return(:email => :by_email)
-      expect(User.search_scope(request)).to eq User.by_email("foo@test.co")
-    end
-
-    it "is chainable" do
-      expect(User.limit(1).search_scope(request).order(:email)).to eq User.limit(1).order(:email)
-    end
-
-    context "when a searchable field does not have a value" do
-      let(:request) { UserSearchMessage.new(:email => ["foo@test.co"]) }
-
-      it "doesn't build a scope from that field" do
-        allow(User).to receive(:searchable_fields).and_return(:email => :by_email)
-        expect(User.search_scope(request)).to eq User.by_email("foo@test.co")
-      end
-    end
-
-    context "when a searchable field uses a non-existant scope" do
-      let(:request) { UserSearchMessage.new(:email => ["foo@test.co"]) }
-
-      it "raises an exception" do
-        allow(User).to receive(:searchable_fields).and_return(:email => :by_hullabaloo)
-        expect { User.search_scope(request) }.to raise_exception(/undefined method .*by_hullabaloo/i)
-      end
-    end
-  end
-
-  describe ".field_scope" do
-    context "when :scope is not defined" do
-      it "defines the given field as searchable using the `by_[:field]` as the scope" do
-        User.field_scope :guid
-        expect(User.searchable_fields[:guid]).to eq :by_guid
-      end
-    end
-
-    context "when :scope is defined" do
-      it "defines the given field as searchable using the given :scope" do
-        User.field_scope :guid, :scope => :custom_scope
-        expect(User.searchable_fields[:guid]).to eq :custom_scope
-      end
-    end
-
-    context "when :parser is not defined" do
-      it "doesn't define the given field as parseable" do
-        User.field_scope :guid
-        expect(User.searchable_field_parsers[:guid]).to eq nil
-      end
-    end
-
-    context "when :parser is defined" do
-      it "defines the given field as parseable using the given :parser" do
-        User.field_scope :guid, :parser => :parser
-        expect(User.searchable_field_parsers[:guid]).to eq :parser
-      end
-    end
-  end
-
-  describe ".parse_search_values" do
-    it "converts single values to collections" do
-      proto = UserMessage.new(:email => "the.email@test.in")
-
-      User.field_scope :email
-      expect(User.parse_search_values(proto, :email)).to eq ["the.email@test.in"]
-    end
-
-    context "when a field parser is defined" do
-      before { User.field_scope :guid, :parser => parser }
-
-      let(:proto) { UserSearchMessage.new(:guid => ["foo"]) }
-
-      context "and the parser does not respond to :to_sym" do
-        let(:parser) { double("parser") }
-
-        it "passes the value to the parser" do
-          expect(parser).to receive(:call).with(["foo"])
-          User.parse_search_values(proto, :guid)
-        end
-      end
-    end
-
-    context "when the field is an enum" do
-      it "maps values to integers" do
-        TheEnum = Class.new(::Protobuf::Enum) do
-          define :VALUE, 1
-        end
-
-        TheMessage = Class.new(::Protobuf::Message) do
-          optional TheEnum, :the_enum_value, 1
-        end
-
-        proto = TheMessage.new(:the_enum_value => TheEnum::VALUE)
-        expect(User.parse_search_values(proto, :the_enum_value)[0]).to be 1
-      end
-    end
-  end
-
-  describe ".upsert_key" do
-    it "adds the fields to the upsert_keys" do
-      ::User.field_scope(:guid)
-      ::User.upsert_key(:guid)
-      expect(::User.upsert_keys).to eq([[:guid]])
-    end
-
-    context "no field_scope defined" do
-      it "raises an error" do
-        expect { ::User.upsert_key(:foobar) }.to raise_error(::Protobuf::ActiveRecord::UpsertScopeError)
-      end
-    end
-  end
-
-  describe ".for_upsert" do
-    let(:guid) { "USR-1" }
-    let(:proto) { ::UserMessage.new(:guid => guid) }
-
-    before do
-      ::User.delete_all
-      ::User.field_scope(:guid)
-      ::User.upsert_key(:guid)
-    end
-
-    context "no matching upsert keys" do
-      let(:proto) { ::UserMessage.new }
-
-      it "raises an error" do
-        expect { ::User.for_upsert(proto) }.to raise_error(::Protobuf::ActiveRecord::UpsertNotFoundError)
-      end
-    end
-
-    context "no existing records" do
-      it "returns a new record" do
-        record = ::User.for_upsert(proto)
-        expect(record.new_record?).to be true
-      end
-    end
-
-    context "existing record" do
-      before { ::User.create(:guid => guid) }
-      after { ::User.delete_all }
-
-      it "returns the existing record" do
-        record = ::User.for_upsert(proto)
-        expect(record.new_record?).to be false
-      end
-    end
-  end
-
-  describe ".upsert" do
-    let(:guid) { "USR-1" }
-    let(:proto) { ::UserMessage.new(:guid => guid, :email => "bar") }
-
-    before do
-      ::User.delete_all
-      ::User.field_scope(:guid)
-      ::User.upsert_key(:guid)
-    end
-
-    context "no existing records" do
-      it "creates a new record" do
-        ::User.upsert(proto)
-        expect(::User.count).to eq(1)
-      end
-    end
-
-    context "existing record" do
-      before { ::User.create(:guid => guid, :email => "foo") }
-      after { ::User.delete_all }
-
-      it "updates the existing record" do
-        ::User.upsert(proto)
-        expect(::User.first.email).to eq("bar")
-      end
-
-      it "returns a user" do
-        result = ::User.upsert(proto)
-        expect(result).to be_a(::User)
-      end
-    end
-  end
-end

data/spec/protobuf/active_record/serialization_spec.rb

@@ -1,208 +0,0 @@
-require "spec_helper"
-
-# Used to test calling #to_proto when no protobuf message is configured.
-class UnconfiguredUser
-  include Protobuf::ActiveRecord::Model
-end
-
-describe Protobuf::ActiveRecord::Serialization do
-  let(:protobuf_message) { UserMessage }
-
-  describe ".field_from_record" do
-    context "when the given transformer is a symbol" do
-      before { User.field_from_record :first_name, :extract_first_name }
-
-      it "creates a symbol transformer from the converter" do
-        expect(User._protobuf_field_symbol_transformers[:first_name]).to eq :extract_first_name
-      end
-    end
-
-    context "when the given transformer is not callable" do
-      it "raises an exception" do
-        expect { User.field_from_record :name, nil }.to raise_exception(Protobuf::ActiveRecord::FieldTransformerError)
-      end
-    end
-
-    context "when the given transformer is callable" do
-      let(:callable) { lambda { |_proto| nil } }
-
-      before {
-        allow(User).to receive(:_protobuf_field_transformers).and_return({})
-        User.field_from_record :account_id, callable
-      }
-
-      it "adds the given converter to the list of protobuf field transformers" do
-        expect(User._protobuf_field_transformers[:account_id]).to eq(callable)
-      end
-    end
-  end
-
-  describe ".protobuf_message" do
-    let(:options) { { :only => [] } }
-
-    before { User.protobuf_message(protobuf_message, options) }
-    after { User.protobuf_message(protobuf_message, {}) }
-
-    context "given a value" do
-      it "defines #to_proto" do
-        expect(User.allocate).to respond_to :to_proto
-      end
-    end
-
-    context "given options" do
-      it "merges them with protobuf field options" do
-        expect(User._protobuf_field_options).to eq options
-      end
-    end
-
-    it "returns the protobuf message for this object" do
-      expect(User.protobuf_message).to eq protobuf_message
-    end
-  end
-
-  context "when protobuf_message is defined" do
-    let(:attributes) { {} }
-    let(:user) { User.new(attributes) }
-
-    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)
-          expect(fields).to eq [:name]
-        end
-      end
-
-      context "when options has :except" do
-        it "returns all except the given field(s)" do
-          fields = user._filter_field_attributes(:except => :name)
-          expect(fields).to match_array(
-            [:guid, :email, :email_domain, :password, :nullify, :photos, :created_at, :updated_at]
-          )
-        end
-      end
-    end
-
-    describe "#_filtered_fields" do
-      it "returns protobuf fields" do
-        expect(user._filtered_fields).to match_array(
-          [:guid, :name, :email, :email_domain, :password, :nullify, :photos, :created_at, :updated_at]
-        )
-      end
-
-      context "given :deprecated => false" do
-        it "filters all deprecated fields" do
-          fields = user._filtered_fields(:deprecated => false)
-          expect(fields).to match_array(
-            [:guid, :name, :email, :password, :nullify, :photos, :created_at, :updated_at]
-          )
-        end
-
-        context "and :include => :email_domain" do
-          it "includes deprecated fields that have been explicitly specified" do
-            fields = user._filtered_fields(:deprecated => false, :include => :email_domain)
-            expect(fields).to match_array(
-              [:guid, :name, :email, :email_domain, :password, :nullify, :photos, :created_at, :updated_at]
-            )
-          end
-        end
-      end
-    end
-
-    describe "#_normalize_options" do
-      let(:options) { { :only => [:name] } }
-
-      context "given empty options" do
-        before { User.protobuf_message(protobuf_message, options) }
-
-        it "returns the class's protobuf field options" do
-          expect(User.allocate._normalize_options({})).to eq options
-        end
-      end
-
-      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)
-          expect(normalized_options[:only]).to eq options[:only]
-        end
-      end
-
-      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)
-          expect(normalized_options[:except]).to eq []
-        end
-      end
-
-      context "given options with :except" do
-        let(:options) { { :except => [:name] } }
-
-        before { User.protobuf_message(protobuf_message, {}) }
-
-        it "ensures that :only exists" do
-          normalized_options = User.allocate._normalize_options(options)
-          expect(normalized_options[:only]).to eq []
-        end
-      end
-    end
-
-    describe "#fields_from_record" do
-      let(:attributes) {
-        {
-          :guid => "foo",
-          :first_name => "bar",
-          :last_name => "baz",
-          :email => "foo@test.co"
-        }
-      }
-
-      context "when a transformer is defined for the field" do
-        it "gets the field from the transformer" do
-          expect(user.fields_from_record[:email_domain]).to eq("test.co")
-        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)
-          expect(fields).to include(:token)
-        end
-      end
-
-      context "when a field is a collection association" do
-        let(:user) { User.create(attributes) }
-
-        it "terminates the association proxy" do
-          fields = user.fields_from_record(:include => :photos)
-          expect(fields[:photos]).to be_an(Array)
-        end
-      end
-    end
-
-    describe "#to_proto" do
-      context "when a protobuf message is configured" do
-        let(:proto) { protobuf_message.new(proto_hash) }
-        let(:proto_hash) { { :name => "foo" } }
-
-        before { allow(user).to receive(:fields_from_record).and_return(proto_hash) }
-
-        it "intializes a new protobuf message with attributes from #to_proto_hash" do
-          expect(user.to_proto).to eq proto
-        end
-      end
-
-      context "when a protobuf message is not configured" do
-        let(:user) { UnconfiguredUser.new }
-
-        it "raises an exception" do
-          expect { user.to_proto }.to raise_exception(Protobuf::ActiveRecord::MessageNotDefined)
-        end
-      end
-    end
-  end
-end

data/spec/protobuf/active_record/transformation_spec.rb

@@ -1,254 +0,0 @@
-require "spec_helper"
-
-describe Protobuf::ActiveRecord::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)
-      expect(attribute_fields[:email]).to eq proto_hash[:email]
-    end
-
-    it "filters repeated fields" do
-      attribute_fields = User._filter_attribute_fields(proto)
-      expect(attribute_fields.key?(:tags)).to be false
-    end
-
-    it "includes attributes that aren't fields, but have attribute transformers" do
-      allow(User).to receive(:_protobuf_attribute_transformers).and_return(:account_id => :fetch_account_id)
-      attribute_fields = User._filter_attribute_fields(proto)
-      expect(attribute_fields.key?(:account_id)).to be true
-    end
-
-    it "includes fields that aren't attributes, but have attribute transformers" do
-      attribute_fields = User._filter_attribute_fields(proto)
-      expect(attribute_fields.key?(:password)).to be true
-    end
-  end
-
-  describe "._protobuf_convert_fields_to_attributes" 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 {
-        allow(User).to receive(:_protobuf_date_datetime_time_or_timestamp_column?).and_return(true)
-        allow(User).to receive(:_protobuf_date_column?).and_return(true)
-      }
-
-      it "converts the given value to a Date object" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_date, value)).to 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 {
-        allow(User).to receive(:_protobuf_date_datetime_time_or_timestamp_column?).and_return(true)
-        allow(User).to receive(:_protobuf_datetime_column?).and_return(true)
-      }
-
-      it "converts the given value to a DateTime object" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_datetime, value)).to be_a(DateTime)
-      end
-
-      it "converts the given value to a DateTime object of the same value" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_datetime, value)).to 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 {
-        allow(User).to receive(:_protobuf_date_datetime_time_or_timestamp_column?).and_return(true)
-        allow(User).to receive(:_protobuf_time_column?).and_return(true)
-      }
-
-      it "converts the given value to a Time object" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to be_a(Time)
-      end
-
-      it "converts the given value to a Time object of the same value" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to 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 {
-        allow(User).to receive(:_protobuf_date_datetime_time_or_timestamp_column?).and_return(true)
-        allow(User).to receive(:_protobuf_timestamp_column?).and_return(true)
-      }
-
-      it "converts the given value to a Time object" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_time, value)).to be_a(Time)
-      end
-
-      it "converts the given value to a Time object of the same value" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo_timestamp, value)).to be_within(1).of(time)
-      end
-    end
-
-    context "when no conversion is necessary" do
-      let(:value) { "Foo" }
-
-      it "returns the given value" do
-        expect(User._protobuf_convert_fields_to_attributes(:foo, value)).to eq value
-      end
-    end
-  end
-
-  describe ".attributes_from_proto" do
-    let(:callable) { lambda { |_proto| 1 } }
-    let(:transformer) { ::Protobuf::ActiveRecord::Transformer.new(callable) }
-
-    context "when a transformer is defined for the attribute" do
-      it "transforms the field value" do
-        attribute_fields = User.attributes_from_proto(proto)
-        expect(attribute_fields[:first_name]).to eq user_attributes[:first_name]
-      end
-    end
-
-    context "when a transformer is a callable that returns nil" do
-      let(:callable) { lambda { |_proto| nil } }
-
-      before do
-        transformers = User._protobuf_attribute_transformers
-        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
-          { :account_id => transformer }.merge(transformers)
-        )
-      end
-
-      it "does not set the attribute" do
-        attribute_fields = User.attributes_from_proto(proto)
-        expect(attribute_fields).to eq user_attributes
-      end
-    end
-
-    context "when the transformer has a nullify_on option" do
-      let(:callable) { lambda { |_proto| nil } }
-      let(:transformer) { ::Protobuf::ActiveRecord::Transformer.new(callable, :nullify_on => :account_id) }
-      let(:proto_hash) { { :name => "foo bar", :email => "foo@test.co", :nullify => [:account_id] } }
-
-      before do
-        transformers = User._protobuf_attribute_transformers
-        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
-          { :account_id => transformer }.merge(transformers)
-        )
-      end
-
-      it "does not set the attribute" do
-        attribute_fields = User.attributes_from_proto(proto)
-        expect(attribute_fields).to include(:account_id => nil)
-      end
-    end
-
-    context "when a transformer is a callable that returns a value" do
-      before do
-        transformers = User._protobuf_attribute_transformers
-        allow(User).to receive(:_protobuf_attribute_transformers).and_return(
-          { :account_id => transformer }.merge(transformers)
-        )
-      end
-
-      it "sets the attribute" do
-        attribute_fields = User.attributes_from_proto(proto)
-        expect(attribute_fields).to eq user_attributes.merge(:account_id => 1)
-      end
-    end
-
-    context "when a transformer is not defined for the attribute" do
-      before {
-        allow(User).to receive(:_protobuf_convert_fields_to_attributes) do |_key, value|
-          value
-        end
-      }
-
-      it "converts the field value" do
-        attribute_fields = User.attributes_from_proto(proto)
-        expect(attribute_fields).to 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
-        expect(User).to 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(Protobuf::ActiveRecord::AttributeTransformerError)
-      end
-    end
-
-    context "when the given transformer is callable" do
-      let(:callable) { lambda { |_proto| nil } }
-
-      before { allow(User).to receive(:_protobuf_attribute_transformers).and_return({}) }
-
-      it "adds the given converter to the list of protobuf field transformers" do
-        User.attribute_from_proto :account_id, callable
-        expect(User._protobuf_attribute_transformers[:account_id].callable).to eq 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
-        expect(User.convert_int64_to_date(int64)).to eq date
-      end
-    end
-  end
-
-  describe ".convert_int64_to_datetime" do
-    let(:datetime) { DateTime.current }
-    let(:int64) { datetime.to_i }
-
-    it "initializes a new DateTime object from the value" do
-      Timecop.freeze(DateTime.current) do
-        expected_datetime = Time.at(datetime.to_i)
-        converted_datetime = User.convert_int64_to_datetime(int64)
-        expect(converted_datetime).to eq expected_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
-        expect(User.convert_int64_to_time(int64)).to be_within(1).of(time)
-      end
-    end
-  end
-
-  describe "#attributes_from_proto" do
-    it "gets attributes from the given protobuf message" do
-      expect(User).to receive(:attributes_from_proto).with(proto)
-      user.attributes_from_proto(proto)
-    end
-  end
-end

data/spec/protobuf/active_record/transformer_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe ::Protobuf::ActiveRecord::Transformer do
-  let(:callable) { lambda { |proto| proto.name } }
-  let(:proto) { ::UserMessage.new(:name => "test", :nullify => ["name"]) }
-  let(:options) { {} }
-
-  subject { described_class.new(callable, options) }
-
-  describe "#call" do
-    it "calls the callable" do
-      result = subject.call(proto)
-      expect(result).to eq("test")
-    end
-  end
-
-  describe "#nullify?" do
-    context "no nullify_on set" do
-      it "returns false" do
-        expect(subject.nullify?(proto)).to eq(false)
-      end
-    end
-
-    context "nullify_on name" do
-      let(:options) { { :nullify_on => :name } }
-
-      context "invalid message" do
-        let(:proto) { ::UserSearchMessage.new }
-
-        it "returns false" do
-          expect(subject.nullify?(proto)).to eq(false)
-        end
-      end
-
-      context "valid message" do
-        it "returns true" do
-          expect(subject.nullify?(proto)).to eq(true)
-        end
-      end
-    end
-  end
-end