flores 0.0.1 → 0.0.2

data/Makefile

@@ -3,25 +3,6 @@ VERSION=$(shell awk -F\" '/spec.version/ { print $$2 }' $(GEMSPEC))
 NAME=$(shell awk -F\" '/spec.name/ { print $$2 }' $(GEMSPEC))
 GEM=$(NAME)-$(VERSION).gem
 
-.PHONY: test
-test:
-	sh notify-failure.sh ruby test/all.rb
-
-.PHONY: testloop
-testloop:
-	while true; do \
-		$(MAKE) test; \
-		$(MAKE) wait-for-changes; \
-	done
-
-.PHONY: serve-coverage
-serve-coverage:
-	cd coverage; python -mSimpleHTTPServer
-
-.PHONY: wait-for-changes
-wait-for-changes:
-	-inotifywait --exclude '\.swp' -e modify $$(find $(DIRS) -name '*.rb'; find $(DIRS) -type d)
-
 .PHONY: package
 package: | $(GEM)
 

data/examples/analyze_number.rb

@@ -1,3 +1,20 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
 require "randomized"
 require "rspec/stress_it"
 

data/examples/socket_acceptance_spec.rb

@@ -1,3 +1,20 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
 require "randomized"
 require "socket"
 require "rspec/stress_it"
@@ -6,6 +23,10 @@ RSpec.configure do |c|
   c.extend RSpec::StressIt
 end
 
+# A factory for encapsulating behavior of a tcp server and client for the
+# purposes of testing.
+#
+# This is probably not really a "factory" in a purist-sense, but whatever.
 class TCPIntegrationTestFactory
   def initialize(port)
     @listener = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
@@ -33,7 +54,6 @@ class TCPIntegrationTestFactory
 
     @client.syswrite(text)
     @client.close
-    #expect(client.syswrite(text)).to(be == text.bytesize)
     server.read
   ensure
     @client.close unless @client.closed?
@@ -42,32 +62,12 @@ class TCPIntegrationTestFactory
 end
 
 describe "TCPServer+TCPSocket" do
-  let(:port) { Randomized.number(1024..65535) }
-  let(:text) { Randomized.text(1..10000) }
+  let(:port) { Randomized.integer(1024..65535) }
+  let(:text) { Randomized.text(1..2000) }
   subject { TCPIntegrationTestFactory.new(port) }
-
-  #describe "using before/after and stress_it2" do
-    #before do
-      #begin
-        #subject.setup
-      #rescue Errno::EADDRINUSE
-        ## We chose a random port that was already in use, let's skip this test.
-        #skip("Port #{port} is in use by another process, skipping")
-      #end
-    #end
-
-    #after do
-      #subject.teardown
-    #end
-
-    #stress_it2 "should send data correctly" do
-      #received = subject.send_and_receive(text)
-      #expect(received).to(be == text)
-    #end
-  #end
   
   describe "using stress_it" do
-    stress_it "should send data correctly" do
+    analyze_it "should send data correctly", [:port, :text] do
       begin
         subject.setup
       rescue Errno::EADDRINUSE
@@ -76,6 +76,7 @@ describe "TCPServer+TCPSocket" do
 
       begin
         received = subject.send_and_receive(text)
+        expect(received.encoding).to(be == text.encoding)
         expect(received).to(be == text)
       ensure
         subject.teardown

data/examples/socket_analyze_spec.rb

@@ -1,3 +1,20 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
 require "randomized"
 require "socket"
 require "rspec/stress_it"
@@ -12,7 +29,7 @@ describe TCPServer do
   after { socket.close }
 
   context "on a random port" do
-    let(:port) { Randomized.number(-100000..100000) }
+    let(:port) { Randomized.integer(-100_000..100_000) }
     analyze_it "should bind successfully", [:port] do
       socket.bind(sockaddr)
       expect(socket.local_address.ip_port).to(be == port)

data/examples/socket_stress_spec.rb

@@ -1,3 +1,20 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
 require "randomized"
 require "socket"
 require "rspec/stress_it"
@@ -13,7 +30,7 @@ describe TCPServer do
     proc do |m, *args|
       begin
         m.call(*args)
-      rescue Errno::EADDRINUSE
+      rescue Errno::EADDRINUSE # rubocop:disable Lint/HandleExceptions
         # ignore
       end
     end
@@ -24,14 +41,14 @@ describe TCPServer do
   end
 
   context "on privileged ports" do
-    let(:port) { Randomized.number(1..1023) }
+    let(:port) { Randomized.integer(1..1023) }
     stress_it "should raise Errno::EACCESS" do
       expect { socket.bind(sockaddr) }.to(raise_error(Errno::EACCES))
     end
   end
 
   context "on unprivileged ports" do
-    let(:port) { Randomized.number(1025..65535) }
+    let(:port) { Randomized.integer(1025..65535) }
     stress_it "should bind on a port" do
       # EADDRINUSE is expected since we are picking ports at random
       # Let's ignore this specific exception

data/flores.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |spec|
-  files = %x{git ls-files}.split("\n")
+  files = %x(git ls-files).split("\n")
 
   spec.name = "flores"
-  spec.version = "0.0.1"
+  spec.version = "0.0.2"
   spec.summary = "Fuzz, randomize, and stress your tests"
   spec.description = <<-DESCRIPTION
     Add fuzzing, randomization, and stress to your tests.
@@ -20,4 +20,3 @@ Gem::Specification.new do |spec|
   spec.authors = ["Jordan Sissel"]
   spec.email = ["jls@semicomplete.com"]
 end
-

data/lib/randomized.rb

@@ -1,5 +1,42 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
+
 # A collection of methods intended for use in randomized testing.
 module Randomized
+  # A selection of UTF-8 characters
+  #
+  # I'd love to generate this, but I don't yet know enough about how unicode
+  # blocks are allocated to do that. For now, hardcode a set of possible
+  # characters.
+  CHARACTERS = [
+    # Basic Latin
+    *(32..126).map(&:chr),
+
+    # hand-selected CJK Unified Ideographs Extension A
+    "㐤", "㐨", "㐻", "㑐",
+
+    # hand-selected Hebrew
+    "א", "ב", "ג", "ד", "ה",
+
+    # hand-selected Cyrillic
+    "Є", "Б", "Р", "н", "я"
+  ]
+
   # Generates text with random characters of a given length (or within a length range)
   #
   # * The length can be a number or a range `x..y`. If a range, it must be ascending (x < y)
@@ -8,30 +45,23 @@ module Randomized
   # @param length [Fixnum or Range] the length of text to generate
   # @return [String] the 
   def self.text(length)
-    if length.is_a?(Range)
-      raise ArgumentError, "Requires ascending range, you gave #{length}." if length.end < length.begin
-      raise ArgumentError, "A negative length is not permitted, I received range #{length}" if length.begin < 0
-
-      length = integer(length)
-    else
-      raise ArgumentError, "A negative length is not permitted, I received #{length}" if length < 0
-    end
+    return text_range(length) if length.is_a?(Range)
 
+    raise ArgumentError, "A negative length is not permitted, I received #{length}" if length < 0
     length.times.collect { character }.join
   end # def text
 
+  def self.text_range(range)
+    raise ArgumentError, "Requires ascending range, you gave #{range}." if range.end < range.begin
+    raise ArgumentError, "A negative range values are not permitted, I received range #{range}" if range.begin < 0
+    text(integer(range))
+  end
+
   # Generates a random character (A string of length 1)
   #
   # @return [String]
   def self.character
-    # TODO(sissel): Add support to generate valid UTF-8. I started reading
-    # Unicode 7 (http://www.unicode.org/versions/Unicode7.0.0/) and after much
-    # reading, I realized I wasn't in my house anymore but had somehow lost
-    # track of time and was alone in a field. Civilization had fallen centuries
-    # ago. :P
-    
-    # Until UTF-8 is supported, just return a random lower ASCII character
-    integer(32..127).chr
+    return CHARACTERS[integer(0...CHARACTERS.length)]
   end # def character
 
   # Return a random integer value within a given range.
@@ -64,4 +94,4 @@ module Randomized
       integer(range).times
     end
   end # def iterations
-end
+end # module Randomized

data/lib/rspec/stress_it.rb

@@ -1,6 +1,31 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 # encoding: utf-8
 require "rspec/core"
 
+# RSpec helpers for stress testing examples
+#
+# Setting it up in rspec:
+#
+#     RSpec.configure do |c|
+#       c.extend RSpec::StressIt
+#     end
+#
+# TODO(sissel): Show an example of stress_it and analyze_it
 module RSpec::StressIt
   DEFAULT_ITERATIONS = 1..5000
 
@@ -10,11 +35,11 @@ module RSpec::StressIt
   # of APIs to help find edge cases and weird behavior.
   #
   # The default number of iterations is randomly selected between 1 and 1000 inclusive
-  def stress_it(name, options={}, &block)
-    __iterations = Randomized.iterations(options.delete(:stress_iterations) || DEFAULT_ITERATIONS)
+  def stress_it(name, options = {}, &block)
+    stress__iterations = Randomized.iterations(options.delete(:stress_iterations) || DEFAULT_ITERATIONS)
     it(name, options) do
       # Run the block of an example many times
-      __iterations.each do |i|
+      stress__iterations.each do
         # Run the block within 'it' scope
         instance_eval(&block)
 
@@ -34,10 +59,10 @@ module RSpec::StressIt
   #     it "should be less than 100" do
   #       expect(number).to(be < 100)
   #     end
-  def stress_it2(name, options={}, &block)
-    __iterations = Randomized.iterations(options.delete(:stress_iterations) || DEFAULT_ITERATIONS)
-    __iterations.each do |i|
-      it(example_name + " [#{i}]", *args) do
+  def stress_it2(name, options = {}, &block)
+    stress__iterations = Randomized.iterations(options.delete(:stress_iterations) || DEFAULT_ITERATIONS)
+    stress__iterations.each do |i|
+      it(name + " [#{i}]", *args) do
         instance_eval(&block)
       end # it ...
     end # .times
@@ -57,18 +82,17 @@ module RSpec::StressIt
   #     end
   #
   # Example report:
-  def analyze_it(name, variables, &block)
+  def analyze_it(name, variables, &block) # rubocop:disable Metrics/AbcSize
     it(name) do
-      results = Hash.new { |h,k| h[k] = [] }
-      iterations = Randomized.iterations(DEFAULT_ITERATIONS)
-      iterations.each do |i|
+      results = Hash.new { |h, k| h[k] = [] }
+      Randomized.iterations(DEFAULT_ITERATIONS).each do
         state = Hash[variables.collect { |l| [l, __send__(l)] }]
         begin
           instance_eval(&block)
           results[:success] << [state, nil]
         rescue => e
           results[e.class] << [state, e]
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           results[e.class] << [state, e]
         end
 
@@ -76,20 +100,19 @@ module RSpec::StressIt
         __memoized.clear
       end
 
-      if results[:success] != iterations
-        raise Analysis.new(results)
-      end
+      raise StandardError, Analysis.new(results) if results.any? { |k, _| k != :success }
     end
-  end
+  end # def analyze_it
 
+  # A formatter to show analysis of an `analyze_it` example. 
   class Analysis < StandardError
     def initialize(results)
       @results = results
-    end
+    end # def initialize
 
     def total
-      @results.reduce(0) { |m, (k,v)| m + v.length }
-    end
+      @results.reduce(0) { |m, (_, v)| m + v.length }
+    end # def total
 
     def success_count
       if @results.include?(:success)
@@ -97,33 +120,54 @@ module RSpec::StressIt
       else
         0
       end
-    end
+    end # def success_count
 
     def percent(count)
       return (count + 0.0) / total
-    end
+    end # def percent
 
     def percent_s(count)
-      return sprintf("%.2f%%", percent(count) * 100)
-    end
+      return format("%.2f%%", percent(count) * 100)
+    end # def percent_s
 
     def to_s
       # This method is crazy complex for a formatter. Should refactor this significantly.
       report = ["#{percent_s(success_count)} tests successful of #{total} tests"]
-      if success_count < total
-        report << "Failure analysis:"
-        report += @results.sort_by { |k,v| -v.length }.reject { |k,v| k == :success }.collect do |k, v|
-          sample = v.sample(5).collect { |v| v.first }.join(", ")
-          [ 
-            "  #{percent_s(v.length)} -> [#{v.length}] #{k}",
-            "    Sample exception:",
-            v.sample(1).first[1].to_s.gsub(/^/, "      "),
-            "    Samples causing #{k}:",
-            *v.sample(5).collect { |state, _exception| "      #{state}" }
-          ]
-        end.flatten
-      end
+      report += failure_summary if success_count < total
       report.join("\n")
-    end
-  end
+    end # def to_s
+
+    # TODO(sissel): All these report/summary/to_s things are an indication that the
+    # report formatting belongs in a separate class.
+    def failure_summary
+      report = ["Failure analysis:"]
+      report += @results.sort_by { |_, v| -v.length }.collect do |group, instances|
+        next if group == :success
+        error_report(group, instances)
+      end.reject(&:nil?).flatten
+      report
+    end # def failure_summary
+
+    def error_report(error, instances)
+      report = error_summary(error, instances)
+      report += error_sample_states(error, instances) if instances.size > 1
+      report
+    end # def error_report
+
+    def error_summary(error, instances)
+      sample = instances.sample(1)
+      [ 
+        "  #{percent_s(instances.length)} -> [#{instances.length}] #{error}",
+        "    Sample exception for #{sample.first[0]}",
+        sample.first[1].to_s.gsub(/^/, "      ")
+      ]
+    end # def error_summary
+
+    def error_sample_states(error, instances)
+      [ 
+        "    Samples causing #{error}:",
+        *instances.sample(5).collect { |state, _exception| "      #{state}" }
+      ]
+    end # def error_sample_states
+  end # class Analysis
 end # module RSpec::StressIt

data/spec/randomized_spec.rb

@@ -1,3 +1,20 @@
+# This file is part of ruby-flores.
+# Copyright (C) 2015 Jordan Sissel
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+# 
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
 require "randomized"
 require "rspec/stress_it"
 
@@ -5,10 +22,19 @@ RSpec.configure do |c|
   c.extend RSpec::StressIt
 end
 
+shared_examples_for String do |variables|
+  analyze_it "should be a String", variables do
+    expect(subject).to(be_a(String))
+  end
+  analyze_it "have valid encoding", variables do
+    expect(subject).to(be_valid_encoding)
+  end
+end
+
 describe Randomized do
   describe "#text" do
     context "with no arguments" do
-      it "should raise ArgumentError" do
+      stress_it "should raise ArgumentError" do
         expect { subject.text }.to(raise_error(ArgumentError))
       end
     end
@@ -18,15 +44,15 @@ describe Randomized do
 
       context "that is positive" do
         let(:length) { rand(1..1000) }
-        stress_it "should give a string with that length" do
-          expect(subject).to(be_a(String))
+        it_behaves_like String, [:length]
+        analyze_it "has correct length", [:length] do
           expect(subject.length).to(eq(length))
         end
       end
 
       context "that is negative" do
         let(:length) { -1 * rand(1..1000) }
-        stress_it "should raise ArgumentError" do
+        analyze_it "should raise ArgumentError", [:length] do
           expect { subject }.to(raise_error(ArgumentError))
         end
       end
@@ -38,16 +64,17 @@ describe Randomized do
       subject { described_class.text(range) }
 
       context "that is ascending" do
-        let(:range) { start .. (start + length) }
-        stress_it "should give a string within that length range" do
+        let(:range) { start..(start + length) }
+        it_behaves_like String, [:range]
+        analyze_it "should give a string within that length range", [:range] do
           expect(subject).to(be_a(String))
           expect(range).to(include(subject.length))
         end
       end
 
       context "that is descending" do
-        let(:range) { start .. (start - length) }
-        stress_it "should raise ArgumentError" do
+        let(:range) { start..(start - length) }
+        analyze_it "should raise ArgumentError", [:range] do
           expect { subject }.to(raise_error(ArgumentError))
         end
       end
@@ -56,40 +83,50 @@ describe Randomized do
 
   describe "#character" do
     subject { described_class.character }
-    stress_it "returns a string of length 1" do
+    it_behaves_like String, [:subject]
+    analyze_it "has length == 1", [:subject] do
       expect(subject.length).to(be == 1)
     end
   end
 
-  shared_examples_for "random numbers within a range" do
-    let(:start) { Randomized.integer(-100000 .. 100000) }
-    let(:length) { Randomized.integer(1 .. 100000) }
-    let(:range) { start .. (start + length) }
+  shared_examples_for Numeric do |type|
+    let(:start) { Randomized.integer(-100_000..100_000) }
+    let(:length) { Randomized.integer(1..100_000) }
+    let(:range) { start..(start + length) }
 
-    stress_it "should be a Numeric" do
-      expect(subject).to(be_a(Numeric))
+    analyze_it "should be a #{type}", [:range] do
+      expect(subject).to(be_a(type))
     end
 
-    stress_it "should be within the bounds of the given range" do
+    analyze_it "should be within the bounds of the given range", [:range] do
       expect(range).to(include(subject))
     end
   end
 
   describe "#integer" do
-    it_behaves_like "random numbers within a range" do
+    it_behaves_like Numeric, Fixnum do
       subject { Randomized.integer(range) }
-      stress_it "is a Fixnum" do
-        expect(subject).to(be_a(Fixnum))
-      end
     end
   end
+
   describe "#number" do
-    it_behaves_like "random numbers within a range" do
+    it_behaves_like Numeric, Float do
       subject { Randomized.number(range) }
+    end
+  end
 
-      stress_it "is a Float" do
-        expect(subject).to(be_a(Float))
-      end
+  describe "#iterations" do
+    let(:start) { Randomized.integer(1..100_000) }
+    let(:length) { Randomized.integer(1..100_000) }
+    let(:range) { start..(start + length) }
+    subject { Randomized.iterations(range) }
+
+    analyze_it "should return an Enumerable", [:range] do
+      expect(subject).to(be_a(Enumerable))
+    end
+
+    analyze_it "should have a size within the expected range", [:range] do
+      expect(range).to(include(subject.size))
     end
   end
 end 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flores
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jordan Sissel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-19 00:00:00.000000000 Z
+date: 2015-02-21 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Add fuzzing, randomization, and stress to your tests.
@@ -23,8 +23,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
+- LICENSE.txt
 - Makefile
 - examples/analyze_number.rb
 - examples/socket_acceptance_spec.rb