passbookpgh 0.4.5

data/spec/lib/commands/build_spec.rb

@@ -0,0 +1,92 @@
+require 'lib/commands/commands_spec_helper'
+require 'passbook'
+
+describe 'Build' do
+
+  before :each do
+    $stderr = StringIO.new
+    mock_terminal
+  end
+
+  context 'command' do
+    specify 'missing directory' do
+      run_command 'build' do
+        @output.string.should eq "\e[31mMissing argument\e[0m\n"
+      end
+    end
+
+    context 'good directory' do
+
+      before :each do
+        File.should_receive(:directory?).with('scraps').and_return true
+        File.should_receive(:exist?).once.with('scraps/pass.json').and_return true
+        File.should_receive(:exist?).once.with('scraps.pkpass').and_return false
+      end
+
+      specify 'no certificate file' do
+        run_command 'build', 'scraps' do
+          @output.string.should eq "\e[31mMissing or invalid certificate file\e[0m\n" 
+        end
+      end
+
+      context 'good certificate file' do
+        before :each do
+          File.should_receive(:exist?).with('jackels').and_return true
+        end
+
+        specify 'no certificate password entered' do
+          run_command 'build', 'scraps', '-w', 'jackels' do
+            @output.string.should eq "Enter certificate password:\n\n"
+          end    
+        end
+
+        context 'all required values' do
+
+          let(:pass_json) {'{"this":"is awesome json"}'}
+          let(:pass_assets) {['pass.json', 'something.jpeg']}
+
+          before :each do
+            Passbook.should_receive(:wwdc_cert=).with 'jackels'      
+            Passbook.should_receive(:p12_key=).with 'badger_key'      
+            Passbook.should_receive(:p12_certificate=).with 'badger_cert'      
+            Passbook.should_receive(:p12_password=).with 'bees'    
+            CommandUtils.should_receive(:get_assets).with('scraps').and_return pass_assets 
+            @pk_pass = double 'pk pass'
+            File.should_receive(:read).with('pass.json').and_return pass_json 
+            Passbook::PKPass.should_receive(:new).with(pass_json).and_return @pk_pass
+            @pk_pass.should_receive(:addFiles).with pass_assets
+          end
+
+          specify 'are set from command line' do
+            pass_stream = double 'passbook stream' 
+            pass_stream.should_receive(:string).and_return 'my badass pass'
+            @pk_pass.should_receive(:stream).and_return pass_stream
+            File.should_receive(:open).with('scraps.pkpass', 'w')
+
+            run_command 'build', 'scraps', '-w', 'jackels',
+              '-p', 'bees', '-k', 'badger_key', '-c', 'badger_cert' do
+              @output.string.should eq ""
+              end    
+          end
+
+          specify 'should catch a general error' do
+            @pk_pass.should_receive(:stream).and_raise(StandardError.new('I have failed'))
+            run_command 'build', 'scraps', '-w', 'jackels',
+              '-p', 'bees', '-k', 'badger_key', '-c', 'badger_cert' do
+              @output.string.should eq "\e[31mError: I have failed\e[0m\n"
+              end    
+          end
+
+          specify 'should catch a general error' do
+            @pk_pass.should_receive(:stream).and_raise(OpenSSL::PKCS12::PKCS12Error.new('I am a failure'))
+            run_command 'build', 'scraps', '-w', 'jackels',
+              '-p', 'bees', '-k', 'badger_key', '-c', 'badger_cert' do
+              @output.string.should eq "\e[31mError: I am a failure\e[0m\n\e[33mYou may be getting this error because the certificate password is either incorrect or missing\e[0m\n"
+              end    
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/commands/commands_spec.rb

@@ -0,0 +1,102 @@
+require 'lib/commands/commands_spec_helper'
+
+describe 'Commands' do
+
+  before :each do
+    program :version, '1.2.3'
+    program :description, "Honey Badger Don't Care"
+  end
+
+  context 'determine directory' do
+
+    specify 'no directories' do
+      Dir.should_receive(:[]).and_return []
+      determine_directory!
+      @directory.should eq nil
+    end
+
+    specify 'one directory present' do
+      Dir.should_receive(:[]).and_return ['ass']
+      File.should_receive(:dirname).with('ass').and_return('/honey/badger/is/bad/ass')
+      determine_directory!
+      @directory.should eq '/honey/badger/is/bad/ass'
+    end
+
+    specify 'multiple directories' do
+      Dir.should_receive(:[]).and_return ['cobras', 'bee_larvae']
+      File.should_receive(:dirname).with('cobras').and_return('/yummy/cobras')
+      File.should_receive(:dirname).with('bee_larvae').and_return('/disgusting/bee_larvae')
+      self.should_receive(:choose).with('Select a directory:', 
+                                        '/yummy/cobras', '/disgusting/bee_larvae').and_return '/yummy/cobras'
+      determine_directory!
+      @directory.should eq '/yummy/cobras' 
+    end
+
+  end
+
+  context 'validate directory' do
+
+    specify 'missing directory' do
+      self.should_receive(:say_error).with('Missing argument').and_return true
+      lambda {
+        @directory = nil
+        validate_directory!
+      }.should exit_with_code(1)
+    end
+
+    specify 'directory does not exist' do
+      self.should_receive(:say_error).with("Directory scraps does not exist").and_return true
+      File.should_receive(:directory?).with('scraps').and_return false
+      lambda {
+        @directory = 'scraps'
+        validate_directory!
+      }.should exit_with_code(1) 
+    end
+
+    specify 'directory does not have a valid pass' do
+      self.should_receive(:say_error).with("Directory scraps is not a valid pass").and_return true
+      File.should_receive(:directory?).with('scraps').and_return true
+      File.should_receive(:exist?).with('scraps/pass.json').and_return false
+      lambda {
+        @directory = 'scraps'
+        validate_directory!
+      }.should exit_with_code(1) 
+    end
+
+    specify 'directory has valid pass' do
+      File.should_receive(:directory?).with('scraps').and_return true
+      File.should_receive(:exist?).with('scraps/pass.json').and_return true
+      lambda {
+        @directory = 'scraps'
+        validate_directory!
+      }.should_not exit_with_code(1) 
+    end
+  end
+
+  context 'validate certificate' do
+    specify 'nil certificate' do
+      self.should_receive(:say_error).with("Missing or invalid certificate file").and_return true
+      lambda {
+        @certificate = nil
+        validate_certificate!
+      }.should exit_with_code(1) 
+    end
+
+    specify 'certificate file does not exist' do
+      self.should_receive(:say_error).with("Missing or invalid certificate file").and_return true
+      File.should_receive(:exist?).with('jackels').and_return false
+      lambda {
+        @certificate = 'jackels'
+        validate_certificate!
+      }.should exit_with_code(1) 
+    end
+
+    specify 'certificate file exists' do
+      File.should_receive(:exist?).with('jackels').and_return true
+      lambda {
+        @certificate = 'jackels'
+        validate_certificate!
+      }.should_not exit_with_code(1) 
+    end
+  end 
+end

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,23 @@
+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', :passphrase => 'ah@rdvintAge'}}
+
+    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'
+      Passbook.should_receive(:notification_passphrase).and_return 'ah@rdvintAge'
+    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