stripe-ruby-mock 2.3.1 → 2.5.8

data/spec/shared_stripe_examples/subscription_items_examples.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+shared_examples 'Subscription Items API' do
+  let(:stripe_helper) { StripeMock.create_test_helper }
+  let(:plan) { stripe_helper.create_plan }
+  let(:plan2) { stripe_helper.create_plan(amount: 100, id: 'one_more_1_plan') }
+  let(:customer) { Stripe::Customer.create(source: stripe_helper.generate_card_token) }
+  let(:subscription) { Stripe::Subscription.create(customer: customer.id, items: [{ plan: plan.id }]) }
+
+  context 'creates an item' do
+    it 'when required params only' do
+      item = Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id)
+
+      expect(item.id).to match(/^test_si/)
+      expect(item.plan.id).to eq(plan.id)
+      expect(item.subscription).to eq(subscription.id)
+    end
+    it 'when no subscription params' do
+      expect { Stripe::SubscriptionItem.create(plan: plan.id) }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription')
+        expect(e.message).to eq('Missing required param: subscription.')
+      }
+    end
+    it 'when no plan params' do
+      expect { Stripe::SubscriptionItem.create(subscription: subscription.id) }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('plan')
+        expect(e.message).to eq('Missing required param: plan.')
+      }
+    end
+  end
+
+  context 'updates an item' do
+    let(:item) { Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id, quantity: 2 ) }
+
+    it 'updates plan' do
+      updated_item = Stripe::SubscriptionItem.update(item.id, plan: plan2.id)
+
+      expect(updated_item.plan.id).to eq(plan2.id)
+    end
+    it 'updates quantity' do
+      updated_item = Stripe::SubscriptionItem.update(item.id, quantity: 23)
+
+      expect(updated_item.quantity).to eq(23)
+    end
+    it 'when no existing item' do
+      expect { Stripe::SubscriptionItem.update('some_id') }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription_item')
+        expect(e.message).to eq('No such subscription_item: some_id')
+      }
+    end
+  end
+
+  context 'retrieves a list of items' do
+    before do
+      Stripe::SubscriptionItem.create(plan: plan.id, subscription: subscription.id, quantity: 2 )
+      Stripe::SubscriptionItem.create(plan: plan2.id, subscription: subscription.id, quantity: 20)
+    end
+
+    it 'retrieves all subscription items' do
+      all = Stripe::SubscriptionItem.list(subscription: subscription.id)
+
+      expect(all.count).to eq(2)
+    end
+    it 'when no subscription param' do
+      expect { Stripe::SubscriptionItem.list }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.param).to eq('subscription')
+        expect(e.message).to eq('Missing required param: subscription.')
+      }
+    end
+  end
+end

data/spec/shared_stripe_examples/tax_rate_examples.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+shared_examples 'TaxRate API' do
+  context 'with created tax rate' do
+    let!(:rate) { Stripe::TaxRate.create }
+
+    it 'returns list of tax rates' do
+      rates = Stripe::TaxRate.list
+      expect(rates.count).to eq(1)
+    end
+
+    it 'retrieves tax rate' do
+      ret_rate = Stripe::TaxRate.retrieve(rate.id)
+      expect(ret_rate.id).not_to be_nil
+      expect(ret_rate.object).to eq('tax_rate')
+      expect(ret_rate.display_name).to eq('VAT')
+      expect(ret_rate.percentage).to eq(21.0)
+      expect(ret_rate.jurisdiction).to eq('EU')
+      expect(ret_rate.inclusive).to eq(false)
+    end
+
+    it 'updates tax rate' do
+      ret_rate = Stripe::TaxRate.update(rate.id, percentage: 30.5)
+      expect(ret_rate.id).not_to be_nil
+      expect(ret_rate.object).to eq('tax_rate')
+      expect(ret_rate.display_name).to eq('VAT')
+      expect(ret_rate.percentage).to eq(30.5)
+      expect(ret_rate.jurisdiction).to eq('EU')
+      expect(ret_rate.inclusive).to eq(false)
+    end
+  end
+
+  it 'creates tax rate' do
+    rate = Stripe::TaxRate.create
+    expect(rate.id).not_to be_nil
+    expect(rate.object).to eq('tax_rate')
+    expect(rate.display_name).to eq('VAT')
+    expect(rate.percentage).to eq(21.0)
+    expect(rate.jurisdiction).to eq('EU')
+    expect(rate.inclusive).to eq(false)
+  end
+end

data/spec/shared_stripe_examples/transfer_examples.rb

@@ -3,22 +3,39 @@ require 'spec_helper'
 shared_examples 'Transfer API' do
 
   it "creates a stripe transfer" do
-    recipient = Stripe::Recipient.create(type:  "corporation", name: "MyCo")
-    transfer = Stripe::Transfer.create(amount:  "100", currency: "usd", recipient: recipient.id)
+    destination = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", id: "acct_12345")
+    transfer = Stripe::Transfer.create(amount: 100, currency: "usd", destination: destination.id)
 
     expect(transfer.id).to match /^test_tr/
-    expect(transfer.amount).to eq('100')
+    expect(transfer.amount).to eq(100)
+    expect(transfer.amount_reversed).to eq(0)
+    expect(transfer.balance_transaction).to eq('txn_2dyYXXP90MN26R')
+    expect(transfer.created).to eq(1304114826)
     expect(transfer.currency).to eq('usd')
-    expect(transfer.recipient).to eq recipient.id
+    expect(transfer.description).to eq('Transfer description')
+    expect(transfer.destination).to eq('acct_12345')
+    expect(transfer.destination_payment).to eq("py_164xRvKbnvuxQXGuVFV2pZo1")
+    expect(transfer.livemode).to eq(false)
+    expect(transfer.metadata).to eq(Stripe::StripeObject.new)
+    expect(transfer.reversals).to eq(Stripe::ListObject.construct_from({
+      object: "list",
+      data: [],
+      total_count: 0,
+      has_more: false,
+      url: "/v1/transfers/#{transfer.id}/reversals"
+    }))
     expect(transfer.reversed).to eq(false)
+    expect(transfer.source_transaction).to eq("ch_164xRv2eZvKYlo2Clu1sIJWB")
+    expect(transfer.source_type).to eq("card")
+    expect(transfer.transfer_group).to eq("group_ch_164xRv2eZvKYlo2Clu1sIJWB")
   end
 
   describe "listing transfers" do
-    let(:recipient) { Stripe::Recipient.create(type: "corporation", name: "MyCo") }
+    let(:destination) { Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "MyCo") }
 
     before do
       3.times do
-        Stripe::Transfer.create(amount: "100", currency: "usd", recipient: recipient.id)
+        Stripe::Transfer.create(amount: "100", currency: "usd", destination: destination.id)
       end
     end
 
@@ -30,30 +47,52 @@ shared_examples 'Transfer API' do
       expect(Stripe::Transfer.all(limit: 2).count).to eq(2)
     end
 
-    it "filters the search to a specific recipient" do
-      r2 = Stripe::Recipient.create(type: "corporation", name: "MyCo")
-      Stripe::Transfer.create(amount: "100", currency: "usd", recipient: r2.id)
+    it "filters the search to a specific destination" do
+      d2 = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "MyCo")
+      Stripe::Transfer.create(amount: "100", currency: "usd", destination: d2.id)
 
-      expect(Stripe::Transfer.all(recipient: r2.id).count).to eq(1)
+      expect(Stripe::Transfer.all(destination: d2.id).count).to eq(1)
+    end
+
+    it "disallows unknown parameters" do
+      expect { Stripe::Transfer.all(recipient: "foo") }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq("recipient")
+        expect(e.message).to eq("Received unknown parameter: recipient")
+        expect(e.http_status).to eq(400)
+      }
     end
   end
 
 
   it "retrieves a stripe transfer" do
-    original = Stripe::Transfer.create(amount:  "100", currency: "usd")
+    original = Stripe::Transfer.create(amount: "100", currency: "usd")
     transfer = Stripe::Transfer.retrieve(original.id)
 
     expect(transfer.id).to eq(original.id)
+    expect(transfer.object).to eq(original.object)
     expect(transfer.amount).to eq(original.amount)
+    expect(transfer.amount_reversed).to eq(original.amount_reversed)
+    expect(transfer.balance_transaction).to eq(original.balance_transaction)
+    expect(transfer.created).to eq(original.created)
     expect(transfer.currency).to eq(original.currency)
-    expect(transfer.recipient).to eq(original.recipient)
+    expect(transfer.description).to eq(original.description)
+    expect(transfer.destination).to eq(original.destination)
+    expect(transfer.destination_payment).to eq(original.destination_payment)
+    expect(transfer.livemode).to eq(original.livemode)
+    expect(transfer.metadata).to eq(original.metadata)
+    expect(transfer.reversals).to eq(original.reversals)
+    expect(transfer.reversed).to eq(original.reversed)
+    expect(transfer.source_transaction).to eq(original.source_transaction)
+    expect(transfer.source_type).to eq(original.source_type)
+    expect(transfer.transfer_group).to eq(original.transfer_group)
   end
 
-  it "canceles a stripe transfer " do
+  it "cancels a stripe transfer" do
     original = Stripe::Transfer.create(amount:  "100", currency: "usd")
-    res, api_key = Stripe.request(:post, "/v1/transfers/#{original.id}/cancel", 'api_key', {})
+    res, api_key = Stripe::StripeClient.active_client.execute_request(:post, "/v1/transfers/#{original.id}/cancel", api_key: 'api_key')
 
-    expect(res[:status]).to eq("canceled")
+    expect(res.data[:status]).to eq("canceled")
   end
 
   it "cannot retrieve a transfer that doesn't exist" do
@@ -64,17 +103,27 @@ shared_examples 'Transfer API' do
     }
   end
 
-  it 'when amount is not integer', live: true do
-    rec = Stripe::Recipient.create({
-                                       type:  'individual',
-                                       name: 'Alex Smith',
-                                   })
+  it "when amount is not integer", live: true do
+    dest = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "Alex Smith")
     expect { Stripe::Transfer.create(amount: '400.2',
-                                       currency: 'usd',
-                                       recipient: rec.id,
-                                       description: 'Transfer for test@example.com') }.to raise_error { |e|
+                                     currency: 'usd',
+                                     destination: dest.id,
+                                     description: 'Transfer for test@example.com') }.to raise_error { |e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('amount')
+      expect(e.http_status).to eq(400)
+    }
+  end
+
+  it "when amount is negative", live: true do
+    dest = Stripe::Account.create(type: "custom", email: "#{SecureRandom.uuid}@example.com", business_name: "Alex Smith")
+    expect { Stripe::Transfer.create(amount: '-400',
+                                     currency: 'usd',
+                                     destination: dest.id,
+                                     description: 'Transfer for test@example.com') }.to raise_error { |e|
       expect(e).to be_a Stripe::InvalidRequestError
       expect(e.param).to eq('amount')
+      expect(e.message).to match(/^Invalid.*integer/)
       expect(e.http_status).to eq(400)
     }
   end

data/spec/shared_stripe_examples/webhook_event_examples.rb

@@ -70,10 +70,10 @@ shared_examples 'Webhook Events API' do
     expect(data[event_b.id][:id]).to eq(event_b.id)
   end
 
-  it "handles stripe connect event when user_id is present" do
+  it "handles stripe connect event when account is present" do
   	acc_12314 = 'acc_12314'
-    event = StripeMock.mock_webhook_event('customer.created', user_id: acc_12314)
-    expect(event[:user_id]).to eq(acc_12314)
+    event = StripeMock.mock_webhook_event('customer.created', account: acc_12314)
+    expect(event[:account]).to eq(acc_12314)
   end
 
   it "retrieves an eveng using the event resource" do
@@ -129,6 +129,22 @@ shared_examples 'Webhook Events API' do
     }.to raise_error StripeMock::UnsupportedRequestError
   end
 
+  it 'has actual created attribute' do
+    time = Time.now.to_i
+
+    evnt = StripeMock.mock_webhook_event('customer.subscription.updated')
+
+    expect(evnt.created).to eq time
+  end
+
+  it 'when created param can be overrided' do
+    time = Time.now.to_i - 1000
+
+    evnt = StripeMock.mock_webhook_event('customer.subscription.updated', created: time)
+
+    expect(evnt.created).to eq time
+  end
+
   describe "listing events" do
 
     it "retrieves all events" do
@@ -183,10 +199,63 @@ shared_examples 'Webhook Events API' do
       events = Stripe::Event.all(limit: 3)
 
       expect(events.count).to eq(3)
-      expect(events.map &:id).to include(customer_created_event.id, plan_created_event.id, coupon_created_event.id)
-      expect(events.map &:type).to include('customer.created', 'plan.created', 'coupon.created')
+      expect(events.map &:id).to include(invoice_item_created_event.id, invoice_created_event.id, coupon_created_event.id)
+      expect(events.map &:type).to include('invoiceitem.created', 'invoice.created', 'coupon.created')
     end
 
   end
+  
+  describe 'Subscription events' do 
+    it "Checks for billing items in customer.subscription.created" do 
+      subscription_created_event = StripeMock.mock_webhook_event('customer.subscription.created')
+      expect(subscription_created_event).to be_a(Stripe::Event)
+      expect(subscription_created_event.id).to_not be_nil
+      expect(subscription_created_event.data.object.items.data.class).to be Array
+      expect(subscription_created_event.data.object.items.data.length).to be 2
+      expect(subscription_created_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_created_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+
+    it "Checks for billing items in customer.subscription.deleted" do 
+      subscription_deleted_event = StripeMock.mock_webhook_event('customer.subscription.deleted')
+      expect(subscription_deleted_event).to be_a(Stripe::Event)
+      expect(subscription_deleted_event.id).to_not be_nil
+      expect(subscription_deleted_event.data.object.items.data.class).to be Array
+      expect(subscription_deleted_event.data.object.items.data.length).to be 2
+      expect(subscription_deleted_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_deleted_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+    
+    it "Checks for billing items in customer.subscription.updated" do 
+      subscription_updated_event = StripeMock.mock_webhook_event('customer.subscription.updated')
+      expect(subscription_updated_event).to be_a(Stripe::Event)
+      expect(subscription_updated_event.id).to_not be_nil
+      expect(subscription_updated_event.data.object.items.data.class).to be Array
+      expect(subscription_updated_event.data.object.items.data.length).to be 2
+      expect(subscription_updated_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_updated_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+    
+    it "Checks for billing items in customer.subscription.trial_will_end" do 
+      subscription_trial_will_end_event = StripeMock.mock_webhook_event('customer.subscription.trial_will_end')
+      expect(subscription_trial_will_end_event).to be_a(Stripe::Event)
+      expect(subscription_trial_will_end_event.id).to_not be_nil
+      expect(subscription_trial_will_end_event.data.object.items.data.class).to be Array
+      expect(subscription_trial_will_end_event.data.object.items.data.length).to be 2
+      expect(subscription_trial_will_end_event.data.object.items.data.first).to respond_to(:plan)
+      expect(subscription_trial_will_end_event.data.object.items.data.first.id).to eq('si_00000000000000')
+    end
+  end
 
+  describe 'Invoices events' do 
+    it "Checks for billing items in invoice.payment_succeeded" do
+      invoice_payment_succeeded = StripeMock.mock_webhook_event('invoice.payment_succeeded')
+      expect(invoice_payment_succeeded).to be_a(Stripe::Event)
+      expect(invoice_payment_succeeded.id).to_not be_nil
+      expect(invoice_payment_succeeded.data.object.lines.data.class).to be Array
+      expect(invoice_payment_succeeded.data.object.lines.data.length).to be 2
+      expect(invoice_payment_succeeded.data.object.lines.data.first).to respond_to(:plan)
+      expect(invoice_payment_succeeded.data.object.lines.data.first.id).to eq('sub_00000000000000')
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -30,9 +30,10 @@ RSpec.configure do |c|
     if ENV['IS_TRAVIS']
       puts "Travis ruby version: #{RUBY_VERSION}"
       api_key = case RUBY_VERSION
-      when '1.9.3' then ENV['STRIPE_TEST_SECRET_KEY_A']
-      when '2.0.0' then ENV['STRIPE_TEST_SECRET_KEY_B']
-      when '2.1.6' then ENV['STRIPE_TEST_SECRET_KEY_C']
+      when '2.0.0'  then ENV['STRIPE_TEST_SECRET_KEY_A']
+      when '2.1.10' then ENV['STRIPE_TEST_SECRET_KEY_B']
+      when '2.2.7'  then ENV['STRIPE_TEST_SECRET_KEY_C']
+      when '2.3.4'  then ENV['STRIPE_TEST_SECRET_KEY_D']
       end
     else
       api_key = ENV['STRIPE_TEST_SECRET_KEY']
@@ -42,11 +43,11 @@ RSpec.configure do |c|
     end
 
     c.before(:each) do
-      StripeMock.stub(:start).and_return(nil)
-      StripeMock.stub(:stop).and_return(nil)
+      allow(StripeMock).to receive(:start).and_return(nil)
+      allow(StripeMock).to receive(:stop).and_return(nil)
       Stripe.api_key = api_key
     end
-    c.after(:each) { sleep 1 }
+    c.after(:each) { sleep 0.01 }
   else
     c.filter_run_excluding :oauth => true
     Stripe.api_key ||= ''

data/spec/stripe_mock_spec.rb

@@ -4,15 +4,28 @@ describe StripeMock do
 
   it "overrides stripe's request method" do
     StripeMock.start
-    Stripe.request(:xtest, '/', 'abcde') # no error
+    Stripe::StripeClient.active_client.execute_request(:xtest, '/', api_key: 'abcde') # no error
+    StripeMock.stop
+  end
+
+  it "overrides stripe's execute_request method in other threads" do
+    StripeMock.start
+    Thread.new { Stripe::StripeClient.active_client.execute_request(:xtest, '/', api_key: 'abcde') }.join # no error
     StripeMock.stop
   end
 
   it "reverts overriding stripe's request method" do
     StripeMock.start
-    Stripe.request(:xtest, '/', 'abcde') # no error
+    Stripe::StripeClient.active_client.execute_request(:xtest, '/', api_key: 'abcde') # no error
+    StripeMock.stop
+    expect { Stripe::StripeClient.active_client.execute_request(:x, '/', api_key: 'abcde') }.to raise_error ArgumentError
+  end
+
+  it "reverts overriding stripe's execute_request method in other threads" do
+    StripeMock.start
+    Thread.new { Stripe::StripeClient.active_client.execute_request(:xtest, '/', api_key: 'abcde') }.join # no error
     StripeMock.stop
-    expect { Stripe.request(:x, '/', 'abcde') }.to raise_error
+    expect { Thread.new { Stripe::StripeClient.active_client.execute_request(:x, '/', api_key: 'abcde') }.join }.to raise_error ArgumentError
   end
 
   it "does not persist data between mock sessions" do

data/spec/support/stripe_examples.rb

@@ -1,4 +1,3 @@
-
 def require_stripe_examples
   Dir["./spec/shared_stripe_examples/**/*.rb"].each {|f| require f}
   Dir["./spec/integration_examples/**/*.rb"].each {|f| require f}
@@ -6,12 +5,14 @@ end
 
 def it_behaves_like_stripe(&block)
   it_behaves_like 'Account API', &block
+  it_behaves_like 'Balance API', &block
   it_behaves_like 'Balance Transaction API', &block
   it_behaves_like 'Bank Account Token Mocking', &block
   it_behaves_like 'Card Token Mocking', &block
   it_behaves_like 'Card API', &block
   it_behaves_like 'Charge API', &block
   it_behaves_like 'Bank API', &block
+  it_behaves_like 'External Account API', &block
   it_behaves_like 'Coupon API', &block
   it_behaves_like 'Customer API', &block
   it_behaves_like 'Dispute API', &block
@@ -19,12 +20,18 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'Invoice API', &block
   it_behaves_like 'Invoice Item API', &block
   it_behaves_like 'Plan API', &block
+  it_behaves_like 'Product API', &block
   it_behaves_like 'Recipient API', &block
   it_behaves_like 'Refund API', &block
   it_behaves_like 'Transfer API', &block
+  it_behaves_like 'Payout API', &block
   it_behaves_like 'Stripe Error Mocking', &block
   it_behaves_like 'Customer Subscriptions', &block
+  it_behaves_like 'Subscription Items API', &block
   it_behaves_like 'Webhook Events API', &block
+  it_behaves_like 'Country Spec API', &block
+  it_behaves_like 'EphemeralKey API', &block
+  it_behaves_like 'TaxRate API', &block
 
   # Integration tests
   it_behaves_like 'Multiple Customer Cards'

data/spec/util_spec.rb

@@ -19,7 +19,7 @@ describe StripeMock::Util do
       expect(result).to eq({ x: { y: 999, z: { m: 44, n: 55 } } })
     end
 
-    it "merges array elements" do
+    it "merges array elements (that are hashes)" do
       dest = { x: [ {a: 1}, {b: 2}, {c: 3} ] }
       source = { x: [ {a: 0}, {a: 0} ] }
       result = StripeMock::Util.rmerge(dest, source)
@@ -27,6 +27,40 @@ describe StripeMock::Util do
       expect(result).to eq({ x: [ {a: 0}, {a: 0, b: 2}, {c: 3} ] })
     end
 
+    context "array elements (that are simple values)" do
+      it "merges arrays" do
+        dest = { x: [ 1, 2 ] }
+        source = { x: [ 3, 4 ] }
+        result = StripeMock::Util.rmerge(dest, source)
+
+        expect(result).to eq({ x: [ 1, 3, 2, 4 ] })
+      end
+
+      it "ignores empty arrays" do
+        dest = { x: [] }
+        source = { x: [ 3, 4 ] }
+        result = StripeMock::Util.rmerge(dest, source)
+
+        expect(result).to eq({ x: [ 3, 4 ] })
+      end
+
+      it "removes nil values" do
+        dest = { x: [ 1, 2, nil ] }
+        source = { x: [ nil, 3, 4 ] }
+        result = StripeMock::Util.rmerge(dest, source)
+
+        expect(result).to eq({ x: [ 1, 2, 3, 4 ] })
+      end
+
+      it "respects duplicate values" do
+        dest = { x: [ 1, 2, 3 ] }
+        source = { x: [ 3, 4 ] }
+        result = StripeMock::Util.rmerge(dest, source)
+
+        expect(result).to eq({ x: [ 1, 3, 2, 4, 3 ] })
+      end
+    end
+
     it "does not truncate the array when merging" do
       dest = { x: [ {a: 1}, {b: 2} ] }
       source = { x: [ nil, nil, {c: 3} ] }

data/stripe-ruby-mock.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'stripe', '~> 1.31'
+  gem.add_dependency 'stripe', '>= 2.0.3'
   gem.add_dependency 'multi_json', '~> 1.0'
   gem.add_dependency 'dante', '>= 0.2.0'