fuzzbert 1.0.0 → 1.0.1

data/lib/fuzzbert/generators.rb

@@ -2,51 +2,51 @@ require 'base64'
 
 module FuzzBert::Generators
 
-  class << self
+  module_function
     
-    def random(limit=1024)
-      -> { random_bytes(limit) { |data| data } }
-    end
+  def random(limit=1024)
+    -> { random_bytes(limit) { |data| data } }
+  end
 
-    def random_b64(limit=1024)
-      -> { random_bytes(b64_len(limit)) { |data| Base64.encode64(data) } }
-    end
+  def random_b64(limit=1024)
+    -> { random_bytes(b64_len(limit)) { |data| Base64.encode64(data) } }
+  end
 
-    def random_hex(limit=1024)
-      -> { random_bytes(hex_len(limit)) { |data| data.unpack("H*")[0] } }
-    end
+  def random_hex(limit=1024)
+    -> { random_bytes(hex_len(limit)) { |data| data.unpack("H*")[0] } }
+  end
 
-    def random_fixlen(len)
-      -> { random_bytes_fixlen(len) { |data| data } }
-    end
+  def random_fixlen(len)
+    -> { random_bytes_fixlen(len) { |data| data } }
+  end
 
-    def random_b64_fixlen(len)
-      -> { random_bytes_fixlen(b64_len(len)) { |data| Base64.encode(data) } }
-    end
+  def random_b64_fixlen(len)
+    -> { random_bytes_fixlen(b64_len(len)) { |data| Base64.encode(data) } }
+  end
 
-    def random_hex_fixlen(len)
-      -> { random_bytes_fixlen(hex_len(len)) { |data| data.unpack("H*")[0] } }
-    end
+  def random_hex_fixlen(len)
+    -> { random_bytes_fixlen(hex_len(len)) { |data| data.unpack("H*")[0] } }
+  end
 
-    def cycle(range)
-      ary = range.to_a
-      i = 0
-      lambda do
-        ret = ary[i]
-        i = (i + 1) % ary.size
-        ret
-      end
-    end
-    
-    def fixed(data)
-      -> { data }
+  def cycle(range)
+    ary = range.to_a
+    i = 0
+    lambda do
+      ret = ary[i]
+      i = (i + 1) % ary.size
+      ret
     end
+  end
+  
+  def fixed(data)
+    -> { data }
+  end
 
-    def sample(ary)
-      -> { ary.sample }
-    end
+  def sample(ary)
+    -> { ary.sample }
+  end
 
-    private
+  private; module_function
 
     def hex_len(len)
       len / 2
@@ -65,6 +65,4 @@ module FuzzBert::Generators
       yield FuzzBert::PRNG.bytes(len)
     end
 
-  end
-
 end

data/lib/fuzzbert/rake_task.rb

@@ -64,18 +64,19 @@ class FuzzBert::RakeTask < ::Rake::TaskLib
 
   private
 
-  def command
-    cmd_parts = []
-    cmd_parts << RUBY
-    cmd_parts << ruby_opts
-    cmd_parts << "-S" << fuzzbert_path
-    cmd_parts << fuzzbert_opts
-    cmd_parts << pattern
-    cmd_parts.flatten.reject(&blank).join(" ")
-  end
+    def command
+      cmd_parts = []
+      cmd_parts << RUBY
+      cmd_parts << ruby_opts
+      cmd_parts << "-S" << fuzzbert_path
+      cmd_parts << fuzzbert_opts
+      cmd_parts << pattern
+      cmd_parts.flatten.reject(&blank).join(" ")
+    end
+
+    def blank
+      lambda {|s| s.nil? || s == ""}
+    end
 
-  def blank
-    lambda {|s| s.nil? || s == ""}
-  end
 end
 

data/lib/fuzzbert/template.rb

@@ -20,135 +20,137 @@ class FuzzBert::Template
 
   private
 
-  class Parser
-    
-    def initialize(template)
-      @io = StringIO.new(template)
-      @template = []
-    end
+    class Parser
+      
+      def initialize(template)
+        @io = StringIO.new(template)
+        @template = []
+      end
 
-    def parse
-      @state = determine_state 
-      while token = parse_token
-        @template << token
+      def parse
+        @state = determine_state 
+        while token = parse_token
+          @template << token
+        end
+        @template
       end
-      @template
-    end
 
-    def parse_token
-      case @state
-      when :TEXT
-        parse_text
-      when :IDENTIFIER
-        parse_identifier
-      else
-        nil
+      def parse_token
+        case @state
+        when :TEXT
+          parse_text
+        when :IDENTIFIER
+          parse_identifier
+        else
+          nil
+        end
       end
-    end
 
-    def determine_state
-      begin
-        @buf = @io.readchar
+      def determine_state
+        begin
+          @buf = @io.readchar
 
-        case @buf
-        when '$'
-          c = @io.readchar
-          if c == "{"
+          case @buf
+          when '$'
+            c = @io.readchar
+            if c == "{"
+              @buf = ""
+              :IDENTIFIER
+            else
+              @buf << c
+              :TEXT
+            end
+          when '\\'
             @buf = ""
-            :IDENTIFIER
+            :TEXT
           else
-            @buf << c
             :TEXT
           end
-        when '\\'
-          @buf = ""
-          :TEXT
-        else
-          :TEXT
+        rescue EOFError
+          :EOF
         end
-      rescue EOFError
-        :EOF
       end
-    end
 
-    def parse_identifier
-      name = ""
-      begin
-        until (c = @io.readchar) == '}'
-          name << c
-        end
+      def parse_identifier
+        name = ""
+        begin
+          until (c = @io.readchar) == '}'
+            name << c
+          end
 
-        if name.empty?
-          raise RuntimeError.new("No identifier name given")
-        end
+          if name.empty?
+            raise RuntimeError.new("No identifier name given")
+          end
 
-        @state = determine_state
-        Identifier.new(name)
-      rescue EOFError
-        raise RuntimeError.new("Unclosed identifier")
+          @state = determine_state
+          Identifier.new(name)
+        rescue EOFError
+          raise RuntimeError.new("Unclosed identifier")
+        end
       end
-    end
 
-    def parse_text
-      text = @buf
-      begin
-        loop do
-          until (c = @io.readchar) == '$'
-            if c == '\\'
-              text << parse_escape
+      def parse_text
+        text = @buf
+        begin
+          loop do
+            until (c = @io.readchar) == '$'
+              if c == '\\'
+                text << parse_escape
+              else
+                text << c
+              end
+            end
+
+            d = @io.readchar
+            if d == "{"
+              @state = :IDENTIFIER
+              return Text.new(text)
             else
               text << c
+              text << d
             end
           end
-
-          d = @io.readchar
-          if d == "{"
-            @state = :IDENTIFIER
-            return Text.new(text)
-          else
-            text << c
-            text << d
-          end
+        rescue EOFError
+          @state = :EOF
+          Text.new(text)
         end
-      rescue EOFError
-        @state = :EOF
-        Text.new(text)
       end
-    end
 
-    def parse_escape
-      begin
-        @io.readchar
-      rescue EOFError
-        '\\'
+      def parse_escape
+        begin
+          @io.readchar
+        rescue EOFError
+          '\\'
+        end
       end
+
     end
 
-  end
+    class Text
 
-  class Text
+      def initialize(text)
+        @text = text
+      end
 
-    def initialize(text)
-      @text = text
-    end
+      def to_data(callbacks)
+        @text
+      end
 
-    def to_data(callbacks)
-      @text
     end
 
-  end
+    class Identifier
 
-  class Identifier
+      def initialize(name)
+        @name = name.to_sym
+      end
 
-    def initialize(name)
-      @name = name.to_sym
-    end
+      def to_data(callbacks)
+        cb = callbacks[@name]
+        raise RuntimeError.new "No callback set for :#{@name}" unless cb
+        cb.call
+      end
 
-    def to_data(callbacks)
-      callbacks[@name].call
     end
 
-  end
-
 end
 

data/lib/fuzzbert/test_suite.rb

@@ -9,16 +9,19 @@ class FuzzBert::TestSuite
   end
 
   def deploy(&blk)
+    raise RuntimeError.new "No block was given" unless blk
     @test = FuzzBert::Test.new(blk)
   end
 
   def data(desc, &blk)
+    raise RuntimeError.new "No block was given" unless blk
     @generators << FuzzBert::Generator.new(desc, blk.call)
   end
 
   def self.create(desc, &blk)
+    raise RuntimeError.new "No block was given" unless blk
     obj = self.new(desc)
-    obj.instance_eval(&blk) if blk
+    obj.instance_eval(&blk)
     obj
   end
  

data/spec/autorun_spec.rb

@@ -1,39 +1,53 @@
 require 'rspec'
 require 'fuzzbert'
 
+
 describe FuzzBert::AutoRun do
 
+  after(:each) do
+    #clear any TestSuites that were created
+    FuzzBert::AutoRun::TEST_CASES.clear
+  end
+
   let(:handler) do
     c = Class.new
-    def c.handle(id, data, pid, status)
+    def c.handle(error_data)
       raise RuntimeError.new
     end
     c
   end
 
-  value = "test"
-  called = false
+  
+  context "with a valid test" do
+    value = "test"
+    called = false
 
-  fuzz "autorun" do
+    fuzz "autorun" do
 
-    deploy do |data|
-      data.should == value
-    end
+      deploy do |data|
+        data.should == value
+      end
+
+      data "1" do
+        called = true
+        -> { value }
+      end
 
-    data "1" do
-      called = true
-      -> { value }
     end
 
+    it "has added a TestSuite to AutoRun" do
+      FuzzBert::AutoRun::TEST_CASES.size.should == 1
+      FuzzBert::AutoRun.run(pool_size: 1, limit: 1, handler: handler, sleep_delay: 0.05)
+      called.should == true
+    end
   end
 
-  it "has added a TestSuite to AutoRun" do
-    suite = FuzzBert::AutoRun::TEST_CASES
-    suite.size.should == 1
-    FuzzBert::Executor.new(suite, pool_size: 1, limit: 1, handler: handler).run
-    called.should == true
+  context "with no test" do
+    it "raises an error when executed" do
+      FuzzBert::AutoRun::TEST_CASES.should be_empty
+      -> { FuzzBert::AutoRun.run }.should raise_error
+    end
   end
 
 end
 
-

data/spec/dsl_spec.rb

@@ -84,5 +84,48 @@ describe FuzzBert::TestSuite do
     end
   end
 
+  it "raises an error when no block is given" do
+    -> { FuzzBert::TestSuite.create "test" }.should raise_error
+  end
+
+  it "raises an error when the deploy block is missing" do
+    lambda do
+      FuzzBert::TestSuite.create "test" do
+          data("1") { FuzzBert::Generators.random }
+      end.should raise_error
+    end
+  end
+
+  it "raises an error when the data blocks are missing" do
+    lambda do
+      FuzzBert::TestSuite.create "test" do
+          deploy { |data| data }
+      end.should raise_error
+    end
+  end
+
+  describe "deploy" do
+    it "raises an error when no block is given" do
+      lambda do
+        FuzzBert::TestSuite.create "test" do
+          deploy
+
+          data("1") { FuzzBert::Generators.random }
+        end
+      end.should raise_error
+    end
+  end
+
+  describe "data" do
+    it "raises an error when no block is given" do
+      lambda do
+        FuzzBert::TestSuite.create "test" do
+          deploy { |data| data }
+          data("1")
+        end
+      end.should raise_error
+    end
+  end
+
 end