singly 0.1.0 → 0.1.1

data/spec/integration/account/merge_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).merge" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /auth/merge" do
+    subject { account.merge("SOURCE_TOKEN") }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/auth/merge" }
+    it { subject.options.should include(
+      method: :get,
+      params: {source: "SOURCE_TOKEN", dest: "TOKEN_STUB"}
+    )}
+  end
+end

data/spec/integration/account/profile_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).profile" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /profile" do
+    subject { account.profile }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profile" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+end

data/spec/integration/account/profiles_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).profiles" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /profiles" do
+    subject { account.profiles }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /profiles with optional params" do
+    subject { account.profiles(data: true, verify: true) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles" }
+    it { subject.options.should include(
+      method: :get,
+      params: {
+        access_token: "TOKEN_STUB",
+        data: true,
+        verify: true
+      }
+    )}
+  end
+  describe "GET /profiles/:service" do
+    subject { account.profiles.foursquare }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles/foursquare" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /profiles/self" do
+    subject { account.profiles.self }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles/self" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "POST /profiles/self with data" do
+    subject { account.profiles.self(x: 1, y: {z: 3})  }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles/self" }
+    it { subject.options.should include(
+      method: :post,
+      params: { access_token: "TOKEN_STUB" },
+      body: { x: 1, y: { z: 3 } }
+    )}
+  end
+  describe "DELETE /profiles" do
+    subject { account.profiles.delete }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/profiles" }
+    it { subject.options.should include(
+      method: :delete,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+end

data/spec/integration/account/proxy_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).proxy" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /proxy/:service/:path" do
+    subject { account.proxy.thirtysevensignals(:get, "some/path/123", {a: :b}) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/proxy/37signals/some%2Fpath%2F123" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB", a: :b }
+    )}
+  end
+  describe "PUT /proxy/:service/:path" do
+    subject { account.proxy.yammer(:put, "some/path/123", {a: :b}) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/proxy/yammer/some%2Fpath%2F123" }
+    it { subject.options.should include(
+      method: :put,
+      params: { access_token: "TOKEN_STUB" },
+      body: { a: :b }
+    )}
+  end
+  describe "POST /proxy/:service/:path" do
+    subject { account.proxy.zeo(:post, "some/path/123", {a: :b}) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/proxy/zeo/some%2Fpath%2F123" }
+    it { subject.options.should include(
+      method: :post,
+      params: { access_token: "TOKEN_STUB" },
+      body: { a: :b }
+    )}
+  end
+  describe "DELETE /proxy/:service/:path" do
+    subject { account.proxy.tumblr(:delete, "some/path/123", {a: :b}) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/proxy/tumblr/some%2Fpath%2F123" }
+    it { subject.options.should include(
+      method: :delete,
+      params: { access_token: "TOKEN_STUB", a: :b },
+    )}
+  end
+end

data/spec/integration/account/services_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).services" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /services/:service" do
+    subject { account.services.dwolla }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/services/dwolla" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /services/:service/:endpoint" do
+    subject { account.services.fitbit.devices }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/services/fitbit/devices" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /services/:service/:endpoint with optional params" do
+    subject { account.services.facebook.photos({
+      fields: "map.oembed",
+      limit: 200,
+      :since => 1361669948000,
+      :until => 1361679948000,
+      near: "40.7361,73.9901",
+      within: "1",
+      q: "Timehop BOOM",
+      participants: "self",
+      map: true
+    }) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/services/facebook/photos" }
+    it { subject.options.should include(
+      method: :get,
+      params: {
+        access_token: "TOKEN_STUB",
+        fields: "map.oembed",
+        limit: 200,
+        :since => 1361669948000,
+        :until => 1361679948000,
+        near: "40.7361,73.9901",
+        within: "1",
+        q: "Timehop BOOM",
+        participants: "self",
+        map: true
+      }
+    )}
+  end
+  describe "GET /services/:service/:endpoint/:id" do
+    subject { account.services.twitter.tweets(id: "1234@5/6") }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/services/twitter/tweets/1234%405%2F6" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+end

data/spec/integration/account/types_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe "Singly.account(:access_token).types" do
+  let(:account) { Singly.account("TOKEN_STUB") }
+  describe "GET /types" do
+    subject { account.types }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/types" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /types/:type" do
+    subject { account.types.photos }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/types/photos" }
+    it { subject.options.should include(
+      method: :get,
+      params: { access_token: "TOKEN_STUB" }
+    )}
+  end
+  describe "GET /types/:type with optional params" do
+    subject { account.types.all({
+      fields: "map.oembed",
+      limit: 200,
+      :since => 1361669948000,
+      :until => 1361679948000,
+      near: "40.7361,73.9901",
+      within: "1",
+      q: "Timehop BOOM",
+      participants: "self",
+      map: true,
+      dedup: true,
+      services: "facebook,foursquare"
+    }) }
+    it { subject.validate.should == true }
+    it { subject.path.should == "/types/all" }
+    it { subject.options.should include(
+      method: :get,
+      params: { 
+        access_token: "TOKEN_STUB",
+        fields: "map.oembed",
+        limit: 200,
+        :since => 1361669948000,
+        :until => 1361679948000,
+        near: "40.7361,73.9901",
+        within: "1",
+        q: "Timehop BOOM",
+        participants: "self",
+        map: true,
+        dedup: true,
+        services: "facebook,foursquare"
+      }
+    )}
+  end
+end

data/spec/integration/api_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe "Integration" do
+  context "For an existing account" do
+    let(:api) { Singly.account("TOKEN_STUB") }
+    describe "GET /profile" do
+      subject { api.profile }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profile" }
+      it { subject.options.should include(
+        method: :get,
+        params: { access_token: "TOKEN_STUB" }
+      )}
+    end
+    describe "GET /profiles" do
+      subject { api.profiles }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles" }
+      it { subject.options.should include(
+        method: :get,
+        params: { access_token: "TOKEN_STUB" }
+      )}
+    end
+    describe "GET /profiles with optional params" do
+      subject { api.profiles(data: true, verify: true) }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles" }
+      it { subject.options.should include(
+        method: :get,
+        params: {
+          access_token: "TOKEN_STUB",
+          data: true,
+          verify: true
+        }
+      )}
+    end
+    describe "GET /profiles/:service" do
+      subject { api.profiles.foursquare }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles/foursquare" }
+      it { subject.options.should include(
+        method: :get,
+        params: { access_token: "TOKEN_STUB" }
+      )}
+    end
+    describe "GET /profiles/self" do
+      subject { api.profiles.self }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles/self" }
+      it { subject.options.should include(
+        method: :get,
+        params: { access_token: "TOKEN_STUB" }
+      )}
+    end
+    describe "POST /profiles/self with data" do
+      subject { api.profiles.self(x: 1, y: {z: 3})  }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles/self" }
+      it { subject.options.should include(
+        method: :post,
+        params: { access_token: "TOKEN_STUB" },
+        body: { x: 1, y: { z: 3 } }
+      )}
+    end
+    describe "DELETE /profiles" do
+      subject { api.profiles.delete }
+      it { subject.validate.should == true }
+      it { subject.path.should == "/profiles" }
+      it { subject.options.should include(
+        method: :delete,
+        params: { access_token: "TOKEN_STUB" }
+      )}
+    end
+  end
+  context "No Account" do
+  end
+end

data/spec/singly/account_spec.rb

@@ -41,7 +41,7 @@ describe Singly::Account do
       subject { account.profiles(data: true, verify: true) }
       it { subject.class.should == Singly::Profiles }
       it { subject.validate.should be_true }
-      it { subject.query_params.should include(data: true, verify: true) }
+      it { subject.options[:params].should include(data: true, verify: true) }
     end
   end
   describe "#types" do
@@ -64,7 +64,7 @@ describe Singly::Account do
       subject { account.id("abc123", map: true) }
       it { subject.class.should == Singly::Id }
       it { subject.validate.should be_true }
-      it { subject.query_params.should include(map: true) }
+      it { subject.options[:params].should include(map: true) }
     end
   end
   describe "#delete" do
@@ -72,20 +72,20 @@ describe Singly::Account do
       subject { account.delete(:facebook) }
       it { subject.class.should == Singly::Profiles::DeleteService }
       it { subject.validate.should be_true }
-      it { subject.route_params.should include(service: "facebook") }
+      it { subject.path.should == "/profiles/facebook" }
     end
     context "where we delete a specific profile by id" do
-      subject { account.delete(:facebook, 987654321) }
+      subject { account.delete(:dropbox, 987654321) }
       it { subject.class.should == Singly::Profiles::DeleteProfile }
       it { subject.validate.should be_true }
-      it { subject.route_params.should include(service: "facebook", id: "987654321") }
+      it { subject.path.should == "/profiles/987654321@dropbox" }
     end
   end
   describe "#merge" do
     subject { account.merge("fake_source_access_token") }
     it { subject.class.should == Singly::Auth::Merge }
     it { subject.validate.should be_true }
-    it { subject.query_params.should include(
+    it { subject.options[:params].should include(
       source: "fake_source_access_token",
       dest: "fake_access_token"
     ) }
@@ -96,13 +96,13 @@ describe Singly::Account do
       subject { account.apply(:instagram, token: "tokin") }
       it { subject.class.should == Singly::Auth::Service::Oauth2Apply }
       it { subject.validate.should be_true }
-      it { subject.query_params.should include(account: "fake_account_id") }
+      it { subject.options[:params].should include(account: "fake_account_id") }
     end
     context "with an oauth1 service" do
       subject { account.apply(:flickr, token: "tokin", token_secret: "shhh_tokin") }
       it { subject.class.should == Singly::Auth::Service::Oauth1Apply }
       it { subject.validate.should be_true }
-      it { subject.query_params.should include(account: "fake_account_id") }
+      it { subject.options[:params].should include(account: "fake_account_id") }
     end
   end
 end

data/spec/singly/endpoint_spec.rb

@@ -1,99 +1,107 @@
 require 'spec_helper'
 
 describe Singly::Endpoint do
-  class DummyEndpoint
+  class DummyGetEndpoint
     include Singly::Endpoint
-    endpoint :get, "/dummy/:service/:id@:type", required: [:a, :b], optional: [:c, :d]
+    endpoint :get, "/dummy/:service/:id@:type", required: [:access_token], optional: [:field1]
+  end
+  class DummyPostEndpoint
+    include Singly::Endpoint
+    endpoint :post, "/dummy/post/:here", required: [:access_token], optional: [:field1]
   end
   context "class methods" do
-    describe ".type" do
-      subject { DummyEndpoint.type }
+    describe ".http_method" do
+      subject { DummyGetEndpoint.http_method }
       it { should == :get }
     end
     describe ".route" do
-      subject { DummyEndpoint.route }
+      subject { DummyGetEndpoint.route }
       it { should == "/dummy/:service/:id@:type" }
     end
-    describe ".required_route_params" do
-      subject { DummyEndpoint.required_route_params }
-      it { should == [:service, :id, :type] }
-    end
     describe ".required_params" do
-      subject { DummyEndpoint.required_params }
-      it { should == [:a, :b] }
+      subject { DummyGetEndpoint.required_params }
+      it { should == [:access_token] }
     end
     describe ".optional_params" do
-      subject { DummyEndpoint.optional_params }
-      it { should == [:c, :d] }
+      subject { DummyGetEndpoint.optional_params }
+      it { should == [:field1] }
     end
   end
   context "instance methods" do
     describe "#fetch" do
-      let(:endpoint) { DummyEndpoint.new(params) }
+      let(:endpoint) { DummyGetEndpoint.new(params) }
       context "with valid params" do
         subject { endpoint.fetch }
         let(:params) { {
           service: :timehop, 
           id: 123, 
           type: "just_my", 
-          a: "a", 
-          b: "b", 
-          c: "c"
+          access_token: "at", 
+          field1: "a field"
+        } }
+        let(:result) { double(:json) }
+        before { Singly::Http.should_receive(:fetch).with("/dummy/timehop/123@just_my", {
+          method: :get, 
+          params: {access_token: "at", field1: "a field"},
+          timeout: 2
+        }).and_return(result) }
+        it { should == result }
+      end
+      context "with post endpoint" do
+        let(:endpoint) { DummyPostEndpoint.new(params) }
+        subject { endpoint.fetch(timeout: 3 ) }
+        let(:params) { {
+          here: "ya_go",
+          access_token: "at",
+          extra: "field"
         } }
         let(:result) { double(:json) }
-        before { Singly::Http.should_receive(:fetch).with(:get, "/dummy/timehop/123@just_my", {a: "a", b: "b", c: "c"}).and_return(result) }
+        before { Singly::Http.should_receive(:fetch).with("/dummy/post/ya_go", {
+          :method=>:post,
+          :timeout=>3,
+          :params=>{:access_token=>"at"},
+          :body=>{:extra=>"field"}
+        }).and_return(result) }
         it { should == result }
       end
       context "with missing required params" do
         let(:params) { {
           service: :timehop, 
           id: 123, 
-          type: "just_my", 
-          b: "b", 
-          c: "c"
+          type: "just_my"
         } }
-        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has query params :a???") }
+        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has required params :access_token???") }
       end
       context "with missing route params" do
         let(:params) { {
           service: :timehop, 
-          a: "a",
-          b: "b"
+          access_token: "at",
+          id: "123"
         } }
-        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has route params :id, :type???") }
+        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has all route params: /dummy/timehop/123@:type???") }
       end
     end
     describe "#url" do
-      let(:endpoint) { DummyEndpoint.new(params) }
+      let(:endpoint) { DummyPostEndpoint.new(params) }
       context "with valid params" do
         subject { endpoint.url }
         let(:params) { {
-          service: :timehop, 
-          id: 123, 
-          type: "just_my", 
-          a: "a", 
-          b: :b, 
-          c: "c"
+          here: "ya_go",
+          access_token: "at"
         } }
-        it { should == "https://api.singly.com/v0/dummy/timehop/123@just_my?a=a&b=b&c=c" }
+        it { should == "https://api.singly.com/v0/dummy/post/ya_go?access_token=at" }
       end
-      context "with missing required params" do
+      context "with missing route params" do
         let(:params) { {
-          service: :timehop, 
-          id: 123, 
-          type: "just_my", 
-          b: "b", 
-          c: "c"
+          access_token: "at"
         } }
-        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has query params :a???") }
+        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has all route params: /dummy/post/:here???") }
       end
-      context "with missing route params" do
+      context "with missing required params" do
         let(:params) { {
-          service: :timehop, 
-          a: "a",
-          b: "b"
+          here: "ya_go"
         } }
-        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has route params :id, :type???") }
+        it { expect{endpoint.fetch}.to raise_error(Singly::Error, "y u no has required params :access_token???") }
       end
     end
   end