tinypass 0.0.1

data/spec/support/tinypass_factories.rb

@@ -0,0 +1,25 @@
+module TinypassFactories
+  def build_tinypass_cookie(tokens, name = nil)
+    name ||= Tinypass::Config.token_cookie_name(Tinypass.aid)
+    list = Tinypass::AccessTokenList.new(tokens)
+    value = Tinypass::ClientBuilder.new.build_access_tokens(list)
+
+    { name => value }
+  end
+
+  def build_expired_trial_access_token(rid)
+    token = Tinypass::AccessToken.new(rid, 0)
+    token.token_data[Tinypass::TokenData::METER_TYPE] = Tinypass::TokenData::METER_STRICT
+    token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i - 1
+
+    token
+  end
+
+  def build_active_trial_access_token(rid)
+    token = Tinypass::AccessToken.new(rid, 0)
+    token.token_data[Tinypass::TokenData::METER_TYPE] = Tinypass::TokenData::METER_STRICT
+    token.token_data[Tinypass::TokenData::METER_TRIAL_ENDTIME] = Time.now.to_i + 24 * 60 * 60
+
+    token
+  end
+end

data/spec/unit/builder/client_builder_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Tinypass::ClientBuilder do
+  describe "#initialize" do
+    it "uses a JsonMsgBuilder and SecureEncoder by default" do
+      Tinypass::JsonMsgBuilder.should_receive(:new)
+      Tinypass::SecureEncoder.should_receive(:new)
+
+      Tinypass::OpenEncoder.should_not_receive(:new)
+
+      Tinypass::ClientBuilder.new
+    end
+
+    it "uses the OpenEncoder if specified" do
+      Tinypass::JsonMsgBuilder.should_receive(:new)
+      Tinypass::OpenEncoder.should_receive(:new)
+
+      Tinypass::SecureEncoder.should_not_receive(:new)
+
+      Tinypass::ClientBuilder.new('_?o')
+    end
+  end
+end

data/spec/unit/builder/client_parser_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Tinypass::ClientParser do
+  describe "#parse_access_tokens" do
+    let(:fake_builder) { double }
+    let(:fake_encoder) { double }
+
+    before do
+      Tinypass::JsonMsgBuilder.should_receive(:new).twice.and_return(fake_builder)
+
+      fake_encoder.should_receive(:decode).twice.with('payload').and_return('decoded payload')
+      fake_builder.should_receive(:parse_access_tokens).twice.with('decoded payload').and_return(OpenStruct.new(tokens: []))
+    end
+
+    it "uses the JsonMsgBuilder and SecureEncoder by default" do
+      Tinypass::SecureEncoder.should_receive(:new).twice.and_return(fake_encoder)
+
+      Tinypass::ClientParser.new.parse_access_tokens("???{QQQ}payload{QQQ}payload") # QQQ is intended to be unkonwn, triggering defaults
+    end
+
+    it "uses the OpenEncoder if specified" do
+      Tinypass::OpenEncoder.should_receive(:new).twice.and_return(fake_encoder)
+
+      Tinypass::ClientParser.new.parse_access_tokens("???{QoQ}payload{QoQ}payload") # the Qs are intended to be unknown, triggering defaults
+    end
+  end
+end

data/spec/unit/builder/cookie_parser_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Tinypass::CookieParser do
+  describe '#extract_cookie_value' do
+    it "returns the value when only key found" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key', 'key=value')).to eq 'value'
+    end
+
+    it "returns the value when not formatted" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key', 'value')).to eq 'value'
+    end
+
+    it "treats empty strings as nil" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key', '')).to be_nil
+    end
+
+    it "returns nil when key not found" do
+      expect(Tinypass::CookieParser.extract_cookie_value('unknown_key', 'key=value')).to be_nil
+    end
+
+    it "returns the value when first key" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key',
+          'key=value; other_key=21; third_key=[CS|v1|27A5]wasdf[C3]; ')).
+        to eq 'value'
+    end
+
+    it "returns the value when middle key" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key',
+          'other_key=21; key=value; third_key=[CS|v1|27A5]wasdf[C3]; ')).
+        to eq 'value'
+    end
+
+    it "returns the value when last key" do
+      expect(Tinypass::CookieParser.extract_cookie_value('key',
+          'other_key=21; third_key=[CS|v1|27A5]wasdf[C3]; key=value;')).
+        to eq 'value'
+    end
+  end
+end

data/spec/unit/builder/json_msg_builder_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Tinypass::JsonMsgBuilder do
+  describe "#build_purchase_requests" do
+    let(:resource) { Tinypass::Resource.new('Premium-Content', 'Site wide premium content access', 'http://resource.com') }
+    let(:price_option_1) do
+      Tinypass::PriceOption.new('.50', '24 hours').tap do |option|
+        option.caption = 'Special offer!'
+        option.start_date_in_secs = 123456789
+        option.end_date_in_secs = 987654321
+        option.add_split_pay('taavo@dd9.com', '50%')
+        option.add_split_pay('bob@example.org', '.10')
+      end
+    end
+    let(:price_option_2) { Tinypass::PriceOption.new('.99', '1 week') }
+    let(:offer) do
+      Tinypass::Offer.new(resource, price_option_1, price_option_2).tap do |offer|
+        offer.tags.push('tag', 'another tag', 'a third tag')
+      end
+    end
+    let(:other_offer) { Tinypass::Offer.new(resource, price_option_2, price_option_1) }
+    let(:purchase_request) do
+      Tinypass::PurchaseRequest.new(offer).tap do |request|
+        request.client_ip = '1.2.3.4'
+        request.user_ref = 'steve'
+        request.options = { 'key' => 'value' }
+        request.secondary_offer = other_offer
+      end
+    end
+
+    let(:builder) { Tinypass::JsonMsgBuilder.new }
+
+    context "with a single purchase request" do
+      let(:result) { MultiJson.load(builder.build_purchase_requests([purchase_request])).first }
+
+      it "encodes the purchase request correctly" do
+        %w(o1 o2 t v).each do |field|
+          expect(result[field]).not_to be_nil
+        end
+
+        expect(result['ip']).to eq '1.2.3.4'
+        expect(result['uref']).to eq 'steve'
+        expect(result['opts']).to eq({ 'key' => 'value' })
+      end
+
+      it "encodes the offers correctly" do
+        %w(pos pol).each do |field|
+          expect(result['o1'][field]).not_to be_nil # yes, we're only currently testing the primary offer
+        end
+
+        expect(result['o1']['rid']).to eq 'Premium-Content'
+        expect(result['o1']['rnm']).to eq 'Site wide premium content access'
+        expect(result['o1']['rurl']).to eq 'http://resource.com'
+        expect(result['o1']['tags']).to eq ['tag', 'another tag', 'a third tag']
+      end
+
+      it "encodes price options correctly" do
+        %w(opt0 opt1).each do |field|
+          expect(result['o1']['pos'][field]).not_to be_nil
+        end
+
+        po_result_1 = result['o1']['pos']['opt0'] # yes, we're only currently testing the first price option
+
+        expect(po_result_1['price']).to eq '.50'
+        expect(po_result_1['exp']).to eq '24 hours'
+        expect(po_result_1['caption']).to eq 'Special offer!'
+        expect(po_result_1['sd']).to eq 123456789
+        expect(po_result_1['ed']).to eq 987654321
+        expect(po_result_1['splits']).to eq ["taavo@dd9.com=0.5", "bob@example.org=0.1"]
+      end
+    end
+  end
+end

data/spec/unit/builder/open_encoder_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Tinypass::OpenEncoder do
+  describe '#encode' do
+    it "is a passthrough" do
+      expect(Tinypass::OpenEncoder.new.encode('the original string')).to eq 'the original string'
+    end
+  end
+
+  describe '#decode' do
+    it "is a passthrough" do
+      expect(Tinypass::OpenEncoder.new.decode('the original string')).to eq 'the original string'
+    end
+  end
+end

data/spec/unit/builder/secure_encoder_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Tinypass::SecureEncoder do
+  let(:encoder) { Tinypass::SecureEncoder.new(private_key) }
+  let(:private_key) { 'private key' }
+  let(:message) { 'a string'}
+
+  describe '#encode' do
+    it 'passes through to SecurityUtils' do
+      Tinypass::SecurityUtils.should_receive(:encrypt).with(private_key, message).and_return 'encrypted'
+
+      expect(encoder.encode(message)).to eq 'encrypted'
+    end
+  end
+
+  describe '#decode' do
+    it 'passes through to SecurityUtils' do
+      Tinypass::SecurityUtils.should_receive(:decrypt).with(private_key, message).and_return 'decrypted'
+
+      expect(encoder.decode(message)).to eq 'decrypted'
+    end
+  end
+end

data/spec/unit/builder/security_utils_spec.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Tinypass::SecurityUtils do
+  let(:private_key) { "thestringliteralisexactlyfortych" }
+
+  let(:java_data) { "JavaIsSoFun" }
+  let(:encrypted_java_data) { "V3IqZVBH2dQh4uxOMy9BAg~~~mB3lhC3FscKs7p18-N2vtvy6pSDsIyicy77lydm-UGk" }
+
+  let(:json_data) { "{\"aid\":\"MICMICMICX\",\"uid\":\"kjkxrNWUyD\",\"tokens\":[\"{\"ex\":1299043304,\"rid\":53530}\"],\"built\":1298957391760}" }
+  let(:encrypted_json_data) { "H1PgAu3LPBqwxFnnIEqG1N70CCRXrYsWL_audQvn1kYcbWEf9RQrA4rKX7qmFDvY_zQq61S8qBTWurpxtMLGPl7aEK86hD6Xkf6K2HxvOmHSKdN7iZ6mEJwyqB9X8b76wHA61qb-5eiERNBp3Nkjmw~~~WvbljkqdoCfCj-U-qjCAdyASh8sIajDSyk0pzkPZlBY" }
+
+  describe "#encrypt" do
+    it "produces the expected result for 'java' data" do
+      expect(Tinypass::SecurityUtils.encrypt(private_key, java_data)).to eq encrypted_java_data
+    end
+
+    it "produces the expected result for json data" do
+      expect(Tinypass::SecurityUtils.encrypt(private_key, json_data)).to eq encrypted_json_data
+    end
+  end
+
+  describe "#decrypt" do
+    it "produces the expected result for 'java' data" do
+      expect(Tinypass::SecurityUtils.decrypt(private_key, encrypted_java_data)).to eq java_data
+    end
+
+    it "produces the expected result for json data" do
+      expect(Tinypass::SecurityUtils.decrypt(private_key, encrypted_json_data)).to eq json_data
+    end
+  end
+
+  describe "#hash_hmac_sha256" do
+    it 'produces the expected results' do
+      expect(Tinypass::SecurityUtils::hash_hmac_sha256(private_key, '')).to eq "Y8MfdiTQSuLQGAW2aCXvAucxnYCmQGQSr780zffAka0"
+      expect(Tinypass::SecurityUtils::hash_hmac_sha256(private_key, 'a')).to eq "QSD2YcjAs_V3Z_-SBWmz3AFQ0jPFJi-j45gcgJMFRQ8"
+      expect(Tinypass::SecurityUtils::hash_hmac_sha256(private_key, 'tinypass')).to eq "AxJ7i3CxUPOF0q53YCpNzoewP4hRbqSOhqfQRoRFRF4"
+      expect(Tinypass::SecurityUtils::hash_hmac_sha256(private_key, '!@#$%^&*()_+{}|:<>?')).to eq "xRdalr1ZhbUYMBxmYJmhjSZi0D4Z-eTKyt-eGFnQPUY"
+      expect(Tinypass::SecurityUtils::hash_hmac_sha256(private_key, 'кирилл')).to eq "iPBDZnvNX0YSy10m6JUoItYZ83nXfPgCQXS76yS7Xo4"
+    end
+  end
+end

data/spec/unit/gateway_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Tinypass::Gateway do
+  describe "#fetch_access_detail" do
+    it "returns nil when server returns 404" do
+      stub_request(:get, 'https://sandbox.tinypass.com/r2/access?rid=my_rid&user_ref=my_user_ref').to_return(status: 404)
+      expect(Tinypass.fetch_access_detail('my_rid', 'my_user_ref')).to be_nil
+    end
+
+    context "when server returns data" do
+      it "returns an AccessDetails" do
+        stub_request(:get, 'https://sandbox.tinypass.com/r2/access?rid=my_rid&user_ref=my_user_ref').
+          to_return(status: 200, body: "{}")
+        expect(Tinypass.fetch_access_detail('my_rid', 'my_user_ref')).to be_kind_of Tinypass::Gateway::AccessDetails
+      end
+    end
+  end
+
+  describe "#fetch_access_details" do
+    it "returns nil when server returns 404" do
+      stub_request(:get, "https://sandbox.tinypass.com/r2/access/search?pagesize=500&user_ref=my_user_ref").to_return(status: 404)
+      expect(Tinypass.fetch_access_details(user_ref: 'my_user_ref')).to be_empty
+    end
+
+    context "when server returns data" do
+      it "returns an array of AccessDetails" do
+        stub_request(:get, "https://sandbox.tinypass.com/r2/access/search?pagesize=500&user_ref=my_user_ref").
+          to_return(status: 200, body: MultiJson.dump(data: [{}]))
+        details_array = Tinypass.fetch_access_details(user_ref: 'my_user_ref')
+        expect(details_array).not_to be_empty
+        expect(details_array.first).to be_kind_of Tinypass::Gateway::AccessDetails
+      end
+    end
+  end
+
+  describe "#fetch_subscription_details" do
+    it "returns the json" do
+      fake_result = [{ 'key' => 'value' }]
+
+      stub_request(:get, "https://sandbox.tinypass.com/r2/subscription/search?rid=my_rid&user_ref=my_user_ref").
+        to_return(status: 200, body: MultiJson.dump(fake_result))
+
+      expect(Tinypass.fetch_subscription_details({user_ref: 'my_user_ref', rid: 'my_rid'})).to eq fake_result
+    end
+  end
+
+  describe "#cancel_subscription" do
+    it "produces the expected request" do
+      cancel_request = stub_request(:post, "https://sandbox.tinypass.com/r2/subscription/cancel?rid=my_rid&user_ref=my_user_ref")
+
+      Tinypass.cancel_subscription({user_ref: 'my_user_ref', rid: 'my_rid'})
+      expect(cancel_request).to have_been_requested
+    end
+  end
+
+  describe "#revoke_access" do
+    it "produces the expected request" do
+      revoke_request = stub_request(:post, "https://sandbox.tinypass.com/r2/access/revoke?refund=true&rid=my_rid&user_ref=my_user_ref")
+
+      Tinypass.revoke_access({user_ref: 'my_user_ref', rid: 'my_rid', refund: true})
+      expect(revoke_request).to have_been_requested
+    end
+  end
+end
+
+describe Tinypass::Gateway::AccessDetails do
+  describe "#access_granted?" do
+    it "returns true when expires not set" do
+      expect(Tinypass::Gateway::AccessDetails.new.access_granted?).to be_true
+    end
+
+    it "returns true when expires in the future" do
+      expect(Tinypass::Gateway::AccessDetails.new(expires: Time.now.to_i + 1000).access_granted?).to be_true
+    end
+
+    it "returns false when expires in the past" do
+      expect(Tinypass::Gateway::AccessDetails.new(expires: Time.now.to_i - 1).access_granted?).to be_false
+    end
+  end
+end

data/spec/unit/offer_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper.rb'
+
+describe Tinypass::Offer do
+  let(:resource) { Tinypass::Resource.new('RID1', 0) }
+  let(:price_option) { Tinypass::PriceOption.new('.50', '24 hours') }
+  let(:other_price_option) { Tinypass::PriceOption.new('.50', '1 week') }
+
+  describe "#initialize" do
+    it "accepts a resource and two price options" do
+      offer = Tinypass::Offer.new(resource, price_option, other_price_option)
+      expect(offer.resource).to eq resource
+      expect(offer.pricing.price_options.length).to eq 2
+    end
+  end
+
+  it "delegates has_active_prices? to pricing" do
+    offer = Tinypass::Offer.new(resource, price_option, other_price_option)
+    fake_pricing = double(has_active_options?: 'it was delegated')
+
+    offer.stub(:pricing).and_return(fake_pricing)
+    expect(offer.has_active_prices?).to eq 'it was delegated'
+  end
+
+  it "can set tags" do
+    offer = Tinypass::Offer.new(resource, price_option, other_price_option)
+    offer.tags << 'one' << 'two' << 'three'
+    expect(offer.tags).to include('one')
+    expect(offer.tags).to include('two')
+    expect(offer.tags).to include('three')
+  end
+end

data/spec/unit/policies/discount_policy_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Tinypass::DiscountPolicy do
+  describe '#on_total_spend_in_period' do
+    let(:data) { Tinypass::DiscountPolicy.on_total_spend_in_period('100', '1 week', '50%') }
+    let(:hash) { data.to_hash }
+
+    it 'returns a DiscountPolicy' do
+      expect(data).to be_kind_of Tinypass::DiscountPolicy
+    end
+
+    it 'sets the type' do
+      expect(hash[Tinypass::Policy::POLICY_TYPE]).to eq Tinypass::Policy::DISCOUNT_TOTAL_IN_PERIOD
+    end
+
+    it 'sets the values' do
+      expect(hash['amount']).to eq '100'
+      expect(hash['withinPeriod']).to eq '1 week'
+      expect(hash['discount']).to eq '50%'
+    end
+  end
+
+  describe '#previous_purchased' do
+    let(:data) { Tinypass::DiscountPolicy.previous_purchased(['RID1'], '50%') }
+    let(:hash) { data.to_hash }
+
+    it 'returns a DiscountPolicy' do
+      expect(data).to be_kind_of Tinypass::DiscountPolicy
+    end
+
+    it 'sets the type' do
+      expect(hash[Tinypass::Policy::POLICY_TYPE]).to eq Tinypass::Policy::DISCOUNT_PREVIOUS_PURCHASE
+    end
+
+    it 'sets the values' do
+      expect(hash['rids']).to eq ['RID1']
+      expect(hash['discount']).to eq '50%'
+    end
+  end
+end

data/spec/unit/policies/pricing_policy_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Tinypass::PricingPolicy do
+  describe 'has_active_options?' do
+    it "returns true when it should" do
+      policy = Tinypass::PricingPolicy.new([double(active?: true)])
+
+      expect(policy.has_active_options?).to be_true
+    end
+
+    it "returns false when it should" do
+      policy = Tinypass::PricingPolicy.new(double(active?: false))
+
+      expect(policy.has_active_options?).to be_false
+    end
+
+    it "returns false when no options" do
+      policy = Tinypass::PricingPolicy.new([])
+
+      expect(policy.has_active_options?).to be_false
+    end
+  end
+end