cipher_bureau 0.2.1

data/test/fixtures/cipher_bureau_statistics.yml

@@ -0,0 +1,40 @@
+noun_4_ascii:
+  id: 13
+  country_code: 47
+  grammar: noun
+  name_type: 
+  ascii: true
+  length: 4
+  word_count: 20
+noun_4:
+  id: 66
+  country_code: 47
+  grammar: noun
+  name_type: 
+  ascii: false
+  length: 4
+  word_count: 20
+surname_5:
+  id: 308
+  country_code: 47
+  grammar: name
+  name_type: surname
+  ascii: false
+  length: 5
+  word_count: 20
+boysname_5:
+  id: 320
+  country_code: 47
+  grammar: name
+  name_type: boysname
+  ascii: false
+  length: 5
+  word_count: 20
+girlsname_5:
+  id: 332
+  country_code: 47
+  grammar: name
+  name_type: girlsname
+  ascii: false
+  length: 5
+  word_count: 20

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Load fixtures from the engine
+if ActiveSupport::TestCase.method_defined?(:fixture_path=)
+  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+end

data/test/units/cipher_bureau/dictionary_test.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# Copyright (c) 2013 Dynamic Project Management AS
+# Copyright (c) 2013 Knut I. Stenmark
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'test_helper'
+
+class CipherBureau::DictionaryTest < ActiveSupport::TestCase
+  fixtures :all
+  
+  context 'validation' do
+    should validate_presence_of :word
+    should validate_presence_of :grammar
+    should validate_presence_of :country_code
+  end
+  context 'saving' do
+    setup do
+      @word = CipherBureau::Dictionary.new :word => 'gurba', :grammar => 'bullshit', :country_code => '999'
+    end
+    should 'be valid' do
+      assert @word.valid?, "Test record was invalid"
+    end
+    should 'set length' do
+      @word.save!
+      assert_equal 5, @word.length
+    end
+    should 'set ascii' do
+      @word.word = 'heihåpp'
+      @word.save!
+      assert !@word.ascii
+    end
+    should 'register statistics' do
+      CipherBureau::Statistic.expects(:register).with(@word)
+      @word.save
+    end
+  end
+  
+  context 'class method' do
+    context 'random' do
+      should 'check statistics before fetching data' do
+        criteria = {:country_code => 47, :grammar => 'noun'}
+        CipherBureau::Statistic.expects(:word_count).with(criteria.merge(:length => 4)).returns(3)
+        CipherBureau::Dictionary.expects(:randomized_offset).with(3).returns(1)
+        assert_equal 'kjel', CipherBureau::Dictionary.random(4, criteria)
+      end
+      should 'support camelize' do
+        CipherBureau::Dictionary.expects(:fetch_random_word).with(:length => 4).returns(stub(:word => 'halo'))
+        assert_equal 'Halo', CipherBureau::Dictionary.random(4, :camelize => true)
+        CipherBureau::Dictionary.expects(:fetch_random_word).with(:length => 4).returns(stub(:word => 'øyne'))
+        assert_equal 'Øyne', CipherBureau::Dictionary.random(4, :camelize => true)
+      end
+    end
+  end
+  
+  
+end

data/test/units/cipher_bureau/password_meter_test.rb

@@ -0,0 +1,128 @@
+# Copyright (c) 2013 Dynamic Project Management AS
+# Copyright (c) 2013 Knut I. Stenmark
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# encoding: utf-8
+require 'test_helper'
+
+class CipherBureau::PasswordMeterTest < ActiveSupport::TestCase
+  # Algorihm:
+  # See http://www.passwordmeter.com
+  setup do
+    @m = CipherBureau::PasswordMeter.new('12345678')
+  end
+  
+  def t(method, expected, password = nil)
+    @m.password = password if password
+    actual = @m.send(method)
+    assert_equal expected, actual, "Method: #{method} with password '#{@m.password}' expected to return #{expected}, was #{actual}"
+  end
+  
+  context 'strength' do
+    should 'calculate weak' do
+      @m.password = 'aaaaaaaaaaaa'
+      assert_equal 48 - 12 - 124 - 22, @m.absolute_score
+      assert_equal 0, @m.strength
+    end
+    should 'calculate strong' do
+      @m.password = 'acgHY79-|/'
+      assert_equal 40 + 16 + 14 + 8 + 18 + 8 + 10 - 2 - 4 - 2, @m.absolute_score
+      assert_equal 100, @m.strength
+    end
+    should 'also be a class method' do
+      assert_equal 100, CipherBureau::PasswordMeter.strength( 'acgHY79-|/')
+    end
+  end
+  
+  
+  context 'addition' do
+    should 'return the expected results' do
+      t :number_of_characters, 8 * 4
+      t :uppercase_letters, (7 - 3 ) * 2, 'AbCdefG'
+      t :uppercase_letters, 0, 'aaaaaaaaaaa'
+      t :lowercase_letters, (7 - 4) * 2, 'AbCdefG'
+      t :lowercase_letters, 0, 'aaaaaaaaaaa'
+      t :lowercase_letters, 2, 'aaaaaaaaaaA'
+      t :numbers, 0, '12345678'
+      t :numbers, 8 * 4, 'a12345678'
+      t :symbols, 3 * 6, 'abcdef[]|'
+      t :middle_numbers_or_symbols, 0, '11'
+      t :middle_numbers_or_symbols, 2 * 2, 'ab12a'
+      t :middle_numbers_or_symbols, 2 * 2, 'ab[]a'
+      t :middle_numbers_or_symbols, 2 * 4, 'ab[12]a'
+      t :requirements, 0, '12'
+      t :requirements, 0, 'abcdefghi'
+      t :requirements, 0, 'abcde1234'
+      t :requirements, 0, 'abcde[]&:'
+      t :requirements, 10, 'AbB=-123i'
+      t :requirements, 8, 'AbB12345'
+    end
+  end
+  
+  context 'deduction' do
+    should 'return representative values for letters only' do
+      t :letters_only, 5, 'abcde'
+      t :letters_only, 5, 'ABCDE'
+      t :letters_only, 5, 'AbCdE'
+      t :letters_only, 0, 'AbCd1'
+      t :letters_only, 0, '12345'
+      t :letters_only, 0, 'AbCd['
+      t :letters_only, 0, ';:`?=)'
+    end
+    should 'return representative values for numbers only' do
+      t :numbers_only, 5, '54321'
+      t :numbers_only, 0, '5432a'
+      t :numbers_only, 0, ';:`?=)'
+      t :numbers_only, 0, 'ABCDE'
+    end
+    should 'return representative values for repeated_characters' do
+      t :repeated_characters, 37, '11111'
+      t :repeated_characters, 15, '11211'
+      t :repeated_characters, 3, 'aa2b1'
+    end
+    should 'return representative values for sequential_letters' do
+      t :sequential_letters, 3, 'ABC'
+      t :sequential_letters, 3, 'BCD'
+      t :sequential_letters, 6, 'ABCD'
+      t :sequential_letters, 6, 'DCBA'
+    end
+    should 'return representative values for sequential_numbers' do
+      t :sequential_numbers, 6, '1234'     
+      t :sequential_numbers, 6, '4321'
+      t :sequential_numbers, 9, '54321'
+    end
+    should 'return representative values for sequential_symbols' do
+      t :sequential_symbols, 21, '!@#$%^&*()'             
+    end
+    should 'return representative values for consecutive_uppercase' do
+      t :consecutive_uppercase, 6, 'ACEG'             
+      t :consecutive_uppercase, 12, 'ACEGsKJSNks'             
+    end
+    should 'return representative values for consecutive_lowercase' do
+      t :consecutive_lowercase, 6, 'aceg'
+      t :consecutive_lowercase, 10, 'acegABkjjJ'
+    end
+    should 'return representative values for consecutive_numbers' do
+      t :consecutive_numbers, 6, '1357'
+      t :consecutive_numbers, 8, 'ab10357CD'
+    end
+  end
+end

data/test/units/cipher_bureau/password_test.rb

@@ -0,0 +1,188 @@
+# Copyright (c) 2013 Dynamic Project Management AS
+# Copyright (c) 2013 Knut I. Stenmark
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# encoding: utf-8
+require 'test_helper'
+
+class CipherBureau::PasswordTest < ActiveSupport::TestCase
+  fixtures :all
+  
+  setup do
+    CipherBureau.default_memorable_options = {}
+  end
+  
+  context 'the interface' do
+    context 'memorable' do
+      should 'generate correct length' do
+        @pwd = CipherBureau::Password.memorable(:length => 10)
+        assert_equal 10, @pwd.length
+      end
+      should 'have a default option' do
+      end
+      should 'support grammar selection' do
+        @pwd = CipherBureau::Password.memorable(:length => 10)
+        @meter = CipherBureau::PasswordMeter.new(@pwd)
+      end
+      should 'support camelize option' do
+        @pwd = CipherBureau::Password.memorable(:length => 10, :camelize => true)
+        assert_equal @pwd[0].upcase, @pwd[0]
+        assert_equal @pwd[6].upcase, @pwd[6]
+      end
+      should 'support middle_numbers option' do
+        CipherBureau::Dictionary.expects(:random).twice.with(4, {}).returns('abcd','efgh')
+        @pwd = CipherBureau::Password.memorable(:length => 10, :middle_numbers => true)
+        assert @pwd.match( /^\w{4,4}\d{2,2}\w{4,4}$/)
+      end
+      should 'embed numbers and symbols in middle' do
+        @pwd = CipherBureau::Password.memorable(:length => 10)
+        @meter = CipherBureau::PasswordMeter.new(@pwd)
+        assert @meter.middle_numbers_or_symbols > 2
+      end
+      
+      context 'scope' do
+        context 'with default values' do
+          setup do            
+            CipherBureau.default_memorable_options = {
+              :length => 10,
+              :country_code => 47,
+              :ascii => false,
+              :grammar => 'name',
+              :name_type => 'girlsname'
+            } 
+          end
+          should 'initialize with them' do
+            @pwd = CipherBureau::Password.new :length => 10
+            assert_equal ({:country_code => 47, :ascii => false, :grammar => 'name', :name_type => 'girlsname'}), @pwd.send(:scope)            
+          end
+          should 'override, by setting initializer' do
+            opts = {:length => 8, :country_code => 44, :ascii => true, :grammar => 'noun'}
+            @pwd = CipherBureau::Password.new opts
+            opts.delete(:length)
+            assert_equal opts, @pwd.send(:scope)
+          end
+        end
+      end
+    end
+    context 'letters_and_numbers' do
+      should 'contain only letters and numbers' do
+        10.times do
+          assert_match /^[A-Za-z0-9]{12,12}$/, CipherBureau::Password.letters_and_numbers(:length => 12)
+        end
+      end
+    end
+    context 'numbers_only' do
+      should 'contain only numbers only' do
+        10.times do
+          assert_match /^[0-9]{10,10}$/, CipherBureau::Password.numbers_only(:length => 10)
+        end
+      end
+    end
+    context 'random' do
+      should 'contain any random character' do
+        50.times do
+          illegal = CipherBureau::Password.random(1, :length => 12).bytes.select { |b| b < 32 || b > 126 }
+          assert_equal 0, illegal.size
+        end
+      end
+      should 'generate the correct length' do
+        pwd = CipherBureau::Password.random(1, :length => 14)
+        assert_equal 14, pwd.length
+      end
+      should 'really be random' do
+        assert_not_equal CipherBureau::Password.random(1, :length => 14), CipherBureau::Password.random(1, :length => 14)
+      end
+    end
+    context 'fips-181' do
+      # http://www.itl.nist.gov/fipspubs/fip181.htm
+      should 'never be used' do
+        assert_raises NoMethodError do
+          pwd = CipherBureau::Password.fips_181(1, :length => 14)
+        end
+      end
+    end
+    context 'strength' do
+      should 'delegate to PasswordMeter' do
+        CipherBureau::PasswordMeter.expects(:strength).with('abcde').returns(1)
+        assert_equal 1, CipherBureau::Password.strength('abcde')
+      end
+    end
+  end
+
+  context 'initializing' do
+    should 'validate length' do
+      assert_raises ArgumentError do
+        pwd = CipherBureau::Password.new
+      end
+    end
+    should 'set options' do
+      pwd = CipherBureau::Password.new({:length => 12, :country_code => 99})
+      assert_equal 12, pwd.length
+      assert_equal ({:country_code => 99}), pwd.options
+    end
+    should 'set defaults' do
+      CipherBureau.default_memorable_options = {
+        :length => 12,
+        :country_code => 98
+      }
+      pwd = CipherBureau::Password.new
+      assert_equal 12, pwd.length
+      assert_equal ({:country_code => 98}), pwd.options
+    end
+  end
+  
+  context 'collecting and enumerating' do
+    context 'single record' do
+      should 'return sigle object' do
+        assert CipherBureau::Password.random(1, :length => 10).is_a?(String)
+        assert CipherBureau::Password.random(:length => 10).is_a?(String)
+      end
+      should 'have the abilty to include strength' do
+        assert CipherBureau::Password.random(:length => 10, :strength => true).is_a?(Array)
+        CipherBureau::Password.expects(:strength).returns(10)
+        CipherBureau::Password.any_instance.expects(:random).returns('abcdefgh')
+        assert_equal ['abcdefgh', 10], CipherBureau::Password.random(:length => 10, :strength => true)
+      end
+    end
+    context 'multiple records' do
+      should 'return array' do
+        assert CipherBureau::Password.random(2, :length => 10).is_a?(Array)
+        assert_equal 2, CipherBureau::Password.random(2, :length => 10).size
+        assert_equal 3, CipherBureau::Password.random(3, :length => 10).size
+      end
+      should 'have the abilty to include strength' do
+        CipherBureau::Password.expects(:strength).twice.returns(10, 5)
+        CipherBureau::Password.any_instance.expects(:random).twice.returns('abcdefgh', 'jklmno')
+        assert_equal [['abcdefgh', 10], ['jklmno', 5]], CipherBureau::Password.random(2, :length => 10, :strength => true)
+      end
+    end
+    context 'hash option' do
+      should 'return hash' do
+        assert CipherBureau::Password.random(:length => 10, :strength => true).is_a?(Array)
+        CipherBureau::Password.stubs(:strength).returns(10)
+        CipherBureau::Password.any_instance.stubs(:random).returns('abcdefgh')
+        expected = {:password => 'abcdefgh', :strength => 10}
+        assert_equal expected, CipherBureau::Password.random(:length => 10, :strength => true, :as => :hash)
+        assert_equal [expected, expected], CipherBureau::Password.random(2, :length => 10, :strength => true, :as => :hash)
+      end
+    end
+  end
+end