active_remote 7.1.0 → 7.2.0

data/spec/lib/active_remote/rpc_spec.rb

@@ -1,86 +0,0 @@
-require "spec_helper"
-
-describe ::ActiveRemote::RPC do
-  subject { ::Tag.new }
-
-  describe ".build_from_rpc" do
-    let(:new_attributes) { {name: "test"} }
-
-    it "dups the default attributes" do
-      expect { ::Tag.build_from_rpc(new_attributes).to_h }.to_not change { ::Tag._default_attributes["name"] }
-    end
-
-    context "missing attributes from rpc" do
-      it "initializes to nil" do
-        expect(::Tag.build_from_rpc(new_attributes).to_h).to include("guid" => nil)
-      end
-    end
-
-    context "extra attributes from rpc" do
-      let(:new_attributes) { {foobar: "test"} }
-
-      it "ignores unknown attributes" do
-        expect(::Tag.build_from_rpc(new_attributes).to_h).to_not include("foobar" => "test")
-      end
-    end
-
-    context "typecasted attributes" do
-      let(:new_attributes) { {birthday: "2017-01-01"} }
-
-      it "calls the typecasters" do
-        expect(::Author.build_from_rpc(new_attributes).to_h).to include({"birthday" => "2017-01-01".to_datetime})
-      end
-    end
-  end
-
-  describe ".remote_call" do
-    let(:args) { double(:args) }
-    let(:response) { double(:response) }
-
-    let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class, ::Tag.endpoints) }
-
-    before { allow(rpc).to receive(:execute).and_return(response) }
-    before { allow(::Tag).to receive(:rpc).and_return(rpc) }
-
-    it "calls the given RPC method" do
-      expect(::Tag.rpc).to receive(:execute).with(:remote_method, args)
-      ::Tag.remote_call(:remote_method, args)
-    end
-
-    it "returns the response" do
-      allow(::Tag.rpc).to receive(:execute).and_return(response)
-      expect(::Tag.remote_call(:remote_method, args)).to eq response
-    end
-  end
-
-  describe "#assign_attributes_from_rpc" do
-    let(:response) { ::Generic::Remote::Tag.new(guid: tag.guid, name: "bar") }
-    let(:tag) { ::Tag.new(guid: SecureRandom.uuid) }
-
-    it "updates the attributes from the response" do
-      expect { tag.assign_attributes_from_rpc(response) }.to change { tag.name }.to(response.name)
-    end
-
-    context "when response does not respond to errors" do
-      let(:response) { double(:response, to_hash: {}) }
-
-      it "does not add errors from the response" do
-        expect { tag.assign_attributes_from_rpc(response) }.to_not change { tag.has_errors? }
-      end
-    end
-
-    context "when errors are returned" do
-      let(:response) {
-        ::Generic::Remote::Tag.new(
-          guid: tag.guid,
-          name: "bar",
-          errors: [{field: "name", message: "message"}]
-        )
-      }
-
-      it "adds errors from the response" do
-        expect { tag.assign_attributes_from_rpc(response) }.to change { tag.has_errors? }.to(true)
-      end
-    end
-  end
-end

data/spec/lib/active_remote/scope_keys_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::ScopeKeys do
-  let(:key) { :user_guid }
-  let(:_scope_keys) { ["user_guid"] }
-  let(:scope_keys) { ["guid"] + _scope_keys }
-  let(:tag) { Tag.new(tag_hash) }
-  let(:tag_hash) { {guid: "TAG-123", user_guid: "USR-123", name: "teh tag"} }
-
-  describe ".scope_key" do
-    after { Tag._scope_keys = [] }
-
-    it "adds scope_key to _scope_keys" do
-      Tag.scope_key(key)
-      expect(Tag._scope_keys).to eq(_scope_keys)
-    end
-  end
-
-  describe ".scope_keys" do
-    before { allow(Tag).to receive(:_scope_keys).and_return(_scope_keys) }
-
-    it "combines primary key with _scope_keys" do
-      expect(Tag.scope_keys).to eq(["guid"] + _scope_keys)
-    end
-  end
-
-  describe "#scope_keys" do
-    it "returns the scope keys for the class" do
-      expect(Tag.new.scope_keys).to eq Tag.scope_keys
-    end
-  end
-
-  describe "#scope_key_hash" do
-    let(:scope_key_hash) { {"guid" => "TAG-123", "user_guid" => "USR-123"} }
-
-    before { allow(tag).to receive(:scope_keys).and_return(scope_keys) }
-
-    it "returns a attribute hash of scope_keys" do
-      expect(tag.scope_key_hash).to eq(scope_key_hash)
-    end
-  end
-end

data/spec/lib/active_remote/search_spec.rb

@@ -1,114 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Search do
-  let(:records) { [Generic::Remote::Tag.new(guid: "123")] }
-  let(:response) { Generic::Remote::Tags.new(records: records) }
-  let(:rpc) { double(:rpc) }
-
-  describe ".find" do
-    let(:args) { {} }
-    let(:record) { double(:record) }
-    let(:records) { [record] }
-
-    before { allow(Tag).to receive(:search).and_return(records) }
-
-    it "searches with the given args" do
-      expect(Tag).to receive(:search).with(args)
-      Tag.find(args)
-    end
-
-    context "when records are returned" do
-      it "returns the first record" do
-        expect(Tag.find(args)).to eq record
-      end
-    end
-
-    context "when no records are returned" do
-      before { allow(Tag).to receive(:search).and_return([]) }
-
-      it "raise an exception" do
-        expect { Tag.find(args) }.to raise_error(::ActiveRemote::RemoteRecordNotFound)
-      end
-
-      it "gives the class of the remote record not found in the message" do
-        expect { Tag.find(args) }.to raise_error(::ActiveRemote::RemoteRecordNotFound, /Tag/)
-      end
-    end
-  end
-
-  describe ".find_by" do
-    let(:args) { {} }
-    let(:record) { double(:record) }
-    let(:records) { [record] }
-
-    before { allow(Tag).to receive(:search).and_return(records) }
-
-    it "searches with the given args" do
-      expect(Tag).to receive(:search).with(args)
-      Tag.find_by(args)
-    end
-
-    context "when records are returned" do
-      it "returns the first record" do
-        expect(Tag.find_by(args)).to eq record
-      end
-    end
-
-    context "when no records are returned" do
-      before { allow(Tag).to receive(:search).and_return([]) }
-
-      it "returns nil" do
-        expect(Tag.find_by(args)).to be_nil
-      end
-    end
-  end
-
-  describe ".search" do
-    let(:serialized_records) { [Tag.instantiate(guid: "123")] }
-
-    context "given args that respond to :to_hash" do
-      let(:args) { {} }
-      let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class, ::Tag.endpoints) }
-
-      before { allow(rpc).to receive(:execute).and_return(response) }
-      before { allow(::Tag).to receive(:rpc).and_return(rpc) }
-
-      it "searches with the given args" do
-        expect(Tag.rpc).to receive(:execute).with(:search, args)
-        Tag.search(args)
-      end
-
-      it "returns records" do
-        records = Tag.search(args)
-        expect(records).to eq serialized_records
-      end
-    end
-
-    context "given args that don't respond to :to_hash" do
-      let(:request) { double(:request) }
-
-      it "raises an exception" do
-        expect { Tag.search(request) }.to raise_error(::RuntimeError, /Invalid parameter/)
-      end
-    end
-  end
-
-  describe "#reload" do
-    let(:args) { attributes.slice("guid", "user_guid") }
-    let(:attributes) { HashWithIndifferentAccess.new(guid: "foo", name: "bar", updated_at: nil, user_guid: "baz") }
-
-    subject { Tag.new(args) }
-
-    before { allow(Tag).to receive(:find).and_return(Tag.new(attributes)) }
-
-    it "reloads the record" do
-      expect(Tag).to receive(:find).with(subject.scope_key_hash)
-      subject.reload
-    end
-
-    it "assigns new attributes" do
-      subject.reload
-      expect(subject.attributes).to eq attributes
-    end
-  end
-end

data/spec/lib/active_remote/serialization_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Serialization do
-  describe ".serialize_records" do
-    let(:records) { [{foo: "bar"}] }
-
-    subject { Tag.new }
-
-    it "serializes records into active remote objects" do
-      Tag.serialize_records(records).each do |record|
-        expect(record).to be_a Tag
-      end
-    end
-  end
-
-  describe "#add_errors" do
-    let(:error) { Generic::Error.new(field: "name", message: "Boom!") }
-    let(:response) {
-      tag = Generic::Remote::Tag.new
-      tag.errors << error
-      tag
-    }
-
-    subject { Tag.new }
-
-    context "when the response has errors" do
-      it "adds the errors to the active remote object" do
-        subject.add_errors(response.errors)
-        expect(subject.errors[:name]).to match_array(["Boom!"])
-      end
-    end
-  end
-end

data/spec/lib/active_remote/serializers/protobuf_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Serializers::Protobuf::Fields do
-  describe ".from_attributes" do
-    let(:ready_value) { {records: [{name: "Cool Post", errors: [{message: "Boom!"}]}]} }
-    let(:value) { {records: {name: "Cool Post", errors: {message: "Boom!"}}} }
-
-    it "gets protobuf-ready fields from attributes" do
-      expect(described_class.from_attributes(Generic::Remote::Posts, value)).to eq ready_value
-    end
-  end
-end
-
-describe ActiveRemote::Serializers::Protobuf::Field do
-  describe ".from_attribute" do
-    context "when field is a repeated message" do
-      let(:field) { Generic::Remote::Posts.get_field(:records) }
-
-      context "and the value is not an array" do
-        let(:ready_value) { [{name: "Cool Post", errors: [{message: "Boom!"}]}] }
-        let(:value) { {name: "Cool Post", errors: {message: "Boom!"}} }
-
-        it "gets protobuf-ready fields from the value" do
-          expect(described_class.from_attribute(field, value)).to eq ready_value
-        end
-      end
-    end
-
-    context "when field is a message" do
-      let(:field) { Generic::Remote::Post.get_field(:category) }
-
-      context "and value is a hash" do
-        let(:ready_value) { {name: "Film", errors: [{message: "Boom!"}]} }
-        let(:value) { {name: "Film", errors: {message: "Boom!"}} }
-
-        it "gets protobuf-ready fields from the value" do
-          expect(described_class.from_attribute(field, value)).to eq ready_value
-        end
-      end
-    end
-
-    context "when field is repeated" do
-      let(:field) { Generic::Remote::PostRequest.get_field(:name) }
-
-      context "and the value is not an array" do
-        let(:ready_value) { ["Cool Post"] }
-        let(:value) { "Cool Post" }
-
-        it "gets protobuf-ready fields from the value" do
-          expect(described_class.from_attribute(field, value)).to eq ready_value
-        end
-      end
-    end
-
-    # TODO: Find a better way to write this. It works for now, but it's not
-    # very clear and is hard to track down since failures don't include a
-    # description.
-    #
-    # TODO: Consider adding specific specs for typecasting dates to integers
-    # or strings since that's what prompted the re-introduction of the
-    # typecasting.
-    #
-    context "when typecasting fields" do
-      let(:string_value) { double(:string, to_s: "") }
-
-      def typecasts(field, conversion)
-        field = Serializer.get_field(field, true)
-        expect(described_class.from_attribute(field, conversion.first[0])).to eq conversion.first[1]
-      end
-
-      it { typecasts(:bool_field, "0" => false) }
-      it { typecasts(:bytes_field, string_value => "") }
-      it { typecasts(:double_field, 0 => 0.0) }
-      it { typecasts(:fixed32_field, "0" => 0) }
-      it { typecasts(:fixed64_field, "0" => 0) }
-      it { typecasts(:float_field, 0 => 0.0) }
-      it { typecasts(:int32_field, "0" => 0) }
-      it { typecasts(:int64_field, "0" => 0) }
-      it { typecasts(:sfixed32_field, "0" => 0) }
-      it { typecasts(:sfixed64_field, "0" => 0) }
-      it { typecasts(:sint32_field, "0" => 0) }
-      it { typecasts(:sint64_field, "0" => 0) }
-      it { typecasts(:string_field, string_value => "") }
-      it { typecasts(:uint32_field, "0" => 0) }
-      it { typecasts(:uint64_field, "0" => 0) }
-      it { typecasts(:enum_field, 0 => 0) }
-    end
-  end
-end

data/spec/lib/active_remote/validations_spec.rb

@@ -1,56 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Validations do
-  let(:invalid_record) { ::Post.new }
-  let(:valid_record) { ::Post.new(name: "test") }
-
-  before { allow(valid_record).to receive(:create_or_update).and_return(true) }
-  before { allow(invalid_record).to receive(:create_or_update).and_return(true) }
-
-  describe "save" do
-    context "valid record" do
-      it "returns true" do
-        result = valid_record.save
-        expect(result).to be true
-      end
-    end
-
-    context "invalid record" do
-      it "returns false" do
-        result = invalid_record.save
-        expect(result).to be false
-      end
-    end
-  end
-
-  describe "save!" do
-    context "valid record" do
-      it "returns true" do
-        result = valid_record.save!
-        expect(result).to be true
-      end
-    end
-
-    context "invalid record" do
-      it "raises invalid record error" do
-        expect { invalid_record.save! }.to raise_error(ActiveRemote::RemoteRecordInvalid)
-      end
-    end
-  end
-
-  describe "valid?" do
-    context "valid record" do
-      it "returns true" do
-        result = valid_record.valid?
-        expect(result).to be true
-      end
-    end
-
-    context "invalid record" do
-      it "returns false" do
-        result = invalid_record.valid?
-        expect(result).to be false
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-require "rubygems"
-require "bundler"
-
-require "simplecov"
-SimpleCov.start do
-  add_filter "/spec/"
-end
-
-Bundler.require(:default, :development, :test)
-
-require "protobuf/rspec"
-require "support/helpers"
-
-$LOAD_PATH << ::File.expand_path("../support/protobuf", __FILE__)
-require "support/protobuf"
-require "support/models"
-
-RSpec.configure do |config|
-  config.include Protobuf::RSpec::Helpers
-
-  # Turn deprecation warnings into errors with full backtrace.
-  config.raise_errors_for_deprecations!
-
-  # Verifies the existance of any stubbed methods, replaces better_receive and better_stub
-  # https://www.relishapp.com/rspec/rspec-mocks/v/3-1/docs/verifying-doubles/partial-doubles
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-end

data/spec/support/definitions/author.proto

@@ -1,30 +0,0 @@
-package generic.remote;
-
-import "error.proto";
-
-message Author {
-  optional string guid = 1;
-  optional string name = 2;
-  repeated Error errors = 3;
-  optional string user_guid = 4;
-}
-
-message Authors {
-  repeated Author records = 1;
-}
-
-message AuthorRequest {
-  repeated string guid = 1;
-  repeated string name = 2;
-}
-
-service AuthorService {
-  rpc Search (AuthorRequest) returns (Authors);
-  rpc Create (Author) returns (Author);
-  rpc Update (Author) returns (Author);
-  rpc Delete (Author) returns (Author);
-  rpc CreateAll (Authors) returns (Authors);
-  rpc UpdateAll (Authors) returns (Authors);
-  rpc DeleteAll (Authors) returns (Authors);
-  rpc DestroyAll (Authors) returns (Authors);
-}

data/spec/support/definitions/category.proto

@@ -1,33 +0,0 @@
-package generic.remote;
-
-import "error.proto";
-
-message Category {
-  optional string guid = 1;
-  optional string name = 2;
-  repeated Error errors = 3;
-  optional string user_guid = 4;
-  optional string author_guid = 5;
-  optional string chief_editor_guid = 6;
-  optional string editor_guid = 7;
-}
-
-message Categories {
-  repeated Category records = 1;
-}
-
-message CategoryRequest {
-  repeated string guid = 1;
-  repeated string name = 2;
-}
-
-service CategoryService {
-  rpc Search (CategoryRequest) returns (Categories);
-  rpc Create (Category) returns (Category);
-  rpc Update (Category) returns (Category);
-  rpc Delete (Category) returns (Category);
-  rpc CreateAll (Categories) returns (Categories);
-  rpc UpdateAll (Categories) returns (Categories);
-  rpc DeleteAll (Categories) returns (Categories);
-  rpc DestroyAll (Categories) returns (Categories);
-}

data/spec/support/definitions/error.proto

@@ -1,6 +0,0 @@
-package generic;
-
-message Error {
-  optional string field = 1;
-  optional string message = 2;
-}

data/spec/support/definitions/post.proto

@@ -1,35 +0,0 @@
-package generic.remote;
-
-import "error.proto";
-import "category.proto";
-
-message Post {
-  optional string guid = 1;
-  optional string name = 2;
-  optional string author_guid = 3;
-  optional Category category = 4;
-  repeated Error errors = 5;
-  optional string user_guid = 6;
-}
-
-message Posts {
-  repeated Post records = 1;
-}
-
-message PostRequest {
-  repeated string guid = 1;
-  repeated string name = 2;
-  repeated string author_guid = 3;
-  repeated string user_guid = 4;
-}
-
-service PostService {
-  rpc Search (PostRequest) returns (Posts);
-  rpc Create (Post) returns (Post);
-  rpc Update (Post) returns (Post);
-  rpc Delete (Post) returns (Post);
-  rpc CreateAll (Posts) returns (Posts);
-  rpc UpdateAll (Posts) returns (Posts);
-  rpc DeleteAll (Posts) returns (Posts);
-  rpc DestroyAll (Posts) returns (Posts);
-}

data/spec/support/definitions/serializer.proto

@@ -1,23 +0,0 @@
-message Serializer {
-  enum Type {
-    DEFAULT = 0;
-    USER = 1;
-  }
-
-  optional bool bool_field         = 1;
-  optional bytes bytes_field       = 2;
-  optional double double_field     = 3;
-  optional fixed32 fixed32_field   = 4;
-  optional fixed64 fixed64_field   = 5;
-  optional float float_field       = 6;
-  optional int32 int32_field       = 7;
-  optional int64 int64_field       = 8;
-  optional sfixed32 sfixed32_field = 9;
-  optional sfixed64 sfixed64_field = 10;
-  optional sint32 sint32_field     = 11;
-  optional sint64 sint64_field     = 12;
-  optional string string_field     = 13;
-  optional uint32 uint32_field     = 14;
-  optional uint64 uint64_field     = 15;
-  optional Type enum_field         = 16;
-}

data/spec/support/definitions/tag.proto

@@ -1,30 +0,0 @@
-package generic.remote;
-
-import "error.proto";
-
-message Tag {
-  optional string guid = 1;
-  optional string name = 2;
-  repeated Error errors = 3;
-}
-
-message Tags {
-  repeated Tag records = 1;
-}
-
-message TagRequest {
-  repeated string guid = 1;
-  repeated string name = 2;
-}
-
-service TagService {
-  rpc Search (TagRequest) returns (Tags);
-  rpc Create (Tag) returns (Tag);
-  rpc Update (Tag) returns (Tag);
-  rpc Delete (Tag) returns (Tag);
-  rpc Register (Tag) returns (Tag);
-  rpc CreateAll (Tags) returns (Tags);
-  rpc UpdateAll (Tags) returns (Tags);
-  rpc DeleteAll (Tags) returns (Tags);
-  rpc DestroyAll (Tags) returns (Tags);
-}

data/spec/support/helpers.rb

@@ -1,35 +0,0 @@
-##
-# Reset all DSL variables so specs don't interfere with each other.
-#
-def reset_dsl_variables(klass)
-  reset_app_name(klass)
-  reset_auto_paging_size(klass)
-  reset_namespace(klass)
-  reset_publishable_attributes(klass)
-  reset_service_class(klass)
-  reset_service_name(klass)
-end
-
-def reset_app_name(klass)
-  klass.send(:instance_variable_set, :@app_name, nil)
-end
-
-def reset_auto_paging_size(klass)
-  klass.send(:instance_variable_set, :@auto_paging_size, nil)
-end
-
-def reset_namespace(klass)
-  klass.send(:instance_variable_set, :@namespace, nil)
-end
-
-def reset_publishable_attributes(klass)
-  klass.send(:instance_variable_set, :@publishable_attributes, nil)
-end
-
-def reset_service_class(klass)
-  klass.send(:instance_variable_set, :@service_class, nil)
-end
-
-def reset_service_name(klass)
-  klass.send(:instance_variable_set, :@service_name, nil)
-end

data/spec/support/models/author.rb

@@ -1,26 +0,0 @@
-require "support/protobuf/author.pb"
-
-##
-# Define a generic class that inherits from active remote base
-#
-class Author < ::ActiveRemote::Base
-  service_class ::Generic::Remote::AuthorService
-
-  attribute :guid, :string
-  attribute :name, :string
-  attribute :user_guid, :string
-  attribute :chief_editor_guid, :string
-  attribute :editor_guid, :string
-  attribute :category_guid, :string
-  attribute :age, :integer
-  attribute :birthday, :datetime
-  attribute :writes_fiction, :boolean
-  attribute :net_sales, :float
-
-  has_many :posts
-  has_many :user_posts, class_name: "::Post", scope: :user_guid
-  has_many :flagged_posts, class_name: "::Post"
-  has_many :bestseller_posts, class_name: "::Post", foreign_key: :bestseller_guid
-
-  belongs_to :category
-end