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

forgery 0.4.3 → 0.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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