zxcvbn-ruby 0.0.1

data/spec/matchers/repeat_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Zxcvbn::Matchers::Repeat do
+  let(:matcher) { subject }
+  let(:matches) { matcher.matches('bbbbbtestingaaa') }
+
+  it 'sets the pattern name' do
+    matches.all? { |m| m.pattern == 'repeat' }.should be_true
+  end
+
+  it 'finds the repeated patterns' do
+    matches.count.should eq 2
+    matches[0].token.should eq 'bbbbb'
+    matches[0].repeated_char.should eq 'b'
+    matches[1].token.should eq 'aaa'
+    matches[1].repeated_char.should eq 'a'
+  end
+end

data/spec/matchers/sequences_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Zxcvbn::Matchers::Sequences do
+  let(:matcher) { subject }
+  let(:matches) { matcher.matches('abcde87654') }
+
+  it 'sets the pattern name' do
+    matches.all? { |m| m.pattern == 'sequence' }.should be_true
+  end
+
+  it 'finds the correct matches' do
+    matches.count.should == 2
+    matches[0].token.should eq 'abcde'
+    matches[1].token.should eq '87654'
+  end
+end

data/spec/matchers/spatial_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Zxcvbn::Matchers::Spatial do
+  let(:matcher) { Zxcvbn::Matchers::Spatial.new(graphs) }
+  let(:graphs)  { Zxcvbn::ADJACENCY_GRAPHS }
+
+  describe '#matches' do
+    let(:matches) { matcher.matches('rtyikm') }
+
+    it 'finds the correct of matches' do
+      matches.count.should eq 3
+      matches[0].token.should eq 'rty'
+      matches[0].graph.should eq 'qwerty'
+      matches[1].token.should eq 'ikm'
+      matches[1].graph.should eq 'qwerty'
+      matches[2].token.should eq 'yik'
+      matches[2].graph.should eq 'dvorak'
+    end
+  end
+end

data/spec/matchers/year_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Zxcvbn::Matchers::Year do
+  let(:matcher) { subject }
+  let(:matches) { matcher.matches('testing1998') }
+
+  it 'sets the pattern name' do
+    matches.all? { |m| m.pattern == 'year' }.should be_true
+  end
+
+  it 'finds the correct matches' do
+    matches.count.should == 1
+    matches[0].token.should eq '1998'
+  end
+end

data/spec/omnimatch_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Zxcvbn::Omnimatch do
+  before(:all) do
+    @omnimatch = described_class.new
+  end
+
+  def omnimatch(password)
+    @omnimatch.matches(password)
+  end
+
+  def js_omnimatch(password)
+    run_js(%'omnimatch("#{password}")')
+  end
+
+  TEST_PASSWORDS.each do |password|
+    it "gives back the same results for #{password}" do
+      js_results = js_omnimatch(password)
+      ruby_results = omnimatch(password)
+
+      ruby_results.should match_js_results js_results
+    end
+  end
+end

data/spec/scorer_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Zxcvbn::Scorer do
+
+end

data/spec/scoring/crack_time_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Zxcvbn::CrackTime do
+  include Zxcvbn::CrackTime
+
+  describe '#entropy_to_crack_time' do
+    specify do
+      entropy_to_crack_time(15.433976574415976).should eq 2.2134000000000014
+    end
+  end
+
+  describe '#crack_time_to_score' do
+    context 'crack time less than 10 to the power 2' do
+      it 'returns 0' do
+        crack_time_to_score(90).should eq 0
+      end
+    end
+
+    context 'crack time in between 10**2 and 10**4' do
+      it 'returns 1' do
+        crack_time_to_score(5000).should eq 1
+      end
+    end
+
+    context 'crack time in between 10**4 and 10**6' do
+      it 'returns 2' do
+        crack_time_to_score(500_000).should eq 2
+      end
+    end
+
+    context 'crack time in between 10**6 and 10**8' do
+      it 'returns 3' do
+        crack_time_to_score(50_000_000).should eq 3
+      end
+    end
+
+    context 'crack time above 10**8' do
+      it 'returns 4' do
+        crack_time_to_score(110_000_000).should eq 4
+      end
+    end
+  end
+
+  describe '#display_time' do
+    let(:minute_to_seconds)  { 60 }
+    let(:hour_to_seconds)    { minute_to_seconds * 60 }
+    let(:day_to_seconds)     { hour_to_seconds * 24 }
+    let(:month_to_seconds)   { day_to_seconds * 31 }
+    let(:year_to_seconds)    { month_to_seconds * 12 }
+    let(:century_to_seconds) { year_to_seconds * 100 }
+
+    context 'when less than a minute' do
+      it 'should return instant' do
+        [0, minute_to_seconds - 1].each do |seconds|
+          display_time(seconds).should eql 'instant'
+        end
+      end
+    end
+
+    context 'when less than an hour' do
+      it 'should return a readable time in minutes' do
+        [60, (hour_to_seconds - 1)].each do |seconds|
+          display_time(seconds).should =~ /[0-9]+ minutes$/
+        end
+      end
+    end
+
+    context 'when less than a day' do
+      it 'should return a readable time in hours' do
+        [hour_to_seconds, (day_to_seconds - 1)].each do |seconds|
+          display_time(seconds).should =~ /[0-9]+ hours$/
+        end
+      end
+    end
+
+    context 'when less than 31 days' do
+      it 'should return a readable time in days' do
+        [day_to_seconds, month_to_seconds - 1].each do |seconds|
+          display_time(seconds).should =~ /[0-9]+ days$/
+        end
+      end
+    end
+
+    context 'when less than 1 year' do
+      it 'should return a readable time in days' do
+        [month_to_seconds, (year_to_seconds - 1)].each do |seconds|
+          display_time(seconds).should =~ /[0-9]+ months$/
+        end
+      end
+    end
+
+    context 'when less than a century' do
+      it 'should return a readable time in days' do
+        [year_to_seconds, (century_to_seconds - 1)].each do |seconds|
+          display_time(seconds).should =~ /[0-9]+ years$/
+        end
+      end
+    end
+
+    context 'when a century or more' do
+      it 'should return centuries' do
+        display_time(century_to_seconds).should eql 'centuries'
+      end
+    end
+  end
+end

data/spec/scoring/entropy_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe Zxcvbn::Entropy do
+  include Zxcvbn::Math
+
+  let(:entropy) {
+    Class.new do
+      include Zxcvbn::Entropy
+    end.new
+  }
+
+  describe '#repeat_entropy' do
+    it 'returns the correct value' do
+      match = Zxcvbn::Match.new(:token => '2222')
+      entropy.repeat_entropy(match).should eq 5.321928094887363
+    end
+  end
+
+  describe '#sequence_entropy' do
+    let(:match) { Zxcvbn::Match.new(:token => token, :ascending => true) }
+
+    {'a' => 'abcdefg', '1' => '1234567'}.each do |first_char, token|
+      context "when the first char is #{first_char}" do
+        let(:token) { token }
+
+        it 'returns the correct value' do
+          entropy.sequence_entropy(match).should eq 3.807354922057604
+        end
+      end
+    end
+
+    context 'when the first character is a digit' do
+      let(:token) { '23456' }
+
+      it 'returns the correct value' do
+        entropy.sequence_entropy(match).should eq 5.643856189774725
+      end
+    end
+
+    context 'when the first character is a lowercase letter' do
+      let(:token) { 'bcdef' }
+
+      it 'returns the correct value' do
+        entropy.sequence_entropy(match).should eq 7.022367813028454
+      end
+    end
+
+    context 'when the first character is an uppercase letter' do
+      let(:token) { 'BCDEF' }
+
+      it 'returns the correct value' do
+        entropy.sequence_entropy(match).should eq 8.022367813028454
+      end
+    end
+
+    context 'when the match is ascending' do
+      before { match.ascending = false }
+      let(:token) { 'bcdef' }
+
+      it 'returns the correct value' do
+        entropy.sequence_entropy(match).should eq 8.022367813028454
+      end
+    end
+  end
+
+  describe '#digits_entropy' do
+    it 'returns the correct value' do
+      match = Zxcvbn::Match.new(:token => '12345678')
+      entropy.digits_entropy(match).should eq 26.5754247590989
+    end
+  end
+
+  describe '#year_entropy' do
+    it 'returns the correct value' do
+      entropy.year_entropy(nil).should eq 6.894817763307944
+    end
+  end
+
+  describe '#date_entropy' do
+    context 'with a two digit year' do
+      it 'returns the correct value' do
+        match = Zxcvbn::Match.new(:year => 98)
+        entropy.date_entropy(match).should eq 15.183015000882756
+      end
+    end
+
+    context 'with a four digit year' do
+      it 'returns the correct value' do
+        match = Zxcvbn::Match.new(:year => 2012)
+        entropy.date_entropy(match).should eq 15.433976574415976
+      end
+    end
+
+    context 'with a separator' do
+      it 'returns the correct value' do
+        match = Zxcvbn::Match.new(:year => 2012, :separator => '/')
+        entropy.date_entropy(match).should eq 17.433976574415976
+      end
+    end
+  end
+
+  describe '#dictionary_entropy' do
+    let(:match) { Zxcvbn::Match.new(:token => token, :rank => rank, :l33t => l33t, :sub => sub) }
+    let(:l33t)  { false }
+    let(:sub)   { {} }
+    let(:calculated_entropy) { entropy.dictionary_entropy(match) }
+
+    context 'a simple dictionary word, all lower case and no l33t subs' do
+      let(:token) { 'you' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 0 }
+    end
+
+    context 'with all upper case characters' do
+      let(:token) { 'YOU' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 1 }
+    end
+
+    context 'starting with uppercase' do
+      let(:token) { 'You' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 1 }
+    end
+
+    context 'starting with uppercase' do
+      let(:token) { 'yoU' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 1 }
+    end
+
+    context 'mixed upper and lower' do
+      let(:token) { 'tEsTiNg' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 6 }
+    end
+
+    context 'starting with digits' do
+      let(:token) { '12345' }
+      let(:rank)  { 1 }
+
+      specify { calculated_entropy.should eq 0 }
+    end
+
+    context 'extra l33t entropy' do
+      let(:token) { 'p3rs0n' }
+      let(:rank)  { 1 }
+      let(:l33t)  { true }
+      let(:sub)   { {'3' => 'e', '0' => 'o'} }
+
+      specify { calculated_entropy.should eq 1 }
+    end
+  end
+
+  describe '#spatial_entropy' do
+    let(:match) { Zxcvbn::Match.new(:token => '123wsclf', :turns => 1) }
+
+    context 'when keyboard is qwerty' do
+      it 'should return the correct entropy' do
+        match.graph = 'qwerty'
+        
+        entropy.spatial_entropy(match).should eql 11.562242424221074
+      end
+    end
+
+    context 'when keyboard is dvorak' do
+      it 'should return the correct entropy' do
+        match.graph = 'dvorak'
+
+        entropy.spatial_entropy(match).should eql 11.562242424221074
+      end
+    end
+
+    context 'when keyboard is not qwerty or dvorak' do
+      it 'should return the correct entropy' do
+        match.graph = 'keypad'
+
+        entropy.spatial_entropy(match).should eql 9.05528243550119
+      end
+    end
+
+    context 'when match includes several turns' do
+      it 'should return the correct entropy' do
+        match.turns = 5
+
+        entropy.spatial_entropy(match).should eql 21.761397858718993
+      end
+    end
+
+    context 'when match includes shifted count' do
+      it 'should return the correct entropy' do
+        match.shiffted_count = 5
+
+        entropy.spatial_entropy(match).should eql 9.05528243550119
+      end
+    end
+
+    context 'when match includes shifted count and several turns' do
+      it 'should return the correct entropy' do
+        match.shiffted_count = 5
+        match.turns          = 5
+
+        entropy.spatial_entropy(match).should eql 21.761397858718993
+      end
+    end
+  end
+
+end

data/spec/scoring/math_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Zxcvbn::Math do
+  include Zxcvbn::Math
+
+  describe '#bruteforce_cardinality' do
+    context 'when empty password' do
+      it 'should return 0 if empty password' do
+        bruteforce_cardinality('').should eql 0
+      end
+    end
+
+    context 'when password is one character long' do
+      context 'and a digit' do
+        it 'should return 10' do
+          (0..9).each do |digit|
+            bruteforce_cardinality(digit.to_s).should eql 10
+          end
+        end
+      end
+
+      context 'and an upper case character' do
+        it 'should return 26' do
+          ('A'..'Z').each do |character|
+            bruteforce_cardinality(character).should eql 26
+          end
+        end
+      end
+
+      context 'and a lower case character' do
+        it 'should return 26' do
+          ('a'..'z').each do |character|
+            bruteforce_cardinality(character).should eql 26
+          end
+        end
+      end
+
+      context 'and a symbol' do
+        it 'should return 33' do
+          %w|/ [ ` {|.each do |symbol|
+            bruteforce_cardinality(symbol).should eql 33
+          end
+        end
+      end
+    end
+
+    context 'when password is more than one character long' do
+      context 'and only digits' do
+        it 'should return 10' do
+          bruteforce_cardinality('123456789').should eql 10
+        end
+      end
+
+      context 'and only lowercase characters' do
+        it 'should return 26' do
+          bruteforce_cardinality('password').should eql 26
+        end
+      end
+
+      context 'and only uppercase characters' do
+        it 'should return 26' do
+          bruteforce_cardinality('PASSWORD').should eql 26
+        end
+      end
+
+      context 'and only symbols' do
+        it 'should return 33' do
+          bruteforce_cardinality('/ [ ` {').should eql 33
+        end
+      end
+
+      context 'and a mixed of character types' do
+        it 'should add up every character type cardinality' do
+          bruteforce_cardinality('p1SsWorD!').should eql 95
+        end
+      end
+    end
+  end
+
+  describe '#average_degree_for_graph' do
+    context 'when keyboard is qwerty' do
+      it 'returns the correct average degree over all keys' do
+        average_degree_for_graph('qwerty').should eql 4.595744680851064
+      end
+    end
+
+    context 'when keyboard is dvorak' do
+      it 'returns the correct average degree over all keys' do
+        average_degree_for_graph('dvorak').should eql 4.595744680851064
+      end
+    end
+
+    context 'when keyboard is keypad' do
+      it 'returns the correct average degree over all keys' do
+        average_degree_for_graph('keypad').should eql 5.066666666666666
+      end
+    end
+
+    context 'when keyboard is mac keypad' do
+      it 'returns the correct average degree over all keys' do
+        average_degree_for_graph('mac_keypad').should eql 5.25
+      end
+    end
+  end
+
+  describe '#starting_positions_for_graph' do
+    context 'when keyboard is qwerty' do
+      it 'returns the correct average degree over all keys' do
+        starting_positions_for_graph('qwerty').should eql 94
+      end
+    end
+
+    context 'when keyboard is dvorak' do
+      it 'returns the correct average degree over all keys' do
+        starting_positions_for_graph('dvorak').should eql 94
+      end
+    end
+
+    context 'when keyboard is keypad' do
+      it 'returns the correct average degree over all keys' do
+        starting_positions_for_graph('keypad').should eql 15
+      end
+    end
+
+    context 'when keyboard is mac keypad' do
+      it 'returns the correct average degree over all keys' do
+        starting_positions_for_graph('mac_keypad').should eql 16
+      end
+    end
+  end
+end