randomexp 0.1.7

data/spec/unit/randomexp/reducer_spec.rb

@@ -0,0 +1,224 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Randomexp::Reducer do
+  describe ".reduce" do
+    it "should expect a sexp, and return a string" do
+      Randomexp::Reducer.reduce([:literal, 'a']).should be_instance_of(String)
+    end
+
+    it "should be an alias for :[]" do
+      Randomexp::Reducer[[:literal, 'a']].should == Randomexp::Reducer.reduce([:literal, 'a'])
+    end
+  end
+
+  describe ".quantify" do
+    it "should call reduce with the sexp and quantity arguments as the :quantify sexp's head and tail" do
+      Randomexp::Reducer.should_receive(:reduce).with([:literal, 'a'], :*)
+      Randomexp::Reducer.quantify([[:literal, 'a'], :*], :'?')  # :'?' is ignored
+    end
+  end
+
+  describe ".random" do
+    it "should call :char with the quantity argument if the sexp's value is :w" do
+      Randomexp::Reducer.should_receive(:char).with(:*)
+      Randomexp::Reducer.random([:w], :*)
+    end
+
+    it "should call :digit with the quantity argument if the sexp's value is :d" do
+      Randomexp::Reducer.should_receive(:digit).with(:*)
+      Randomexp::Reducer.random([:d], :*)
+    end
+
+    it "should call :whitespace with the quantity argument if the sexp's value is :w" do
+      Randomexp::Reducer.should_receive(:whitespace).with(:*)
+      Randomexp::Reducer.random([:s], :*)
+    end
+
+    it "should call :randgen with the quantity argument if the sexp's value for all other cases" do
+      Randomexp::Reducer.should_receive(:randgen).with(:alpha_numeric, :*)
+      Randomexp::Reducer.random([:alpha_numeric], :*)
+    end
+  end
+
+  describe ".literal" do
+    it "should raise an exception if the quantity argument is :+ or :'+?'" do
+      lambda { Randomexp::Reducer.literal(['a'], :+) }.should raise_error("Sorry, \"a+\" is too vague, try setting a range: \"a{1,3}\"")
+      lambda { Randomexp::Reducer.literal(['b'], :'+?') }.should raise_error("Sorry, \"b+\" is too vague, try setting a range: \"b{1,3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randomexp::Reducer.literal(['a'], :*) }.should raise_error("Sorry, \"a*\" is too vague, try setting a range: \"a{0,3}\"")
+      lambda { Randomexp::Reducer.literal(['b'], :'*?') }.should raise_error("Sorry, \"b*\" is too vague, try setting a range: \"b{0,3}\"")
+    end
+  end
+
+  describe ".intersection" do
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randomexp::Reducer.intersection([[:literal, 'a'], [:literal, 'b']], :+) }.should raise_error("Sorry, \"((...)|(...))+\" is too vague, try setting a range: \"((...)|(...)){1, 3}\"")
+      lambda { Randomexp::Reducer.intersection([[:literal, 'b'], [:literal, 'a']], :'+?') }.should raise_error("Sorry, \"((...)|(...))+\" is too vague, try setting a range: \"((...)|(...)){1, 3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randomexp::Reducer.intersection([[:literal, 'a'], [:literal, 'b']], :*) }.should raise_error("Sorry, \"((...)|(...))*\" is too vague, try setting a range: \"((...)|(...)){0, 3}\"")
+      lambda { Randomexp::Reducer.intersection([[:literal, 'b'], [:literal, 'a']], :'*?') }.should raise_error("Sorry, \"((...)|(...))*\" is too vague, try setting a range: \"((...)|(...)){0, 3}\"")
+    end
+  end
+
+  describe ".union" do
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randomexp::Reducer.union([[:literal, 'a'], [:literal, 'b']], :+) }.should raise_error("Sorry, \"(...)+\" is too vague, try setting a range: \"(...){1, 3}\"")
+      lambda { Randomexp::Reducer.union([[:literal, 'b'], [:literal, 'a']], :'+?') }.should raise_error("Sorry, \"(...)+\" is too vague, try setting a range: \"(...){1, 3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randomexp::Reducer.union([[:literal, 'a'], [:literal, 'b']], :*) }.should raise_error("Sorry, \"(...)*\" is too vague, try setting a range: \"(...){0, 3}\"")
+      lambda { Randomexp::Reducer.union([[:literal, 'b'], [:literal, 'a']], :'*?') }.should raise_error("Sorry, \"(...)*\" is too vague, try setting a range: \"(...){0, 3}\"")
+    end
+  end
+
+  describe ".char" do
+    it "should call Randgen.char if the quantity argument is :'?'" do
+      Randgen.should_receive(:char)
+      Randomexp::Reducer.char(:'?')
+    end
+
+    it "should call Randgen.char if the quantity argument is 1" do
+      Randgen.should_receive(:char)
+      Randomexp::Reducer.char(1)
+    end
+
+    it "should call Randgen.char if the quantity argument is nil" do
+      Randgen.should_receive(:char)
+      Randomexp::Reducer.char(nil)
+    end
+
+    it "should call Randgen.word if the quantity argument is :+" do
+      Randgen.should_receive(:word)
+      Randomexp::Reducer.char(:+)
+    end
+
+    it "should call Randgen.word if the quantity argument is :'+?'" do
+      Randgen.should_receive(:word)
+      Randomexp::Reducer.char(:'+?')
+    end
+
+    it "should call Randgen.word with the :length option if the quantity argument is an Integer" do
+      Randgen.should_receive(:word).with(:length => 5)
+      Randomexp::Reducer.char(5)
+    end
+
+    it "should call Randgen.word with the :length option if the quantity argument is a Range" do
+      range = 1..10
+      range.should_receive(:pick_rand_value).and_return 7
+      Randgen.should_receive(:word).with(:length => 7)
+      Randomexp::Reducer.char(range)
+    end
+  end
+
+  describe ".whitespace" do
+    it "should call Randgen.whitespace if the quantity is :'?'" do
+      Randgen.should_receive(:whitespace)
+      Randomexp::Reducer.whitespace(:'?')
+    end
+
+    it "should call Randgen.whitespace if the quantity is nil" do
+      Randgen.should_receive(:whitespace)
+      Randomexp::Reducer.whitespace(nil)
+    end
+
+    it "should call Randgen.whitespace quantity times if the quantity is an Integer" do
+      Randgen.should_receive(:whitespace).exactly(5).times
+      Randomexp::Reducer.whitespace(5)
+    end
+
+    it "should call Randgen.whitespace quantity times if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick_rand_value).and_return 7
+      Randgen.should_receive(:whitespace).exactly(7).times
+      Randomexp::Reducer.whitespace(range)
+    end
+
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randomexp::Reducer.whitespace(:+) }.should raise_error("Sorry, \"\\s+\" is too vague, try setting a range: \"\\s{1, 5}\"")
+      lambda { Randomexp::Reducer.whitespace(:'+?') }.should raise_error("Sorry, \"\\s+\" is too vague, try setting a range: \"\\s{1, 5}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randomexp::Reducer.whitespace(:*) }.should raise_error("Sorry, \"\\s*\" is too vague, try setting a range: \"\\s{0, 5}\"")
+      lambda { Randomexp::Reducer.whitespace(:'*?') }.should raise_error("Sorry, \"\\s*\" is too vague, try setting a range: \"\\s{0, 5}\"")
+    end
+  end
+
+  describe ".digit" do
+    it "should call Randgen.digit if the quantity is :'?'" do
+      Randgen.should_receive(:digit)
+      Randomexp::Reducer.digit(:'?')
+    end
+
+    it "should call Randgen.digit if the quantity is nil" do
+      Randgen.should_receive(:digit)
+      Randomexp::Reducer.digit(nil)
+    end
+
+    it "should call Randgen.digit quantity times if the quantity is an Integer" do
+      Randgen.should_receive(:digit).exactly(5).times
+      Randomexp::Reducer.digit(5)
+    end
+
+    it "should call Randgen.digit quantity times if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick_rand_value).and_return 7
+      Randgen.should_receive(:digit).exactly(7).times
+      Randomexp::Reducer.digit(range)
+    end
+
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randomexp::Reducer.digit(:+) }.should raise_error("Sorry, \"\\d+\" is too vague, try setting a range: \"\\d{1, 5}\"")
+      lambda { Randomexp::Reducer.digit(:'+?') }.should raise_error("Sorry, \"\\d+\" is too vague, try setting a range: \"\\d{1, 5}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randomexp::Reducer.digit(:*) }.should raise_error("Sorry, \"\\d*\" is too vague, try setting a range: \"\\d{0, 5}\"")
+      lambda { Randomexp::Reducer.digit(:'*?') }.should raise_error("Sorry, \"\\d*\" is too vague, try setting a range: \"\\d{0, 5}\"")
+    end
+  end
+
+  describe ".randgen" do
+    it "should send Randgen the method name argument with a :length => 1 option if the quantity is :'?'" do
+      Randgen.should_receive(:send).with(:foo, :length => 1)
+      Randomexp::Reducer.randgen([:foo], :'?')
+    end
+
+    it "should send Randgen the method name argument if the quantity is nil" do
+      Randgen.should_receive(:send).with(:bar)
+      Randomexp::Reducer.randgen([:bar], nil)
+    end
+
+    it "should send Rangen the method name argument if the quantity is 1" do
+      Randgen.should_receive(:send).with(:baz)
+      Randomexp::Reducer.randgen([:baz], 1)
+    end
+
+    it "should send Randgen the method name argument if the quantity is :+" do
+      Randgen.should_receive(:send).with(:foo)
+      Randomexp::Reducer.randgen([:foo], :+)
+    end
+
+    it "should send Randgen the method name argument if the quantity is :*" do
+      Randgen.should_receive(:send).with(:bar)
+      Randomexp::Reducer.randgen([:bar], :*)
+    end
+
+    it "should send Randgen the method name argument with a length option if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick_rand_value).and_return 7
+      Randgen.should_receive(:send).with(:baz, :length => 7)
+      Randomexp::Reducer.randgen([:baz], range)
+    end
+
+    it "should send Randgen the method name argument with a length option if the quantity is a Integer" do
+      Randgen.should_receive(:send).with(:baz, :length => 7)
+      Randomexp::Reducer.randgen([:baz], 7)
+    end
+  end
+end

data/spec/unit/randomexp_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Randomexp do
+  describe "#initialize" do
+    it "should set the sexp attribute" do
+      Randomexp.new("abcd").sexp.should_not be_nil
+    end
+  end
+
+  describe ".reduce" do
+    it "should not change the original sexp in any way" do
+      @randomexp = Randomexp.new("def")
+      @sexp = @randomexp.sexp
+
+      @randomexp.reduce
+
+      @sexp.should == @randomexp.sexp
+    end
+  end
+end
+
+describe Randomexp do
+ describe "#parse" do
+
+   describe '("\\w")' do
+     it "should be a random sexp" do
+       Randomexp::Parser.parse("\\w").first.should == :random
+     end
+
+     it "should hold a word symbol" do
+       Randomexp::Parser.parse("\\w").last.should == :w
+     end
+   end
+
+   describe '("\\s")' do
+     it "should be a literal sexp" do
+       Randomexp::Parser.parse("\\s").first.should == :random
+     end
+
+     it "should hold a whitespace symbol " do
+       Randomexp::Parser.parse("\\s").last.should == :s
+     end
+   end
+
+   describe '("\\d")' do
+     it "should be a literal sexp" do
+       Randomexp::Parser.parse("\\d").first.should == :random
+     end
+
+     it "should hold a digit character " do
+       Randomexp::Parser.parse("\\d").last.should == :d
+     end
+   end
+
+   describe '("\\c")' do
+     it "should be a literal sexp" do
+       Randomexp::Parser.parse("\\c").first.should == :random
+     end
+
+     it "should hold a digit character " do
+       Randomexp::Parser.parse("\\c").last.should == :c
+     end
+   end
+
+   describe '("(\\w)")' do
+     it "should be a random sexp" do
+       Randomexp::Parser.parse("(\\w)").first.should == :random
+       Randomexp::Parser.parse("(\\w)").last.should == :w
+     end
+   end
+
+   describe '("(\\w)(\\d)")' do
+     it "should be a union between random sexp's" do
+       Randomexp::Parser.parse("(\\w)(\\d)").first.should == :union
+       Randomexp::Parser.parse("(\\w)(\\d)")[1].first.should == :random
+       Randomexp::Parser.parse("(\\w)(\\d)")[2].first.should == :random
+     end
+   end
+
+   describe '("(\\w)(\\s)(\\d)")' do
+     xit "should be a union between 3 sexp's" do
+       Randomexp::Parser.parse("(\\w)(\\s)(\\d)").first.should == :union
+       Randomexp::Parser.parse("(\\w)(\\s)(\\d)").size.should == 4
+     end
+   end
+
+   describe '("\\w*")' do
+     it "should be a quantify sexp and hold a random sexp" do
+       Randomexp::Parser.parse("\\w*").first.should == :quantify
+       Randomexp::Parser.parse("\\w*")[1].first.should == :random
+       Randomexp::Parser.parse("\\w*")[2].should == :*
+     end
+   end
+
+   it "should blah" do
+     Randomexp::Parser.parse("(\\w)|(\\d)").should == [:intersection, [:random, :w], [:random, :d]]
+   end
+
+   describe '("[:sentence:]")' do
+     it "should be a random sexp" do
+       Randomexp::Parser.parse("[:sentence:]").first.should == :random
+       Randomexp::Parser.parse("[:sentence:]").last.should == :sentence
+     end
+   end
+ end
+
+ describe "#reduce" do
+   it "should return a character" do
+     Randomexp.new("\\w").reduce.should =~ /\w/
+   end
+
+   it "should return a word" do
+     Randomexp.new("\\w+").reduce.should =~ /\w+/
+   end
+
+   it "should return a word or an empty string" do
+     Randomexp.new("\\w*").reduce.should =~ /\w*/
+   end
+
+   it "should return a word with 4 to 5 characters" do
+     Randomexp.new("\\w{4,5}").reduce.should =~ /\w{4,5}/
+   end
+
+   it "should return a digit" do
+     Randomexp.new("\\d").reduce.should =~ /\d/
+   end
+
+   it "should return a 2 to 10 digit number" do
+     Randomexp.new("\\d{2,10}").reduce.should =~ /\d{2,10}/
+   end
+
+   it "should return a digit or empty string" do
+     Randomexp.new("\\d?").reduce.should =~ /\d?/
+   end
+
+   it "should return a digit or a character" do
+     Randomexp.new("\\d|\\w").reduce.should =~ /\w|\d/
+   end
+
+   xit "should return a word or a 3 digit number" do
+     Randomexp.new("\\d{3}|\\w+").reduce.should =~ /\w+|d{3}/
+   end
+
+   it "should return a word or number" do
+     Randomexp.new("\\w+|\\d{3}").reduce.should =~ /\w+|d{3}/
+   end
+
+   it "should return a sentence" do
+     Randomexp.new("[:sentence:]").reduce.should =~ /(\w+\s)*\w+/
+   end
+
+   it "should handle a telephone number" do
+     100.times do
+       Randomexp.new("(\\d{3}-)?\\d{3}-\\d{4}").reduce.should =~ /(\d{3}-)?\d{3}-\d{4}/
+     end
+   end
+ end
+end