maestrano 0.1.0

data/maestrano.gemspec

@@ -0,0 +1,32 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'maestrano/version'
+
+Gem::Specification.new do |s|
+  s.name = 'maestrano'
+  s.version = Maestrano::VERSION
+  s.summary = 'Ruby bindings for the Maestrano API'
+  s.description = 'Maestrano is the next generation marketplace for SME applications. See https://maestrano.com for details.'
+  s.authors = ['Arnaud Lachaume']
+  s.email = ['arnaud.lachaume@maestrano.com']
+  s.homepage = 'https://maestrano.com'
+  s.license = 'MIT'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('mime-types', '~> 1.25')
+  s.add_dependency('json', '~> 1.8')
+  
+  s.add_development_dependency('test-unit', '~> 2')
+  s.add_development_dependency('mocha', '~> 0.13')
+  s.add_development_dependency('shoulda', '~> 2.11')
+  s.add_development_dependency('timecop', '<= 0.6.0')
+  s.add_development_dependency('rake', '~> 10')
+  
+  s.add_runtime_dependency("uuid", ["~> 2.3"])
+  s.add_runtime_dependency("nokogiri", [">= 1.5.0"])
+end

data/test/helpers/api_helpers.rb

@@ -0,0 +1,82 @@
+module APITestHelper
+  def test_response(body={}, code=200)
+    # When an exception is raised, restclient clobbers method_missing.  Hence we
+    # can't just use the stubs interface.
+    body = JSON.generate(body) if !(body.kind_of? String)
+    m = mock
+    m.instance_variable_set('@resp_values', { :body => body, :code => code })
+    def m.body; @resp_values[:body]; end
+    def m.code; @resp_values[:code]; end
+    m
+  end
+  
+  def test_account_bill_content(params={})
+    {
+      object: 'account_bill',
+      id: 'bill-1',
+      group_id: 'cld-1',
+      created_at: Time.now.utc.iso8601,
+      price_cents: 2300,
+      status: 'submitted',
+      currency: 'AUD',
+      units: 1,
+      description: 'Bill for something',
+      period_start: Time.now.utc.iso8601,
+      period_end: (Time.now + 3600000).utc.iso8601,
+    }.merge(params)
+  end
+  
+  def test_account_bill(params={})
+    {
+      success: true,
+      errors: {},
+      data: test_account_bill_content(params)
+    }
+  end
+  
+  def test_account_bill_array
+    {
+      success: true,
+      errors: {},
+      data: [test_account_bill_content, test_account_bill_content, test_account_bill_content],
+    }
+  end
+  
+  def test_account_bill_array_one
+    {
+      success: true,
+      errors: {},
+      data: [test_account_bill_content],
+    }
+  end
+  
+  def test_invalid_api_key_error
+    {
+      'success' => false,
+      'data' => {},
+      "errors" => {
+        "authentication" => ["Invalid API token"],
+      }
+    }
+  end
+  
+  def test_missing_id_error
+    {
+      'success' => false,
+      'data' => {},
+      'errors' => {
+        'id' => ["does not exist"]
+      }
+    }
+  end
+  
+  def test_api_error
+    {
+      'success' => false,
+      'data' => {},
+      'errors' => {
+        'system' => ["A system error occured. Please retry later or contact support@maestrano.com if the issue persists."]
+      }
+    }
+  end
+end

data/test/helpers/saml_helpers.rb

@@ -0,0 +1,62 @@
+module SamlTestHelper
+  def fixture(document, base64 = true)
+    response = Dir.glob(File.join(File.dirname(__FILE__), '..', 'support', 'saml', "responses", "#{document}*")).first
+    if base64 && response =~ /\.xml$/
+      Base64.encode64(File.read(response))
+    else
+      File.read(response)
+    end
+  end
+
+  def response_document
+    @response_document ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response1.xml.base64'))
+  end
+
+  def response_document_2
+    @response_document2 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response2.xml.base64'))
+  end
+
+  def response_document_3
+    @response_document3 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response3.xml.base64'))
+  end
+
+  def response_document_4
+    @response_document4 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response4.xml.base64'))
+  end
+
+  def response_document_5
+    @response_document5 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response5.xml.base64'))
+  end
+
+  def r1_response_document_6
+    @response_document6 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'r1_response6.xml.base64'))
+  end
+
+  def ampersands_response
+    @ampersands_resposne ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'response_with_ampersands.xml.base64'))
+  end
+
+  def response_document_6
+    doc = Base64.decode64(response_document)
+    doc.gsub!(/NotBefore=\"(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z\"/, "NotBefore=\"#{(Time.now-300).getutc.strftime("%Y-%m-%dT%XZ")}\"")
+    doc.gsub!(/NotOnOrAfter=\"(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z\"/, "NotOnOrAfter=\"#{(Time.now+300).getutc.strftime("%Y-%m-%dT%XZ")}\"")
+    Base64.encode64(doc)
+  end
+
+  def wrapped_response_2
+    @wrapped_response_2 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'responses', 'wrapped_response_2.xml.base64'))
+  end
+
+  def signature_fingerprint_1
+    @signature_fingerprint1 ||= "C5:19:85:D9:47:F1:BE:57:08:20:25:05:08:46:EB:27:F6:CA:B7:83"
+  end
+  
+  def signature_1
+    @signature1 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'certificates', 'certificate1'))
+  end
+
+  def r1_signature_2
+    @signature2 ||= File.read(File.join(File.dirname(__FILE__), '..', 'support', 'saml', 'certificates', 'r1_certificate2_base64'))
+  end
+
+end

data/test/maestrano/account/bill_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+module Maestrano
+  module Account
+    class BillTest < Test::Unit::TestCase
+      include APITestHelper
+      
+      should "bills should be listable" do
+        @api_mock.expects(:get).once.returns(test_response(test_account_bill_array))
+        c = Maestrano::Account::Bill.all
+        assert c.data.kind_of? Array
+        c.each do |bill|
+          assert bill.kind_of?(Maestrano::Account::Bill)
+        end
+      end
+
+      should "bills should be cancellable" do
+        @api_mock.expects(:delete).once.returns(test_response(test_account_bill))
+        c = Maestrano::Account::Bill.construct_from(test_account_bill[:data])
+        c.cancel
+      end
+
+      should "bills should not be updateable" do
+        assert_raises NoMethodError do
+          @api_mock.stubs(:put).returns(test_response(test_account_bill))
+          c = Maestrano::Account::Bill.construct_from(test_account_bill[:data])
+          c.save
+        end
+      end
+
+
+      should "create should successfully create a remote bill when passed correct parameters" do
+        @api_mock.expects(:post).with do |url, api_key, params|
+          url == "#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills" && api_key.nil? && 
+          CGI.parse(params) == {"group_id"=>["cld-1"], "price_cents"=>["23000"], "currency"=>["AUD"], "description"=>["Some bill"]}
+        end.once.returns(test_response(test_account_bill))
+
+        bill = Maestrano::Account::Bill.create({
+          group_id: 'cld-1',
+          price_cents: 23000,
+          currency: 'AUD',
+          description: 'Some bill'
+        })
+        assert bill.id
+      end
+    end
+  end
+end

data/test/maestrano/api/list_object_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+module Maestrano
+  module API
+    class ListObjectTest < Test::Unit::TestCase
+      include APITestHelper
+      
+      should "be able to retrieve full lists given a listobject" do
+        @api_mock.expects(:get).twice.returns(test_response(test_account_bill_array))
+        c = Maestrano::Account::Bill.all
+        assert c.kind_of?(Maestrano::API::ListObject)
+        assert_equal('account/bills', c.url)
+        all = c.all
+        assert all.kind_of?(Maestrano::API::ListObject)
+        assert_equal('account/bills', all.url)
+        assert all.data.kind_of?(Array)
+      end
+    end
+  end
+end

data/test/maestrano/api/object_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+module Maestrano
+  module API
+    class ObjectTest < Test::Unit::TestCase
+      should "implement #respond_to correctly" do
+        obj = Maestrano::API::Object.construct_from({ :id => 1, :foo => 'bar' })
+        assert obj.respond_to?(:id)
+        assert obj.respond_to?(:foo)
+        assert !obj.respond_to?(:baz)
+      end
+
+      should "marshal a maestrano object correctly" do
+        date = Time.now.utc
+        obj = Maestrano::API::Object.construct_from({ 
+          id: 1, 
+          name: 'Maestrano',
+          some_date: date.iso8601
+        }, 'apikey')
+        m = Marshal.load(Marshal.dump(obj))
+        assert_equal 1, m.id
+        assert_equal 'Maestrano', m.name
+        assert_equal 'apikey', m.api_key
+        assert_equal date.iso8601, m.some_date.iso8601
+      end
+    end
+  end
+end

data/test/maestrano/api/resource_test.rb

@@ -0,0 +1,343 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../../test_helper', __FILE__)
+
+module Maestrano
+  module API
+    class ResourceTest < Test::Unit::TestCase
+      include APITestHelper
+      
+      should "creating a new Resource should not fetch over the network" do
+        @api_mock.expects(:get).never
+        Maestrano::Account::Bill.new("someid")
+      end
+
+      should "creating a new Resource from a hash should not fetch over the network" do
+        @api_mock.expects(:get).never
+        Maestrano::Account::Bill.construct_from({
+          id: "somebill",
+          object: "account_bill",
+          price_cents: 2300,
+          currency: 'AUD'
+        })
+      end
+
+      should "setting an attribute should not cause a network request" do
+        @api_mock.expects(:get).never
+        @api_mock.expects(:post).never
+        c = Maestrano::Account::Bill.new("test_account_bill");
+        c.price_cents= 50000
+      end
+
+      should "accessing id should not issue a fetch" do
+        @api_mock.expects(:get).never
+        c = Maestrano::Account::Bill.new("test_account_bill");
+        c.id
+      end
+
+      should "specifying invalid api credentials should raise an exception" do
+        response = test_response(test_invalid_api_key_error, 401)
+        assert_raises Maestrano::API::Error::AuthenticationError do
+          @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+          Maestrano::Account::Bill.retrieve("failing_bill")
+        end
+      end
+
+      should "AuthenticationErrors should have an http status, http body, and JSON body" do
+        response = test_response(test_invalid_api_key_error, 401)
+        begin
+          @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+          Maestrano::Account::Bill.retrieve("failing_bill")
+        rescue Maestrano::API::Error::AuthenticationError => e
+          assert_equal(401, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, !!e.json_body[:errors])
+          assert_equal(test_invalid_api_key_error['errors'].first.join(" "), e.json_body[:errors].first.join(" "))
+        end
+      end
+
+      context "when specifying per-object credentials" do
+        context "with no global API key set" do
+          setup do
+            @original_api_key = Maestrano.param('api_key')
+            Maestrano.configure { |c| c.api_key = nil }
+          end
+          
+          teardown do
+            Maestrano.configure { |c| c.api_key = @original_api_key }
+          end
+          
+          should "use the per-object credential when creating" do
+            Maestrano::API::Operation::Base.expects(:execute_request).with do |opts|
+              opts[:headers][:authorization] == "Basic #{Base64.encode64('sk_test_local:')}"
+            end.returns(test_response(test_account_bill))
+
+            Maestrano::Account::Bill.create({
+                group_id: 'cld-1',
+                price_cents: 23000,
+                currency: 'AUD',
+                description: 'Some bill'
+              },
+              'sk_test_local'
+            )
+          end
+        end
+
+        context "with a global API key set" do
+          should "use the per-object credential when creating" do
+            Maestrano::API::Operation::Base.expects(:execute_request).with do |opts|
+              opts[:headers][:authorization] == "Basic #{Base64.encode64('local:')}"
+            end.returns(test_response(test_account_bill))
+
+            Maestrano::Account::Bill.create({
+                group_id: 'cld-1',
+                price_cents: 23000,
+                currency: 'AUD',
+                description: 'Some bill'
+              },
+              'local'
+            )
+          end
+        end
+      end
+
+      context "with valid credentials" do
+        should "urlencode values in GET params" do
+          response = test_response(test_account_bill_array)
+          @api_mock.expects(:get).with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills?bill=test%20bill", nil, nil).returns(response)
+          bills = Maestrano::Account::Bill.all(:bill => 'test bill').data
+          assert bills.kind_of? Array
+        end
+
+        should "construct URL properly with base query parameters" do
+          response = test_response(test_account_bill_array)
+          @api_mock.expects(:get).with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills?bill=test_account_bill", nil, nil).returns(response)
+          bills = Maestrano::Account::Bill.all(:bill => 'test_account_bill')
+
+          
+        end
+        
+        should "construct URL properly with multiple query parameters" do
+          response = test_response(test_account_bill_array)
+          @api_mock.expects(:get).with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills?bill=test_account_bill&paid=true", nil, nil).returns(response)
+          bills = Maestrano::Account::Bill.all(bill:'test_account_bill', paid: true)
+        end
+
+        should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
+          response = test_response(test_missing_id_error, 400)
+          @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+          begin
+            Maestrano::Account::Bill.retrieve("foo")
+          rescue Maestrano::API::Error::InvalidRequestError => e
+            assert_equal(400, e.http_status)
+            assert_equal(true, !!e.http_body)
+            assert_equal(true, e.json_body.kind_of?(Hash))
+          end
+        end
+
+        should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
+          response = test_response(test_missing_id_error, 401)
+          @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+          begin
+            Maestrano::Account::Bill.retrieve("foo")
+          rescue Maestrano::API::Error::AuthenticationError => e
+            assert_equal(401, e.http_status)
+            assert_equal(true, !!e.http_body)
+            assert_equal(true, e.json_body.kind_of?(Hash))
+          end
+        end
+
+        should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
+          response = test_response(test_missing_id_error, 404)
+          @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+          begin
+            Maestrano::Account::Bill.retrieve("foo")
+          rescue Maestrano::API::Error::InvalidRequestError => e
+            assert_equal(404, e.http_status)
+            assert_equal(true, !!e.http_body)
+            assert_equal(true, e.json_body.kind_of?(Hash))
+          end
+        end
+
+        should "setting a nil value for a param should exclude that param from the GET request" do
+          @api_mock.expects(:get).with do |url, api_key, params|
+            uri = URI(url)
+            query = CGI.parse(uri.query)
+            (url =~ %r{^#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills?} &&
+             query.keys.sort == ['offset', 'sad'])
+          end.returns(test_response(test_account_bill_array_one))
+          Maestrano::Account::Bill.all(:count => nil, :offset => 5, :sad => false)
+        end
+        
+        should "setting a nil value for a param should exclude that param from the POST request" do
+          @api_mock.expects(:post).with do |url, api_key, params|
+            url == "#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills" &&
+              api_key.nil? &&
+              CGI.parse(params) == { 'group_id' => ['cld-1'], 'price_cents' => ['23000'], 'currency' => ['AUD'] }
+          end.returns(test_response(test_account_bill))
+          Maestrano::Account::Bill.create({
+            group_id: 'cld-1',
+            price_cents: 23000,
+            currency: 'AUD',
+            description: nil
+          })
+        end
+
+        should "requesting with a unicode ID should result in a request" do
+          response = test_response(test_missing_id_error, 404)
+          @api_mock.expects(:get).once.with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
+          c = Maestrano::Account::Bill.new("☃")
+          assert_raises(Maestrano::API::Error::InvalidRequestError) { c.refresh }
+        end
+
+        should "requesting with no ID should result in an InvalidRequestError with no request" do
+          c = Maestrano::Account::Bill.new
+          assert_raises(Maestrano::API::Error::InvalidRequestError) { c.refresh }
+        end
+
+        should "making a GET request with parameters should have a query string and no body" do
+          params = { :limit => 1 }
+          @api_mock.expects(:get).once.with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills?limit=1", nil, nil).returns(test_response(test_account_bill_array_one))
+          Maestrano::Account::Bill.all(params)
+        end
+
+        should "making a POST request with parameters should have a body and no query string" do
+          date = Time.now.utc
+          params = {
+            group_id: 'cld-1',
+            price_cents: 23000,
+            currency: 'AUD',
+            description: 'Some bill',
+            period_started_at: date
+          }
+          @api_mock.expects(:post).once.with do |url, get, post|
+            get.nil? && 
+            CGI.parse(post) == {"group_id"=>["cld-1"], "price_cents"=>["23000"], "currency"=>["AUD"], "description"=>["Some bill"], "period_started_at" => ["#{date.iso8601}"]}
+          end.returns(test_response(test_account_bill))
+          Maestrano::Account::Bill.create(params)
+        end
+
+        should "loading an object should issue a GET request" do
+          @api_mock.expects(:get).once.returns(test_response(test_account_bill))
+          c = Maestrano::Account::Bill.new("test_account_bill")
+          c.refresh
+        end
+
+        should "using array accessors should be the same as the method interface" do
+          @api_mock.expects(:get).once.returns(test_response(test_account_bill))
+          c = Maestrano::Account::Bill.new("test_account_bill")
+          c.refresh
+          assert_equal c.created_at, c[:created_at]
+          assert_equal c.created_at, c['created_at']
+          date = Time.now.utc.iso8601
+          c['created'] = date
+          assert_equal c.created, date
+        end
+
+        # Not related object defined on any model yet
+        # should "accessing a property other than id or parent on an unfetched object should fetch it" do
+        #   @api_mock.expects(:get).once.returns(test_response(test_account_bill))
+        #   c = Maestrano::Account::Bill.new("test_account_bill")
+        #   c.price_cents
+        # end
+
+        should "updating an object should issue a PUT request with only the changed properties" do
+          @api_mock.expects(:put).with do |url, api_key, params|
+            url == "#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills/bill-1" && 
+            api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
+          end.once.returns(test_response(test_account_bill))
+          
+          c = Maestrano::Account::Bill.construct_from(test_account_bill[:data])
+          class << c
+            include Maestrano::API::Operation::Update
+          end
+          
+          c.description = "another_mn"
+          c.save
+        end
+
+        should "updating should merge in returned properties" do
+          @api_mock.expects(:put).once.returns(test_response(test_account_bill))
+          c = Maestrano::Account::Bill.new(test_account_bill[:data])
+          class << c
+            include Maestrano::API::Operation::Update
+          end
+          
+          c.description = "another_mn"
+          c.save
+        end
+
+        should "deleting should send no props and result in an object that has no props other deleted" do
+          @api_mock.expects(:get).never
+          @api_mock.expects(:post).never
+          @api_mock.expects(:delete).with("#{Maestrano.param('api_host')}#{Maestrano.param('api_base')}account/bills/bill-1", nil, nil).once.returns(test_response(test_account_bill))
+
+          c = Maestrano::Account::Bill.construct_from(test_account_bill[:data])
+          class << c
+            include Maestrano::API::Operation::Delete
+          end
+
+          c.delete
+
+
+          assert_raises NoMethodError do
+            c.livemode
+          end
+        end
+
+        # should "loading an object with properties that have specific types should instantiate those classes" do
+        #   @api_mock.expects(:get).once.returns(test_response(test_account_bill))
+        #   c = Maestrano::Account::Bill.retrieve("test_account_bill")
+        #   assert c.card.kind_of?(Maestrano::API::Object) && c.card.object == 'card'
+        # end
+
+        should "loading all of a Resource should return an array of recursively instantiated objects" do
+          @api_mock.expects(:get).once.returns(test_response(test_account_bill_array))
+          c = Maestrano::Account::Bill.all.data
+          assert c.kind_of? Array
+          assert c[0].kind_of? Maestrano::Account::Bill
+          
+          # No object to test for the moment
+          #assert c[0].card.kind_of?(Maestrano::API::Object) && c[0].card.object == 'card'
+        end
+
+        context "error checking" do
+
+          should "404s should raise an InvalidRequestError" do
+            response = test_response(test_missing_id_error, 404)
+            @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+
+            rescued = false
+            begin
+              Maestrano::Account::Bill.new("test_account_bill").refresh
+              assert false #shouldn't get here either
+            rescue Maestrano::API::Error::InvalidRequestError => e # we don't use assert_raises because we want to examine e
+              rescued = true
+              assert e.kind_of? Maestrano::API::Error::InvalidRequestError
+              assert_equal "id", e.param
+              assert_equal 'id does not exist', e.message
+            end
+
+            assert_equal true, rescued
+          end
+
+          should "5XXs should raise an API::Error" do
+            response = test_response(test_api_error, 500)
+            @api_mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
+
+            rescued = false
+            begin
+              Maestrano::Account::Bill.new("test_account_bill").refresh
+              assert false #shouldn't get here either
+            rescue Maestrano::API::Error::BaseError => e # we don't use assert_raises because we want to examine e
+              rescued = true
+              assert e.kind_of? Maestrano::API::Error::BaseError
+            end
+
+            assert_equal true, rescued
+          end
+          
+        end
+      end
+    end
+  end
+end