active_remote 1.2.1

data/spec/lib/active_remote/search_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe ActiveRemote::Search do
+  describe ".find" do
+    let(:args) { Hash.new }
+    let(:record) { double(:record) }
+    let(:records) { [ record ] }
+
+    before { Tag.stub(:search).and_return(records) }
+
+    it "searches with the given args" do
+      Tag.should_receive(:search).with(args)
+      Tag.find(args)
+    end
+
+    context "when records are returned" do
+      it "returns the first record" do
+        Tag.find(args).should eq record
+      end
+    end
+
+    context "when no records are returned" do
+      before { Tag.stub(:search).and_return([]) }
+
+      it "raise an exception" do
+        expect { Tag.find(args) }.to raise_error(::ActiveRemote::RemoteRecordNotFound)
+      end
+    end
+  end
+
+  describe ".search" do
+    context "given args that respond to :to_hash" do
+      let(:args) { Hash.new }
+
+      before {
+        Tag.any_instance.stub(:_active_remote_search)
+      }
+
+      it "searches with the given args" do
+        Tag.any_instance.should_receive(:_active_remote_search).with(args)
+        Tag.search(args)
+      end
+
+      it "returns records" do
+        records = double(:records)
+
+        Tag.any_instance.stub(:serialize_records).and_return(records)
+        Tag.search(args).should eq records
+      end
+    end
+
+    context "given args that don't respond to :to_hash" do
+      let(:request) { double(:request) }
+
+      it "raises an exception" do
+        expect { described_class.search(request) }.to raise_exception
+      end
+    end
+  end
+
+  describe "#_active_remote_search" do
+    let(:args) { Hash.new }
+
+    subject { Tag.new }
+
+    it "runs callbacks" do
+      subject.should_receive(:run_callbacks).with(:search)
+      subject._active_remote_search(args)
+    end
+
+    it "executes the search" do
+      subject.should_receive(:execute).with(:search, args)
+      subject._active_remote_search(args)
+    end
+  end
+
+  describe "#reload" do
+    let(:args) { { :guid => 'foo' } }
+    let(:attributes) { HashWithIndifferentAccess.new }
+
+    subject { Tag.new(args) }
+
+    before {
+      subject.stub(:_active_remote_search)
+      subject.stub(:last_response).and_return(attributes)
+    }
+
+    it "reloads the record" do
+      subject.should_receive(:_active_remote_search).with(args)
+      subject.reload
+    end
+
+    it "assigns new attributes" do
+      subject.should_receive(:assign_attributes).with(attributes)
+      subject.reload
+    end
+  end
+end

data/spec/lib/active_remote/serialization_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe ActiveRemote::Serialization do
+  describe "#add_errors_from_response" do
+    let(:error) { Generic::Error.new(:field => 'name', :message => 'Boom!') }
+    let(:last_response) {
+      tag = Generic::Remote::Tag.new
+      tag.errors << error
+      tag
+    }
+
+    subject { Tag.new }
+
+    context "when the last response has errors" do
+
+      before { subject.stub(:last_response).and_return(last_response) }
+
+      it "adds the errors to the active remote object" do
+        subject.add_errors_from_response
+        subject.errors[:name].should =~ ['Boom!']
+      end
+    end
+
+    context "when the last response doesn't respond to errors" do
+      it "doesn't add errors" do
+        subject.add_errors_from_response
+        subject.errors.empty?.should be_true
+      end
+    end
+  end
+
+  describe "#serialize_records" do
+    let(:last_response) {
+      MessageWithOptions.new(:records => records)
+    }
+    let(:records) { [ { :foo => 'bar' } ] }
+
+    subject { Tag.new }
+
+    context "when the last response has records" do
+
+      before { subject.stub(:last_response).and_return(last_response) }
+
+      it "serializes records into active remote objects" do
+        subject.serialize_records.each do |record|
+          record.should be_a Tag
+        end
+      end
+    end
+
+    context "when the last response doesn't respond to records" do
+      it "returns nil" do
+        subject.serialize_records.should be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveRemote::Serializers::JSON do
+  describe "#as_json" do
+    let(:attributes) { { :guid => 'foo', :name => 'bar' } }
+
+    subject { Tag.new(attributes) }
+
+    it "accepts standard JSON options" do
+      subject.as_json(:root => false).should eq attributes.stringify_keys
+    end
+
+    context "with publishable attributes defined" do
+      let(:expected_json) { { :tag => attributes.slice(:name) }.to_json }
+
+      before { Tag.attr_publishable :name }
+      after { reset_publishable_attributes(Tag) }
+
+      it "serializes to JSON with only the publishable attributes" do
+        subject.to_json.should eq expected_json
+      end
+    end
+
+    context "without publishable attributes defined" do
+      let(:expected_json) { { :tag => attributes }.to_json }
+
+      it "serializes to JSON" do
+        subject.to_json.should eq expected_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe ActiveRemote::Serializers::Protobuf do
+  describe ".build_message" do
+    it "coerces the attribute value to a compatible type"
+
+    it "builds a protobuf message"
+
+    context "when the message doesn't have a field matching a given attribute" do
+      it "skips the attribute"
+    end
+
+    context "when a field is repeated" do
+      it "converts the attribute to a collection"
+      it "coerces the attribute value(s) to a compatible type"
+    end
+
+    context "when the field is an enum" do
+      it "converts the attribute into an integer"
+    end
+
+    context "when a field is a message" do
+      let(:attributes) { { :category => category } }
+      let(:category) { { :name  => 'foo' } }
+      let(:category_message) { Generic::Remote::Category.new(category) }
+
+      context "and the value is a hash" do
+        it "builds new messages with the value(s)" do
+          message = ::ActiveRemote::Base.build_message(Generic::Remote::Post, attributes)
+          message.category.should eq (category_message)
+        end
+      end
+
+      context "and the value is a message" do
+        let(:attributes) { { :category => category_message } }
+
+        it "returns the value" do
+          message = ::ActiveRemote::Base.build_message(Generic::Remote::Post, attributes)
+          message.category.should eq (category_message)
+        end
+      end
+
+      context "and the field is repeated" do
+        context "and the value is a hash" do
+          let(:attributes) { { :records => [ tag ] } }
+          let(:tag) { { :name  => 'foo' } }
+          let(:tag_message) { Generic::Remote::Tag.new(tag) }
+
+          it "builds new messages with the value(s)" do
+            message = ::ActiveRemote::Base.build_message(Generic::Remote::Tags, attributes)
+            message.records.first.should eq (tag_message)
+          end
+        end
+
+        context "and the value is a message" do
+          let(:attributes) { { :records => [ tag_message ] } }
+          let(:tag_message) { Generic::Remote::Tag.new }
+
+          it "returns the value" do
+            message = ::ActiveRemote::Base.build_message(Generic::Remote::Tags, attributes)
+            message.records.first.should eq (tag_message)
+          end
+        end
+      end
+    end
+  end
+
+  describe ".coerce" do
+    context "when field_type is :bool" do
+      context "and value is 1" do
+        it "returns true"
+      end
+
+      context "and value is 0" do
+        it "returns false"
+      end
+    end
+
+    context "when the field_type is :int32" do
+      it "returns an integer"
+    end
+
+    context "when the field_type is :int64" do
+      it "returns an integer"
+    end
+
+    context "when the field_type is :double" do
+      it "returns a float"
+    end
+
+    context "when the field_type is :string" do
+      it "returns a string"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+Bundler.require(:default, :development, :test)
+
+require 'protobuf/rspec'
+require 'support/helpers'
+require 'support/protobuf'
+
+RSpec.configure do |config|
+  config.include Protobuf::RSpec::Helpers
+end

data/spec/support/definitions/author.proto

@@ -0,0 +1,29 @@
+package generic.remote;
+
+import "support/protobuf/error.proto";
+
+message Author { 
+  optional string guid = 1;
+  optional string name = 2;
+  repeated Error errors = 3;
+}
+
+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/post.proto

@@ -0,0 +1,33 @@
+package generic.remote;
+
+import "support/protobuf/error.proto";
+import "support/protobuf/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;
+}
+
+message Posts {
+  repeated Post records = 1;
+}
+
+message PostRequest {
+  repeated string guid = 1;
+  repeated string name = 2;
+  repeated string author_guid = 3;
+}
+
+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/support/protobuf/category.proto

@@ -0,0 +1,29 @@
+package generic.remote;
+
+import "support/protobuf/error.proto";
+
+message Category { 
+  optional string guid = 1;
+  optional string name = 2;
+  repeated Error errors = 3;
+}
+
+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/support/protobuf/error.proto

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

data/spec/support/definitions/tag.proto

@@ -0,0 +1,29 @@
+package generic.remote;
+
+import "support/protobuf/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 CreateAll (Tags) returns (Tags);
+  rpc UpdateAll (Tags) returns (Tags);
+  rpc DeleteAll (Tags) returns (Tags);
+  rpc DestroyAll (Tags) returns (Tags);
+}

data/spec/support/helpers.rb

@@ -0,0 +1,37 @@
+require 'support/models'
+
+##
+# 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