pwl 0.0.1

data/test/acceptance/test_export.rb

@@ -0,0 +1,42 @@
+require 'helper'
+require 'nokogiri/diff'
+
+# Tests `pwl export`
+class TestExport < Test::Pwl::AppTestCase
+  def test_empty
+    fixture = fixture("test_empty.html").gsub('CREATED_STAMP', DateTime.now.strftime('%F %R')).gsub('MODIFIED_STAMP', 'never').gsub('DATABASE_FILE', store_file)
+    assert_successful_html(fixture, 'export')
+  end
+
+  def test_all
+    test_vector = Hash['foo', 'one', 'bar', 'two', 'Chuck Norris', 'Roundhouse Kick']
+    test_vector.each{|k,v|
+      assert_successful('', "put '#{k}' '#{v}'")
+    }
+    
+    now = DateTime.now.strftime('%F %R')
+    fixture = fixture("test_all.html").gsub('CREATED_STAMP', now).gsub('MODIFIED_STAMP', now).gsub('DATABASE_FILE', store_file)
+    
+    assert_successful_html(fixture, 'export')
+  end
+
+  def assert_successful_html(expected_out, cmd, password = store_password)
+    out, err, rc = execute(cmd, password)
+    assert_equal(0, rc.exitstatus, "Expected exit status 0, but it was #{rc.exitstatus}. STDERR was: #{err}")
+    assert(err.empty?, "Expected empty STDERR, but it yielded #{err}")
+
+    actual   = Nokogiri::HTML(out)
+    expected = Nokogiri::HTML(expected_out)
+
+    differences = actual.diff(expected, :added => true, :removed => true)
+
+    assert_equal(0, differences.count, "Unexpected differences in output. Diff:\n" << differences.collect{|change, node|
+      case change
+      when '+'
+        "Actual: #{node.to_html}"
+      when '-'
+        "Expected: #{node.to_html}"
+      end
+    }.join("\n"))
+  end
+end

data/test/acceptance/test_get.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+# Tests `pwl get`
+class TestGet < Test::Pwl::AppTestCase
+  def test_get_unknown_key
+    assert_error('No entry was found for foo', 'get foo')
+  end
+
+  def test_get_blank_key
+    assert_error('may not be blank', 'get')
+  end
+
+  def test_get_known_key
+    assert_successful('', 'put foo bar') # TODO Use a fixture instead of put
+    assert_successful('^bar$', 'get foo')
+  end
+end

data/test/acceptance/test_init.rb

@@ -0,0 +1,81 @@
+require 'helper'
+require 'pty'
+require 'expect'
+
+class TestInit < Test::Pwl::AppTestCase
+  #
+  # Tests that initing with two matching passwords succeeds
+  #
+  # A session is expected to look like this:
+  #
+  # $ bin/pwl init --force --verbose
+  # Enter new master password:
+  # **************
+  # Enter master password again:
+  # **************
+  # Successfully initialized new store at ...
+  # $
+  #
+  def test_matching_passwords
+    cmd = "bin/pwl init --force --verbose --file \"#{@store_file}\""
+
+    PTY.spawn(cmd){|pwl_out, pwl_in, pid|
+      assert_response('Enter new master password:', pwl_out)
+      pwl_in.puts("secr3tPassw0rd")
+
+      assert_response('Enter master password again:', pwl_out)
+      pwl_in.puts("secr3tPassw0rd")
+
+      assert_response('Successfully initialized new store', pwl_out)
+    }
+  end
+
+  #
+  # Tests that initing with two passwords that don't match fails
+  #
+  # A session is expected to look like this (using s3cretPassw0rd at the first and secr3tPassw0rd at the second password prompt):
+  #
+  # $ bin/pwl init --force --verbose
+  # Enter new master password:
+  # **************
+  # Enter master password again:
+  # **************
+  # Passwords do not match.
+  # $
+  #
+  def test_unmatching_passwords
+    cmd = "bin/pwl init --force --verbose --file \"#{store_file}\""
+
+    PTY.spawn(cmd){|pwl_out, pwl_in, pid|
+      assert_response('Enter new master password:', pwl_out)
+      pwl_in.puts("s3cretPassw0rd")
+
+      assert_response('Enter master password again:', pwl_out)
+      pwl_in.puts("secr3tPassw0rd")
+
+      assert_response('Passwords do not match\.', pwl_out)
+    }
+  end
+
+  #
+  # Tests that initing an existing store without --force does not touch the existing store
+  #
+  def test_exists
+    assert_error('already exists', "init")
+  end
+
+  #
+  # Tests that cancelling a forced re-init does not change the store file
+  #
+  def test_cancel
+    # TODO
+  end
+
+  private
+
+  def assert_response(expected, actual_io)
+    if !actual_io.expect(/#{expected}/, 1)
+      raise StandardError.new("Expected response '#{expected}' was not matched")
+    end
+  end
+end

data/test/acceptance/test_list.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+# Tests `pwl list`
+class TestList < Test::Pwl::AppTestCase
+  def test_list_empty
+    assert_empty(store.list)
+    assert_error('^$', 'list')
+    assert_error('^List is empty\.$', 'list --verbose')
+  end
+
+  def test_list_all
+    test_vector = Hash['foo', 'one', 'bar', 'two', 'Chuck Norris', 'Roundhouse Kick']
+    test_vector.each{|k,v|
+      assert_successful('', "put '#{k}' '#{v}'")
+    }
+
+    assert_successful(test_vector.keys.join('-'), 'list -s "-"')
+  end
+
+  def test_list_filter
+    test_vector = Hash['foo', 'one', 'foot', 'two', 'Homer Simpson', 'Apu Nahasapeemapetilon']
+    test_vector.each{|k,v|
+      assert_successful('', "put '#{k}' '#{v}'")
+    }
+
+    filter = 'foo'
+    expected = test_vector.keys.select{|k,v| k =~ /#{filter}/}.join(',')
+    assert_successful("^#{expected}$", "list #{filter} -s ,")
+  end
+end

data/test/acceptance/test_passwd.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+# Tests `pwl passwd`
+class TestPasswd < Test::Pwl::AppTestCase
+  def test_blank_password
+    assert_error('May not be blank', 'passwd')
+  end
+
+  def test_standard
+    assert_successful('', 'put foo bar')
+
+    new_pwd = store_password.reverse
+
+    # If we are in a pipe (and we are in these tests), the new password is expected as first arg
+    assert_successful('^$', "passwd \"#{new_pwd}\"")
+
+    # the old password must not work anymore
+    assert_error('The master password is wrong', 'list')
+
+    # re-open with the changed password
+    assert_successful('^bar$', 'get foo', new_pwd)
+  end
+end

data/test/acceptance/test_put.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+# Tests `pwl put`
+class TestPut < Test::Pwl::AppTestCase
+  def test_put_blank_key
+    assert_error('may not be blank', 'put')
+  end
+
+  def test_put_simple
+    assert_successful('', 'put foo bar')
+    assert_successful('^bar$', 'get foo')
+  end
+
+  def test_put_update
+    assert_successful('', 'put foo bar')
+    assert_successful('', 'put foo baz') # just do it twice
+    assert_successful('^baz$', 'get foo')
+  end
+end

data/test/fixtures/test_all.html

@@ -0,0 +1,71 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+  <title>Password Manager Export</title>
+  <style type="text/css">
+    table { page-break-inside:auto}
+    tr    { page-break-inside:avoid; page-break-after:auto}
+    thead { display:table-header-group}
+    tfoot { display:table-footer-group; font-size: 0.85em;}
+
+    /* adapted from http://coding.smashingmagazine.com/2008/08/13/top-10-css-table-designs/ */
+    body{
+      font-family: "Lucida Sans Unicode", "Lucida Grande", Sans-Serif;
+      font-size: 12px;
+      margin: 45px;
+      width: 480px;
+      border-collapse: collapse;
+      text-align: left;
+    }
+    th{
+      font-size: 14px;
+      font-weight: bold;
+      padding: 10px 8px;
+      border-bottom: 2px solid;
+    }
+    td{
+      border-bottom: 1px solid;
+      padding: 6px 8px;
+    }
+  </style>
+</head>
+<body>
+  <h1>Password Manager Export</h1>
+  <table>
+    <thead>
+      <tr>
+        <th>Name</th>
+        <th>Value</th>
+      </tr>
+    </thead>
+    <tfoot>
+      <tr>
+        <td colspan="2">
+          This <a href="http://rdoc.info/github/nerab/pwl/master/frames">pwl</a> export was created on CREATED_STAMP.
+        <br/>
+          The database at DATABASE_FILE was last modified MODIFIED_STAMP.
+        </td>
+      </tr>
+    </tfoot>
+    <tbody>
+
+      <tr>
+        <td>foo</td>
+        <td>one</td>
+      </tr>
+
+      <tr>
+        <td>bar</td>
+        <td>two</td>
+      </tr>
+
+      <tr>
+        <td>Chuck Norris</td>
+        <td>Roundhouse Kick</td>
+      </tr>
+
+    </tbody>
+  </table>
+</body>
+</html>

data/test/fixtures/test_empty.html

@@ -0,0 +1,56 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+  <title>Password Manager Export</title>
+  <style type="text/css">
+    table { page-break-inside:auto}
+    tr    { page-break-inside:avoid; page-break-after:auto}
+    thead { display:table-header-group}
+    tfoot { display:table-footer-group; font-size: 0.85em;}
+
+    /* adapted from http://coding.smashingmagazine.com/2008/08/13/top-10-css-table-designs/ */
+    body{
+      font-family: "Lucida Sans Unicode", "Lucida Grande", Sans-Serif;
+      font-size: 12px;
+      margin: 45px;
+      width: 480px;
+      border-collapse: collapse;
+      text-align: left;
+    }
+    th{
+      font-size: 14px;
+      font-weight: bold;
+      padding: 10px 8px;
+      border-bottom: 2px solid;
+    }
+    td{
+      border-bottom: 1px solid;
+      padding: 6px 8px;
+    }
+  </style>
+</head>
+<body>
+  <h1>Password Manager Export</h1>
+  <table>
+    <thead>
+      <tr>
+        <th>Name</th>
+        <th>Value</th>
+      </tr>
+    </thead>
+    <tfoot>
+      <tr>
+        <td colspan="2">
+          This <a href="http://rdoc.info/github/nerab/pwl/master/frames">pwl</a> export was created on CREATED_STAMP.
+        <br/>
+          The database at DATABASE_FILE was never modified.
+        </td>
+      </tr>
+    </tfoot>
+    <tbody>
+
+    </tbody>
+  </table>
+</body>
+</html>

data/test/helper.rb

@@ -0,0 +1,79 @@
+require 'simplecov'
+SimpleCov.start
+
+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 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'pwl'
+require 'tmpdir'
+
+class Test::Unit::TestCase
+  FIXTURES_DIR = File.join(File.dirname(__FILE__), 'fixtures')
+end
+
+module Test
+  module Pwl
+    class TestCase < Test::Unit::TestCase
+      attr_reader :store, :store_file
+
+      def setup
+        @store_file = temp_file_name
+        @store = ::Pwl::Store.new(@store_file, store_password)
+      end
+
+      def teardown
+        File.unlink(@store_file)
+      end
+
+      def store_password
+        's3cret passw0rd'
+      end
+
+      # Make up a name of a file that does not exist in ENV['TMPDIR'] yet
+      def temp_file_name
+        begin
+          result = File.join(Dir.tmpdir, "#{self.class.name}-#{Random.rand}.pstore")
+        end while File.exists?(result)
+        result
+      end
+    end
+
+    class AppTestCase < TestCase
+      APP = 'bin/pwl'
+
+      protected
+
+      def assert_successful(expected_out, cmd, password = store_password)
+        out, err, rc = execute(cmd, password)
+        assert_equal(0, rc.exitstatus, "Expected exit status 0, but it was #{rc.exitstatus}. STDERR was: #{err}")
+        assert(err.empty?, "Expected empty STDERR, but it yielded #{err}")
+        assert(out =~ /#{expected_out}/, "'#{out}' did not match expected response '#{expected_out}'")
+      end
+
+      def assert_error(expected_err, cmd, password = store_password)
+        out, err, rc = execute(cmd, password)
+        assert_not_equal(0, rc.exitstatus, "Expected non-zero exit status, but it was #{rc.exitstatus}. STDOUT was: #{out}")
+        assert(out.empty?, "Expected empty STDOUT, but it yielded #{out}")
+        assert(err =~ /#{expected_err}/, "'#{err}' did not match expected response '#{expected_err}'")
+      end
+
+      def execute(cmd, password)
+        Open3.capture3("echo \"#{password}\" | #{APP} #{cmd} --file \"#{store_file}\"")
+      end
+  
+      def fixture(name)
+        File.read(File.join(FIXTURES_DIR, name))
+      end
+    end
+  end
+end

data/test/unit/test_error.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TestError < Test::Unit::TestCase
+  def setup
+    @message = Pwl::ErrorMessage.new("<%= first %> <%= last %>", 1, :first => 'FIRSTNAME', :last => 'LASTNAME')
+  end
+
+  def test_code_0
+    assert_raise Pwl::ReservedMessageCodeError do
+      Pwl::ErrorMessage.new('', 0)
+    end
+  end
+
+  def test_to_s
+    assert_equal('Mislav Marohnic', @message.to_s(:first => "Mislav", "last" => "Marohnic"))
+  end
+
+  def test_to_s_empty
+    assert_equal('FIRSTNAME LASTNAME', @message.to_s)
+  end
+
+  def test_code
+    assert_equal(1, @message.exit_code)
+  end
+
+  def test_to_s_extra
+    assert_equal('Apu Nahasapeemapetilon', @message.to_s({:first => 'Apu', 'last' => 'Nahasapeemapetilon', :worklocation => 'Kwik-E-Mart'}))
+  end
+end

data/test/unit/test_message.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+class TestMessageZero < Test::Unit::TestCase
+  def setup
+    @msg =  Pwl::Message.new("Name: <%= first %> <%= last %>", 0, :first => 'FIRSTNAME', :last => 'LASTNAME')
+  end
+
+  def test_to_s
+    assert_equal('Name: Mislav Marohnic', @msg.to_s(:first => "Mislav", "last" => "Marohnic"))
+  end
+
+  def test_to_s_default
+    assert_equal('Name: FIRSTNAME LASTNAME', @msg.to_s)
+  end
+
+  def test_code
+    assert_equal(0, @msg.exit_code)
+  end
+
+  def test_to_s_extra
+    assert_equal('Name: Apu Nahasapeemapetilon', @msg.to_s({:first => 'Apu', 'last' => 'Nahasapeemapetilon', :worklocation => 'Kwik-E-Mart'}))
+  end
+end
+
+class TestMessageNonZero < Test::Unit::TestCase
+  def setup
+    @code = Random.rand(255)
+    @msg = Pwl::Message.new("Name: <%= first %> <%= last %>", @code)
+  end
+
+  def test_code
+    assert_equal(@code, @msg.exit_code)
+  end
+end

data/test/unit/test_store_construction.rb

@@ -0,0 +1,62 @@
+require 'helper'
+require 'tempfile'
+
+class TestStoreConstruction < Test::Pwl::TestCase
+  def test_existing_store
+    assert_raise Pwl::Store::FileAlreadyExistsError do
+      Pwl::Store.new(store_file, store_password)
+    end
+  end
+
+  def test_nonexisting_store
+    assert_raise Pwl::Store::FileNotFoundError do
+      Pwl::Store.open(temp_file_name, store_password)
+    end
+  end
+
+  # fake level  (increasingly close to structure)
+  USER    = 1 # user root exists
+  SYSTEM  = 2 # user and system root exists
+  CREATED = 3 # user and system root exists, system root contains created stamp
+  SALT    = 4 # like above, plus salt is set to random value
+
+  def test_existing_uninitialized_store
+    {USER    => Pwl::Store::NotInitializedError,
+     SYSTEM  => Pwl::Store::NotInitializedError,
+     CREATED => Pwl::Store::NotInitializedError,
+     SALT    => Pwl::Store::WrongMasterPasswordError,
+    }.each{|fake_level, error| assert assert_uninitialized(fake_level, error)}
+  end
+
+  private
+
+  def assert_uninitialized(fake_level, error)
+    existing_file = Tempfile.new(self.class.name)
+
+    begin
+      fake_store(existing_file, fake_level)
+
+      assert_raise(error) do
+        Pwl::Store.open(existing_file, store_password)
+      end
+    ensure
+       existing_file.close
+       existing_file.unlink
+    end
+  end
+
+  # Pretend that we have a store with correct layout
+  def fake_store(existing_file, fake_level)
+    store = PStore.new(existing_file)
+    store.transaction{
+      store.commit if fake_level < USER
+      store[:user] = {}
+      store.commit if fake_level < SYSTEM
+      store[:system] = {}
+      store.commit if fake_level < CREATED
+      store[:system][:created] = DateTime.now
+      store.commit if fake_level < SALT
+      store[:system][:salt] = Random.rand.to_s
+    }
+  end
+end

data/test/unit/test_store_crud.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+class TestStoreCRUD < Test::Pwl::TestCase
+  def test_put_get
+    store.put('foo', 'bar')
+    assert_equal('bar', store.get('foo'))
+  end
+
+  def test_get_blank
+    assert_raise Pwl::Store::BlankKeyError do
+      store.get('')
+    end
+
+    assert_raise Pwl::Store::BlankKeyError do
+      store.get(nil)
+    end
+  end
+
+  def test_put_get_blank
+    assert_raise Pwl::Store::BlankValueError do
+      store.put('empty', '')
+    end
+
+    assert_raise Pwl::Store::BlankValueError do
+      store.put('nil', nil)
+    end
+  end
+
+  def test_unknown_key
+    assert_raise Pwl::Store::KeyNotFoundError do
+      store.get('foo')
+    end
+  end
+
+  def test_list_empty
+    assert_empty(store.list)
+  end
+
+  def test_list
+    test_vector = Hash['foo', 'one', 'bar', 'two', 'Chuck Norris', 'Roundhouse Kick']
+    test_vector.each{|k,v| store.put(k, v)}
+    assert_equal(test_vector.keys, store.list)
+    store.list.each{|key|
+      assert_equal(test_vector[key], store.get(key))
+    }
+  end
+
+  def test_all
+    test_vector = Hash['foo', 'one', 'bar', 'two', 'Chuck Norris', 'Roundhouse Kick']
+    test_vector.each{|k,v| store.put(k, v)}
+    assert_equal(test_vector, store.all)
+    store.all.each{|k,v|
+      assert_equal(test_vector[k], v)
+    }
+  end
+
+  def test_list_filter
+    test_vector = Hash['foo', 'one', 'bar', 'two', 'Chuck Norris', 'Roundhouse Kick']
+    test_vector.each{|k,v| store.put(k, v)}
+
+    filter = 'foo bar'
+    expected = test_vector.keys.select{|k,v| k =~ /#{filter}/}
+    assert_equal(expected, store.list(filter))
+  end
+  
+  def test_delete
+    store.put('foo', 'bar')
+    assert_equal('bar', store.delete('foo'))
+    
+    assert_raise Pwl::Store::KeyNotFoundError do
+      store.get('foo')
+    end
+  end
+  
+  def test_delete_blank
+    assert_raise Pwl::Store::BlankKeyError do
+      store.delete('')
+    end
+
+    assert_raise Pwl::Store::BlankKeyError do
+      store.delete(nil)
+    end
+  end
+
+  def test_delete_unknown_key
+    assert_raise Pwl::Store::KeyNotFoundError do
+      store.delete('foo')
+    end
+  end
+end

data/test/unit/test_store_metadata.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestStoreConstruction < Test::Pwl::TestCase
+  # when comparing timestamps, allow not more than this difference in seconds
+  TIMESTAMP_PRECISION = 1
+
+  def test_created
+    assert_equal(nil, store.last_accessed)
+    assert_in_delta(DateTime.now.to_time.to_i, store.created.to_time.to_i, TIMESTAMP_PRECISION)
+  end
+
+  def test_last_accessed
+    assert_equal(nil, store.last_accessed)
+    store.put('foobar', 'barfoot')
+    assert_equal(nil, store.last_accessed)
+    store.get('foobar')
+    assert_in_delta(DateTime.now.to_time.to_i, store.last_accessed.to_time.to_i, TIMESTAMP_PRECISION)
+  end
+
+  def test_last_accessed_nonexisting
+    assert_equal(nil, store.last_accessed)
+    assert_raise Pwl::Store::KeyNotFoundError do
+      store.get('foobar')
+    end
+
+    # Make sure a failed read is not counted as last_accessed
+    assert_equal(nil, store.last_accessed)
+  end
+
+  def test_last_modified
+    assert_equal(nil, store.last_modified)
+    store.put('foobar', 'barfoot')
+    assert_in_delta(DateTime.now.to_time.to_i, store.last_modified.to_time.to_i, TIMESTAMP_PRECISION)
+  end
+end