require File.expand_path(File.dirname(__FILE__) + '/spec_helper')

require 'dionysus/digest'

describe Digest do
  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
    { :md5 => 128, :sha1 => 160, :sha2 => 256, 
      :sha256 => 256, :sha384 => 384, :sha512 => 512 }.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
          Digest.digest_lengths(:base64)[dig].should == bits / 6
          Digest.digest_lengths(6)[dig].should == bits / 6
        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
          Digest.digest_lengths(7)[dig].should == bits / 7
        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
  end
end