click_and_send 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/fixtures/config.yml
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+script: bundle exec rspec -t '~@acceptance' spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in click_and_send.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Zubin Henner
+
+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,41 @@
+# ClickAndSend
+
+Ruby adapter for Australia Post's [ClickAndSend](http://www.clickandsend.com.au/) API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'click_and_send'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install click_and_send
+
+## Usage
+
+Configure like this:
+
+    ClickAndSend.configure do |c|
+      c.account_number = '1234567'
+      c.api_key = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+      c.user_name = 'acme'
+      c.wsdl = 'https://auspost-staging.oss.neopost-id.com/modules/oss/api/ship/wsdl?sz_Client=AustraliaPost'
+    end
+
+Note that the WSDL URL above is for ClickAndSend's staging environment.
+
+You should only need to call methods on the `ClickAndSend` class.
+Refer to the docs and acceptance tests for usage examples.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/click_and_send.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/click_and_send/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Zubin Henner"]
+  gem.email         = ["zubin.henner@gmail.com"]
+  gem.description   = %q{Ruby adapter for Australia Post's ClickAndSend API}
+  gem.summary       = %q{Ruby adapter for Australia Post's ClickAndSend API}
+  gem.homepage      = "https://github.com/zubin/click_and_send"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "click_and_send"
+  gem.require_paths = ["lib"]
+  gem.version       = ClickAndSend::VERSION
+
+  gem.add_dependency 'nori'
+  gem.add_dependency 'savon'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'faker'
+  gem.add_development_dependency 'pry'
+end

data/lib/click_and_send.rb

@@ -0,0 +1,92 @@
+require 'click_and_send/version'
+require 'click_and_send/configuration'
+require 'click_and_send/encryption'
+require 'click_and_send/errors'
+require 'click_and_send/request'
+require 'click_and_send/request/check_services'
+require 'click_and_send/request/create_items'
+require 'click_and_send/request/delete_items'
+require 'click_and_send/request/item_summary'
+require 'click_and_send/request/print_item'
+require 'click_and_send/xml'
+
+module ClickAndSend
+  class << self
+    attr_accessor :configuration
+
+    # Example use:
+    #
+    #     ClickAndSend.configure do |c|
+    #       c.account_number = '1234567'
+    #       c.api_key = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+    #       c.user_name = 'acme'
+    #       c.wsdl = 'https://auspost-staging.oss.neopost-id.com/modules/oss/api/ship/wsdl?sz_Client=AustraliaPost'
+    #     end
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def check_services(options)
+      ensure_keys_present(options, %w(Sender Receiver ItemDetails))
+      Request::CheckServices.new(options).result.fetch(:product_found)
+    end
+
+    def create_items(options)
+      ensure_keys_present(options, %w(Transactions))
+      Request::CreateItems.new(options).result.fetch(:item_created)
+    end
+
+    def delete_items_by_ref(refs)
+      items = find_tracking_numbers(refs).inject([]) do |carrier, (ref, tracking_numbers)|
+        tracking_numbers.each { |t| carrier << {'DeleteItem' => {'CustTransactionID' => ref, 'TrackingNumber' => t}} }
+        carrier
+      end
+      delete_items('DeleteItems' => items)
+    end
+
+    def delete_items(options)
+      ensure_keys_present(options, %w(DeleteItems))
+      Request::DeleteItems.new(options).result
+    end
+
+    def find_tracking_numbers(refs)
+      item_summary.inject({}) do |hash,item|
+        if refs.include?(item[:cust_transaction_id])
+          hash[item[:cust_transaction_id]] ||= []
+          hash[item[:cust_transaction_id]] << item[:tracking_number]
+        end
+        hash
+      end
+    end
+
+    def item_summary
+      Request::ItemSummary.new.result.fetch(:item_summary_transaction)
+    end
+
+    def pdf_url(ref)
+      tracking_numbers = find_tracking_numbers([ref]).fetch(ref)
+      case tracking_numbers.length
+      when 0 then raise(Errors::APIError, "Not found: '#{ref}'")
+      when 1 then tracking_number = tracking_numbers.first
+      else
+        raise(Errors::APIError, "Expected 1 but found #{tracking_numbers.length} tracking numbers for 'REF': #{tracking_numbers.join(', ')}")
+      end
+      options = {
+        'PrintFormat' => 'LINK',
+        'CustTransactionID' => ref,
+        'TrackingNumber' => tracking_number
+      }
+      Request::PrintItem.new(options).result
+    end
+
+    private
+
+    def ensure_keys_present(hash, required_keys)
+      missing_keys = required_keys - hash.keys
+      if missing_keys.any?
+        raise(Errors::InvalidInput, "Missing: #{missing_keys.join(', ')}")
+      end
+    end
+  end
+end

data/lib/click_and_send/configuration.rb

@@ -0,0 +1,18 @@
+module ClickAndSend
+  class Configuration
+    ATTRIBUTES = [:account_number, :api_version, :api_key, :user_name, :wsdl]
+    attr_accessor *ATTRIBUTES
+
+    def initialize
+      @api_version = 10
+    end
+
+    def errors
+      Hash[ATTRIBUTES.collect { |attribute| [attribute, ("is required" if send(attribute).nil?)] }]
+    end
+
+    def valid?
+      errors.values.compact.empty?
+    end
+  end
+end

data/lib/click_and_send/encryption.rb

@@ -0,0 +1,44 @@
+require 'base64'
+require 'openssl'
+
+module ClickAndSend
+  class Encryption
+    def initialize(data)
+      @data = data
+    end
+
+    def to_s
+      Base64.encode64(encrypted).chomp.gsub(/\={1,2}$/, '') unless @data.nil?
+    end
+
+    private
+
+    def cipher
+      @cipher ||= begin
+        cipher = OpenSSL::Cipher::Cipher.new(cipher_type)
+        cipher.encrypt
+        cipher.key = key
+        cipher.iv = key[0..15]
+        cipher
+      end
+    end
+
+    def cipher_type
+      'AES-256-CBC'
+    end
+
+    def encrypted
+      cipher.update(padded_data)
+    end
+
+    def key
+      ClickAndSend.configuration.api_key
+    end
+
+    # Data must be padded to nearest multiple of 16
+    def padded_data
+      desired_length = (@data.length.to_f / 16).ceil * 16
+      @data.ljust(desired_length, ' ')
+    end
+  end
+end

data/lib/click_and_send/errors.rb

@@ -0,0 +1,6 @@
+module ClickAndSend::Errors
+  class APIError < StandardError; end
+  class InvalidConfiguration < StandardError; end
+  class InvalidInput < StandardError; end
+  class NotImplemented < StandardError; end
+end

data/lib/click_and_send/request.rb

@@ -0,0 +1,100 @@
+require 'nori'
+require 'savon'
+
+module ClickAndSend
+  module Request
+    attr_accessor :data
+
+    def initialize(data = {})
+      self.data = data
+    end
+
+    def result
+      raise_on_error
+      response.fetch(key(:result))
+    end
+
+    private
+
+    def client
+      raise ClickAndSend::Errors::InvalidConfiguration unless config.valid?
+      @client ||= Savon.client do |wsdl, http|
+        wsdl.document = config.wsdl
+        http.auth.ssl.verify_mode = :none
+      end
+    end
+
+    def config
+      ClickAndSend.configuration
+    end
+
+    def encrypt(data)
+      ClickAndSend::Encryption.new(data).to_s
+    end
+
+    def errors
+      response.values_at(*key(:errors)).compact
+    end
+
+    def errors?
+      errors.any?
+    end
+
+    def default_keys
+      { :errors => [:item_errors, :errors_found] }
+    end
+
+    def extra_request_xml
+      ClickAndSend::XML.new(data).to_xml if data
+    end
+
+    def header
+      <<-XML
+      <Header>
+        <CnSUserName>#{encrypt(config.user_name)}</CnSUserName>
+        <APIAccessKey>#{encrypt(config.api_key)}</APIAccessKey>
+        <RequestDate>#{encrypt(request_date)}</RequestDate>
+        <APIVersion>#{config.api_version}</APIVersion>
+      </Header>
+      XML
+    end
+
+    def key(name)
+      default_keys.merge(keys).fetch(name)
+    end
+
+    # Hash with keys :answer, :request, :response, :result
+    def keys
+      raise(ClickAndSend::Errors::NotImplemented, "#{klass_name}#keys")
+    end
+
+    def klass_name
+      self.class.name
+    end
+
+    def raise_on_error
+      raise(ClickAndSend::Errors::APIError, errors) if errors?
+    end
+
+    def request_date
+      Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+    end
+
+    def request_xml
+      "<#{key(:request)}Request>%s</#{key(:request)}Request>" % CGI::escapeHTML(<<-XML.strip.gsub(/\n\s+/, "\n"))
+        <#{key(:request)}>
+        #{header}
+        #{extra_request_xml}
+        </#{key(:request)}>
+      XML
+    end
+
+    def response
+      @response ||= Nori.parse(request.to_hash[key(:response)][key(:response)]).fetch(key(:answer))
+    end
+
+    def request
+      client.request(:ind, key(:request), :body => request_xml)
+    end
+  end
+end

data/lib/click_and_send/request/check_services.rb

@@ -0,0 +1,16 @@
+module ClickAndSend
+  module Request
+    class CheckServices
+      include ClickAndSend::Request
+
+      private
+
+      def keys
+        { :answer   => :ws_check_services_answer,
+          :request  => 'WSCheckServices',
+          :response => :ws_check_services_response,
+          :result   => :products_found }
+      end
+    end
+  end
+end

data/lib/click_and_send/request/create_items.rb

@@ -0,0 +1,16 @@
+module ClickAndSend
+  module Request
+    class CreateItems
+      include ClickAndSend::Request
+
+      private
+
+      def keys
+        { :answer   => :ws_create_items_answer,
+          :request  => 'WSCreateItems',
+          :response => :ws_create_items_response,
+          :result   => :items_created }
+      end
+    end
+  end
+end

data/lib/click_and_send/request/delete_items.rb

@@ -0,0 +1,16 @@
+module ClickAndSend
+  module Request
+    class DeleteItems
+      include ClickAndSend::Request
+
+      private
+
+      def keys
+        { :answer   => :ws_delete_items_answer,
+          :request  => 'WSDeleteItems',
+          :response => :ws_delete_items_response,
+          :result   => :delete_items }
+      end
+    end
+  end
+end

data/lib/click_and_send/request/item_summary.rb

@@ -0,0 +1,16 @@
+module ClickAndSend
+  module Request
+    class ItemSummary
+      include ClickAndSend::Request
+
+      private
+
+      def keys
+        { :answer   => :ws_item_summary_answer,
+          :request  => 'WSItemSummary',
+          :response => :ws_item_summary_response,
+          :result   => :item_summary_transactions }
+      end
+    end
+  end
+end

data/lib/click_and_send/request/print_item.rb

@@ -0,0 +1,16 @@
+module ClickAndSend
+  module Request
+    class PrintItem
+      include ClickAndSend::Request
+
+      private
+
+      def keys
+        { :answer   => :ws_print_item_answer,
+          :request  => 'WSPrintItem',
+          :response => :ws_print_item_response,
+          :result   => :label_http_link }
+      end
+    end
+  end
+end

data/lib/click_and_send/version.rb

@@ -0,0 +1,3 @@
+module ClickAndSend
+  VERSION = '0.0.2'
+end

data/lib/click_and_send/xml.rb

@@ -0,0 +1,11 @@
+module ClickAndSend
+  class XML
+    def initialize(input)
+      @input = input
+    end
+
+    def to_xml
+      Gyoku.xml(@input)
+    end
+  end
+end

data/spec/acceptance_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe ClickAndSend, :acceptance do
+  let(:item_details) {  }
+  before { load_config(:acceptance) }
+
+  describe '.check_services' do
+    subject { ClickAndSend.check_services(attributes_for(%w(Sender Receiver ItemDetails))) }
+    specify { should be_a(Array) }
+  end
+
+  describe '.create_items' do
+    subject { ClickAndSend.create_items(options) }
+
+    context "when one transaction" do
+      let(:options) { {'Transactions' => attributes_for('Transaction')} }
+      specify { should be_a(Hash) }
+    end
+
+    context "when two transactions" do
+      let(:options) { attributes_for('Transactions') }
+      specify { should be_a(Array) }
+    end
+  end
+
+  context "when item uploaded" do
+    let(:create_item_attributes) { attributes_for('Transaction') }
+    let(:ref) { create_item_attributes.values.first.fetch('CustTransactionID') }
+    before { ClickAndSend.create_items('Transactions' => create_item_attributes) }
+
+    describe '.find_tracking_numbers' do
+      subject { ClickAndSend.find_tracking_numbers([ref]) }
+      specify do
+        should be_a(Hash)
+        subject.keys.should == [ref]
+      end
+    end
+
+    describe '.pdf_url' do
+      subject { ClickAndSend.pdf_url(ref) }
+      specify do
+        subject.should be_a(String)
+        open(subject).content_type.should == 'application/pdf'
+      end
+    end
+
+    describe '.delete_items_by_ref' do
+      specify do
+        expect do
+          ClickAndSend.delete_items_by_ref([ref])
+        end.to change { ClickAndSend.find_tracking_numbers([ref]).empty? }.to(true)
+      end
+    end
+
+    describe '.delete_items' do
+      let(:items) do
+        tracking_numbers.collect do |tracking_number|
+          {'DeleteItem' => {'CustTransactionID' => ref, 'TrackingNumber' => tracking_number}}
+        end
+      end
+      let(:tracking_numbers) { ClickAndSend.find_tracking_numbers([ref]).fetch(ref) }
+      specify do
+        expect do
+          ClickAndSend.delete_items('DeleteItems' => items)
+        end.to change { ClickAndSend.find_tracking_numbers(ref).empty? }.to(true)
+      end
+    end
+  end
+
+  describe '.item_summary' do
+    subject { ClickAndSend.item_summary }
+    specify { should be_a(Array) }
+  end
+end

data/spec/click_and_send/request_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe ClickAndSend::Request do
+  subject { klass.new }
+  let(:klass) { Class.new.tap { |klass| klass.send(:include, ClickAndSend::Request) } }
+
+  describe '.new' do
+    it "defaults data to an empty hash" do
+      subject.data.should == {}
+    end
+
+    it "sets data" do
+      klass.new('foo').data.should == 'foo'
+    end
+  end
+
+  describe '#result' do
+    subject { klass.new(data).result }
+    let(:data) { stub(:data) }
+    before { load_config }
+
+    context "valid keys" do
+      let(:client) { stub(:client) }
+      let(:config) { ClickAndSend.configuration }
+      let(:expected_xml) do
+        "<WSSomethingRequest>%s</WSSomethingRequest>" % CGI::escapeHTML(<<-XML.strip.gsub(/\n\s+/, "\n"))
+          <WSSomething>
+          <Header>
+            <CnSUserName>encrypted_#{config.user_name}</CnSUserName>
+            <APIAccessKey>encrypted_#{config.api_key}</APIAccessKey>
+            <RequestDate>encrypted_#{Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')}</RequestDate>
+            <APIVersion>#{config.api_version}</APIVersion>
+          </Header>
+          <ExtraRequestXml></ExtraRequestXml>
+          </WSSomething>
+        XML
+      end
+      let(:parsed_response) { {:ws_something_answer => {:something_result => 'the result'}} }
+      let(:request) { stub.as_null_object }
+      before do
+        klass.send(:define_method, :keys) do
+          { :answer   => :ws_something_answer,
+            :request  => 'WSSomething',
+            :response => :ws_something_response,
+            :result   => :something_result }
+        end
+        Savon.stub(:client) { client }
+        ClickAndSend::Encryption.stub(:new) { |arg| stub(:to_s => "encrypted_#{arg}") }
+        ClickAndSend::XML.stub(:new).with(data) { stub(:to_xml => "<ExtraRequestXml></ExtraRequestXml>") }
+        client.stub(:request) { request }
+        Nori.stub(:parse).with(request.to_hash[:ws_something_response][:ws_something_response]) do
+          parsed_response
+        end
+        
+      end
+
+      it "calls service with :request key" do
+        client.should_receive(:request).with(:ind, 'WSSomething', :body => expected_xml)
+        subject
+      end
+
+      it "parses response" do
+        Nori.should_receive(:parse).with(request.to_hash[:ws_something_response][:ws_something_response])
+        subject
+      end
+
+      it "uses :response and :answer keys" do
+        request = stub.as_null_object
+        client.should_receive(:request) { request }
+        Nori.should_receive(:parse).with(request.to_hash[:ws_something_response][:ws_something_response])
+        subject.should == 'the result'
+      end
+
+      context "when error key present in response" do
+        let(:parsed_response) { {:ws_something_answer => {:errors_found => "Oops!"}} }
+        it "raises on API error" do
+          expect { subject }.to raise_error(ClickAndSend::Errors::APIError)
+        end
+      end
+    end
+
+    context "keys undefined" do
+      it "raises NotImplemented" do
+        expect { subject }.to raise_error(ClickAndSend::Errors::NotImplemented)
+      end
+    end
+
+    context "missing key" do
+      before { klass.send(:define_method, :keys) { {} } }
+      it "raises KeyError" do
+        expect { subject }.to raise_error(KeyError)
+      end
+    end
+  end
+end

data/spec/click_and_send/xml_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ClickAndSend::XML do
+  describe '#to_xml' do
+    subject { ClickAndSend::XML.new(input).to_xml }
+    context "hash" do
+      let(:input) { {:a => 1, "b" => 2} }
+      it { should == "<a>1</a><b>2</b>" }
+    end
+
+    context "nested hash" do
+      let(:input) { {:a => {:b => 2}} }
+      it { should == "<a><b>2</b></a>" }
+    end
+  end
+end

data/spec/click_and_send_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe ClickAndSend do
+  before { ClickAndSend.configuration = nil }
+
+  describe '.configuration' do
+    subject { ClickAndSend.configuration }
+
+    context "unconfigured" do
+      it { should be_nil }
+    end
+
+    context "configured" do
+      before { ClickAndSend.configure {} }
+      it { should be_a(ClickAndSend::Configuration) }
+      its(:api_version) { should == 10 }
+    end
+  end
+
+  describe '.configure' do
+    before { ClickAndSend.configure {} }
+
+    [:account_number, :api_key, :user_name, :wsdl].each do |attribute|
+      it "requires #{attribute}" do
+        expect do
+          ClickAndSend.configure { |c| c.send(:"#{attribute}=", "foo") }
+        end.to change { ClickAndSend.configuration.errors[attribute] }.to(nil)
+      end
+    end
+
+    context "unrecognised attribute" do
+      specify do
+        expect { ClickAndSend.configure { |c| c.foo = "bar" } }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  context "requests" do
+    describe '.check_services' do
+      subject { ClickAndSend.check_services(options) }
+      let(:required_inputs) { %w(Sender Receiver ItemDetails) }
+      it_behaves_like "data required"
+
+      context "when input has valid keys" do
+        let(:options) { {'Sender' => stub, 'Receiver' => stub, 'ItemDetails' => stub} }
+        it "fetches :product_found from CheckServices result" do
+          ClickAndSend::Request::CheckServices.should_receive(:new) { stub(:result => {:product_found => 'services'}) }
+          subject.should == 'services'
+        end
+      end
+    end
+
+    describe '.create_items' do
+      subject { ClickAndSend.create_items(options) }
+      let(:options) { {'Transactions' => stub} }
+      let(:required_inputs) { %w(Transactions) }
+      it_behaves_like "data required"
+      it "fetches :item_created from CreateItems result" do
+        ClickAndSend::Request::CreateItems.should_receive(:new) { stub(:result => {:item_created => 'created'}) }
+        subject.should == 'created'
+      end
+    end
+
+    describe '.delete_items_by_ref' do
+      subject { ClickAndSend.delete_items_by_ref(['my_ref']) }
+      it "calls delete_items with ref, tracking_number" do
+        ClickAndSend.stub(:find_tracking_numbers).with(['my_ref']) { {'my_ref' => ['t1', 't2']} }
+        ClickAndSend.should_receive(:delete_items).with('DeleteItems' => [
+          {'DeleteItem' => {'CustTransactionID' => 'my_ref', 'TrackingNumber' => 't1'}},
+          {'DeleteItem' => {'CustTransactionID' => 'my_ref', 'TrackingNumber' => 't2'}}
+        ])
+        subject
+      end
+    end
+
+    describe '.delete_items' do
+      subject { ClickAndSend.delete_items(options) }
+      let(:options) { {'DeleteItems' => stub} }
+      let(:required_inputs) { %w(DeleteItems) }
+      it_behaves_like "data required"
+      it "calls DeleteItems result" do
+        ClickAndSend::Request::DeleteItems.should_receive(:new) { stub(:result => 'deleted') }
+        subject.should == 'deleted'
+      end
+    end
+
+    describe '.find_tracking_numbers' do
+      subject { ClickAndSend.find_tracking_numbers(['REF']) }
+      let(:item_summary) do
+        [ {:cust_transaction_id => 'REF', :tracking_number => 'TRACK-REF-1'},
+          {:cust_transaction_id => 'REF', :tracking_number => 'TRACK-REF-2'},
+          {:cust_transaction_id => 'OTHER_REF', :tracking_number => 'TRACK-OTHER-REF'} ]
+      end
+      before { ClickAndSend.stub(:item_summary) { item_summary } }
+      it { should be_a(Hash) }
+      its(:keys) { should == ['REF'] }
+      it "includes tracking numbers for REF" do
+        subject.values.first.should include('TRACK-REF-1')
+        subject.values.first.should include('TRACK-REF-2')
+      end
+      it "excludes other tracking number" do
+        subject.values.first.should_not include('TRACK-OTHER-REF')
+      end
+    end
+
+    describe '.item_summary' do
+      subject { ClickAndSend.item_summary }
+      it "fetches :item_summary_transaction from ItemSummary result" do
+        ClickAndSend::Request::ItemSummary.should_receive(:new) do
+          stub(:result => {:item_summary_transaction => 'items'})
+        end
+        subject.should == 'items'
+      end
+    end
+
+    describe '.pdf_url' do
+      subject { ClickAndSend.pdf_url('REF') }
+      let(:options) do
+        {
+          'PrintFormat' => 'LINK',
+          'CustTransactionID' => 'REF',
+          'TrackingNumber' => tracking_numbers.first
+        }
+      end
+      let(:pdf_url) { 'http://example.com/paperwork.pdf' }
+      before do
+        ClickAndSend.stub(:find_tracking_numbers).with(['REF']) do
+          {'REF' => tracking_numbers}
+        end
+      end
+
+      context "one tracking number" do
+        let(:tracking_numbers) { ['xyz'] }
+        specify "requests URL from PrintItem" do
+          ClickAndSend::Request::PrintItem.should_receive(:new).with(options) do
+            stub(:result => pdf_url)
+          end
+          subject.should == pdf_url
+        end
+      end
+
+      context "no matching tracking numbers" do
+        let(:tracking_numbers) { [] }
+        it "raises API error" do
+          expect { subject }.to raise_error(ClickAndSend::Errors::APIError, "Not found: 'REF'")
+        end
+      end
+
+      context "two tracking numbers" do
+        let(:tracking_numbers) { ['uvw', 'xyz'] }
+        it "raises API error" do
+          expect { subject }.to raise_error(ClickAndSend::Errors::APIError, "Expected 1 but found 2 tracking numbers for 'REF': uvw, xyz")
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/config.example.yml

@@ -0,0 +1,5 @@
+# To run the acceptance test, copy this file to config.yml and change these values to your test account's credentials.
+:account_number: 1234567
+:api_key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+:user_name: acme
+:wsdl: https://auspost-staging.oss.neopost-id.com/modules/oss/api/ship/wsdl?sz_Client=AustraliaPost

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'click_and_send'
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |path| require path }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # 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
+  # Disabled random order because some acceptance tests need to run in order.
+  # config.order = 'random'
+end

data/spec/support/factories.rb

@@ -0,0 +1,128 @@
+require 'faker'
+
+module ClickAndSend
+  module Test
+    module Factories
+      def attributes_for(*keys)
+        keys.flatten.inject({}) do |hash, key|
+          value = case key
+          when 'ItemDetails' then item_details_attributes
+          when 'Receiver' then us_address_attributes
+          when 'Sender' then au_address_attributes
+          when 'Transaction' then transaction_attributes
+          when 'Transactions'
+            [{'Transaction' => [transaction_attributes, transaction_attributes]}]
+          else raise UnknownDataKey, key
+          end
+          hash.merge(key => value)
+        end
+      end
+
+      private
+
+      def address_attributes
+        {
+          'CompanyName'  => '',
+          'ContactName'  => name,
+          'Telephone'    => phone_number,
+          'Email'        => email,
+          'AddressLine1' => street_address,
+          'AddressLine2' => '',
+          'AddressLine3' => '',
+        }
+      end
+
+      def au_address_attributes
+        address_attributes.merge(
+          'Town'         => "Sydney",
+          'StateCode'    => "NSW",
+          'PostCode'     => "2000",
+          'CountryCode'  => "AU"
+        )
+      end
+
+      def us_address_attributes
+        address_attributes.merge(
+          'Town'         => city,
+          'StateCode'    => "NY",
+          'PostCode'     => "10001",
+          'CountryCode'  => "US",
+        )
+      end
+
+      def city
+        Faker::Address.city
+      end
+
+      def customs_data_attributes
+        {
+          'CustomsData' => {
+            # 'CustomsItemType' => '',
+            # 'CustomsQuantity' => '',
+            # 'ExportDeclarationNumber' => '',
+            # 'ReasonForExport' => '',
+            'NameOfPersonLodging' => name,
+            # 'HSTariffNumber' => '',
+            # 'CountryOfOrigin' => '',
+            # 'NonDeliverySenderInstructions' => '',
+            # 'ReturnFollowingAddress' => '',
+          }
+        }
+      end
+
+      def dimensions
+        { 'Length' => '12.00', 'Width' => '12.00', 'Height' => '5.00' }
+      end
+
+      def email
+        Faker::Internet.email
+      end
+
+      def item_details_attributes
+        {
+          'PackagingType'                       => 'M', # Merchandise
+          'Dimensions'                          => dimensions,
+          'ItemWeight'                          => '0.500', # Float Format 999.999 Kg
+          'ExtraCover'                          => 0, # Boolean
+          'ExtraCoverAmountOrDeclaredValue'     => '100.00',
+          'ItemDescriptionOrDescriptionOfGoods' => "stuff",
+          'InternationalItemDetails'            => customs_data_attributes
+        }
+      end
+
+      def name
+        Faker::Name.name
+      end
+
+      def payment_details_attributes
+        {
+          'PaymentType' => '01',
+          'PaymentData' => ClickAndSend.configuration.account_number
+        }
+      end
+
+      def phone_number
+        Faker::PhoneNumber.phone_number.gsub(/[^\d]/, '')
+      end
+
+      def street_address
+        Faker::Address.street_address
+      end
+
+      def transaction_attributes
+        {
+          'CustTransactionID' => rand(10**10).to_s,
+          'Sender'            => au_address_attributes,
+          'Receiver'          => us_address_attributes,
+          'ItemDetails'       => item_details_attributes,
+          'ProductCode'       => '1',
+          'PaymentDetails'    => payment_details_attributes,
+        }
+      end
+
+      class UnknownDataKey < StandardError; end
+    end
+  end
+end
+
+RSpec.configure { |c| c.include ClickAndSend::Test::Factories }

data/spec/support/helpers.rb

@@ -0,0 +1,25 @@
+require 'yaml'
+
+module ClickAndSend
+  module Test
+    module Helpers
+      def load_config(mode = :test)
+        yaml_config_path = case mode
+        when :test
+          File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/config.example.yml'))
+        when :acceptance
+          File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/config.yml'))
+        end
+        if File.exists?(yaml_config_path)
+          ClickAndSend.configure do |config|
+            YAML::load_file(yaml_config_path).each { |k,v| config.send(:"#{k}=", v) }
+          end
+        else
+          pending "Can't run acceptance tests because #{yaml_config_path} is missing. See fixtures/config.example.yml."
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure { |c| c.include ClickAndSend::Test::Helpers }

data/spec/support/open_uri.rb

@@ -0,0 +1,2 @@
+require 'open-uri'
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE

data/spec/support/shared_examples.rb

@@ -0,0 +1,19 @@
+shared_examples_for "data required" do
+  context "empty input" do
+    let(:options) { {} }
+    it "raises InvalidInput" do
+      required_inputs.each do |required_input|
+        expect { subject }.to raise_error(ClickAndSend::Errors::InvalidInput) do |e|
+          e.message.should include(required_input)
+        end
+      end
+    end
+  end
+
+  context "required keys present" do
+    let(:options) { required_inputs.inject({}) { |hash, key| hash.merge(key => stub) } }
+    it "doesn't raise InvalidInput" do
+      expect { subject }.not_to raise_error(ClickAndSend::Errors::InvalidInput)
+    end
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: click_and_send
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Zubin Henner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: &70235421689060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70235421689060
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: &70235421676680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70235421676680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70235421675840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235421675840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70235421675300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235421675300
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: &70235421674500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235421674500
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70235421673020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235421673020
+description: Ruby adapter for Australia Post's ClickAndSend API
+email:
+- zubin.henner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- click_and_send.gemspec
+- lib/click_and_send.rb
+- lib/click_and_send/configuration.rb
+- lib/click_and_send/encryption.rb
+- lib/click_and_send/errors.rb
+- lib/click_and_send/request.rb
+- lib/click_and_send/request/check_services.rb
+- lib/click_and_send/request/create_items.rb
+- lib/click_and_send/request/delete_items.rb
+- lib/click_and_send/request/item_summary.rb
+- lib/click_and_send/request/print_item.rb
+- lib/click_and_send/version.rb
+- lib/click_and_send/xml.rb
+- spec/acceptance_spec.rb
+- spec/click_and_send/request_spec.rb
+- spec/click_and_send/xml_spec.rb
+- spec/click_and_send_spec.rb
+- spec/fixtures/config.example.yml
+- spec/spec_helper.rb
+- spec/support/factories.rb
+- spec/support/helpers.rb
+- spec/support/open_uri.rb
+- spec/support/shared_examples.rb
+homepage: https://github.com/zubin/click_and_send
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1242808500940722472
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1242808500940722472
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby adapter for Australia Post's ClickAndSend API
+test_files:
+- spec/acceptance_spec.rb
+- spec/click_and_send/request_spec.rb
+- spec/click_and_send/xml_spec.rb
+- spec/click_and_send_spec.rb
+- spec/fixtures/config.example.yml
+- spec/spec_helper.rb
+- spec/support/factories.rb
+- spec/support/helpers.rb
+- spec/support/open_uri.rb
+- spec/support/shared_examples.rb