pwl 0.0.1 → 0.0.2

data/test/acceptance/test_passwd.rb

@@ -7,9 +7,9 @@ class TestPasswd < Test::Pwl::AppTestCase
   end
 
   def test_standard
-    assert_successful('', 'put foo bar')
+    assert_successful('', 'add foo bar')
 
-    new_pwd = store_password.reverse
+    new_pwd = locker_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}\"")

data/test/fixtures/test_all.json

@@ -0,0 +1,19 @@
+{
+  "created": "2012-03-28T21:54:21+02:00",
+  "last_accessed": "2012-03-28T22:01:49+02:00",
+  "last_modified": "2012-03-29T22:46:29+02:00",
+  "entries": [
+    {
+      "key": "foo",
+      "value": "one"
+    },
+    {
+      "key": "bar",
+      "value": "two"
+    },
+    {
+      "key": "Chuck Norris",
+      "value": "Roundhouse Kick"
+    }
+  ]
+}

data/test/fixtures/test_all.yaml

@@ -0,0 +1,11 @@
+---
+:created: '2012-03-28T21:54:21+02:00'
+:last_accessed: '2012-03-28T22:01:49+02:00'
+:last_modified: '2012-03-29T22:46:29+02:00'
+:entries:
+- :key: foo
+  :value: one
+- :key: bar
+  :value: two
+- :key: Chuck Norris
+  :value: Roundhouse Kick

data/test/fixtures/test_empty.json

@@ -0,0 +1,7 @@
+{
+  "created": "2012-03-28T21:54:21+02:00",
+  "last_accessed": "2012-03-28T22:01:49+02:00",
+  "last_modified": "2012-03-29T22:46:29+02:00",
+  "entries": [
+  ]
+}

data/test/fixtures/test_empty.yaml

@@ -0,0 +1,5 @@
+---
+:created: '2012-03-28T21:54:21+02:00'
+:last_accessed: '2012-03-28T22:01:49+02:00'
+:last_modified: '2012-03-29T22:46:29+02:00'
+:entries: []

data/test/helper.rb

@@ -24,18 +24,18 @@ end
 module Test
   module Pwl
     class TestCase < Test::Unit::TestCase
-      attr_reader :store, :store_file
+      attr_reader :locker, :locker_file
 
       def setup
-        @store_file = temp_file_name
-        @store = ::Pwl::Store.new(@store_file, store_password)
+        @locker_file = temp_file_name
+        @locker = ::Pwl::Locker.new(@locker_file, locker_password)
       end
 
       def teardown
-        File.unlink(@store_file)
+        File.unlink(@locker_file)
       end
 
-      def store_password
+      def locker_password
         's3cret passw0rd'
       end
 
@@ -53,14 +53,14 @@ module Test
 
       protected
 
-      def assert_successful(expected_out, cmd, password = store_password)
+      def assert_successful(expected_out, cmd, password = locker_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)
+      def assert_error(expected_err, cmd, password = locker_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}")
@@ -68,7 +68,7 @@ module Test
       end
 
       def execute(cmd, password)
-        Open3.capture3("echo \"#{password}\" | #{APP} #{cmd} --file \"#{store_file}\"")
+        Open3.capture3("echo \"#{password}\" | #{APP} #{cmd} --file \"#{locker_file}\"")
       end
   
       def fixture(name)

data/test/unit/test_store_construction.rb

@@ -1,16 +1,16 @@
 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)
+class TestLockerConstruction < Test::Pwl::TestCase
+  def test_existing_locker
+    assert_raise Pwl::Locker::FileAlreadyExistsError do
+      Pwl::Locker.new(locker_file, locker_password)
     end
   end
 
-  def test_nonexisting_store
-    assert_raise Pwl::Store::FileNotFoundError do
-      Pwl::Store.open(temp_file_name, store_password)
+  def test_nonexisting_locker
+    assert_raise Pwl::Locker::FileNotFoundError do
+      Pwl::Locker.open(temp_file_name, locker_password)
     end
   end
 
@@ -20,11 +20,11 @@ class TestStoreConstruction < Test::Pwl::TestCase
   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,
+  def test_existing_uninitialized_locker
+    {USER    => Pwl::Locker::NotInitializedError,
+     SYSTEM  => Pwl::Locker::NotInitializedError,
+     CREATED => Pwl::Locker::NotInitializedError,
+     SALT    => Pwl::Locker::WrongMasterPasswordError,
     }.each{|fake_level, error| assert assert_uninitialized(fake_level, error)}
   end
 
@@ -34,10 +34,10 @@ class TestStoreConstruction < Test::Pwl::TestCase
     existing_file = Tempfile.new(self.class.name)
 
     begin
-      fake_store(existing_file, fake_level)
+      fake_locker(existing_file, fake_level)
 
       assert_raise(error) do
-        Pwl::Store.open(existing_file, store_password)
+        Pwl::Locker.open(existing_file, locker_password)
       end
     ensure
        existing_file.close
@@ -45,18 +45,18 @@ class TestStoreConstruction < Test::Pwl::TestCase
     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
+  # Pretend that we have a locker with correct layout
+  def fake_locker(existing_file, fake_level)
+    locker = PStore.new(existing_file)
+    locker.transaction{
+      locker.commit if fake_level < USER
+      locker[:user] = {}
+      locker.commit if fake_level < SYSTEM
+      locker[:system] = {}
+      locker.commit if fake_level < CREATED
+      locker[:system][:created] = DateTime.now
+      locker.commit if fake_level < SALT
+      locker[:system][:salt] = Random.rand.to_s
     }
   end
 end

data/test/unit/test_store_crud.rb

@@ -1,90 +1,90 @@
 require 'helper'
 
-class TestStoreCRUD < Test::Pwl::TestCase
-  def test_put_get
-    store.put('foo', 'bar')
-    assert_equal('bar', store.get('foo'))
+class TestLockerCRUD < Test::Pwl::TestCase
+  def test_add_get
+    locker.add('foo', 'bar')
+    assert_equal('bar', locker.get('foo'))
   end
 
   def test_get_blank
-    assert_raise Pwl::Store::BlankKeyError do
-      store.get('')
+    assert_raise Pwl::Locker::BlankKeyError do
+      locker.get('')
     end
 
-    assert_raise Pwl::Store::BlankKeyError do
-      store.get(nil)
+    assert_raise Pwl::Locker::BlankKeyError do
+      locker.get(nil)
     end
   end
 
-  def test_put_get_blank
-    assert_raise Pwl::Store::BlankValueError do
-      store.put('empty', '')
+  def test_add_get_blank
+    assert_raise Pwl::Locker::BlankValueError do
+      locker.add('empty', '')
     end
 
-    assert_raise Pwl::Store::BlankValueError do
-      store.put('nil', nil)
+    assert_raise Pwl::Locker::BlankValueError do
+      locker.add('nil', nil)
     end
   end
 
   def test_unknown_key
-    assert_raise Pwl::Store::KeyNotFoundError do
-      store.get('foo')
+    assert_raise Pwl::Locker::KeyNotFoundError do
+      locker.get('foo')
     end
   end
 
   def test_list_empty
-    assert_empty(store.list)
+    assert_empty(locker.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))
+    test_vector.each{|k,v| locker.add(k, v)}
+    assert_equal(test_vector.keys, locker.list)
+    locker.list.each{|key|
+      assert_equal(test_vector[key], locker.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|
+    test_vector.each{|k,v| locker.add(k, v)}
+    assert_equal(test_vector, locker.all)
+    locker.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)}
+    test_vector.each{|k,v| locker.add(k, v)}
 
     filter = 'foo bar'
     expected = test_vector.keys.select{|k,v| k =~ /#{filter}/}
-    assert_equal(expected, store.list(filter))
+    assert_equal(expected, locker.list(filter))
   end
   
   def test_delete
-    store.put('foo', 'bar')
-    assert_equal('bar', store.delete('foo'))
+    locker.add('foo', 'bar')
+    assert_equal('bar', locker.delete('foo'))
     
-    assert_raise Pwl::Store::KeyNotFoundError do
-      store.get('foo')
+    assert_raise Pwl::Locker::KeyNotFoundError do
+      locker.get('foo')
     end
   end
   
   def test_delete_blank
-    assert_raise Pwl::Store::BlankKeyError do
-      store.delete('')
+    assert_raise Pwl::Locker::BlankKeyError do
+      locker.delete('')
     end
 
-    assert_raise Pwl::Store::BlankKeyError do
-      store.delete(nil)
+    assert_raise Pwl::Locker::BlankKeyError do
+      locker.delete(nil)
     end
   end
 
   def test_delete_unknown_key
-    assert_raise Pwl::Store::KeyNotFoundError do
-      store.delete('foo')
+    assert_raise Pwl::Locker::KeyNotFoundError do
+      locker.delete('foo')
     end
   end
 end

data/test/unit/test_store_metadata.rb

@@ -1,35 +1,35 @@
 require 'helper'
 
-class TestStoreConstruction < Test::Pwl::TestCase
+class TestLockerMetaData < Test::Pwl::TestCase
   # when comparing timestamps, allow not more than this difference in seconds
-  TIMESTAMP_PRECISION = 1
+  TIMESTAMP_PRECISION = 0.001
 
   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)
+    assert_equal(nil, locker.last_accessed)
+    assert_in_delta(DateTime.now, locker.created, 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)
+    assert_equal(nil, locker.last_accessed)
+    locker.add('foobar', 'barfoot')
+    assert_equal(nil, locker.last_accessed)
+    locker.get('foobar')
+    assert_in_delta(DateTime.now, locker.last_accessed, TIMESTAMP_PRECISION)
   end
 
   def test_last_accessed_nonexisting
-    assert_equal(nil, store.last_accessed)
-    assert_raise Pwl::Store::KeyNotFoundError do
-      store.get('foobar')
+    assert_equal(nil, locker.last_accessed)
+    assert_raise Pwl::Locker::KeyNotFoundError do
+      locker.get('foobar')
     end
 
     # Make sure a failed read is not counted as last_accessed
-    assert_equal(nil, store.last_accessed)
+    assert_equal(nil, locker.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)
+    assert_equal(nil, locker.last_modified)
+    locker.add('foobar', 'barfoot')
+    assert_in_delta(DateTime.now, locker.last_modified, TIMESTAMP_PRECISION)
   end
 end

data/test/unit/test_store_password_policy.rb

@@ -1,12 +1,12 @@
 require 'helper'
 
-class TestStorePasswordPolicy < Test::Pwl::TestCase
+class TestLockerPasswordPolicy < Test::Pwl::TestCase
   def setup
-    @store_file = temp_file_name
+    @locker_file = temp_file_name
   end
 
   def teardown
-    File.unlink(@store_file) if File.exist?(@store_file)
+    File.unlink(@locker_file) if File.exist?(@locker_file)
   end
 
   def test_validations_ok_0
@@ -48,9 +48,9 @@ class TestStorePasswordPolicy < Test::Pwl::TestCase
   private
 
   def assert_valid(password)
-    store = ::Pwl::Store.new(@store_file, password)
-    store.put('foo', 'bar')
-    assert_equal('bar', store.get('foo'))
+    locker = ::Pwl::Locker.new(@locker_file, password)
+    locker.add('foo', 'bar')
+    assert_equal('bar', locker.get('foo'))
   end
 
   def assert_invalid(password)

data/test/unit/test_store_security.rb

@@ -1,34 +1,34 @@
 require 'helper'
 
-class TestStoreSecurity < Test::Pwl::TestCase
+class TestLockerSecurity < Test::Pwl::TestCase
 
-  # Read back raw PStore and ensure what we get is not clear text, even though we know the structure of the store
+  # Read back raw PStore and ensure what we get is not clear text, even though we know the structure of the locker
   def test_encryption
-    assert(!store.nil?, "Store expected, but it is nil")
-    store.put('foo', 'bar')
-    raw = PStore.new(store_file)
+    assert(!locker.nil?, "Locker expected, but it is nil")
+    locker.add('foo', 'bar')
+    raw = PStore.new(locker_file)
     assert_not_equal('bar', raw.transaction{raw[:user]['foo']})
     assert_nil(raw.transaction{raw[:user]['foo']}) # must not find cleartext entry
   end
 
   def test_wrong_password
-    assert_raise Pwl::Store::WrongMasterPasswordError do
-      Pwl::Store.open(store_file, store_password.reverse)
+    assert_raise Pwl::Locker::WrongMasterPasswordError do
+      Pwl::Locker.open(locker_file, locker_password.reverse)
     end
   end
 
   def test_change_password
-    assert(!store.nil?, "Store expected, but it is nil")
-    store.put('Homer', 'Simpson')
-    store.change_password!(store_password.reverse)
+    assert(!locker.nil?, "Locker expected, but it is nil")
+    locker.add('Homer', 'Simpson')
+    locker.change_password!(locker_password.reverse)
 
     # the old password must not work anymore
-    assert_raise Pwl::Store::WrongMasterPasswordError do
-      Pwl::Store.open(store_file, store_password)
+    assert_raise Pwl::Locker::WrongMasterPasswordError do
+      Pwl::Locker.open(locker_file, locker_password)
     end
 
     # Read back with the changed password
-    reopened = Pwl::Store.open(store_file, store_password.reverse)
+    reopened = Pwl::Locker.open(locker_file, locker_password.reverse)
     assert_equal('Simpson', reopened.get('Homer'))
   end
 end