active_remote 1.2.1

data/spec/lib/active_remote/base_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe ActiveRemote::Base do
+  describe "#initialize" do
+    it "runs callbacks" do
+      described_class.any_instance.should_receive(:run_callbacks).with(:initialize)
+      described_class.new
+    end
+  end
+end

data/spec/lib/active_remote/bulk_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe ActiveRemote::Bulk do
+  let(:records) { double(:records, :to_hash => {}) }
+  let(:serialized_records) { double(:serialized_records) }
+
+  describe ".create_all" do
+    before {
+      Tag.stub(:parse_records).and_return(records)
+      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
+    }
+
+    it "creates remote records" do
+      Tag.any_instance.should_receive(:execute).with(:create_all, records)
+      Tag.create_all(records)
+    end
+  end
+
+  describe ".delete_all" do
+    before {
+      Tag.stub(:parse_records).and_return(records)
+      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
+    }
+
+    it "deletes remote records" do
+      Tag.any_instance.should_receive(:execute).with(:delete_all, records)
+      Tag.delete_all(records)
+    end
+  end
+
+  describe ".destroy_all" do
+    before {
+      Tag.stub(:parse_records).and_return(records)
+      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
+    }
+
+    it "destroys remote records" do
+      Tag.any_instance.should_receive(:execute).with(:destroy_all, records)
+      Tag.destroy_all(records)
+    end
+  end
+
+  describe ".parse_records" do
+    let(:records) { [ Hash.new ] }
+
+    it "preps records to be built into a bulk request" do
+      parsed_records = { :records => records }
+      Tag.parse_records(records).should eq parsed_records
+    end
+
+    context "when given a bulk message" do
+      let(:records) { [ tag.to_hash ] }
+      let(:tag) { Generic::Remote::Tag.new }
+      let(:tags) { Generic::Remote::Tags.new(:records => [ tag ]) }
+
+      it "preps records to be built into a bulk request" do
+        parsed_records = { :records => records }
+        Tag.parse_records(tags).should eq parsed_records
+      end
+    end
+  end
+
+  describe ".update_all" do
+    before {
+      Tag.stub(:parse_records).and_return(records)
+      Tag.any_instance.stub(:serialize_records).and_return(serialized_records)
+    }
+
+    it "updates remote records" do
+      Tag.any_instance.should_receive(:execute).with(:update_all, records)
+      Tag.update_all(records)
+    end
+  end
+end

data/spec/lib/active_remote/dsl_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+# For testing the DSL methods
+module Another
+  class TagService < Protobuf::Rpc::Service
+  end
+end
+
+describe ActiveRemote::DSL do
+  before { reset_dsl_variables(Tag) }
+  after { Tag.service_class Generic::Remote::TagService }
+
+  describe ".attr_publishable" do
+    after { reset_publishable_attributes(Tag) }
+
+    it "appends given attributes to @publishable_attributes" do
+      Tag.attr_publishable :guid
+      Tag.attr_publishable :name
+
+      Tag.publishable_attributes.should =~ [ :guid, :name ]
+    end
+  end
+
+  describe ".auto_paging_size" do
+    context "when given a value" do
+      it "sets @auto_paging_size to the value" do
+        Tag.auto_paging_size 100
+        Tag.auto_paging_size.should eq 100
+      end
+    end
+  end
+
+  describe ".namespace" do
+    context "when given a value" do
+      it "sets @namespace to the value" do
+        Tag.namespace :foo
+        Tag.namespace.should eq :foo
+      end
+    end
+  end
+
+  describe ".service_class" do
+    context "when nil" do
+      it "determines the service class" do
+        Tag.namespace :another
+
+        Tag.service_class.should eq Another::TagService
+      end
+    end
+
+    context "when given a value" do
+      it "sets @service_class to the value" do
+        Tag.service_class Generic::Remote::TagService
+        Tag.service_class.should eq Generic::Remote::TagService
+      end
+    end
+  end
+
+  describe ".service_name" do
+    context "when nil" do
+      it "determines the service name" do
+        Tag.service_name.should eq :tag_service
+      end
+    end
+
+    context "when given a value" do
+      it "sets @service_name to the value" do
+        Tag.service_name :foo
+        Tag.service_name.should eq :foo
+      end
+    end
+  end
+end

data/spec/lib/active_remote/persistence_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+describe ActiveRemote::Persistence do
+  subject { Tag.new }
+
+  before { Tag.any_instance.stub(:last_response).and_return(HashWithIndifferentAccess.new) }
+
+  describe ".create" do
+    before { Tag.any_instance.stub(:execute) }
+    after { Tag.any_instance.unstub(:execute) }
+
+    it "initializes and saves a new record" do
+      Tag.any_instance.should_receive(:save)
+      Tag.create(:name => 'foo')
+    end
+
+    it "returns a new record" do
+      value = Tag.create(:name => 'foo')
+      value.should be_a(Tag)
+    end
+  end
+
+  describe ".create!" do
+    before { Tag.any_instance.stub(:execute) }
+    after { Tag.any_instance.unstub(:execute) }
+
+    it "initializes and saves a new record" do
+      Tag.any_instance.should_receive(:save!)
+      Tag.create!(:name => 'foo')
+    end
+
+    context "when the record has errors" do
+      before { Tag.any_instance.stub(: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
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    it "deletes a remote record" do
+      subject.should_receive(:execute).with(:delete, subject.attributes.slice("guid"))
+      subject.delete
+    end
+
+    context "when the record doesn't have errors" do
+      it "freezes the record" do
+        subject.delete
+        subject.frozen?.should be_true
+      end
+    end
+  end
+
+  describe "#delete!" do
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    it "deletes a remote record" do
+      subject.should_receive(:execute).with(:delete, subject.attributes.slice("guid"))
+      subject.delete!
+    end
+
+    context "when an error occurs" do
+      before { subject.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
+
+      it "raises an exception" do
+        expect { subject.delete! }.to raise_error(ActiveRemote::ActiveRemoteError)
+      end
+    end
+  end
+
+  describe "#destroy" do
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    it "destroys a remote record" do
+      subject.should_receive(:execute).with(:destroy, subject.attributes.slice("guid"))
+      subject.destroy
+    end
+
+    context "when the record doesn't have errors" do
+      it "freezes the record" do
+        subject.destroy
+        subject.frozen?.should be_true
+      end
+    end
+  end
+
+  describe "#destroy!" do
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    it "destroys a remote record" do
+      subject.should_receive(:execute).with(:destroy, subject.attributes.slice("guid"))
+      subject.destroy!
+    end
+
+    context "when an error occurs" do
+      before { subject.stub(:execute).and_raise(ActiveRemote::ActiveRemoteError) }
+
+      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_false }
+    end
+
+    context "when errors are present" do
+      before { subject.errors[:base] << "Boom!" }
+
+      its(:has_errors?) { should be_true }
+    end
+  end
+
+  describe "#new_record?" do
+    context "when the record is persisted" do
+      subject { Tag.new(:guid => 'foo') }
+
+      its(:new_record?) { should be_false }
+    end
+
+    context "when the record is not persisted" do
+      subject { Tag.new }
+
+      its(:new_record?) { should be_true }
+    end
+  end
+
+  describe "#persisted?" do
+    context "when the record has a guid" do
+      subject { Tag.new(:guid => 'foo') }
+
+      its(:persisted?) { should be_true }
+    end
+
+    context "when the record does not have a guid" do
+      subject { Tag.new }
+
+      its(:persisted?) { should be_false }
+    end
+  end
+
+  describe "#save" do
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    it "runs callbacks" do
+      subject.should_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.reject { |key, value| key == "guid" }
+        subject.should_receive(:execute).with(:create, expected_attributes)
+        subject.save
+      end
+    end
+
+    context "when the record is not new" do
+      let(:attributes) { { 'guid' => 'foo' } }
+
+      subject { Tag.new(attributes) }
+
+      it "updates the record" do
+        subject.should_receive(:execute).with(:update, attributes)
+        subject.save
+      end
+    end
+
+    context "when the record is saved" do
+      before { subject.errors.clear }
+
+      it "returns true" do
+        subject.save.should be_true
+      end
+    end
+
+    context "when the record is not saved" do
+      before { subject.errors[:base] << "Boom!" }
+
+      it "returns false" do
+        subject.save.should be_false
+      end
+    end
+  end
+
+  describe "#save!" do
+    before { subject.stub(:execute) }
+    after { subject.unstub(:execute) }
+
+    context "when the record is saved" do
+      it "returns true" do
+        subject.stub(:save).and_return(true)
+        subject.save!.should be_true
+      end
+    end
+
+    context "when the record is not saved" do
+      it "raises an exception" do
+        subject.stub(:save).and_return(false)
+        expect { subject.save! }.to raise_error(ActiveRemote::RemoteRecordNotSaved)
+      end
+    end
+  end
+
+  describe "#success?" do
+    context "when errors are present" do
+      before { subject.errors[:base] << "Boom!" }
+
+      its(:success?) { should be_false }
+    end
+
+    context "when errors are not present" do
+      before { subject.errors.clear }
+
+      its(:success?) { should be_true }
+    end
+  end
+
+  describe "#update_attributes" do
+    let(:attributes) { HashWithIndifferentAccess.new(:name => 'bar') }
+
+    before { subject.stub(:save) }
+    after { subject.unstub(:save) }
+
+    it "assigns new attributes" do
+      subject.should_receive(:assign_attributes).with(attributes)
+      subject.update_attributes(attributes)
+    end
+
+    it "saves the record" do
+      subject.should_receive(:save)
+      subject.update_attributes(attributes)
+    end
+  end
+
+  describe "#update_attributes!" do
+    let(:attributes) { HashWithIndifferentAccess.new(:name => 'bar') }
+
+    before { subject.stub(:save!) }
+    after { subject.unstub(:save!) }
+
+    it "assigns new attributes" do
+      subject.should_receive(:assign_attributes).with(attributes)
+      subject.update_attributes!(attributes)
+    end
+
+    it "saves! the record" do
+      subject.should_receive(:save!)
+      subject.update_attributes!(attributes)
+    end
+  end
+end

data/spec/lib/active_remote/rpc_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ActiveRemote::RPC do
+  subject { Tag.new }
+
+  describe ".remote_call" do
+    let(:args) { double(:args) }
+    let(:response) { double(:response) }
+
+    before { Tag.any_instance.stub(:execute) }
+
+    it "calls the given RPC method" do
+      Tag.any_instance.should_receive(:execute).with(:remote_method, args)
+      Tag.remote_call(:remote_method, args)
+    end
+
+    it "returns the response" do
+      Tag.any_instance.stub(:last_response).and_return(response)
+      Tag.remote_call(:remote_method, args).should eq response
+    end
+  end
+
+  describe ".request" do
+    let(:attributes) { Hash.new }
+    let(:message) { double(:message) }
+
+    it "builds an RPC request" do
+      Tag.should_receive(:build_message).with(Generic::Remote::Tag, attributes)
+      Tag.request(:create, attributes)
+    end
+  end
+
+  describe ".request_type" do
+    it "fetches the request type for the given RPC method" do
+      Tag.request_type(:search).should eq Generic::Remote::TagRequest
+    end
+  end
+
+  describe "#execute" do
+    let(:request) { double(:request) }
+
+    it "calls the given RPC method" do
+      mock_remote_service(Tag.service_class, :create, :response => double(:to_hash => {}))
+      subject.execute(:create, request)
+    end
+
+    it "sets the last request" do
+      mock_remote_service(Tag.service_class, :create, :response => double(:to_hash => {}))
+
+      subject.execute(:create, request)
+      subject.last_request.should eq(request)
+    end
+
+    context "when request args is a hash" do
+      let(:args){ Hash.new }
+      let(:request) { double(:request) }
+
+      before {
+        subject.stub(:request).and_return(request)
+        mock_remote_service(Tag.service_class, :create, :response => double(:to_hash => {}))
+      }
+
+      it "creates a request" do
+        subject.should_receive(:request).with(:create, args)
+        subject.execute(:create, args)
+      end
+    end
+
+    context "when a request succeeds" do
+      let(:success_response) { double(:status => 'success', :awesome_town => true, :to_hash => {}) }
+
+      before {
+        mock_remote_service(Tag.service_class, :create, :response => success_response)
+      }
+
+      it "sets the last response" do
+        subject.execute(:create, request)
+        subject.last_response.should eq(success_response)
+      end
+    end
+
+    context "when a request fails" do
+      let(:error_response) { double(:error, :message => "Boom goes the dynamite!") }
+
+      before {
+        mock_remote_service(Tag.service_class, :create, :error => error_response)
+      }
+
+      it "raises an exception" do
+        expect { subject.execute(:create, request) }.to raise_error(ActiveRemote::ActiveRemoteError)
+      end
+    end
+  end
+end