protobuf-activerecord 7.0.0 → 7.1.0

data/protobuf-activerecord.gemspec

@@ -1,47 +0,0 @@
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "protobuf/active_record/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "protobuf-activerecord"
-  spec.version = Protobuf::ActiveRecord::VERSION
-  spec.authors = ["Adam Hutchison"]
-  spec.email = ["liveh2o@gmail.com"]
-  spec.homepage = "http://github.com/liveh2o/protobuf-activerecord"
-  spec.summary = "Google Protocol Buffers integration for Active Record"
-  spec.description = "Provides the ability to create Active Record objects from Protocol Buffer messages and vice versa."
-  spec.license = "MIT"
-
-  spec.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables = spec.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  ##
-  # Dependencies
-  #
-  spec.add_dependency "activerecord", "~> 7.0.0"
-  spec.add_dependency "activesupport", "~> 7.0.0"
-  spec.add_dependency "concurrent-ruby"
-  spec.add_dependency "heredity", ">= 0.1.1"
-  spec.add_dependency "protobuf", ">= 3.0"
-
-  ##
-  # Development dependencies
-  #
-  spec.add_development_dependency "benchmark-ips"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", ">= 3.3.0"
-  spec.add_development_dependency "rspec-pride", ">= 3.1.0"
-  spec.add_development_dependency "pry-nav"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "standard"
-
-  if ENV["PLATFORM"] == "java" || ::RUBY_PLATFORM == "java"
-    spec.platform = "java"
-    spec.add_development_dependency "activerecord-jdbcsqlite3-adapter"
-  else
-    spec.add_development_dependency "sqlite3", ">= 1.4"
-  end
-
-  spec.add_development_dependency "timecop"
-end

data/spec/protobuf/active_record/columns_spec.rb

@@ -1,98 +0,0 @@
-require "spec_helper"
-
-describe Protobuf::ActiveRecord::Columns do
-  describe "._protobuf_map_columns" do
-    context "when the class has a table" do
-      let(:expected_column_names) {
-        User.columns.each_with_object({}) do |column, hash|
-          hash[column.name.to_sym] = column
-        end
-      }
-
-      let(:expected_column_types) {
-        User.columns.each_with_object({}) do |column, hash|
-          hash[column.type.to_sym] ||= ::Set.new
-          hash[column.type.to_sym] << column.name.to_sym
-        end
-      }
-
-      it "maps columns by name" do
-        expect(User._protobuf_columns).to eq expected_column_names
-      end
-
-      it "maps column names by column type" do
-        expected_column_types.each do |expected_column_type, value|
-          expect(User._protobuf_column_types).to include expected_column_type => value
-        end
-      end
-    end
-  end
-
-  context "column type predicates" do
-    before { allow(User).to receive(:_protobuf_column_types).and_return({}) }
-
-    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
-          expect(User._protobuf_date_column?(:foo_date)).to be true
-        end
-      end
-
-      context "when the column type is not :date" do
-        it "is false" do
-          expect(User._protobuf_date_column?(:bar_date)).to 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
-          expect(User._protobuf_datetime_column?(:foo_datetime)).to be true
-        end
-      end
-
-      context "when the column type is not :datetime" do
-        it "is false" do
-          expect(User._protobuf_datetime_column?(:bar_datetime)).to 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
-          expect(User._protobuf_time_column?(:foo_time)).to be true
-        end
-      end
-
-      context "when the column type is not :time" do
-        it "is false" do
-          expect(User._protobuf_time_column?(:bar_time)).to 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
-          expect(User._protobuf_timestamp_column?(:foo_timestamp)).to be true
-        end
-      end
-
-      context "when the column type is not :timestamp" do
-        it "is false" do
-          expect(User._protobuf_timestamp_column?(:bar_timestamp)).to be false
-        end
-      end
-    end
-  end
-end

data/spec/protobuf/active_record/nested_attributes_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Protobuf::ActiveRecord::NestedAttributes do
-  let(:user_message) {
-    UserMessage.new(name: "foo bar", email: "foo@test.co", photos: [{url: "https://test.co/test.png"}])
-  }
-
-  describe "._filter_attribute_fields", aggregate_failures: true do
-    it "includes nested attributes" do
-      attribute_fields = User._filter_attribute_fields(user_message)
-      expect(attribute_fields[:photos_attributes]).to eq(user_message.photos)
-    end
-
-    context "when" do
-    end
-  end
-
-  describe ".new" do
-    context "when a model accepts nested attributes" do
-      it "transforms nested attributes", aggregate_failures: true do
-        user_message.photos.each do |photo_message|
-          expect(Photo).to receive(:attributes_from_proto).with(photo_message).and_call_original
-        end
-        User.new(user_message)
-      end
-    end
-  end
-end

data/spec/protobuf/active_record/persistence_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-describe Protobuf::ActiveRecord::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) { UserMessage.new(proto_hash) }
-
-  describe ".create" do
-    it "accepts a protobuf message" do
-      expect_any_instance_of(User).to receive(:save)
-      User.create(proto)
-    end
-
-    it "accepts a hash" do
-      expect_any_instance_of(User).to receive(:save)
-      User.create(user_attributes)
-    end
-  end
-
-  describe ".create!" do
-    it "accepts a protobuf message" do
-      expect_any_instance_of(User).to receive(:save!)
-      User.create!(proto)
-    end
-
-    it "accepts a hash" do
-      expect_any_instance_of(User).to receive(:save!)
-      User.create!(user_attributes)
-    end
-  end
-
-  describe "#assign_attributes" do
-    let(:user) { ::User.new }
-
-    it "accepts a protobuf message" do
-      user.assign_attributes(proto)
-      expect(user.changed?).to be true
-    end
-
-    it "accepts a hash" do
-      user.assign_attributes(user_attributes)
-      expect(user.changed?).to be true
-    end
-  end
-
-  describe "#update" do
-    it "accepts a protobuf message" do
-      expect_any_instance_of(User).to receive(:save)
-      user.update(proto)
-    end
-
-    it "accepts a hash" do
-      expect_any_instance_of(User).to receive(:save)
-      user.update(user_attributes)
-    end
-  end
-
-  describe "#update!" do
-    it "accepts a protobuf message" do
-      expect_any_instance_of(User).to receive(:save!)
-      user.update!(proto)
-    end
-
-    it "accepts a hash" do
-      expect_any_instance_of(User).to receive(:save!)
-      user.update!(user_attributes)
-    end
-  end
-end

data/spec/protobuf/active_record/scope_spec.rb

@@ -1,201 +0,0 @@
-require "spec_helper"
-
-class TheEnum < ::Protobuf::Enum
-  define :VALUE, 1
-end
-
-class TheMessage < ::Protobuf::Message
-  optional TheEnum, :the_enum_value, 1
-end
-
-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
-        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| } }
-
-      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