tinypass 0.0.1

data/spec/unit/policies/restriction_policy_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Tinypass::RestrictionPolicy do
+  describe '#limit_purchases_in_period_by_amount' do
+    let(:data) { Tinypass::RestrictionPolicy.limit_purchases_in_period_by_amount('10', '1 week') }
+    let(:hash) { data.to_hash }
+
+    it 'returns a RestrictionPolicy' do
+      expect(data).to be_kind_of Tinypass::RestrictionPolicy
+    end
+
+    it 'sets the type' do
+      expect(hash[Tinypass::Policy::POLICY_TYPE]).to eq Tinypass::Policy::RESTRICT_MAX_PURCHASES
+    end
+
+    it 'sets the values' do
+      expect(hash['amount']).to eq '10'
+      expect(hash['withinPeriod']).to eq '1 week'
+    end
+
+    context "with details" do
+      let(:data) { Tinypass::RestrictionPolicy.limit_purchases_in_period_by_amount('10', '1 week', 'details') }
+
+      it 'sets the type' do
+        expect(hash[Tinypass::Policy::POLICY_TYPE]).to eq Tinypass::Policy::RESTRICT_MAX_PURCHASES
+      end
+
+      it 'sets the values' do
+        expect(hash['amount']).to eq '10'
+        expect(hash['withinPeriod']).to eq '1 week'
+        expect(hash['linkWithDetails']).to eq 'details'
+      end
+    end
+  end
+end

data/spec/unit/price_option_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper.rb'
+
+describe Tinypass::PriceOption do
+  describe "#initialize" do
+    it "accepts a price and an access period" do
+      option = Tinypass::PriceOption.new('.50', '24 hours')
+      expect(option.price).to eq '.50'
+      expect(option.access_period).to eq '24 hours'
+    end
+  end
+
+  it "can set price" do
+    option = Tinypass::PriceOption.new('.50', '24 hours')
+    option.price = '1.50'
+    expect(option.price).to eq '1.50'
+  end
+
+  it "can set access period" do
+    option = Tinypass::PriceOption.new('.50', '24 hours')
+    option.access_period = '1 week'
+    expect(option.access_period).to eq '1 week'
+  end
+
+  describe "#access_period_in_msecs" do
+    it "passes the happy case" do
+      option = Tinypass::PriceOption.new('.50', '321 msecs')
+      expect(option.access_period_in_msecs).to eq 321
+    end
+  end
+
+  describe "#access_period_in_secs" do
+    it "passes the happy case" do
+      option = Tinypass::PriceOption.new('.50', '321 secs')
+      expect(option.access_period_in_secs).to eq 321
+    end
+  end
+
+  it "can set start date" do
+    option = Tinypass::PriceOption.new('.50', '24 hours')
+    option.start_date_in_secs = 1234
+    expect(option.start_date_in_secs).to eq 1234
+  end
+
+  it "can set end date" do
+    option = Tinypass::PriceOption.new('.50', '24 hours')
+    option.end_date_in_secs = 1234
+    expect(option.end_date_in_secs).to eq 1234
+  end
+
+  it "can set caption" do
+    option = Tinypass::PriceOption.new('.50', '24 hours')
+    option.caption = 'caption'
+    expect(option.caption).to eq 'caption'
+  end
+
+  describe "#active?" do
+    it "returns true when no start or end date" do
+      expect(Tinypass::PriceOption.new('.50', '1 day').active?).to be_true
+    end
+
+    it "returns false when before start date" do
+      expect(Tinypass::PriceOption.new('.50', '1 day', Time.now.to_i + 10).active?).to be_false
+    end
+
+    it "returns false when after end date" do
+      expect(Tinypass::PriceOption.new('.50', '1 day', nil, Time.now.to_i - 1).active?).to be_false
+    end
+
+    it "returns true when after start and no end" do
+      expect(Tinypass::PriceOption.new('.50', '1 day', Time.now.to_i - 1).active?).to be_true
+    end
+
+    it "returns true when before end and no start" do
+      expect(Tinypass::PriceOption.new('.50', '1 day', nil, Time.now.to_i + 10).active?).to be_true
+    end
+
+    it "returns true when between start and end dates" do
+      expect(Tinypass::PriceOption.new('.50', '1 day', Time.now.to_i - 1, Time.now.to_i + 10).active?).to be_true
+    end
+
+    context "when passed a value" do
+      it "uses the value instead of the current time" do
+        option = Tinypass::PriceOption.new('.50', '1 day', Time.now.to_i - 1, Time.now.to_i + 10)
+        expect(option.active?(Time.now.to_i - 2)).to be_false
+      end
+    end
+  end
+
+  it "can add split pays" do
+    price_option = Tinypass::PriceOption.new('.50', '1 day')
+    price_option.add_split_pay('email@example.org', '.25')
+    price_option.add_split_pay('another_email@another_host.net', '5%')
+    expect(price_option.split_pays).not_to be_nil
+    expect(price_option.split_pays['email@example.org']).to eq 0.25
+    expect(price_option.split_pays['another_email@another_host.net']).to eq 0.05
+  end
+
+  describe "#to_s" do
+    it "translates the price option as expected" do
+      price_option = Tinypass::PriceOption.new('.50', '1 day',
+        Date.new(2013, 9, 21).to_time.to_i,
+        Date.new(2013, 7, 3).to_time.to_i)
+      price_option.add_split_pay('email@example.org', '.25')
+      price_option.add_split_pay('another_email@another_host.net', '5%')
+
+      expect(price_option.to_s).to eq "Price:.50\tPeriod:1 day\tTrial Period:1 day\tStart:1379736000:Sat, 21 Sep 2013 00 00 00\tEnd:1372824000:Wed, 03 Jul 2013 00 00 00\tSplit:email@example.org:0.25\tSplit:another_email@another_host.net:0.05"
+    end
+  end
+end

data/spec/unit/resource_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper.rb'
+
+describe Tinypass::Resource do
+  describe "#initialize" do
+    it "accepts an rid and a name" do
+      resource = Tinypass::Resource.new('rid', 'name')
+      expect(resource.rid).to eq 'rid'
+      expect(resource.name).to eq 'name'
+    end
+
+    it "accepts an rid, name and url" do
+      resource = Tinypass::Resource.new('rid', 'name', 'url')
+      expect(resource.rid).to eq 'rid'
+      expect(resource.name).to eq 'name'
+      expect(resource.url).to eq 'url'
+    end
+  end
+
+  it "can set name" do
+    resource = Tinypass::Resource.new('rid', 'name')
+    resource.name = 'NEW'
+    expect(resource.name).to eq 'NEW'
+  end
+end

data/spec/unit/tinypass_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper.rb'
+
+describe Tinypass do
+  it "can set and get sandbox" do
+    Tinypass.sandbox = true
+    expect(Tinypass.sandbox).to be_true
+  end
+
+  it "can set and get the aid" do
+    Tinypass.aid = 'this is my aid'
+    expect(Tinypass.aid).to eq 'this is my aid'
+  end
+
+  it "can set and get the private key" do
+    Tinypass.private_key = 'this is my private key'
+    expect(Tinypass.private_key).to eq 'this is my private key'
+  end
+end
+
+describe Tinypass::Config do
+  it "has the expected version number" do
+    expect(Tinypass::Config::VERSION).to eq '2.0.7'
+  end
+
+  it "has the expected context" do
+    expect(Tinypass::Config::CONTEXT).to eq '/v2'
+  end
+
+  describe "#endpoint" do
+    after do
+      if Tinypass.const_defined?('API_ENDPOINT_DEV')
+        Tinypass.send(:remove_const, 'API_ENDPOINT_DEV')
+      end
+    end
+
+    it "returns the live url when live" do
+      Tinypass.sandbox = false
+      expect(Tinypass::Config.endpoint).to eq "https://api.tinypass.com"
+    end
+
+    it "returns the sandbox url when sandboxed" do
+      Tinypass.sandbox = true
+      expect(Tinypass::Config.endpoint).to eq "https://sandbox.tinypass.com"
+    end
+
+    it "returns the development url if set" do
+      Tinypass.const_set('API_ENDPOINT_DEV', 'http://test.com')
+      expect(Tinypass::Config.endpoint).to eq 'http://test.com'
+    end
+  end
+end

data/spec/unit/token/access_token_list_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper.rb'
+
+describe Tinypass::AccessTokenList do
+  let(:list) { Tinypass::AccessTokenList.new }
+  let(:token) { Tinypass::AccessToken.new('present') }
+  let(:other_token) { Tinypass::AccessToken.new(123456) }
+  let(:tokens) { [token, other_token] }
+
+  describe "#initialize" do
+    it "accepts an access token" do
+      list = Tinypass::AccessTokenList.new(token)
+      expect(list[token.rid]).not_to be_nil
+    end
+
+    it "accepts an array of access tokens" do
+      list = Tinypass::AccessTokenList.new(tokens)
+      expect(list[token.rid]).not_to be_nil
+      expect(list[other_token.rid]).not_to be_nil
+    end
+  end
+
+  describe "#tokens, by default" do
+    it "is not null" do
+      expect(list.tokens).not_to be_nil
+    end
+
+    it "is empty" do
+      expect(list.tokens.size).to eq 0
+    end
+  end
+
+  describe "#contains" do
+    context "when empty" do
+      it "returns false" do
+        expect(list.empty?).to be_true
+        expect(list.contains?(123)).to be_false
+      end
+    end
+
+    context "when not empty" do
+      let(:list) { Tinypass::AccessTokenList.new(tokens) }
+
+      before do
+        Tinypass::AccessToken.new('absent')
+        expect(list.empty?).to be_false
+      end
+
+      it "returns true for present token RIDs" do
+        expect(list.include?(token.rid)).to be_true #test alias
+        expect(list.contains?(other_token.rid)).to be_true
+      end
+
+      it "returns false for absent token RIDs" do
+        expect(list.contains?('absent')).to be_false
+      end
+    end
+  end
+
+  describe "#<<" do
+    before do
+      stub_const('Tinypass::AccessTokenList::MAX', 1)
+    end
+
+    it "adds the token to the list if we haven't reached the max" do
+      list << token
+      expect(list.length).to eq 1
+      expect(list.first).to eq token
+    end
+
+    it "drops the oldest tokens if we reach the max" do
+      list << token
+      list << other_token
+      expect(list.length).to eq 1
+      expect(list.first).to eq other_token
+    end
+  end
+
+  describe "#add_all" do
+    it "adds all the tokens" do
+      list.add_all(tokens)
+      expect(list.length).to eq 2
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true when empty" do
+      expect(list).to be_empty
+    end
+
+    it "returns false when populated" do
+      expect(Tinypass::AccessTokenList.new(token)).not_to be_empty
+    end
+  end
+end

data/spec/unit/token/access_token_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper.rb'
+
+describe Tinypass::AccessToken do
+  let(:token) { Tinypass::AccessToken.new('123456', 3000) }
+
+  it "creates token data" do
+    expect(token.token_data.values).not_to be_nil
+  end
+
+  it "sets the rid" do
+    expect(token.rid).to eq '123456'
+  end
+
+  describe "#access_id" do
+    it "can be retrieved" do
+      token.token_data[Tinypass::TokenData::ACCESS_ID] = 'value'
+      expect(token.access_id).to eq 'value'
+    end
+  end
+
+  describe "#uid" do
+    it "can be retrieved" do
+      token.token_data[Tinypass::TokenData::UID] = 'value'
+      expect(token.uid).to eq 'value'
+    end
+  end
+
+  describe "#expiration_in_seconds" do
+    it "can be retrieved" do
+      expect(token.expiration_in_seconds).to eq 3000
+    end
+
+    it "is aliased as #expiration_in_secs" do
+      expect(token.expiration_in_secs).to eq 3000
+    end
+  end
+
+  describe "#early_expiration_in_seconds" do
+    it "defaults to zero" do
+      expect(token.early_expiration_in_seconds).to eq 0
+    end
+
+    it "is aliased as #expiration_in_secs" do
+      expect(token.early_expiration_in_secs).to eq 0
+    end
+  end
+
+  it "supports trial_end_time_secs" do
+    token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = 4000
+    expect(token.trial_end_time_secs).to eq 4000
+    token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = 1000
+    expect(token.trial_end_time_secs).to eq 1000
+  end
+
+  it "supports lockout_end_time_secs" do
+    token.token_data[Tinypass::TokenData::METER_LOCKOUT_ENDTIME] = 4000
+    expect(token.lockout_end_time_secs).to eq 4000
+    token.token_data[Tinypass::TokenData::METER_LOCKOUT_ENDTIME] = 1000
+    expect(token.lockout_end_time_secs).to eq 1000
+  end
+
+  it "supports trial_view_count" do
+    expect(token.trial_view_count).to eq 0
+    token.token_data[Tinypass::TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = 1000
+    expect(token.trial_view_count).to eq 1000
+  end
+
+  it "supports trial_view_limit" do
+    expect(token.trial_view_limit).to eq 0
+    token.token_data[Tinypass::TokenData::METER_TRIAL_MAX_ACCESS_ATTEMPTS] = 1000
+    expect(token.trial_view_limit).to eq 1000
+  end
+
+  describe "#access_state" do
+    it "returns ACCESS_GRANTED by default" do
+      token = Tinypass::AccessToken.new('RID', 0)
+      expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+    end
+  end
+
+  describe "#access_granted?" do
+    it "returns true when not expired" do
+      token = Tinypass::AccessToken.new('RID', Time.now.to_i + 4)
+      expect(token.access_granted?).to be_true
+      expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+    end
+
+    it "returns true when expiration is zero" do
+      token = Tinypass::AccessToken.new('RID', 0)
+      expect(token.access_granted?).to be_true
+      expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+    end
+
+    it "returns true when expiration is nil" do
+      token = Tinypass::AccessToken.new('RID', nil)
+      expect(token.access_granted?).to be_true
+      expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+    end
+
+    it "returns false when expired" do
+      token = Tinypass::AccessToken.new('RID', Time.now.to_i - 1)
+      expect(token.access_granted?).to be_false
+      expect(token.expired?).to be_true
+      expect(token.access_state).to eq Tinypass::AccessState::EXPIRED
+    end
+
+    it "returns false when early expired" do
+      token = Tinypass::AccessToken.new('RID', 0, Time.now.to_i - 1)
+      expect(token.access_granted?).to be_false
+      expect(token.access_state).to eq Tinypass::AccessState::EXPIRED
+    end
+
+    context "when passed an ip" do
+      let(:token) { Tinypass::AccessToken.new('RID', 0) }
+      it "ignores the ip if no ips set" do
+        expect(token.access_granted?('1.1.1.1')).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+      end
+
+      it "ignores the ip if ip included" do
+        token.token_data[Tinypass::TokenData::IPS] = ['1.1.1.1']
+        expect(token.access_granted?('1.1.1.1')).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::ACCESS_GRANTED
+      end
+
+      it "returns false when ip not included" do
+        token.token_data[Tinypass::TokenData::IPS] = ['1.1.1.1']
+        expect(token.access_granted?('1.1.1.2')).to be_false
+        expect(token.access_state).to eq Tinypass::AccessState::CLIENT_IP_DOES_NOT_MATCH_TOKEN
+      end
+    end
+
+    context "timed meter" do
+      let(:token) { Tinypass::AccessToken.new('RID', 0) }
+
+      before do
+        token.token_data[Tinypass::TokenData::METER_TYPE] = Tinypass::TokenData::METER_STRICT
+      end
+
+      it "returns true when not expired" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i + 1000
+        expect(token.access_granted?).to be_true
+        expect(token.metered?).to be_true
+        expect(token.trial_period_active?).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_IN_TRIAL
+      end
+
+      it "returns false when expired" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+        expect(token.access_granted?).to be_false
+        expect(token.metered?).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_TRIAL_DEAD
+      end
+
+      it "returns false when null" do
+        expect(token.access_granted?).to be_false
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_TRIAL_DEAD
+      end
+
+      it "returns false with special state if locked out" do
+        token.token_data[Tinypass::TokenData::METER_LOCKOUT_ENDTIME] = Time.now.to_i + 1000
+        expect(token.access_granted?).to be_false
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_IN_LOCKOUT
+      end
+    end
+
+    context "view meter" do
+      let(:token) { Tinypass::AccessToken.new('RID', 0) }
+
+      before do
+        token.token_data[Tinypass::TokenData::METER_TYPE] = Tinypass::TokenData::METER_REMINDER
+      end
+
+      context "not expired" do
+        before do
+          token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i + 1000
+        end
+
+        it "returns true when views not exceeded" do
+          token.token_data[Tinypass::TokenData::METER_TRIAL_MAX_ACCESS_ATTEMPTS] = 1
+          token.token_data[Tinypass::TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = 0
+          expect(token.access_granted?).to be_true
+          expect(token.access_state).to eq Tinypass::AccessState::METERED_IN_TRIAL
+        end
+
+        it "returns false when views exceeded" do
+          token.token_data[Tinypass::TokenData::METER_TRIAL_MAX_ACCESS_ATTEMPTS] = 1
+          token.token_data[Tinypass::TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = 2 # NOTE: probable off-by-one error
+          expect(token.access_granted?).to be_false
+          expect(token.access_state).to eq Tinypass::AccessState::METERED_TRIAL_DEAD
+        end
+      end
+
+      context "expired" do
+        before do
+          token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+        end
+
+        it "returns false despite views not exceeded" do
+          token.token_data[Tinypass::TokenData::METER_TRIAL_MAX_ACCESS_ATTEMPTS] = 1
+          token.token_data[Tinypass::TokenData::METER_TRIAL_ACCESS_ATTEMPTS] = 0
+          expect(token.access_granted?).to be_false
+          expect(token.access_state).to eq Tinypass::AccessState::METERED_TRIAL_DEAD
+        end
+      end
+    end
+
+    context "unknown meter" do
+      let(:token) { Tinypass::AccessToken.new('RID', 0) }
+
+      before do
+        token.token_data[Tinypass::TokenData::METER_TYPE] = 'unknown meter type'
+      end
+
+      it "returns true when not expired" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i + 1000
+        expect(token.access_granted?).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_IN_TRIAL
+      end
+
+      it "returns false when expired" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+        expect(token.access_granted?).to be_false
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_TRIAL_DEAD
+      end
+
+      it "returns true when null" do
+        expect(token.access_granted?).to be_true
+        expect(token.access_state).to eq Tinypass::AccessState::METERED_IN_TRIAL
+      end
+    end
+  end
+
+  describe "#trial_dead?" do
+    let(:token) { Tinypass::AccessToken.new('RID', 0) }
+
+    it "returns true when not metered" do
+      expect(token.trial_dead?).to be_true
+    end
+
+    context "when metered" do
+      before do
+        token.token_data[Tinypass::TokenData::METER_TYPE] = Tinypass::TokenData::METER_STRICT
+      end
+
+      it "returns false when trial is active" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i + 1000
+        expect(token.trial_dead?).to be_false
+      end
+
+      it "returns false when lockout is active" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+        token.token_data[Tinypass::TokenData::METER_LOCKOUT_ENDTIME] = Time.now.to_i + 1000
+        expect(token.trial_dead?).to be_false
+        expect(token.lockout_period_active?).to be_true
+      end
+
+      it "returns true when lockout and trial expired" do
+        token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+        token.token_data[Tinypass::TokenData::METER_LOCKOUT_ENDTIME] = Time.now.to_i - 1
+        expect(token.trial_dead?).to be_true
+        expect(token.lockout_period_active?).to be_false
+      end
+    end
+  end
+
+end