zxcvbn-ruby 1.1.0 → 1.2.1

data/spec/feedback_giver_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-
-describe Zxcvbn::FeedbackGiver do
-  # NOTE: We go in via the tester because the `FeedbackGiver` relies on both
-  #       Omnimatch and the Scorer, which are troublesome to wire up for tests
-  let(:tester) { Zxcvbn::Tester.new }
-
-  describe '.get_feedback' do
-    it "gives empty feedback when a password's score is good" do
-      feedback = tester.test('5815A30BE798').feedback
-
-      expect(feedback).to be_a Zxcvbn::Feedback
-      expect(feedback.warning).to be_nil
-      expect(feedback.suggestions).to be_empty
-    end
-
-    it 'gives general feedback when a password is empty' do
-      feedback = tester.test('').feedback
-
-      expect(feedback).to be_a Zxcvbn::Feedback
-      expect(feedback.warning).to be_nil
-      expect(feedback.suggestions).to contain_exactly(
-        'Use a few words, avoid common phrases',
-        'No need for symbols, digits, or uppercase letters'
-      )
-    end
-
-    it "gives general feedback when a password is poor but doesn't match any heuristics" do
-      feedback = tester.test(':005:0').feedback
-
-      expect(feedback).to be_a Zxcvbn::Feedback
-      expect(feedback.warning).to be_nil
-      expect(feedback.suggestions).to contain_exactly(
-        'Add another word or two. Uncommon words are better.'
-      )
-    end
-
-    describe 'gives specific feedback' do
-      describe 'for dictionary passwords' do
-        it 'that are extremely common' do
-          feedback = tester.test('password').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql('This is a top-10 common password')
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-        end
-
-        it 'that are very, very common' do
-          feedback = tester.test('letmein').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql('This is a top-100 common password')
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-        end
-
-        it 'that are very common' do
-          feedback = tester.test('playstation').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql('This is a very common password')
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-        end
-
-        it 'that are common and you tried to use l33tsp33k' do
-          feedback = tester.test('pl4yst4ti0n').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'This is similar to a commonly used password'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.',
-            "Predictable substitutions like '@' instead of 'a' don't help very much"
-          )
-        end
-
-        it 'that are common and you capitalised the start' do
-          feedback = tester.test('Password').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'This is a top-10 common password'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.',
-            "Capitalization doesn't help very much"
-          )
-        end
-
-        it 'that are common and you capitalised the whole thing' do
-          feedback = tester.test('PASSWORD').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'This is a top-10 common password'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.',
-            'All-uppercase is almost as easy to guess as all-lowercase'
-          )
-        end
-
-        it 'that contain a common first name or last name' do
-          feedback = tester.test('jessica').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'Names and surnames by themselves are easy to guess'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-
-          feedback = tester.test('smith').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'Names and surnames by themselves are easy to guess'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-        end
-
-        it 'that contain a common name and surname' do
-          feedback = tester.test('jessica smith').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'Common names and surnames are easy to guess'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.'
-          )
-        end
-      end
-
-      describe 'for spatial passwords' do
-        it 'that contain a straight keyboard row' do
-          feedback = tester.test('1qaz').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'Straight rows of keys are easy to guess'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.',
-            'Use a longer keyboard pattern with more turns'
-          )
-        end
-
-        it 'that contain a keyboard pattern with one turn' do
-          feedback = tester.test('zaqwer').feedback
-
-          expect(feedback).to be_a Zxcvbn::Feedback
-          expect(feedback.warning).to eql(
-            'Short keyboard patterns are easy to guess'
-          )
-          expect(feedback.suggestions).to contain_exactly(
-            'Add another word or two. Uncommon words are better.',
-            'Use a longer keyboard pattern with more turns'
-          )
-        end
-      end
-
-      it 'for passwords with repeated characters' do
-        feedback = tester.test('zzz').feedback
-
-        expect(feedback).to be_a Zxcvbn::Feedback
-        expect(feedback.warning).to eql(
-          'Repeats like "aaa" are easy to guess'
-        )
-        expect(feedback.suggestions).to contain_exactly(
-          'Add another word or two. Uncommon words are better.',
-          'Avoid repeated words and characters'
-        )
-      end
-
-      it 'for passwords with sequential characters' do
-        feedback = tester.test('pqrpqrpqr').feedback
-
-        expect(feedback).to be_a Zxcvbn::Feedback
-        expect(feedback.warning).to eql(
-          'Sequences like abc or 6543 are easy to guess'
-        )
-        expect(feedback.suggestions).to contain_exactly(
-          'Add another word or two. Uncommon words are better.',
-          'Avoid sequences'
-        )
-      end
-
-      it 'for passwords containing dates' do
-        feedback = tester.test('testing02\12\1997').feedback
-
-        expect(feedback).to be_a Zxcvbn::Feedback
-        expect(feedback.warning).to eql(
-          'Dates are often easy to guess'
-        )
-        expect(feedback.suggestions).to contain_exactly(
-          'Add another word or two. Uncommon words are better.',
-          'Avoid dates and years that are associated with you'
-        )
-      end
-    end
-  end
-end

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