google-api 0.0.1.alpha → 0.0.1.beta

data/spec/fixtures/drive_error.json

@@ -0,0 +1,13 @@
+{
+ "error": {
+  "errors": [
+   {
+    "domain": "global",
+    "reason": "notFound",
+    "message": "File not found: asdfasdf"
+   }
+  ],
+  "code": 404,
+  "message": "File not found: asdfasdf"
+ }
+}

data/spec/fixtures/drive_files.json

@@ -0,0 +1,51 @@
+{
+ "kind": "drive#fileList",
+ "etag": "\"j-adummyetag/pIy649ByRBzgnLlQWUq3mFq4jbc\"",
+ "selfLink": "https://www.googleapis.com/drive/v2/files",
+ "items": [
+  {
+   "kind": "drive#file",
+   "id": "adummyidnumber",
+   "etag": "\"j-adummyetag/MTM0NjIwMjM0MzYzOQ\"",
+   "selfLink": "https://www.googleapis.com/drive/v2/files/adummyidnumber",
+   "alternateLink": "https://docs.google.com/a/bryant.edu/folder/d/adummyidnumber/edit",
+   "title": "Test Folder",
+   "mimeType": "application/vnd.google-apps.folder",
+   "labels": {
+    "starred": false,
+    "hidden": false,
+    "trashed": false,
+    "restricted": false,
+    "viewed": true
+   },
+   "createdDate": "2012-08-29T01:05:43.651Z",
+   "modifiedDate": "2012-08-29T01:05:43.639Z",
+   "modifiedByMeDate": "2012-08-29T01:05:43.639Z",
+   "lastViewedByMeDate": "2012-08-29T01:05:43.639Z",
+   "parents": [
+    {
+     "kind": "drive#parentReference",
+     "id": "adummyparentidnumber",
+     "selfLink": "https://www.googleapis.com/drive/v2/files/adummyidnumber/parents/adummyparentidnumber",
+     "parentLink": "https://www.googleapis.com/drive/v2/files/adummyparentidnumber",
+     "isRoot": true
+    }
+   ],
+   "userPermission": {
+    "kind": "drive#permission",
+    "etag": "\"j-adummyetag/JxXBnYVV_rnFy38Ll-sTHyzNvF8\"",
+    "id": "me",
+    "selfLink": "https://www.googleapis.com/drive/v2/files/adummyidnumber/permissions/me",
+    "role": "owner",
+    "type": "user"
+   },
+   "quotaBytesUsed": "0",
+   "ownerNames": [
+    "Alexander Robbin"
+   ],
+   "lastModifyingUserName": "Alexander Robbin",
+   "editable": true,
+   "writersCanShare": true
+  }
+ ]
+}

data/spec/fixtures/refresh_access_token.json

@@ -0,0 +1,5 @@
+{
+  "access_token": "reallysecureaccesstoken",
+  "token_type": "Bearer",
+  "expires_in": 3600
+}

data/spec/google-api/api_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+shared_context "api call" do
+
+  let(:map) { fixture(:discovery_rest_drive)['resources']['files']['methods'] }
+  let(:api) { GoogleAPI::API.new(client.access_token, :drive, map) }
+  let(:stubbed_response) { OAuth2Response.new }
+  before(:each) do
+    GoogleAPI.discovered_apis[:drive] = fixture(:discovery_rest_drive)
+    client.client.connection = TEST_CONNECTION
+  end
+
+end
+
+describe GoogleAPI::API do
+
+  let(:object) { User.new }
+  let(:client) { GoogleAPI::Client.new(object) }
+  before(:each) do
+    GoogleAPI.configure do |config|
+      config.client_id = 'test id'
+      config.client_secret = 'test secret'
+    end
+    object.authenticated = true
+  end
+
+  describe "#initialize" do
+
+    let(:api) { GoogleAPI::API.new(client.access_token, :drive, fixture(:discovery_rest_drive)['resources']) }
+
+    it "should set the access_token attribute" do
+      api.access_token.token.should == client.access_token.token
+    end
+
+    it "should set the api attribute" do
+      api.api.should == :drive
+    end
+
+    it "should set the map attribute" do
+      api.map.should == fixture(:discovery_rest_drive)['resources']
+    end
+
+  end
+
+  describe "API method generation" do
+
+    context "when there are methods lower in the tree" do
+
+      it "should build another GoogleAPI::API class with the correct map" do
+        api = GoogleAPI::API.new(client.access_token, :drive, fixture(:discovery_rest_drive)['resources'])
+        api.files.should be_an_instance_of(GoogleAPI::API)
+      end
+
+    end
+
+    context "when the method tree is the lowest it can be" do
+
+      include_context "api call"
+
+      it "should call the #build_url method" do
+        api.should_receive(:build_url).with(map['list'], {}).and_return(['https://www.googleapis.com/drive/v2/files', {}])
+        api.list
+      end
+
+      %w(POST PUT PATCH).each do |http_method|
+        context "when the method's HTTP method is #{http_method}" do
+
+          it "should raise ArgumentError if no body was passed" do
+            expect {
+              api.insert(media: '/Test/File/Path.txt')
+            }.to raise_error(ArgumentError)
+          end
+
+        end
+      end
+
+      context "when the mediaUpload key is present" do
+
+        it "should call the #upload method" do
+          api.should_receive(:upload).with('post', 'https://www.googleapis.com/resumable/upload/drive/v2/files', body: {title: 'Test File.txt'}, media: '/Test/File/Path.txt')
+          api.insert(body: {title: 'Test File.txt'}, media: '/Test/File/Path.txt')
+        end
+
+      end
+
+      context "when it is a normal API method request" do
+
+        it "should delegate to the #request method" do
+          api.should_receive(:request).with('get', 'https://www.googleapis.com/drive/v2/files', {})
+          api.list
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#request" do
+
+    include_context "api call"
+
+    it "should build the correct headers hash" do
+      ::OAuth2::AccessToken.any_instance.should_receive(:get).with('https://www.googleapis.com/drive/v2/files', headers: {'Content-Type' => 'application/json'}).and_return(stubbed_response)
+      api.list
+    end
+
+    it "should convert the body to JSON" do
+      ::OAuth2::AccessToken.any_instance.should_receive(:post).with('https://www.googleapis.com/drive/v2/files', body: '{"title":"Test Folder"}', headers: {'Content-Type' => 'application/json'}).and_return(stubbed_response)
+      api.insert(body: {title: 'Test Folder'})
+    end
+
+    context "when a request is successful" do
+
+      it "should only make the request attempt once" do
+        ::OAuth2::AccessToken.any_instance.should_receive(:get).once.and_return(stubbed_response)
+        api.list
+      end
+
+      it "should return a parsed response if body is present" do
+        api.list.should == fixture(:drive_files)
+      end
+
+      it "should return the full Response object if body is blank" do
+        api.delete(fileId: 'adummyfileidnumber').should be_an_instance_of(::OAuth2::Response)
+      end
+
+    end
+
+    context "when a request fails and development mode is turned off" do
+
+      it "should attempt the request 5 times" do
+        ::OAuth2::AccessToken.any_instance.should_receive(:put).exactly(5).times.and_return(OAuth2Response.new(404))
+        api.update(fileId: 'adummyfileidnumber', body: {bad: 'attribute'})
+      end
+
+      it "should break out of the attempt loop if the request succeeds" do
+        ::OAuth2::AccessToken.any_instance.should_receive(:put).exactly(2).times.and_return(OAuth2Response.new(404))
+        ::OAuth2::AccessToken.any_instance.should_receive(:put).once.and_return(stubbed_response)
+        api.update(fileId: 'adummyfileidnumber', body: {bad: 'attribute'})
+      end
+
+    end
+
+  end
+
+  describe "#upload" do
+
+    include_context "api call"
+
+    before(:each) { api.stub(:request).and_return(stubbed_response) }
+
+    it "should build the correct options hash that is passed to the first request" do
+      api.should_receive(:request).with('post', 'https://www.googleapis.com/resumable/upload/drive/v2/files', body: {title: 'Test File.txt', mimeType: 'application/x-ruby'}, headers: {'X-Upload-Content-Type' => 'application/x-ruby'})
+      api.send(:upload, 'post', 'https://www.googleapis.com/resumable/upload/drive/v2/files', body: {title: 'Test File.txt'}, media: File.expand_path('spec/spec_helper.rb'))
+    end
+
+    it "should change the original headers for the actual file upload" do
+      api.should_receive(:request)
+      api.should_receive(:request).with(:put, nil, body: File.read(File.expand_path('spec/spec_helper.rb')), headers: {'Content-Type' => 'application/x-ruby', 'Content-Length' => '399'})
+      api.send(:upload, 'post', 'https://www.googleapis.com/resumable/upload/drive/v2/files', body: {title: 'Test File.txt'}, media: File.expand_path('spec/spec_helper.rb'))
+    end
+
+  end
+
+  describe "#build_url" do
+
+    include_context "api call"
+
+    context "when the mediaUpload key is present" do
+
+      it "should use the rootUrl of the discovered API" do
+        url, options = api.send(:build_url, map['insert'], media: File.expand_path('spec/spec_helper.rb'))
+        url.should == 'https://www.googleapis.com/resumable/upload/drive/v2/files'
+      end
+
+    end
+
+    context "when it is a normal API method request" do
+
+      it "should build the final URL" do
+        url, options = api.send(:build_url, map['get'], fileId: 'adummyfileidnumber', updateViewedDate: true)
+        url.should == 'https://www.googleapis.com/drive/v2/files/adummyfileidnumber?updateViewedDate=true'
+      end
+
+      it "should delete query/path parameters from the options Hash" do
+        url, options = api.send(:build_url, map['get'], fileId: 'adummyfileidnumber', updateViewedDate: true)
+        options.should == {}
+      end
+
+      it "should raise ArgumentError if the parameter is required and the matching option isn't passed" do
+        expect {
+          api.send(:build_url, map['get'], updateViewedDate: true)
+        }.to raise_error(ArgumentError)
+      end
+
+    end
+
+  end
+
+end

data/spec/google-api/client_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe GoogleAPI::Client do
+
+  let(:object) { User.new }
+  let(:client) { GoogleAPI::Client.new(object) }
+  before(:each) do
+    GoogleAPI.configure do |config|
+      config.client_id = 'test id'
+      config.client_secret = 'test secret'
+    end
+    object.authenticated = true
+    client.client.connection = TEST_CONNECTION
+  end
+
+  describe "#initialize" do
+
+    it "should set the object attribute" do
+      client = GoogleAPI::Client.new(object)
+      client.object.should == object
+    end
+
+    it "should raise NoMethodError if the object isn't oauthable" do
+      expect {
+        GoogleAPI::Client.new(Class.new)
+      }.to raise_error(NoMethodError)
+    end
+
+    it "should raise ArgumentError if the object isn't OAuth2 authenticated" do
+      object.authenticated = false
+      expect {
+        GoogleAPI::Client.new(object)
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "#access_token" do
+
+    it "should call to the OAuth2 Access Token class" do
+      client.access_token.token.should == object.oauth_hash[:access_token]
+    end
+
+    context "when the access token is expired" do
+
+      before(:each) { object.expires_at = Time.now - 86400 }
+
+      it "should call refresh on the OAuth2 Access Token" do
+        stubbed_access_token = Class.new
+        stubbed_access_token.stub(:token).and_return('test token')
+        ::OAuth2::AccessToken.any_instance.should_receive(:refresh!).and_return(stubbed_access_token)
+        client.access_token
+      end
+
+      it "should update the object's stored OAuth information" do
+        object.should_receive(:update_access_token!)
+        client.access_token
+      end
+
+    end
+
+    context "when the access token is fresh" do
+
+      it "should not try and refresh the token again" do
+        ::OAuth2::AccessToken.any_instance.should_not_receive(:refresh!)
+        client.access_token
+      end
+
+    end
+
+  end
+
+  describe "#client" do
+
+    it "should create the OAuth2 Client instance" do
+      client.client.should be_an_instance_of(::OAuth2::Client)
+    end
+
+  end
+
+  describe "API method generation" do
+
+    context "when the API hasn't been discovered" do
+
+      it "should call out to the Discovery API" do
+        GoogleAPI.discovered_apis[:drive].should be_nil
+        client.drive
+        GoogleAPI.discovered_apis[:drive].should == fixture(:discovery_rest_drive)
+      end
+
+      it "should save the Discovery API map to the cache" do
+        client.drive
+        GoogleAPI.discovered_apis[:drive].should == fixture(:discovery_rest_drive)
+      end
+
+    end
+
+    context "when the API has already been discovered" do
+
+      it "should not fetch the Discovery API map" do
+        GoogleAPI.discovered_apis[:drive] = fixture(:discovery_drive)
+        ::OAuth2::AccessToken.any_instance.should_not_receive(:get)
+        client.drive
+      end
+
+    end
+
+    it "should build the GoogleAPI::API class" do
+      GoogleAPI::API.should_receive(:new).with(an_instance_of(::OAuth2::AccessToken), :drive, fixture(:discovery_rest_drive)['resources'])
+      client.drive
+    end
+
+  end
+
+end

data/spec/google-api_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe GoogleAPI do
+
+  describe "#configure" do
+
+    it "should raise an error when the CLIENT ID is blank" do
+      expect {
+        GoogleAPI.configure do |config|
+          config.client_id = nil
+          config.client_secret = 'test secret'
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an error when the CLIENT SECRET is blank" do
+      expect {
+        GoogleAPI.configure do |config|
+          config.client_id = 'test id'
+          config.client_secret = nil
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an error when both the CLIENT ID and SECRET are blank" do
+      expect {
+        GoogleAPI.configure do |config|
+          config.client_id = nil
+          config.client_secret = nil
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should set development mode to false when not passed" do
+      GoogleAPI.configure do |config|
+        config.client_id = 'test id'
+        config.client_secret = 'test secret'
+      end
+
+      GoogleAPI.development_mode.should be_false
+    end
+
+    it "should set development mode when passed" do
+      GoogleAPI.configure do |config|
+        config.client_id = 'test id'
+        config.client_secret = 'test secret'
+        config.development_mode = true
+      end
+
+      GoogleAPI.development_mode.should be_true
+    end
+
+    it "should use Rails' logger when Rails is defined" do
+      stub_const("Rails", Class.new)
+      Rails.stub(:logger).and_return(Logger.new(STDOUT))
+
+      Rails.should_receive(:logger)
+
+      GoogleAPI.configure do |config|
+        config.client_id = 'test id'
+        config.client_secret = 'test secret'
+      end
+
+    end
+
+    it "should use a STDOUT when Rails is not defined" do
+      GoogleAPI.should_receive(:stdout_logger)
+
+      GoogleAPI.configure do |config|
+        config.client_id = 'test id'
+        config.client_secret = 'test secret'
+      end
+    end
+
+  end
+
+  describe "#discovered_apis" do
+
+    it "should start as an empty hash" do
+      GoogleAPI.discovered_apis.should == {}
+    end
+
+    it "should keep a cache of discovered APIs" do
+      GoogleAPI.discovered_apis[:test_api1] = {a: 1, b: 2, c: 3}
+
+      GoogleAPI.discovered_apis[:test_api1].should == {a: 1, b: 2, c: 3}
+    end
+
+  end
+
+  describe "#stdout_logger" do
+
+    let(:logger) { GoogleAPI.stdout_logger }
+
+    it "should create a new Logger object" do
+      logger = GoogleAPI.stdout_logger
+      logger.should be_an_instance_of(Logger)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+require 'rspec'
+require 'google-api'
+
+Faraday.default_adapter = :test
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.after(:each) { GoogleAPI.reset_environment! }
+end

data/spec/support/faraday_stubs.rb

@@ -0,0 +1,17 @@
+stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+  stub.post('/o/oauth2/token') { faraday_response(:refresh_access_token) }
+  stub.get('/discovery/v1/apis?name=drive&preferred=true') { faraday_response(:discovery_drive) }
+  stub.get('/discovery/v1/apis/drive/v2/rest') { faraday_response(:discovery_rest_drive) }
+  stub.post('/resumable/upload/drive/v2/files') { [200] }
+  stub.get('/drive/v2/files') { faraday_response(:drive_files) }
+  stub.delete('/drive/v2/files/adummyfileidnumber') { [204] }
+  stub.put('/drive/v2/files/adummyfileidnumber') { faraday_response(:drive_error, 404) }
+end
+
+TEST_CONNECTION = Faraday.new do |builder|
+  builder.adapter :test, stubs
+end
+
+def faraday_response(fixture, code = 200)
+  [code, {'Content-Type' => 'application/json'}, fixture(fixture, false)]
+end

data/spec/support/fixture.rb

@@ -0,0 +1,9 @@
+require 'multi_json'
+
+def fixture(name, jsonify = true)
+  path = File.expand_path '../../fixtures', __FILE__
+
+  file = File.read("#{path}/#{name}.json")
+
+  jsonify ? MultiJson.load(file) : file
+end

data/spec/support/oauth2_response.rb

@@ -0,0 +1,17 @@
+class OAuth2Response
+
+  attr_accessor :status
+
+  def initialize(status_code = 200)
+    @status = status_code
+  end
+
+  def headers
+    {}
+  end
+
+  def parsed
+    fixture(:drive_files)
+  end
+
+end

data/spec/support/oauthable_object.rb

@@ -0,0 +1,27 @@
+class User
+
+  attr_accessor :authenticated, :expires_at
+
+  def self.oauthable
+    true
+  end
+
+  def id
+    1
+  end
+
+  def oauth_hash
+    {
+      access_token: authenticated ? 'test access token' : nil,
+      refresh_token: authenticated ? 'test refresh token' : nil,
+      expires_at: expires_at || (authenticated ? Time.now + 3600 : nil)
+    }
+  end
+
+  def update_access_token!(access_token)
+  end
+
+  def google
+  end
+
+end