paypal-sdk-rest 1.7.3 → 2.0.0.rc2

data/spec/core/api/rest_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-
-describe PayPal::SDK::Core::API::REST do
-
-  module PayPalRest
-    class API < PayPal::SDK::Core::API::REST
-    end
-  end
-
-  def create_api(*args)
-    api = PayPalRest::API.new(*args)
-    @log_file ||= File.open("spec/log/rest_http.log", "w")
-    api.http.set_debug_output(@log_file)
-    api
-  end
-
-  before :all do
-    @api = create_api("v1/payments/", :with_authentication)
-    @vault_api = create_api("v1/vault/", :with_authentication)
-  end
-
-  describe "Configuration" do
-    it "create api with prefix" do
-      api = create_api("v1/payments")
-      expect(api.uri.path).to eql "/v1/payments"
-    end
-
-    it "service endpoint for sandbox" do
-      api = create_api
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.sandbox.paypal.com"
-      api = create_api( :mode => "sandbox" )
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.sandbox.paypal.com"
-      api = create_api( :mode => :sandbox )
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.sandbox.paypal.com"
-      api = create_api( :mode => "invalid" )
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.sandbox.paypal.com"
-      api = create_api( :mode => nil )
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.sandbox.paypal.com"
-    end
-
-    it "service endpoint for live" do
-      api = create_api( :mode => "live" )
-      expect(api.service_endpoint).to eql "https://api.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.paypal.com"
-      api = create_api( :mode => :live )
-      expect(api.service_endpoint).to eql "https://api.paypal.com"
-      expect(api.token_endpoint).to   eql "https://api.paypal.com"
-    end
-
-    it "override service endpoint" do
-      api = create_api( :rest_endpoint => "https://testing.api.paypal.com" )
-      expect(api.service_endpoint).to eql "https://testing.api.paypal.com"
-      expect(api.token_endpoint).to   eql "https://testing.api.paypal.com"
-      api = create_api( :endpoint => "https://testing.api.paypal.com" )
-      expect(api.service_endpoint).to eql "https://testing.api.paypal.com"
-      expect(api.token_endpoint).to   eql "https://testing.api.paypal.com"
-    end
-
-    it "override token endpoint" do
-      api = create_api( :rest_token_endpoint => "https://testing.api.paypal.com" )
-      expect(api.service_endpoint).to eql "https://api.sandbox.paypal.com"
-      expect(api.token_endpoint).to   eql "https://testing.api.paypal.com"
-    end
-  end
-
-  describe "Validation" do
-    it "Invalid client_id and client_secret" do
-      api = create_api(:with_authentication, :client_id => "XYZ", :client_secret => "ABC")
-      expect {
-        api.token
-      }.to raise_error PayPal::SDK::Core::Exceptions::UnauthorizedAccess
-    end
-
-    it "Should handle expired token" do
-      old_token = @api.token
-      @api.token_hash[:expires_in] = 0
-      new_token = @api.token
-      expect(@api.token_hash[:expires_in]).not_to eql 0
-    end
-
-    it "Get token" do
-      expect(@api.token).not_to be_nil
-    end
-  end
-
-  describe "Success request", :integration => true do
-
-    it "Create Payment" do
-      response = @api.post("payment", {
-        "intent" => "sale",
-        "payer" => {
-          "payment_method" => "credit_card",
-          "funding_instruments" => [{
-            "credit_card" => {
-              "type" => "visa",
-              "number" => "4567516310777851",
-              "expire_month" => "11", "expire_year" => "2018",
-              "first_name" => "Joe", "last_name" => "Shopper" }}]},
-        "transactions" => [{
-          "amount" => {
-            "total" => "7.47",
-            "currency" => "USD" }}]})
-      expect(response["error"]).to be_nil
-    end
-
-    it "List Payments" do
-      response = @api.get("payment", { "count" => 10 })
-      expect(response["error"]).to be_nil
-      expect(response["count"]).not_to be_nil
-    end
-
-    it "Execute Payment"
-
-    it "Create FundingInstrument" do
-      new_funding_instrument = @vault_api.post("credit-card", {
-        "type" =>  "visa",
-        "number" =>  "4111111111111111",
-        "expire_month" =>  "11", "expire_year" =>  "2018",
-        "cvv2" =>  "874",
-        "first_name" =>  "Joe", "last_name" =>  "Shopper" })
-      expect(new_funding_instrument["error"]).to  be_nil
-      expect(new_funding_instrument["id"]).not_to be_nil
-
-      funding_instrument = @vault_api.get("credit-card/#{new_funding_instrument["id"]}")
-      expect(funding_instrument["error"]).to be_nil
-      expect(funding_instrument["id"]).to eql new_funding_instrument["id"]
-    end
-
-  end
-
-  describe "Failure request", :integration => true do
-    it "Invalid Resource ID" do
-      expect {
-        response = @api.get("payment/PAY-1234")
-      }.to raise_error PayPal::SDK::Core::Exceptions::ResourceNotFound
-    end
-
-    it "Invalid parameters" do
-      response = @api.post("payment")
-      expect(response["error"]["name"]).to eql "VALIDATION_ERROR"
-    end
-  end
-
-  describe "format response" do
-    before :each do
-      @response = instance_double(Net::HTTPResponse)
-      allow(@response).to receive(:code) { "200" }
-      allow(@response).to receive(:content_type) { "application/json" }
-    end
-
-    it "parses empty object JSON correctly" do
-      allow(@response).to receive(:body) { "{}" }
-      payload = {
-        :response => @response
-      }
-
-      formatted_response = @api.format_response(payload)
-      expect(formatted_response).to_not be_nil
-      expect(formatted_response[:data]).to eq({})
-    end
-
-    it "parses empty string JSON correctly" do
-      allow(@response).to receive(:body) { '""' }
-      payload = {
-        :response => @response
-      }
-
-      formatted_response = @api.format_response(payload)
-      expect(formatted_response).to_not be_nil
-      expect(formatted_response[:data]).to eq("")
-    end
-
-    it "parses whitespace body correctly" do
-      allow(@response).to receive(:body) { ' 	 ' }
-      payload = {
-        :response => @response
-      }
-
-      formatted_response = @api.format_response(payload)
-      expect(formatted_response).to_not be_nil
-      expect(formatted_response[:data]).to eq({})
-    end
-
-    it "parses nil body correctly" do
-      allow(@response).to receive(:body) { nil }
-      payload = {
-        :response => @response
-      }
-
-      formatted_response = @api.format_response(payload)
-      expect(formatted_response).to_not be_nil
-      expect(formatted_response[:data]).to eq({})
-    end
-
-    it "parses with whitespace around JSON correctly" do
-      allow(@response).to receive(:body) { '    { "test": "value"  } ' }
-      payload = {
-        :response => @response
-      }
-
-      formatted_response = @api.format_response(payload)
-      expect(formatted_response).to_not be_nil
-      expect(formatted_response[:data]).to eq({ "test" => "value" })
-    end
-  end
-end

data/spec/core/config_spec.rb

@@ -1,192 +0,0 @@
-require 'spec_helper'
-
-describe PayPal::SDK::Core::Config do
-
-  Config = PayPal::SDK::Core::Config
-
-  it "load configuration file and default environment" do
-    expect {
-      Config.load("spec/config/paypal.yml", "test")
-      expect(Config.default_environment).to eql "test"
-    }.not_to raise_error
-  end
-
-  it "Set default environment" do
-    begin
-      backup_default_environment = Config.default_environment
-      Config.default_environment = "new_env"
-      expect(Config.default_environment).to eql "new_env"
-    ensure
-      Config.default_environment = backup_default_environment
-    end
-  end
-
-  it "Set configurations" do
-    begin
-      backup_configurations = Config.configurations
-      Config.configurations = { Config.default_environment => { :username => "direct", :password => "direct" } }
-      expect(Config.config.username).to eql "direct"
-      expect(Config.config.password).to eql "direct"
-      expect(Config.config.signature).to be_nil
-    ensure
-      Config.configurations = backup_configurations
-    end
-  end
-
-  it "Configure with parameters" do
-    begin
-      backup_configurations = Config.configurations
-      Config.configurations = nil
-      Config.configure( :username => "Testing" )
-      expect(Config.config.username).to eql "Testing"
-      expect(Config.config.app_id).to be_nil
-    ensure
-      Config.configurations = backup_configurations
-    end
-  end
-
-  it "Configure with block" do
-    begin
-      backup_configurations = Config.configurations
-      Config.configurations = nil
-      Config.configure do |config|
-        config.username = "Testing"
-      end
-      expect(Config.config.username).to eql "Testing"
-      expect(Config.config.app_id).to be_nil
-    ensure
-      Config.configurations = backup_configurations
-    end
-  end
-
-  it "Configure with default values" do
-    begin
-      backup_configurations = Config.configurations
-      default_config = Config.config
-      Config.configure do |config|
-        config.username = "Testing"
-      end
-      expect(Config.config.username).to eql "Testing"
-      expect(Config.config.app_id).not_to be_nil
-      expect(Config.config.app_id).to eql default_config.app_id
-    ensure
-      Config.configurations = backup_configurations
-    end
-  end
-
-  it "validate configuration" do
-    config = Config.new( :username => "XYZ")
-    expect {
-      config.required!(:username)
-    }.not_to raise_error
-    expect {
-      config.required!(:password)
-    }.to raise_error "Required configuration(password)"
-    expect {
-      config.required!(:username, :password)
-    }.to raise_error "Required configuration(password)"
-    expect {
-      config.required!(:password, :signature)
-    }.to raise_error "Required configuration(password, signature)"
-  end
-
-  it "return default environment configuration" do
-    expect(Config.config).to be_a Config
-  end
-
-  it "return configuration based on environment" do
-    expect(Config.config(:development)).to be_a Config
-  end
-
-  it "override default configuration" do
-    override_configuration = { :username => "test.example.com", :app_id => "test"}
-    config = Config.config(override_configuration)
-
-    expect(config.username).to eql(override_configuration[:username])
-    expect(config.app_id).to eql(override_configuration[:app_id])
-  end
-
-  it "get cached config" do
-    expect(Config.config(:test)).to eql Config.config(:test)
-    expect(Config.config(:test)).not_to eql Config.config(:development)
-  end
-
-  it "should raise error on invalid environment" do
-    expect {
-      Config.config(:invalid_env)
-    }.to raise_error "Configuration[invalid_env] NotFound"
-  end
-
-  it "set logger" do
-    require 'logger'
-    my_logger = Logger.new(STDERR)
-    Config.logger = my_logger
-    expect(Config.logger).to eql my_logger
-  end
-
-  it "Access PayPal::SDK methods" do
-    expect(PayPal::SDK.configure).to eql PayPal::SDK::Core::Config.config
-    expect(PayPal::SDK.logger).to eql PayPal::SDK::Core::Config.logger
-    PayPal::SDK.logger = PayPal::SDK.logger
-    expect(PayPal::SDK.logger).to eql PayPal::SDK::Core::Config.logger
-  end
-
-  describe "include Configuration" do
-    class TestConfig
-      include PayPal::SDK::Core::Configuration
-    end
-
-    it "Get default configuration" do
-      test_object = TestConfig.new
-      expect(test_object.config).to be_a Config
-    end
-
-    it "Change environment" do
-      test_object = TestConfig.new
-      test_object.set_config("test")
-      expect(test_object.config).to eql Config.config("test")
-      expect(test_object.config).not_to eql Config.config("development")
-    end
-
-    it "Override environment configuration" do
-      test_object = TestConfig.new
-      test_object.set_config("test", :username => "test")
-      expect(test_object.config).not_to eql Config.config("test")
-    end
-
-    it "Override default/current configuration" do
-      test_object = TestConfig.new
-      test_object.set_config( :username => "test")
-      expect(test_object.config.username).to eql "test"
-      test_object.set_config( :password => "test")
-      expect(test_object.config.password).to eql "test"
-      expect(test_object.config.username).to eql "test"
-    end
-
-    it "Append ssl_options" do
-      test_object = TestConfig.new
-      test_object.set_config( :ssl_options => { :ca_file => "test_path" } )
-      expect(test_object.config.ssl_options[:ca_file]).to eql "test_path"
-      test_object.set_config( :ssl_options => { :verify_mode => 1 } )
-      expect(test_object.config.ssl_options[:verify_mode]).to eql 1
-      expect(test_object.config.ssl_options[:ca_file]).to eql "test_path"
-    end
-
-    it "Set configuration without loading configuration File" do
-      backup_configurations = Config.configurations
-      begin
-        Config.configurations = nil
-        test_object = TestConfig.new
-        expect {
-          test_object.config
-        }.to raise_error
-        test_object.set_config( :username => "test" )
-        expect(test_object.config).to be_a Config
-      ensure
-        Config.configurations = backup_configurations
-      end
-    end
-
-  end
-
-end

data/spec/core/logging_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'stringio'
-
-describe PayPal::SDK::Core::Logging do
-  Logging = PayPal::SDK::Core::Logging
-
-  class TestLogging
-    include Logging
-  end
-
-  before :each do
-    @logger_file   = StringIO.new
-    Logging.logger = Logger.new(@logger_file)
-    @test_logging = TestLogging.new
-  end
-
-  it "get logger object" do
-    expect(@test_logging.logger).to be_a Logger
-  end
-
-  it "write message to logger" do
-    test_message = "Example log message!!!"
-    @test_logging.logger.info(test_message)
-    @logger_file.rewind
-    expect(@logger_file.read).to match test_message
-  end
-
-end

data/spec/core/openid_connect_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-
-describe PayPal::SDK::OpenIDConnect do
-  OpenIDConnect = PayPal::SDK::OpenIDConnect
-
-  before :all do
-    OpenIDConnect.set_config( :client_id => "client_id", :openid_redirect_uri => "http://google.com" )
-  end
-
-  it "Validate user_agent" do
-    expect(OpenIDConnect::API.user_agent).to match "PayPalSDK/openid-connect-ruby"
-  end
-
-  describe "generate_authorize_url" do
-
-    it "generate autorize_url" do
-      url = OpenIDConnect::Tokeninfo.authorize_url
-      expect(url).to match "client_id=client_id"
-      expect(url).to match Regexp.escape("redirect_uri=#{CGI.escape("http://google.com")}")
-      expect(url).to match "scope=openid"
-    end
-
-    describe "sandbox" do
-      before do
-        PayPal::SDK.configure(:mode => "sandbox")
-      end
-
-      it "generates a sandbox authorize url" do
-        url = OpenIDConnect::Tokeninfo.authorize_url
-        expect(url).to match "sandbox.paypal.com"
-      end
-    end
-  end
-
-  it "Override authorize_url params" do
-    url = OpenIDConnect.authorize_url(
-      :client_id => "new_client_id",
-      :redirect_uri => "http://example.com",
-      :scope => "openid profile")
-    expect(url).to match "client_id=new_client_id"
-    expect(url).to match Regexp.escape("redirect_uri=#{CGI.escape("http://example.com")}")
-    expect(url).to match Regexp.escape("scope=#{CGI.escape("openid profile")}")
-  end
-
-  it "Generate logout_url" do
-    url = OpenIDConnect.logout_url
-    expect(url).to match "logout=true"
-    expect(url).to match Regexp.escape("redirect_uri=#{CGI.escape("http://google.com")}")
-    expect(url).not_to match "id_token"
-  end
-
-  it "Override logout_url params" do
-    url = OpenIDConnect.logout_url({
-      :redirect_uri => "http://example.com",
-      :id_token  => "testing" })
-    expect(url).to match Regexp.escape("redirect_uri=#{CGI.escape("http://example.com")}")
-    expect(url).to match "id_token=testing"
-  end
-
-  describe "Validation" do
-    it "Create token" do
-      expect{
-        tokeninfo = OpenIDConnect::Tokeninfo.create("invalid-autorize-code")
-      }.to raise_error PayPal::SDK::Core::Exceptions::BadRequest
-    end
-
-    it "Refresh token" do
-      expect{
-        tokeninfo = OpenIDConnect::Tokeninfo.refresh("invalid-refresh-token")
-      }.to raise_error PayPal::SDK::Core::Exceptions::BadRequest
-    end
-
-    it "Get userinfo" do
-      expect{
-        userinfo = OpenIDConnect::Userinfo.get("invalid-access-token")
-      }.to raise_error PayPal::SDK::Core::Exceptions::UnauthorizedAccess
-    end
-  end
-
-  describe "Tokeninfo" do
-    before do
-      @tokeninfo = OpenIDConnect::Tokeninfo.new( :access_token => "test_access_token",
-        :refresh_token => "test_refresh_token",
-        :id_token => "test_id_token" )
-    end
-
-    it "create" do
-      allow(OpenIDConnect::Tokeninfo.api).to receive_messages( :post => { :access_token => "access_token" } )
-      tokeninfo = OpenIDConnect::Tokeninfo.create("authorize_code")
-      expect(tokeninfo).to be_a OpenIDConnect::Tokeninfo
-      expect(tokeninfo.access_token).to eql "access_token"
-    end
-
-    it "refresh" do
-      allow(@tokeninfo.api).to receive_messages( :post => { :access_token => "new_access_token" } )
-      expect(@tokeninfo.access_token).to eql "test_access_token"
-      @tokeninfo.refresh
-      expect(@tokeninfo.access_token).to eql "new_access_token"
-    end
-
-    it "userinfo" do
-      allow(@tokeninfo.api).to receive_messages( :post => { :name => "Testing" } )
-      userinfo = @tokeninfo.userinfo
-      expect(userinfo).to be_a OpenIDConnect::Userinfo
-      expect(userinfo.name).to eql "Testing"
-    end
-
-    describe "logout_url" do
-      it "Generate logout_url" do
-        url = @tokeninfo.logout_url
-        expect(url).to match "id_token=test_id_token"
-        expect(url).to match "logout=true"
-        expect(url).to match Regexp.escape("redirect_uri=#{CGI.escape("http://google.com")}")
-      end
-
-      describe "sandbox" do
-        before do
-          PayPal::SDK.configure(:mode => "sandbox")
-        end
-
-        it "generates a sandbox logout url" do
-          url = @tokeninfo.logout_url
-          expect(url).to match "sandbox.paypal.com"
-        end
-      end
-    end
-  end
-
-  describe "Userinfo" do
-    it "get" do
-      allow(OpenIDConnect::Userinfo.api).to receive_messages( :post => { :name => "Testing" } )
-
-      userinfo = OpenIDConnect::Userinfo.get("access_token")
-      userinfo = OpenIDConnect::Userinfo.new( { :name => "Testing" } )
-      expect(userinfo).to be_a OpenIDConnect::Userinfo
-      expect(userinfo.name).to eql "Testing"
-
-      userinfo = OpenIDConnect::Userinfo.get( :access_token => "access_token" )
-      expect(userinfo).to be_a OpenIDConnect::Userinfo
-      expect(userinfo.name).to eql "Testing"
-    end
-
-    it "get", :integration => true do
-      api = PayPal::SDK::REST::API.new
-      access_token = api.token_hash()
-      userinfo = OpenIDConnect::Userinfo.get( access_token )
-      expect(userinfo).to be_a OpenIDConnect::Userinfo
-      expect(userinfo.email).to eql "jaypatel512-facilitator@hotmail.com"
-    end
-  end
-
-
-end