live_paper 0.0.16 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08f7b71dda58a9c4818afd3d35ce049498826b34
-  data.tar.gz: 0c84394e22237d9f7a6133ae0c9aa2b8ae808038
+  metadata.gz: 9b78bada6a9a8ab8ff6c8cb229635947544c4e7f
+  data.tar.gz: b350744d43232723db63f9770f449a3c4104aede
 SHA512:
-  metadata.gz: d7b7cedb9406f264f7cb4166e121ec0c921c0a6efe45ef519dab0ee22158daa2a8925773485462650a71aba61c72417dc00cb472d232e9280ede847afb5ed78c
-  data.tar.gz: 0755f093df5f9cbbeff91ca58a285edb4099c25b0d8f10fc912ff629bab5aff3b06a2fc73aae1e039592ad606d96107fc4699f2e3b5126acbc86a2c3cd768223
+  metadata.gz: 7fa9418f1a5ecc2d26c6473fac545f0fc792aab1d95bb737fc4299b2c3bd2873d6ba6278203e574fc25474a3f971e03dd1423cfabdaca5989ed0d81306c3f7a0
+  data.tar.gz: 63b41015e36b75060691730b83596848f3adf6b83d333dc523cae7a064624ec6de02a3270923a4c2829f0b431289bb9af969af3c13f5f0fe519b0c7683ee0418

data/README.md

@@ -145,7 +145,7 @@ You can list existing resources with the list operation.
 
 ## Contributing
 
-1. Fork it ( https://github.com/IPGPTP/live_paper/fork )
+1. Fork it ( https://github.com/IPGPTP/live_paper_rubygem/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/live_paper/base_object.rb

@@ -1,9 +1,14 @@
-require_relative 'http_client'
 require 'json'
 
+class NotAuthenticatedError < Exception
+end
+
 module LivePaper
   class BaseObject
-    extend HttpClient
+
+    LP_API_HOST="https://www.livepaperapi.com"
+    AUTH_URL = "#{LP_API_HOST}/auth/token"
+
     attr_accessor :id, :name, :date_created, :date_modified, :link
 
     def assign_attributes(data)
@@ -23,71 +28,66 @@ module LivePaper
 
     def save
       validate_attributes!
-      BaseObject.request_handling_auth(self.class.api_url, 'POST') do |request|
-        response = BaseObject.send_request(request, content_type: 'application/json', body: create_body.to_json)
+      unless present? @id
+        response = BaseObject.rest_request( self.class.api_url, :post, body: create_body.to_json )
         parse(response.body)
-      end unless present? @id
+      end
       self
     end
 
     def self.get(id)
-      request_handling_auth("#{api_url}/#{id}", 'GET') do |request|
-        response = send_request(request, content_type: 'application/json')
-        parse response.body
-      end rescue nil
+      response = rest_request( "#{api_url}/#{id}", :get )
+      case response.code
+        when 200
+          parse response.body
+        else #when 404
+          nil
+      end
     end
 
     def self.list
       objects=[]
-      request_handling_auth("#{api_url}", 'GET') do |request|
-        response = send_request(request, content_type: 'application/json')
-        JSON.parse(response.body, symbolize_names: true)[list_key].each do |linkdata|
-          objects << self.parse({item_key => linkdata}.to_json)
-        end
-      end #rescue nil
+      # $lpp_access_token = 'force retry'
+
+      response = rest_request( api_url, :get )
+      JSON.parse(response.body, symbolize_names: true)[list_key].each do |linkdata|
+        objects << self.parse({item_key => linkdata}.to_json)
+      end
       objects
     end
 
     def update
       response_code = 'Object Invalid'
       if self.id
-        BaseObject.request_handling_auth("#{self.class.api_url}/#{id}", 'PUT') do |request|
-          response = BaseObject.send_request(request,
-                                             content_type: 'application/json',
-                                             body: update_body.to_json,
-                                             allow_codes: [200, 400, 404, 409])
-          response_code = case response.code.to_i
-            when 200
-              parse(response.body)
-              'OK'
-            when 400
-              @errors=response.body
-              'Bad Request'
-            when 409
-              @errors=response.body
-              'Conflict'
-            else
-              'Object Invalid'
-          end
+        response = BaseObject.rest_request( "#{self.class.api_url}/#{id}", :put, body: update_body.to_json )
+        response_code = case response.code
+          when 200
+            parse(response.body)
+            '200 OK'
+          when 400
+            @errors=response.body
+            'Bad Request'
+          when 409
+            @errors=response.body
+            'Conflict'
+          else
+            'Object Invalid'
         end
       end
       response_code
     end
 
     def delete
-      response_code = nil
       if self.id
-        BaseObject.request_handling_auth("#{self.class.api_url}/#{id}", 'DELETE') do |request|
-          response = BaseObject.send_request(request, content_type: 'application/json', allow_codes: [200, 204, 409])
-          response_code = case response.code.to_i
-            when 200
-              'OK'
-            when 204
-              'OK'
-            when 409
-              @errors=response.body
-              'Conflict'
-          end
+        response = BaseObject.rest_request( "#{self.class.api_url}/#{id}", :delete )
+        response_code = case response.code
+          when 200
+            '200 OK'
+          when 409
+            @errors=response.body
+            'Conflict'
+          else
+            'unknown'
         end
       else
         response_code = "Object Invalid"
@@ -95,6 +95,54 @@ module LivePaper
       response_code
     end
 
+    def self.rest_request(url, method, options={})
+      tries = 0
+      verb = (method||"get").downcase.to_sym
+      raise "Method '#{verb}' not supported." unless [:get, :post, :put, :delete].include?(verb)
+
+      request_access_token unless $lpp_access_token
+      headers = {}
+      headers[:authorization] = "Bearer #{$lpp_access_token}"
+      headers[:accept] = options[:accept] || "application/json"
+      headers[:x_user_info] = 'app=rubygem' unless options[:skip] == :user_info  #watermark download fails if set
+      headers[:content_type] = 'application/json' unless options[:body].nil?
+
+      h = {:method => verb, :url => url.to_s, :headers => headers}
+      h.merge!({:payload => options[:body]}) unless options[:body].nil?
+
+      begin
+        response = RestClient::Request.execute(h) { |response, request, result| response }
+        raise NotAuthenticatedError if response.code == 401
+      rescue NotAuthenticatedError => e
+        tries += 1
+        if tries < 3
+          request_access_token
+          headers[:authorization] = "Bearer #{$lpp_access_token}"
+          retry
+        else
+          raise e
+        end
+      end
+      response
+    end
+
+    def self.request_access_token
+      h = { method: :post,
+            url: AUTH_URL,
+            headers: { authorization: "Basic #{$lpp_basic_auth}",
+                       content_type: 'application/x-www-form-urlencoded',
+                       accept: 'application/json' },
+            payload: 'grant_type=client_credentials&scope=all'
+          }
+
+      response = RestClient::Request.execute(h) { |response, request, result| response }
+
+      parsed = JSON.parse(response.body)
+      @access_token = parsed['accessToken']
+      $lpp_access_token = @access_token
+    end
+
+
     def errors
       begin
         JSON.parse(@errors)

data/lib/live_paper/image.rb

@@ -3,7 +3,6 @@ require 'rest-client'
 
 module LivePaper
   class Image
-    extend HttpClient
 
     attr_accessor :url
 
@@ -16,14 +15,15 @@ module LivePaper
       end
       begin
         src_image = RestClient.get(img, Accept: 'image/jpg')
-        request_access_token unless @access_token
+        BaseObject.request_access_token unless $lpp_access_token
         response = RestClient.post API_URL,
                                    src_image.body,
-                                   Authorization: "Bearer #{@access_token}",
+                                   authorization: "Bearer #{$lpp_access_token}",
                                    content_type: 'image/jpg'
         response.headers[:location]
       rescue Exception => e
         puts "Exception! ******\n#{e}"
+        puts e.response
         img
       end
     end

data/lib/live_paper/link.rb

@@ -5,7 +5,6 @@ module LivePaper
     attr_accessor :payoff_id, :trigger_id
 
     def parse(jsondata)
-      puts "parsing data and it is #{jsondata}"
       data = JSON.parse(jsondata, symbolize_names: true)[self.class.item_key]
       assign_attributes data
       self

data/lib/live_paper/qr_trigger.rb

@@ -14,11 +14,8 @@ module LivePaper
     end
 
     def download_qrcode
-      QrTrigger.request_handling_auth(self.qrcode_url, 'GET') do |request|
-        request['Accept'] = "image/jpg"
-        response = QrTrigger.send_request(request)
-        response.body.empty? ? nil : response.body
-      end
+      response = QrTrigger.rest_request( self.qrcode_url, :get, accept: "image/jpg" )
+      response.body.empty? ? nil : response.body
     end
 
     private

data/lib/live_paper/version.rb

@@ -1,3 +1,3 @@
 module LivePaper
-  VERSION = "0.0.16"
+  VERSION = "0.0.20"
 end

data/lib/live_paper/wm_trigger.rb

@@ -15,11 +15,11 @@ module LivePaper
     end
 
     def download_watermark
-      WmTrigger.request_handling_auth(self.wm_url, 'GET') do |request|
-        request['Accept'] = "image/jpg"
-        response = WmTrigger.send_request(request)
-        response.body.empty? ? nil : response.body
-      end
+      response = WmTrigger.rest_request( self.wm_url, :get, accept: "image/jpg", skip: :x_user_info )
+      response.body.empty? ? nil : response.body
+    rescue Exception => e
+      puts 'Exception!\n'
+      puts e.response
     end
 
     private

data/lib/live_paper.rb

@@ -1,5 +1,4 @@
 require "live_paper/base_object"
-require "live_paper/http_client"
 require "live_paper/image"
 require "live_paper/link"
 require "live_paper/payoff"

data/spec/live_paper/base_object_spec.rb

@@ -159,7 +159,7 @@ describe LivePaper::BaseObject do
                     id: obj_id,
                     date_created: 'date_created',
                     date_modified: 'date_modified'} }
-    let(:resp_body) { }
+    let(:resp_body) {}
 
     before do
       stub_unimplemented_methods
@@ -167,21 +167,21 @@ describe LivePaper::BaseObject do
     end
 
     context 'with valid data' do
-      let(:resp_body) { { object: {name: new_name,
-                          id: obj_id,
-                          date_created: 'date_created',
-                          date_modified: 'new_date_modified'}} }
+      let(:resp_body) { {object: {name: new_name,
+                                  id: obj_id,
+                                  date_created: 'date_created',
+                                  date_modified: 'new_date_modified'}} }
       let(:new_name) { 'my_valid_name_change' }
-     before do
-       @response = resp_body
-        stub_request(:put, "#{@api_url}/#{obj_id}").to_return(:body => @response, :status => 200)
+      before do
+        @response = resp_body
+        stub_request(:put, "#{@api_url}/#{obj_id}").to_return(:body => resp_body.to_json, :status => 200)
         @obj=LivePaper::BaseObject.new data1
         @obj.name = new_name
       end
       it 'should return success' do
         ret_val = @obj.update
         assert_requested :put, "#{@api_url}/#{obj_id}"
-        expect(ret_val).to eq 'OK'
+        expect(ret_val).to eq '200 OK'
       end
       xit 'should reflect the updated object' do
         allow(@response).to receive(:body).and_return(@response[:object])
@@ -266,7 +266,7 @@ describe LivePaper::BaseObject do
       it 'should DELETE when there is an ID' do
         result=@obj.delete
         assert_requested :delete, "#{@api_url}/#{@obj.id}"
-        expect(result).to eq 'OK'
+        expect(result).to eq '200 OK'
       end
     end
 
@@ -383,4 +383,57 @@ describe LivePaper::BaseObject do
       expect { LivePaper::BaseObject.new.send :create_body }.to raise_error
     end
   end
+
+  describe '.request_access_token' do
+    it 'should corerectly get the token' do
+      $lpp_access_token = nil
+      LivePaper::BaseObject.request_access_token
+      expect($lpp_access_token).to eq 'SECRETTOKEN'
+    end
+  end
+
+  describe 'rest_request' do
+    before do
+
+    end
+
+    context 'when there is no access token' do
+      before do
+        $lpp_access_token = nil
+      end
+      it 'should request the access token' do
+        expect(LivePaper::BaseObject).to receive(:request_access_token)
+        LivePaper::BaseObject.rest_request(@api_url, :post)
+      end
+    end
+
+    context 'when there is an access token' do
+      before do
+        $lpp_access_token = 'TOPSECRET'
+      end
+
+      it 'should NOT call request_access_token' do
+        expect(LivePaper::BaseObject).to receive(:request_access_token).exactly(0).times
+        LivePaper::BaseObject.rest_request(@api_url, :post)
+      end
+
+      context 'when the access token is invalid' do
+        before do
+          $lpp_access_token = 'invalid'
+
+          @response = double('A mock for a response')
+          allow(@response).to receive(:body)
+          @response.stub(:code).and_return(401, 401, 200) #fail first two calls
+          RestClient::Request.stub(:execute).and_return(@response)
+        end
+
+        it 'should request access an token' do
+          expect(LivePaper::BaseObject).to receive(:request_access_token).exactly(2).times
+          LivePaper::BaseObject.rest_request(@api_url, :put, body: @data.to_json)
+        end
+
+      end
+    end
+
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: live_paper
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.20
 platform: ruby
 authors:
 - Mike Whitmarsh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2014-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -95,7 +95,6 @@ files:
 - Rakefile
 - lib/live_paper.rb
 - lib/live_paper/base_object.rb
-- lib/live_paper/http_client.rb
 - lib/live_paper/image.rb
 - lib/live_paper/link.rb
 - lib/live_paper/payoff.rb
@@ -106,7 +105,6 @@ files:
 - lib/live_paper/wm_trigger.rb
 - live_paper.gemspec
 - spec/live_paper/base_object_spec.rb
-- spec/live_paper/http_client_spec.rb
 - spec/live_paper/link_spec.rb
 - spec/live_paper/payoff_spec.rb
 - spec/live_paper/trigger_spec.rb
@@ -139,7 +137,6 @@ specification_version: 4
 summary: Ruby interface to the Live Paper service by HP.
 test_files:
 - spec/live_paper/base_object_spec.rb
-- spec/live_paper/http_client_spec.rb
 - spec/live_paper/link_spec.rb
 - spec/live_paper/payoff_spec.rb
 - spec/live_paper/trigger_spec.rb

data/lib/live_paper/http_client.rb

@@ -1,87 +0,0 @@
-require 'open-uri'
-require 'net/https'
-
-class NotAuthenticatedError < Exception
-end
-
-module LivePaper
-  module HttpClient
-    LP_API_HOST="https://www.livepaperapi.com"
-    AUTH_URL = "#{LP_API_HOST}/auth/token"
-
-    def send_request(request, options={})
-      request['Content-type'] = options[:content_type] if options[:content_type]
-      request.body = options[:body] if options[:body]
-      options[:allow_codes] ||= [200,201]
-      response = @http.request(request)
-      check_response(response, options[:allow_codes])
-      response
-    end
-
-    def check_response(response, allow_codes)
-      status = response.code.to_i
-      raise NotAuthenticatedError.new("Unauthorized") if status == 401
-      unless allow_codes.include?(status)
-        raise "Request failed with code #{status}"
-      end
-    end
-
-    def request_handling_auth(url, method)
-      tries = 0
-      begin
-        request_access_token unless @access_token
-        request = http_request(url, method)
-        request['Authorization'] = "Bearer #{@access_token}"
-        request['X-user-info'] = 'app=rubygem'
-        request['Accept'] = "application/json"
-        yield request
-      rescue NotAuthenticatedError => e
-        tries += 1
-        if tries < 3
-          @access_token = nil
-          retry
-        else
-          raise e
-        end
-      end
-    end
-
-    def request_access_token
-      request = http_request(AUTH_URL, 'POST')
-      request['Authorization'] = "Basic #{$lpp_basic_auth}"
-      request['Content-Type'] = 'application/x-www-form-urlencoded'
-      request.body = 'grant_type=client_credentials&scope=all'
-      response = @http.request(request)
-      parsed = JSON.parse(response.body)
-      @access_token = parsed['accessToken']
-    end
-
-    def http_request(url, method)
-      uri = URI.parse(url)
-      set_http uri
-
-      case method.to_s.upcase
-        when 'POST'
-          Net::HTTP::Post.new(uri.request_uri)
-        when 'GET'
-          Net::HTTP::Get.new(uri.request_uri)
-        when 'PUT'
-          Net::HTTP::Put.new(uri.request_uri)
-        when 'DELETE'
-          Net::HTTP::Delete.new(uri.request_uri)
-        else
-          raise "Method '#{method}' not supported."
-      end
-    end
-
-    private
-    def set_http(uri)
-      http_params = [uri.host, uri.port]
-      http_params.concat ENV['HTTP_PROXY'].gsub('http://', '').split(':') unless ENV['HTTP_PROXY'].to_s.empty?
-
-      @http = Net::HTTP.new(*http_params)
-      @http.use_ssl = true
-      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-  end
-end

data/spec/live_paper/http_client_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-
-module LivePaper
-  class DummyHTTP
-    include HttpClient
-  end
-end
-
-describe LivePaper::HttpClient do
-  before do
-    $lpp_basic_auth=Base64.strict_encode64("auth:pass")
-    @http_client = LivePaper::DummyHTTP.new
-    stub_request(:post, 'https://auth:pass@www.livepaperapi.com/auth/token').to_return(:body => lpp_auth_response_json, :status => 200)
-  end
-
-  describe '#send_request' do
-
-    before(:each) do
-      @http = double('Http mock')
-      allow(@http).to receive(:request)
-      @http_client.instance_variable_set(:@http, @http)
-      @request = double('Request mock')
-      allow(@http_client).to receive(:check_response)
-    end
-
-    it 'should add the content type to the request' do
-      expect(@request).to receive(:[]=).with('Content-type', 'image/jpg')
-      allow(@request).to receive(:body=)
-      @http_client.send_request @request, content_type: 'image/jpg', body: 'body'
-    end
-
-    it 'should add the body to the request' do
-      expect(@request).to receive(:body=).with('body')
-      allow(@request).to receive(:[]=)
-      @http_client.send(:send_request, @request, content_type: 'image/jpg', body: 'body')
-    end
-
-    it 'should call the request method from the http instance' do
-      allow(@request).to receive(:body=)
-      allow(@request).to receive(:[]=)
-      expect(@http).to receive(:request)
-      @http_client.send(:send_request, @request, content_type: 'image/jpg', body: 'body')
-    end
-
-    it 'should check the response with default allow_codes' do
-      allow(@request).to receive(:body=)
-      allow(@request).to receive(:[]=)
-      expect(@http_client).to receive(:check_response).with(anything, [200, 201])
-      @http_client.send(:send_request, @request, content_type: 'image/jpg', body: 'body')
-    end
-
-    it 'should call check_response with the provided allow_codes' do
-      allow(@request).to receive(:body=)
-      allow(@request).to receive(:[]=)
-      allow_codes = [200, 201, 409]
-      expect(@http_client).to receive(:check_response).with(anything, allow_codes)
-      @http_client.send(:send_request, @request, content_type: 'image/jpg', body: 'body', allow_codes: allow_codes)
-    end
-  end
-
-  describe 'check_response' do
-
-    before(:each) do
-      @response = double('A mock for a response')
-      allow(@response).to receive(:body)
-      @allow=[200, 201]
-    end
-
-    it 'should raise NotAuthenticatedError if the response code is 401' do
-      allow(@response).to receive(:code).and_return('401')
-      expect { @http_client.send(:check_response, @response, @allow) }.to raise_error NotAuthenticatedError
-    end
-
-    it 'should not raise any exception if the response code is 200..201' do
-      allow(@response).to receive(:code).and_return('201')
-      expect { @http_client.send(:check_response, @response, @allow) }.to_not raise_error
-    end
-
-    it 'should raise exception if the response code is other than 200..201|401' do
-      allow(@response).to receive(:code).and_return('500')
-      expect { @http_client.send(:check_response, @response, @allow) }.to raise_error
-    end
-  end
-
-  describe 'request_handling_auth' do
-
-    before(:each) do
-      @url = 'https://dev.livepaperapi.com/auth/token'
-    end
-
-    context 'when there is no access token' do
-
-      before(:each) do
-        @http_client.instance_variable_set(:@access_token, nil)
-      end
-
-      it 'should request the access token' do
-        expect(@http_client).to receive(:request_access_token)
-        @http_client.send(:request_handling_auth, @url, "POST") { |request|}
-      end
-    end
-
-    context 'when there is access token' do
-
-      before(:each) do
-        @http_client.instance_variable_set(:@access_token, 'TOPSECRET')
-      end
-
-      it 'should yield the given block' do
-        a_mock = double('Some mock')
-        expect(a_mock).to receive(:a_message)
-        @http_client.send(:request_handling_auth, @url, 'POST') do |request|
-          a_mock.a_message
-        end
-      end
-
-      context 'when the access token is invalid' do
-
-        before(:each) do
-          @http_client.instance_variable_set(:@access_token, 'INVALID')
-        end
-
-        it 'should retry max 3 times' do
-          a_mock = double('Some mock')
-          expect(a_mock).to receive(:a_message).at_least(:twice)
-          begin
-            @http_client.send(:request_handling_auth, @url, 'POST') do |request|
-              a_mock.a_message
-              raise NotAuthenticatedError.new
-            end
-          rescue NotAuthenticatedError => e
-          end
-        end
-
-        it 'should raise exception if retried more than 3 times' do
-          allow(@http_client).to receive (:request_access_token)
-          expect {
-            @http_client.send(:request_handling_auth, @url, 'POST') do |request|
-              raise NotAuthenticatedError.new
-            end
-          }.to raise_error
-        end
-      end
-    end
-  end
-
-  describe 'request_access_token' do
-
-    it 'should parse the response getting the accessToken entry' do
-      @http_client.send :request_access_token
-      expect(@http_client.instance_variable_get(:@access_token)).to eq 'SECRETTOKEN'
-    end
-  end
-
-  describe 'http_request' do
-
-    before do
-      @host = 'https://dev.livepaperapi.com/auth/token'
-      @http = double('Http mock')
-      allow(@http).to receive(:verify_mode=)
-      allow(@http).to receive(:use_ssl=)
-    end
-    it 'should create and return a Net::HTTP::Post instance if POST method is chosen.' do
-      expect(Net::HTTP::Post).to receive(:new).and_call_original
-      @http_client.send(:http_request, @host, 'POST')
-    end
-
-    it 'should create and return a Net::HTTP::Get instance if GET method is chosen.' do
-      expect(Net::HTTP::Get).to receive(:new).and_call_original
-      @http_client.send(:http_request, @host, 'GET')
-    end
-
-    it 'should create and return a Net::HTTP::Delete instance if DELETE method is chosen.' do
-      expect(Net::HTTP::Delete).to receive(:new).and_call_original
-      @http_client.send(:http_request, @host, 'DELETE')
-    end
-
-    it 'should use ssl' do
-      allow(Net::HTTP).to receive(:new).and_return(@http)
-      expect(@http).to receive(:use_ssl=)
-      @http_client.send(:http_request, @host, 'POST')
-    end
-
-    it 'should handle proxy settings' do
-      ENV['HTTP_PROXY'] = 'http://proxy.com:1234'
-      expect(Net::HTTP).to receive(:new).with('dev.livepaperapi.com', 443, 'proxy.com', '1234').and_return(@http)
-      @http_client.send(:http_request, @host, 'POST')
-    end
-
-    it 'should raise exception if the method provided is not supported.' do
-      expect { @http_client.send(:http_request, @host, 'NOT_SUPPORTED') }.to raise_error
-    end
-
-  end
-
-end