keybox 1.1.0 → 1.1.1

data/spec/kpg_app_spec.rb

@@ -1,132 +1,125 @@
 require 'keybox'
 require 'keybox/application/password_generator'
 
-context "Keybox Password Generator Application" do
-    setup do
-    end
+describe "Keybox Password Generator Application" do
 
-    specify "nil argv should do nothing" do
+    it "nil argv should do nothing" do
         kpg = Keybox::Application::PasswordGenerator.new(nil)
-        kpg.error_message.should_be nil
+        kpg.error_message.should == nil
     end
 
-    specify "invalid options set the error message, exit 1 and have output on stderr" do
+    it "invalid options set the error message, exit 1 and have output on stderr" do
         kpg = Keybox::Application::PasswordGenerator.new(["--invalid-option"])
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kpg.run
         rescue SystemExit => se
-            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.error_message.should =~ /Try.*--help/m
+            kpg.stderr.string.should =~ /Try.*--help/m
             se.status.should == 1
         end
     end
 
-    specify "can set the algorithm" do
+    it "can set the algorithm" do
         kpg = Keybox::Application::PasswordGenerator.new(["--alg", "pron"])
         kpg.set_io(StringIO.new,StringIO.new)
         kpg.run
         kpg.options.algorithm.should == :pronounceable
     end
     
-    specify "can specify the number of passwords created " do
+    it "can it the number of passwords created " do
         kpg = Keybox::Application::PasswordGenerator.new(["--num", "4"])
         kpg.set_io(StringIO.new,StringIO.new)
         kpg.run
-        kpg.options.number_to_generate.should_eql 4
-        kpg.stdout.string.split(/\s+/).size.should == 4
+        kpg.options.number_to_generate.should == 4
+        kpg.stdout.string.split(/\s+/).should have(4).items
     end
 
-    specify "help has output on stdout and exits 0" do
+    it "help has output on stdout and exits 0" do
         kpg = Keybox::Application::PasswordGenerator.new(["--h"]) 
         kpg.set_io(StringIO.new,StringIO.new)
         begin
             kpg.run
         rescue SystemExit => se
-            se.status.should_eql 0
-            kpg.stdout.string.length.should_be > 0
+            se.status.should == 0
+            kpg.stdout.string.length.should > 0
         end
-        kpg.stdout.string.should_satisfy { |msg| msg =~ /--help/m }
+        kpg.stdout.string.should =~ /--help/m
     end
 
-    specify "version has output on stdout and exits 0" do
+    it "version has output on stdout and exits 0" do
         kpg = Keybox::Application::PasswordGenerator.new(["--version"]) 
         kpg.set_io(StringIO.new,StringIO.new)
         begin
             kpg.run
         rescue SystemExit => se
-            se.status.should_eql 0
+            se.status.should == 0
         end
-        kpg.stdout.string.should_satisfy { |msg| msg =~ /version 1/m }
+        kpg.stdout.string.should  =~ /version 1/m
     end
 
-    specify "minimum length can be set and all generated passwords will have length >= minimum length" do
+    it "minimum length can be set and all generated passwords will have length >= minimum length" do
         kpg = Keybox::Application::PasswordGenerator.new(["--min", "4"]) 
         kpg.set_io(StringIO.new,StringIO.new)
         kpg.run
 
-        kpg.options.min_length.should_eql 4
+        kpg.options.min_length.should == 4
         kpg.stdout.string.split("\n").each do |pass|
-            pass.length.should_satisfy { |s| s >= kpg.options.min_length }
+            pass.length.should >= kpg.options.min_length 
         end
     end
 
-    specify "maximum length can be set and all generated passwords will have length <= maximum length" do
+    it "maximum length can be set and all generated passwords will have length <= maximum length" do
         kpg = Keybox::Application::PasswordGenerator.new(["--max", "4", "--min", "3"]) 
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         kpg.run
 
-        kpg.options.max_length.should_eql 4
+        kpg.options.max_length.should == 4
         kpg.stdout.string.split("\n").each do |pass|
-            pass.length.should_satisfy { |s| s <= 4 }
+            pass.length.should <= 4 
         end
     end
 
-    specify "setting an invalid required symbol set exits 1 and outputs data on stderr" do
+    it "setting an invalid required symbol set exits 1 and outputs data on stderr" do
         kpg = Keybox::Application::PasswordGenerator.new(["--req","bunk"])
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kpg.run
         rescue SystemExit => se
-            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.error_message.should =~ /Try.*--help/m
+            kpg.stderr.string.should =~ /Try.*--help/m
             se.status.should == 1
         end
  
     end
 
-    specify "setting an invalid use symbol set exits 1 and outputs data on stderr" do
+    it "setting an invalid use symbol set exits 1 and outputs data on stderr" do
         kpg = Keybox::Application::PasswordGenerator.new(["--use","bunk"])
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kpg.run
         rescue SystemExit => se
-            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.error_message.should =~ /Try.*--help/m
+            kpg.stderr.string.should =~ /Try.*--help/m 
             se.status.should == 1
         end
  
     end
 
-    specify "setting an valid use symbol works" do
+    it "setting an valid use symbol works" do
         kpg = Keybox::Application::PasswordGenerator.new(["--use","l"])
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         kpg.run
-        kpg.options.use_symbols.should_include Keybox::SymbolSet::LOWER_ASCII
+        kpg.options.use_symbols.should be_include(Keybox::SymbolSet::LOWER_ASCII)
         kpg.stdout.string.split(/\s+/).size.should == 6
     end
 
-    specify "setting an valid required symbol works" do
+    it "setting an valid required symbol works" do
         kpg = Keybox::Application::PasswordGenerator.new(["--req","l"])
         kpg.set_io(StringIO.new,StringIO.new,StringIO.new)
         kpg.run
-        kpg.options.require_symbols.should_include Keybox::SymbolSet::LOWER_ASCII
+        kpg.options.require_symbols.should be_include(Keybox::SymbolSet::LOWER_ASCII)
         kpg.stdout.string.split(/\s+/).size.should == 6
     end
-
-
-
-
-
 end
 

data/spec/password_hash_spec.rb

@@ -1,10 +1,10 @@
 require 'keybox'
-context "PasswordHash" do
-    setup do 
+describe "PasswordHash" do
+    before(:each) do 
         @pwd_hash = Keybox::PasswordHash.new("i love ruby")
     end
 
-    specify "creates string for password" do
+    it "creates string for password" do
         pwd = @pwd_hash.password_for_url("http://www.nytimes.com")
         pwd.should == "2f85a2e2f"
     end

data/spec/randomizer_spec.rb

@@ -1,116 +1,115 @@
 require 'keybox/randomizer'
 
-context "a random device class" do
-    specify "should have a default source" do
-        Keybox::RandomDevice.default.should_eql "/dev/urandom" 
+describe "a random device class" do
+    it "should have a default source" do
+        Keybox::RandomDevice.default.should == "/dev/urandom" 
     end
 
-    specify "should produce strings" do
-        Keybox::RandomDevice.random_bytes.should_be_an_instance_of(String)
+    it "should produce strings" do
+        Keybox::RandomDevice.random_bytes.should be_an_instance_of(String)
     end
 
-    specify "should produce strings of a given length" do
-        Keybox::RandomDevice.random_bytes(4).size.should_eql 4 
+    it "should produce strings of a given length" do
+        Keybox::RandomDevice.random_bytes(4).size.should == 4 
     end
 
-    specify "should raise exception when given an invalid device" do
-        Proc.new {Keybox::RandomDevice.default = "/tmp/junk" }.should_raise ArgumentError
+    it "should raise exception when given an invalid device" do
+        Proc.new {Keybox::RandomDevice.default = "/tmp/junk" }.should raise_error( ArgumentError)
     end
 
-    specify "should be able to assign a new default source" do
-        (Keybox::RandomDevice.default = "/dev/random").should_eql "/dev/random"
+    it "should be able to assign a new default source" do
+        (Keybox::RandomDevice.default = "/dev/random").should == "/dev/random"
         Keybox::RandomDevice.default = "/dev/urandom"
     end
 end
 
-context "a random device instance" do
-    setup do
+describe "a random device instance" do
+    before(:each) do
         @random_device = Keybox::RandomDevice.new
     end
-    specify "should have a source" do
-        @random_device.source.should_eql "/dev/urandom"
+    it "should have a source" do
+        @random_device.source.should == "/dev/urandom"
     end
 
-    specify "should produce strings" do
-        @random_device.random_bytes.should_be_an_instance_of(String)
+    it "should produce strings" do
+        @random_device.random_bytes.should be_an_instance_of(String)
     end
 
-    specify "should produce strings of a given length" do
-        @random_device.random_bytes(20).size.should_eql 20 
+    it "should produce strings of a given length" do
+        @random_device.random_bytes(20).size.should == 20 
     end
 
-    specify "should default to the RandomDevice default when given an invalid device " do 
+    it "should default to the RandomDevice default when given an invalid device " do 
         rd = Keybox::RandomDevice.new("/tmp/bad-random-device")
-        rd.source.should_eql Keybox::RandomDevice.default
+        rd.source.should == Keybox::RandomDevice.default
     end
 
-    specify "should accept a valid readable device" do
+    it "should accept a valid readable device" do
         rd = Keybox::RandomDevice.new("/dev/random")
-        rd.source.should_eql "/dev/random"
+        rd.source.should == "/dev/random"
     end
 end
 
-context "a random source class " do
-    setup do
+describe "a random source class " do
+    before(:each) do
         @random_source_class = mock("JunkRandomSource")
         @random_source_class.should_receive("random_bytes").at_least(0).times
     end
-    specify "should have a default" do
-        Keybox::RandomSource.source.should_not_equal nil
+    it "should have a default" do
+        Keybox::RandomSource.source.should_not == nil
     end
 
-    specify "invalid default class should throw exception " do
-        lambda { Keybox::RandomSource.source = String }.should_raise ArgumentError
+    it "invalid default class should throw exception " do
+        lambda { Keybox::RandomSource.source = String }.should raise_error(ArgumentError)
     end
 
-    specify "valid class should allow default to be set" do
-        (Keybox::RandomSource.source = @random_source_class).should_eql @random_source_class
-        Keybox::RandomSource.source_classes.should_have(3).entries
+    it "valid class should allow default to be set" do
+        (Keybox::RandomSource.source = @random_source_class).should == @random_source_class
+        Keybox::RandomSource.source_classes.should have(3).entries
         Keybox::RandomSource.source_classes.delete(@random_source_class)
-        Keybox::RandomSource.source_classes.should_have(2).entries
-        Keybox::RandomSource.source.should_eql ::Keybox::RandomDevice
+        Keybox::RandomSource.source_classes.should have(2).entries
+        Keybox::RandomSource.source.should == ::Keybox::RandomDevice
     end
 
-    specify "rand with no parameters should return a value between 0 and 1" do
+    it "rand with no parameters should return a value between 0 and 1" do
         r = Keybox::RandomSource.rand
-        r.should_satisfy { |arg| arg >= 0.0 and arg < 1.0 }
+        r.should >= 0.0
+        r.should < 1.0
     end
 
-    specify "rand with parameters should return an integer value between 0 and that value" do
+    it "rand with parameters should return an integer value between 0 and that value" do
         r = Keybox::RandomSource.rand(42)
-        r.should_be_a_kind_of(Integer)
-        r.should_be < 42
+        r.should be_a_kind_of(Integer)
+        r.should < 42
     end
 end
 
-context "a randomzier instance" do 
-    setup do
+describe "a randomzier instance" do 
+    before(:each) do
         @randomizer = Keybox::Randomizer.new
         @hash       = { :stuff => "stuff", :things => "things" }
         @array      = ["foo", "bar", "baz" ]
     end
-    specify "should have a default random source" do
-        @randomizer.random_source.should_not_be nil
+    it "should have a default random source" do
+        @randomizer.random_source.should_not == nil
     end
 
-    specify "giving an invalid default random source should raise an exception" do
-        lambda { r = Keybox::Randomizer.new(Array) }.should_raise ArgumentError
+    it "giving an invalid default random source should raise an exception" do
+        lambda { r = Keybox::Randomizer.new(Array) }.should raise_error(ArgumentError)
     end
 
-    specify "picking from a non-array should raise an exception" do
-        lambda { @randomizer.pick_count_from(@hash) }.should_raise ArgumentError
+    it "picking from a non-array should raise an exception" do
+        lambda { @randomizer.pick_count_from(@hash) }.should raise_error(ArgumentError)
     end
 
-    specify "picking one from an array should be okay" do
-        @randomizer.pick_one_from(@array).should_satisfy do |x|
-            @array.include?(x)
-        end
+    it "picking one from an array should be okay" do
+        @array.should be_include(@randomizer.pick_one_from(@array))
     end
 
-    specify "picking N from an array should result in an array" do
-        @randomizer.pick_count_from(@array,3).should_have(3).entries
+    it "picking N from an array should result in an array" do
+        @randomizer.pick_count_from(@array,3).should have(3).entries
         @randomizer.pick_count_from(@array,9).each do |arg|
-            @array.should_include(arg)
+            @array.should be_include(arg)
         end
     end
 end

data/spec/storage_container_spec.rb

@@ -6,8 +6,8 @@ require 'openssl'
 require 'tempfile'
 require 'yaml'
 
-context 'a storage container' do
-    setup do
+describe 'a storage container' do
+    before(:each) do
         @passphrase  = "i love ruby"
         @keybox_file = Tempfile.new("keybox").path
         @testing_file = "/tmp/testing.yml"
@@ -17,54 +17,64 @@ context 'a storage container' do
         @container.save
     end
 
-    teardown do
+    after(:each) do
         File.unlink(@testing_file) if File.exists?(@testing_file)
         File.unlink(@keybox_file) if File.exists?(@keybox_file)
     end
 
-    specify 'should have a uuid' do
-        @container.uuid.should_satisfy { |uuid| uuid.to_s.length == 36 }
+    it 'should have a uuid' do
+        @container.uuid.to_s.length.should == 36 
     end
 
-    specify 'should have a valid key ' do
-        @container.key_digest.should_satisfy { |kd| kd.length == 64 }
+    it 'should have a valid key ' do
+        @container.key_digest.length.should == 64 
     end
 
-    specify 'should save correctly to a file' do
+    it 'should save correctly to a file' do
         @container.save(@testing_file)
-        File.size(@testing_file).should_satisfy { |s| s > 0 }
+        File.size(@testing_file).should > 0 
     end
 
-    specify "should load correctly from a file" do
+    it "should load correctly from a file" do
         @container.save(@testing_file)
         new_container = Keybox::Storage::Container.new(@passphrase,@testing_file)
         new_container.should_be_not_modified
         new_container.uuid.should == @container.uuid
     end
 
-    specify "should validate passphrase" do
+    it "should validate passphrase" do
         nc = Keybox::Storage::Container.new("i love ruby", @keybox_file)
         nc.save(@testing_file)
-        nc.key_digest.should_eql @container.key_digest
-        lambda { Keybox::Storage::Container.new("i hate ruby", @testing_file) }.should_raise Keybox::ValidationError
+        nc.key_digest.should == @container.key_digest
+        lambda { Keybox::Storage::Container.new("i hate ruby", @testing_file) }.should raise_error(Keybox::ValidationError)
 
     end
 
-    specify "url accounts should have the correct password after save" do
+    it "url accounts should have the correct password after save" do
         @container.save(@testing_file)
         new_container = Keybox::Storage::Container.new(@passphrase, @testing_file)
         recs = new_container.find_by_url("nytimes")
-        new_container.records.size.should_eql 2
-        recs.size.should_eql 1
+        new_container.records.size.should == 2
+        recs.size.should == 1
         recs[0].password.should == "2f85a2e2f"
     end
 
-    specify "can find matching records" do
+    it "can find matching records" do
         matches = @container.find(/times/)
-        matches.size.should_be 1
+        matches.size.should == 1
     end
 
-    specify "changing the password is safe" do
+    it "can find matching records - case insensitive via regex input" do
+        matches = @container.find(/Times/)
+        matches.size.should == 1
+    end
+    
+    it "can find matching records - case insensitive via string input" do
+        matches = @container.find("Times")
+        matches.size.should == 1
+    end
+
+    it "changing the password is safe" do
         @container.save(@testing_file)
         copy_of_container= Keybox::Storage::Container.new(@passphrase, @testing_file)
         times_1 = copy_of_container.find_by_url("nytimes").first
@@ -73,27 +83,27 @@ context 'a storage container' do
         @container.save(@keybox_file)
         @container = Keybox::Storage::Container.new("I love ruby too!", @keybox_file)
         times_2 = @container.find_by_url("nytimes").first
-        times_1.should_eql times_2
+        times_1.should == times_2
     end
 
-    specify "should not be modified upon load" do 
-        @container.modified?.should_eql false
+    it "should not be modified upon load" do 
+        @container.modified?.should == false
     end
 
-    specify "a modified db can be detected" do
+    it "a modified db can be detected" do
         l1 = @container.find("localhost").first
         l1.username = "new username"
-        @container.modified?.should_eql true
+        @container.modified?.should == true
     end
 
-    specify "deleting an item should modify the container" do
+    it "deleting an item should modify the container" do
         ll = @container.find("localhost").first
         @container.delete(ll)
-        @container.modified?.should_eql true
+        @container.modified?.should == true
     end
 
-    specify "able to see how many items are in the container" do
-        @container.size.should_eql 2
-        @container.length.should_eql 2
+    it "able to see how many items are in the container" do
+        @container.size.should == 2
+        @container.length.should == 2
     end
 end