remotely 0.0.4

data/lib/remotely/version.rb

@@ -0,0 +1,3 @@
+module Remotely
+  VERSION = "0.0.4"
+end

data/remotely.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/remotely/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matte Noble"]
+  gem.email         = ["me@mattenoble.com"]
+  gem.description   = %q{Remote API based model associations.}
+  gem.summary       = %q{Remote API based model associations.}
+  gem.homepage      = ''
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "remotely"
+  gem.require_paths = ['lib']
+  gem.version       = Remotely::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", "~> 2.6.0"
+  gem.add_development_dependency "ZenTest"
+  gem.add_development_dependency "autotest-growl"
+  gem.add_development_dependency "webmock"
+  gem.add_development_dependency "ruby-debug19"
+  gem.add_development_dependency "ruby-debug-completion"
+
+  gem.add_dependency "activesupport"
+  gem.add_dependency "activemodel"
+  gem.add_dependency "faraday",   "~> 0.7.4"
+  gem.add_dependency "yajl-ruby", "~> 0.8.2"
+end

data/spec/remotely/associations_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe Remotely::Associations do
+  let(:app) { "http://localhost:1234" }
+
+  shared_examples_for "an association" do
+    it "keeps track of it's remote associations" do
+      subject.remote_associations.should include(assoc)
+    end
+
+    it "creates a method for the association" do
+      subject.should respond_to(assoc)
+    end
+
+    it "creates a setter for the associations" do
+      subject.public_send(:"#{assoc}=", "guy")
+      subject.public_send(assoc).should == "guy"
+    end
+  end
+
+  shared_examples_for "an association with a path" do
+    it "generates the correct path" do
+      subject.path_to(assoc, type).should == path
+    end
+
+    it "requests the correct path" do
+      subject.send(assoc)
+      a_request(:get, "#{app}#{path}").should have_been_made
+    end
+  end
+
+  describe "has_many_remote" do
+    subject     { HasMany.new(id: 1) }
+    let(:type)  { :has_many }
+    let(:assoc) { :things }
+
+    it_behaves_like "an association"
+
+    it "returns a Collection" do
+      subject.things.should be_a Remotely::Collection
+    end
+
+    it "returns a Collection of the appropriate model" do
+      subject.things.first.should be_a Thing
+    end
+
+    it "returns nil when it can not fetch the association" do
+      subject.id = nil
+      subject.things.should be_nil
+    end
+
+    context "with no options" do
+      subject    { HasMany.new(id: 1) }
+      let(:path) { "/has_manies/1/things" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with the :path option" do
+      subject    { HasManyWithPath.new(id: 1) }
+      let(:path) { "/custom/things" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with :path variables" do
+      subject    { HasManyWithPathVariables.new(name: "stuff") }
+      let(:path) { "/custom/stuff/things" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with the :foreign_key option" do
+      subject { HasManyWithForeignKey.new }
+      specify { expect { subject.path_to(:things, :has_many) }.to raise_error(Remotely::HasManyForeignKeyError) }
+    end
+  end
+
+  describe "has_one_remote" do
+    subject     { HasOne.new(id: 1) }
+    let(:type)  { :has_one }
+    let(:assoc) { :thing }
+
+    it_behaves_like "an association"
+
+    it "returns an object of the appropriate model" do
+      subject.thing.should be_a Thing
+    end
+
+    context "with no options" do
+      subject    { HasOne.new(id: 1) }
+      let(:path) { "/has_ones/1/thing" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with the :path option" do
+      subject    { HasOneWithPath.new(id: 1) }
+      let(:path) { "/custom/thing" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with :path variables" do
+      subject    { HasOneWithPathVariables.new(name: "stuff") }
+      let(:path) { "/custom/stuff/thing" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with the :foreign_key option" do
+      subject { HasOneWithForeignKey.new }
+      specify { expect { subject.path_to(:thing, :has_one) }.to raise_error(Remotely::HasManyForeignKeyError) }
+    end
+  end
+
+  describe "belongs_to_remote" do
+    subject     { BelongsTo.new(id: 1, thing_id: 1) }
+    let(:type)  { :belongs_to }
+    let(:assoc) { :thing }
+
+    it_behaves_like "an association"
+
+    it "returns an object of the appropriate model" do
+      subject.thing.should be_a Thing
+    end
+
+    it "should not fetch an association when the foreign key is nil" do
+      subject.thing_id = nil
+      subject.thing.should be_nil
+      a_request(:get, %r(/things)).should_not have_been_made
+    end
+
+    context "with no options" do
+      subject    { BelongsTo.new(thing_id: 1) }
+      let(:path) { "/things/1" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with the :path option" do
+      subject    { BelongsToWithPath.new }
+      let(:path) { "/custom/thing" }
+      it_behaves_like "an association with a path"
+    end
+
+    context "with :path variables" do
+      subject    { BelongsToWithPathVariables.new(name: "stuff") }
+      let(:path) { "/custom/stuff/thing" }
+      it_behaves_like "an association with a path"
+    end
+  end
+end

data/spec/remotely/collection_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Remotely::Collection do
+  let(:finn)      { Member.new(id: 1, name: "Finn", type: "human") }
+  let(:jake)      { Member.new(id: 2, name: "Jake", type: "dog")   }
+  let(:adventure) { Adventure.new(id: 3) }
+
+  subject { Remotely::Collection.new(adventure, Member, [jake, finn]) }
+
+  describe "#find" do
+    it "finds by id" do
+      subject.find(1).should == finn
+    end
+  end
+
+  describe "#where" do
+    it "is searchable by attributes and values" do
+      subject.where(name: "Jake", type: "dog").should == [jake]
+    end
+
+    it "returns a new Collection" do
+      subject.where(name: "Jake", type: "dog").should be_a Remotely::Collection
+    end
+  end
+
+  describe "#order" do
+    it "orders by an attribute" do
+      subject.order(:name).should == [finn, jake]
+    end
+  end
+
+  describe "#build" do
+    it "creates a new model object with the foreign key automatically defined" do
+      adventure.members.build.adventure_id.should == 3
+    end
+
+    it "adds the new object to itself" do
+      new_member = adventure.members.build
+      adventure.members.should include(new_member)
+    end
+  end
+
+  describe "#create" do
+    before do
+      stub_request(:post, %r(/members)).to_return(lambda { |req| {body: req.body} })
+    end
+
+    it "creates and saves a new model object with the foreign key automatically defined" do
+      adventure.members.create.adventure_id.should == 3
+    end
+
+    it "adds the new object to itself" do
+      new_member = adventure.members.create
+      adventure.members.should include(new_member)
+    end
+  end
+end

data/spec/remotely/ext/url_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe URL do
+  it "takes n number of arguments and joins them" do
+    URL.new("a", "b", "c").should == "/a/b/c"
+  end
+
+  it "removes duplicate slashes" do
+    URL.new("a", "/", "b").should == "/a/b"
+  end
+
+  it "is comparable" do
+    URL.new("a", "b").should == URL.new("a", "b")
+  end
+
+  it "is addable" do
+    (URL.new("a", "b") + URL.new("c")).to_s.should == "/a/b/c"
+  end
+
+  it "is subtractable" do
+    (URL.new("a", "b") - URL.new("b")).to_s.should == "/a"
+  end
+
+  it "creatable using URL()" do
+    URL("a", "b").should == "/a/b"
+  end
+end

data/spec/remotely/http_methods_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Remotely::HTTPMethods do
+  include Remotely::HTTPMethods
+
+  it "raises NonJsonResponseError when HTML is returned on GET" do
+    stub_request(:get, %r(/things)).to_return(body: "<html><head><title></title></head></html>")
+    expect { get("/things") }.to raise_error(Remotely::NonJsonResponseError)
+  end
+
+  it "raises NonJsonResponseError when HTML is returned on POST" do
+    stub_request(:post, %r(/things)).to_return(body: "<html><head><title></title></head></html>")
+    expect { post("/things") }.to raise_error(Remotely::NonJsonResponseError)
+  end
+
+  it "raises NonJsonResponseError when HTML is returned on PUT" do
+    stub_request(:put, %r(/things)).to_return(body: "<html><head><title></title></head></html>")
+    expect { put("/things") }.to raise_error(Remotely::NonJsonResponseError)
+  end
+
+  it "raises NonJsonResponseError when HTML is returned on DELETE" do
+    stub_request(:delete, %r(/things)).to_return(body: "<html><head><title></title></head></html>")
+    expect { http_delete("/things") }.to raise_error(Remotely::NonJsonResponseError)
+  end
+end

data/spec/remotely/model_spec.rb

@@ -0,0 +1,368 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Remotely::Model do
+  let(:app)        { "http://localhost:1234" }
+  let(:attributes) { {id: 1, name: "Marceline Quest", type: "MATHEMATICAL!"} }
+
+  subject { Adventure.new(attributes) }
+
+  describe ".attr_savable" do
+    let(:attrs) { {id: 2, name: "Wishes!", type: "MATHEMATICAL!", length: 9} }
+    let(:saved) { to_json({name: "OMG New Name!", type: "MATHEMATICAL!", id: 2}) }
+
+    subject { Adventure.new(attrs) }
+
+    it "stores which attributes are savable" do
+      Adventure.savable_attributes.should == [:name, :type]
+    end
+
+    it "only sends the specified attributes when saving an existing record" do
+      stub_request(:put, "#{app}/adventures/2").to_return(body: saved)
+      subject.update_attribute(:name, "OMG New Name!")
+      a_request(:put, "#{app}/adventures/2").with(body: saved).should have_been_made
+    end
+  end
+
+  describe ".find" do
+    it "retreives an individual resource" do
+      Adventure.find(1)
+      a_request(:get, "#{app}/adventures/1").should have_been_made
+    end
+  end
+
+  describe ".where" do
+    it "searches for resources" do
+      Adventure.where(:type => "MATHEMATICAL!")
+      a_request(:get, "#{app}/adventures/search?type=MATHEMATICAL!").should have_been_made
+    end
+
+    it "returns a collection of resources" do
+      Adventure.where(:type => "MATHEMATICAL!").should be_a Remotely::Collection
+    end
+  end
+
+  describe ".destroy" do
+    it "destroys the resource" do
+      Adventure.destroy(1)
+      a_request(:delete, "#{app}/adventures/1").should have_been_made
+    end
+
+    it "returns true on success" do
+      Adventure.destroy(1).should be_true
+    end
+
+    it "returns false on failure" do
+      stub_request(:delete, %r[/adventures/1]).to_return(status: 500)
+      Adventure.destroy(1).should be_false
+    end
+  end
+
+  describe ".create" do
+    let(:attrs) { attributes.except(:id) }
+
+    before do
+      stub_request(:post, "#{app}/adventures").to_return(lambda { |req| { body: req.body, status: 201 }})
+    end
+
+    it "creates the resource" do
+      Adventure.create(attrs)
+      a_request(:post, "#{app}/adventures").with(attrs).should have_been_made
+    end
+
+    it "returns the new resource on creation" do
+      Adventure.create(attrs).name.should == "Marceline Quest"
+    end
+
+    it "returns an instance with errors when the creation fails" do
+      body = Yajl.dump({errors: {base: ["error"]}})
+      stub_request(:post, %r[/adventures]).to_return(status: 500, body: body)
+      Adventure.create(attrs).errors[:base].should include("error")
+    end
+  end
+
+  describe ".find_or_" do
+    let(:body)         { Yajl::Encoder.encode([{id: 1, name: "BubbleGum"}]) }
+    let(:stub_success) { stub_request(:get, "#{app}/adventures/search?name=BubbleGum").to_return(body: body) }
+    let(:stub_failure) { stub_request(:get, "#{app}/adventures/search?name=BubbleGum").to_return(body: "[]") }
+
+    describe "initialize" do
+      it "tries to fetch the record" do
+        stub_success
+        Adventure.find_or_initialize(name: "BubbleGum")
+        a_request(:get, "#{app}/adventures/search?name=BubbleGum").should have_been_made
+      end
+
+      it "returns the fetched object if found" do
+        stub_success
+        Adventure.find_or_initialize(name: "BubbleGum").id.should == 1
+      end
+
+      it "creates a new object if one is not found" do
+        stub_failure
+        Adventure.find_or_initialize(name: "BubbleGum").should be_a_new_record
+      end
+    end
+
+    describe "create" do
+      it "automatically saves the new object" do
+        stub_failure
+        Adventure.should_receive(:create).with(name: "BubbleGum")
+        Adventure.find_or_create(name: "BubbleGum")
+      end
+
+      it "returns the first item from the collection" do
+        stub_success
+        Adventure.find_or_create(name: "BubbleGum").should be_an Adventure
+      end
+    end
+  end
+
+  describe ".find_by_*" do
+    it "searches by a single attribute" do
+      Adventure.find_by_name("Fun")
+      a_request(:get, "#{app}/adventures/search?name=Fun").should have_been_made
+    end
+
+    it "searches by multiple attributes seperated by 'and'" do
+      Adventure.find_by_name_and_type("Fun", "MATHEMATICAL!")
+      a_request(:get, "#{app}/adventures/search?name=Fun&type=MATHEMATICAL!").should have_been_made
+    end
+  end
+
+  describe ".all" do
+    it "fetches all resources" do
+      Adventure.all
+      a_request(:get, "#{app}/adventures").should have_been_made
+    end
+  end
+
+  describe ".update_all" do
+    it "request an update to all entries" do
+      Adventure.update_all(type: "awesome")
+      a_request(:put, "#{app}/adventures").with(type: "awesome").should have_been_made
+    end
+  end
+
+  describe "#save" do
+    let(:new_name)       { "City of Thieves" }
+    let(:new_attributes) { attributes.merge(name: new_name) }
+
+    context "when updating" do
+      it "updates the resource" do
+        adventure = Adventure.new(attributes)
+        adventure.name = new_name
+        adventure.save
+        a_request(:put, "#{app}/adventures/1").with(new_attributes).should have_been_made
+      end
+
+      it "returns true when the save succeeds" do
+        Adventure.new(attributes).save.should be_a Adventure
+      end
+
+      it "sets errors when a save fails" do
+        adventure = Adventure.new(attributes)
+        stub_request(:put, %r[/adventures/1]).to_return(status: 409, body: to_json({errors: {base: %w{this failed}}}))
+        adventure.save
+        adventure.errors[:base].should == %w{this failed}
+      end
+    end
+
+    context "when creating" do
+      it "merges in the response body to attributes on success" do
+        adventure = Adventure.new(name: "To Be Saved...")
+        stub_request(:post, %r(/adventures)).to_return(body: to_json(attributes.merge(name: "To Be Saved...", id: 2)), status: 201)
+        adventure.save
+        adventure.id.should == 2
+      end
+
+      it "sets errors on a failure" do
+        body = Yajl.dump({errors: {base: ["error"]}})
+        stub_request(:post, %r(/adventures)).to_return(status: 409, body: body)
+        Adventure.new(name: "name").save.errors.should_not be_empty
+      end
+    end
+  end
+
+  describe "#update_attribute" do
+    it "updates a single attribute and saves" do
+      subject.update_attribute(:type, "powerful")
+      a_request(:put, "#{app}/adventures/1").with(type: "powerful").should have_been_made
+    end
+  end
+
+  describe "#to_param" do
+    it "returns correct value" do
+      subject.to_param.should == '1'
+    end
+  end
+
+  describe "#update_attributes" do
+    let(:updates)        { {type: "awesome"} }
+    let(:new_attributes) { subject.attributes.merge(updates) }
+
+    it "replaces existing attribute values" do
+      subject.update_attributes(updates)
+      subject.type.should == "awesome"
+    end
+
+    it "calls save" do
+      subject.update_attributes(updates)
+      a_request(:put, "#{app}/adventures/1").with(new_attributes).should have_been_made
+    end
+
+    it "returns true on success" do
+      subject.update_attributes(updates).should be_true
+    end
+
+    it "sets errors on failure" do
+      body = Yajl.dump({errors: {base: ["error"]}})
+      stub_request(:put, %r[/adventures/1]).to_return(status: 500, body: body)
+      subject.update_attributes(updates)
+      subject.errors[:base].should include("error")
+    end
+
+    it "reverts the object's attributes if the save fails" do
+      body = Yajl.dump({errors: {base: ["error"]}})
+      stub_request(:put, %r[/adventures/1]).to_return(status: 500, body: body)
+      subject.update_attributes(updates)
+      subject.type.should == "MATHEMATICAL!"
+    end
+  end
+
+  describe "#destroy" do
+    it "destroys a resource with the might of 60 jotun!!" do
+      Adventure.new(attributes).destroy
+      a_request(:delete, "#{app}/adventures/1").should have_been_made
+    end
+  end
+
+  describe "associations" do
+    let(:member) { Member.new(id: 2, name_id: 1) }
+
+    it "creates associations when instantiated" do
+      member.should respond_to :name
+    end
+
+    it "fetches the resource when accessed" do
+      Name.should_receive(:find).with(1)
+      member.name
+    end
+
+    it "doesn't fetch a resource twice" do
+      Name.should_receive(:find).with(1).once
+      member.name
+      member.name
+    end
+
+    it "reloads association objects" do
+      Name.should_receive(:find).with(1).twice
+      member.name
+      member.name(true)
+    end
+  end
+
+  context "basic auth" do
+    before do
+      Remotely.configure { app :adventure_app, "http://localhost:3000" }
+    end
+
+    after do
+      Remotely.reset!
+    end
+
+    it "sends Authorization headers when basic auth is configured" do
+      Remotely.configure { basic_auth "user", "password" }
+      Adventure.find(1)
+      a_request(:get, "#{app}/adventures/1").with(headers: {'Authorization' => "Basic dXNlcjpwYXNzd29yZA=="})
+    end
+
+    it "doesn't send Authorization headers when basic auth is not configured" do
+      Adventure.find(1)
+      a_request(:get, "#{app}/adventures/1").with(headers: {})
+    end
+  end
+
+  it "sets the app it belongs to" do
+    Adventure.app.should == :adventure_app
+  end
+
+  it "sets the uri to itself" do
+    Adventure.uri.should == "/adventures"
+  end
+
+  it "has a connection" do
+    Adventure.remotely_connection.should be_a Faraday::Connection
+  end
+
+  it "supports ActiveModel::Naming methods" do
+    Adventure.model_name.element.should == "adventure"
+  end
+
+  it "is reloadable" do
+    subject.reload
+    a_request(:get, "#{app}/adventures/1")
+  end
+
+  it "symbolizes attribute keys" do
+    subject.attributes.should == attributes
+  end
+
+  it "can be initialized with a hash of attribute/values" do
+    subject.name.should == "Marceline Quest"
+  end
+
+  it "sets an attribute value" do
+    subject.name = "City of Thieves"
+    subject.name.should == "City of Thieves"
+  end
+
+  it "raises a normal NoMethodError for non-existent attributes" do
+    expect { subject.height }.to raise_error(NoMethodError)
+  end
+
+  it "is a new_record when no id exists" do
+    subject.id = nil
+    subject.should be_a_new_record
+  end
+
+  it "creates boolean methods for each attribute" do
+    subject.name?.should == true
+  end
+
+  it "returns id from #to_key" do
+    subject.id = 1
+    subject.to_key.should == [1]
+  end
+
+  it "returns id from #to_param" do
+    subject.id = 1
+    subject.to_param.should == "1"
+  end
+
+  it "returns itself from #to_model" do
+    subject.to_model.should == subject
+  end
+
+  context "with an app uri" do
+    before do
+      Remotely.app :uri_app, "http://localhost:3000/api"
+      Thing.app :uri_app
+    end
+
+    it "prepends the app uri" do
+      Thing.expand("/members").should == "/api/members"
+    end
+
+    it "doesn't prepend when it's already there" do
+      Thing.expand("/api/members").should == "/api/members"
+    end
+  end
+
+  context "with errors" do
+    let(:attributes) { {'errors' => {:base => %w{totally failed dude}}} }
+
+    it "adds errors during #initialize" do
+      subject.errors[:base].should == %w{totally failed dude}
+    end
+  end
+end