itunes-receipt-mock 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e89959f9b704e3139a602239387361f6aa7a8b98
-  data.tar.gz: e237a12123a3c5193b951359c79df514a0e89812
+  metadata.gz: efc7aa090d82b68d8a3ac83e0ddd6723aaef8259
+  data.tar.gz: 5397e14dd57d12944d392cdcfe8b49df155bdb49
 SHA512:
-  metadata.gz: f21216a625c2226f9cc7f7f011e797f7fc03294f5c698361edc83993e90dcb23840bacb9115640bda5b54a9823a0d9d7430c0e4f64ad2da3f0de36af6e3d4278
-  data.tar.gz: 506df8e5fb160fbacbf0172090cabb76d32310461cede025613380ebbae220053f58ce5020582af325fc0f6803b718d3e6732230d510464e2fc96453ea298816
+  metadata.gz: ed57db647afc32fc3dbab1154f61beb1d98ade455a80231d39b47efec02486454f2a22c88c3f775dfee0db6644f0e83cea917e53f3e4dcbf90ce2dce1acdefcf
+  data.tar.gz: 9b6fc7473831a9650378b176d1442fd43d2c314e0ac942d9984aeb2e4d67c1247f2e93b5fd0731f0fdb2afba1317a71faf57b58ae83a0271b9bb66abbc3cc430

data/lib/itunes_receipt_mock.rb

@@ -1,6 +1,6 @@
 require 'base64'
 require 'itunes_receipt_mock/mixins'
-require 'itunes_receipt_mock/validation'
+require 'itunes_receipt_mock/transaction_proxy'
 require 'itunes_receipt_mock/receipt'
 require 'itunes_receipt_mock/purchase'
 require 'itunes_receipt_mock/subscription'
@@ -10,24 +10,7 @@ require 'itunes_receipt_mock/subscription'
 module ItunesReceiptMock
   class MissingArgumentError < StandardError; end
 
-  @transaction_id = 1_000_000_000
-  @web_order_line_item_id = 1_000_000_000
-  ##
-  # Creates a new iTunes receipt
-  #
-  # Returns: rdoc-ref:ItunesReceiptMock::Validation
-  #
-  # Params:
-  # +options+:: rdoc-ref:ItunesReceiptMock
   def self.new(options = {})
-    Validation.new(options)
-  end
-
-  def self.next_transaction_id
-    @transaction_id += 1
-  end
-
-  def self.next_web_order_line_item_id
-    @web_order_line_item_id += 1
+    Receipt.new(options)
   end
 end

data/lib/itunes_receipt_mock/mixins.rb

@@ -15,7 +15,7 @@ module ItunesReceiptMock
     def date_attrs(prefix, date)
       {
         "#{prefix}_date" => date.utc.strftime('%F %T') + ' Etc/GMT',
-        "#{prefix}_date_ms" => date.utc.strftime('%s%L').to_i,
+        "#{prefix}_date_ms" => date.utc.strftime('%s%L'),
         "#{prefix}_date_pst" => date.getlocal('-08:00').strftime('%F %T') +
           ' America/Los_Angeles'
       }

data/lib/itunes_receipt_mock/purchase.rb

@@ -7,30 +7,37 @@ module ItunesReceiptMock
     include ItunesReceiptMock::Mixins
 
     PURCHASE_DEFAULTS = {
+      receipt: nil,
       product_id: nil,
       quantity: 1,
-      transaction_id: proc { ItunesReceiptMock.next_transaction_id },
+      transaction_id: proc { receipt.transactions.next_transaction_id },
       original_transaction_id: proc { transaction_id },
       purchase_date: proc { Time.now },
-      original_purchase_date: proc { purchase_date }
+      original_purchase_date: proc { purchase_date },
+      is_trial_period: false,
+      in_app: true
     }
 
     attr_accessor :quantity, :product_id, :transaction_id,
                   :original_transaction_id, :purchase_date,
-                  :original_purchase_date
+                  :original_purchase_date, :is_trial_period,
+                  :receipt, :in_app
+
+    alias_method :in_app?, :in_app
 
     def initialize(options = {})
       send_defaults(PURCHASE_DEFAULTS, options)
-      fail ItunesReceiptMock::MissingArgumentError,
-           'product_id is required' unless @product_id
+      fail MissingArgumentError, 'product_id is required' unless @product_id
+      fail MissingArgumentError, 'receipt is required' unless @receipt
     end
 
-    def result(_options = {})
+    def as_json
       {
-        'quantity' => quantity,
+        'quantity' => quantity.to_s,
         'product_id' => product_id,
-        'transaction_id' => transaction_id,
-        'original_transaction_id' => original_transaction_id
+        'transaction_id' => transaction_id.to_s,
+        'original_transaction_id' => original_transaction_id.to_s,
+        'is_trial_period' => is_trial_period.to_s
       }
         .merge(date_attrs('purchase', purchase_date))
         .merge(date_attrs('original_purchase', original_purchase_date))

data/lib/itunes_receipt_mock/receipt.rb

@@ -6,9 +6,12 @@ module ItunesReceiptMock
   class Receipt
     include ItunesReceiptMock::Mixins
 
-    RECEIPT_DEFAULTS = {
-      bundle_id: nil,
+    STATUS_CODES = [0, 21_000] + (21_002..21_008).to_a
+    DEFAULTS = {
+      status: 0,
+      request_date: proc { Time.now },
       environment: 'Production',
+      bundle_id: nil,
       adam_id: 1,
       app_item_id: 1,
       application_version: 1,
@@ -18,20 +21,37 @@ module ItunesReceiptMock
       original_application_version: 1
     }
 
-    attr_reader :in_app
-    attr_accessor :environment, :adam_id, :app_item_id, :bundle_id,
-                  :application_version, :download_id,
+    attr_reader :transactions
+    attr_accessor :status, :environment, :request_date, :adam_id, :app_item_id,
+                  :bundle_id, :application_version, :download_id,
                   :version_external_identifier, :original_purchase_date,
                   :original_application_version
 
     def initialize(options = {})
-      @in_app = {}
-      send_defaults(RECEIPT_DEFAULTS, options)
+      send_defaults(DEFAULTS, options)
+      @transactions = TransactionProxy.new(self)
       fail MissingArgumentError, 'bundle_id is required' unless @bundle_id
     end
 
-    def result(options = {})
-      request_date = options.fetch :request_date, Time.now
+    def as_json
+      result = { 'status' => status }
+      if status == 0
+        result.merge!(
+          'status' => status,
+          'environment' => environment,
+          'receipt' => inner_json,
+          'latest_receipt_info' => transactions.latest_receipt_info
+        )
+        result.merge!(
+          'latest_receipt' => Base64.strict_encode64(result.to_json)
+        )
+      end
+      result
+    end
+
+    private
+
+    def inner_json
       {
         'receipt_type' => environment,
         'adam_id' => adam_id.to_i,
@@ -42,28 +62,10 @@ module ItunesReceiptMock
         'version_external_identifier' => version_external_identifier.to_i,
         'original_application_version' =>
           format('%.1f', original_application_version),
-        'in_app' => in_app_result(options)
+        'in_app' => transactions.in_app
       }
         .merge(date_attrs('request', request_date))
         .merge(date_attrs('original_purchase', original_purchase_date))
     end
-
-    def add_purchase(options = {})
-      purchase = Purchase.new(options)
-      @in_app[purchase.transaction_id] = purchase
-      purchase
-    end
-
-    def add_subscription(options = {})
-      purchase = Subscription.new(options)
-      @in_app[purchase.transaction_id] = purchase
-      purchase
-    end
-
-    private
-
-    def in_app_result(options)
-      in_app.map { |_, v| v.result(options) }
-    end
   end
 end

data/lib/itunes_receipt_mock/subscription.rb

@@ -7,23 +7,34 @@ module ItunesReceiptMock
     SUBSCRIPTION_DEFAULTS = {
       expires_date: nil,
       web_order_line_item_id: proc do
-        ItunesReceiptMock.next_web_order_line_item_id
-      end,
-      is_trial_period: false
+        receipt.transactions.next_web_order_line_item_id
+      end
     }
 
-    attr_accessor :expires_date, :web_order_line_item_id, :is_trial_period
+    attr_accessor :expires_date, :web_order_line_item_id
 
-    def initialize(options = {})
+    def initialize(options)
       super
       send_defaults(SUBSCRIPTION_DEFAULTS, options)
       fail MissingArgumentError, 'expires_date is required' unless @expires_date
     end
 
-    def result(_options = {})
+    def renew(options)
+      attrs = {
+        receipt: receipt,
+        in_app: false,
+        quantity: quantity,
+        product_id: product_id,
+        original_transaction_id: transaction_id,
+        original_purchase_date: purchase_date,
+        is_trial_period: is_trial_period
+      }.merge(options)
+      receipt.transactions.create attrs
+    end
+
+    def as_json
       super.merge(
-        'web_order_line_item_id' => web_order_line_item_id.to_s,
-        'is_trial_period' => is_trial_period
+        'web_order_line_item_id' => web_order_line_item_id.to_s
       ).merge(date_attrs('expires', expires_date))
     end
   end

data/lib/itunes_receipt_mock/transaction_proxy.rb

@@ -0,0 +1,38 @@
+##
+# ItunesReceiptMock
+module ItunesReceiptMock
+  ##
+  # ItunesReceiptMock::TransactionProxy
+  class TransactionProxy < Array
+    attr_accessor :receipt, :transaction_id, :web_order_line_item_id
+
+    def initialize(receipt)
+      @receipt = receipt
+      @transaction_id = 1_000_000_000
+      @web_order_line_item_id = 1_000_000_000
+    end
+
+    def create(options)
+      klass = options[:expires_date].nil? ? Purchase : Subscription
+      transaction = klass.new options.merge(receipt: @receipt)
+      self << transaction
+      transaction
+    end
+
+    def in_app
+      select(&:in_app?).map(&:as_json)
+    end
+
+    def latest_receipt_info
+      map(&:as_json)
+    end
+
+    def next_transaction_id
+      @transaction_id += 1
+    end
+
+    def next_web_order_line_item_id
+      @web_order_line_item_id += 1
+    end
+  end
+end

data/lib/itunes_receipt_mock/version.rb

@@ -1,5 +1,5 @@
 ##
 # ItunesReceiptMock::VERSION
 module ItunesReceiptMock
-  VERSION = '0.0.5'
+  VERSION = '0.1.0'
 end

data/spec/itunes_receipt_mock_spec.rb

@@ -0,0 +1,409 @@
+require 'spec_helper'
+
+describe ItunesReceiptMock do
+  before do
+    Timecop.freeze
+  end
+
+  after do
+    Timecop.return
+  end
+
+  describe '.new' do
+    subject { described_class.new(options) }
+
+    let(:options) { { bundle_id: 'com.example' } }
+
+    it 'initializes a Receipt' do
+      expect(subject).to be_a(described_class::Receipt)
+    end
+
+    it 'sets the attributes' do
+      expect(subject.status).to eq(0)
+      expect(subject.request_date).to eq(Time.now)
+      expect(subject.environment).to eq('Production')
+      expect(subject.bundle_id).to eq('com.example')
+      expect(subject.adam_id).to eq(1)
+      expect(subject.app_item_id).to eq(1)
+      expect(subject.application_version).to eq(1)
+      expect(subject.download_id).to eq(1)
+      expect(subject.version_external_identifier).to eq(1)
+      expect(subject.original_purchase_date).to eq(Time.now)
+      expect(subject.original_application_version).to eq(1)
+    end
+
+    it 'initializes the transactions' do
+      expect(subject.transactions).to be_a(described_class::TransactionProxy)
+    end
+
+    context 'when options are populated' do
+      let(:options) do
+        {
+          status: 21_000,
+          request_date: 1.day.ago,
+          environment: 'Sandbox',
+          bundle_id: 'com.example2',
+          adam_id: 2,
+          app_item_id: 2,
+          application_version: 2,
+          download_id: 2,
+          version_external_identifier: 2,
+          original_purchase_date: 1.day.ago,
+          original_application_version: 2
+        }
+      end
+
+      it 'sets the attributes' do
+        expect(subject.status).to eq(21_000)
+        expect(subject.request_date).to eq(1.day.ago)
+        expect(subject.environment).to eq('Sandbox')
+        expect(subject.bundle_id).to eq('com.example2')
+        expect(subject.adam_id).to eq(2)
+        expect(subject.app_item_id).to eq(2)
+        expect(subject.application_version).to eq(2)
+        expect(subject.download_id).to eq(2)
+        expect(subject.version_external_identifier).to eq(2)
+        expect(subject.original_purchase_date).to eq(1.day.ago)
+        expect(subject.original_application_version).to eq(2)
+      end
+    end
+
+    context 'when bundle_id is not present' do
+      let(:options) { {} }
+
+      it 'raises an MissingArgumentError' do
+        expect { subject }.to raise_error(
+          described_class::MissingArgumentError,
+          'bundle_id is required'
+        )
+      end
+    end
+  end
+
+  describe '#receipt.transactions.create' do
+    subject { receipt.transactions.create(options) }
+
+    let(:receipt) { described_class.new(bundle_id: 'com.example') }
+
+    shared_examples 'a Purchase' do
+      it 'adds it to the transactions' do
+        expect(receipt.transactions).to include(subject)
+      end
+
+      it 'increments the transaction_id' do
+        expect(receipt.transactions.transaction_id).to eq(1_000_000_000)
+        subject
+        expect(receipt.transactions.transaction_id).to eq(1_000_000_001)
+      end
+
+      it 'sets the attributes' do
+        expect(subject.product_id).to eq('foobar')
+        expect(subject.quantity).to eq(1)
+        expect(subject.transaction_id).to eq(1_000_000_001)
+        expect(subject.original_transaction_id).to eq(subject.transaction_id)
+        expect(subject.purchase_date).to eq(Time.now)
+        expect(subject.original_purchase_date).to eq(subject.purchase_date)
+        expect(subject.is_trial_period).to eq(false)
+        expect(subject.in_app).to eq(true)
+        expect(subject.receipt).to eq(receipt)
+      end
+
+      context 'when options are populated' do
+        let(:options) do
+          {
+            product_id: 'whatever',
+            quantity: 2,
+            transaction_id: 999,
+            original_transaction_id: 998,
+            purchase_date: 1.day.ago,
+            original_purchase_date: 2.days.ago,
+            is_trial_period: true
+          }
+        end
+
+        it 'sets the attributes' do
+          expect(subject.product_id).to eq('whatever')
+          expect(subject.quantity).to eq(2)
+          expect(subject.transaction_id).to eq(999)
+          expect(subject.original_transaction_id).to eq(998)
+          expect(subject.purchase_date).to eq(1.day.ago)
+          expect(subject.original_purchase_date).to eq(2.days.ago)
+          expect(subject.is_trial_period).to eq(true)
+        end
+      end
+
+      context 'when product_id is missing' do
+        let(:options) { {} }
+
+        it 'raises an MissingArgumentError' do
+          expect { subject }.to raise_error(
+            described_class::MissingArgumentError,
+            'product_id is required'
+          )
+        end
+      end
+    end
+
+    shared_examples 'a Subscription' do
+      it_behaves_like 'a Purchase'
+
+      it 'increments the web_order_line_item_id' do
+        expect(receipt.transactions.web_order_line_item_id).to eq(1_000_000_000)
+        subject
+        expect(receipt.transactions.web_order_line_item_id).to eq(1_000_000_001)
+      end
+
+      it 'sets the attributes' do
+        expect(subject.expires_date).to eq(1.month.from_now)
+        expect(subject.web_order_line_item_id).to eq(1_000_000_001)
+      end
+
+      context 'when options are populated' do
+        let(:options) do
+          {
+            product_id: 'whatever',
+            expires_date: 7.days.from_now,
+            web_order_line_item_id: 999
+          }
+        end
+
+        it 'sets the attributes' do
+          expect(subject.web_order_line_item_id).to eq(999)
+        end
+      end
+    end
+
+    context 'creating a purchase' do
+      let(:options) do
+        {
+          product_id: 'foobar'
+        }
+      end
+
+      it 'initializes a Purchase' do
+        expect(subject).to be_a(described_class::Purchase)
+      end
+
+      it_behaves_like 'a Purchase'
+    end
+
+    context 'creating a subscription' do
+      let(:options) do
+        {
+          product_id: 'foobar',
+          expires_date: 1.month.from_now
+        }
+      end
+
+      it 'initializes a Subscription' do
+        expect(subject).to be_a(described_class::Subscription)
+      end
+
+      it_behaves_like 'a Subscription'
+    end
+  end
+
+  describe 'subscription.renew' do
+    subject { subscription.renew(options) }
+
+    let(:receipt) { described_class.new(bundle_id: 'com.example') }
+    let!(:subscription) do
+      receipt.transactions.create(
+        product_id: 'premium',
+        purchase_date: 1.month.ago,
+        expires_date: Time.now
+      )
+    end
+    let(:options) do
+      {
+        expires_date: 1.month.from_now
+      }
+    end
+
+    it 'initializes a Subscription' do
+      expect(subject).to be_a(described_class::Subscription)
+    end
+
+    it 'adds the new subscription to transactions' do
+      expect(receipt.transactions).to include(subject)
+      expect(receipt.transactions).to include(subscription)
+    end
+
+    it 'assigns the attributes' do
+      expect(subject.expires_date).to eq(1.month.from_now)
+      expect(subject.in_app).to eq(false)
+    end
+
+    context 'when in_app is set to true' do
+      let(:options) do
+        {
+          expires_date: 1.month.from_now,
+          in_app: true
+        }
+      end
+
+      it 'sets in_app to true' do
+        expect(subject.in_app).to eq(true)
+      end
+    end
+  end
+
+  describe '#receipt.as_json' do
+    subject { receipt.as_json }
+
+    let(:receipt) { described_class.new(bundle_id: 'com.example') }
+    let!(:purchase) do
+      receipt.transactions.create(product_id: 'foobar')
+    end
+    let!(:subscription) do
+      receipt.transactions.create(
+        product_id: 'premium',
+        purchase_date: 1.month.ago,
+        expires_date: Time.now
+      )
+    end
+    let(:in_app_purchase_json) do
+      subject['receipt']['in_app'].detect do |t|
+        t['transaction_id'].to_i == purchase.transaction_id
+      end
+    end
+    let(:latest_receipt_info_purchase_json) do
+      subject['latest_receipt_info'].detect do |t|
+        t['transaction_id'].to_i == purchase.transaction_id
+      end
+    end
+    let(:in_app_subscription_json) do
+      subject['receipt']['in_app'].detect do |t|
+        t['transaction_id'].to_i == subscription.transaction_id
+      end
+    end
+    let(:latest_receipt_info_subscription_json) do
+      subject['latest_receipt_info'].detect do |t|
+        t['transaction_id'].to_i == subscription.transaction_id
+      end
+    end
+
+    shared_examples 'a date' do
+      it 'displays the date in GMT' do
+        expect(json[prefix + '_date'])
+          .to eq(date.utc.strftime('%F %T') + ' Etc/GMT')
+      end
+
+      it 'displays the date as a ms timestamp' do
+        expect(json[prefix + '_date_ms'])
+          .to eq(date.utc.strftime('%s%L'))
+      end
+
+      it 'displays the date in PST' do
+        expect(json[prefix + '_date_pst'])
+          .to eq(date.getlocal('-08:00').strftime('%F %T') +
+                 ' America/Los_Angeles')
+      end
+    end
+
+    shared_examples 'a purchase json object' do
+      it 'contains all the details for a purchase' do
+        expect(json['product_id']).to eq(obj.product_id)
+        expect(json['quantity']).to eq(obj.quantity.to_s)
+        expect(json['original_transaction_id'])
+          .to eq(obj.original_transaction_id.to_s)
+      end
+
+      describe 'purchase date' do
+        let(:date) { obj.purchase_date }
+        let(:prefix) { 'purchase' }
+        it_behaves_like 'a date'
+      end
+
+      describe 'original purchase date' do
+        let(:date) { obj.original_purchase_date }
+        let(:prefix) { 'original_purchase' }
+        it_behaves_like 'a date'
+      end
+    end
+
+    shared_examples 'a subscription json object' do
+      it_behaves_like 'a purchase json object'
+
+      it 'contains all the details for a subscription' do
+        expect(json['web_order_line_item_id'])
+          .to eq(obj.web_order_line_item_id.to_s)
+        expect(json['is_trial_period']).to eq(obj.is_trial_period.to_s)
+      end
+
+      describe 'expires date' do
+        let(:date) { obj.expires_date }
+        let(:prefix) { 'expires' }
+        it_behaves_like 'a date'
+      end
+    end
+
+    it 'contains the lastest_receipt' do
+      expect(subject['latest_receipt']).to_not be_nil
+    end
+
+    it 'contains all the purchases in the receipt.in_app object' do
+      expect(subject['receipt']['in_app'].length).to eq(2)
+    end
+
+    it 'contains all the purchases in the latest_receipt_info object' do
+      expect(subject['latest_receipt_info'].length).to eq(2)
+    end
+
+    it_behaves_like 'a purchase json object' do
+      let(:obj) { purchase }
+      let(:json) { in_app_purchase_json }
+    end
+
+    it 'contains the same object for the purchase in latest_receipt_info' do
+      expect(in_app_purchase_json).to eq(latest_receipt_info_purchase_json)
+    end
+
+    it_behaves_like 'a subscription json object' do
+      let(:obj) { subscription }
+      let(:json) { in_app_subscription_json }
+    end
+
+    it 'contains the same object for the subscription in latest_receipt_info' do
+      expect(in_app_subscription_json)
+        .to eq(latest_receipt_info_subscription_json)
+    end
+
+    context 'renewing the subscription' do
+      let(:subscription_options) do
+        {
+          expires_date: 1.month.from_now
+        }
+      end
+
+      let!(:renewal) do
+        subscription.renew subscription_options
+      end
+
+      it 'contains two transactions in receipt.in_app' do
+        expect(subject['receipt']['in_app'].length).to eq(2)
+      end
+
+      it 'contains three transactions in latest_receipt_info' do
+        expect(subject['latest_receipt_info'].length).to eq(3)
+      end
+
+      context 'when in_app is true' do
+        let(:subscription_options) do
+          {
+            expires_date: 1.month.from_now,
+            in_app: true
+          }
+        end
+
+        it 'contains three transactions in receipt.in_app' do
+          expect(subject['receipt']['in_app'].length).to eq(3)
+        end
+
+        it 'contains three transactions in latest_receipt_info' do
+          expect(subject['latest_receipt_info'].length).to eq(3)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: itunes-receipt-mock
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - mbaasy.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-12 00:00:00.000000000 Z
+date: 2015-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -119,12 +119,10 @@ files:
 - lib/itunes_receipt_mock/purchase.rb
 - lib/itunes_receipt_mock/receipt.rb
 - lib/itunes_receipt_mock/subscription.rb
-- lib/itunes_receipt_mock/validation.rb
+- lib/itunes_receipt_mock/transaction_proxy.rb
 - lib/itunes_receipt_mock/version.rb
-- spec/module_spec.rb
-- spec/receipt_spec.rb
+- spec/itunes_receipt_mock_spec.rb
 - spec/spec_helper.rb
-- spec/validation_spec.rb
 homepage: https://github.com/mbaasy/itunes-receipt-mock-ruby
 licenses:
 - MIT

data/lib/itunes_receipt_mock/validation.rb

@@ -1,70 +0,0 @@
-##
-# ItunesReceiptMock
-module ItunesReceiptMock
-  ##
-  # ItunesReceiptMock::Validation
-  class Validation
-    include ItunesReceiptMock::Mixins
-
-    STATUS_CODES = [0, 21_000] + (21_002..21_008).to_a
-
-    attr_reader :receipt, :latest_receipt_info
-
-    def initialize(options = {})
-      @latest_receipt_info = {}
-      @receipt = Receipt.new(options)
-    end
-
-    def result(options = {})
-      status = options.fetch(:status, 0)
-      result = { 'status' => status }
-      if status == 0
-        result.merge!(
-          'status' => status,
-          'environment' => receipt.environment,
-          'receipt' => receipt.result(options),
-          'latest_receipt_info' => latest_receipt_info_result(options)
-        )
-        result.merge!(
-          'latest_receipt' => Base64.strict_encode64(result.to_json)
-        )
-      end
-      result
-    end
-
-    def add_purchase(options = {})
-      purchase = receipt.add_purchase(options)
-      @latest_receipt_info[purchase.transaction_id] = purchase
-      purchase
-    end
-
-    def add_subscription(options = {})
-      purchase = receipt.add_subscription(options)
-      @latest_receipt_info[purchase.transaction_id] = purchase
-      purchase
-    end
-
-    def renew_subscription(purchase, options = {})
-      expires_date = options.fetch(:expires_date, nil)
-      fail MissingArgumentError, 'expires_date is required' unless expires_date
-
-      attrs = {
-        quantity: purchase.quantity,
-        product_id: purchase.product_id,
-        original_transaction_id: purchase.original_transaction_id,
-        original_purchase_date: purchase.original_purchase_date,
-        web_order_line_item_id: purchase.web_order_line_item_id,
-        is_trial_period: purchase.is_trial_period
-      }.merge(expires_date: expires_date).merge(options)
-
-      receipt.in_app.delete(purchase.original_transaction_id)
-      add_subscription(attrs)
-    end
-
-    private
-
-    def latest_receipt_info_result(options)
-      latest_receipt_info.map { |_, v| v.result(options) }
-    end
-  end
-end

data/spec/module_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe ItunesReceiptMock do
-  describe '.new' do
-    subject { described_class.new(options) }
-
-    context 'with minimal options' do
-      let(:options) { { bundle_id: 'foobar' } }
-
-      it 'creates an instance of Validation' do
-        expect(subject).to be_a(described_class::Validation)
-      end
-    end
-
-    context 'when bundle_id is not present' do
-      let(:options) { {} }
-
-      it 'raises an MissingArgumentError' do
-        expect { subject }.to raise_error(
-          described_class::MissingArgumentError,
-          'bundle_id is required'
-        )
-      end
-    end
-  end
-
-  describe 'full integration' do
-    let(:validation) { described_class.new(bundle_id: 'com.example') }
-    let!(:purchase) { validation.add_purchase(product_id: 'foobar') }
-    let!(:subscription) do
-      validation.add_subscription product_id: 'premium',
-                                  purchase_date: 1.month.ago,
-                                  expires_date: Time.now
-    end
-    let(:in_app_purchase_json) do
-      subject['receipt']['in_app'].detect do |t|
-        t['transaction_id'] == purchase.transaction_id
-      end
-    end
-    let(:latest_receipt_info_purchase_json) do
-      subject['latest_receipt_info'].detect do |t|
-        t['transaction_id'] == purchase.transaction_id
-      end
-    end
-    let(:in_app_subscription_json) do
-      subject['receipt']['in_app'].detect do |t|
-        t['transaction_id'] == subscription.transaction_id
-      end
-    end
-    let(:latest_receipt_info_subscription_json) do
-      subject['latest_receipt_info'].detect do |t|
-        t['transaction_id'] == subscription.transaction_id
-      end
-    end
-
-    subject { validation.result }
-
-    shared_examples 'a date' do
-      it 'displays the date in GMT' do
-        expect(json[prefix + '_date'])
-          .to eq(date.utc.strftime('%F %T') + ' Etc/GMT')
-      end
-
-      it 'displays the date as a ms timestamp' do
-        expect(json[prefix + '_date_ms'])
-          .to eq(date.utc.strftime('%s%L').to_i)
-      end
-
-      it 'displays the date in PST' do
-        expect(json[prefix + '_date_pst'])
-          .to eq(date.getlocal('-08:00').strftime('%F %T') +
-                 ' America/Los_Angeles')
-      end
-    end
-
-    shared_examples 'a purchase json object' do
-      it 'contains all the details for a purchase' do
-        expect(json['product_id']).to eq(obj.product_id)
-        expect(json['quantity']).to eq(obj.quantity)
-        expect(json['original_transaction_id'])
-          .to eq(obj.original_transaction_id)
-      end
-
-      describe 'purchase date' do
-        let(:date) { obj.purchase_date }
-        let(:prefix) { 'purchase' }
-        it_behaves_like 'a date'
-      end
-
-      describe 'original purchase date' do
-        let(:date) { obj.original_purchase_date }
-        let(:prefix) { 'original_purchase' }
-        it_behaves_like 'a date'
-      end
-    end
-
-    shared_examples 'a subscription json object' do
-      it_behaves_like 'a purchase json object'
-
-      it 'contains all the details for a subscription' do
-        expect(json['web_order_line_item_id'])
-          .to eq(obj.web_order_line_item_id.to_s)
-        expect(json['is_trial_period']).to eq(obj.is_trial_period)
-      end
-
-      describe 'expires date' do
-        let(:date) { obj.expires_date }
-        let(:prefix) { 'expires' }
-        it_behaves_like 'a date'
-      end
-    end
-
-    it 'contains all the purchases in the receipt.in_app object' do
-      expect(subject['receipt']['in_app'].length).to eq(2)
-    end
-
-    it 'contains all the purchases in the latest_receipt_info object' do
-      expect(subject['latest_receipt_info'].length).to eq(2)
-    end
-
-    it_behaves_like 'a purchase json object' do
-      let(:obj) { purchase }
-      let(:json) { in_app_purchase_json }
-    end
-
-    it 'contains the same object for the purchase in latest_receipt_info' do
-      expect(in_app_purchase_json).to eq(latest_receipt_info_purchase_json)
-    end
-
-    it_behaves_like 'a subscription json object' do
-      let(:obj) { subscription }
-      let(:json) { in_app_subscription_json }
-    end
-
-    it 'contains the same object for the subscription in latest_receipt_info' do
-      expect(in_app_subscription_json)
-        .to eq(latest_receipt_info_subscription_json)
-    end
-
-    context 'renewing the subscription' do
-      let!(:renewal) do
-        validation.renew_subscription subscription,
-                                      expires_date: 1.month.from_now
-      end
-
-      it 'contains two subscription transactions in latest_receipt_info' do
-        expect(subject['latest_receipt_info'].length).to eq(3)
-      end
-    end
-  end
-end

data/spec/receipt_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-describe ItunesReceiptMock::Receipt do
-  before do
-    Timecop.freeze
-  end
-
-  after do
-    Timecop.return
-  end
-
-  describe '.new' do
-    subject { described_class.new(options) }
-
-    context 'with minimal options' do
-      let(:options) { { bundle_id: 'foobar' } }
-
-      it 'sets "bundle_id" to the option value' do
-        expect(subject.bundle_id).to eq(options[:bundle_id])
-      end
-
-      it 'defaults everything else' do
-        expect(subject.environment).to eq('Production')
-        expect(subject.adam_id).to eq(1)
-        expect(subject.app_item_id).to eq(1)
-        expect(subject.application_version).to eq(1)
-        expect(subject.download_id).to eq(1)
-        expect(subject.version_external_identifier).to eq(1)
-        expect(subject.original_purchase_date).to eq(Time.now)
-      end
-    end
-
-    context 'when options are complete' do
-      let(:options) do
-        {
-          bundle_id: 'foobar',
-          environment: 'Sandbox',
-          adam_id: rand(1..5),
-          app_item_id: rand(1..5),
-          application_version: rand(1..5).to_s,
-          download_id: rand(1..5),
-          version_external_identifier: rand(1..5),
-          original_purchase_date: Time.new(2015, 06, 20, 8, 16, 32)
-        }
-      end
-
-      it 'sets all the things' do
-        expect(subject.environment).to eq(options[:environment])
-        expect(subject.adam_id).to eq(options[:adam_id])
-        expect(subject.app_item_id).to eq(options[:app_item_id])
-        expect(subject.application_version).to eq(options[:application_version])
-        expect(subject.download_id).to eq(options[:download_id])
-        expect(subject.version_external_identifier).to eq(
-          options[:version_external_identifier]
-        )
-        expect(subject.original_purchase_date).to eq(
-          options[:original_purchase_date]
-        )
-      end
-    end
-  end
-
-  describe '#add_purchase' do
-    let(:receipt) { described_class.new(bundle_id: 'foobar') }
-
-    subject { receipt.add_purchase(options) }
-
-    context 'with minimal options' do
-      let(:options) { { product_id: 'whatever' } }
-
-      it 'creates an instance of Purchase' do
-        expect(subject).to be_a(ItunesReceiptMock::Purchase)
-      end
-
-      it 'adds the purchase to the #in_app object' do
-        expect(receipt.in_app[subject.transaction_id]).to eq(subject)
-      end
-    end
-
-    context 'when product_id is not present' do
-      let(:options) { {} }
-
-      it 'raises an MissingArgumentError' do
-        expect { subject }.to raise_error(
-          ItunesReceiptMock::MissingArgumentError,
-          'product_id is required'
-        )
-      end
-    end
-  end
-
-  describe '#add_subscription' do
-    let(:receipt) { described_class.new(bundle_id: 'foobar') }
-
-    subject { receipt.add_subscription(options) }
-
-    context 'with minimal options' do
-      let(:options) do
-        {
-          product_id: 'whatever',
-          expires_date: 1.month.from_now
-        }
-      end
-
-      it 'creates an instance of Subscription' do
-        expect(subject).to be_a(ItunesReceiptMock::Subscription)
-      end
-
-      it 'adds the subscription to the #in_app object' do
-        expect(receipt.in_app[subject.transaction_id]).to eq(subject)
-      end
-    end
-
-    context 'when expires_date is not present' do
-      let(:options) { { product_id: 'whatever' } }
-
-      it 'raises an MissingArgumentError' do
-        expect { subject }.to raise_error(
-          ItunesReceiptMock::MissingArgumentError,
-          'expires_date is required'
-        )
-      end
-    end
-  end
-
-  describe '#result' do
-    let(:receipt) { described_class.new(bundle_id: 'foobar') }
-    let(:options) { {} }
-
-    subject { receipt.result(options) }
-
-    it 'returns everything' do
-      expect(subject['receipt_type']).to eq(receipt.environment)
-      expect(subject['adam_id']).to eq(receipt.adam_id)
-      expect(subject['app_item_id']).to eq(receipt.app_item_id)
-      expect(subject['bundle_id']).to eq(receipt.bundle_id)
-      expect(subject['application_version'])
-        .to eq(receipt.application_version.to_s)
-      expect(subject['download_id']).to eq(receipt.download_id)
-      expect(subject['version_external_identifier'])
-        .to eq(receipt.version_external_identifier)
-      expect(subject['original_application_version'])
-        .to eq(format('%.1f', receipt.original_application_version))
-      expect(subject['in_app']).to be_a(Array)
-      expect(subject['request_date'])
-        .to eq(Time.now.utc.strftime('%F %T') + ' Etc/GMT')
-      expect(subject['original_purchase_date'])
-        .to eq(receipt.original_purchase_date.utc.strftime('%F %T') +
-               ' Etc/GMT')
-    end
-
-    context 'when "request_date" is in options' do
-      let(:options) { { request_date: rand(1..5).hours.ago } }
-
-      it 'returns the request_date as specified' do
-        expect(subject['request_date']).to eq(
-          options[:request_date].utc.strftime('%F %T') + ' Etc/GMT'
-        )
-      end
-    end
-  end
-end

data/spec/validation_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe ItunesReceiptMock::Validation do
-  describe '.new' do
-    let(:options) { { bundle_id: 'foobar' } }
-
-    subject { described_class.new(options) }
-
-    it 'creates an instance of Receipt' do
-      expect(subject.receipt).to be_a(ItunesReceiptMock::Receipt)
-    end
-  end
-
-  describe '#result' do
-    let(:validation) { described_class.new(bundle_id: 'foobar') }
-
-    subject { validation.result(options) }
-
-    context 'when status is 0' do
-      let(:options) { { status: 0 } }
-
-      it 'returns everything' do
-        expect(subject['status']).to eq(0)
-        expect(subject['environment']).to_not be_nil
-        expect(subject['receipt']).to_not be_nil
-      end
-    end
-
-    context 'when status is not 0' do
-      let(:options) { { status: 1 } }
-
-      it 'returns just the status' do
-        expect(subject).to eq('status' => options[:status])
-      end
-    end
-  end
-
-  describe '#add_purchase' do
-    let(:validation) { described_class.new(bundle_id: 'foobar') }
-
-    subject { validation.add_purchase(product_id: 'foobar') }
-
-    it 'adds the purchase to the #latest_receipt_info object' do
-      expect(validation.latest_receipt_info[subject.transaction_id])
-        .to eq(subject)
-    end
-  end
-
-  describe '#add_subscription' do
-    let(:validation) { described_class.new(bundle_id: 'foobar') }
-
-    subject do
-      validation.add_subscription product_id: 'foobar',
-                                  expires_date: 1.month.from_now
-    end
-
-    it 'adds the subscription to the #latest_receipt_info object' do
-      expect(validation.latest_receipt_info[subject.transaction_id])
-        .to eq(subject)
-    end
-  end
-
-  describe '#renew_subscription' do
-    let(:validation) { described_class.new(bundle_id: 'foobar') }
-    let(:subscription) do
-      validation.add_subscription product_id: 'foobar',
-                                  purchase_date: 1.month.ago,
-                                  expires_date: Time.now
-    end
-
-    subject do
-      validation.renew_subscription subscription,
-                                    expires_date: 1.month.from_now
-    end
-
-    it 'removes the old transaction from #receipt#in_app' do
-      expect(validation.receipt.in_app[subscription.transaction_id])
-        .to eq(subscription)
-      subject
-      expect(validation.receipt.in_app[subscription.transaction_id])
-        .to be_nil
-    end
-
-    it 'adds the new transaction to #receipt#in_app' do
-      expect(validation.receipt.in_app[subject.transaction_id]).to eq(subject)
-    end
-
-    it 'adds the new tranaction to #latest_receipt_info' do
-      expect(validation.latest_receipt_info[subject.transaction_id])
-        .to eq(subject)
-    end
-
-    it 'preserves both transactions in #latest_receipt_info' do
-      subject
-      expect(validation.latest_receipt_info.values)
-        .to match_array([subscription, subject])
-    end
-  end
-end