keyrack 0.3.0.pre → 0.3.0

data/features/step_definitions/keyrack_steps.rb

@@ -1,61 +0,0 @@
-Before do
-  @fake_home = Dir::Tmpname.create('keyrack') { }
-  Dir.mkdir(@fake_home)
-  @old_home = ENV['HOME']
-  ENV['HOME'] = @fake_home
-end
-
-After do
-  ENV['HOME'] = @old_home
-  FileUtils.rm_rf(@fake_home)
-end
-
-When /I run keyrack interactively/ do
-  @out, @in, @pid = PTY.spawn("bundle exec ruby -Ilib bin/keyrack")
-end
-
-Then /the output should contain "([^"]+)"/ do |expected|
-  if @slept
-    @slept = false
-  else
-    sleep 1
-  end
-  @output = @out.read_nonblock(255)
-  assert @output.include?(expected), "Output: #{@output.inspect}"
-end
-
-Then %r{the output should match /([^/]+)/} do |expected|
-  # This won't work for escaped backslashes
-  if @slept
-    @slept = false
-  else
-    sleep 1
-  end
-  @output = @out.read_nonblock(255)
-  assert @output.match(Regexp.new(expected))
-end
-
-Then /the output should also contain "([^"]+)"/ do |expected|
-  assert @output.include?(expected)
-end
-
-When /I type "([^"]+)"/ do |text|
-  @in.puts(text)
-end
-
-When /I wait a few seconds/ do
-  sleep 5
-  @slept = true
-end
-
-Then /my clipboard should contain "([^"]+)"/ do |expected|
-  sleep 1
-  result = %x{xclip -selection clipboard -o}.chomp
-  assert_equal expected, result
-end
-
-Then /my clipboard should match "([^"]+)"/ do |expected|
-  sleep 1
-  result = %x{xclip -selection clipboard -o}.chomp
-  assert_match Regexp.new(expected), result
-end

data/features/support/env.rb

@@ -1,16 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'tempfile'
-require 'fileutils'
-require 'pty'
-require 'yaml'
-require 'test/unit/assertions'
-
-World(Test::Unit::Assertions)

data/test/fixtures/config.yml

@@ -1,4 +0,0 @@
-'store':
-  'type': 'filesystem'
-  'path': /tmp/keyrack.dat
-'key': test/fixtures/id_rsa

data/test/fixtures/id_rsa

@@ -1,54 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,030F0E3D8BD7BF1A
-
-8s6OIKXWfXq6xrPRrJ3m2qU/Xd+N35Y9cCjr+nqnESWGBrT7ZLLIiS4xEMy2WwHB
-N9kj0OekQxDz0yfCP/+CyCMvtFpJGwbqgOCJWXyDsmaQDVG3Z7MRehoGA2s9Zkab
-2h4F6YE7iE3oVY/2Z86SBhk4KITyGi0Jb8/KHvoig+iF6rqAPos0I5Y3M1vVa9DJ
-lFdyoTbFzx+mzbEXIefGOdcXinkfAoG7MchPiEypunrpEgYPddsON2b/dQfIBmEy
-3+gN9FnbWH3LNTOShzl4l4v2aBfxXgg5bHPnKkJiUNRDlY6ozyQYfxxoOs4uL8mI
-WnfmVGezxkD3YWHB+xwevLaIjChowSNP/q7sSHVOD/bVadmhd30I7CnhFITKi0Wp
-vr0qbGpSrsWm7zCtSWcK0fFMGKea2UoH4lrfqJv95mOhZ+pmok35CxGUbG0S53rm
-A4ggoIr3cYvRMPkp/Q9dZQxE6FHftXO9C+IvJc1CmtUJl+LR7aOtQy4pgPyRV83x
-yfw2SrJ9ls0RZKm4lQUqlwDrru20hf8YiyeLPGlpnRpVVGkdNfhR3Q/e1Tl4qr/3
-ITJ1uxopaQZtggR+9wlYG9oS5htJ9VZo+Jh8Oys5c0ZAPlzHQMuU3TQVeLuXIAQ6
-zgLyThmKGgG3iBKG2FUZIpGX3WGIFgKwuwAQJXs0fthF5JJAuBXY5Jbvu3y1AQDC
-rC9XgYr9PfL8o4zIXxxRvxUny2YO+XaKjgiOV9kKV5reUNJQW95sCvuZZyFh3STW
-tywsdQ7ZzsHLJ0sun0Dj4GjbIfMb9l95x1baMIAcXqbqmS9c6Hd53gM2e+8d0Wja
-tBb9f2rddcmoyMNB/MKTnCm1L7GjrHtQJXClCKlpyDgZrUbdHcRhq4UY8diVVdam
-ZhIVRdMIYr70BUhpTH3gqBLQlNX0D6DItCNdI+cr9p2BUqM87xTeQM84HfKOyZZO
-ZqgwZ5jhxjgyrQYADeBD6RqH7fcnitowksRGxZdnZQdm+U+SfQbfmA0zYCh+jgz3
-fMVQ+9sjnGZzl0/Wn8Kg8K2jA33N96ou7X89wyiSLMvAW6G+/CaxQMEgTDy+mxES
-BLv7h+LdGzOtRE8556hBmNs5ku8AoMmP5irvEkGJIjtB+JcmeIi+AD0hBSq7O4Gp
-5OoyXEYp+cYLTQtyLEQ6/CnSEvjgzXRG2xKY9wxspXaJn/q7QwadkgltvjtUo0Iu
-OXV6MJGQYkVkm5xf3tmvuQYQNV3NK/nQpDixhMJye19Kjr7jelRpcr+Y5VXelRP5
-5CiqpqW0DtM1YWQBUr7p3ckft1DCYB48ARcEqmrgV7KASawZAh7Lun/SkiJ6SYl0
-3Q4QVhQbOyx1S04UPRWzEqIBquHqMFzEjnzkQRFAxvnWJx3mnQudAi1yKtKZDpLL
-3kuMXJ90hg+/VoEWehEG+VZXxPOgFf624Wv9SnEv2vtxZv4g8B+Ny9SXl/CzDiA0
-GsbA9tOzJc9MmYCts19QQ85zsp9B1eJO7oxh5OETOe2FkivU/HqMOp0A3B3rEjY+
-CS0g15bqEmCyFxvbBkR8aUZ6c5fHvNngvxYbkGVLyHpgIHmszGj1+gz/8DlEXldM
-EE5gY6kZ/iH8ikTjhPCX3Cd8HybjOh1JQogTbOeOMGhkKtEEs+XyFZYP6OrC2Cuf
-Yk2osm4J+g+mPXFjQU/Ie9f6Q8Bv0tShFHEh17N4/IJRQPCRhiIMfq/PaBp7Rt3m
-RT3fmPl/g4WywBVfC8jv4ES+HA2xWC3cds8rOeh3mgmaimNRmPzpHVe/vyxSUqUh
-PC8BXJ+wN+jNg718MYNneah1cC9hsrCMa3wU9dv59LGHsC0rNrbCqmmGMFZVKldV
-4HbG77K6QyLjk8bNsVUtwV+0hClBAWHi6K5dAY7IOCdGcVgrZ+drFl1sDyM4vkZ+
-kkBnNLrvczR3Mqh+Q901Ha1aepTyHbFN0EMK965Ni8PWw41cYXvgKzRDFJi1iuvx
-hr3qu2icCOeVCLE/Vnk0w0t6pxr+1V0sxYx3weBXHDO3NS6EEFKdX8zoGZI17MSF
-QVYq1Oko1LU44VvXfw18yS/dsu7nxC106uL9EPOjaN+wf0+V/i9s3AWnPCYftwA8
-9l2EBuhElh8drZ2Kb0aL1i0VzB/1zYwDbNZnVhhRF2CAcXTmnpD6RXfgLUnnUVGa
-nCPZ8/ks84rXjAxWNcLHSCdVWzczHDKz22VJFa+AIrqMxz77r+aEAzMvxHNAbs5v
-E8cPNfmir56mOSD0TRrfPqKoCARLcmLd97RGikh3kw1BYVI02BAwQ3jABrW5v/53
-fg8fMafNuQl3Xw4LkQ4VoKAwR4mi5JUN5ngeRDfQVmBs1GOVV981dHvrfrGa3lrR
-xHTb7iYXU0XJ219yZHNtGzaTs6g+xvbMF9aELkfbIPGkwqMlKp/2OQmQqq171Nez
-me/suc8ZzmZsVGVhW3a/uvB7+DLOgnO41AxQVe9DXO8aVjpjwdpXWmPt8sisgMov
-uJFTUBsnG6rg2agxzWrQEQpBONkeY3CGk5P3JLIruhXhNCFs4pjff7xKrdppHmBe
-ukm5z2jEbvbdt7VQ/UtGeWzUEoiRh2k7EK/EnK7j0NRsKMPe5DPsIncgWdB/krTn
-iXzzvHY0iN6W0ZQELuN8wvt5lnnDmak21+Q/vaA04NHWBhznCIggZDl4+MIuYIBo
-T+4OkwEIObuKOW06AI8qIaKVX24bmeZ2Fcj4dGMT0SHlXga6S4ouVUeZ1hOCGg9Z
-4Nw53gzWaOIW3TntoNoieibjzHigUWghnXEpn1DB+dfGhTxDWpSZKRIkuBNPEVvn
-FtXPwvUg0yrMp4JItSQ7PT2GMtar16qBc+0bgQlX53Vb5kW22rIoNq5zDwWcNB8s
-0octG6yq6aEVId/3/2rrQi8izkoZXZe8FJgR02o9M4J/4HsJ74xbqnbuNE7FUZiZ
-EX+2BKoNEShxujW+zd1NpSNSfGRAYuk0llUMsbRO8ZfNlZWj9fTNmPHshCWIvZ3a
-yxTdjoC3SPtAUz+ZDznBnlIiXyU6XcUPEY+FBsN9K2S0Blb8fvc1cxjL1H1r5Pdj
-yPJAIxlfePv1TRYzCf2kmdnIOq3yoCWAU6RxGq8TII6KGvKP14OtMHCyonDB2/UZ
------END RSA PRIVATE KEY-----

data/test/keyrack/store/test_filesystem.rb

@@ -1,25 +0,0 @@
-require 'helper'
-
-module Keyrack
-  module Store
-    class TestFilesystem < Test::Unit::TestCase
-      def test_read
-        path = fixture_path('foo.txt')
-        store = Filesystem.new('path' => path)
-        assert_equal File.read(path), store.read
-      end
-
-      def test_write
-        path = get_tmpname
-        store = Filesystem.new('path' => path)
-        store.write("foobar")
-        assert_equal "foobar", File.read(path)
-      end
-
-      def test_read_returns_nil_for_non_existant_file
-        store = Filesystem.new('path' => 'blargityblargh')
-        assert_nil store.read
-      end
-    end
-  end
-end

data/test/keyrack/store/test_ssh.rb

@@ -1,36 +0,0 @@
-require 'helper'
-
-module Keyrack
-  module Store
-    class TestSSH < Test::Unit::TestCase
-      def test_read
-        store = SSH.new('host' => 'example.com', 'user' => 'dude', 'port' => 22, 'path' => 'foo.txt')
-        scp = mock('scp session')
-        scp.expects(:download!).with("foo.txt").returns("foo")
-        session = mock('ssh session', :scp => scp)
-        Net::SSH.expects(:start).with('example.com', 'dude', :port => 22).yields(session)
-        assert_equal "foo", store.read
-      end
-
-      def test_write
-        store = SSH.new('host' => 'example.com', 'user' => 'dude', 'path' => 'foo.txt')
-        scp = mock('scp session')
-        session = mock('ssh session', :scp => scp)
-        Net::SSH.expects(:start).with('example.com', 'dude', :port => 22).yields(session)
-        scp.expects(:upload!).with do |local, remote|
-          local.is_a?(StringIO) && local.read == "foo" && remote == "foo.txt"
-        end
-        store.write("foo")
-      end
-
-      def test_read_returns_nil_for_non_existant_file
-        store = SSH.new('host' => 'example.com', 'user' => 'dude', 'port' => 22, 'path' => 'foo.txt')
-        scp = mock('scp session')
-        scp.expects(:download!).with("foo.txt").raises(Net::SCP::Error)
-        session = mock('ssh session', :scp => scp)
-        Net::SSH.expects(:start).with('example.com', 'dude', :port => 22).yields(session)
-        assert_nil store.read
-      end
-    end
-  end
-end

data/test/keyrack/test_database.rb

@@ -1,111 +0,0 @@
-require 'helper'
-
-module Keyrack
-  class TestDatabase < Test::Unit::TestCase
-    def setup
-      @key = "abcdefgh" * 32
-      @iv = @key.reverse
-
-      @path = get_tmpname
-      @store = Store['filesystem'].new('path' => @path)
-
-      @database = Keyrack::Database.new(@key, @iv, @store)
-      @database.add('Twitter', 'username', 'password')
-      @database.save
-    end
-
-    def test_encrypts_database
-      encrypted_data = File.read(@path)
-      cipher = OpenSSL::Cipher::Cipher.new("AES-128-CBC")
-      cipher.decrypt; cipher.key = @key; cipher.iv = @iv
-      marshalled_data = cipher.update(encrypted_data) + cipher.final
-      data = Marshal.load(marshalled_data)
-      assert_equal({'Twitter'=>{:username=>'username',:password=>'password'}}, data)
-    end
-
-    def test_reading_existing_database
-      database = Keyrack::Database.new(@key, @iv, @store)
-      expected = {:username => 'username', :password => 'password'}
-      assert_equal(expected, database.get('Twitter', 'username'))
-    end
-
-    def test_sites
-      @database.add('Blargh', 'dudeguy', 'secret', :group => "Junk")
-      assert_equal(%w{Twitter}, @database.sites)
-      assert_equal(%w{Blargh}, @database.sites(:group => "Junk"))
-      assert_equal([], @database.sites(:group => "New group"))
-    end
-
-    def test_groups
-      assert_equal [], @database.groups
-      @database.add('Blargh', 'dudeguy', 'secret', :group => "Junk")
-      assert_equal %w{Junk}, @database.groups
-    end
-
-    def test_dirty
-      assert !@database.dirty?
-      @database.add('Foo', 'bar', 'baz')
-      assert @database.dirty?
-    end
-
-    def test_large_number_of_entries
-      site = "abcdefg"; user = "1234567"; pass = "zyxwvut" * 2
-      500.times do |i|
-        @database.add(site, user, pass)
-        site.next!; user.next!; pass.next!
-      end
-      @database.save
-      assert_equal 501, @database.sites.length
-    end
-
-    def test_add_with_top_level_group
-      @database.add('Twitter', 'dudeguy', 'secret', :group => "Social")
-      expected = {:username => 'dudeguy', :password => 'secret'}
-      assert_equal expected, @database.get('Twitter', 'dudeguy', :group => "Social")
-    end
-
-    def test_delete
-      @database.delete('Twitter', 'username')
-      assert_equal [], @database.sites
-      assert @database.dirty?
-    end
-
-    def test_delete_non_existant_entry
-      @database.delete('Twitter', 'foobar')
-      assert_equal ['Twitter'], @database.sites
-      assert !@database.dirty?
-    end
-
-    def test_delete_group_entry
-      @database.add('Facebook', 'dudeguy', 'secret', :group => "Social")
-      @database.delete('Facebook', 'dudeguy', :group => 'Social')
-      assert_equal [], @database.sites(:group => 'Social')
-      assert_equal ['Twitter'], @database.sites
-    end
-
-    def test_multiple_entries_with_the_same_site
-      @database.add('Facebook', 'dudeguy', 'secret')
-      @database.add('Facebook', 'foobar', 'secret')
-
-      expected_1 = {:username => 'dudeguy', :password => 'secret'}
-      assert_equal expected_1, @database.get('Facebook', 'dudeguy')
-      expected_2 = {:username => 'foobar', :password => 'secret'}
-      assert_equal expected_2, @database.get('Facebook', 'foobar')
-      assert_equal [expected_1, expected_2], @database.get('Facebook')
-      assert_equal ['Facebook', 'Twitter'], @database.sites
-    end
-
-    def test_get_missing_entry_by_site_and_username
-      @database.add('Facebook', 'dudeguy', 'secret')
-      assert_nil @database.get('Facebook', 'foobar')
-    end
-
-    def test_deleting_one_of_two_entries_with_the_same_site
-      @database.add('Facebook', 'dudeguy', 'secret')
-      @database.add('Facebook', 'foobar', 'secret')
-      @database.delete('Facebook', 'dudeguy')
-      assert_nil @database.get('Facebook', 'dudeguy')
-      assert_equal({:username => 'foobar', :password => 'secret'}, @database.get('Facebook', 'foobar'))
-    end
-  end
-end

data/test/keyrack/test_runner.rb

@@ -1,111 +0,0 @@
-require 'helper'
-
-module Keyrack
-  class TestRunner < Test::Unit::TestCase
-    def setup
-      @console = stub('console', {
-        :get_password => 'secret',
-        :database= => nil, :menu => :quit,
-        :get_new_entry => {:site => "Foo", :username => "bar", :password => "baz"}
-      })
-      UI::Console.stubs(:new).returns(@console)
-      @database = stub('database', { :add => nil })
-      Database.stubs(:new).returns(@database)
-    end
-
-    def test_console
-      store_path = 'foo/bar/hey/buddy'
-      rsa_path = 'omg/rsa/path'
-      aes_path = 'hey/its/some/aes/stuff'
-      config = {
-        'store' => { 'type' => 'filesystem', 'path' => store_path },
-        'rsa' => rsa_path, 'aes' => aes_path
-      }
-      keyrack_dir = get_tmpname
-      Dir.mkdir(keyrack_dir)
-      File.open(File.join(keyrack_dir, "config"), 'w') { |f| f.print(config.to_yaml) }
-
-      UI::Console.expects(:new).returns(@console)
-
-      seq = sequence('ui sequence')
-      @console.expects(:get_password).returns('secret').in_sequence(seq)
-      rsa = mock("rsa key")
-      Utils.expects(:open_rsa_key).with(File.expand_path(rsa_path, keyrack_dir), 'secret').returns(rsa).in_sequence(seq)
-      aes = {'key' => '12345', 'iv' => '54321'}
-      Utils.expects(:open_aes_data).with(File.expand_path(aes_path, keyrack_dir), rsa).returns(aes).in_sequence(seq)
-      store = mock('filesystem store')
-      Store::Filesystem.expects(:new).with('path' => store_path).returns(store).in_sequence(seq)
-      Database.expects(:new).with('12345', '54321', store).returns(@database).in_sequence(seq)
-      @console.expects(:database=).with(@database).in_sequence(seq)
-
-      @console.expects(:menu).returns(:new).in_sequence(seq)
-      @console.expects(:get_new_entry).returns({:site => "Foo", :username => "bar", :password => "baz"}).in_sequence(seq)
-      @database.expects(:add).with("Foo", "bar", "baz", {})
-      @console.expects(:menu).returns(nil).in_sequence(seq)
-      @console.expects(:menu).returns(:save).in_sequence(seq)
-      @database.expects(:save).in_sequence(seq)
-      @console.expects(:menu).returns(:delete).in_sequence(seq)
-      @console.expects(:delete_entry).with({}).in_sequence(seq)
-      @console.expects(:menu).returns(:new_group).in_sequence(seq)
-      @console.expects(:get_new_group).returns(:group => 'Blah').in_sequence(seq)
-      @console.expects(:menu).with(:group => 'Blah').returns(:top).in_sequence(seq)
-      @console.expects(:menu).returns(:group => 'Huge').in_sequence(seq)
-      @console.expects(:menu).with(:group => 'Huge').returns(nil).in_sequence(seq)
-      @console.expects(:menu).with(:group => 'Huge').returns(:new).in_sequence(seq)
-      @console.expects(:get_new_entry).returns({:site => "Bar", :username => "bar", :password => "baz"}).in_sequence(seq)
-      @database.expects(:add).with("Bar", "bar", "baz", :group => 'Huge')
-      @console.expects(:menu).with(:group => "Huge").returns(:delete).in_sequence(seq)
-      @console.expects(:delete_entry).with(:group => 'Huge').in_sequence(seq)
-      @console.expects(:menu).with(:group => 'Huge').returns(:top).in_sequence(seq)
-      @console.expects(:menu).returns(:quit).in_sequence(seq)
-
-      runner = Runner.new(["-d", keyrack_dir])
-    end
-
-    def test_console_first_run
-      keyrack_dir = get_tmpname
-      seq = sequence('ui sequence')
-
-      @console.expects(:display_first_time_notice).in_sequence(seq)
-
-      # RSA generation
-      rsa_path = 'id_rsa'
-      @console.expects(:rsa_setup).returns('password' => 'secret', 'path' => rsa_path).in_sequence(seq)
-      rsa = mock('rsa key')
-      Utils.expects(:generate_rsa_key).with('secret').returns([rsa, 'private key']).in_sequence(seq)
-
-      # AES generation
-      Utils.expects(:generate_aes_key).twice.returns('foobar', 'barfoo').in_sequence(seq)
-      dump = Marshal.dump('key' => 'foobar', 'iv' => 'barfoo')
-      rsa.expects(:public_encrypt).with(dump).returns("encrypted dump")
-
-      # Store setup
-      @console.expects(:store_setup).returns('type' => 'filesystem', 'path' => 'database').in_sequence(seq)
-      store = mock('filesystem store')
-      Store::Filesystem.expects(:new).with('path' => File.join(keyrack_dir, 'database')).returns(store).in_sequence(seq)
-
-      Database.expects(:new).with('foobar', 'barfoo', store).returns(@database).in_sequence(seq)
-      @console.expects(:database=).with(@database).in_sequence(seq)
-      @console.expects(:menu).returns(:quit).in_sequence(seq)
-
-      runner = Runner.new(["-d", keyrack_dir])
-
-      assert Dir.exist?(keyrack_dir)
-      expected_rsa_file = File.expand_path(rsa_path, keyrack_dir)
-      assert File.exist?(expected_rsa_file)
-      assert_equal 'private key', File.read(expected_rsa_file)
-
-      expected_aes_file = File.expand_path('aes', keyrack_dir)
-      assert File.exist?(expected_aes_file)
-      assert_equal 'encrypted dump', File.read(expected_aes_file)
-
-      expected_config_file = File.expand_path('config', keyrack_dir)
-      assert File.exist?(expected_config_file)
-      expected_config = {
-        'rsa' => expected_rsa_file, 'aes' => expected_aes_file,
-        'store' => { 'type' => 'filesystem', 'path' => File.join(keyrack_dir, 'database') }
-      }
-      assert_equal expected_config, YAML.load_file(expected_config_file)
-    end
-  end
-end

data/test/keyrack/test_store.rb

@@ -1,15 +0,0 @@
-require 'helper'
-
-module Keyrack
-  class TestStore < Test::Unit::TestCase
-    def test_get_filesystem
-      assert_equal Store::Filesystem, Store[:filesystem]
-      assert_equal Store::Filesystem, Store['filesystem']
-    end
-
-    def test_get_ssh
-      assert_equal Store::SSH, Store[:ssh]
-      assert_equal Store::SSH, Store['ssh']
-    end
-  end
-end

data/test/keyrack/test_utils.rb

@@ -1,41 +0,0 @@
-require 'helper'
-
-module Keyrack
-  class TestUtils < Test::Unit::TestCase
-    def test_generate_password
-      result = Utils.generate_password
-      assert_match /^[!-~]{8}$/, result
-    end
-
-    def test_generate_rsa_key
-      rsa = mock('rsa')
-      OpenSSL::PKey::RSA.expects(:new).with(4096).returns(rsa)
-      cipher = mock('cipher')
-      OpenSSL::Cipher::Cipher.expects(:new).with('des3').returns(cipher)
-      rsa.expects(:to_pem).with(cipher, 'secret').returns('private key')
-
-      assert_equal([rsa, 'private key'], Utils.generate_rsa_key('secret'))
-    end
-
-    def test_generate_aes_key
-      SecureRandom.expects(:base64).with(128).returns("x" * 172)
-      result = Utils.generate_aes_key
-      assert_equal 128, result.length
-    end
-
-    def test_open_rsa_key
-      rsa_path = fixture_path('id_rsa')
-      rsa = mock('rsa')
-      OpenSSL::PKey::RSA.expects(:new).with(File.read(rsa_path), 'secret').returns(rsa)
-      assert_equal(rsa, Utils.open_rsa_key(rsa_path, 'secret'))
-    end
-
-    def test_open_aes_data
-      aes_path = fixture_path('aes')
-      aes = {'key' => '12345', 'iv' => '54321'}
-      rsa = mock('rsa')
-      rsa.expects(:private_decrypt).with(File.read(aes_path)).returns(Marshal.dump(aes))
-      assert_equal(aes, Utils.open_aes_data(aes_path, rsa))
-    end
-  end
-end