contextio 0.5.0 → 1.0.0

data/spec/contextio/api/url_builder_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'contextio/api/url_builder'
+
+describe ContextIO::API::URLBuilder do
+  let(:api) { double('api') }
+
+  describe "#url_for" do
+    subject { ContextIO::API::URLBuilder.url_for(resource) }
+
+    context "when passed an unregistered class" do
+      let(:resource) { "String isn't registered."}
+
+      it "raises an exception" do
+        expect { subject }.to raise_exception(ContextIO::API::URLBuilder::Error)
+      end
+    end
+
+    context "when passed a ConnectToken" do
+      context "with an account" do
+        let(:account) { double('account', id: 'account_id') }
+        let(:resource) { ContextIO::ConnectToken.new(api, token: 'token', account: account) }
+
+        it { should eq('accounts/account_id/connect_tokens/token') }
+      end
+
+      context "without an account" do
+        let(:resource) { ContextIO::ConnectToken.new(api, token: 'token', api_attributes: { 'account' => { } }) }
+
+        it { should eq('connect_tokens/token') }
+      end
+    end
+
+    context "when passed a ConnectTokenCollection" do
+      context "with an account" do
+        let(:account) { double('account', id: 'account_id') }
+        let(:resource) { ContextIO::ConnectTokenCollection.new(api, account: account) }
+
+        it { should eq('accounts/account_id/connect_tokens') }
+      end
+
+      context "wiehout an account" do
+        let(:resource) { ContextIO::ConnectTokenCollection.new(api) }
+
+        it { should eq('connect_tokens') }
+      end
+    end
+
+    context "when passed an OAuthProvider" do
+      let(:resource) { ContextIO::OAuthProvider.new(api, provider_consumer_key: 'provider_consumer_key') }
+
+      it { should eq('oauth_providers/provider_consumer_key') }
+    end
+
+    context "when passed an OAuthProviderCollection" do
+      let(:resource) { ContextIO::OAuthProviderCollection.new(api) }
+
+      it { should eq('oauth_providers') }
+    end
+
+    context "when passed an EmailSettings" do
+      let(:resource) { ContextIO::EmailSettings.new(api, 'email') }
+
+      it { should eq('discovery') }
+    end
+
+    context "when passed an Account" do
+      let(:resource) { ContextIO::Account.new(api, id: 'account_id') }
+
+      it { should eq('accounts/account_id') }
+    end
+
+    context "when passed an AccountCollection" do
+      let(:resource) { ContextIO::AccountCollection.new(api) }
+
+      it { should eq('accounts') }
+    end
+  end
+end

data/spec/contextio/api_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'contextio/api'
+
+describe ContextIO::API do
+  describe ".version" do
+    subject { ContextIO::API }
+
+    it "uses API version 2.0" do
+      expect(subject.version).to eq('2.0')
+    end
+  end
+
+  describe ".base_url" do
+    subject { ContextIO::API }
+
+    it "is https://api.context.io" do
+      expect(subject.base_url).to eq('https://api.context.io')
+    end
+  end
+
+  describe ".new" do
+    subject { ContextIO::API.new('test_key', 'test_secret') }
+
+    it "takes a key" do
+      expect(subject.key).to eq('test_key')
+    end
+
+    it "takes a secret" do
+      expect(subject.secret).to eq('test_secret')
+    end
+  end
+
+  describe "#path" do
+    context "without params" do
+      subject { ContextIO::API.new(nil, nil).path('test_command') }
+
+      it "puts the command in the path" do
+        expect(subject).to eq('/2.0/test_command')
+      end
+    end
+
+    context "with params" do
+      subject { ContextIO::API.new(nil, nil).path('test_command', foo: 1, bar: %w(a b c)) }
+
+      it "URL encodes the params" do
+        expect(subject).to eq('/2.0/test_command?foo=1&bar=a%2Cb%2Cc')
+      end
+    end
+
+    context "with a full URL" do
+      subject { ContextIO::API.new(nil, nil).path('https://api.context.io/2.0/test_command') }
+
+      it "strips out the command" do
+        expect(subject).to eq('/2.0/test_command')
+      end
+    end
+  end
+
+  describe "#request" do
+    subject { ContextIO::API.new(nil, nil).request(:get, 'test') }
+
+    context "with a good response" do
+      before do
+        FakeWeb.register_uri(
+          :get,
+          'https://api.context.io/2.0/test',
+          body: JSON.dump('a' => 'b', 'c' => 'd')
+        )
+      end
+
+      it "parses the JSON response" do
+        expect(subject).to eq('a' => 'b', 'c' => 'd')
+      end
+    end
+
+    context "with a bad response that has a body" do
+      before do
+        FakeWeb.register_uri(
+          :get,
+          'https://api.context.io/2.0/test',
+          status: ['400', 'Bad Request'],
+          body: JSON.dump('type' => 'error', 'value' => 'nope')
+        )
+      end
+
+      it "raises an API error with the body message" do
+        expect { subject }.to raise_error(ContextIO::API::Error, 'nope')
+      end
+    end
+
+    context "with a bad response that has no body" do
+      before do
+        FakeWeb.register_uri(
+          :get,
+          'https://api.context.io/2.0/test',
+          status: ['400', 'Bad Request']
+        )
+      end
+
+      it "raises an API error with the header message" do
+        expect { subject }.to raise_error(ContextIO::API::Error, 'Bad Request')
+      end
+    end
+  end
+
+  describe ".url_for" do
+    it "delegates to ContextIO::API::URLBuilder" do
+      ContextIO::API::URLBuilder.should_receive(:url_for).with('foo')
+
+      ContextIO::API.url_for('foo')
+    end
+  end
+
+  describe "#url_for" do
+    subject { ContextIO::API.new('test_key', 'test_secret') }
+
+    it "delegates to the class" do
+      ContextIO::API.should_receive(:url_for).with('foo')
+
+      subject.url_for('foo')
+    end
+  end
+end

data/spec/contextio/connect_token_collection_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'contextio/connect_token_collection'
+
+describe ContextIO::ConnectTokenCollection do
+  let(:api) { double('API', url_for: 'url from api') }
+
+  subject { ContextIO::ConnectTokenCollection.new(api) }
+
+  describe "#create" do
+    before do
+      api.stub(:request).with(:post, anything, anything).and_return({ token: '1234' })
+    end
+
+    it "posts to the api" do
+      api.should_receive(:request).with(
+        :post,
+        'url from api',
+        hash_including(callback_url: 'http://callback.com')
+      )
+
+      subject.create('http://callback.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('http://callback.com')
+    end
+
+    it "returns a ConnectToken" do
+      expect(subject.create('http://callback.com')).to be_a(ContextIO::ConnectToken)
+    end
+
+    it "takes an optional service level" do
+      api.should_receive(:request).with(
+        anything,
+        anything,
+        hash_including(service_level: 'PRO')
+      )
+
+      subject.create('http://callback.com', service_level: 'PRO')
+    end
+
+    it "takes an optional email" do
+      api.should_receive(:request).with(
+        anything,
+        anything,
+        hash_including(email: 'person@email.com')
+      )
+
+      subject.create('http://callback.com', email: 'person@email.com')
+    end
+
+    it "takes an optional first name" do
+      api.should_receive(:request).with(
+        anything,
+        anything,
+        hash_including(first_name: 'Bruno')
+      )
+
+      subject.create('http://callback.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('http://callback.com', last_name: 'Morency')
+    end
+  end
+end

data/spec/contextio/connect_token_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'contextio/connect_token'
+
+describe ContextIO::ConnectToken do
+  let(:api) { double('API') }
+
+  describe ".new" do
+    subject { ContextIO::ConnectToken.new(api, token: '1234', foo: 'bar') }
+
+    it "takes an api handle" do
+      expect(subject.api).to eq(api)
+    end
+
+    it "assigns instance variables for hash arguments" do
+      expect(subject.instance_variable_get('@token')).to eq('1234')
+      expect(subject.instance_variable_get('@foo')).to eq('bar')
+    end
+
+    context "with a token passed in" do
+      it "doesn't raise an error" do
+        expect { ContextIO::ConnectToken.new(api, token: '1234') }.to_not raise_error
+      end
+    end
+
+    context "with neither a provider_token nor a resource_url passed in" do
+      it "raises an ArgumentError" do
+        expect { ContextIO::ConnectToken.new(api, foo: 'bar') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#token" do
+    context "when input at creation" do
+      subject { ContextIO::ConnectToken.new(api, token: '1234') }
+
+      it "uses the input key" do
+        api.should_not_receive(:request)
+
+        expect(subject.token).to eq('1234')
+      end
+    end
+
+    context "when not input at creation" do
+      subject { ContextIO::ConnectToken.new(api, resource_url: 'http://example.com/hitme') }
+
+      it "loads it from the API" do
+        api.should_receive(:request).with(
+          :get,
+          'http://example.com/hitme'
+        ).and_return({
+          'token' => 'baphoo'
+        })
+
+        expect(subject.token).to eq('baphoo')
+      end
+    end
+  end
+end

data/spec/contextio/email_settings_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'contextio/email_settings'
+
+describe ContextIO::EmailSettings do
+  let(:api) { double('API') }
+
+  subject { ContextIO::EmailSettings.new(api, 'email@email.com') }
+
+  describe ".new" do
+    context "without a source type passed in" do
+      it "takes an api handle" do
+        expect(subject.api).to eq(api)
+      end
+
+      it "takes an email address" do
+        expect(subject.email).to eq('email@email.com')
+      end
+
+      it "defaults the source type to 'IMAP'" do
+        expect(subject.source_type).to eq('IMAP')
+      end
+    end
+
+    context "with a source type passed in" do
+      subject { ContextIO::EmailSettings.new(api, 'email@email.com', 'FOO') }
+
+      it "takes a source type argument" do
+        expect(subject.source_type).to eq('FOO')
+      end
+    end
+  end
+
+  describe "#resource_url" do
+    it "builds the right url" do
+      expect(subject.resource_url).to eq('discovery')
+    end
+  end
+
+  describe "#documentation" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'documentation' => ['foo', 'bar'] })
+      expect(subject.documentation).to eq(['foo', 'bar'])
+    end
+  end
+
+  describe "#found?" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'found' => true })
+      expect(subject).to be_found
+    end
+  end
+
+  describe "#type" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'type' => 'gmail' })
+      expect(subject.type).to eq('gmail')
+    end
+  end
+
+  describe "#server" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'imap' => { 'server' => 'imap.gmail.com' }})
+      expect(subject.server).to eq('imap.gmail.com')
+    end
+  end
+
+  describe "#username" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'imap' => { 'username' => 'ben' }})
+      expect(subject.username).to eq('ben')
+    end
+  end
+
+  describe "#port" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'imap' => { 'port' => 993 }})
+      expect(subject.port).to eq(993)
+    end
+  end
+
+  describe "#oauth?" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'imap' => { 'oauth' => false }})
+      expect(subject).to_not be_oauth
+    end
+  end
+
+  describe "#use_ssl?" do
+    it "fetches it from the api" do
+      api.should_receive(:request).with(:get, anything, anything).and_return({ 'imap' => { 'use_ssl' => false }})
+      expect(subject).to_not be_use_ssl
+    end
+  end
+
+  describe "#fetch_attributes" do
+    before do
+      api.stub(:request).with(:get, anything, anything).and_return({ 'foo' => 'bar' })
+    end
+
+    it "defines a getter if one doesn't already exist" do
+      subject.send(:fetch_attributes)
+
+      expect(subject.foo).to eq('bar')
+    end
+
+    it "hits the right URL" do
+      api.should_receive(:request).with(:get, 'discovery', 'email' => 'email@email.com', 'source_type' => 'IMAP')
+
+      subject.send(:fetch_attributes)
+    end
+  end
+end