paypal-sdk-rest 1.7.6 → 2.0.0.rc1

data/spec/core/api/data_type_spec.rb

@@ -1,289 +0,0 @@
-require 'spec_helper'
-
-describe PayPal::SDK::Core::API::DataTypes::Base do
-
-  DataType = PayPal::SDK::Core::API::DataTypes::Base
-
-  class TestCurrency < DataType
-
-    # Members
-    object_of :amount, String
-    object_of :desciption, String, :namespace => "ns"
-    # Attributes
-    add_attribute :currencyID, :namespace => "cc"
-  end
-
-  class TestType < DataType
-    object_of :fromCurrency, TestCurrency
-    array_of  :toCurrency,   TestCurrency
-    object_of :firstname,    String, :name => "first-name"
-  end
-
-  class TestSimpleType < DataType
-    include PayPal::SDK::Core::API::DataTypes::SimpleTypes
-    object_of :created_on, Date
-    object_of :created_at, DateTime
-  end
-
-  class Message < DataType
-    object_of :value, String
-  end
-
-  it "should allow content key" do
-    message = Message.new("Testing message")
-    expect(message.value).to eql "Testing message"
-
-    message = Message.new(:value => "Testing message")
-    expect(message.value).to eql "Testing message"
-  end
-
-  it "should create member object automatically" do
-    test_type = TestType.new
-    expect(test_type.fromCurrency).to   be_a TestCurrency
-    expect(test_type.toCurrency).to     be_a Array
-    expect(test_type.toCurrency[0]).to  be_a TestCurrency
-    expect(test_type.toCurrency[1]).to  be_a TestCurrency
-    expect(test_type.toCurrency[0].amount).to eql nil
-    expect(test_type.fromCurrency.amount).to  eql nil
-    expect(test_type.fromCurrency.desciption).to    eql nil
-    expect(test_type.fromCurrency.currencyID).to    eql nil
-  end
-
-  it "should convert the given data to configured type" do
-    test_type = TestType.new( :fromCurrency => { :currencyID => "USD", :amount => "50.0"})
-    expect(test_type.fromCurrency).to be_a TestCurrency
-    expect(test_type.fromCurrency.currencyID).to    eql "USD"
-    expect(test_type.fromCurrency.amount).to  eql "50.0"
-  end
-
-  it "invoice address loads all members of default address object" do
-    invoice_address = InvoiceAddress.new(:line1 => "line1", :line2 => "line2", :phone => { :country_code => "123", :national_number => "1231231234", :extension => "123" }, :status => "status" )
-    expect(invoice_address).to be_a InvoiceAddress
-    expect(invoice_address.phone).to be_a Phone
-    expect(invoice_address.line1).to eql "line1"
-    expect(invoice_address.line2).to eql "line2"
-    expect(invoice_address.status).to eql "status"
-    expect(invoice_address.phone.country_code).to eql "123"
-    expect(invoice_address.phone.national_number).to eql "1231231234"
-    expect(invoice_address.phone.extension).to eql "123"
-  end
-
-  it "billing info converts an address to invoiceaddress automatically" do
-    address = Address.new(:line1 => "line1", :line2 => "line2", :status => "status" )
-    billing_info = BillingInfo.new({
-      :first_name => "Sally",
-      :last_name => "Patient",
-      :business_name => "Not applicable",
-    })
-    billing_info.address = address
-    expect(billing_info.address).to be_a Address
-    expect(billing_info.invoice_address).to be_a InvoiceAddress
-  end
-
-  it "shipping info returns an Address even if set to InvoiceAddress for backwards compatibility" do
-    address = InvoiceAddress.new(:line1 => "line1", :line2 => "line2", :status => "status", :phone => { :national_number => "1234567890" } )
-    billing_info = BillingInfo.new({
-      :first_name => "Sally",
-      :last_name => "Patient",
-      :business_name => "Not applicable",
-    })
-    billing_info.address = address
-    expect(billing_info.address).to be_a Address
-    expect(billing_info.invoice_address).to be_a InvoiceAddress
-    expect(billing_info.invoice_address.phone.national_number).to eql "1234567890"
-  end
-
-  it "returns the address and invoice address types in the billing info" do
-    billing_info = BillingInfo.new({
-      "first_name" => "Sally",
-      "last_name" => "Patient",
-      "business_name" => "Not applicable",
-      "address" => {
-        "line1" => "line1Value",
-        "phone" => { "country_code" => "123", "national_number" => "1234567890", "extension" => "456" },
-      },
-    })
-    expect(billing_info.address).to be_a Address
-    expect(billing_info.address.line1).to eql "line1Value"
-    expect(billing_info.invoice_address).to be_a InvoiceAddress
-    expect(billing_info.invoice_address.line1).to eql "line1Value"
-    expect(billing_info.invoice_address.phone.country_code).to eql "123"
-    expect(billing_info.invoice_address.phone.national_number).to eql "1234567890"
-    expect(billing_info.invoice_address.phone.extension).to eql "456"
-  end
-
-  it "shipping info converts an address to invoiceaddress automatically" do
-    address = Address.new(:line1 => "line1", :line2 => "line2", :status => "status" )
-    shipping_info = ShippingInfo.new({
-      "first_name" => "Sally",
-      "last_name" => "Patient",
-      "business_name" => "Not applicable",
-    })
-    shipping_info.address = address
-    expect(shipping_info.address).to be_a Address
-    expect(shipping_info.invoice_address).to be_a InvoiceAddress
-  end
-
-  it "shipping info returns an Address even if set to InvoiceAddress for backwards compatibility" do
-    address = InvoiceAddress.new(:line1 => "line1", :line2 => "line2", :status => "status", :phone => { :national_number => "1234567890" } )
-    shipping_info = ShippingInfo.new({
-      "first_name" => "Sally",
-      "last_name" => "Patient",
-      "business_name" => "Not applicable",
-    })
-    shipping_info.address = address
-    expect(shipping_info.address).to be_a Address
-    expect(shipping_info.invoice_address).to be_a InvoiceAddress
-    expect(shipping_info.invoice_address.phone.national_number).to eql "1234567890"
-  end
-
-  it "returns the address and invoice address types in the shipping info" do
-    shipping_info = ShippingInfo.new({
-      "first_name" => "Sally",
-      "last_name" => "Patient",
-      "business_name" => "Not applicable",
-      "address" => {
-        "line1" => "line1Value",
-        "phone" => { "country_code" => "123", "national_number" => "1234567890", "extension" => "456" },
-      },
-    })
-    expect(shipping_info.address).to be_a Address
-    expect(shipping_info.address.line1).to eql "line1Value"
-    expect(shipping_info.invoice_address).to be_a InvoiceAddress
-    expect(shipping_info.invoice_address.line1).to eql "line1Value"
-    expect(shipping_info.invoice_address.phone.country_code).to eql "123"
-    expect(shipping_info.invoice_address.phone.national_number).to eql "1234567890"
-    expect(shipping_info.invoice_address.phone.extension).to eql "456"
-  end
-
-  it "should allow block with initializer" do
-    test_type = TestType.new do
-      fromCurrency do
-        self.currencyID = "USD"
-        self.amount = "50.0"
-      end
-    end
-    expect(test_type.fromCurrency.currencyID).to    eql "USD"
-    expect(test_type.fromCurrency.amount).to  eql "50.0"
-  end
-
-  it "should allow block with member" do
-    test_type = TestType.new
-    test_type.fromCurrency do
-      self.currencyID = "USD"
-      self.amount = "50.0"
-    end
-    expect(test_type.fromCurrency.currencyID).to    eql "USD"
-    expect(test_type.fromCurrency.amount).to  eql "50.0"
-  end
-
-  it "should assign value to attribute" do
-    test_currency = TestCurrency.new( :@currencyID => "USD", :amount => "50" )
-    expect(test_currency.currencyID).to eql "USD"
-  end
-
-  it "should allow configured Class object" do
-    test_currency = TestCurrency.new( :currencyID => "USD", :amount => "50" )
-    test_type = TestType.new( :fromCurrency => test_currency )
-    expect(test_type.fromCurrency).to eql test_currency
-  end
-
-  it "should allow snakecase" do
-    test_type = TestType.new( :from_currency => {} )
-    expect(test_type.from_currency).to be_a TestCurrency
-    expect(test_type.from_currency).to eql test_type.fromCurrency
-  end
-
-  it "should allow array" do
-    test_type = TestType.new( :toCurrency => [{ :currencyID => "USD", :amount => "50.0" }] )
-    expect(test_type.toCurrency).to be_a Array
-    expect(test_type.toCurrency.first).to be_a TestCurrency
-    expect(test_type.toCurrency.first.currencyID).to eql "USD"
-  end
-
-  it "should skip undefind members on initializer" do
-    test_type = TestType.new( :notExist => "testing")
-    expect do
-      test_type.notExist
-    end.to raise_error NoMethodError
-    expect do
-      test_type.notExist = "Value"
-    end.to raise_error NoMethodError
-  end
-
-  it "should not convert empty hash" do
-    test_type = TestType.new( :fromCurrency => {} )
-    expect(test_type.to_hash).to eql({})
-  end
-
-  it "should not convert empty array" do
-    test_type = TestType.new( :toCurrency => [] )
-    expect(test_type.to_hash).to eql({})
-  end
-
-  it "should not convert array of empty hash" do
-    test_type = TestType.new( :toCurrency => [ {} ] )
-    expect(test_type.to_hash).to eql({})
-  end
-
-  it "should return empty hash" do
-    test_type = TestType.new
-    expect(test_type.to_hash).to eql({})
-  end
-
-  it "should convert to hash" do
-    test_currency = TestCurrency.new(:amount => "500")
-    expect(test_currency.to_hash).to eql("amount" => "500")
-  end
-
-  it "should convert to hash with key as symbol" do
-    test_currency = TestCurrency.new(:amount => "500")
-    expect(test_currency.to_hash(:symbol => true)).to eql(:amount => "500")
-  end
-
-  it "should convert attribute key with @" do
-    test_currency = TestCurrency.new( :currencyID => "USD", :amount => "50" )
-    expect(test_currency.to_hash["@currencyID"]).to eql "USD"
-  end
-
-  it "should convert attribute key without @" do
-    test_currency = TestCurrency.new( :currencyID => "USD", :amount => "50" )
-    expect(test_currency.to_hash(:attribute => false)["currencyID"]).to eql "USD"
-  end
-
-  it "should convert to hash with namespace" do
-    test_currency = TestCurrency.new(:currencyID => "USD", :amount => "500", :desciption => "Testing" )
-    hash = test_currency.to_hash
-    expect(hash["amount"]).to eql "500"
-    expect(hash["ns:desciption"]).to eql "Testing"
-    expect(hash["@currencyID"]).to eql "USD"
-    hash = test_currency.to_hash(:namespace => false)
-    expect(hash["amount"]).to eql "500"
-    expect(hash["desciption"]).to eql "Testing"
-    expect(hash["@currencyID"]).to eql "USD"
-  end
-
-  it "should allow namespace" do
-    test_currency = TestCurrency.new(:amount => "500", :"ns:desciption" => "Testing" )
-    expect(test_currency.desciption).to eql "Testing"
-  end
-
-  it "should use name option in members" do
-    test_type = TestType.new( :firstname => "FirstName")
-    expect(test_type.to_hash).to eql({"first-name" => "FirstName" })
-  end
-
-  it "should allow date" do
-    date_time = "2010-10-10T10:10:10"
-    test_simple_type = TestSimpleType.new( :created_on => date_time, :created_at => date_time )
-    expect(test_simple_type.created_on).to be_a Date
-    expect(test_simple_type.created_at).to be_a DateTime
-  end
-
-  it "should allow date with value 0" do
-    test_simple_type = TestSimpleType.new( :created_at => "0" )
-    expect(test_simple_type.created_at).to be_a DateTime
-  end
-
-end
-

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