aws_agcod_2 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57228cfced3a4ce27d86778e5458cb28c6dd00490880ae22db9ef8c2b1ca456e
+  data.tar.gz: f06da4395c979dba879ef0aaced9bbdd6ad79958b3514340d6ccbed0bfec74f0
+SHA512:
+  metadata.gz: 7384eddccb0d643c91eb8e6c00ea515333b7a9a602b46200f2bda20d1d5464e49c02dbc36b3d650de43ffc27aa9a5fc6bc35349a6ae6b1007f92400545e3b12a
+  data.tar.gz: 7971db886d28511ba4818d283b8c3245ac0cf14f850d14ea58539e8b574293ae4d7b75454d0661574556bd6b7348a83dfe8d11bec623071e7efa0c187aef5a79

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Xenor Chang
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# AGCOD
+
+[![Build Status](https://travis-ci.org/compwron/aws_agcod.svg?branch=master)](https://travis-ci.org/compwron/aws_agcod)
+[![Gem Version](https://badge.fury.io/rb/aws_agcod.svg)](http://badge.fury.io/rb/aws_agcod)
+
+Amazon Gift Code On Demand (AGCOD) API v2 implementation for distributing Amazon gift cards (gift codes) instantly in any denomination.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'aws_agcod'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aws_agcod
+
+## Usage
+
+#### Configure
+
+```ruby
+require "aws_agcod"
+
+AGCOD.configure do |config|
+  config.access_key = "YOUR ACCESS KEY"
+  config.secret_key = "YOUR SECRET KEY"
+  config.partner_id = "PARTNER ID"
+
+  # The `production` config is important as it determines which endpoint
+  # you're hitting.
+  config.production = true  # This defaults to false.
+
+  # Optionally, you can customize the URI completely.
+  config.uri = "https://my-custom-agcod-endpoint.com"
+
+  config.region  = "us-east-1" # default
+end
+```
+
+#### Create Gift Code/Card
+
+```ruby
+request_id = "test"
+amount = 10
+currency = "USD" # default to USD, available types are: USD, EUR, JPY, CNY, CAD
+httpable = HTTP # or HTTParty- whatever library you're using that has .post
+request = AGCOD::CreateGiftCard.new(httpable, request_id, amount, currency)
+
+# When succeed
+if request.success?
+  request.claim_code # => code for the gift card
+  request.gc_id # => gift card id
+  request.request_id # => your request id
+else
+# When failed
+  request.error_message # => Error response from AGCOD service
+end
+```
+
+#### Cancel Gift Code/Card
+
+```ruby
+request_id = "test"
+gc_id = "test_gc_id"
+httpable = HTTP # or HTTParty- whatever library you're using that has .post
+request = AGCOD::CancelGiftCard.new(httpable, request_id, gc_id)
+
+# When failed
+unless request.success?
+  request.error_message # => Error response from AGCOD service
+end
+```
+
+#### Get Gift Code/Card activities
+
+```ruby
+request_id = "test"
+start_time = Time.now - 86400
+end_time = Time.now
+page = 1
+per_page = 100
+show_no_ops = false # Whether or not to show activities with no operation
+httpable = HTTP # or HTTParty- whatever library you're using that has .post
+request = AGCOD::GiftCardActivityList.new(httpable, request_id, start_time, end_time, page, per_page, show_no_ops)
+
+if request.success?
+  request.results.each do |activity|
+    activity.status # => SUCCESS, FAILURE, RESEND
+    activity.created_at
+    activity.type
+    activity.card_number
+    activity.amount
+    activity.error_code
+    activity.gc_id
+    activity.partner_id
+    activity.request_id
+  end
+else
+  request.error_message # => Error response from AGCOD service
+end
+```
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/aws_agcod/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`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task default: :spec
+
+RSpec::Core::RakeTask.new
+

data/lib/aws_agcod.rb

@@ -0,0 +1,19 @@
+require "aws_agcod/version"
+require "aws_agcod/config"
+require "aws_agcod/create_gift_card"
+require "aws_agcod/cancel_gift_card"
+require "aws_agcod/gift_card_activity_list"
+
+module AGCOD
+  def self.configure(&block)
+    @config = Config.new
+
+    yield @config
+
+    nil
+  end
+
+  def self.config
+    @config
+  end
+end

data/lib/aws_agcod/available_funds.rb

@@ -0,0 +1,13 @@
+require 'aws_agcod/request'
+
+module AGCOD
+  class AvailableFunds
+    attr_reader :currency_code, :amount
+
+    def initialize(payload)
+      @currency_code = payload['currencyCode']
+      @amount = payload['amount']
+    end
+  end
+end
+

data/lib/aws_agcod/cancel_gift_card.rb

@@ -0,0 +1,16 @@
+require "aws_agcod/request"
+
+module AGCOD
+  class CancelGiftCard
+    extend Forwardable
+
+    def_delegators :@response, :status, :success?, :error_message
+
+    def initialize(httpable, request_id, gc_id)
+      @response = Request.new(httpable,"CancelGiftCard",
+        "creationRequestId" => request_id,
+        "gcId" => gc_id
+      ).response
+    end
+  end
+end

data/lib/aws_agcod/config.rb

@@ -0,0 +1,27 @@
+module AGCOD
+  class Config
+    attr_writer :uri
+    attr_accessor :access_key,
+                  :secret_key,
+                  :partner_id,
+                  :region,
+                  :production
+
+    URI = {
+      sandbox: "https://agcod-v2-gamma.amazon.com",
+      production: "https://agcod-v2.amazon.com"
+    }
+
+    def initialize
+      # API defaults
+      @production = false
+      @region = "us-east-1"
+    end
+
+    def uri
+      return @uri if @uri
+
+      production ? URI[:production] : URI[:sandbox]
+    end
+  end
+end

data/lib/aws_agcod/create_gift_card.rb

@@ -0,0 +1,43 @@
+require "aws_agcod/request"
+
+module AGCOD
+  class CreateGiftCardError < StandardError; end
+
+  class CreateGiftCard
+    extend Forwardable
+
+    CURRENCIES = %w(USD EUR JPY CNY CAD)
+
+    def_delegators :@response, :status, :success?, :error_message
+
+    def initialize(httpable, request_id, amount, currency = "USD")
+      unless CURRENCIES.include?(currency.to_s)
+        raise CreateGiftCardError, "Currency #{currency} not supported, available types are #{CURRENCIES.join(", ")}"
+      end
+
+      @response = Request.new(httpable, "CreateGiftCard",
+        "creationRequestId" => request_id,
+        "value" => {
+          "currencyCode" => currency,
+          "amount" => amount
+        }
+      ).response
+    end
+
+    def claim_code
+      @response.payload["gcClaimCode"]
+    end
+
+    def expiration_date
+      @expiration_date ||= Time.parse @response.payload["gcExpirationDate"]
+    end
+
+    def gc_id
+      @response.payload["gcId"]
+    end
+
+    def request_id
+      @response.payload["creationRequestId"]
+    end
+  end
+end

data/lib/aws_agcod/get_available_funds.rb

@@ -0,0 +1,30 @@
+require 'aws_agcod/request'
+require 'aws_agcod/available_funds'
+
+module AGCOD
+  class GetAvailableFunds
+    extend Forwardable
+
+    def initialize(httpable, partner_id)
+      @response = Request.new(httpable, 'GetAvailableFunds',
+        'partnerId' => partner_id,
+      ).response
+    end
+
+    def available_funds
+      @response.payload['availableFunds'].map { |payload| AGCOD::AvailableFunds.new(payload) }
+    end
+
+    def timestamp
+      Time.parse(@response.payload['timestamp'])
+    end
+
+    def status
+      @response.payload['status']
+    end
+
+    def success?
+      @response.payload['status'] == 'SUCCESS'
+    end
+  end
+end

data/lib/aws_agcod/gift_card_activity_list.rb

@@ -0,0 +1,54 @@
+require "aws_agcod/request"
+
+module AGCOD
+  class GiftCardActivityListError < StandardError; end
+
+  class GiftCardActivity
+    attr_reader :status, :created_at, :type, :card_number, :amount, :error_code,
+                :gc_id, :partner_id, :request_id
+
+    def initialize(payload)
+      @payload = payload
+      @status = payload["activityStatus"]
+      @created_at = payload["activityTime"]
+      @type = payload["activityType"]
+      @card_number = payload["cardNumber"]
+      @amount = payload["cardValue"]["amount"] if payload["cardValue"]
+      @error_code = payload["failureCode"]
+      @gc_id = payload["gcId"]
+      @partner_id = payload["partnerId"]
+      @request_id = payload["requestId"]
+    end
+
+    def is_real?
+      @payload["isRealOp"] == "true"
+    end
+  end
+
+  class GiftCardActivityList
+    extend Forwardable
+
+    LIMIT = 1000 # limit per request
+    TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+    def_delegators :@response, :success?, :error_message
+
+    def initialize(httpable, request_id, start_time, end_time, page = 1, per_page = 100, show_no_ops = false)
+      raise GiftCardActivityListError, "Only #{LIMIT} records allowed per request." if per_page > LIMIT
+
+      @response = Request.new(httpable,"GetGiftCardActivityPage",
+        "requestId" => request_id,
+        "utcStartDate" => start_time.strftime(TIME_FORMAT),
+        "utcEndDate" => end_time.strftime(TIME_FORMAT),
+        "pageIndex" => (page - 1) * per_page,
+        "pageSize" => per_page,
+        "showNoOps" => show_no_ops
+      ).response
+    end
+
+    def results
+      @response.payload["cardActivityList"].map { |payload| GiftCardActivity.new(payload) }
+    end
+  end
+end
+

data/lib/aws_agcod/request.rb

@@ -0,0 +1,61 @@
+require "aws_agcod/signature"
+require "aws_agcod/response"
+require "http"
+require "yaml"
+
+module AGCOD
+  class Request
+    TIME_FORMAT = "%Y%m%dT%H%M%SZ"
+    MOCK_REQUEST_IDS = %w(F0000 F2005)
+
+    attr_reader :response
+
+    def initialize(httpable, action, params) # httpable is anything that can have post called upon it; this allows passing in a proxy
+      @action = action
+      @params = sanitized_params(params)
+
+      @response = Response.new(httpable.post(uri, body: body, headers: signed_headers).body)
+    end
+
+    private
+
+    def signed_headers
+      time = Time.now.utc
+
+      headers = {
+        "content-type" => "application/json",
+        "x-amz-date" => time.strftime(TIME_FORMAT),
+        "accept" => "application/json",
+        "host" => uri.host,
+        "x-amz-target" => "com.amazonaws.agcod.AGCODService.#{@action}",
+        "date" => time.to_s
+      }
+
+      Signature.new(AGCOD.config).sign(uri, headers, body)
+    end
+
+    def uri
+      @uri ||= URI("#{AGCOD.config.uri}/#{@action}")
+    end
+
+    def body
+      @body ||= @params.merge(
+        "partnerId" => AGCOD.config.partner_id
+      ).to_json
+    end
+
+    def sanitized_params(params)
+      # Prefix partner_id when it's not given as part of request_id for creationRequestId and it's not a mock request_id
+      if params["creationRequestId"] && !(params["creationRequestId"] =~ /#{AGCOD.config.partner_id}/) && !(MOCK_REQUEST_IDS.member?(params["creationRequestId"]))
+        params["creationRequestId"] = "#{AGCOD.config.partner_id}#{params["creationRequestId"]}"
+      end
+
+      # Remove partner_id when it's prefixed in requestId
+      if params["requestId"] && !!(params["requestId"] =~ /^#{AGCOD.config.partner_id}/)
+        params["requestId"].sub!(/^#{AGCOD.config.partner_id}/, "")
+      end
+
+      params
+    end
+  end
+end

data/lib/aws_agcod/response.rb

@@ -0,0 +1,31 @@
+require "json"
+
+module AGCOD
+  class Response
+    attr_reader :status, :payload
+
+    def initialize(raw_json)
+      @payload = JSON.parse(raw_json)
+
+      # All status:
+      # SUCCESS -- Operation succeeded
+      # FAILURE -- Operation failed
+      # RESEND -- A temporary/recoverable system failure that can be resolved by the partner retrying the request
+      @status = if payload["status"]
+        payload["status"]
+      elsif payload["agcodResponse"]
+        payload["agcodResponse"]["status"]
+      else
+        "FAILURE"
+      end
+    end
+
+    def success?
+      status == "SUCCESS"
+    end
+
+    def error_message
+      "#{payload["errorCode"]} #{payload["errorType"]} - #{payload["message"]}"
+    end
+  end
+end

data/lib/aws_agcod/signature.rb

@@ -0,0 +1,95 @@
+# Currently AGCOD v2 uses v4 Signature for it's authentication,
+# this class generates signed headers for making proper request to AGCOD service.
+#
+# Based on https://github.com/ifeelgoods/aws4/blob/master/lib/aws4/signer.rb
+require "openssl"
+require "uri"
+require "pathname"
+
+module AGCOD
+  class Signature
+    SERVICE = "AGCODService"
+
+    def initialize(credentials)
+      @access_key = credentials.access_key
+      @secret_key = credentials.secret_key
+      @region = credentials.region || DEFAULT_REGION
+    end
+
+    def sign(uri, headers, body = "")
+      @uri = uri
+      @headers = headers
+      @body = body
+      @date = headers["x-amz-date"]
+
+      signed_headers = headers.dup
+      signed_headers["Authorization"] = authorization
+
+      signed_headers
+    end
+
+    private
+
+    def authorization
+      [
+        "AWS4-HMAC-SHA256 Credential=#{@access_key}/#{credential_string}",
+        "SignedHeaders=#{@headers.keys.map(&:downcase).sort.join(";")}",
+        "Signature=#{signature}"
+      ].join(", ")
+    end
+
+    # Reference http://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html
+    def signature
+      k_date = hmac("AWS4" + @secret_key, @date[0, 8])
+      k_region = hmac(k_date, @region)
+      k_service = hmac(k_region, SERVICE)
+      k_credentials = hmac(k_service, "aws4_request")
+      hexhmac(k_credentials, string_to_sign)
+    end
+
+    # Reference http://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html
+    def string_to_sign
+      @string_to_sign ||= [
+        "AWS4-HMAC-SHA256", # Algorithm
+        @date, # RequestDate
+        credential_string, # CredentialScope
+        hexdigest(canonical_request) # HashedCanonicalRequest
+      ].join("\n")
+    end
+
+    def credential_string
+      @credential_string ||= [@date[0, 8], @region, SERVICE, "aws4_request"].join("/")
+    end
+
+    # Reference http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+    def canonical_request
+      @canonical_request ||= [
+        "POST", # HTTPRequestMethod
+        Pathname.new(@uri.path).cleanpath.to_s, # CanonicalURI
+        @uri.query, # CanonicalQueryString
+        @headers.sort.map { |k, v| [k.downcase, v.strip].join(":") }.join("\n") + "\n", # CanonicalHeaders
+        @headers.sort.map { |k, v| k.downcase }.join(";"), # SignedHeaders
+        hexdigest(@body) # HexEncode(Hash(RequestPayload))
+      ].join("\n")
+    end
+
+    # Hexdigest simply produces an ascii safe way
+    # to view the bytes produced from the hash algorithm.
+    # It takes the hex representation of each byte
+    # and concatenates them together to produce a string
+    def hexdigest(value)
+      Digest::SHA256.new.update(value).hexdigest
+    end
+
+    # Hash-based message authentication code (HMAC)
+    # is a mechanism for calculating a message authentication code
+    # involving a hash function in combination with a secret key
+    def hmac(key, value)
+      OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), key, value)
+    end
+
+    def hexhmac(key, value)
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), key, value)
+    end
+  end
+end

data/lib/aws_agcod/version.rb

@@ -0,0 +1,3 @@
+module AGCOD
+  VERSION = "1.1.0"
+end

data/spec/aws_agcod/cancel_gift_card_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "aws_agcod/cancel_gift_card"
+
+describe AGCOD::CancelGiftCard do
+  let(:partner_id) { "Testa" }
+  let(:response) { spy }
+  let(:httpable) { HTTP }
+
+  before do
+    AGCOD.configure do |config|
+      config.partner_id = partner_id
+    end
+  end
+
+  context ".new" do
+    let(:request_id) { "test1" }
+    let(:gc_id) { "FOO" }
+
+    it "makes cancel request" do
+      expect(AGCOD::Request).to receive(:new) do |_, action, params|
+        expect(action).to eq("CancelGiftCard")
+        expect(params["creationRequestId"]).to eq(request_id)
+        expect(params["gcId"]).to eq(gc_id)
+      end.and_return(response)
+
+      AGCOD::CancelGiftCard.new(httpable, request_id, gc_id)
+    end
+  end
+
+  shared_context "request with response" do
+    let(:gc_id) { "BAR" }
+    let(:creation_request_id) { "BAZ" }
+    let(:status) { "SUCCESS" }
+    let(:request) { AGCOD::CancelGiftCard.new(httpable, creation_request_id, gc_id) }
+
+    before do
+      allow(AGCOD::Request).to receive(:new) { double(response: response) }
+      allow(response).to receive(:status) { status }
+    end
+  end
+
+  context "#status" do
+    include_context "request with response"
+
+    it "returns the response status" do
+      expect(request.status).to eq(status)
+    end
+  end
+end

data/spec/aws_agcod/config_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "aws_agcod/config"
+
+describe AGCOD::Config do
+  let(:config) { AGCOD::Config.new }
+
+  context ".new" do
+    it "sets default uri and region" do
+      expect(config.uri).not_to be_nil
+      expect(config.region).not_to be_nil
+      expect(config.production).to eq(false)
+    end
+  end
+
+  context "#uri" do
+    context "when uri is set" do
+      before do
+        config.uri = "https://custom-uri.example.com"
+      end
+
+      it "returns the custom uri" do
+        expect(config.uri).to eq("https://custom-uri.example.com")
+      end
+    end
+
+    context "when uri is not set" do
+      context "when production is enabled" do
+        before do
+          config.production = true
+        end
+
+        it "returns the production uri" do
+          expect(config.uri).to eq(AGCOD::Config::URI[:production])
+        end
+      end
+
+      context "when production is disabled" do
+        it "returns the sandbox uri" do
+          expect(config.uri).to eq(AGCOD::Config::URI[:sandbox])
+        end
+      end
+    end
+  end
+end

data/spec/aws_agcod/create_gift_card_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+require "aws_agcod/create_gift_card"
+
+describe AGCOD::CreateGiftCard do
+  let(:partner_id) { "Testa" }
+  let(:request_id) { "test1" }
+  let(:amount) { 10 }
+  let(:currency) { AGCOD::CreateGiftCard::CURRENCIES.first }
+  let(:response) { spy }
+  let(:httpable) { HTTP }
+
+  before do
+    AGCOD.configure do |config|
+      config.partner_id = partner_id
+    end
+  end
+
+  context ".new" do
+    context "when currency available" do
+      it "makes create request" do
+        expect(AGCOD::Request).to receive(:new) do |httpable, action, params|
+          expect(httpable).to eq(HTTP)
+          expect(action).to eq("CreateGiftCard")
+          expect(params["creationRequestId"]).to eq(request_id)
+          expect(params["value"]).to eq(
+            "currencyCode" => currency,
+            "amount" => amount
+          )
+        end.and_return(response)
+
+        AGCOD::CreateGiftCard.new(httpable, request_id, amount, currency)
+      end
+    end
+
+    context "when currency not available" do
+      let(:currency) { "NOTEXIST" }
+
+      it "raises error" do
+        expect {
+          AGCOD::CreateGiftCard.new(httpable, request_id, amount, currency)
+        }.to raise_error(
+          AGCOD::CreateGiftCardError,
+          "Currency #{currency} not supported, available types are #{AGCOD::CreateGiftCard::CURRENCIES.join(", ")}"
+        )
+      end
+    end
+  end
+
+  shared_context "request with response" do
+    let(:claim_code) { "FOO" }
+    let(:expiration_date) { "Wed Mar 12 22:59:59 UTC 2025" }
+    let(:gc_id) { "BAR" }
+    let(:creation_request_id) { "BAZ" }
+    let(:status) { "SUCCESS" }
+    let(:payload) { {"gcClaimCode" => claim_code, "gcId" => gc_id, "creationRequestId" => creation_request_id, "gcExpirationDate" => expiration_date} }
+    let(:request) { AGCOD::CreateGiftCard.new(httpable, request_id, amount, currency) }
+
+    before do
+      allow(AGCOD::Request).to receive(:new) { double(response: response) }
+      allow(response).to receive(:payload) { payload }
+      allow(response).to receive(:status) { status }
+    end
+  end
+
+  context "#claim_code" do
+    include_context "request with response"
+
+    it "returns claim_code" do
+      expect(request.claim_code).to eq(claim_code)
+    end
+  end
+
+  context "#expiration_date" do
+    include_context "request with response"
+
+    it "returns expiration_date" do
+      expect(request.expiration_date).to eq(Time.parse expiration_date)
+    end
+  end
+
+  context "#gc_id" do
+    include_context "request with response"
+
+    it "returns gc_id" do
+      expect(request.gc_id).to eq(gc_id)
+    end
+  end
+
+  context "#request_id" do
+    include_context "request with response"
+
+    it "returns creation request_id" do
+      expect(request.request_id).to eq(creation_request_id)
+    end
+  end
+
+  context "#status" do
+    include_context "request with response"
+
+    it "returns the response status" do
+      expect(request.status).to eq(status)
+    end
+  end
+end

data/spec/aws_agcod/get_available_funds_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'aws_agcod/get_available_funds'
+require 'ostruct'
+
+describe AGCOD::GetAvailableFunds do
+  let(:partner_id) { 'Testa' }
+  let(:currency) { AGCOD::CreateGiftCard::CURRENCIES.first }
+  let(:httpable) { HTTP }
+  let(:timestamp) { '20180323T233815Z' }
+  let(:status) { 'SUCCESS' }
+  let(:currency_code) { 'USD' }
+  let(:amount) { 0.0 }
+  OpenStruct.new(
+    first_name: OpenStruct.new({
+      primary: OpenStruct.new({
+        first_name: 'Albus',
+      }),
+    }),
+  )
+  let(:payload) { { "availableFunds" => { "amount" => amount, "currencyCode" => currency_code }, "status" => status, "timestamp" => timestamp } }
+
+  let(:request_response) {
+    OpenStruct.new(response:
+      OpenStruct.new(payload:
+        {
+          "availableFunds" => [
+            {
+              "amount" => amount,
+              "currencyCode" => currency_code
+            }
+          ],
+          "status" => status,
+          "timestamp" => timestamp
+        }
+      )
+    )
+  }
+
+  subject { described_class.new(httpable, partner_id) }
+
+  before do
+    AGCOD.configure do |config|
+      config.partner_id = partner_id
+    end
+  end
+
+  context '.new' do
+    it 'makes request' do
+      expect(AGCOD::Request).to receive(:new) do |httpable, action, params|
+        expect(httpable).to eq(HTTP)
+        expect(action).to eq('GetAvailableFunds')
+        expect(params['partnerId']).to eq(partner_id)
+      end.and_return(request_response)
+
+      expect(subject.available_funds.first.currency_code).to eq currency
+      expect(subject.available_funds.first.amount).to eq amount
+      expect(subject.timestamp).to eq Time.parse(timestamp)
+      expect(subject.status).to eq status
+      expect(subject.success?).to eq true
+    end
+  end
+end

data/spec/aws_agcod/gift_card_activity_list_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require "aws_agcod/gift_card_activity_list"
+
+describe AGCOD::GiftCardActivityList do
+  let(:partner_id) { "Testa" }
+  let(:request_id) { "test1" }
+  let(:start_time) { double("start_time") }
+  let(:end_time) { double("end_time") }
+  let(:page) { 1 }
+  let(:per_page) { AGCOD::GiftCardActivityList::LIMIT }
+  let(:show_no_ops) { true }
+  let(:response) { spy }
+  let(:httpable) { HTTP }
+
+  before do
+    AGCOD.configure do |config|
+      config.partner_id = partner_id
+    end
+  end
+
+  context ".new" do
+    it "makes request" do
+      expect(start_time).to receive(:strftime).with(
+        AGCOD::GiftCardActivityList::TIME_FORMAT
+      ).and_return(start_time)
+
+      expect(end_time).to receive(:strftime).with(
+        AGCOD::GiftCardActivityList::TIME_FORMAT
+      ).and_return(end_time)
+
+      expect(AGCOD::Request).to receive(:new) do |_, action, params|
+        expect(action).to eq("GetGiftCardActivityPage")
+        expect(params["requestId"]).to eq(request_id)
+        expect(params["utcStartDate"]).to eq(start_time)
+        expect(params["utcEndDate"]).to eq(end_time)
+        expect(params["pageIndex"]).to eq((page - 1) * per_page)
+        expect(params["pageSize"]).to eq(per_page)
+        expect(params["showNoOps"]).to eq(show_no_ops)
+      end.and_return(response)
+
+      AGCOD::GiftCardActivityList.new(httpable, request_id, start_time, end_time, page, per_page, show_no_ops)
+    end
+
+    context "when request per_page reaches limit" do
+      let(:per_page) { AGCOD::GiftCardActivityList::LIMIT + 1 }
+
+      it "raises error" do
+        expect {
+          AGCOD::GiftCardActivityList.new(httpable, request_id, start_time, end_time, page, per_page, show_no_ops)
+        }.to raise_error(
+          AGCOD::GiftCardActivityListError,
+          "Only #{AGCOD::GiftCardActivityList::LIMIT} records allowed per request."
+        )
+      end
+    end
+  end
+
+  context "#results" do
+    let(:payload) { { "cardActivityList" => [spy] } }
+    let(:request) { AGCOD::GiftCardActivityList.new(httpable, request_id, start_time, end_time, page, per_page, show_no_ops) }
+
+    before do
+      allow(start_time).to receive(:strftime)
+      allow(end_time).to receive(:strftime)
+      allow(AGCOD::Request).to receive(:new) { double(response: response) }
+      allow(response).to receive(:payload) { payload }
+    end
+
+    it "returns GiftCardActivity instances" do
+      request.results.each do |item|
+        expect(item).to be_a(AGCOD::GiftCardActivity)
+      end
+    end
+  end
+end

data/spec/aws_agcod/request_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require "aws_agcod/request"
+
+describe AGCOD::Request do
+  let(:action) { "Foo" }
+  let(:params) { {} }
+  let(:signature) { double("Signature") }
+  let(:signed_headers) { double("signed_headers") }
+  let(:base_uri) { "https://example.com" }
+  let(:partner_id) { "BAR" }
+  let(:config) { double(uri: base_uri, partner_id: partner_id) }
+  let(:httpable) { HTTP }
+
+  context "#new" do
+    before do
+      allow(AGCOD).to receive(:config) { config }
+      allow(AGCOD::Signature).to receive(:new).with(config) { signature }
+    end
+
+    context "with creationRequestId as special testing value" do
+      let(:params) { { creationRequestId: creationRequestId } }
+
+      subject { AGCOD::Request.new(httpable, action, params) }
+
+      before do
+        allow(signature).to receive(:sign).and_return(signed_headers)
+      end
+
+      context "with special creationRequestId F0000" do
+        let(:creationRequestId) { "F0000" }
+
+        it "does not add partnerId to creationRequestId" do
+          expect(HTTP).to receive(:post) do |_, options|
+            expect(JSON.parse(options[:body])["creationRequestId"]).to eq("F0000")
+          end.and_return(double(body: params.to_json))
+          subject
+        end
+      end
+
+      context "with special creationRequestId F2005" do
+        let(:creationRequestId) { "F2005" }
+
+        it "does not add partnerId to creationRequestId" do
+          expect(HTTP).to receive(:post) do |_, options|
+            expect(JSON.parse(options[:body])["creationRequestId"]).to eq("F2005")
+          end.and_return(double(body: params.to_json))
+          subject
+        end
+      end
+    end
+
+    it "sends post request to endpoint uri" do
+      expect(signature).to receive(:sign) do |uri, headers, body|
+        expect(uri).to eq(URI("#{base_uri}/#{action}"))
+        expect(headers.keys).to match_array(%w(content-type x-amz-date accept host x-amz-target date))
+        expect(headers["content-type"]).to eq("application/json")
+        expect(headers["x-amz-target"]).to eq("com.amazonaws.agcod.AGCODService.#{action}")
+        expect(JSON.parse(body)["partnerId"]).to eq(partner_id)
+      end.and_return(signed_headers)
+
+      expect(HTTP).to receive(:post) do |uri, options|
+        expect(uri).to eq(URI("#{base_uri}/#{action}"))
+        expect(JSON.parse(options[:body])["partnerId"]).to eq(partner_id)
+        expect(options[:headers]).to eq(signed_headers)
+      end.and_return(double(body: params.to_json))
+
+      AGCOD::Request.new(httpable, action, params)
+    end
+
+    it "sets response" do
+      expect(signature).to receive(:sign) { signed_headers }
+      expect(HTTP).to receive(:post) { (double(body: params.to_json)) }
+
+      response = AGCOD::Request.new(httpable, action, params).response
+
+      expect(response).to be_a(AGCOD::Response)
+    end
+  end
+end

data/spec/aws_agcod/response_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "aws_agcod/response"
+
+describe AGCOD::Response do
+  let(:payload) { { foo: "bar" }.to_json }
+
+  context "#new" do
+    it "sets payload and status" do
+      response = AGCOD::Response.new(payload)
+
+      expect(response.payload).not_to be_nil
+      expect(response.status).not_to be_nil
+    end
+
+    context "when no status in payload" do
+      it "sets status to failure" do
+        expect(AGCOD::Response.new(payload).status).to eq("FAILURE")
+      end
+    end
+
+    context "when has status in payload" do
+      let(:status) { "foo" }
+      let(:payload) { { status: status }.to_json }
+
+      it "sets status as payload's status" do
+        expect(AGCOD::Response.new(payload).status).to eq(status)
+      end
+    end
+
+    context "when has agcodResponse in payload" do
+      let(:status) { "foo" }
+      let(:payload) { { agcodResponse: { status: status } }.to_json }
+
+      it "sets status as agcodResponse's status" do
+        expect(AGCOD::Response.new(payload).status).to eq(status)
+      end
+    end
+  end
+
+  context "success?" do
+    context "when status is SUCCESS" do
+      let(:payload) { { status: "SUCCESS" }.to_json }
+
+      it "returns true" do
+        expect(AGCOD::Response.new(payload).success?).to be_truthy
+      end
+    end
+
+    context "when status is not SUCCESS" do
+      it "returns false" do
+        expect(AGCOD::Response.new(payload).success?).to be_falsey
+      end
+    end
+  end
+
+  context "error_message" do
+    let(:error_code) { "foo" }
+    let(:error_type) { "bar" }
+    let(:error_message) { "baz" }
+    let(:payload) { { errorCode: error_code, errorType: error_type, message: error_message }.to_json }
+
+    it "composes error message by error code, type, and message from payload" do
+      expect(AGCOD::Response.new(payload).error_message).to eq("#{error_code} #{error_type} - #{error_message}")
+    end
+  end
+end

data/spec/aws_agcod_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "aws_agcod"
+
+describe AGCOD do
+  context ".configure" do
+    it "yields config" do
+      AGCOD.configure do |config|
+        expect(config).to be_an_instance_of(AGCOD::Config)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require "pathname"
+require "http"
+
+ROOT_PATH = Pathname.new(__FILE__).join("../..").expand_path
+$LOAD_PATH.unshift(ROOT_PATH.join("lib"))
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  # Disable the should syntax compeletely; we use the expect syntax only.
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: aws_agcod_2
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Xenor Chang
+- compwron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: |-
+  Amazon Gift Code On Demand (AGCOD) API v2 implementation for
+                            distribute Amazon gift cards (gift codes) instantly in any denomination
+email:
+- xenor@listia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/aws_agcod.rb
+- lib/aws_agcod/available_funds.rb
+- lib/aws_agcod/cancel_gift_card.rb
+- lib/aws_agcod/config.rb
+- lib/aws_agcod/create_gift_card.rb
+- lib/aws_agcod/get_available_funds.rb
+- lib/aws_agcod/gift_card_activity_list.rb
+- lib/aws_agcod/request.rb
+- lib/aws_agcod/response.rb
+- lib/aws_agcod/signature.rb
+- lib/aws_agcod/version.rb
+- spec/aws_agcod/cancel_gift_card_spec.rb
+- spec/aws_agcod/config_spec.rb
+- spec/aws_agcod/create_gift_card_spec.rb
+- spec/aws_agcod/get_available_funds_spec.rb
+- spec/aws_agcod/gift_card_activity_list_spec.rb
+- spec/aws_agcod/request_spec.rb
+- spec/aws_agcod/response_spec.rb
+- spec/aws_agcod_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/compwron/aws_agcod
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: AWS AGCOD API v2 endpoints implementation
+test_files:
+- spec/aws_agcod/cancel_gift_card_spec.rb
+- spec/aws_agcod/config_spec.rb
+- spec/aws_agcod/create_gift_card_spec.rb
+- spec/aws_agcod/get_available_funds_spec.rb
+- spec/aws_agcod/gift_card_activity_list_spec.rb
+- spec/aws_agcod/request_spec.rb
+- spec/aws_agcod/response_spec.rb
+- spec/aws_agcod_spec.rb
+- spec/spec_helper.rb