passbook-iid 0.4.0

data/spec/lib/commands/commands_spec_helper.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'terminal-table'
+require 'commander/import'
+require 'utils/command_utils'
+
+def load_commands
+  Dir['lib/commands/**/*.rb'].each {|f|
+    load File.join(File.dirname(__FILE__), '../../..', f)
+    require File.join(File.dirname(__FILE__), '../../..', f.gsub(/.rb/, ''))
+  }
+end
+
+def mock_terminal
+  @input = StringIO.new
+  @output = StringIO.new
+  $terminal = HighLine.new @input, @output
+end
+
+def new_command_runner *args, &block
+  Commander::Runner.instance_variable_set :"@singleton", Commander::Runner.new(args)
+  program :version, '1.2.3'
+  program :description, "Honey Badger Don't Care"
+  yield if block
+  Commander::Runner.instance
+end
+
+def run *args
+  runner = new_command_runner(*args) do
+    load_commands
+  end
+  runner.run!  
+  @output.string
+end
+
+RSpec::Matchers.define :exit_with_code do |exp_code|
+  actual = nil
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == exp_code
+  end
+  failure_message_for_should do |block|
+    "expected block to call exit(#{exp_code}) but exit" +
+      (actual.nil? ? " not called" : "(#{actual}) was called")
+  end
+  failure_message_for_should_not do |block|
+    "expected block not to call exit(#{exp_code})"
+  end
+  description do
+    "expect block to call exit(#{exp_code})"
+  end
+end
+
+def run_raw_command(*args)
+  lambda{
+    run(*args)
+  }.should raise_error(SystemExit, ' ')
+end
+
+def run_command(*args, &block)
+  begin
+    run_raw_command *args
+  rescue
+    yield
+  end
+end

data/spec/lib/commands/generate_spec.rb

@@ -0,0 +1,72 @@
+require 'lib/commands/commands_spec_helper'
+require 'passbook'
+
+describe 'Generate' do
+
+  before :each do
+    $stderr = StringIO.new
+    mock_terminal
+  end
+
+  context 'command' do
+    specify 'no options' do
+      run_command 'generate' do
+        @output.string.should eq 'Enter a passbook name: '
+      end
+
+    end
+
+    specify 'passbook entered directory already exists' do
+      @input << "my_awesome_passbook\n"
+      @input.rewind
+      File.should_receive(:directory?).with('my_awesome_passbook').and_return true
+      run_command 'generate' do
+        @output.string.should eq "Enter a passbook name: \e[31mDirectory my_awesome_passbook already exists\e[0m\n"
+      end    
+    end
+
+    specify 'passbook entered file already exists' do
+      @input << "my_awesome_passbook\n"
+      @input.rewind
+      File.should_receive(:directory?).with('my_awesome_passbook').and_return false
+      File.should_receive(:exist?).with('my_awesome_passbook').and_return true
+      run_command 'generate' do
+        @output.string.should eq "Enter a passbook name: \e[31mFile exists at my_awesome_passbook\e[0m\n"
+      end    
+    end
+
+    context 'valid pass directory' do
+      
+      before :each do
+        File.should_receive(:directory?).with('my_awesome_passbook').and_return false
+        File.should_receive(:exist?).with('my_awesome_passbook').and_return false
+      end
+
+      specify 'invalid type' do
+        @input << "my_awesome_passbook\n"
+        @input.rewind
+        run_command 'generate', '-T', 'honey_badger' do
+          @output.string.should eq "Enter a passbook name: \e[31mInvalid type: \"honey_badger\", expected one of: [boarding-pass, coupon, event-ticket, store-card, generic]\e[0m\n"
+        end    
+      end
+
+      specify 'valid type' do
+        CommandUtils.should_receive(:get_current_directory).and_return('')
+        FileUtils.should_receive(:mkdir_p).with('my_awesome_passbook')
+        FileUtils.should_receive(:cp).with("/../commands/templates/boarding-pass.json", "my_awesome_passbook/pass.json")
+        FileUtils.should_receive(:touch).with("my_awesome_passbook/icon.png")
+        FileUtils.should_receive(:touch).with("my_awesome_passbook/icon@2x.png")
+        @input << "1\n"
+        @input.rewind
+        run_command 'generate', 'my_awesome_passbook'  do
+          @output.string.should eq "Select a pass type\n1. boarding-pass\n2. coupon\n3. event-ticket\n4. store-card\n5. generic\n?  \e[32mPass generated in my_awesome_passbook\e[0m\n"
+        end    
+      end
+    end
+
+
+  end
+
+
+end
+

data/spec/lib/passbook/pkpass_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Passbook  do
+
+  let (:content) {{
+    :formatVersion => 1,
+    :passTypeIdentifier => "pass.passbook.test",
+    :serialNumber => "001",
+    :teamIdentifier => ENV['APPLE_TEAM_ID'],
+    :relevantDate => "2012-10-02",
+    :locations => [  #TODO
+      {
+    :longitude => 2.35403,
+    :latitude => 48.893855
+  }
+  ],
+    :organizationName => "WorldCo",
+    :description => "description",
+    :foregroundColor => "rgb(227,210,18)",
+    :backgroundColor => "rgb(60, 65, 76)",
+    :logoText => "Event",
+    :eventTicket => {
+    :primaryFields => [
+      {
+    :key => "date",
+    :label => "DATE",
+    :value => "date"
+  }
+  ],
+    :backFields => [
+      {
+    :key => "description",
+    :label => "DESCRIPTION",
+    :value => "description"
+  },
+    {
+    :key => "aboutUs",
+    :label => "MORE",
+    :value => "about us"
+  }
+  ]
+  }
+  }}
+
+  let (:signer) {double 'signer'}
+  let (:pass) {Passbook::PKPass.new content.to_json, signer}
+
+  context 'outputs' do
+    let (:base_path) {'spec/data'}
+    let (:entries) {["pass.json", "manifest.json", "signature", "icon.png", "icon@2x.png", "logo.png", "logo@2x.png"]}
+
+    before :each do
+      pass.addFiles ["#{base_path}/icon.png","#{base_path}/icon@2x.png","#{base_path}/logo.png","#{base_path}/logo@2x.png"]
+      signer.should_receive(:sign).and_return('Signed by the Honey Badger')
+      @file_entries = []
+      Zip::InputStream::open(zip_path) {|io|
+        while (entry = io.get_next_entry)
+          @file_entries << entry.name
+        end
+      }
+    end
+
+    context 'zip file' do
+      let(:zip_path) {pass.file.path}
+
+      subject {entries}
+      it {should eq @file_entries}
+    end
+
+    context 'StringIO' do
+      let (:temp_file) {Tempfile.new("pass.pkpass")}
+      let (:zip_path) {
+        zip_out = pass.stream
+        zip_out.class.should eq(Class::StringIO)
+        #creating file, re-reading zip to see if correctly formed
+        temp_file.write zip_out.string
+        temp_file.close
+        temp_file.path
+      }
+
+      subject {entries}
+      it {should eq @file_entries}
+
+      after do
+        temp_file.delete
+      end
+    end
+  end
+
+  # TODO: find a proper way to do this
+  context 'Error catcher' do
+    context 'formatVersion' do
+      let (:base_path) {'spec/data'}
+
+      before :each do
+        pass.addFiles ["#{base_path}/icon.png","#{base_path}/icon@2x.png","#{base_path}/logo.png","#{base_path}/logo@2x.png"]
+        tpass = JSON.parse(pass.pass)
+        tpass['formatVersion'] = 'It should be a numeric'
+        pass.pass = tpass.to_json
+      end
+
+      it "raise an error" do
+        expect { pass.build }.to raise_error('Format Version should be a numeric')
+      end
+
+    end
+  end
+end

data/spec/lib/passbook/push_notification_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'grocer'
+
+describe Passbook::PushNotification  do
+
+  context 'send notification' do
+    let(:grocer_pusher) {double 'Grocer'}
+    let(:notification) {double 'Grocer::Notification'} 
+    let(:notification_settings) {{:certificate => './notification_cert.pem', :gateway => 'honeybadger.apple.com'}}
+
+    before :each do
+      Passbook.should_receive(:notification_cert).and_return './notification_cert.pem'
+      Grocer::PassbookNotification.should_receive(:new).with(:device_token => 'my token').and_return notification 
+      grocer_pusher.should_receive(:push).with(notification).and_return 55
+      Grocer.should_receive(:pusher).with(notification_settings).and_return grocer_pusher
+      Passbook.should_receive(:notification_gateway).and_return 'honeybadger.apple.com'
+    end
+
+    subject {Passbook::PushNotification.send_notification('my token')}
+    it {should eq 55}
+  end
+end

data/spec/lib/passbook/signer_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe 'Signer'  do
+  context 'signatures' do
+
+    context 'p12_cert_and_key' do
+      context 'pem p12 certs' do
+        context 'using config file certificates' do
+          before do
+            Passbook.should_receive(:p12_password).and_return 'password'
+            Passbook.should_receive(:p12_key).and_return 'my_p12_key'
+            Passbook.should_receive(:p12_certificate).and_return 'my_p12_certificate'
+            Passbook.should_receive(:wwdc_cert).and_return 'i_love_robots'
+            File.should_receive(:read).with('my_p12_key').and_return 'my_p12_key_file'
+            File.should_receive(:read).with('my_p12_certificate').and_return 'my_p12_certificate_file'
+            OpenSSL::PKey::RSA.should_receive(:new).with('my_p12_key_file', 'password').and_return 'my_rsa_key'
+            OpenSSL::X509::Certificate.should_receive(:new).with('my_p12_certificate_file').and_return 'my_ssl_p12_cert'
+          end
+
+          subject {Passbook::Signer.new.key_hash}
+          its([:key]) {should eq 'my_rsa_key'}
+          its([:cert]) {should eq 'my_ssl_p12_cert'}
+        end
+
+        context 'using passed in certificates' do
+          before do
+            Passbook.should_receive(:p12_password).never
+            Passbook.should_receive(:p12_key).never
+            Passbook.should_receive(:p12_certificate).never
+            Passbook.should_receive(:wwdc_cert).never
+            File.should_receive(:read).with('my_p12_key').and_return 'my_p12_key_file'
+            File.should_receive(:read).with('my_p12_certificate').and_return 'my_p12_certificate_file'
+            OpenSSL::PKey::RSA.should_receive(:new).with('my_p12_key_file', 'password').and_return 'my_rsa_key'
+            OpenSSL::X509::Certificate.should_receive(:new).with('my_p12_certificate_file').and_return 'my_ssl_p12_cert'
+          end
+
+          subject {Passbook::Signer.new(certificate: 'my_p12_certificate', password: 'password', 
+                                        key: 'my_p12_key', wwdc_cert: 'i_love_robots').key_hash}
+          its([:key]) {should eq 'my_rsa_key'}
+          its([:cert]) {should eq 'my_ssl_p12_cert'}
+        end
+      end
+
+      context 'p12 files' do
+        let (:p12) { double('OpenSSL::PKCS12') }
+        let (:final_hash) {{:key => 'my_final_p12_key', :cert => 'my_final_p12_cert'}}
+        context 'using config file certificates' do
+          before do
+            p12.should_receive(:key).and_return final_hash[:key]
+            p12.should_receive(:certificate).and_return final_hash[:cert]
+            Passbook.should_receive(:p12_password).and_return 'password'
+            Passbook.should_receive(:wwdc_cert).and_return 'i_love_robots'
+            Passbook.should_receive(:p12_certificate).and_return 'my_p12_cert'
+            Passbook.should_receive(:p12_key).and_return nil
+            File.should_receive(:read).with('my_p12_cert').and_return 'my_p12_cert_file'
+            OpenSSL::PKCS12.should_receive(:new).with('my_p12_cert_file', 'password').and_return p12
+          end
+
+          subject {Passbook::Signer.new.key_hash}
+          its([:key]) {should eq final_hash[:key]}
+          its([:cert]) {should eq final_hash[:cert]}
+        end
+
+        context 'using passed in certificates' do
+          before do
+            p12.should_receive(:key).and_return final_hash[:key]
+            p12.should_receive(:certificate).and_return final_hash[:cert]
+            Passbook.should_receive(:p12_password).never
+            Passbook.should_receive(:p12_key).never
+            Passbook.should_receive(:p12_certificate).never
+            Passbook.should_receive(:wwdc_cert).never
+            File.should_receive(:read).with('my_p12_cert').and_return 'my_p12_cert_file'
+            OpenSSL::PKCS12.should_receive(:new).with('my_p12_cert_file', 'password').and_return p12
+          end
+
+          subject {Passbook::Signer.new(certificate: 'my_p12_cert', password: 'password', 
+                                        wwdc_cert: 'i_love_robots').key_hash}
+          its([:key]) {should eq final_hash[:key]}
+          its([:cert]) {should eq final_hash[:cert]}
+        end
+      end
+    end
+  end
+end

data/spec/lib/rack/passbook_rack_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe Rack::PassbookRack  do
+
+  let(:register_delete_path) {'/v1/devices/fe772e610be3efafb65ed77772ca311a/registrations/pass.com.polyglotprogramminginc.testpass/27-1'}
+  let(:register_delete_params) {{'deviceLibraryIdentifier' => 'fe772e610be3efafb65ed77772ca311a',
+    'passTypeIdentifier' => 'pass.com.polyglotprogramminginc.testpass',
+    'serialNumber' => '27-1'}}
+  let(:passes_for_device_path) {'/v1/devices/fe772e610be3efafb65ed77772ca311a/registrations/pass.com.polyglotprogramminginc.testpass'}
+  let(:passes_for_device_params) {{'deviceLibraryIdentifier' => 'fe772e610be3efafb65ed77772ca311a',
+    'passTypeIdentifier' => 'pass.com.polyglotprogramminginc.testpass'}}
+  let(:latest_pass_path) {'/v1/passes/pass.com.polyglotprogramminginc.testpass/27-1'}
+  let(:latest_pass_params) {{'passTypeIdentifier' => 'pass.com.polyglotprogramminginc.testpass',
+                                'serialNumber' => '27-1'}}
+  let(:log_path) {'/v1/log'}
+  let(:push_token) {"8c56f2e787d9c089963960ace834bc2875e3f0cf7745da5b98d58bc6be05b4dc"}
+  let(:auth_token) {"3c0adc9ccbcf3e733edeb897043a4835"}
+
+  context 'find method' do
+    let(:passbook_rack) {Rack::PassbookRack.new nil}
+
+    shared_examples_for 'a method that can handle non passbook urls' do
+      context 'incomplete passbook api path' do
+        subject {passbook_rack.find_method('/v1/devices/fe772e610be3efafb65ed77772ca311a/registrations')}
+        it {should eq nil}
+      end
+
+      context 'no version api path' do
+        subject {passbook_rack.find_method('/devices/fe772e610be3efafb65ed77772ca311a/registrations')}
+        it {should eq nil}
+      end
+
+      context 'no devices api path' do
+        subject {passbook_rack.find_method('/v1/fe772e610be3efafb65ed77772ca311a/registrations')}
+        it {should eq nil}
+      end
+
+      context 'no registrations api path' do
+        subject {passbook_rack.find_method('/v1/devices/fe772e610be3efafb65ed77772ca311a')}
+        it {should eq nil}
+      end
+    end
+
+    context 'device register delete' do
+      context 'a valid path' do
+        subject {passbook_rack.find_method(register_delete_path)}
+        its([:method]) {should eq 'device_register_delete'}
+        its([:params]) {should eq(register_delete_params) }
+      end
+
+      it_behaves_like 'a method that can handle non passbook urls' 
+
+    end
+
+    context 'passes for device' do
+      subject {passbook_rack.find_method(passes_for_device_path)}
+      its([:method]) {should eq 'passes_for_device'}
+      its([:params]) {should eq passes_for_device_params }
+    end
+
+    context 'latest pass' do
+      subject {passbook_rack.find_method(latest_pass_path)}
+      its([:method]) {should eq 'latest_pass'}
+      its([:params]) {should eq(latest_pass_params) }
+    end
+
+    context 'latest pass' do
+      subject {passbook_rack.find_method(log_path)}
+      its([:method]) {should eq 'log'}
+    end
+  end
+
+  context 'rack middleware' do
+
+    context 'register pass without authToken' do
+      before do
+        Passbook::PassbookNotification.should_receive(:register_pass).
+          with(register_delete_params.merge!('pushToken' => push_token)).and_return({:status => 201})
+        post register_delete_path, {"pushToken" => push_token}.to_json
+      end
+
+      subject {last_response}
+      its(:status) {should eq 201}
+    end
+
+    context 'register pass with authToken' do
+      before do
+        Passbook::PassbookNotification.should_receive(:register_pass).
+          with(register_delete_params.merge!('pushToken' => push_token,'authToken' => auth_token)).and_return({:status => 201})
+        post register_delete_path, {"pushToken" => push_token}.to_json, rack_env = {'HTTP_AUTHORIZATION' => auth_token}
+      end
+
+      subject {last_response}
+      its(:status) {should eq 201}
+    end
+
+    context 'passes for device' do
+      context 'with passes' do
+        let(:passes_for_device_response) {{'last_updated' => 1, 'serial_numbers' => [343, 234]}}
+        before do
+          Passbook::PassbookNotification.should_receive(:passes_for_device).
+            with(passes_for_device_params).and_return(passes_for_device_response)
+          get passes_for_device_path
+        end
+
+        context 'status' do
+          subject {last_response.status}
+          it {should eq 200}
+        end
+
+        context 'body' do
+          subject{JSON.parse(last_response.body)}
+          it {should eq passes_for_device_response}
+        end
+      end
+
+      context 'with passes modified since' do
+        before do
+          Passbook::PassbookNotification.should_receive(:passes_for_device).
+            with(passes_for_device_params.merge!('passesUpdatedSince' => '1371189712')).and_return(nil)
+          path_with_update_since = passes_for_device_path + "?passesUpdatedSince=1371189712"
+          get path_with_update_since
+        end
+
+        context 'status' do
+          subject {last_response.status}
+          it {should eq 204}
+        end
+      end
+
+      context 'without passes' do
+        before do
+          Passbook::PassbookNotification.should_receive(:passes_for_device).
+            with(passes_for_device_params).and_return(nil)
+          get passes_for_device_path
+        end
+
+        context 'status' do
+          subject {last_response.status}
+          it {should eq 204}
+        end
+      end
+    end
+
+    context 'get latest pass' do
+      context 'valid pass' do
+        let(:raw_pass) {'some url encoded text'}
+
+        before do
+          Passbook::PassbookNotification.should_receive(:latest_pass).with(latest_pass_params).
+            and_return(raw_pass)
+          get latest_pass_path
+        end
+
+        subject {last_response}
+        its(:status) {should eq 200}
+        its(:header) {should eq({'Content-Type' => 'application/vnd.apple.pkpass', 
+          'Content-Disposition' => 'attachment', 'filename' => '27-1.pkpass', 'Content-Length' => '21'})}
+        its(:body) {should eq raw_pass}
+      end
+
+      context 'no pass' do
+        before do
+          Passbook::PassbookNotification.should_receive(:latest_pass).with(latest_pass_params).
+            and_return(nil)
+          get latest_pass_path
+        end
+
+        subject {last_response}
+        its(:status) {should eq 204}
+      end
+    end
+
+    context 'unregister pass without authToken' do
+      before do
+        Passbook::PassbookNotification.should_receive(:unregister_pass).
+          with(register_delete_params).and_return({:status => 200})
+        delete register_delete_path
+      end
+
+      subject {last_response}
+      its(:status) {should eq 200}
+    end
+
+    context 'unregister pass with authToken' do
+      before do
+        Passbook::PassbookNotification.should_receive(:unregister_pass).
+          with(register_delete_params.merge!('authToken' => auth_token)).and_return({:status => 200})
+        delete register_delete_path, {}, rack_env = {'HTTP_AUTHORIZATION' => auth_token}
+      end
+
+      subject {last_response}
+      its(:status) {should eq 200}
+    end
+
+    context 'log' do
+      let(:log_params) {{'logs' => ['some error']}}
+      before do
+        Passbook::PassbookNotification.should_receive(:passbook_log).
+          with(log_params)
+        post log_path, log_params.to_json
+      end
+
+      subject {last_response}
+      its(:status) {should eq 200}
+    end
+
+    context 'non passbook requests' do
+      before do
+        get '/foo'
+      end
+
+      subject {last_response}
+      its(:status) {should eq 200}
+      its(:body) {should eq 'test app'}
+    end    
+  end
+
+end
+
+require 'rack/test'
+include Rack::Test::Methods
+
+def app
+  test_app = lambda do |env|
+    [200, {}, 'test app']
+  end 
+
+  Rack::PassbookRack.new test_app
+end
+
+class Passbook::PassbookNotification
+end