active_remote 7.1.0 → 7.2.0

data/spec/lib/active_remote/integration_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-
-describe ::ActiveRemote::Integration do
-  let(:guid) { "GUID-derp" }
-  let(:tag) { ::Tag.new(guid: guid) }
-
-  subject { tag }
-
-  context ".to_param" do
-    specify { expect(::Tag).to respond_to(:to_param) }
-  end
-
-  context "#to_param" do
-    specify { expect(subject).to respond_to(:to_param) }
-
-    it "returns the guid if the guid is present (by default)" do
-      expect(tag.to_param).to eq(guid)
-    end
-  end
-
-  context "#cache_key" do
-    specify { expect(subject).to respond_to(:cache_key) }
-
-    it "sets 'new' as the identifier when the record has not been persisted" do
-      expect(tag).to receive(:new_record?).and_return(true)
-      expect(tag.cache_key).to match(/tags\/new/)
-    end
-
-    it "sets the cache_key to the class/guid as a default" do
-      expect(tag).to receive(:new_record?).and_return(false)
-      expect(tag.cache_key).to eq("tags/#{guid}")
-    end
-
-    it "adds the 'updated_at' attribute to the cache_key if updated_at is present" do
-      ::ActiveRemote.config.default_cache_key_updated_at = true
-      twenty_o_one_one = tag.updated_at = DateTime.new(2001, 0o1, 0o1)
-      expect(tag).to receive(:new_record?).and_return(false)
-      expect(tag.cache_key).to eq("tags/#{guid}-#{twenty_o_one_one.to_fs(:usec)}")
-      tag.updated_at = nil
-      ::ActiveRemote.config.default_cache_key_updated_at = false
-    end
-
-    it "defaults the cache updated_at to false" do
-      expect(::ActiveRemote.config.default_cache_key_updated_at?).to be_falsey
-    end
-  end
-
-  describe "#cache_key_with_version" do
-    let(:tag) { ::Tag.new(guid: guid, updated_at: ::DateTime.current) }
-
-    specify { expect(subject).to respond_to(:cache_key_with_version) }
-
-    context "when cache versioning is enabled" do
-      around do |example|
-        cache_versioning_value = ::Tag.cache_versioning
-        ::Tag.cache_versioning = true
-        example.run
-        ::Tag.cache_versioning = cache_versioning_value
-      end
-
-      it "returns a cache key with the version" do
-        expect(tag.cache_version).to be_present
-        expect(tag.cache_key_with_version).to eq("#{tag.cache_key}-#{tag.cache_version}")
-      end
-    end
-
-    context "when cache versioning is not enabled" do
-      around do |example|
-        cache_versioning_value = ::Tag.cache_versioning
-        ::Tag.cache_versioning = false
-        example.run
-        ::Tag.cache_versioning = cache_versioning_value
-      end
-
-      it "returns a cache key without the version" do
-        expect(tag.cache_key_with_version).to eq(tag.cache_key)
-      end
-    end
-  end
-
-  describe "#cache_version" do
-    specify { expect(subject).to respond_to(:cache_version) }
-
-    context "when cache versioning is enabled" do
-      around do |example|
-        cache_versioning_value = ::Tag.cache_versioning
-        ::Tag.cache_versioning = true
-        example.run
-        ::Tag.cache_versioning = cache_versioning_value
-      end
-
-      it "returns a cache version" do
-        tag.updated_at = DateTime.new(2001, 0o1, 0o1)
-        expect(tag.cache_version).to eq(tag.updated_at.utc.to_fs(:usec))
-      end
-    end
-
-    context "when cache versioning is not enabled" do
-      around do |example|
-        cache_versioning_value = ::Tag.cache_versioning
-        ::Tag.cache_versioning = false
-        example.run
-        ::Tag.cache_versioning = cache_versioning_value
-      end
-
-      it "returns nil" do
-        expect(tag.cache_version).to be_nil
-      end
-    end
-  end
-end

data/spec/lib/active_remote/persistence_spec.rb

@@ -1,416 +0,0 @@
-require "spec_helper"
-
-describe ::ActiveRemote::Persistence do
-  let(:response_without_errors) { ::HashWithIndifferentAccess.new(errors: []) }
-  let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class, ::Tag.endpoints) }
-
-  subject { ::Tag.new }
-
-  before {
-    allow(rpc).to receive(:execute).and_return(response_without_errors)
-    allow(Tag).to receive(:rpc).and_return(rpc)
-  }
-  after { allow(::Tag).to receive(:rpc).and_call_original }
-
-  describe ".create" do
-    it "runs create callbacks" do
-      expect_any_instance_of(Tag).to receive(:after_create_callback)
-      Tag.create(name: "foo")
-    end
-
-    it "initializes and saves a new record" do
-      expect_any_instance_of(Tag).to receive(:save)
-      Tag.create(name: "foo")
-    end
-
-    it "returns a new record" do
-      value = Tag.create(name: "foo")
-      expect(value).to be_a(Tag)
-    end
-  end
-
-  describe ".create!" do
-    it "initializes and saves a new record" do
-      expect_any_instance_of(Tag).to receive(:save!)
-      Tag.create!(name: "foo")
-    end
-
-    context "when the record has errors" do
-      before { allow_any_instance_of(Tag).to receive(:save!).and_raise(ActiveRemote::ActiveRemoteError) }
-
-      it "raises an exception" do
-        expect { Tag.create!(name: "foo") }.to raise_error(ActiveRemote::ActiveRemoteError)
-      end
-    end
-  end
-
-  describe "#delete" do
-    it "deletes a remote record" do
-      expect(rpc).to receive(:execute).with(:delete, subject.scope_key_hash)
-      subject.delete
-    end
-
-    context "when the record doesn't have errors" do
-      it "freezes the record" do
-        subject.delete
-        expect(subject.frozen?).to be_truthy
-      end
-    end
-
-    context "when the response has errors" do
-      let(:error) { Generic::Error.new(field: "name", message: "Boom!") }
-      let(:response) { Generic::Remote::Tag.new(errors: [error]) }
-
-      before { allow(rpc).to receive(:execute).and_return(response) }
-
-      it "adds the errors to the record" do
-        subject.delete
-        expect(subject.has_errors?).to be_truthy
-      end
-
-      it "returns false" do
-        expect(subject.delete).to be_falsey
-      end
-    end
-  end
-
-  describe "#delete!" do
-    it "deletes a remote record" do
-      expect(rpc).to receive(:execute).with(:delete, subject.scope_key_hash)
-      subject.delete!
-    end
-
-    context "when an error occurs" do
-      let(:error) { Generic::Error.new(field: "name", message: "Boom!") }
-      let(:response) { Generic::Remote::Tag.new(errors: [error]) }
-
-      before { allow(rpc).to receive(:execute).and_return(response) }
-
-      it "raises an exception" do
-        expect { subject.delete! }.to raise_error(ActiveRemote::ActiveRemoteError)
-      end
-    end
-  end
-
-  describe "#destroy" do
-    it "destroys a remote record" do
-      expect(rpc).to receive(:execute).with(:destroy, subject.scope_key_hash)
-      subject.destroy
-    end
-
-    context "when the record doesn't have errors" do
-      it "freezes the record" do
-        subject.destroy
-        expect(subject.frozen?).to be_truthy
-      end
-    end
-
-    context "when the response has errors" do
-      let(:error) { Generic::Error.new(field: "name", message: "Boom!") }
-      let(:response) { Generic::Remote::Tag.new(errors: [error]) }
-
-      before { allow(rpc).to receive(:execute).and_return(response) }
-
-      it "adds the errors to the record" do
-        subject.destroy
-        expect(subject.has_errors?).to be_truthy
-      end
-
-      it "returns false" do
-        expect(subject.destroy).to be_falsey
-      end
-    end
-  end
-
-  describe "#destroy!" do
-    it "destroys a remote record" do
-      expect(rpc).to receive(:execute).with(:destroy, subject.scope_key_hash)
-      subject.destroy!
-    end
-
-    context "when an error occurs" do
-      let(:error) { Generic::Error.new(field: "name", message: "Boom!") }
-      let(:response) { Generic::Remote::Tag.new(errors: [error]) }
-
-      before { allow(rpc).to receive(:execute).and_return(response) }
-
-      it "raises an exception" do
-        expect { subject.destroy! }.to raise_error(ActiveRemote::ActiveRemoteError)
-      end
-    end
-  end
-
-  describe "#has_errors?" do
-    context "when errors are not present" do
-      before { subject.errors.clear }
-
-      its(:has_errors?) { should be_falsey }
-    end
-
-    context "when errors are present" do
-      before { subject.errors.add(:base, :invalid, message: "Boom!") }
-
-      its(:has_errors?) { should be_truthy }
-    end
-  end
-
-  describe "#new_record?" do
-    context "when the record is created through instantiate" do
-      subject { Tag.instantiate(guid: "foo") }
-
-      its(:new_record?) { should be_falsey }
-    end
-
-    context "when the record is persisted" do
-      subject { Tag.allocate.instantiate(guid: "foo") }
-
-      its(:new_record?) { should be_falsey }
-    end
-
-    context "when the record is not persisted" do
-      subject { Tag.new }
-
-      its(:new_record?) { should be_truthy }
-    end
-  end
-
-  describe "#persisted?" do
-    context "when the record is persisted" do
-      subject { Tag.allocate.instantiate(guid: "foo") }
-
-      its(:persisted?) { should be_truthy }
-    end
-
-    context "when the record is not persisted" do
-      subject { Tag.new }
-
-      its(:persisted?) { should be_falsey }
-    end
-  end
-
-  describe "#readonly?" do
-    context "when the record is created through instantiate with options[:readonly]" do
-      subject { Tag.instantiate({guid: "foo"}, readonly: true) }
-
-      its(:new_record?) { should be_falsey }
-      its(:readonly?) { should be_truthy }
-    end
-  end
-
-  describe "#remote" do
-    let(:response) { ::Generic::Remote::Tag.new(guid: tag.guid, name: "bar") }
-    let(:rpc) { ::ActiveRemote::RPCAdapters::ProtobufAdapter.new(::Tag.service_class, ::Tag.endpoints) }
-    let(:tag) { ::Tag.new(guid: SecureRandom.uuid) }
-
-    subject { tag }
-
-    before do
-      allow(::Tag).to receive(:rpc).and_return(rpc)
-      allow(rpc).to receive(:execute).and_return(response)
-    end
-
-    it "calls the given RPC method with default args" do
-      expect(::Tag.rpc).to receive(:execute).with(:remote_method, tag.scope_key_hash)
-      tag.remote(:remote_method)
-    end
-
-    it "updates the attributes from the response" do
-      expect { tag.remote(:remote_method) }.to change { tag.name }.to(response.name)
-    end
-
-    it "returns true" do
-      expect(tag.remote(:remote_method)).to be(true)
-    end
-
-    context "when request args are given" do
-      it "calls the given RPC method with default args" do
-        attributes = {guid: tag.guid, name: "foo"}
-        expect(::Tag.rpc).to receive(:execute).with(:remote_method, attributes)
-        tag.remote(:remote_method, attributes)
-      end
-    end
-
-    context "when response does not respond to errors" do
-      it "returns true" do
-        allow(rpc).to receive(:execute).and_return(double(:response, to_hash: {}))
-        expect(tag.remote(:remote_method)).to be(true)
-      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.remote(:remote_method) }.to change { tag.has_errors? }.to(true)
-      end
-
-      it "returns false" do
-        expect(tag.remote(:remote_method)).to be(false)
-      end
-    end
-  end
-
-  describe "#save" do
-    it "runs save callbacks" do
-      allow(subject).to receive(:run_callbacks).with(:validation).and_return(true)
-      expect(subject).to receive(:run_callbacks).with(:save)
-      subject.save
-    end
-
-    context "when the record is new" do
-      subject { Tag.new }
-
-      it "creates the record" do
-        expected_attributes = subject.attributes
-        expect(rpc).to receive(:execute).with(:create, expected_attributes)
-        subject.save
-      end
-    end
-
-    context "when the record is not new" do
-      let(:attributes) { {"guid" => "foo"} }
-
-      subject { Tag.allocate.instantiate(attributes) }
-
-      it "updates the record" do
-        expect(rpc).to receive(:execute).with(:update, attributes)
-        subject.save
-      end
-    end
-
-    context "when the record is saved" do
-      it "returns true" do
-        allow(subject).to receive(:has_errors?) { false }
-        expect(subject.save).to be_truthy
-      end
-    end
-
-    context "when the record is not saved" do
-      it "returns false" do
-        allow(subject).to receive(:has_errors?) { true }
-        expect(subject.save).to be_falsey
-      end
-    end
-
-    context "when the record has errors before the save" do
-      before { subject.errors.add(:base, :invalid, message: "Boom!") }
-
-      it "clears the errors before the save" do
-        expect(subject.errors).not_to be_empty
-        expect(subject.save).to be_truthy
-        expect(subject.errors).to be_empty
-      end
-    end
-  end
-
-  describe "#save!" do
-    context "when the record is saved" do
-      it "returns true" do
-        allow(subject).to receive(:save).and_return(true)
-        expect(subject.save!).to be_truthy
-      end
-    end
-
-    context "when the record is not saved" do
-      let(:errors) {
-        [Generic::Error.new(field: "name", message: "Error one!"),
-          Generic::Error.new(field: "name", message: "Error two!")]
-      }
-      let(:response) { Generic::Remote::Tag.new(errors: errors) }
-      before { allow(rpc).to receive(:execute).and_return(response) }
-
-      it "raises an exception" do
-        expect { subject.save! }
-          .to raise_error(ActiveRemote::RemoteRecordNotSaved, "Name Error one!, Name Error two!")
-      end
-    end
-  end
-
-  describe "#success?" do
-    context "when errors are present" do
-      before { subject.errors.add(:base, :invalid, message: "Boom!") }
-
-      its(:success?) { should be_falsey }
-    end
-
-    context "when errors are not present" do
-      before { subject.errors.clear }
-
-      its(:success?) { should be_truthy }
-    end
-  end
-
-  describe "#update_attribute" do
-    let(:tag) { Tag.allocate.instantiate(guid: "123") }
-
-    it "runs update callbacks" do
-      expect(tag).to receive(:after_update_callback)
-      tag.update_attribute(:name, "foo")
-    end
-
-    it "updates a remote record" do
-      expect(rpc).to receive(:execute).with(:update, {"name" => "foo", "guid" => "123"})
-      tag.update_attribute(:name, "foo")
-    end
-
-    before { allow(subject).to receive(:save) }
-    after { allow(subject).to receive(:save).and_call_original }
-
-    it "assigns new attributes" do
-      expect(subject).to receive(:name=).with("foo")
-      subject.update_attribute(:name, "foo")
-    end
-
-    it "saves the record" do
-      expect(subject).to receive(:save)
-      subject.update_attribute(:name, "foo")
-    end
-  end
-
-  describe "#update_attributes" do
-    let(:attributes) { HashWithIndifferentAccess.new(name: "bar") }
-    let(:tag) { Tag.allocate.instantiate(guid: "123") }
-
-    it "runs update callbacks" do
-      expect(tag).to receive(:after_update_callback)
-      tag.update({})
-    end
-
-    it "updates a remote record" do
-      expect(rpc).to receive(:execute).with(:update, tag.scope_key_hash)
-      tag.update({})
-    end
-
-    before { allow(subject).to receive(:save) }
-    after { allow(subject).to receive(:save).and_call_original }
-
-    it "assigns new attributes" do
-      expect(subject).to receive(:assign_attributes).with(attributes)
-      subject.update(attributes)
-    end
-
-    it "saves the record" do
-      expect(subject).to receive(:save)
-      subject.update(attributes)
-    end
-  end
-
-  describe "#update_attributes!" do
-    let(:attributes) { HashWithIndifferentAccess.new(name: "bar") }
-
-    before { allow(subject).to receive(:save!) }
-    after { allow(subject).to receive(:save!).and_call_original }
-
-    it "assigns new attributes" do
-      expect(subject).to receive(:assign_attributes).with(attributes)
-      subject.update!(attributes)
-    end
-
-    it "saves! the record" do
-      expect(subject).to receive(:save!)
-      subject.update!(attributes)
-    end
-  end
-end

data/spec/lib/active_remote/primary_key_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::PrimaryKey do
-  let(:tag) { Tag.new(id: "1234", guid: "TAG-123", user_guid: "USR-123") }
-
-  after { Tag.instance_variable_set :@primary_key, nil }
-
-  describe ".default_primary_key" do
-    it "returns array of :guid" do
-      expect(Tag.default_primary_key).to eq(:guid)
-    end
-  end
-
-  describe "primary_key" do
-    context "when no arguments are passed" do
-      it "returns default primary key" do
-        expect(Tag.primary_key).to eq(:guid)
-      end
-    end
-
-    context "when arguments are passed" do
-      let(:specified_primary_key) { :name }
-
-      it "returns the given primary key" do
-        expect(Tag.primary_key(specified_primary_key)).to eq(specified_primary_key)
-      end
-    end
-  end
-
-  describe "#primary_key" do
-    it "returns the primary key for the class" do
-      expect(Tag.new.primary_key).to eq Tag.primary_key
-    end
-  end
-
-  describe "#to_key" do
-    context "when no primary key is specified and default of guid does not exist" do
-      it "returns nil" do
-        expect(NoAttributes.new.to_key).to eq nil
-      end
-    end
-
-    context "when no primary key is specified, but default of guid exists" do
-      it "returns guid in array" do
-        expect(Tag.new(guid: "TAG-123").to_key).to eq ["TAG-123"]
-      end
-    end
-  end
-end

data/spec/lib/active_remote/query_attribute_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe ::ActiveRemote::QueryAttributes do
-  subject { ::Author.new }
-
-  describe "#query_attribute" do
-    it "is false when the attribute is false" do
-      subject.writes_fiction = false
-      expect(subject.writes_fiction?).to eq false
-    end
-
-    it "is true when the attribute is true" do
-      subject.writes_fiction = true
-      expect(subject.writes_fiction?).to eq true
-    end
-
-    it "is false when the attribute is nil" do
-      subject.name = nil
-      expect(subject.name?).to eq false
-    end
-
-    it "is false when the attribute is an empty string" do
-      subject.name = ""
-      expect(subject.name?).to eq false
-    end
-
-    it "is true when the attribute is a non-empty string" do
-      subject.name = "Chris"
-      expect(subject.name?).to eq true
-    end
-
-    # This behavior varies from ActiveRecord, so we test it explicitly
-    it "is true when the attribute is 0" do
-      subject.age = 0
-      expect(subject.age?).to eq true
-    end
-
-    it "is true when the attribute is 1" do
-      subject.age = 1
-      expect(subject.age?).to eq true
-    end
-  end
-end

data/spec/lib/active_remote/rpc_adapters/protobuf_adapter_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::RPCAdapters::ProtobufAdapter do
-  let(:adapter) { ActiveRemote::RPCAdapters::ProtobufAdapter.new(Tag.service_class, Tag.endpoints) }
-  let(:client) { double(:client) }
-
-  subject { adapter }
-
-  # The Protobuf RPC client relies on method missing and delegations
-  # Provide a client double to make it possible to add expectations that specific methods are called
-  before { allow(adapter).to receive(:client).and_return(client) }
-
-  describe "#execute" do
-    context "when a custom endpoint is defined" do
-      before { adapter.endpoints[:create] = :register }
-      after { adapter.endpoints[:create] = :create }
-
-      it "calls the custom endpoint" do
-        expect(adapter.client).to receive(:register)
-        adapter.execute(:create, name: "foo")
-      end
-    end
-  end
-end