htauth 1.0.3 → 1.1.0

data/lib/htauth/version.rb

@@ -1,22 +1,21 @@
-require 'htauth'
 module HTAuth
+  VERSION = "1.1.0"
   module Version
-    MAJOR   = 1
-    MINOR   = 0
-    BUILD   = 3
-
+    STRING  = HTAuth::VERSION
     def to_a
-      [MAJOR, MINOR, BUILD]
+      STRING.split(".")
     end
 
     def to_s
-      to_a.join(".")
+      STRING
     end
 
     module_function :to_a
     module_function :to_s
 
-    STRING = Version.to_s
+    MAJOR   = Version.to_a[0]
+    MINOR   = Version.to_a[1]
+    BUILD   = Version.to_a[2]
+
   end
-  VERSION = Version.to_s
 end

data/lib/htauth.rb

@@ -26,11 +26,21 @@ module HTAuth
     sp = ::File.join( sp, *args ) if args
   end
 
-  class FileAccessError < StandardError ; end
-  class TempFileError < StandardError ; end
-  class PasswordError < StandardError ; end
 end
 
 require 'htauth/version'
-require 'htauth/passwd'
+require 'htauth/algorithm'
+require 'htauth/crypt'
 require 'htauth/digest'
+require 'htauth/digest_entry'
+require 'htauth/digest_file'
+require 'htauth/entry'
+require 'htauth/errors'
+require 'htauth/file'
+require 'htauth/md5'
+require 'htauth/passwd'
+require 'htauth/passwd_entry'
+require 'htauth/passwd_file'
+require 'htauth/plaintext'
+require 'htauth/sha1'
+

data/spec/crypt_spec.rb

@@ -1,18 +1,16 @@
-
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-
+require 'spec_helper'
 require 'htauth/crypt'
 
 describe HTAuth::Crypt do
-    it "has a prefix" do
-        HTAuth::Crypt.new.prefix.should == ""
-    end
+  it "has a prefix" do
+    HTAuth::Crypt.new.prefix.must_equal ""
+  end
 
-    it "encrypts the same way that apache does" do
-        apache_salt = "L0LDd/.."
-        apache_result = "L0ekWYm59LT1M"
-        crypt = HTAuth::Crypt.new({ :salt => apache_salt} )
-        crypt.encode("a secret").should == apache_result
-    end
+  it "encrypts the same way that apache does" do
+    apache_salt = "L0LDd/.."
+    apache_result = "L0ekWYm59LT1M"
+    crypt = HTAuth::Crypt.new({ :salt => apache_salt} )
+    crypt.encode("a secret").must_equal apache_result
+  end
 end
 

data/spec/digest_entry_spec.rb

@@ -1,5 +1,4 @@
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-
+require 'spec_helper'
 require 'htauth/digest_entry'
 
 describe HTAuth::DigestEntry do
@@ -9,53 +8,53 @@ describe HTAuth::DigestEntry do
     end
 
     it "initializes with a user and realm" do
-        @alice.user.should == "alice"
-        @alice.realm.should == "htauth"
+        @alice.user.must_equal "alice"
+        @alice.realm.must_equal "htauth"
     end
 
     it "has the correct digest for a password" do
         @alice.password = "digit"
-        @alice.digest.should == "4ed9e5744c6747af8f292d28afd6372e"
+        @alice.digest.must_equal "4ed9e5744c6747af8f292d28afd6372e"
     end
 
     it "returns username:realm for a key" do
-        @alice.key.should == "alice:htauth"
+        @alice.key.must_equal "alice:htauth"
     end
 
     it "checks the password correctly" do
-        @bob.authenticated?("b secret").should == true
+        @bob.authenticated?("b secret").must_equal true
     end
 
     it "formats correctly when put to a string" do
-        @bob.to_s.should == "bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e"
+        @bob.to_s.must_equal "bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e"
     end
 
     it "parses an input line" do
         @bob_new = HTAuth::DigestEntry.from_line("bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e")
-        @bob.user.should == @bob_new.user
-        @bob.digest.should == @bob_new.digest
-        @bob.realm.should == @bob_new.realm
+        @bob.user.must_equal @bob_new.user
+        @bob.digest.must_equal @bob_new.digest
+        @bob.realm.must_equal @bob_new.realm
     end
 
     it "knows if an input line is a possible entry and raises an exception" do
-        lambda { HTAuth::DigestEntry.is_entry!("#stuff") }.should raise_error(HTAuth::InvalidDigestEntry)
-        lambda { HTAuth::DigestEntry.is_entry!("this:that:other:stuff") }.should raise_error(HTAuth::InvalidDigestEntry)
-        lambda { HTAuth::DigestEntry.is_entry!("this:that:other") }.should raise_error(HTAuth::InvalidDigestEntry)
-        lambda { HTAuth::DigestEntry.is_entry!("this:that:0a90549e8ffb2dd62f98252a95d88xyz") }.should raise_error(HTAuth::InvalidDigestEntry)
+        lambda { HTAuth::DigestEntry.is_entry!("#stuff") }.must_raise(HTAuth::InvalidDigestEntry)
+        lambda { HTAuth::DigestEntry.is_entry!("this:that:other:stuff") }.must_raise(HTAuth::InvalidDigestEntry)
+        lambda { HTAuth::DigestEntry.is_entry!("this:that:other") }.must_raise(HTAuth::InvalidDigestEntry)
+        lambda { HTAuth::DigestEntry.is_entry!("this:that:0a90549e8ffb2dd62f98252a95d88xyz") }.must_raise(HTAuth::InvalidDigestEntry)
     end
     
     it "knows if an input line is a possible entry and returns false" do
-        HTAuth::DigestEntry.is_entry?("#stuff").should == false
-        HTAuth::DigestEntry.is_entry?("this:that:other:stuff").should == false 
-        HTAuth::DigestEntry.is_entry?("this:that:other").should == false 
-        HTAuth::DigestEntry.is_entry?("this:that:0a90549e8ffb2dd62f98252a95d88xyz").should == false
+        HTAuth::DigestEntry.is_entry?("#stuff").must_equal false
+        HTAuth::DigestEntry.is_entry?("this:that:other:stuff").must_equal false 
+        HTAuth::DigestEntry.is_entry?("this:that:other").must_equal false 
+        HTAuth::DigestEntry.is_entry?("this:that:0a90549e8ffb2dd62f98252a95d88xyz").must_equal false
     end
     
     it "knows if an input line is a possible entry and returns true" do
-        HTAuth::DigestEntry.is_entry?("bob:htauth:0a90549e8ffb2dd62f98252a95d88697").should == true
+        HTAuth::DigestEntry.is_entry?("bob:htauth:0a90549e8ffb2dd62f98252a95d88697").must_equal true
     end
 
     it "duplicates itself" do
-        @alice.dup.to_s.should == @alice.to_s
+        @alice.dup.to_s.must_equal @alice.to_s
     end
 end

data/spec/digest_file_spec.rb

@@ -1,5 +1,4 @@
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-
+require 'spec_helper'
 require 'htauth/digest_file'
 require 'tempfile'
 
@@ -23,35 +22,35 @@ describe HTAuth::DigestFile do
 
     it "can add a new entry to an already existing digest file" do
         @digest_file.add_or_update("charlie", "htauth-new", "c secret")
-        @digest_file.contents.should == IO.read(DIGEST_ADD_TEST_FILE)
+        @digest_file.contents.must_equal IO.read(DIGEST_ADD_TEST_FILE)
     end
 
     it "can tell if an entry already exists in the digest file" do
-        @digest_file.has_entry?("alice", "htauth").should == true
-        @digest_file.has_entry?("alice", "some other realm").should == false
+        @digest_file.has_entry?("alice", "htauth").must_equal true
+        @digest_file.has_entry?("alice", "some other realm").must_equal false
     end
     
     it "can update an entry in an already existing digest file" do
         @digest_file.add_or_update("alice", "htauth", "a new secret")
-        @digest_file.contents.should == IO.read(DIGEST_UPDATE_TEST_FILE)
+        @digest_file.contents.must_equal IO.read(DIGEST_UPDATE_TEST_FILE)
     end
 
     it "fetches a copy of an entry" do
-        @digest_file.fetch("alice", "htauth").to_s.should == "alice:htauth:2f361db93147d84831eb34f19d05bfbb"
+        @digest_file.fetch("alice", "htauth").to_s.must_equal "alice:htauth:2f361db93147d84831eb34f19d05bfbb"
     end
 
     it "raises an error if an attempt is made to alter a non-existenet file" do
-        lambda { HTAuth::DigestFile.new("some-file") }.should raise_error(HTAuth::FileAccessError)
+        lambda { HTAuth::DigestFile.new("some-file") }.must_raise(HTAuth::FileAccessError)
     end
 
     # this test will only work on systems that have /etc/ssh_host_rsa_key 
     it "raises an error if an attempt is made to open a file where no permissions are granted" do
-        lambda { HTAuth::DigestFile.new("/etc/ssh_host_rsa_key") }.should raise_error(HTAuth::FileAccessError)
+        lambda { HTAuth::DigestFile.new("/etc/ssh_host_rsa_key") }.must_raise(HTAuth::FileAccessError)
     end
 
     it "deletes an entry" do
         @digest_file.delete("alice", "htauth")
-        @digest_file.contents.should == IO.read(DIGEST_DELETE_TEST_FILE)
+        @digest_file.contents.must_equal IO.read(DIGEST_DELETE_TEST_FILE)
     end
     
     it "is usable in a ruby manner and yeilds itself when opened" do
@@ -60,7 +59,7 @@ describe HTAuth::DigestFile do
             pf.delete('bob', 'htauth')
         end
         lines = IO.readlines(@tf.path)
-        lines.size.should == 1
-        lines.first.strip.should == "alice:htauth:2f361db93147d84831eb34f19d05bfbb"
+        lines.size.must_equal 1
+        lines.first.strip.must_equal "alice:htauth:2f361db93147d84831eb34f19d05bfbb"
     end
 end

data/spec/digest_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
+require 'spec_helper'
 require 'htauth/digest'
 require 'tempfile'
 
@@ -41,8 +41,8 @@ describe HTAuth::Digest do
         begin
             @rdigest.run([ "-h" ])
         rescue SystemExit => se
-            se.status.should == 1
-            @stdout.string.should =~ /passwordfile realm username/m
+            se.status.must_equal 1
+            @stdout.string.must_match( /passwordfile realm username/m )
         end
     end
 
@@ -50,8 +50,8 @@ describe HTAuth::Digest do
         begin
             @rdigest.run([ "--version" ])
         rescue SystemExit => se
-            se.status.should == 1
-            @stdout.string.should =~ /version #{HTAuth::VERSION}/
+            se.status.must_equal 1
+            @stdout.string.must_match( /version #{HTAuth::VERSION}/ )
         end
     end
     
@@ -62,8 +62,8 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ "-c", @new_file, "htauth", "bob" ])
         rescue SystemExit => se
-            se.status.should == 0
-            IO.read(@new_file).should == IO.readlines(DIGEST_ORIGINAL_TEST_FILE).first
+            se.status.must_equal 0
+            IO.read(@new_file).must_equal IO.readlines(DIGEST_ORIGINAL_TEST_FILE).first
         end
     end
 
@@ -74,8 +74,8 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ "-c", @tf.path, "htauth", "bob"])
         rescue SystemExit => se
-            se.status.should == 0
-            IO.read(@tf.path).should == IO.read(DIGEST_DELETE_TEST_FILE)
+            se.status.must_equal 0
+            IO.read(@tf.path).must_equal IO.read(DIGEST_DELETE_TEST_FILE)
         end
     end
 
@@ -86,8 +86,8 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ @tf.path, "htauth-new", "charlie" ])
         rescue SystemExit => se
-            se.status.should == 0
-            IO.read(@tf.path).should == IO.read(DIGEST_ADD_TEST_FILE)
+            se.status.must_equal 0
+            IO.read(@tf.path).must_equal IO.read(DIGEST_ADD_TEST_FILE)
         end
     end
 
@@ -98,9 +98,9 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ @tf.path, "htauth", "alice" ])
         rescue SystemExit => se
-            @stderr.string.should == ""
-            se.status.should == 0
-            IO.read(@tf.path).should == IO.read(DIGEST_UPDATE_TEST_FILE)
+            @stderr.string.must_equal ""
+            se.status.must_equal 0
+            IO.read(@tf.path).must_equal IO.read(DIGEST_UPDATE_TEST_FILE)
         end
     end
     
@@ -108,9 +108,9 @@ describe HTAuth::Digest do
         begin
             @rdigest.run([ "-d", @tf.path, "htauth", "alice" ])
         rescue SystemExit => se
-            @stderr.string.should == ""
-            se.status.should == 0
-            IO.read(@tf.path).should == IO.read(DIGEST_DELETE_TEST_FILE)
+            @stderr.string.must_equal ""
+            se.status.must_equal 0
+            IO.read(@tf.path).must_equal IO.read(DIGEST_DELETE_TEST_FILE)
         end
     end
 
@@ -121,8 +121,8 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ "-c", "/etc/you-cannot-create-me", "htauth", "alice"])
         rescue SystemExit => se
-            @stderr.string.should =~ %r{Could not open password file /etc/you-cannot-create-me}m
-            se.status.should == 1
+            @stderr.string.must_match( %r{Could not open password file /etc/you-cannot-create-me}m )
+            se.status.must_equal 1
         end
     end
 
@@ -133,8 +133,8 @@ describe HTAuth::Digest do
             @stdin.rewind
             @rdigest.run([ @tf.path, "htauth", "alice"])
         rescue SystemExit => se
-            @stderr.string.should =~ /They don't match, sorry./m
-            se.status.should == 1
+            @stderr.string.must_match( /They don't match, sorry./m )
+            se.status.must_equal 1
         end
     end
 
@@ -142,8 +142,8 @@ describe HTAuth::Digest do
         begin
             @rdigest.run(["--blah"])
         rescue SystemExit => se
-            @stderr.string.should =~ /ERROR:/m
-            se.status.should == 1
+            @stderr.string.must_match( /ERROR:/m )
+            se.status.must_equal 1
         end
     end
 

data/spec/md5_spec.rb

@@ -4,14 +4,14 @@ require 'htauth/md5'
 
 describe HTAuth::Md5 do
     it "has a prefix" do
-        HTAuth::Md5.new.prefix.should == "$apr1$"
+        HTAuth::Md5.new.prefix.must_equal "$apr1$"
     end
 
     it "encrypts the same way that apache does" do
         apache_salt = "L0LDd/.."
         apache_result = "$apr1$L0LDd/..$yhUzDjpxam5F1kWdtwMco1"
         md5 = HTAuth::Md5.new({ 'salt' => apache_salt })
-        md5.encode("a secret").should == apache_result
+        md5.encode("a secret").must_equal apache_result
     end
 end
 

data/spec/passwd_entry_spec.rb

@@ -1,139 +1,138 @@
-
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-
+require 'spec_helper'
 require 'htauth/passwd_entry'
 
 describe HTAuth::PasswdEntry do
     before(:each) do
         @alice = HTAuth::PasswdEntry.new("alice", "a secret", "crypt", { :salt => "mD" })
         @bob   = HTAuth::PasswdEntry.new("bob", "b secret", "crypt", { :salt => "b8"})
+        @salt  = "lo1tk/.."
     end
 
     it "initializes with a user and realm" do
-        @alice.user.should == "alice"
+        @alice.user.must_equal "alice"
     end
 
     it "has the correct crypt password" do
         @alice.password = "a secret"
-        @alice.digest.should == "mDwdZuXalQ5zk"
+        @alice.digest.must_equal "mDwdZuXalQ5zk"
     end
 
-    it "should encrypt correctly for md5" do
-        bob = HTAuth::PasswdEntry.new("bob", "b secret", "md5", { :salt => "lo1tk/.." })
-        bob.digest.should == "$apr1$lo1tk/..$CarApvZPee0F6Wj1U0GxZ1"
+    it "encrypts correctly for md5" do
+        bob = HTAuth::PasswdEntry.new("bob", "b secret", "md5", { :salt => @salt })
+        bob.digest.must_equal "$apr1$lo1tk/..$CarApvZPee0F6Wj1U0GxZ1"
     end
     
-    it "should encrypt correctly for sha1" do
+    it "encrypts correctly for sha1" do
         bob = HTAuth::PasswdEntry.new("bob", "b secret", "sha1", { :salt => @salt })
-        bob.digest.should == "{SHA}b/tjGXbX80MEKVnF200S43ca4hY="
+        bob.digest.must_equal "{SHA}b/tjGXbX80MEKVnF200S43ca4hY="
     end
     
-    it "should encrypt correctly for plaintext" do
+    it "encrypts correctly for plaintext" do
         bob = HTAuth::PasswdEntry.new("bob", "b secret", "plaintext", { :salt => @salt })
-        bob.digest.should == "b secret"
+        bob.digest.must_equal "b secret"
     end
 
     it "encrypts with crypt as a default, when parsed from crypt()'d line" do
         bob2 = HTAuth::PasswdEntry.from_line(@bob.to_s)
-        bob2.algorithm.should be_an_instance_of(Array)
-        bob2.algorithm.should have(2).items
+        bob2.algorithm.must_be_instance_of( Array )
+        bob2.algorithm.size.must_equal 2
         bob2.password = "another secret"
-        bob2.algorithm.should be_an_instance_of(HTAuth::Crypt)
+        bob2.algorithm.must_be_instance_of(HTAuth::Crypt)
     end
 
     it "encrypts with crypt as a default, when parsed from plaintext line" do
         p = HTAuth::PasswdEntry.new('paul', 'p secret', 'plaintext')
         p2 = HTAuth::PasswdEntry.from_line(p.to_s)
-        p2.algorithm.should be_an_instance_of(Array)
-        p2.algorithm.should have(2).items
+        p2.algorithm.must_be_instance_of(Array)
+        p2.algorithm.size.must_equal 2
         p2.password = "another secret"
-        p2.algorithm.should be_an_instance_of(HTAuth::Crypt)
+        p2.algorithm.must_be_instance_of(HTAuth::Crypt)
     end
 
     it "encrypts with md5 as default, when parsed from an md5 line" do
         m = HTAuth::PasswdEntry.new("mary", "m secret", "md5") 
         m2 = HTAuth::PasswdEntry.from_line(m.to_s)
-        m2.algorithm.should be_an_instance_of(HTAuth::Md5)
+        m2.algorithm.must_be_instance_of(HTAuth::Md5)
     end
     
     it "encrypts with sha1 as default, when parsed from an sha1 line" do
         s = HTAuth::PasswdEntry.new("steve", "s secret", "sha1") 
         s2 = HTAuth::PasswdEntry.from_line(s.to_s)
-        s2.algorithm.should be_an_instance_of(HTAuth::Sha1)
+        s2.algorithm.must_be_instance_of(HTAuth::Sha1)
     end
 
     it "determins the algorithm to be crypt when checking a password" do
         bob2 = HTAuth::PasswdEntry.from_line(@bob.to_s)
-        bob2.algorithm.should be_an_instance_of(Array)
-        bob2.algorithm.should have(2).items
-        bob2.authenticated?("b secret").should == true
-        bob2.algorithm.should be_an_instance_of(HTAuth::Crypt)
+        bob2.algorithm.must_be_instance_of(Array)
+        bob2.algorithm.size.must_equal 2
+        bob2.authenticated?("b secret").must_equal true
+        bob2.algorithm.must_be_instance_of(HTAuth::Crypt)
     end
     
     it "determins the algorithm to be plain when checking a password" do
         bob2 = HTAuth::PasswdEntry.from_line("bob:b secret")
-        bob2.algorithm.should be_an_instance_of(Array)
-        bob2.algorithm.should have(2).items
-        bob2.authenticated?("b secret").should == true
-        bob2.algorithm.should be_an_instance_of(HTAuth::Plaintext)
+        bob2.algorithm.must_be_instance_of(Array)
+        bob2.algorithm.size.must_equal 2
+        bob2.authenticated?("b secret").must_equal true
+        bob2.algorithm.must_be_instance_of(HTAuth::Plaintext)
     end
 
     it "authenticates correctly against md5" do
         m = HTAuth::PasswdEntry.new("mary", "m secret", "md5") 
         m2 = HTAuth::PasswdEntry.from_line(m.to_s)
-        m2.authenticated?("m secret").should == true
+        m2.authenticated?("m secret").must_equal true
     end
     
     it "authenticates correctly against sha1" do
         s = HTAuth::PasswdEntry.new("steve", "s secret", "sha1") 
         s2 = HTAuth::PasswdEntry.from_line(s.to_s)
-        s2.authenticated?("s secret").should == true
+        s2.authenticated?("s secret").must_equal true
     end
 
 
 
 
     it "returns username for a key" do
-        @alice.key.should == "alice"
+        @alice.key.must_equal "alice"
     end
 
     it "checks the password correctly" do
-        @bob.authenticated?("b secret").should == true
+        @bob.authenticated?("b secret").must_equal true
     end
 
     it "formats correctly when put to a string" do
-        @bob.to_s.should == "bob:b8Ml4Jp9I0N8E"
+        @bob.to_s.must_equal "bob:b8Ml4Jp9I0N8E"
     end
 
     it "parses an input line" do
         @bob_new = HTAuth::PasswdEntry.from_line("bob:b8Ml4Jp9I0N8E")
-        @bob.user.should == @bob_new.user
-        @bob.digest.should == @bob_new.digest
+        @bob.user.must_equal @bob_new.user
+        @bob.digest.must_equal @bob_new.digest
     end
 
     it "knows if an input line is a possible entry and raises an exception" do
-        lambda { HTAuth::PasswdEntry.is_entry!("#stuff") }.should raise_error(HTAuth::InvalidPasswdEntry)
-        lambda { HTAuth::PasswdEntry.is_entry!("this:that:other:stuff") }.should raise_error(HTAuth::InvalidPasswdEntry)
-        lambda { HTAuth::PasswdEntry.is_entry!("this:that:other") }.should raise_error(HTAuth::InvalidPasswdEntry)
-        lambda { HTAuth::PasswdEntry.is_entry!("this:that:0a90549e8ffb2dd62f98252a95d88xyz") }.should raise_error(HTAuth::InvalidPasswdEntry)
+        lambda { HTAuth::PasswdEntry.is_entry!("#stuff") }.must_raise(HTAuth::InvalidPasswdEntry)
+        lambda { HTAuth::PasswdEntry.is_entry!("this:that:other:stuff") }.must_raise(HTAuth::InvalidPasswdEntry)
+        lambda { HTAuth::PasswdEntry.is_entry!("this:that:other") }.must_raise(HTAuth::InvalidPasswdEntry)
+        lambda { HTAuth::PasswdEntry.is_entry!("this:that:0a90549e8ffb2dd62f98252a95d88xyz") }.must_raise(HTAuth::InvalidPasswdEntry)
     end
     
     it "knows if an input line is a possible entry and returns false" do
-        HTAuth::PasswdEntry.is_entry?("#stuff").should == false
-        HTAuth::PasswdEntry.is_entry?("this:that:other:stuff").should == false 
-        HTAuth::PasswdEntry.is_entry?("this:that:other").should == false 
-        HTAuth::PasswdEntry.is_entry?("this:that:0a90549e8ffb2dd62f98252a95d88xyz").should == false
+        HTAuth::PasswdEntry.is_entry?("#stuff").must_equal false
+        HTAuth::PasswdEntry.is_entry?("this:that:other:stuff").must_equal false 
+        HTAuth::PasswdEntry.is_entry?("this:that:other").must_equal false 
+        HTAuth::PasswdEntry.is_entry?("this:that:0a90549e8ffb2dd62f98252a95d88xyz").must_equal false
     end
     
     it "knows if an input line is a possible entry and returns true" do
-        HTAuth::PasswdEntry.is_entry?("bob:irRm0g.SDfCyI").should == true
-        HTAuth::PasswdEntry.is_entry?("bob:b secreat").should == true
-        HTAuth::PasswdEntry.is_entry?("bob:{SHA}b/tjGXbX80MEKVnF200S43ca4hY=").should == true
-        HTAuth::PasswdEntry.is_entry?("bob:$apr1$lo1tk/..$CarApvZPee0F6Wj1U0GxZ1").should == true
+        HTAuth::PasswdEntry.is_entry?("bob:irRm0g.SDfCyI").must_equal true
+        HTAuth::PasswdEntry.is_entry?("bob:b secreat").must_equal true
+        HTAuth::PasswdEntry.is_entry?("bob:{SHA}b/tjGXbX80MEKVnF200S43ca4hY=").must_equal true
+        HTAuth::PasswdEntry.is_entry?("bob:$apr1$lo1tk/..$CarApvZPee0F6Wj1U0GxZ1").must_equal true
 
     end
 
     it "duplicates itself" do
-        @alice.dup.to_s.should == @alice.to_s
+        @alice.dup.to_s.must_equal @alice.to_s
     end
 end

data/spec/passwd_file_spec.rb

@@ -1,5 +1,4 @@
-require File.join(File.dirname(__FILE__),"spec_helper.rb")
-
+require 'spec_helper'
 require 'htauth/passwd_file'
 require 'tempfile'
 
@@ -23,35 +22,35 @@ describe HTAuth::PasswdFile do
 
     it "can add a new entry to an already existing passwd file" do
         @passwd_file.add_or_update("charlie", "c secret", "sha1")
-        @passwd_file.contents.should == IO.read(PASSWD_ADD_TEST_FILE)
+        @passwd_file.contents.must_equal IO.read(PASSWD_ADD_TEST_FILE)
     end
 
     it "can tell if an entry already exists in the passwd file" do
-        @passwd_file.has_entry?("alice").should == true
-        @passwd_file.has_entry?("david").should == false
+        @passwd_file.has_entry?("alice").must_equal true
+        @passwd_file.has_entry?("david").must_equal false
     end
     
     it "can update an entry in an already existing passwd file, algorithm can change" do
         @passwd_file.add_or_update("alice", "a new secret", "sha1")
-        @passwd_file.contents.should == IO.read(PASSWD_UPDATE_TEST_FILE)
+        @passwd_file.contents.must_equal IO.read(PASSWD_UPDATE_TEST_FILE)
     end
 
     it "fetches a copy of an entry" do
-        @passwd_file.fetch("alice").to_s.should == "alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0"
+        @passwd_file.fetch("alice").to_s.must_equal "alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0"
     end
 
     it "raises an error if an attempt is made to alter a non-existenet file" do
-        lambda { HTAuth::PasswdFile.new("some-file") }.should raise_error(HTAuth::FileAccessError)
+        lambda { HTAuth::PasswdFile.new("some-file") }.must_raise(HTAuth::FileAccessError)
     end
 
     # this test will only work on systems that have /etc/ssh_host_rsa_key 
     it "raises an error if an attempt is made to open a file where no permissions are granted" do
-        lambda { HTAuth::PasswdFile.new("/etc/ssh_host_rsa_key") }.should raise_error(HTAuth::FileAccessError)
+        lambda { HTAuth::PasswdFile.new("/etc/ssh_host_rsa_key") }.must_raise(HTAuth::FileAccessError)
     end
 
     it "deletes an entry" do
         @passwd_file.delete("bob")
-        @passwd_file.contents.should == IO.read(PASSWD_DELETE_TEST_FILE)
+        @passwd_file.contents.must_equal IO.read(PASSWD_DELETE_TEST_FILE)
     end
 
     it "is usable in a ruby manner and yeilds itself when opened" do
@@ -60,8 +59,8 @@ describe HTAuth::PasswdFile do
             pf.delete('bob')
         end
         lines = IO.readlines(@tf.path)
-        lines.size.should == 1
-        lines.first.split(':').first.should == "alice"
-        lines.first.split(':').last.should =~ /\$apr1\$/
+        lines.size.must_equal 1
+        lines.first.split(':').first.must_equal "alice"
+        lines.first.split(':').last.must_match( /\$apr1\$/ )
     end
 end