dionysus 1.0.2 → 2.0.0

data/spec/configuration_spec.rb

@@ -1,176 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'dionysus/configuration'
-
-describe Configuration do
-  describe "basics" do
-    before(:each) { @c = Configuration.new(false) }
-  
-    it "should be empty when no defaults" do
-      @c.size.should == 0
-      @c.should be_empty
-    end
-  
-    it "should be accessible by hash brackets" do
-      @c[:something] = 'a value'
-      @c['something-else'] = 'b value'
-      @c.should_not be_empty
-      @c[:something].should == 'a value'
-      @c['something'].should == 'a value'
-      @c[:'something-else'].should == 'b value'
-      @c['something-else'].should == 'b value'
-    end
-  
-    it "should be accessible by method name" do
-      @c.something = 'a value'
-      @c.should_not be_empty
-      @c.something.should == 'a value'
-    end
-  
-    it "should be accessible by get/set methods" do
-      @c.set(:something, 'a value')
-      @c.set('something-else', 'b value')
-      @c.should_not be_empty
-      @c.get(:something).should == 'a value'
-      @c.get('something').should == 'a value'
-      @c.get(:'something-else').should == 'b value'
-      @c.get('something-else').should == 'b value'
-    end
-    
-    it "should not allow keys with the same name as defined methods." do
-      lambda { @c.set(:set, 'wowsers') }.should raise_error(ArgumentError, "Invalid key: set")
-      @c.to_hash[:set].should be_nil
-      lambda { @c[:set] = 'wowsers' }.should raise_error(ArgumentError, "Invalid key: set")
-      @c.to_hash[:set].should be_nil
-      lambda { @c.set = 'wowsers' }.should raise_error(ArgumentError, "Invalid key: set")
-      @c.to_hash[:set].should be_nil
-    end
-    
-    it "should not allow keys that do not conform to the allowed regex." do
-      lambda { @c.set('^&^&*^&*', 'wowsers') }.should raise_error(ArgumentError, "Invalid key: ^&^&*^&*")
-      lambda { @c.set('', 'wowsers') }.should raise_error(ArgumentError, "Invalid key: ")
-      lambda { @c.set(nil, 'wowsers') }.should raise_error(ArgumentError, "Invalid key: ")
-      lambda { @c.set(Object.new, 'wowsers') }.should raise_error(ArgumentError, /^Invalid key: #<Object:0x[a-fA-F0-9]+>$/)
-    end
-    
-    it "should revert to the normal method_missing with a block" do
-      lambda { @c.not_a_key { 1+1 } }.should raise_error(NoMethodError)
-    end
-    
-    it "should revert to the normal method_missing with any arguments" do
-      lambda { @c.not_a_key('fooey') }.should raise_error(NoMethodError)
-      lambda { @c.not_a_key(nil) }.should raise_error(NoMethodError)
-    end
-    
-    it "should revert to normal method_missing with a setter and more than 1 argument" do
-      lambda { @c.send(:not_a_key=, 'fooey', nil) }.should raise_error(NoMethodError)
-    end
-  end
-  
-  describe "with soft keys" do
-    before(:each) { @c = Configuration.new(false) }
-    
-    it 'should be soft keys' do
-      @c.should be_soft_keys
-    end
-    
-    it 'should initialize empty' do
-      @c.size.should == 0
-      @c.should be_empty
-    end
-  
-    it "should take defaults" do
-      @c = Configuration.new(false, :a_val => 'some value')
-      @c.should be_soft_key
-      @c.a_val.should == 'some value'
-      @c.size.should == 1
-      @c.should_not be_empty
-    end
-    
-    it "should remove the key on delete" do
-      @c.foo = 'fooey'
-      @c.keys.should == [:foo]
-    
-      @c.delete :foo
-      @c.foo.should be_nil
-      @c.keys.should be_empty
-    end
-  
-    it "should not remove the key on set nil" do
-      @c.foo = 'fooey'
-      @c.keys.should == [:foo]
-      
-      @c.foo = nil
-      @c.foo.should be_nil
-      @c.keys.should == [:foo]
-    end
-    
-    it "should allow any key" do
-      @c.allowed_key?('fjdasfiodsaifo').should be_true
-      @c.allowed_key?('^&*%^*9789').should be_true
-      @c.allowed_key?(Object.new).should be_true
-    end
-    
-    it "should not allow setting hard keys" do
-      lambda { @c = Configurat.new(false, :a_hard_key, :a_val => 'some_value') }.should
-        raise_error(ArgumentError, 'Cannot define hard keys in soft keys mode')
-      
-    end
-  end
-  
-  describe "with hard keys" do
-    before(:each) { @c = Configuration.new(:foo, :bar) }
-    
-    it "should be hard keys" do
-      @c.should be_hard_keys
-    end
-    
-    it "should initialize empty" do
-      @c.size.should == 0
-      @c.should be_empty
-      @c.keys.should == [:bar, :foo]
-    end
-    
-    it "should take defaults" do
-      @c = Configuration.new(:foo, :bar, {'wowsers' => 'wow', :bar => 'fooey'})
-      @c.keys.should == [:bar, :foo, :wowsers]
-      @c.size.should == 2
-      @c.foo.should == nil
-      @c.bar.should == 'fooey'
-      @c[:wowsers].should == 'wow'
-    end
-    
-    it "should not remove the key on delete" do
-      @c.foo = 'fooey'
-      @c.keys.should include(:foo)
-      @c.size.should == 1
-    
-      @c.delete :foo
-      @c.foo.should be_nil
-      @c.keys.should include(:foo)
-      @c.size.should == 0
-    end
-  
-    it "should not remove the key on set nil" do
-      @c.foo = 'fooey'
-      @c.keys.should include(:foo)
-      @c.size.should == 1
-      
-      @c.foo = nil
-      @c.foo.should be_nil
-      @c.keys.should include(:foo)
-      @c.size.should == 1
-    end
-    
-    it "should allow only the hard keys" do
-      @c.allowed_key?('fjdasfiodsaifo').should be_false
-      @c.allowed_key?('^&*%^*9789').should be_false
-      @c.allowed_key?(Object.new).should be_false
-      @c.allowed_key?(:foo).should be_true
-      @c.allowed_key?('foo').should be_true
-    end
-    
-    it "should revert to the normal method_missing an unallowed key" do
-      lambda { @c.not_a_key }.should raise_error(NoMethodError)
-    end
-  end
-end

data/spec/digest_spec.rb

@@ -1,183 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require 'dionysus/digest'
-
-describe Digest do
-  DIGESTS = { :md5 => 128, :sha1 => 160, :sha2 => 256, 
-              :sha256 => 256, :sha384 => 384, :sha512 => 512 }
-  it 'should have the default available digests' do
-    Digest.available_digests.length.should == Digest::DEFAULT_DIGESTS.length
-    Digest::DEFAULT_DIGESTS.each do |dig|
-      Digest.available_digests.should include(dig)
-    end
-  end
-  
-  describe 'registration' do
-    before(:all) do
-      Digest.digests.clear
-    end
-    
-    after(:each) do
-      Digest.digests.clear
-    end
-    
-    after(:all) do
-      Digest::DEFAULT_DIGESTS.each do |sym|
-        Digest.register_digest!(sym)
-      end
-    end
-    
-    it 'should register an available digest' do
-      Digest.register_digest(:md5).should be_a(Hash)
-      Digest.digests[:md5].should be_a(Hash)
-    end
-    
-    it 'should register an available digest with bang' do
-      Digest.register_digest!(:md5).should be_a(Hash)
-      Digest.digests[:md5].should be_a(Hash)
-    end
-    
-    it 'should automatically interpret the class' do
-      Digest.register_digest(:md5)
-      Digest.digests[:md5][:klass].should == Digest::MD5
-    end
-    
-    it 'should register a digest with a class' do
-      Digest.register_digest(:md5, :klass => Digest::SHA256)
-      Digest.digests[:md5][:klass].should == Digest::SHA256
-      Digest.digests[:md5][:bit_length].should == 256
-    end
-    
-    it 'should automatically interpret the bit length' do
-      Digest.register_digest(:md5)
-      Digest.digests[:md5][:bit_length].should == 128
-    end
-    
-    it 'should register a digest with a class and a bit length' do
-      Digest.register_digest(:md5, :klass => Digest::SHA256, :bit_length => 1)
-      Digest.digests[:md5][:klass].should == Digest::SHA256
-      Digest.digests[:md5][:bit_length].should == 1
-    end
-    
-    it 'should quietly reject a digest if it does not exist' do
-      Digest.register_digest(:foobar).should == nil
-      Digest.digests.should == {}
-    end
-    
-    it 'should raise an error if a digest does not exist' do
-      lambda { Digest.register_digest!(:foobar) }.should 
-             raise_error(LoadError, 'library not found for class Digest::FOOBAR -- digest/foobar')
-    end
-    
-    it 'should take an arbitrary object that responds to digest' do
-      my_digest = mock('my_digest')
-      my_digest.should_receive(:digest).with('1').and_return('12345')
-      Digest.register_digest(:my_digest, :klass => my_digest)
-      Digest.digests[:my_digest][:bit_length].should == 5 * 8
-      Digest.digests[:my_digest][:klass].should === my_digest
-      Digest.digests[:my_digest][:method].should == :digest
-    end
-    
-    it 'should take an arbitrary method' do
-      my_digest = mock('my_digest')
-      my_digest.should_receive(:do_digest).with('1').and_return('12345')
-      Digest.register_digest(:my_digest, :klass => my_digest, :method => :do_digest)
-      Digest.digests[:my_digest][:bit_length].should == 5 * 8
-      Digest.digests[:my_digest][:klass].should === my_digest
-      Digest.digests[:my_digest][:method].should == :do_digest
-    end
-  end
-  
-  describe 'digest lengths' do
-    DIGESTS.each do |dig, bits|
-        it "should have binary length for #{dig}" do
-          Digest.digest_lengths[dig].should == bits / 8
-          Digest.digest_lengths(:binary)[dig].should == bits / 8
-          Digest.digest_lengths(8)[dig].should == bits / 8
-        end
-        
-        it "should have hex length for #{dig}" do
-          Digest.digest_lengths(:hex)[dig].should == bits / 4
-          Digest.digest_lengths(:hexidecimal)[dig].should == bits / 4
-          Digest.digest_lengths(4)[dig].should == bits / 4
-        end
-        
-        it "should have base64 length for #{dig}" do
-          len = bits / 6
-          expected = (len % 4 == 0 ? len : len + (4 - len % 4))
-          Digest.digest_lengths(:base64)[dig].should == expected
-          Digest.digest_lengths(6)[dig].should == expected
-        end
-
-        it "should have bit length for #{dig}" do
-          Digest.digest_lengths(:bit)[dig].should == bits
-          Digest.digest_lengths(1)[dig].should == bits
-        end
-        
-        it "should have arbitrary length for #{dig}" do
-          len = bits / 7
-          Digest.digest_lengths(7)[dig].should == len + (8 - len % 8)
-        end
-    end
-    
-    it 'should reject bit length requests for < 0' do
-      lambda { Digest.digest_lengths(0) }.should    raise_error(ArgumentError, 'Invalid encoding')
-      lambda { Digest.digest_lengths(-1) }.should   raise_error(ArgumentError, 'Invalid encoding')
-      lambda { Digest.digest_lengths(-100) }.should raise_error(ArgumentError, 'Invalid encoding')
-    end
-    
-    it 'should reject bit length requests for unknown encodings' do
-      lambda { Digest.digest_lengths(:my_digest) }.should raise_error(ArgumentError, 'Invalid encoding')
-    end
-  end
-  
-  describe "digest helper" do
-    DIGESTS.each do |dig, bits|
-      it "should run the digest for #{dig}" do
-        Digest.digest(dig, 'foobar').length.should == bits / 8
-      end
-      
-      it "should still have working original digest methods" do
-        "Digest::#{dig.to_s.upcase}".constantize.digest('foobar').length.should == bits / 8
-      end
-    end
-    
-    it "should fail invalid digest" do
-      lambda { Digest.digest(:my_digest, 'foobar') }.should raise_error(LoadError)
-    end
-  end
-  
-  describe "detection" do
-    DIGESTS.each do |dig, bits|
-      it "should detect #{dig} in binary" do
-        str = Digest.digest(dig, 'foobar')
-        Digest.detect_digest(str).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest(str, :binary).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest!(str).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest!(str, :binary).should == (dig == :sha2 ? :sha256 : dig)
-      end
-      
-      it "should detect #{dig} in base64" do
-        str = Digest.digest(dig, 'foobar').encode64s
-        Digest.detect_digest(str, :base64).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest!(str, :base64).should == (dig == :sha2 ? :sha256 : dig)
-      end
-      
-      it "should detect #{dig} in hexidecimal" do
-        str = Digest.digest(dig, 'foobar').encode_hexidecimal
-        Digest.detect_digest(str, :hex).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest(str, :hexidecimal).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest!(str, :hex).should == (dig == :sha2 ? :sha256 : dig)
-        Digest.detect_digest!(str, :hexidecimal).should == (dig == :sha2 ? :sha256 : dig)
-      end
-    end
-    
-    it "should return nil on unknown digest" do
-      Digest.detect_digest('blah').should be_nil
-    end
-    
-    it "should fail on unknown digest with !" do
-      lambda { Digest.detect_digest!('blah') }.should raise_error(RuntimeError, "Unknown digest")
-    end
-  end
-end

data/spec/dionysus_spec.rb

@@ -1,8 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require 'dionysus'
-describe Dionysus do
-  it "should have a version number" do
-    Dionysus::VERSION.should match(/\A\d+(\.\d+)+(\.\w+)??\Z/)
-  end
-end

data/spec/password_salt_spec.rb

@@ -1,169 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require 'dionysus/security/password_salt'
-describe PasswordSalt do
-  it "should not allow placements other than before, after, and split" do
-    salt = PasswordSalt.new('ABCDEFG')
-    [:before, :after, :split].each do |p|
-      salt.placement = p
-      salt.placement.should == p
-      salt.placement = p.to_s
-      salt.placement.should == p
-    end
-    
-    lambda { salt.placement = :wowsers }.should raise_error(ArgumentError, "Invalid salt placement: wowsers")
-  end
-  
-  it "should should return the salt string with to_s" do
-    salt = PasswordSalt.new('ABCDEFG')
-    salt.to_s.should == 'ABCDEFG'
-    salt = PasswordSalt.new('ABCDEFG', :after)
-    salt.to_s.should == 'ABCDEFG'
-    salt = PasswordSalt.new()
-    salt.to_s.should == salt.string
-  end
-  
-  it "should compare equivalance on both string and placement" do
-    salt1 = PasswordSalt.new('ABCDEFG')
-    salt2 = PasswordSalt.new('ABCDEFG')
-    salt1.eql?(salt2).should be_true
-    salt2.eql?(salt1).should be_true
-    
-    salt1 = PasswordSalt.new('ABCDEFG', :before)
-    salt2 = PasswordSalt.new('ABCDEFG', :before)
-    salt1.eql?(salt2).should be_true
-    salt2.eql?(salt1).should be_true
-    
-    salt1 = PasswordSalt.new('ABCDEFG', :before)
-    salt2 = PasswordSalt.new('ABCDEFG', :split)
-    salt1.eql?(salt2).should_not be_true
-    salt2.eql?(salt1).should_not be_true
-  end
-  
-  describe "initializer" do
-    it "should take the first string arg as the literal salt" do
-      salt = PasswordSalt.new('ABCDEFG')
-      salt.string.should == 'ABCDEFG'
-    end
-    
-    it "should take the the second symbold arg as the placement" do
-      salt = PasswordSalt.new('ABCDEFG', :before)
-      salt.placement.should == :before
-    end
-    
-    it "should generate a new salt of 8 characters and :after placement with no arguments" do
-      s = PasswordSalt.new
-      s.placement.should == :after
-      s.string.length.should == 8
-    end
-    
-    it "should take a length option" do
-      s = PasswordSalt.new(:length => 20)
-      s.placement.should == :after
-      s.string.length.should == 20
-    end
-  end
-  
-  describe "salt generation" do
-    it "should generate 8 characters by default" do
-      salt = PasswordSalt.generate
-      salt.length.should == 8
-    end
-    
-    it "should generate n characters when told to" do
-      (0..20).each do |n|
-        PasswordSalt.generate(n).length.should == n
-      end
-    end
-    
-    it "should raise an error with negative length" do
-      lambda { PasswordSalt.generate(-1) }.should raise_error(ArgumentError, "Invalid length: -1")
-    end
-    
-    it "should generate ascii characters only by default" do
-      100.times do
-        salt = PasswordSalt.generate(100)
-        salt.should match(/\A[A-Za-z0-9\+\/]{100}\Z/)
-      end
-    end
-    
-    it "should generate binary characters" do
-      100.times do
-        salt = PasswordSalt.generate(100, :binary)
-        salt.should_not match(/\A[A-Za-z0-9\+\/]{100}\Z/)
-      end
-    end
-    
-    it "should raise an error with an invalid format" do
-      lambda { PasswordSalt.generate(10, :foobar) }.should raise_error(ArgumentError, "Invalid format: foobar")
-    end
-  end
-  
-  describe "after placement" do
-    before(:each) do
-      @password = 'foobar'
-      @salt = "ABCDEFG"
-    end
-    
-    it "should put the salt after the password by default" do
-      salt = PasswordSalt.new(@salt)
-      salt.salt_password(@password).should == @password+@salt
-    end
-    
-    it "should put the salt after the password" do
-      salt = PasswordSalt.new(@salt, :after)
-      salt.salt_password(@password).should == @password+@salt
-    end
-    
-    it "should raise an error with a bad placement" do
-      salt = PasswordSalt.new(@salt)
-      salt.instance_variable_set('@placement', :foobar)
-      lambda { salt.salt_password(@password) }.should raise_error(RuntimeError, "Invalid salt placement: foobar")
-    end
-  end
-  
-  describe "before placement" do
-    before(:each) do
-      @password = 'foobar'
-      @salt = "ABCDEFG"
-    end
-    
-    it "should put the salt before the password" do
-      salt = PasswordSalt.new(@salt, :before)
-      salt.salt_password(@password).should == @salt+@password
-      salt = PasswordSalt.new(@salt)
-      salt.placement = :before
-      salt.salt_password(@password).should == @salt+@password
-    end
-  end
-  
-  describe "split placement with even number of characters" do
-    before(:each) do
-      @password = 'foobar'
-      @salt = "ABCDEFGH"
-    end
-    
-    it "should put half the salt before and half the salt after the password" do
-      salt = PasswordSalt.new(@salt, :split)
-      salt.salt_password(@password).should == 'ABCD'+@password+'EFGH'
-      salt = PasswordSalt.new(@salt)
-      salt.placement = :split
-      salt.salt_password(@password).should == 'ABCD'+@password+'EFGH'
-    end
-  end
-  
-  describe "split placement with odd number of characters" do
-    before(:each) do
-      @password = 'foobar'
-      @salt = "ABCDEFG"
-    end
-    
-    it "should put half the salt before and half the salt after the password" do
-      salt = PasswordSalt.new(@salt, :split)
-      salt.salt_password(@password).should == 'ABC'+@password+'DEFG'
-      salt = PasswordSalt.new(@salt)
-      salt.placement = :split
-      salt.salt_password(@password).should == 'ABC'+@password+'DEFG'
-    end
-  end
-end