zxcvbn-ruby 1.2.0 → 1.2.2

data/spec/matchers/date_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Matchers::Date do
-  let(:matcher) { subject }
-
-  {
-    ' ' => 'testing02 12 1997',
-    '-' => 'testing02-12-1997',
-    '/' => 'testing02/12/1997',
-    '\\' => 'testing02\12\1997',
-    '_' => 'testing02_12_1997',
-    '.' => 'testing02.12.1997'
-  }.each do |separator, password|
-    context "with #{separator} seperator" do
-      let(:matches) { matcher.matches(password) }
-
-      it 'finds matches' do
-        expect(matches).not_to be_empty
-      end
-
-      it 'finds the correct matches' do
-        expect(matches.count).to eq 1
-        expect(matches[0].token).to eq %w[ 02 12 1997 ].join(separator)
-        expect(matches[0].separator).to eq separator
-        expect(matches[0].day).to eq 2
-        expect(matches[0].month).to eq 12
-        expect(matches[0].year).to eq 1997
-      end
-    end
-  end
-
-  # context 'without separator' do
-  #   context '5 digit date' do
-  #     let(:matches) { matcher.matches('13192boo') }
-
-  #     it 'finds matches' do
-  #       matches.should_not be_empty
-  #     end
-
-  #     it 'finds the correct matches' do
-  #       matches.count.should eq 2
-  #       matches[0].token.should eq '13192'
-  #       matches[0].separator.should eq ''
-  #       matches[0].day.should eq 13
-  #       matches[0].month.should eq 1
-  #       matches[0].year.should eq 1992
-
-  #       matches[1].token.should eq '13192'
-  #       matches[1].separator.should eq ''
-  #       matches[1].day.should eq 31
-  #       matches[1].month.should eq 1
-  #       matches[1].year.should eq 1992
-  #     end
-  #   end
-  # end
-
-  # describe '#extract_dates' do
-  #   {
-  #     '1234' => [
-  #       {:year => 2012, :month => 3, :day => 4},
-  #       {:year => 1934, :month => 2, :day => 1},
-  #       {:year => 1934, :month => 1, :day => 2}
-  #     ],
-  #     '12345' => [
-  #       {:year => 1945, :month => 3, :day => 12},
-  #       {:year => 1945, :month => 12, :day => 3},
-  #       {:year => 1945, :month => 1, :day => 23}
-  #     ],
-  #     '54321' => [
-  #       {:year => 1954, :month => 3, :day => 21}
-  #     ],
-  #     '151290' => [
-  #       {:year => 1990, :month => 12, :day => 15}
-  #     ],
-  #     '901215' => [
-  #       {:year => 1990, :month => 12, :day => 15}
-  #     ],
-  #     '1511990' => [
-  #       {:year => 1990, :month => 1, :day => 15}
-  #     ]
-  #   }.each do |token, expected_candidates|
-  #     it "finds the correct candidates for #{token}" do
-  #       matcher.extract_dates(token).should match_array expected_candidates
-  #     end
-  #   end
-  # end
-
-  # describe '#expand_year' do
-  #   {
-  #     12 => 2012,
-  #     01 => 2001,
-  #     15 => 2015,
-  #     19 => 2019,
-  #     20 => 1920
-  #   }.each do |small, expanded|
-  #     it "expands #{small} to #{expanded}" do
-  #       matcher.expand_year(small).should eq expanded
-  #     end
-  #   end
-  # end
-
-  context 'invalid date' do
-    let(:matches) { matcher.matches('testing0.x.1997') }
-
-    it 'doesnt match' do
-      expect(matches).to be_empty
-    end
-  end
-end

data/spec/matchers/dictionary_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Zxcvbn::Matchers::Dictionary do
-  subject(:matcher) { described_class.new("Test dictionary", dictionary) }
-
-  describe "#matches" do
-    let(:matches) { matcher.matches(password) }
-    let(:matched_words) { matches.map(&:matched_word) }
-
-    context "Given a dictionary of English words" do
-      let(:dictionary) { Zxcvbn::Data.new.ranked_dictionaries["english"] }
-      let(:password) { "whatisinit" }
-
-      it "finds all the matches" do
-        expect(matched_words).to match_array %w[wha what ha hat a at tis i is sin i in i it]
-      end
-    end
-
-    context "Given a custom dictionary" do
-      let(:dictionary) { Zxcvbn::DictionaryRanker.rank_dictionary(%w[test AB10CD]) }
-      let(:password) { "AB10CD" }
-
-      it "matches uppercase passwords with normalised dictionary entries" do
-        expect(matched_words).to match_array(%w[ab10cd])
-      end
-    end
-  end
-end

data/spec/matchers/digits_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Matchers::Digits do
-  let(:matcher) { subject }
-  let(:matches) { matcher.matches('testing1239xx9712') }
-
-  it 'sets the pattern name' do
-    expect(matches.all? { |m| m.pattern == 'digits' }).to eql(true)
-  end
-
-  it 'finds the correct matches' do
-    expect(matches.count).to eq(2)
-    expect(matches[0].token).to eq '1239'
-  end
-end

data/spec/matchers/l33t_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Matchers::L33t do
-  let(:matcher) { described_class.new([dictionary_matcher]) }
-  let(:dictionary) { Zxcvbn::Data.new.ranked_dictionaries['english'] }
-  let(:dictionary_matcher) { Zxcvbn::Matchers::Dictionary.new('english', dictionary) }
-
-  describe '#relevant_l33t_substitutions' do
-    it 'returns relevant l33t substitutions' do
-      expect(matcher.relevent_l33t_subtable('p@ssw1rd24')).to eq(
-        {'a' => ['4', '@'], 'i' => ['1'], 'l' => ['1'], 'z' => ['2']}
-      )
-    end
-  end
-
-  describe 'possible l33t substitutions' do
-    context 'with 2 possible substitutions' do
-      it 'returns the correct possible substitutions' do
-        substitutions = {'a' => ['@'], 'i' => ['1']}
-        expect(matcher.l33t_subs(substitutions)).to match_array([
-          {'@' => 'a', '1' => 'i'}
-        ])
-      end
-
-      it 'returns the correct possible substitutions with multiple options' do
-        substitutions = {'a' => ['@', '4'], 'i' => ['1']}
-        expect(matcher.l33t_subs(substitutions)).to match_array([
-          {'@' => 'a', '1' => 'i'},
-          {'4' => 'a', '1' => 'i'}
-        ])
-      end
-    end
-
-    context 'with 3 possible substitutions' do
-      it 'returns the correct possible substitutions' do
-        substitutions = {'a' => ['@'], 'i' => ['1'], 'z' => ['3']}
-        expect(matcher.l33t_subs(substitutions)).to match_array([
-          {'@' => 'a', '1' => 'i', '3' => 'z'}
-        ])
-      end
-    end
-
-    context 'with 4 possible substitutions' do
-      it 'returns the correct possible substitutions' do
-        substitutions = {'a' => ['@'], 'i' => ['1'], 'z' => ['3'], 'b' => ['8']}
-        expect(matcher.l33t_subs(substitutions)).to match_array([
-          {'@' => 'a', '1' => 'i', '3' => 'z', '8' => 'b'}
-        ])
-      end
-    end
-  end
-
-  describe '#matches' do
-    subject(:matches) { matcher.matches('p@ssword') }
-
-    it "doesn't find 'password' because it's not in english.txt" do
-      expect(matches.map(&:matched_word)).not_to include "password"
-    end
-
-    it 'finds the correct matches' do
-      expect(matches.map(&:matched_word)).to match_array([
-        'pas',
-        'a',
-        'as',
-        'ass'
-      ])
-    end
-
-    it 'sets the token correctly on those matches' do
-      expect(matches.map(&:token)).to match_array([
-        'p@s',
-        '@',
-        '@s',
-        '@ss'
-      ])
-    end
-
-    it 'sets the substituions used' do
-      expect(matches.map(&:sub)).to match_array([
-        {'@' => 'a'},
-        {'@' => 'a'},
-        {'@' => 'a'},
-        {'@' => 'a'}
-      ])
-    end
-  end
-end

data/spec/matchers/repeat_spec.rb

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

data/spec/matchers/sequences_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Matchers::Sequences do
-  let(:matcher) { subject }
-  let(:matches) { matcher.matches('abcde87654') }
-
-  it 'sets the pattern name' do
-    expect(matches.all? { |m| m.pattern == 'sequence' }).to eql(true)
-  end
-
-  it 'finds the correct matches' do
-    expect(matches.count).to eq(2)
-    expect(matches[0].token).to eq 'abcde'
-    expect(matches[1].token).to eq '87654'
-  end
-
-  it 'finds overlapping matches' do
-    matches = matcher.matches('abcba')
-    expect(matches.map(&:token)).to eq ['abc', 'cba']
-  end
-end

data/spec/matchers/spatial_spec.rb

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

data/spec/matchers/year_spec.rb

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

data/spec/omnimatch_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Omnimatch do
-  before(:all) do
-    @omnimatch = described_class.new(Zxcvbn::Data.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)
-
-      expect(ruby_results).to match_js_results js_results
-    end
-  end
-end

data/spec/scorer_spec.rb

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

data/spec/scoring/crack_time_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::CrackTime do
-  include Zxcvbn::CrackTime
-
-  describe '#entropy_to_crack_time' do
-    specify do
-      expect(entropy_to_crack_time(15.433976574415976)).to 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
-        expect(crack_time_to_score(90)).to eq 0
-      end
-    end
-
-    context 'crack time in between 10**2 and 10**4' do
-      it 'returns 1' do
-        expect(crack_time_to_score(5000)).to eq 1
-      end
-    end
-
-    context 'crack time in between 10**4 and 10**6' do
-      it 'returns 2' do
-        expect(crack_time_to_score(500_000)).to eq 2
-      end
-    end
-
-    context 'crack time in between 10**6 and 10**8' do
-      it 'returns 3' do
-        expect(crack_time_to_score(50_000_000)).to eq 3
-      end
-    end
-
-    context 'crack time above 10**8' do
-      it 'returns 4' do
-        expect(crack_time_to_score(110_000_000)).to 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|
-          expect(display_time(seconds)).to 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|
-          expect(display_time(seconds)).to match(/[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|
-          expect(display_time(seconds)).to match(/[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|
-          expect(display_time(seconds)).to match(/[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|
-          expect(display_time(seconds)).to match(/[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|
-          expect(display_time(seconds)).to match(/[0-9]+ years$/)
-        end
-      end
-    end
-
-    context 'when a century or more' do
-      it 'should return centuries' do
-        expect(display_time(century_to_seconds)).to eql 'centuries'
-      end
-    end
-  end
-end

data/spec/scoring/entropy_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::Entropy do
-  include Zxcvbn::Math
-
-  let(:entropy) {
-    Class.new do
-      include Zxcvbn::Entropy
-      def data
-        Zxcvbn::Data.new
-      end
-    end.new
-  }
-
-  describe '#repeat_entropy' do
-    it 'returns the correct value' do
-      match = Zxcvbn::Match.new(:token => '2222')
-      expect(entropy.repeat_entropy(match)).to 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
-          expect(entropy.sequence_entropy(match)).to eq 3.807354922057604
-        end
-      end
-    end
-
-    context 'when the first character is a digit' do
-      let(:token) { '23456' }
-
-      it 'returns the correct value' do
-        expect(entropy.sequence_entropy(match)).to eq 5.643856189774725
-      end
-    end
-
-    context 'when the first character is a lowercase letter' do
-      let(:token) { 'bcdef' }
-
-      it 'returns the correct value' do
-        expect(entropy.sequence_entropy(match)).to eq 7.022367813028454
-      end
-    end
-
-    context 'when the first character is an uppercase letter' do
-      let(:token) { 'BCDEF' }
-
-      it 'returns the correct value' do
-        expect(entropy.sequence_entropy(match)).to 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
-        expect(entropy.sequence_entropy(match)).to eq 8.022367813028454
-      end
-    end
-  end
-
-  describe '#digits_entropy' do
-    it 'returns the correct value' do
-      match = Zxcvbn::Match.new(:token => '12345678')
-      expect(entropy.digits_entropy(match)).to eq 26.5754247590989
-    end
-  end
-
-  describe '#year_entropy' do
-    it 'returns the correct value' do
-      expect(entropy.year_entropy(nil)).to 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)
-        expect(entropy.date_entropy(match)).to eq 15.183015000882756
-      end
-    end
-
-    context 'with a four digit year' do
-      it 'returns the correct value' do
-        match = Zxcvbn::Match.new(:year => 2012)
-        expect(entropy.date_entropy(match)).to eq 15.433976574415976
-      end
-    end
-
-    context 'with a separator' do
-      it 'returns the correct value' do
-        match = Zxcvbn::Match.new(:year => 2012, :separator => '/')
-        expect(entropy.date_entropy(match)).to 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 { expect(calculated_entropy).to eq 0 }
-    end
-
-    context 'with all upper case characters' do
-      let(:token) { 'YOU' }
-      let(:rank)  { 1 }
-
-      specify { expect(calculated_entropy).to eq 1 }
-    end
-
-    context 'starting with uppercase' do
-      let(:token) { 'You' }
-      let(:rank)  { 1 }
-
-      specify { expect(calculated_entropy).to eq 1 }
-    end
-
-    context 'starting with uppercase' do
-      let(:token) { 'yoU' }
-      let(:rank)  { 1 }
-
-      specify { expect(calculated_entropy).to eq 1 }
-    end
-
-    context 'mixed upper and lower' do
-      let(:token) { 'tEsTiNg' }
-      let(:rank)  { 1 }
-
-      specify { expect(calculated_entropy).to eq 6 }
-    end
-
-    context 'starting with digits' do
-      let(:token) { '12345' }
-      let(:rank)  { 1 }
-
-      specify { expect(calculated_entropy).to eq 0 }
-    end
-
-    context 'extra l33t entropy' do
-      let(:token) { 'p3rs0n' }
-      let(:rank)  { 1 }
-      let(:l33t)  { true }
-      let(:sub)   { {'3' => 'e', '0' => 'o'} }
-
-      specify { expect(calculated_entropy).to 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'
-
-        expect(entropy.spatial_entropy(match)).to eql 11.562242424221074
-      end
-    end
-
-    context 'when keyboard is dvorak' do
-      it 'should return the correct entropy' do
-        match.graph = 'dvorak'
-
-        expect(entropy.spatial_entropy(match)).to eql 11.562242424221074
-      end
-    end
-
-    context 'when keyboard is not qwerty or dvorak' do
-      it 'should return the correct entropy' do
-        match.graph = 'keypad'
-
-        expect(entropy.spatial_entropy(match)).to eql 9.05528243550119
-      end
-    end
-
-    context 'when match includes several turns' do
-      it 'should return the correct entropy' do
-        match.turns = 5
-
-        expect(entropy.spatial_entropy(match)).to eql 21.761397858718993
-      end
-    end
-
-    context 'when match includes shifted count' do
-      it 'should return the correct entropy' do
-        match.shiffted_count = 5
-
-        expect(entropy.spatial_entropy(match)).to 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
-
-        expect(entropy.spatial_entropy(match)).to eql 21.761397858718993
-      end
-    end
-  end
-
-end