coinbase_commerce 0.8.7

data/spec/api_resources/base/api_object_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe CoinbaseCommerce::APIResources::Base::APIObject do
+  describe "#respond_to" do
+    it "should implement respond_to method" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(id: 1, foo: "bar")
+      expect(obj.respond_to?(:foo)).to be true
+      expect(obj.respond_to?(:baz)).to be false
+    end
+  end
+
+  describe "#serialize params" do
+    it "should serialize params on an empty object" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      expect({}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a new object with a sub object" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.new
+      obj.metadata = {foo: "bar"}
+      expect({metadata: {foo: "bar"}}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a basic object" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.update_attributes(foo: "bar")
+      expect({foo: "bar"}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a complex object" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(
+          foo: CoinbaseCommerce::APIResources::Base::APIObject.create_from(bar: nil, baz: nil))
+      obj.foo.bar = "newbar"
+      expect({foo: {bar: "newbar"}}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.foo = ["new-value"]
+      expect({foo: ["new-value"]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array that shortens" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: ["0-index", "1-index", "2-index"])
+      obj.foo = ["new-value"]
+      expect({foo: ["new-value"]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array of hashes" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.foo = [
+          CoinbaseCommerce::APIResources::Base::APIObject.create_from(bar: nil),
+      ]
+      obj.foo[0].bar = "baz"
+      expect({foo: [{bar: "baz"}]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params doesn't include unchanged values" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: nil)
+      expect({}).to eq obj.serialize_params
+    end
+
+    it "should serialize params with a APIObject" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      obj.metadata = CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: "bar")
+      serialized = obj.serialize_params
+      expect({foo: "bar"}).to eq serialized[:metadata]
+    end
+
+    it "should serialize params with APIObject that's been replaced" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(
+          source: CoinbaseCommerce::APIResources::Base::APIObject.create_from(bar: "foo"))
+
+      obj.source = CoinbaseCommerce::APIResources::Base::APIObject.create_from(baz: "foo")
+
+      serialized = obj.serialize_params
+      expect({baz: "foo"}).to eq serialized[:source]
+    end
+
+    it "should serialize params with an array of APIObjects" do
+      stub_request(:post, "#{@api_base}charges").to_return(body: {data: mock_item}.to_json)
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      obj.metadata = [
+          CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: "bar"),
+      ]
+
+      serialized = obj.serialize_params
+      expect([{foo: "bar"}]).to eq serialized[:metadata]
+    end
+
+    it "should serialize params with embed API resources" do
+      charge = CoinbaseCommerce::APIResources::Charge.create_from(id: "charge_id")
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      obj.charge = charge
+      expect(obj.charge).is_a? CoinbaseCommerce::APIResources::Charge
+    end
+
+    it "should serialize params and not include API resources that have not been set" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(id: "cus_123")
+      obj2 = CoinbaseCommerce::APIResources::Base::APIObject.create_from(obj: obj)
+      serialized = obj2.serialize_params
+      expect({}).to eq serialized
+    end
+
+    it "should serialize params takes a push option" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(
+          id: "id", metadata: CoinbaseCommerce::APIResources::Base::APIObject.create_from(foo: "bar"))
+      serialized = obj.serialize_params(push: true)
+      expect({id: "id", metadata: {foo: "bar"}}).to eq serialized
+    end
+  end
+
+  describe "update attributes" do
+    it "should update attributes with a hash" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      obj.update_attributes(metadata: {foo: "bar"})
+      expect(obj.metadata.class).to eq CoinbaseCommerce::APIResources::Base::APIObject
+    end
+
+    it "should assign question mark accessors for booleans added after initialization" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.new
+      obj.bool = true
+      expect(obj.respond_to?(:bool?)).to be true
+      expect(obj.bool?).to be true
+    end
+
+    it "should assign question mark accessors for booleans" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from(id: 1, bool: true, not_bool: "bar")
+      expect(obj.respond_to?(:bool?)).to be true
+      expect(obj.respond_to?(:not_bool)).to be true
+      expect(obj.bool?).to be true
+    end
+
+    it "should create accessors when update attributes is called" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      expect(obj.send(:metaclass).method_defined?(:foo)).to eq false
+      obj.update_attributes(foo: "bar")
+      expect(obj.send(:metaclass).method_defined?(:foo)).to eq true
+    end
+
+    it "should update attributes with a hash" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      obj.update_attributes(metadata: {foo: "bar"})
+      expect(CoinbaseCommerce::APIResources::Base::APIObject).to eq obj.metadata.class
+    end
+
+    it "should create accessors when update attributes is called" do
+      obj = CoinbaseCommerce::APIResources::Base::APIObject.create_from({})
+      expect(obj.send(:metaclass).method_defined?(:foo)).to be false
+      obj.update_attributes(foo: "bar")
+      expect(obj.send(:metaclass).method_defined?(:foo)).to be true
+    end
+  end
+end

data/spec/api_resources/base/api_resource_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe CoinbaseCommerce::APIResources::Base::APIResource do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "shout create a new APIResource without request" do
+    CoinbaseCommerce::APIResources::Base::APIResource.new("id")
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+
+  it "should create APIResource object form hash without request" do
+    CoinbaseCommerce::APIResources::Base::APIResource.create_from(id: "some_id",
+                                                                  param: {id: "param_id"})
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+
+  it "setting an attribute should not cause a network request" do
+    c = CoinbaseCommerce::APIResources::Base::APIResource.new("cus_123")
+    c.param = {id: "param_id"}
+    assert_not_requested :get, %r{#{@api_base}/.*}
+    assert_not_requested :post, %r{#{@api_base}/.*}
+  end
+
+  it "accessing id should not issue a fetch" do
+    c = CoinbaseCommerce::APIResources::Base::APIResource.new("cus_123")
+    c.id
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+end

data/spec/api_resources/charge_spec.rb

@@ -0,0 +1,19 @@
+describe CoinbaseCommerce::APIResources::Charge do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "making a POST request with parameters should have a body and no query string" do
+    stub_request(:post, "#{@api_base}#{CoinbaseCommerce::APIResources::Charge::RESOURCE_PATH}")
+        .with(body: {:id => "id_value", :key => "key_value"})
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    @client.charge.create(id: "id_value", key: "key_value")
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{CoinbaseCommerce::APIResources::Charge::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.charge.list(limit: 5)
+  end
+end

data/spec/api_resources/checkout_spec.rb

@@ -0,0 +1,31 @@
+describe CoinbaseCommerce::APIResources::Checkout do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "checkout should save nothing if nothing changes" do
+    stub_request(:post, "#{@api_base}#{CoinbaseCommerce::APIResources::Checkout::RESOURCE_PATH}")
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    checkout = @client.checkout.create(id: "id_value", key: "key_value")
+
+    stub_request(:put, "#{@api_base}#{CoinbaseCommerce::APIResources::Checkout::RESOURCE_PATH}/id_value")
+        .with(body: {})
+        .to_return(body: JSON.generate("id" => "id_value", "key" => "key_value"))
+
+    checkout.save
+  end
+
+  it "making a POST request with parameters should have a body and no query string" do
+    stub_request(:post, "#{@api_base}#{CoinbaseCommerce::APIResources::Checkout::RESOURCE_PATH}")
+        .with(body: {:id => "id_value", :key => "key_value"})
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    @client.checkout.create(id: "id_value", key: "key_value")
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{CoinbaseCommerce::APIResources::Checkout::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.checkout.list(limit: 5)
+  end
+end

data/spec/api_resources/event_spec.rb

@@ -0,0 +1,12 @@
+describe CoinbaseCommerce::APIResources::Event do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{CoinbaseCommerce::APIResources::Event::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.event.list(limit: 5)
+  end
+end

data/spec/endpont_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe CoinbaseCommerce do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  # test list resources
+  it "should get charges" do
+    stub_request(:get, "#{@api_base}charges").to_return(body: mock_list.to_json)
+    charge_list = @client.charge.list
+    expect(charge_list).is_a? @client.charge
+    expect(charge_list.data).is_a? Array
+    expect(charge_list.pagination).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(charge_list.data[0].to_hash).to eq mock_item
+  end
+
+  it "should get checkouts" do
+    stub_request(:get, "#{@api_base}checkouts").to_return(body: mock_list.to_json)
+    checkout_list = @client.checkout.list
+    expect(checkout_list).is_a? @client.checkout
+    expect(checkout_list.data).is_a? Array
+    expect(checkout_list.pagination).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(checkout_list.data[0].to_hash).to eq mock_item
+  end
+
+  it "should should get events" do
+    stub_request(:get, "#{@api_base}events").to_return(body: mock_list.to_json)
+    event_list = @client.event.list
+    expect(event_list).is_a? @client.checkout
+    expect(event_list.data).is_a? Array
+    expect(event_list.pagination).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(event_list.data[0].to_hash).to eq mock_item
+  end
+
+
+  # test single resources
+  it "should get charge" do
+    stub_request(:get, "#{@api_base}charges/key").to_return(body: {data: mock_item}.to_json)
+    charge = @client.charge.retrieve :key
+    expect(charge).is_a? @client.charge
+    expect(charge).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(charge.id).to eq mock_item[:id]
+    expect(charge.key).to eq mock_item[:key]
+  end
+
+  it "should get checkout" do
+    stub_request(:get, "#{@api_base}checkouts/key").to_return(body: {data: mock_item}.to_json)
+    checkout = @client.checkout.retrieve :key
+    expect(checkout).is_a? @client.checkout
+    expect(checkout).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(checkout.id).to eq mock_item[:id]
+    expect(checkout.key).to eq mock_item[:key]
+  end
+
+  it "should get event" do
+    stub_request(:get, "#{@api_base}events/key").to_return(body: {data: mock_item}.to_json)
+    event = @client.event.retrieve :key
+    expect(event).is_a? @client.charge
+    expect(event).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(event.id).to eq mock_item[:id]
+    expect(event.key).to eq mock_item[:key]
+  end
+
+  # test create resources
+  it "should create charge" do
+    stub_request(:post, "#{@api_base}charges").to_return(body: {data: mock_item}.to_json)
+    charge = @client.charge.create(mock_item)
+    expect(charge).is_a? @client.charge
+    expect(charge).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(charge.id).to eq mock_item[:id]
+    expect(charge.key).to eq mock_item[:key]
+  end
+
+  it "should create checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    expect(checkout).is_a? @client.checkout
+    expect(checkout).is_a? CoinbaseCommerce::APIResources::Base::APIObject
+    expect(checkout.id).to eq mock_item[:id]
+    expect(checkout.key).to eq mock_item[:key]
+  end
+
+  # test delete resources
+  it "should delete checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    stub_request(:delete, "#{@api_base}checkouts/val").to_return(body: {}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    checkout.delete
+  end
+
+  # test save resources
+  it "should save checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    stub_request(:put, "#{@api_base}checkouts/val").to_return(body: {:edited => true}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    checkout.key = "new value"
+    checkout.save
+    expect(checkout.edited).to eq true
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe CoinbaseCommerce do
+  before :all do
+    @client = CoinbaseCommerce::Client.new(api_key: 'api_key')
+  end
+
+  it "should get appropriate error when invalid response object" do
+    stub_request(:get, /.*/).to_return(body: {errors: [{id: "boo", message: "foo"}]}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::APIError
+  end
+
+  it "should handle invalid request general" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "invalid_request", message: "test"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::InvalidRequestError
+  end
+
+  it "should handle param required" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "param_required", message: "param_required"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::ParamRequiredError
+  end
+
+  it "should handle validation error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "validation_error", message: "validation_error"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::ValidationError
+  end
+
+  it "should handle param_required" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "invalid_request", message: "invalid_request"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::InvalidRequestError
+  end
+
+  it "should handle authentication error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "auth_error", message: "auth_error"}}.to_json, status: 401)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::AuthenticationError
+  end
+
+  it "should handle resource not found error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "not_found", message: "not_found"}}.to_json, status: 404)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::ResourceNotFoundError
+  end
+
+  it "should handle rate limit exceeded error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "rate_limit_exceeded", message: "rate_limit_exceeded"}}.to_json, status: 429)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::RateLimitExceededError
+  end
+
+  it "should handle internal server error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "internal_error", message: "internal_error"}}.to_json, status: 500)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::InternalServerError
+  end
+
+  it "should handle service unavailable error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "service_unavailable", message: "service_unavailable"}}.to_json, status: 503)
+    expect {@client.checkout.list}.to raise_error CoinbaseCommerce::Errors::ServiceUnavailableError
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe CoinbaseCommerce::CoinbaseCommerceResponse do
+  describe "from_faraday_hash" do
+    it "should initialize a CoinbaseCommerceResponse object from a Hash like the kind" do
+      body = '{"foo": "bar"}'
+      headers = {"x-request-id" => "x-request-id"}
+      http_resp = {
+          body: body,
+          headers: headers,
+          status: 200,
+      }
+      resp = CoinbaseCommerce::CoinbaseCommerceResponse.from_faraday_hash(http_resp)
+
+      expect(JSON.parse(body, symbolize_names: true)).to eq resp.data
+      expect(body).to eq resp.http_body
+      expect(headers).to eq resp.http_headers
+      expect(200).to eq resp.http_status
+      expect("x-request-id").to eq resp.request_id
+    end
+  end
+
+  describe "from_faraday_response" do
+    it "should initialize a CoinbaseCommerceResponse object from a Faraday HTTP response object." do
+      body = '{"foo": "bar"}'
+      headers = {"x-request-id" => "x-request-id"}
+      env = Faraday::Env.from(
+          status: 200, body: body,
+          response_headers: headers
+      )
+      http_resp = Faraday::Response.new(env)
+
+      resp = CoinbaseCommerce::CoinbaseCommerceResponse.from_faraday_response(http_resp)
+
+      expect(JSON.parse(body, symbolize_names: true)).to eq resp.data
+      expect(body).to eq resp.http_body
+      expect(headers).to eq resp.http_headers
+      expect(200).to eq resp.http_status
+      expect("x-request-id").to eq resp.request_id
+    end
+  end
+end