RubyGems - forgery - Versions diffs - 0.4.3 → 0.8.1 - Mend

forgery 0.4.3 → 0.8.1

Files changed (56) hide show

checksums.yaml +7 -0
data/.gitignore +6 -0
data/.travis.yml +12 -0
data/Gemfile +9 -0
data/Gemfile.lock +35 -0
data/LICENSE +1 -1
data/README.markdown +196 -60
data/Rakefile +10 -54
data/forgery.gemspec +23 -0
data/lib/forgery.rb +0 -1
data/lib/forgery/dictionaries/bics +7 -0
data/lib/forgery/dictionaries/company_names +0 -1
data/lib/forgery/dictionaries/currency_descriptions +2 -2
data/lib/forgery/dictionaries/ibans +61 -0
data/lib/forgery/dictionaries/job_titles +1 -1
data/lib/forgery/dictionaries/zones +1 -2
data/lib/forgery/extend.rb +0 -2
data/lib/forgery/extensions/range.rb +1 -1
data/lib/forgery/file_reader.rb +2 -1
data/lib/forgery/forgery/bank_account.rb +25 -0
data/lib/forgery/forgery/basic.rb +1 -1
data/lib/forgery/forgery/credit_card.rb +71 -0
data/lib/forgery/forgery/geo.rb +54 -0
data/lib/forgery/forgery/internet.rb +7 -0
data/lib/forgery/forgery/lorem_ipsum.rb +4 -4
data/lib/forgery/forgery/russian_tax.rb +57 -0
data/lib/forgery/forgery_railtie.rb +0 -29
data/lib/forgery/formats/phone +1 -1
data/lib/forgery/version.rb +3 -1
data/spec/data/dictionaries/code_names +6 -0
data/spec/data/dictionaries/female_first_names +1 -0
data/spec/data/documents/mock_web_page.html +17 -0
data/spec/data/documents/mock_xml_doc.xml +5 -0
data/spec/dictionaries_spec.rb +35 -0
data/spec/extensions/array_spec.rb +25 -0
data/spec/extensions/range_spec.rb +33 -0
data/spec/extensions/string_spec.rb +29 -0
data/spec/file_reader_spec.rb +32 -0
data/spec/forgery/address_spec.rb +84 -0
data/spec/forgery/bank_account_spec.rb +16 -0
data/spec/forgery/basic_spec.rb +179 -0
data/spec/forgery/credit_card_spec.rb +68 -0
data/spec/forgery/currency_spec.rb +15 -0
data/spec/forgery/date_spec.rb +134 -0
data/spec/forgery/internet_spec.rb +62 -0
data/spec/forgery/lorem_ipsum_spec.rb +132 -0
data/spec/forgery/monetary_spec.rb +14 -0
data/spec/forgery/name_spec.rb +11 -0
data/spec/forgery/personal_spec.rb +15 -0
data/spec/forgery/russian_tax_spec.rb +81 -0
data/spec/forgery/time_spec.rb +7 -0
data/spec/forgery_spec.rb +63 -0
data/spec/formats_spec.rb +35 -0
data/spec/spec_helper.rb +39 -0
metadata +89 -38
data/lib/forgery/file_writer.rb +0 -54

data/lib/forgery/forgery_railtie.rb CHANGED

@@ -3,36 +3,7 @@ require 'rails'
 require 'rake'
 class ForgeryRailtie < Rails::Railtie
-  extend Rake::DSL
   config.to_prepare do
     Forgery.load_from! "#{Rails.root}/lib/forgery"
   end
-  rake_tasks do
-    namespace :forgery do
-      desc %q{
-      Create a dictionary file from web content (xml or html).
-      Writes to the directory specified by Forgery::FileWriter#write_to!
-      '${GEM_HOME}/lib/forgery/dictionaries' by default (standalone)
-      '${Rails.root}/lib/forgery/dictionaries' by default (as a Rails 3 plugin)
-      Parameters:
-      :dictionary_name  -- the name of your new dictionary file
-      :source_url       -- web page containing the data for your dictionary file
-      :css_or_xpath     -- css or xpath selector(s) to element(s) containing the desired data
-      Usage:
-      rake forgery:create_dictionary[name_of_file,'http://www.html_or_xml_page.com','li']
-      }
-      task :create_dictionary, :dictionary_name, :source_url, :css_or_xpath do |t, args|
-        dictionary_name = args[:dictionary_name].to_s || raise("parameter :dictionary_name is required")
-        source_url = args[:source_url].to_s || raise("parameter :source_url is required")
-        css_or_xpath = args[:css_or_xpath].to_s || raise("parameter :css_or_xpath is required")
-        Forgery::FileWriter.write_to! "#{Rails.root}/lib/forgery/dictionaries"
-        Forgery::FileWriter.create_dictionary dictionary_name, source_url, css_or_xpath
-      end
-    end
-  end
 end

data/lib/forgery/formats/phone CHANGED

	@@ -1 +1 @@
1	- ~~#-(###)###-####~~
1	+ #-###-###-####

data/lib/forgery/version.rb CHANGED

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
 class Forgery
-  VERSION = "0.4.3"
+  VERSION = '0.8.1'
 end

data/spec/data/dictionaries/code_names ADDED

@@ -0,0 +1,6 @@
+Phoenix
+Deer Park
+Bon Echo
+Gran Paradiso
+Shiretoko
+Namoroka

data/spec/data/dictionaries/female_first_names ADDED

	@@ -0,0 +1 @@
1	+ Amber

data/spec/data/documents/mock_web_page.html ADDED

@@ -0,0 +1,17 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+        "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+    <title>Mock Web Page</title>
+</head>
+<body>
+<h1>Title</h1>
+<h2>Subtitle</h2>
+<p>Paragraph.</p>
+<ul id="list">
+    <li>uno</li>
+    <li>dos</li>
+    <li>tres</li>
+</ul>
+</body>
+</html>

data/spec/data/documents/mock_xml_doc.xml ADDED

@@ -0,0 +1,5 @@
+<dogs>
+    <dog>Labrador Retriever</dog>
+    <dog>Beagle</dog>
+    <dog>Border Collie</dog>
+</dogs>

data/spec/dictionaries_spec.rb ADDED

@@ -0,0 +1,35 @@
+require 'spec_helper'
+describe Forgery::Dictionaries do
+  it "should check if the dictionary is loaded" do
+    dictionaries = Forgery::Dictionaries.new
+    dictionaries[:colors]
+    expect(dictionaries).to be_loaded(:colors)
+  end
+  it "should load a dictionary when called by the key" do
+    dictionaries = Forgery::Dictionaries.new
+    dictionaries.reset!
+    expect(dictionaries).not_to be_loaded(:colors)
+    dictionaries[:colors]
+    expect(dictionaries).to be_loaded(:colors)
+  end
+  it "should clear the loaded dictionaries when calling reset!" do
+    dictionaries = Forgery::Dictionaries.new
+    dictionaries[:colors]
+    expect(dictionaries).to be_loaded(:colors)
+    dictionaries.reset!
+    expect(dictionaries).not_to be_loaded(:colors)
+  end
+end

data/spec/extensions/array_spec.rb ADDED

@@ -0,0 +1,25 @@
+require 'spec_helper'
+describe Array do
+  before do
+    @array = Forgery::Extend([0,1,2,3,4,5,6,7,8,9])
+  end
+  it "should get a random item out of the array" do
+    10.times { expect(@array).to include(@array.random) }
+  end
+  it "should return nil if the array is empty" do
+    expect(Forgery::Extend([]).random).to be_nil
+  end
+  it "should return a random subset of the array" do
+    @array.random_subset(5).each do |i|
+      expect(@array).to include(i)
+    end
+  end
+  it "should return a random subset of the array that is 3 long" do
+    expect(@array.random_subset(3).size).to eq(3)
+  end
+end

data/spec/extensions/range_spec.rb ADDED

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'timeout'
+describe Range do
+  it 'should get a random number out of the range' do
+    range = Forgery::Extend(0..9)
+    10.times { expect(range).to include(range.random) }
+  end
+  it 'should not take a long time when the range is huge' do
+    expect do
+      Timeout.timeout(1) { Forgery::Extend(1_234_567_890..12_345_678_901_234_567_890).random }
+    end.not_to raise_error
+  end
+  it 'should return nil for a random number from a reverse range' do
+    10.times { expect(Forgery::Extend(9..0).random).to be_nil }
+  end
+  it 'should get a random string our of the range' do
+    range = Forgery::Extend('a'..'z')
+    10.times { expect(range).to include(range.random) }
+  end
+  it 'should return nil if the maximum is less than the minimum' do
+    expect(Forgery::Extend('z'..'a').random).to be_nil
+  end
+  it 'should not return the maximum at excluded range' do
+    expect(Random).to receive(:rand).with(0...9).and_return(8)
+    expect(Forgery::Extend(0...9).random).to_not eq(9)
+  end
+end

data/spec/extensions/string_spec.rb ADDED

@@ -0,0 +1,29 @@
+require 'spec_helper'
+describe String do
+  it "should change a single # to a number 0-9" do
+    expect(0..9).to include(Integer(Forgery::Extend("#").to_numbers))
+  end
+  it "should change two #'s to two numbers 0-9" do
+    Forgery::Extend("##").to_numbers.split("").each do |s|
+      expect(0..9).to include(Integer(s))
+    end
+  end
+  it "should only replace #'s in the string with numbers 0-9" do
+    s = Forgery::Extend('###-###-####')
+    n = s.to_numbers
+    0.upto(s.size - 1) do |i|
+      if s[i, 1] == "#"
+        expect('0'..'9').to include(n[i, 1])
+      else
+        expect('0'..'9').not_to include(n[i, 1])
+      end
+    end
+  end
+  it "should allow the replacing of a different character" do
+    expect(0..9).to include(Integer(Forgery::Extend("-").to_numbers("-")))
+  end
+end

data/spec/file_reader_spec.rb ADDED

@@ -0,0 +1,32 @@
+require 'spec_helper'
+describe Forgery::FileReader do
+  it "should return an array when calling read_dictionary" do
+    expect(Forgery::FileReader.read_dictionary(:colors)).to be_is_a(Array)
+  end
+  it "should return an array when calling read_format" do
+    expect(Forgery::FileReader.read_format(:phone)).to be_is_a(Array)
+  end
+  it "should override default dictionaries if Forgery#load_from! was called" do
+    Forgery.load_from! "spec/data"
+    expect(Forgery::FileReader.read_dictionary(:female_first_names)).to eq(%w(Amber))
+  end
+  it "should read dictionaries from custom places if Forgery#load_from! was called" do
+    Forgery.load_from! "spec/data"
+    expect(Forgery::FileReader.read_dictionary(:code_names)).to include('Shiretoko')
+  end
+  it "should raise an exception if file wasn't found in load paths" do
+    expect {
+      Forgery::FileReader.read_dictionary(:non_existing_dictionary)
+    }.to raise_error(ArgumentError)
+  end
+  after do
+    # reset load_paths
+    Forgery.load_paths.clear
+    Forgery.load_paths << File.expand_path("lib/forgery")
+  end
+end

data/spec/forgery/address_spec.rb ADDED

@@ -0,0 +1,84 @@
+require 'spec_helper'
+describe Forgery::Address do
+  it "should return a random street" do
+    expect(Forgery.dictionaries[:streets]).to include(Forgery::Address.street_name)
+  end
+  it "should return a random street number" do
+    original_format = Forgery::Address.street_number.gsub(/\d/, '#')
+    expect(Forgery.formats[:street_number]).to include(original_format)
+  end
+  it "should return a random street suffix" do
+    expect(Forgery.dictionaries[:street_suffixes]).to include(Forgery::Address.street_suffix)
+  end
+  describe ".street_address" do
+    before do
+      @split_address = Forgery::Address.street_address.split
+    end
+    it "should return a random street suffix" do
+      street_suffix = @split_address.pop
+      expect(Forgery.dictionaries[:street_suffixes]).to include(street_suffix)
+    end
+    it "should return a random street number" do
+      street_number_format = @split_address.shift.gsub(/\d/, '#')
+      expect(Forgery.formats[:street_number]).to include(street_number_format)
+    end
+    it "should return a random street" do
+      @split_address.pop
+      @split_address.shift
+      street = @split_address.join(" ")
+      expect(Forgery.dictionaries[:streets]).to include(street)
+    end
+  end
+  it "should return a random city" do
+    city = Forgery::Address.city
+    expect(Forgery.dictionaries[:cities]).to include(city)
+  end
+  it "should return a random state" do
+    state = Forgery::Address.state
+    expect(Forgery.dictionaries[:states]).to include(state)
+  end
+  it "should return a random state abbreviation" do
+    state_abbrev = Forgery::Address.state_abbrev
+    expect(Forgery.dictionaries[:state_abbrevs]).to include(state_abbrev)
+  end
+  it "should return a random Canadian province or territory" do
+    province = Forgery::Address.province
+    expect(Forgery.dictionaries[:provinces]).to include(province)
+  end
+  it "should return a random Canadian province or territory abbreviation" do
+    province_abbrev = Forgery::Address.province_abbrev
+    expect(Forgery.dictionaries[:province_abbrevs]).to include(province_abbrev)
+  end
+  it "should return a random country" do
+    country = Forgery::Address.country
+    expect(Forgery.dictionaries[:countries]).to include(country)
+  end
+  it "should return a random continent" do
+    continent = Forgery::Address.continent
+    expect(Forgery.dictionaries[:continents]).to include(continent)
+  end
+  it "should return a random zip code" do
+    zip_format = Forgery::Address.zip.gsub(/\d/, '#')
+    expect(Forgery.formats[:zip]).to include(zip_format)
+  end
+  it "should return a random phone number" do
+    phone_format = Forgery::Address.phone.gsub(/\d/, '#')
+    expect(Forgery.formats[:phone]).to include(phone_format)
+  end
+end

data/spec/forgery/bank_account_spec.rb ADDED

@@ -0,0 +1,16 @@
+require 'spec_helper'
+describe Forgery::BankAccount do
+  describe 'ibans' do
+    it 'returns a random iban' do
+      expect(Forgery.dictionaries[:ibans]).to include(Forgery::BankAccount.iban)
+    end
+  end
+  describe 'bics' do
+    it 'returns a random bic' do
+      expect(Forgery.dictionaries[:bics]).to include(Forgery::BankAccount.bic)
+    end
+  end
+end

data/spec/forgery/basic_spec.rb ADDED

@@ -0,0 +1,179 @@
+require 'spec_helper'
+describe Forgery::Basic do
+  describe ".password" do
+    it "should only uppercase characters" do
+      expect(Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => true,
+                            :allow_numeric => false,
+                            :allow_special => false)).to only_contain(Forgery::Basic::UPPER_ALPHA)
+    end
+    it "should only contain lowercase characters" do
+      expect(Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => false,
+                            :allow_numeric => false,
+                            :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA)
+    end
+    it "should only contain numeric characters" do
+      expect(Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => true,
+                            :allow_special => false)).to only_contain(Forgery::Basic::NUMERIC)
+    end
+    it "should only contain special characters" do
+      expect(Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => false,
+                            :allow_special => true)).to only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+    it "should only contain lower and uppercase characters" do
+      expect(Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => true,
+                            :allow_numeric => false,
+                            :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA,
+                                                                         Forgery::Basic::UPPER_ALPHA)
+    end
+    it "should only contain numeric and special characters" do
+      expect(Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => true,
+                            :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
+                                                                        Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+    it "should contain any of the defined characters" do
+      expect(Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => true,
+                            :allow_numeric => true,
+                            :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
+                                                                        Forgery::Basic::SPECIAL_CHARACTERS,
+                                                                        Forgery::Basic::LOWER_ALPHA,
+                                                                        Forgery::Basic::UPPER_ALPHA)
+    end
+  end
+  describe ".encrypt" do
+    it "should encrypt to hex digits" do
+      expect(Forgery::Basic.encrypt("something")).to only_contain(Forgery::Basic::HEX_DIGITS)
+    end
+    it "should encrypt different words to different output" do
+      expect(Forgery::Basic.encrypt("foo")).not_to eq(Forgery::Basic.encrypt("bar"))
+    end
+    it "should allow a salt that changes the output" do
+      expect(Forgery::Basic.encrypt("foo", "baz")).not_to eq(Forgery::Basic.encrypt("foo", "bar"))
+    end
+    it "should have the same output when encrypting twice" do
+      expect(Forgery::Basic.encrypt("foo", "bar")).to eq(Forgery::Basic.encrypt("foo", "bar"))
+    end
+  end
+  describe ".boolean" do
+    it "should return true or false" do
+      expect([true, false]).to include(Forgery::Basic.boolean)
+    end
+  end
+  describe ".color" do
+    it "should return a random color" do
+      expect(Forgery.dictionaries[:colors]).to include(Forgery::Basic.color)
+    end
+  end
+  describe ".hex_color" do
+    it "should return a 6-character hex color" do
+      expect(Forgery::Basic.hex_color).to match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){6}/)
+    end
+  end
+  describe ".short_hex_color" do
+    it "should return a 3-character hex color" do
+      expect(Forgery::Basic.short_hex_color).to match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){3}/)
+    end
+  end
+  describe ".number" do
+    it "should return a number >= the at_least option" do
+      expect(Forgery::Basic.number(:at_least => 2)).to be >= 2
+    end
+    it "should return a number <= the at_most option" do
+      expect(Forgery::Basic.number(:at_most => 12)).to be <= 12
+    end
+  end
+  describe ".text" do
+    it "should return text whose length is >= the at_least option" do
+      expect(Forgery::Basic.text(:at_least => 5).size).to be >= 5
+    end
+    it "should return text whose length is <= the at_most option" do
+      expect(Forgery::Basic.text(:at_most => 15).size).to be <= 15
+    end
+    it "should return text whose length is == the exactly option" do
+      expect(Forgery::Basic.text(:exactly => 20).size).to eq(20)
+    end
+    it "should only uppercase characters" do
+      expect(Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => true,
+                        :allow_numeric => false,
+                        :allow_special => false)).to only_contain(Forgery::Basic::UPPER_ALPHA)
+    end
+    it "should only contain lowercase characters" do
+      expect(Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => false,
+                        :allow_numeric => false,
+                        :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA)
+    end
+    it "should only contain numeric characters" do
+      expect(Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => true,
+                        :allow_special => false)).to only_contain(Forgery::Basic::NUMERIC)
+    end
+    it "should only contain special characters" do
+      expect(Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => false,
+                        :allow_special => true)).to only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+    it "should only contain lower and uppercase characters" do
+      expect(Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => true,
+                        :allow_numeric => false,
+                        :allow_special => false)).to only_contain(Forgery::Basic::LOWER_ALPHA,
+                                                                     Forgery::Basic::UPPER_ALPHA)
+    end
+    it "should only contain numeric and special characters" do
+      expect(Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => true,
+                        :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
+                                                                    Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+    it "should contain any of the defined characters" do
+      expect(Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => true,
+                        :allow_numeric => true,
+                        :allow_special => true)).to only_contain(Forgery::Basic::NUMERIC,
+                                                                    Forgery::Basic::SPECIAL_CHARACTERS,
+                                                                    Forgery::Basic::LOWER_ALPHA,
+                                                                    Forgery::Basic::UPPER_ALPHA)
+    end
+  end
+end