paid 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 614d4c58acc67641a1e7bfbda9eccd0236b4113b
-  data.tar.gz: 794f70851a0c85480cb9ee45a622cf9f056fe04d
+  metadata.gz: c131f42824035c881ba3eaf3896d2a8e79aa9a26
+  data.tar.gz: c2b902c2b3d7e0fba75c67b71ec3cff06db9fc98
 SHA512:
-  metadata.gz: 6d5b35e417e89252742f10d705c647b6184284f4677675a8ab27f3909d2822e4f92e82767c9d4ecf8c0972cdab3b649e47fdae1ba5c684b45373ad74d670d0b9
-  data.tar.gz: 6e2d8fe2782449bdface40585cdacbb8f5ee678261a96300a48466feb9ab83089e1d06b62aba5ad6f93af426c6e2eef8e9002d0b60a6cad9f33e955860b65ac5
+  metadata.gz: 97115b5ea5004e528b213f9fc9800d5adfebe63d6ff7c0ed95f98f06a04d4acc0523067a285707521a6ce19ef365ec38768aed459cfa6da6e37afe61a72dd339
+  data.tar.gz: b1b15a66a2e5c093635e35d790bc9c801ad03143f595e1d86c512a26f7e88885a6adbeb69731fd1ca5ee5fa630c90f013549ec1d2b3e8398a1cf1f1bed29258c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    paid (0.0.8)
+    paid (0.1.0)
       json (~> 1.8.1)
       mime-types (>= 1.25, < 3.0)
       rest-client (~> 1.4)

data/lib/paid.rb

@@ -28,6 +28,8 @@ require 'paid/invoice'
 require 'paid/transaction'
 require 'paid/event'
 require 'paid/alias'
+require 'paid/plan'
+require 'paid/subscription'
 
 # Errors
 require 'paid/errors/paid_error'

data/lib/paid/api_operations/update.rb

@@ -4,33 +4,33 @@ module Paid
       def save(opts={})
         values = serialize_params(self).merge(opts)
 
-        if @values[:metadata]
-          values[:metadata] = serialize_metadata
+        if @values[:properties]
+          values[:properties] = serialize_properties
         end
 
         if values.length > 0
           values.delete(:id)
 
-          response, api_key = Paid.request(:put, api_url, @api_key, values)
+          response, api_key = Paid.request(:post, api_url, @api_key, values)
           refresh_from(response, api_key)
         end
         self
       end
 
-      def serialize_metadata
-        if @unsaved_values.include?(:metadata)
-          # the metadata object has been reassigned
-          # i.e. as object.metadata = {key => val}
-          metadata_update = @values[:metadata]  # new hash
-          new_keys = metadata_update.keys.map(&:to_sym)
+      def serialize_properties
+        if @unsaved_values.include?(:properties)
+          # the properties object has been reassigned
+          # i.e. as object.properties = {key => val}
+          properties_update = @values[:properties]  # new hash
+          new_keys = properties_update.keys.map(&:to_sym)
           # remove keys at the server, but not known locally
-          keys_to_unset = @previous_metadata.keys - new_keys
-          keys_to_unset.each {|key| metadata_update[key] = ''}
+          keys_to_unset = @previous_properties.keys - new_keys
+          keys_to_unset.each {|key| properties_update[key] = ''}
 
-          metadata_update
+          properties_update
         else
-          # metadata is a PaidObject, and can be serialized normally
-          serialize_params(@values[:metadata])
+          # properties is a PaidObject, and can be serialized normally
+          serialize_params(@values[:properties])
         end
       end
 

data/lib/paid/paid_object.rb

@@ -45,7 +45,7 @@ module Paid
     def refresh_from(values, api_key, partial=false)
       @api_key = api_key
 
-      @previous_metadata = values[:metadata]
+      @previous_properties = values[:properties]
       removed = partial ? Set.new : Set.new(@values.keys - values.keys)
       added = Set.new(values.keys - @values.keys)
 

data/lib/paid/plan.rb

@@ -0,0 +1,6 @@
+module Paid
+  class Plan < APIResource
+    include Paid::APIOperations::List
+    include Paid::APIOperations::Create
+  end
+end

data/lib/paid/subscription.rb

@@ -0,0 +1,19 @@
+module Paid
+  class Subscription < APIResource
+    include Paid::APIOperations::List
+    include Paid::APIOperations::Create
+
+    def cancel(params={}, opts={})
+      api_key, headers = Util.parse_opts(opts)
+      response, api_key = Paid.request(
+        :post, cancel_url, api_key || @api_key, params, headers)
+      refresh_from(response, api_key)
+    end
+
+    private
+
+    def cancel_url
+      api_url + '/cancel'
+    end
+  end
+end

data/lib/paid/util.rb

@@ -25,7 +25,9 @@ module Paid
         'customer' => Customer,
         'event' => Event,
         'invoice' => Invoice,
-        'alias' => Alias
+        'alias' => Alias,
+        'plan' => Plan,
+        'subscription' => Subscription
       }
     end
 

data/lib/paid/version.rb

@@ -1,3 +1,3 @@
 module Paid
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

data/test/paid/alias_test.rb

@@ -1,29 +1,22 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
+  # AliasTest
   class AliasTest < Test::Unit::TestCase
-    should "aliases should not be deletable" do
+    should 'aliases should not be deletable' do
       assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Paid::Alias.retrieve("test_alias")
+        # Expect twice because Paid::Alias.retrieve returns a customer object
+        @mock.expects(:get).twice.returns(test_response(test_customer))
+        c = Paid::Alias.retrieve('test_alias')
         c.delete
       end
     end
 
-    should "execute should return a new, fully executed alias when passed correct parameters" do
-      @mock.expects(:post).with do |url, api_key, params|
-        url == "#{Paid.api_base}/v0/aliases" && api_key.nil? && CGI.parse(params) == {
-            'name' => ['test-alias'],
-            'customer' => ['c_test_customer']
-        }
-      end.once.returns(test_response(test_alias))
-
-      a = Paid::Alias.create({
-        :name => 'test-alias',
-        :customer => 'c_test_customer'
-      })
-
-      assert a.name == 'test-alias'
+    should 'retrieve should retrieve alias' do
+      # Expect twice because Paid::Alias.retrieve returns a customer object
+      @mock.expects(:get).twice.returns(test_response(test_alias))
+      i = Paid::Alias.retrieve('in_test_alias')
+      assert_equal 'al_test_alias', i.id
     end
   end
 end

data/test/paid/api_resource_test.rb

@@ -3,64 +3,62 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class ApiResourceTest < Test::Unit::TestCase
-    should "creating a new APIResource should not fetch over the network" do
+    should 'creating a new APIResource should not fetch over the network' do
       @mock.expects(:get).never
-      Paid::Customer.new("someid")
+      Paid::Customer.new('someid')
     end
 
-    should "creating a new APIResource from a hash should not fetch over the network" do
+    should 'creating a new APIResource from a hash should not fetch over the network' do
       @mock.expects(:get).never
-      Paid::Customer.construct_from({
-        :id => "somecustomer",
-        :object => "customer",
-        :email => 'someone@example.com',
-        :name => 'Some Business',
-        :account_id => 'acct_1234'
-      })
+      Paid::Customer.construct_from(id: 'somecustomer',
+                                    object: 'customer',
+                                    email: 'someone@example.com',
+                                    name: 'Some Business',
+                                    account_id: 'acct_1234')
     end
 
-    should "setting an attribute should not cause a network request" do
+    should 'setting an attribute should not cause a network request' do
       @mock.expects(:get).never
       @mock.expects(:post).never
-      c = Paid::Customer.new("test_customer");
+      c = Paid::Customer.new('test_customer')
       c.name = 'Another Name'
     end
 
-    should "accessing id should not issue a fetch" do
+    should 'accessing id should not issue a fetch' do
       @mock.expects(:get).never
-      c = Paid::Customer.new("test_customer")
+      c = Paid::Customer.new('test_customer')
       c.id
     end
 
-    should "not specifying api credentials should raise an exception" do
+    should 'not specifying api credentials should raise an exception' do
       Paid.api_key = nil
       assert_raises Paid::AuthenticationError do
-        Paid::Customer.new("test_customer").refresh
+        Paid::Customer.new('test_customer').refresh
       end
     end
 
-    should "specifying api credentials containing whitespace should raise an exception" do
-      Paid.api_key = "key "
+    should 'specifying api credentials containing whitespace should raise an exception' do
+      Paid.api_key = 'key '
       assert_raises Paid::AuthenticationError do
-        Paid::Customer.new("test_customer").refresh
+        Paid::Customer.new('test_customer').refresh
       end
     end
 
-    should "specifying invalid api credentials should raise an exception" do
-      Paid.api_key = "invalid"
+    should 'specifying invalid api credentials should raise an exception' do
+      Paid.api_key = 'invalid'
       response = test_response(test_invalid_api_key_error, 401)
       assert_raises Paid::AuthenticationError do
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Paid::Customer.retrieve("failing_customer")
+        Paid::Customer.retrieve('failing_customer')
       end
     end
 
-    should "AuthenticationErrors should have an http status, http body, and JSON body" do
-      Paid.api_key = "invalid"
+    should 'AuthenticationErrors should have an http status, http body, and JSON body' do
+      Paid.api_key = 'invalid'
       response = test_response(test_invalid_api_key_error, 401)
       begin
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Paid::Customer.retrieve("failing_customer")
+        Paid::Customer.retrieve('failing_customer')
       rescue Paid::AuthenticationError => e
         assert_equal(401, e.http_status)
         assert_equal(true, !!e.http_body)
@@ -69,75 +67,75 @@ module Paid
       end
     end
 
-    should "send paid account as header when set" do
-      paid_account = "acct_0000"
+    should 'send paid account as header when set' do
+      paid_account = 'acct_0000'
       Paid.expects(:execute_request).with do |opts|
         opts[:headers][:paid_account] == paid_account
       end.returns(test_response(test_transaction))
 
-      Paid::Transaction.create({:amount => 100},
-                            {:paid_account => paid_account, :api_key => 'sk_test_local'})
+      Paid::Transaction.create({ amount: 100 },
+                               paid_account: paid_account, api_key: 'sk_test_local')
     end
 
-    should "not send paid account as header when not set" do
+    should 'not send paid account as header when not set' do
       Paid.expects(:execute_request).with do |opts|
         opts[:headers][:paid_account].nil?
       end.returns(test_response(test_transaction))
 
       Paid::Transaction.create(
         {
-          :amount => 200,
-          :description => 'This is a description.',
-          :customer => 'somecustomer'
+          amount: 200,
+          description: 'This is a description.',
+          customer: 'somecustomer'
 
         },
         'sk_test_local'
       )
     end
 
-    context "when specifying per-object credentials" do
-      context "with no global API key set" do
-        should "use the per-object credential when creating" do
+    context 'when specifying per-object credentials' do
+      context 'with no global API key set' do
+        should 'use the per-object credential when creating' do
           Paid.expects(:execute_request).with do |opts|
             opts[:headers][:authorization] == 'Bearer sk_test_local'
           end.returns(test_response(test_transaction))
 
           Paid::Transaction.create(
             {
-              :amount => 200,
-              :description => 'This is a description.',
-              :customer => 'somecustomer'
+              amount: 200,
+              description: 'This is a description.',
+              customer: 'somecustomer'
             },
             'sk_test_local'
           )
         end
       end
 
-      context "with a global API key set" do
+      context 'with a global API key set' do
         setup do
-          Paid.api_key = "global"
+          Paid.api_key = 'global'
         end
 
         teardown do
           Paid.api_key = nil
         end
 
-        should "use the per-object credential when creating" do
+        should 'use the per-object credential when creating' do
           Paid.expects(:execute_request).with do |opts|
             opts[:headers][:authorization] == 'Bearer local'
           end.returns(test_response(test_transaction))
 
           Paid::Transaction.create(
             {
-              :amount => 200,
-              :description => 'This is a description.',
-              :customer => 'somecustomer'
+              amount: 200,
+              description: 'This is a description.',
+              customer: 'somecustomer'
             },
             'local'
           )
         end
 
-        should "use the per-object credential when retrieving and making other calls" do
+        should 'use the per-object credential when retrieving and making other calls' do
           Paid.expects(:execute_request).with do |opts|
             opts[:url] == "#{Paid.api_base}/v0/transactions/tr_test_transaction" &&
               opts[:headers][:authorization] == 'Bearer local'
@@ -148,154 +146,154 @@ module Paid
       end
     end
 
-    context "with valid credentials" do
-      should "send along the idempotency-key header" do
+    context 'with valid credentials' do
+      should 'send along the idempotency-key header' do
         Paid.expects(:execute_request).with do |opts|
           opts[:headers][:idempotency_key] == 'bar'
         end.returns(test_response(test_transaction))
 
         Paid::Transaction.create(
           {
-            :amount => 200,
-            :description => 'This is a description.',
-            :customer => 'somecustomer'
-          }, 
-          {
-            :idempotency_key => 'bar',
-            :api_key => 'local',
-          }
+            amount: 200,
+            description: 'This is a description.',
+            customer: 'somecustomer'
+          },
+          idempotency_key: 'bar',
+          api_key: 'local'
         )
       end
 
-      should "urlencode values in GET params" do
+      should 'urlencode values in GET params' do
         response = test_response(test_transaction_array)
         @mock.expects(:get).with("#{Paid.api_base}/v0/transactions?customer=test%20customer", nil, nil).returns(response)
-        transactions = Paid::Transaction.all(:customer => 'test customer').data
-        assert transactions.kind_of? Array
+        transactions = Paid::Transaction.all(customer: 'test customer').data
+        assert transactions.is_a? Array
       end
 
-      should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
+      should 'a 400 should give an InvalidRequestError with http status, body, and JSON body' do
         response = test_response(test_missing_id_error, 400)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
-          Paid::Customer.retrieve("foo")
+          Paid::Customer.retrieve('foo')
         rescue Paid::InvalidRequestError => e
           assert_equal(400, e.http_status)
           assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
       end
 
-      should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
+      should 'a 401 should give an AuthenticationError with http status, body, and JSON body' do
         response = test_response(test_missing_id_error, 401)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
-          Paid::Customer.retrieve("foo")
+          Paid::Customer.retrieve('foo')
         rescue Paid::AuthenticationError => e
           assert_equal(401, e.http_status)
           assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
       end
 
-      should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
+      should 'a 404 should give an InvalidRequestError with http status, body, and JSON body' do
         response = test_response(test_missing_id_error, 404)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
-          Paid::Customer.retrieve("foo")
+          Paid::Customer.retrieve('foo')
         rescue Paid::InvalidRequestError => e
           assert_equal(404, e.http_status)
           assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
+          assert_equal(true, e.json_body.is_a?(Hash))
         end
       end
 
-      should "setting a nil value for a param should exclude that param from the request" do
-        @mock.expects(:get).with do |url, api_key, params|
+      should 'setting a nil value for a param should exclude that param from the request' do
+        @mock.expects(:get).with do |url, _api_key, _params|
           uri = URI(url)
           query = CGI.parse(uri.query)
           (url =~ %r{^#{Paid.api_base}/v0/transactions?} &&
-           query.keys.sort == ['offset', 'sad'])
-        end.returns(test_response({ :count => 1, :data => [test_transaction] }))
-        Paid::Transaction.all(:count => nil, :offset => 5, :sad => false)
+           query.keys.sort == %w(offset sad))
+        end.returns(test_response(count: 1, data: [test_transaction]))
+        Paid::Transaction.all(count: nil, offset: 5, sad: false)
 
         @mock.expects(:post).with do |url, api_key, params|
           url == "#{Paid.api_base}/v0/transactions" &&
             api_key.nil? &&
             CGI.parse(params) == { 'amount' => ['100'] }
-        end.returns(test_response({ :count => 1, :data => [test_transaction] }))
-        Paid::Transaction.create(:amount => 100)
+        end.returns(test_response(count: 1, data: [test_transaction]))
+        Paid::Transaction.create(amount: 100)
       end
 
-      should "requesting with a unicode ID should result in a request" do
+      should 'requesting with a unicode ID should result in a request' do
         response = test_response(test_missing_id_error, 404)
         @mock.expects(:get).once.with("#{Paid.api_base}/v0/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
-        c = Paid::Customer.new("☃")
+        c = Paid::Customer.new('☃')
         assert_raises(Paid::InvalidRequestError) { c.refresh }
       end
 
-      should "requesting with no ID should result in an InvalidRequestError with no request" do
+      should 'requesting with no ID should result in an InvalidRequestError with no request' do
         c = Paid::Customer.new
         assert_raises(Paid::InvalidRequestError) { c.refresh }
       end
 
-      should "making a GET request with parameters should have a query string and no body" do
-        params = { :limit => 1 }
+      should 'making a GET request with parameters should have a query string and no body' do
+        params = { limit: 1 }
         @mock.expects(:get).once.with("#{Paid.api_base}/v0/transactions?limit=1", nil, nil).returns(test_response([test_transaction]))
         Paid::Transaction.all(params)
       end
 
-      should "making a POST request with parameters should have a body and no query string" do
-        params = { :amount => 100, :alias => 'test_alias' }
-        @mock.expects(:post).once.with do |url, get, post|
-          get.nil? && CGI.parse(post) == {'amount' => ['100'], 'alias' => ['test_alias']}
+      should 'making a POST request with parameters should have a body and no query string' do
+        params = { amount: 100, alias: 'test_alias' }
+        @mock.expects(:post).once.with do |_url, get, post|
+          get.nil? && CGI.parse(post) == { 'amount' => ['100'], 'alias' => ['test_alias'] }
         end.returns(test_response(test_transaction))
         Paid::Transaction.create(params)
       end
 
-      should "loading an object should issue a GET request" do
+      should 'loading an object should issue a GET request' do
         @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Paid::Customer.new("test_customer")
+        c = Paid::Customer.new('test_customer')
         c.refresh
       end
 
-      should "using array accessors should be the same as the method interface" do
+      should 'using array accessors should be the same as the method interface' do
         @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Paid::Customer.new("test_customer")
+        c = Paid::Customer.new('test_customer')
         c.refresh
         assert_equal c.created, c[:created]
         assert_equal c.created, c['created']
-        c['created'] = 12345
-        assert_equal c.created, 12345
+        c['created'] = 12_345
+        assert_equal c.created, 12_345
       end
 
-      should "accessing a property other than id or parent on an unfetched object should fetch it" do
+      should 'accessing a property other than id or parent on an unfetched object should fetch it' do
         @mock.expects(:get).once.returns(test_response(test_customer))
-        c = Paid::Customer.new("test_customer")
+        c = Paid::Customer.new('test_customer')
         c.transactions
       end
 
-      should "updating an object should issue a POST request with only the changed properties" do
+      should 'updating an object should issue a POST request with only the changed properties' do
         @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Paid.api_base}/v0/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
+          url == "#{Paid.api_base}/v0/customers/cus_test_customer" &&
+            api_key.nil? &&
+            CGI.parse(params) == { 'description' => ['another_mn'] }
         end.once.returns(test_response(test_customer))
         c = Paid::Customer.construct_from(test_customer)
-        c.description = "another_mn"
+        c.description = 'another_mn'
         c.save
       end
 
-      should "updating should merge in returned properties" do
+      should 'updating should merge in returned properties' do
         @mock.expects(:post).once.returns(test_response(test_customer))
-        c = Paid::Customer.new("c_test_customer")
-        c.description = "another_mn"
+        c = Paid::Customer.new('cus_test_customer')
+        c.description = 'another_mn'
         c.save
         # assert_equal false, c.livemode
       end
 
-      should "deleting should send no props and result in an object that has no props other deleted" do
+      should 'deleting should send no props and result in an object that has no props other deleted' do
         @mock.expects(:get).never
         @mock.expects(:post).never
-        @mock.expects(:delete).with("#{Paid.api_base}/v0/customers/c_test_customer", nil, nil).once.returns(test_response({ "id" => "test_customer", "deleted" => true }))
+        @mock.expects(:delete).with("#{Paid.api_base}/v0/customers/cus_test_customer", nil, nil).once.returns(test_response('id' => 'test_customer', 'deleted' => true))
 
         c = Paid::Customer.construct_from(test_customer)
         c.delete
@@ -306,51 +304,50 @@ module Paid
         end
       end
 
-      should "loading an object with properties that have specific types should instantiate those classes" do
+      should 'loading an object with properties that have specific types should instantiate those classes' do
         @mock.expects(:get).once.returns(test_response(test_transaction))
-        t = Paid::Transaction.retrieve("test_transaction")
-        assert t.kind_of?(Paid::PaidObject) && t.object == 'transaction'
+        t = Paid::Transaction.retrieve('test_transaction')
+        assert t.is_a?(Paid::PaidObject) && t.object == 'transaction'
       end
 
-      should "loading all of an APIResource should return an array of recursively instantiated objects" do
+      should 'loading all of an APIResource should return an array of recursively instantiated objects' do
         @mock.expects(:get).once.returns(test_response(test_transaction_array))
         t = Paid::Transaction.all.data
-        assert t.kind_of? Array
-        assert t[0].kind_of? Paid::Transaction
-        assert t[0].kind_of?(Paid::PaidObject) && t[0].object == 'transaction'
+        assert t.is_a? Array
+        assert t[0].is_a? Paid::Transaction
+        assert t[0].is_a?(Paid::PaidObject) && t[0].object == 'transaction'
       end
 
-      context "error checking" do
-
-        should "404s should raise an InvalidRequestError" do
+      context 'error checking' do
+        should '404s should raise an InvalidRequestError' do
           response = test_response(test_missing_id_error, 404)
           @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
 
           rescued = false
           begin
-            Paid::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
+            Paid::Customer.new('test_customer').refresh
+            assert false # shouldn't get here either
           rescue Paid::InvalidRequestError => e # we don't use assert_raises because we want to examine e
             rescued = true
-            assert e.kind_of? Paid::InvalidRequestError
-            assert_equal "id", e.param
-            assert_equal "Missing id", e.message
+            assert e.is_a? Paid::InvalidRequestError
+            assert_equal 'id', e.param
+            assert_equal 'Missing id', e.message
           end
 
           assert_equal true, rescued
         end
 
-        should "5XXs should raise an APIError" do
+        should '5XXs should raise an APIError' do
           response = test_response(test_api_error, 500)
           @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
 
           rescued = false
           begin
-            Paid::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
+            Paid::Customer.new('test_customer').refresh
+            assert false # shouldn't get here either
           rescue Paid::APIError => e # we don't use assert_raises because we want to examine e
             rescued = true
-            assert e.kind_of? Paid::APIError
+            assert e.is_a? Paid::APIError
           end
 
           assert_equal true, rescued

data/test/paid/customer_test.rb

@@ -29,7 +29,7 @@ module Paid
     should "create should return a new customer" do
       @mock.expects(:post).once.returns(test_response(test_customer))
       c = Paid::Customer.create
-      assert_equal "c_test_customer", c.id
+      assert_equal "cus_test_customer", c.id
     end
 
     should "be able to generate invoice" do

data/test/paid/plan_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class PlanTest < Test::Unit::TestCase
+    should "retrieve should retrieve plans" do
+      @mock.expects(:get).once.returns(test_response(test_plan))
+      i = Paid::Plan.retrieve('in_test_plan')
+      assert_equal 'pl_test_plan', i.id
+    end
+
+    should "create should create a new plan" do
+      @mock.expects(:post).once.returns(test_response(test_plan))
+      i = Paid::Plan.create
+      assert_equal "pl_test_plan", i.id
+    end
+  end
+end

data/test/paid/properties_test.rb

@@ -0,0 +1,103 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class PropertiesTest < Test::Unit::TestCase
+    setup do
+      @properties_supported = {
+        transaction: {
+          new: Paid::Transaction.method(:new),
+          test: method(:test_transaction),
+          url: "/v0/transactions/#{test_transaction[:id]}"
+        },
+        customer: {
+          new: Paid::Customer.method(:new),
+          test: method(:test_customer),
+          url: "/v0/customers/#{test_customer[:id]}"
+        }
+      }
+
+      @base_url = 'https://api.paidapi.com'
+    end
+
+    should 'not touch properties' do
+      update_actions = ->(obj) { obj.description = 'test' }
+      check_properties({ properties: { 'initial' => 'true' } },
+                     'description=test',
+                     update_actions)
+    end
+
+    should 'update properties as a whole' do
+      update_actions = ->(obj) { obj.properties = { 'uuid' => '6735' } }
+      check_properties({ properties: {} },
+                     'properties[uuid]=6735',
+                     update_actions)
+
+      if is_greater_than_ruby_1_9?
+        check_properties({ properties: { initial: 'true' } },
+                       'properties[uuid]=6735&properties[initial]=',
+                       update_actions)
+      end
+    end
+
+    should 'update properties keys individually' do
+      update_actions = ->(obj) { obj.properties['txn_id'] = '134a13' }
+      check_properties({ properties: { 'initial' => 'true' } },
+                     'properties[txn_id]=134a13',
+                     update_actions)
+    end
+
+    should 'clear properties as a whole' do
+      update_actions = ->(obj) { obj.properties = nil }
+      check_properties({ properties: { 'initial' => 'true' } },
+                     'properties=',
+                     update_actions)
+    end
+
+    should 'clear properties keys individually' do
+      update_actions = ->(obj) { obj.properties['initial'] = nil }
+      check_properties({ properties: { 'initial' => 'true' } },
+                     'properties[initial]=',
+                     update_actions)
+    end
+
+    should 'handle combinations of whole and partial properties updates' do
+      if is_greater_than_ruby_1_9?
+        update_actions = lambda do |obj|
+          obj.properties = { 'type' => 'summer' }
+          obj.properties['uuid'] = '6735'
+        end
+        params = { properties: { 'type' => 'summer', 'uuid' => '6735' } }
+        curl_args = Paid.uri_encode(params)
+        check_properties({ properties: { 'type' => 'christmas' } },
+                       curl_args,
+                       update_actions)
+      end
+    end
+
+    def check_properties(initial_params, curl_args, properties_update)
+      @properties_supported.each do |_name, methods|
+        neu = methods[:new]
+        test = methods[:test]
+        url = @base_url + methods[:url]
+
+        initial_test_obj = test.call(initial_params)
+        @mock.expects(:get).once.returns(test_response(initial_test_obj))
+
+        final_test_obj = test.call
+        @mock.expects(:post).once
+          .returns(test_response(final_test_obj))
+          .with(url, nil, curl_args)
+
+        obj = neu.call('test')
+        obj.refresh
+        properties_update.call(obj)
+        obj.save
+      end
+    end
+
+    def is_greater_than_ruby_1_9?
+      version = RUBY_VERSION.dup  # clone preserves frozen state
+      Gem::Version.new(version) >= Gem::Version.new('1.9')
+    end
+  end
+end

data/test/paid/subscription_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  # SubscriptionTest
+  class SubscriptionTest < Test::Unit::TestCase
+    should 'retrieve should retrieve subscriptions' do
+      @mock.expects(:get).once.returns(test_response(test_subscription))
+      i = Paid::Subscription.retrieve('in_test_subscription')
+      assert_equal 'sub_test_subscription', i.id
+    end
+
+    should 'create should create a new subscription' do
+      @mock.expects(:post).once.returns(test_response(test_subscription))
+      i = Paid::Subscription.create
+      assert_equal 'sub_test_subscription', i.id
+    end
+
+    should 'subscriptions should be cancellable' do
+      @mock.expects(:get).never
+      @mock.expects(:post).once.returns(
+        test_response(
+          id: 'sub_test_subscription',
+          cancelled_at: 123_456_789
+        )
+      )
+      s = Paid::Subscription.new('test_subscription')
+      s.cancel
+      assert !s.cancelled_at.nil?
+    end
+  end
+end

data/test/paid/transaction_test.rb

@@ -2,54 +2,52 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class TransactionTest < Test::Unit::TestCase
-    should "transactions should be listable" do
+    should 'transactions should be listable' do
       @mock.expects(:get).once.returns(test_response(test_transaction_array))
       c = Paid::Transaction.all
-      assert c.data.kind_of? Array
+      assert c.data.is_a? Array
       c.each do |transaction|
-        assert transaction.kind_of?(Paid::Transaction)
+        assert transaction.is_a?(Paid::Transaction)
       end
     end
 
-    should "transactions should not be deletable" do
+    should 'transactions should not be deletable' do
       assert_raises NoMethodError do
         @mock.expects(:get).once.returns(test_response(test_transaction))
-        c = Paid::Transaction.retrieve("test_transaction")
+        c = Paid::Transaction.retrieve('test_transaction')
         c.delete
       end
     end
 
-    should "transactions should be updateable" do
+    should 'transactions should be updateable' do
       @mock.expects(:get).once.returns(test_response(test_transaction))
       @mock.expects(:post).once.returns(test_response(test_transaction))
-      c = Paid::Transaction.new("test_transaction")
+      c = Paid::Transaction.new('test_transaction')
       c.refresh
-      c.mnemonic = "New transaction description"
+      c.mnemonic = 'New transaction description'
       c.save
     end
 
-    should "execute should return a new, fully executed transaction when passed correct parameters" do
+    should 'execute should return a new, fully executed transaction when passed correct parameters' do
       @mock.expects(:post).with do |url, api_key, params|
         url == "#{Paid.api_base}/v0/transactions" && api_key.nil? && CGI.parse(params) == {
-            'amount' => ['100'],
-            'description' => ['a description'],
-            'customer' => ['c_test_customer']
+          'amount' => ['100'],
+          'description' => ['a description'],
+          'customer' => ['cus_test_customer']
         }
       end.once.returns(test_response(test_transaction))
 
-      c = Paid::Transaction.create({
-        :amount => 100,
-        :description => 'a description',
-        :customer => 'c_test_customer'
-      })
+      c = Paid::Transaction.create(amount: 100,
+                                   description: 'a description',
+                                   customer: 'cus_test_customer')
 
       assert !c.paid
     end
 
-    should "transactions should be able to be marked as paid" do
+    should 'transactions should be able to be marked as paid' do
       @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "tr_test_transaction", :paid => true}))
-      t = Paid::Invoice.new("test_transaction")
+      @mock.expects(:post).once.returns(test_response(id: 'tr_test_transaction', paid: true))
+      t = Paid::Invoice.new('test_transaction')
       t.mark_as_paid
       assert t.paid
     end

data/test/test_data.rb

@@ -17,7 +17,7 @@ module Paid
         :object => "alias",
         :id => id,
         :name => 'test-alias',
-        :customer => 'c_test_customer'
+        :customer => 'cus_test_customer'
       }.merge(params)
     end
 
@@ -30,7 +30,7 @@ module Paid
     end
 
     def test_customer(params={})
-      id = params[:id] || 'c_test_customer'
+      id = params[:id] || 'cus_test_customer'
       {
         :transactions => [],
         :object => "customer",
@@ -56,7 +56,7 @@ module Paid
         :object => "transaction",
         :description => 'a description',
         :created => 1304114826,
-        :customer => 'c_test_customer'
+        :customer => 'cus_test_customer'
       }.merge(params)
     end
 
@@ -89,7 +89,7 @@ module Paid
         next_chase_on: nil,
         terms: 30,
         due_date: nil,
-        customer: "c_test_customer",
+        customer: "cus_test_customer",
         issued_at: nil
       }
     end
@@ -120,5 +120,46 @@ module Paid
         }
       }
     end
+
+    def test_plan(params={})
+      {
+        :amount => 100,
+        :id => 'pl_test_plan',
+        :object => 'plan',
+        :name => 'test-name',
+        :description => 'a description',
+        :interval => 'month',
+        :interval_count => 3
+      }.merge(params)
+    end
+
+    def test_plans_array(params={})
+      {
+        :data => [test_plan, test_plan, test_plan],
+        :object => 'list',
+        :url => '/v0/plans'
+      }
+    end
+
+    def test_subscription(params={})
+      {
+        :amount => 100,
+        :id => 'sub_test_subscription',
+        :customer => 'cus_test_customer',
+        :cancelled_at => nil,
+        :ended_at => nil,
+        :started_at => 123_456_789,
+        :start_on => nil,
+        :plan => 'pl_test_plan'
+      }.merge(params)
+    end
+
+    def test_subscriptions_array(params={})
+      {
+        :data => [test_subscription, test_subscription, test_subscription],
+        :object => 'list',
+        :url => '/v0/subscriptions'
+      }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paid
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryan Jackson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-25 00:00:00.000000000 Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -148,7 +148,9 @@ files:
 - lib/paid/invoice.rb
 - lib/paid/list_object.rb
 - lib/paid/paid_object.rb
+- lib/paid/plan.rb
 - lib/paid/singleton_api_resource.rb
+- lib/paid/subscription.rb
 - lib/paid/transaction.rb
 - lib/paid/util.rb
 - lib/paid/version.rb
@@ -161,8 +163,10 @@ files:
 - test/paid/customer_test.rb
 - test/paid/invoice_test.rb
 - test/paid/list_object_test.rb
-- test/paid/metadata_test.rb
 - test/paid/paid_object_test.rb
+- test/paid/plan_test.rb
+- test/paid/properties_test.rb
+- test/paid/subscription_test.rb
 - test/paid/transaction_test.rb
 - test/paid/util_test.rb
 - test/test_data.rb
@@ -199,8 +203,10 @@ test_files:
 - test/paid/customer_test.rb
 - test/paid/invoice_test.rb
 - test/paid/list_object_test.rb
-- test/paid/metadata_test.rb
 - test/paid/paid_object_test.rb
+- test/paid/plan_test.rb
+- test/paid/properties_test.rb
+- test/paid/subscription_test.rb
 - test/paid/transaction_test.rb
 - test/paid/util_test.rb
 - test/test_data.rb

data/test/paid/metadata_test.rb

@@ -1,104 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Paid
-  class MetadataTest < Test::Unit::TestCase
-    setup do
-      @metadata_supported = {
-        :transaction => {
-          :new => Paid::Transaction.method(:new),
-          :test => method(:test_transaction),
-          :url => "/v0/transactions/#{test_transaction()[:id]}"
-        },
-        :customer => {
-          :new => Paid::Customer.method(:new),
-          :test => method(:test_customer),
-          :url => "/v0/customers/#{test_customer()[:id]}"
-        }
-      }
-
-      @base_url = 'https://api.paidapi.com'
-    end
-
-    should "not touch metadata" do
-      update_actions = lambda {|obj| obj.description = 'test'}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                    'description=test',
-                    update_actions)
-    end
-
-
-    should "update metadata as a whole" do
-      update_actions = lambda {|obj| obj.metadata = {'uuid' => '6735'}}
-      check_metadata({:metadata => {}},
-                    'metadata[uuid]=6735',
-                    update_actions)
-
-      if is_greater_than_ruby_1_9?
-        check_metadata({:metadata => {:initial => 'true'}},
-                      'metadata[uuid]=6735&metadata[initial]=',
-                      update_actions)
-      end
-    end
-
-    should "update metadata keys individually" do
-      update_actions = lambda {|obj| obj.metadata['txn_id'] = '134a13'}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata[txn_id]=134a13',
-                     update_actions)
-    end
-
-    should "clear metadata as a whole" do
-      update_actions = lambda {|obj| obj.metadata = nil}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata=',
-                     update_actions)
-    end
-
-    should "clear metadata keys individually" do
-      update_actions = lambda {|obj| obj.metadata['initial'] = nil}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata[initial]=',
-                     update_actions)
-    end
-
-    should "handle combinations of whole and partial metadata updates" do
-      if is_greater_than_ruby_1_9?
-        update_actions = lambda do |obj|
-          obj.metadata = {'type' => 'summer'}
-          obj.metadata['uuid'] = '6735'
-        end
-        params = {:metadata => {'type' => 'summer', 'uuid' => '6735'}}
-        curl_args = Paid.uri_encode(params)
-        check_metadata({:metadata => {'type' => 'christmas'}},
-                       curl_args,
-                       update_actions)
-      end
-    end
-
-    def check_metadata (initial_params, curl_args, metadata_update)
-      @metadata_supported.each do |name, methods|
-        neu = methods[:new]
-        test = methods[:test]
-        url = @base_url + methods[:url]
-
-        initial_test_obj = test.call(initial_params)
-        @mock.expects(:get).once.returns(test_response(initial_test_obj))
-
-        final_test_obj = test.call()
-        @mock.expects(:post).once.
-          returns(test_response(final_test_obj)).
-          with(url, nil, curl_args)
-
-        obj = neu.call("test")
-        obj.refresh()
-        metadata_update.call(obj)
-        obj.save
-      end
-    end
-
-    def is_greater_than_ruby_1_9?
-      version = RUBY_VERSION.dup  # clone preserves frozen state
-      Gem::Version.new(version) >= Gem::Version.new('1.9')
-    end
-  end
-end