contextio 0.5.0 → 1.0.0

data/lib/contextio/webhook_collection.rb

@@ -0,0 +1,26 @@
+require_relative 'api/resource_collection'
+require_relative 'webhook'
+
+class ContextIO
+  class WebhookCollection
+    include ContextIO::API::ResourceCollection
+
+    self.resource_class = ContextIO::Webhook
+    self.association_name = :webhooks
+
+    belongs_to :account
+
+    def create(success_callback_url, failure_callback_url, options={})
+      api_args = options.merge(
+        'callback_url' => success_callback_url,
+        'failure_notif_url' => failure_callback_url
+      )
+
+      result_hash = api.request(:post, resource_url, api_args)
+
+      result_hash.delete('success')
+
+      resource_class.new(api, result_hash)
+    end
+  end
+end

data/spec/config.yml.example

@@ -0,0 +1,3 @@
+---
+key: 12345
+secret: 54321

data/spec/contextio/account_collection_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'contextio/account_collection'
+
+describe ContextIO::AccountCollection do
+  let(:api) { double('API', url_for: 'url from api') }
+
+  subject { ContextIO::AccountCollection.new(api) }
+
+  describe "#create" do
+    before do
+      api.stub(:request).with(:post, anything, anything).and_return(
+        'success'      => true,
+        'id'           => '1234',
+        'resource_url' => 'resource_url'
+      )
+    end
+
+    context "without where constraints" do
+      it "requires an email address" do
+        expect { subject.create(first_name: 'Bruno') }.to raise_error(ArgumentError)
+      end
+
+      it "posts to the api" do
+        api.should_receive(:request).with(
+          :post,
+          'url from api',
+          hash_including(email: 'hello@email.com')
+        )
+
+        subject.create(email: 'hello@email.com')
+      end
+
+      it "doesn't make any more API calls than it needs to" do
+        api.should_not_receive(:request).with(:get, anything, anything)
+
+        subject.create(email: 'hello@email.com')
+      end
+
+      it "returns an Account" do
+        expect(subject.create(email: 'hello@email.com')).to be_a(ContextIO::Account)
+      end
+
+      it "takes an optional first name" do
+        api.should_receive(:request).with(
+          anything,
+          anything,
+          hash_including(first_name: 'Bruno')
+        )
+
+        subject.create(email: 'hello@email.com', first_name: 'Bruno')
+      end
+
+      it "takes an optional last name" do
+        api.should_receive(:request).with(
+          anything,
+          anything,
+          hash_including(last_name: 'Morency')
+        )
+
+        subject.create(email: 'hello@email.com', last_name: 'Morency')
+      end
+    end
+
+    context "with email in the where constraints" do
+      subject { ContextIO::AccountCollection.new(api).where(email: 'hello@email.com')}
+
+      it "allows a missing email address" do
+        expect { subject.create(first_name: 'Bruno') }.to_not raise_error(ArgumentError)
+      end
+
+      it "uses the email address from the where constraints" do
+        api.should_receive(:request).with(anything, anything, hash_including(email: 'hello@email.com'))
+
+        subject.create(first_name: 'Bruno')
+      end
+    end
+  end
+end

data/spec/contextio/account_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'contextio/account'
+
+describe ContextIO::Account do
+  let(:api) { double('api', url_for: 'url from api') }
+
+  subject { ContextIO::Account.new(api, id: '1234') }
+
+  describe ".new" do
+    context "with an id passed in" do
+      it "doesn't raise an error" do
+        expect { ContextIO::Account.new(api, id: '1234') }.to_not raise_error
+      end
+    end
+
+    context "with neither an id nor a resource_url passed in" do
+      it "raises an ArgumentError" do
+        expect { ContextIO::Account.new(api, foo: 'bar') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#update" do
+    before do
+      api.stub(:request).and_return({'success' => true})
+    end
+
+    subject { ContextIO::Account.new(api, id: '1234', first_name: 'old first name') }
+
+    it "posts to the api" do
+      api.should_receive(:request).with(
+        :post,
+        'url from api',
+        first_name: 'new first name'
+      )
+
+      subject.update(first_name: 'new first name')
+    end
+
+    it "updates the object" do
+      subject.update(first_name: 'new first name')
+
+      expect(subject.first_name).to eq('new first name')
+    end
+
+    it "doesn't make any more API calls than it needs to" do
+      api.should_not_receive(:request).with(:get, anything, anything)
+
+      subject.update(first_name: 'new first name')
+    end
+  end
+end

data/spec/contextio/api/association_helpers_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'contextio/api/association_helpers'
+
+describe "ContextIO::API::AssociationHelpers" do
+  subject { ContextIO::API::AssociationHelpers }
+
+  describe ".class_for_association_name" do
+    context "when the resource is registered" do
+      let(:resource_class) do
+        Class.new
+      end
+
+      before do
+        subject.register_resource(resource_class, :registered)
+      end
+
+      it "makes the resource available" do
+        expect(subject.class_for_association_name(:registered)).to be(resource_class)
+      end
+    end
+
+    context "when the resource is NOT registered" do
+      it "returns nil" do
+        expect(subject.class_for_association_name(:not_registered)).to be_nil
+      end
+    end
+  end
+end

data/spec/contextio/api/resource_collection_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+require 'contextio/api/resource_collection'
+
+class SingularHelper
+  def initialize(*args); end
+  def self.primary_key; 'token'; end
+end
+
+class Owner
+  def self.primary_key; 'id'; end
+  def id; 4; end
+  def initialize(*args); end
+
+  ContextIO::API::AssociationHelpers.register_resource(self, :owner)
+end
+
+describe ContextIO::API::ResourceCollection do
+  let(:api) { double('api', url_for: 'url from api') }
+
+  describe ".resource_class=" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+
+        self.resource_class = SingularHelper
+      end
+    end
+
+    subject do
+      helper_class.new(api)
+    end
+
+    it "makes the class available to instances of the collection" do
+      expect(subject.resource_class).to eq(SingularHelper)
+    end
+  end
+
+  describe ".belongs_to" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+
+        belongs_to :owner
+
+        self.association_name = :helper_class
+        self.resource_class = SingularHelper
+      end
+    end
+
+    let(:owner) { Owner.new }
+
+    subject { helper_class.new(api, owner: owner) }
+
+    it "makes the belonged-to object available" do
+      expect(subject.owner).to eq(owner)
+    end
+  end
+
+  describe "#api" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+      end
+    end
+
+    subject do
+      helper_class.new(api)
+    end
+
+    it "holds a reference to the api" do
+      expect(subject.api).to eq(api)
+    end
+  end
+
+  describe ".where" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+
+        belongs_to :owner
+
+        self.resource_class = SingularHelper
+      end
+    end
+
+    subject do
+      helper_class.new(api, owner: :relation)
+    end
+
+    it "limits the scope of subsequent #each calls" do
+      api.should_receive(:request).with(anything, anything, foo: 'bar').and_return([])
+
+      subject.where(foo: 'bar').each { }
+    end
+
+    it "returns a new object, not the same one, modified" do
+      expect(subject.where(foo: 'bar')).to_not be(subject)
+    end
+
+    it "returns a collection object" do
+      expect(subject.where(foo: 'bar')).to be_a(helper_class)
+    end
+
+    it "makes the constraints available" do
+      expect(subject.where(foo: 'bar').where_constraints).to eq(foo: 'bar')
+    end
+
+    it "overrides older constraints with newer ones" do
+      expect(subject.where(foo: 'bar').where(foo: 'baz').where_constraints).to eq(foo: 'baz')
+    end
+
+    it "keeps collection relations from the old to new object" do
+      expect(subject.where(foo: 'bar').owner).to eq(subject.owner)
+    end
+  end
+
+  describe "#each" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+
+        self.resource_class = SingularHelper
+      end
+    end
+
+    context "when no attribute hashes are passed in at creation" do
+      subject do
+        helper_class.new(api)
+      end
+
+      before do
+        api.stub(:request).and_return([{key: 'value 1'}, {key: 'value 2'}])
+      end
+
+      it "yields instances of the singular resource class" do
+        subject.each do |x|
+          expect(x).to be_a(SingularHelper)
+        end
+      end
+
+      it "gets attributes for the resources from the api" do
+        api.should_receive(:request).exactly(:once).with(:get, 'url from api', {})
+
+        subject.each { }
+      end
+
+      it "passes the api to the singular resource instances" do
+        SingularHelper.should_receive(:new).exactly(:twice).with(api, anything)
+
+        subject.each { }
+      end
+
+      it "passes attributes to the singular resource instances" do
+        SingularHelper.should_receive(:new).exactly(:once).with(anything, key: 'value 1')
+        SingularHelper.should_receive(:new).exactly(:once).with(anything, key: 'value 2')
+
+        subject.each { }
+      end
+
+      context "with a belonged-to resource" do
+        let(:helper_class) do
+          Class.new do
+            include ContextIO::API::ResourceCollection
+
+            belongs_to :owner
+
+            self.resource_class = SingularHelper
+          end
+        end
+
+        let(:owner) { Owner.new }
+
+        subject do
+          helper_class.new(api, owner: owner)
+        end
+
+        it "passes the belonged-to resource to the singular resource instances" do
+          SingularHelper.should_receive(:new).exactly(:twice).with(
+            anything,
+            hash_including(owner: owner)
+          )
+
+          subject.each { }
+        end
+      end
+    end
+
+    context "when attribute hashes are passed in at creation" do
+      subject do
+        helper_class.new(api, attribute_hashes: [{foo: 'bar'}, {foo: 'baz'}])
+      end
+
+      it "yields instances of the singular resource class" do
+        subject.each do |x|
+          expect(x).to be_a(SingularHelper)
+        end
+      end
+
+      it "doesn't hit the API" do
+        api.should_not_receive(:request)
+
+        subject.each { }
+      end
+
+      it "passes the api to the singular resource instances" do
+        SingularHelper.should_receive(:new).exactly(:twice).with(api, anything)
+
+        subject.each { }
+      end
+
+      it "passes attributes to the singular resource instances" do
+        SingularHelper.should_receive(:new).exactly(:once).with(anything, foo: 'bar')
+        SingularHelper.should_receive(:new).exactly(:once).with(anything, foo: 'baz')
+
+        subject.each { }
+      end
+
+      context "with a belonged-to resource" do
+        let(:helper_class) do
+          Class.new do
+            include ContextIO::API::ResourceCollection
+
+            belongs_to :owner
+
+            self.resource_class = SingularHelper
+          end
+        end
+
+        let(:owner) { Owner.new }
+
+        subject do
+          helper_class.new(
+            api,
+            attribute_hashes: [{foo: 'bar'}, {foo: 'baz'}],
+            owner: owner
+          )
+        end
+
+        it "passes the belonged-to resource to the singular resource instances" do
+          SingularHelper.should_receive(:new).exactly(:twice).with(
+            anything,
+            hash_including(owner: owner)
+          )
+
+          subject.each { }
+        end
+      end
+    end
+  end
+
+  describe "#[]" do
+    let(:helper_class) do
+      Class.new do
+        include ContextIO::API::ResourceCollection
+
+        self.resource_class = SingularHelper
+      end
+    end
+
+    subject do
+      helper_class.new(api)
+    end
+
+    it "returns a new instance of the resource class" do
+      expect(subject[1234]).to be_a(SingularHelper)
+    end
+
+    it "feeds the given key to the resource class" do
+      SingularHelper.should_receive(:new).with(anything, 'token' => 1234)
+
+      subject[1234]
+    end
+
+    it "feeds the api to the resource class" do
+      SingularHelper.should_receive(:new).with(api, anything)
+
+      subject[1234]
+    end
+
+    it "doesn't hit the API" do
+      api.should_not_receive(:request)
+
+      subject[1234]
+    end
+  end
+end