fuzzbert 1.0.0

data/lib/fuzzbert/generation.rb

@@ -0,0 +1,8 @@
+
+module FuzzBert::Generation
+
+  def generator
+    -> { to_data }
+  end
+
+end

data/lib/fuzzbert/generator.rb

@@ -0,0 +1,18 @@
+
+class FuzzBert::Generator
+  include FuzzBert::Generation
+
+  attr_reader :description
+
+  def initialize(desc, generator=nil, &blk)
+    @description = desc
+    @generator = generator || blk
+    raise RuntimeError.new("No generator given") unless @generator
+  end
+
+  def to_data
+    @generator.call
+  end
+
+end
+

data/lib/fuzzbert/generators.rb

@@ -0,0 +1,70 @@
+require 'base64'
+
+module FuzzBert::Generators
+
+  class << self
+    
+    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_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_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 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
+
+    private
+
+    def hex_len(len)
+      len / 2
+    end
+
+    def b64_len(len)
+      len * 3 / 4
+    end
+
+    def random_bytes(limit)
+      len = FuzzBert::PRNG.rand(1..limit)
+      yield FuzzBert::PRNG.bytes(len)
+    end
+
+    def random_bytes_fixlen(len)
+      yield FuzzBert::PRNG.bytes(len)
+    end
+
+  end
+
+end

data/lib/fuzzbert/mutator.rb

@@ -0,0 +1,19 @@
+
+class FuzzBert::Mutator < FuzzBert::Generator
+
+  def initialize(value)
+    orig = value.dup
+    orig.force_encoding(Encoding::BINARY)
+    super("Mutator") do
+      #select a byte
+      i = FuzzBert::PRNG.rand(value.size)
+      old = orig[i].ord
+      #map a random value from 0..254 to 0..255 excluding the current value
+      b = FuzzBert::PRNG.rand(255)
+      b = b < old ? b : b + 1
+      orig.dup.tap { |s| s.setbyte(i, b) }
+    end
+  end
+
+end
+

data/lib/fuzzbert/rake_task.rb

@@ -0,0 +1,81 @@
+require 'fuzzbert'
+require 'rake'
+require 'rake/tasklib'
+
+class FuzzBert::RakeTask < ::Rake::TaskLib
+  include ::Rake::DSL if defined?(::Rake::DSL)
+
+  # Name of task.
+  #
+  # default:
+  #   :fuzz
+  attr_accessor :name
+
+  # Glob pattern to match files.
+  #
+  # default:
+  #   'fuzz/**/fuzz_*.rb'
+  attr_accessor :pattern
+
+  # Command line options to pass to ruby.
+  #
+  # default:
+  #   nil
+  attr_accessor :ruby_opts
+
+  # Path to FuzzBert
+  #
+  # default:
+  #   'fuzzbert'
+  attr_accessor :fuzzbert_path
+
+  # Command line options to pass to fuzzbert.
+  #
+  # default:
+  #   nil
+  attr_accessor :fuzzbert_opts
+
+  def initialize(*args)
+    #configure the rake task
+    setup_ivars(args)
+    yield self if block_given?
+
+    desc "Run FuzzBert random test suite" unless ::Rake.application.last_comment
+
+    task name do
+      run_task
+    end
+  end
+
+  def setup_ivars(*args)
+    @name = args.shift || :fuzz
+    @ruby_opts, @fuzzbert_opts = nil, nil
+    @fuzzbert_path = 'fuzzbert'
+    @pattern = 'fuzz/**/fuzz_*.rb'
+  end
+
+  def run_task
+    begin
+      system(command)
+    rescue
+      #silent, user could have interrupted a permanent session
+    end
+  end
+
+  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 blank
+    lambda {|s| s.nil? || s == ""}
+  end
+end
+

data/lib/fuzzbert/template.rb

@@ -0,0 +1,154 @@
+require 'stringio'
+
+class FuzzBert::Template
+  include FuzzBert::Generation
+
+  def initialize(template)
+    @template = Parser.new(template).parse
+    @callbacks = {}
+  end
+
+  def set(name, &blk)
+    @callbacks[name] = blk
+  end
+
+  def to_data
+    "".tap do |buf|
+      @template.each { |t| buf << t.to_data(@callbacks) }
+    end
+  end
+
+  private
+
+  class Parser
+    
+    def initialize(template)
+      @io = StringIO.new(template)
+      @template = []
+    end
+
+    def parse
+      @state = determine_state 
+      while token = parse_token
+        @template << token
+      end
+      @template
+    end
+
+    def parse_token
+      case @state
+      when :TEXT
+        parse_text
+      when :IDENTIFIER
+        parse_identifier
+      else
+        nil
+      end
+    end
+
+    def determine_state
+      begin
+        @buf = @io.readchar
+
+        case @buf
+        when '$'
+          c = @io.readchar
+          if c == "{"
+            @buf = ""
+            :IDENTIFIER
+          else
+            @buf << c
+            :TEXT
+          end
+        when '\\'
+          @buf = ""
+          :TEXT
+        else
+          :TEXT
+        end
+      rescue EOFError
+        :EOF
+      end
+    end
+
+    def parse_identifier
+      name = ""
+      begin
+        until (c = @io.readchar) == '}'
+          name << c
+        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")
+      end
+    end
+
+    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
+      rescue EOFError
+        @state = :EOF
+        Text.new(text)
+      end
+    end
+
+    def parse_escape
+      begin
+        @io.readchar
+      rescue EOFError
+        '\\'
+      end
+    end
+
+  end
+
+  class Text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_data(callbacks)
+      @text
+    end
+
+  end
+
+  class Identifier
+
+    def initialize(name)
+      @name = name.to_sym
+    end
+
+    def to_data(callbacks)
+      callbacks[@name].call
+    end
+
+  end
+
+end
+

data/lib/fuzzbert/test.rb

@@ -0,0 +1,13 @@
+
+class FuzzBert::Test
+
+  def initialize(runner)
+    @runner = runner
+  end
+
+  def run(data)
+    @runner.call data
+  end
+
+end
+

data/lib/fuzzbert/test_suite.rb

@@ -0,0 +1,25 @@
+
+class FuzzBert::TestSuite
+
+  attr_reader :description, :test, :generators
+
+  def initialize(desc)
+    @description = desc
+    @generators = []
+  end
+
+  def deploy(&blk)
+    @test = FuzzBert::Test.new(blk)
+  end
+
+  def data(desc, &blk)
+    @generators << FuzzBert::Generator.new(desc, blk.call)
+  end
+
+  def self.create(desc, &blk)
+    obj = self.new(desc)
+    obj.instance_eval(&blk) if blk
+    obj
+  end
+ 
+end

data/lib/fuzzbert/version.rb

@@ -0,0 +1,4 @@
+module FuzzBert
+  VERSION = "1.0.0"
+end
+

data/spec/autorun_spec.rb

@@ -0,0 +1,39 @@
+require 'rspec'
+require 'fuzzbert'
+
+describe FuzzBert::AutoRun do
+
+  let(:handler) do
+    c = Class.new
+    def c.handle(id, data, pid, status)
+      raise RuntimeError.new
+    end
+    c
+  end
+
+  value = "test"
+  called = false
+
+  fuzz "autorun" do
+
+    deploy do |data|
+      data.should == value
+    end
+
+    data "1" do
+      called = true
+      -> { value }
+    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
+  end
+
+end
+
+

data/spec/dsl_spec.rb

@@ -0,0 +1,88 @@
+require 'rspec'
+require 'fuzzbert'
+
+describe FuzzBert::TestSuite do
+  describe "fuzz" do
+    context "with one generator" do
+      let(:suite) do
+        FuzzBert::TestSuite.create "test" do
+          deploy { |data| data }
+
+          data("1") { FuzzBert::Generators.random }
+        end
+      end
+
+      it "returns an instance of TestSuite" do
+        suite.should be_an_instance_of(FuzzBert::TestSuite)
+        suite.description.should == "test"
+      end
+
+      it "defines a test that executes the block in deploy" do
+        suite.test.should_not be_nil
+        suite.test.should be_an_instance_of(FuzzBert::Test)
+        ["a", 10, true, Object.new].each { |o| suite.test.run(o).should == o }
+      end
+
+      it "defines one generator" do
+        suite.generators.size.should == 1
+        gen = suite.generators.first
+        gen.should be_an_instance_of(FuzzBert::Generator)
+        gen.description.should == "1"
+        gen.to_data.should be_an_instance_of(String)
+      end
+
+    end
+
+    context "with two generators" do
+      let(:suite) do
+        FuzzBert::TestSuite.create "test" do
+          deploy { |data| data }
+
+          data("1") { FuzzBert::Generators.fixed(1) }
+          data("2") { FuzzBert::Generators.fixed(2) }
+        end
+      end
+
+      it "defines two generators" do
+        suite.generators.size.should == 2
+        gen = suite.generators.first
+        gen.should be_an_instance_of(FuzzBert::Generator)
+        gen.description.should == "1"
+        gen.to_data.should == 1
+
+        gen = suite.generators[1]
+        gen.should be_an_instance_of(FuzzBert::Generator)
+        gen.description.should == "2"
+        gen.to_data.should == 2
+      end
+
+    end
+
+    context "with complex data" do
+      let(:suite) do
+        FuzzBert::TestSuite.create "test" do
+          deploy { |data| data }
+
+          data "1" do
+            c = FuzzBert::Container.new
+            c << FuzzBert::Generators.fixed("1")
+            c << FuzzBert::Generators.fixed("2")
+            c << FuzzBert::Generators.fixed("3")
+            c.generator
+          end
+
+        end
+      end
+
+      it "applies the container generators in sequence" do
+        suite.generators.size.should == 1
+        gen = suite.generators.first
+        gen.should be_an_instance_of(FuzzBert::Generator)
+        gen.description.should == "1"
+        gen.to_data.should == "123"
+      end
+    end
+  end
+
+end
+