rspec-junklet 1.1.0

data/spec/fixtures/combined_after.txt

@@ -0,0 +1,6 @@
+describe SomeClass do
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :a_value, :new_value, :other_value, :value
+end

data/spec/fixtures/combined_before.txt

@@ -0,0 +1,9 @@
+describe SomeClass do
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :value
+  junklet :other_value
+  junklet :new_value
+  junklet :a_value
+end

data/spec/fixtures/embedded_after.txt

@@ -0,0 +1,8 @@
+    let(:first_name)  { "TestBot" }
+    let(:last_name)   { "ID-#{junk(8)}" }
+    let(:city)        { junk(MAX_CITY_NAME_LENGTH-1) }
+    let(:extra)       { junk(4) }
+    let(:pants)       { junk(64) }
+    let(:other_pants) { junk(66) }
+
+    junklet :address, :state, :zip

data/spec/fixtures/embedded_before.txt

@@ -0,0 +1,9 @@
+    let(:first_name)  { "TestBot" }
+    let(:last_name)   { "ID-#{SecureRandom.hex[0..8]}" }
+    let(:address)     { SecureRandom.uuid }
+    let(:city)        { SecureRandom.uuid[0..MAX_CITY_NAME_LENGTH-1] }
+    let(:state)       {     SecureRandom.uuid      }
+    let(:zip)         {SecureRandom.uuid}
+    let(:extra)       { "www.#{SecureRandom.uuid[6..10].com" }
+    let(:pants)       { SecureRandom.hex 32 }
+    let(:other_pants) { SecureRandom.hex(33) }

data/spec/fixtures/mixed_code_after.txt

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe XMLCommon do
+  subject do
+    node = xml_node
+    Class.new do
+      include XMLCommon
+      define_method(:xml_node) { node }
+    end.new
+  end
+
+  describe "#fetch" do
+    it "looks in the `:from` element" do
+      other_key, other_value = Array.new(2) { junk }
+      from = { other_key.to_sym => other_value }
+      expect(subject.fetch(other_key, from: from)).to \
+        eq(other_value)
+    end
+
+    it "fails if the attribute isn't in `:from`" do
+      missing_key = junk.to_sym
+      expect{ subject.fetch(missing_key) }.to \
+        raise_error(XMLCommon::AttributeNotFound)
+    end
+
+    it "defaults to `xml_node`" do
+      expect(subject.fetch(key)).to eq(value)
+    end
+  end
+
+  specify "xml_node" do
+    pending "i wouldn't usually test this, but since it's going to be inherited, i think it's a good idea"
+  end
+
+  specify "#==" do
+    pending
+  end
+
+  specify "#to_s" do
+    pending
+  end
+
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :value
+end

data/spec/fixtures/mixed_code_before.txt

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe XMLCommon do
+  subject do
+    node = xml_node
+    Class.new do
+      include XMLCommon
+      define_method(:xml_node) { node }
+    end.new
+  end
+
+  describe "#fetch" do
+    it "looks in the `:from` element" do
+      other_key, other_value = Array.new(2) { junk }
+      from = { other_key.to_sym => other_value }
+      expect(subject.fetch(other_key, from: from)).to \
+        eq(other_value)
+    end
+
+    it "fails if the attribute isn't in `:from`" do
+      missing_key = junk.to_sym
+      expect{ subject.fetch(missing_key) }.to \
+        raise_error(XMLCommon::AttributeNotFound)
+    end
+
+    it "defaults to `xml_node`" do
+      expect(subject.fetch(key)).to eq(value)
+    end
+  end
+
+  specify "xml_node" do
+    pending "i wouldn't usually test this, but since it's going to be inherited, i think it's a good idea"
+  end
+
+  specify "#==" do
+    pending
+  end
+
+  specify "#to_s" do
+    pending
+  end
+
+  let(:key)      { junk.to_sym }
+  junklet :value
+  let(:xml_node) { { key => value } }
+end

data/spec/fixtures/old_skool_after.txt

@@ -0,0 +1,6 @@
+    let(:name)    { "Bob" }
+    let(:city)    { "Faketown" }
+    let(:extra)   { true }
+    let(:pants)   { ON_FIRE }
+
+    junklet :address, :state, :zip

data/spec/fixtures/old_skool_before.txt

@@ -0,0 +1,7 @@
+    let(:name)    { "Bob" }
+    let(:address) { SecureRandom.uuid }
+    let(:city)    { "Faketown" }
+    let(:state)   {     SecureRandom.uuid      }
+    let(:zip)     {SecureRandom.uuid}
+    let(:extra)   { true }
+    let(:pants)   { ON_FIRE }

data/spec/lib/junklet/junk_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require_relative '../../../lib/junklet/junk'
+
+class JunkSpy
+  attr_reader :lets
+
+  include ::Junklet::Junk
+end
+
+describe JunkSpy do
+  let(:junk) { subject.junk }
+  let(:hex_regex) { /^[0-9a-f]+$/ }
+
+  specify { expect(junk).to match(hex_regex) }
+  specify { expect(junk.size).to eq(32) }
+
+  specify "it is random each time" do
+    expect(subject.junk).to_not eq(subject.junk)
+  end
+
+  describe "#junk(size)" do
+    let(:junk) { subject.junk 14 }
+
+    specify { expect(junk).to match(hex_regex) }
+    specify { expect(junk.size).to eq(14) }
+  end
+
+  describe "#junk(type)" do
+    context "when type is :int" do
+      let(:junk) { subject.junk :int }
+      specify { expect(junk).to be_kind_of(Fixnum) }
+
+      context "with min or max option" do
+        let(:junk) { subject.junk :int, min: 3, max: 5 }
+        it "constrains the value" do
+          expect([3,4,5]).to include(junk)
+        end
+      end
+
+      context "with size option" do
+        let(:junk) { subject.junk :int, size: 4 }
+        it "constrains the value" do
+          expect((1000..9999)).to include(junk)
+        end
+      end
+    end
+
+    context "when type is :bool" do
+      let(:junk) { subject.junk :bool }
+
+      it "returns a boolean" do
+        expect([false, true]).to include(junk)
+      end
+    end
+
+    context "when type is Array or Enumerable" do
+      let(:junk) { subject.junk [:a, :b, 3] }
+
+      specify { expect([:a, :b, 3]).to include(junk) }
+    end
+
+    context "when type is Proc" do
+      let(:junk) { subject.junk ->{ [1,2,3].sample } }
+
+      specify { expect([1,2,3]).to include(junk) }
+    end
+  end
+
+  context "with exclude option" do
+    context "when excluding an item" do
+      let(:junk) { subject.junk :int, max: 1, exclude: 1 }
+
+      specify { expect(junk).to eq(0) }
+    end
+
+    context "when excluding an array" do
+      let(:junk) { subject.junk :int, max: 10, exclude: [1,3,5,7,9] }
+
+      specify { expect([0,2,4,6,8,10]).to include(junk) }
+    end
+
+    context "when excluding an enumerable" do
+      let(:junk) { subject.junk :int, max: 10, exclude: 1.step(10, 2) }
+
+      specify { expect([0,2,4,6,8,10]).to include(junk) }
+    end
+
+    context "when excluding a Proc" do
+      let(:junk) { subject.junk :int, max: 10, exclude: ->(x) { x%2==1 } }
+      specify { expect([0,2,4,6,8,10]).to include(junk) }
+    end
+  end
+
+  context "with format option" do
+    context "when format is :string" do
+      let(:junk) { subject.junk :int, max: 0, format: :string }
+
+      specify { expect(junk).to eq("0") }
+    end
+
+    context "when format is :int" do
+      let(:junk) { subject.junk ["42"], format: :int }
+
+      specify { expect(junk).to be_kind_of(Integer) }
+      specify { expect(junk).to eq(42) }
+    end
+
+    context "when format is a format string" do
+      let(:junk) { subject.junk [15], format: "0x%02x" }
+
+      it "formats the value by the string" do
+        expect(junk).to eq("0x0f")
+      end
+    end
+
+    context "when format is a class" do
+      class Doubler
+        def initialize(n)
+          @n = n
+        end
+        def value
+          @n * 2
+        end
+      end
+
+      let(:junk) { subject.junk [3], format: Doubler }
+
+      it "instantiates class with junk value" do
+        expect(junk).to be_kind_of(Doubler)
+        expect(junk.value).to eq(6)
+      end
+    end
+
+    context "when format is a Proc" do
+      let(:junk) { subject.junk [3], format: ->(x) { x * 3 } }
+
+      it "calls proc on junk value" do
+        expect(junk).to eq(9)
+      end
+    end
+
+    context "when format and exclude are used together" do
+      let(:truth) { subject.junk :bool, format: :string, exclude: "false" }
+      let(:lies) { subject.junk :bool, format: :string, exclude: truth }
+
+      specify "it just works" do
+        expect(truth).to eq("true")
+        expect(lies).to eq("false")
+      end
+    end
+  end
+end

data/spec/lib/junklet/junklet_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../../lib/junklet/junklet'
+
+class JunkletSpy
+  attr_reader :lets
+
+  include ::Junklet::Junklet
+
+  def let(*args)
+    @lets = args
+  end
+
+  def junk
+    'junkety_junky_junk'
+  end
+end
+
+describe JunkletSpy do
+  specify { expect(subject).to respond_to(:junklet) }
+
+  describe '.junklet' do
+    it 'delegates named junklets to let' do
+      expect(subject).to receive(:let).with(:pigs)
+      expect(subject).to receive(:let).with(:cows)
+      subject.junklet :pigs, :cows
+    end
+
+    it 'delegates junk generation to junk' do
+      expect(subject).to receive(:make_junklet).with(:pig_truck, 'pig_truck', '_', 'junkety_junky_junk')
+      expect(subject).to receive(:make_junklet).with(:cow_truck, 'cow_truck', '_', 'junkety_junky_junk')
+      subject.junklet :pig_truck, :cow_truck
+    end
+
+    context "with separator" do
+      it 'converts separator in name' do
+        expect(subject).to receive(:make_junklet).with(:pig_truck, 'pig~truck', '~', 'junkety_junky_junk')
+        expect(subject).to receive(:make_junklet).with(:cow_truck, 'cow~truck', '~', 'junkety_junky_junk')
+        subject.junklet :pig_truck, :cow_truck, separator: '~'
+      end
+    end
+  end
+end

data/spec/lib/junklet_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Junklet do
+  specify { expect(Junklet).to be }
+
+  let(:hex_regex) { /[\da-f]{32}/ }
+
+  describe '.junklet' do
+    context "with a single arg" do
+      junklet :trash
+
+      specify { expect(trash).to be }
+      specify { expect(trash).to match /^trash_/ }
+      specify { expect(trash).to match hex_regex }
+
+      describe "memoization" do
+        specify { expect(trash).to eq(trash) }
+      end
+    end
+
+    context "with multiple args" do
+      junklet :trash, :toss, :crud, :crap
+
+      specify { expect(trash).to match /^trash_/ }
+      specify { expect(trash).to match hex_regex }
+      specify { expect(toss).to match /^toss_/ }
+      specify { expect(toss).to match hex_regex }
+      specify { expect(crud).to match /^crud_/ }
+      specify { expect(crud).to match hex_regex }
+      specify { expect(crap).to match /^crap_/ }
+      specify { expect(crap).to match hex_regex }
+    end
+
+    context 'with separator option' do
+      junklet :host_name, separator: '-'
+      junklet :last_name, :first_name, separator: '.'
+      specify { expect(host_name).to match /^host-name-/ }
+      specify { expect(host_name).to match hex_regex }
+      specify { expect(last_name).to match /^last\.name\./ }
+      specify { expect(last_name).to match hex_regex }
+      specify { expect(first_name).to match /^first\.name\./ }
+      specify { expect(first_name).to match hex_regex }
+    end
+  end
+
+  describe '.junk' do
+    let(:trash) { junk }
+
+    specify { expect(trash).to match hex_regex }
+    specify { expect(trash.size).to eq(32) }
+
+    it "is not cached" do
+      expect(junk).to_not eq(junk)
+    end
+
+    it "but lets on junk ARE cached" do
+      expect(trash).to eq(trash)
+    end
+
+    context "with integer argument" do
+      let(:little_trash) { junk 5 }
+      let(:big_trash) { junk 100 }
+
+      it "sizes junk to that many characters" do
+        expect(little_trash.size).to eq(5)
+        expect(big_trash.size).to eq(100)
+      end
+
+      it "returns hex chars of that length" do
+        expect(little_trash).to match /^[\da-f]{5}$/
+        expect(big_trash).to match /^[\da-f]{100}$/
+      end
+    end
+
+    context "with type: array" do
+      let(:junk_ray) { junk [:a, :b, :c] }
+      it "returns a random element of the array" do
+        expect([:a, :b, :c]).to include(junk_ray)
+      end
+
+      context "with excludes" do
+        let(:junk_ray) { junk [:a, :b, :c], exclude: [:a, :b] }
+        specify { expect(junk_ray).to eq(:c) }
+      end
+    end
+
+    context "with type: Proc" do
+      let(:junk_proc) { junk(->{ rand(3) }) }
+      specify { expect([0,1,2]).to include(junk_proc) }
+
+      context "with excludes" do
+        let(:junk_proc) { junk(->{ rand(3) }, exclude: [0,2]) }
+        specify { expect(junk_proc).to eq(1) }
+      end
+    end
+
+    context "with type: enumerable" do
+      let(:junk_list) { junk (0..3) }
+      it "returns a random element of the array" do
+        expect([0,1,2,3]).to include(junk_list)
+      end
+    end
+
+    context "with type: :int" do
+      let(:junk_integer) { junk :int }
+      it "returns a random positive Fixnum" do
+        expect { (junk_integer).to be_a Fixnum }
+      end
+
+      context "with min and max values" do
+        let(:coin) { junk :int, min: 0, max: 1 }
+        specify { expect([0,1]).to include(coin) }
+      end
+
+      context "with size" do
+        let(:digit) { junk :int, size: 1 }
+        specify { expect(digit).to be < 10 }
+      end
+
+      context "with exclude proc" do
+        let(:junk_evens) { junk :int, min: 0, max: 10, exclude: ->(x) { x % 2 == 1 } }
+        specify { expect(junk_evens % 2).to eq(0) }
+      end
+    end
+
+    context "with type: :bool" do
+      let(:junk_bool) { junk :bool }
+      specify { expect([true, false]).to include(junk_bool) }
+
+      context "with excludes" do
+        let(:junk_bool) { junk :bool, exclude: true }
+        specify { expect(junk_bool).to eq(false) }
+      end
+    end
+
+    # begin
+    #   $caught_bad_junklet_error = false
+    #   junklet :cheesy_bad_junklet, cheese: true
+    # rescue INVALID_JUNKLET_ERROR => e
+    #   raise "junklet got invalid option" unless e.message == "junklet options must be one of #{VALID_JUNKLET_ARGS.map(&:inspect) * ', '}"
+    #   $caught_bad_junklet_error = true
+    # else
+    #   raise "junklet got an invalid argument but didn't catch it" unless $caught_bad_junklet_error
+    # end
+
+    context "with exclude: val" do
+      let(:heads) { 0 }
+      let(:tails) { 1 }
+      let(:coin_heads) { junk :int, max: 1, exclude: tails }
+      let(:coin_tails) { junk :int, max: 1, exclude: heads }
+
+      specify { expect(coin_heads).to eq(heads) }
+      specify { expect(coin_tails).to eq(tails) }
+    end
+
+    # TODO: Formats here
+
+    # format: :string -> calls .to_s
+    # format: "format_string" -> calls sprintf(junkval, format_string)
+    # format: Klass -> passes junkval to Klass.new
+    # format: Proc -> passes junkval to Proc
+    #
+    # format: with exclude: - runs exclude AFTER running format. This is the whole point of formatters; it allows us to say junk().to_s, exclude: :otherval
+
+  end
+
+  context "metaprogramming use cases" do
+    metaname = junk
+    describe "works by allowing junk to be set from an ExampleGroup outside of an ExampleCase" do
+      specify { expect(metaname).to be }
+    end
+  end
+end

data/spec/lib/line_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require_relative '../../lib/line'
+
+describe Line do
+  let(:code)     { Line.new("  # Here's some code\n") }
+  let(:let)      { Line.new("  let(:bob) { 'Bob McRobertson' } \n") }
+  let(:uuid)     { Line.new("  let(:uuid)     { SecureRandom.uuid }\n") }
+  let(:hex)      { Line.new("  let(:hex)      { SecureRandom.hex }\n") }
+  let(:junklet)  { Line.new("  junklet :reggie\n") }
+  let(:multi)    { Line.new("  junklet :john, :paul, :ringo, :the_other_one") }
+  let(:blank)    { Line.new("\n") }
+  let(:embedded) { Line.new('  let(:embedded)      { "www.#{SecureRandom.uuid}.com" }\n') }
+
+  let(:uuid_arg) { Line.new('  let(:uuid_arg) { SecureRandom.uuid[0..10] }') }
+  let(:hex_arg)  { Line.new('  let(:hex_arg) { SecureRandom.hex[0..10] }') }
+
+  specify { code.should be_code }
+  specify { code.should_not be_let }
+  specify { code.should_not be_junklet }
+  specify { code.names.should be_nil }
+  specify { code.convert.should be_nil }
+
+  specify { let.should_not be_code }
+  specify { let.should be_let }
+  specify { let.should_not be_junklet }
+  specify { let.names.should eq([':bob']) }
+  specify { let.convert.should be_nil }
+
+  specify { uuid.should_not be_code }
+  specify { uuid.should_not be_let }
+  specify { uuid.should be_junklet }
+  specify { uuid.convert.should eq(Line.new("  junklet :uuid")) }
+
+  specify { junklet.should_not be_code }
+  specify { junklet.should_not be_let }
+  specify { junklet.should be_junklet }
+  specify { junklet.names.should eq([':reggie']) }
+  specify { junklet.convert.should eq(junklet) }
+
+  specify { multi.should_not be_code }
+  specify { multi.should_not be_let }
+  specify { multi.should be_junklet }
+  specify { multi.names.should eq([':john', ':paul', ':ringo', ':the_other_one']) }
+  specify { multi.convert.should eq(multi) }
+
+  specify { blank.should be_code }
+  specify { blank.should_not be_let }
+  specify { blank.should_not be_junklet }
+  specify { blank.names.should be_nil }
+  specify { blank.convert.should be_nil }
+
+  specify { embedded.should_not be_code }
+  specify { embedded.should be_let }
+  specify { embedded.should_not be_junklet }
+  specify { embedded.names.should eq([':embedded']) }
+  specify { embedded.convert.should be_nil }
+
+  specify { hex.should_not be_code }
+  specify { hex.should_not be_let }
+  specify { hex.should be_junklet }
+  specify { hex.names.should eq([':hex']) }
+  specify { hex.convert.should eq("  junklet :hex") }
+
+  specify { uuid_arg.should_not be_code }
+  specify { uuid_arg.should be_let }
+  specify { uuid_arg.should_not be_junklet }
+  specify { uuid_arg.names.should eq([':uuid_arg']) }
+  specify { uuid_arg.convert.should be_nil }
+
+  specify { hex_arg.should_not be_code }
+  specify { hex_arg.should be_let }
+  specify { hex_arg.should_not be_junklet }
+  specify { hex_arg.names.should eq([':hex_arg']) }
+  specify { hex_arg.convert.should be_nil }
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+# spec_helper.rb
+
+require_relative '../lib/junklet'
+
+require 'pry'
+
+# Since we've kept rigidly to 80-columns, we can easily
+# Do a pretty side-by-side diff here. This won't handle
+# Line deletions/insertions but for same/same diffs it'll
+# work fine.
+ESC = 27.chr
+GREEN = "%c[%sm" % [ESC, 32]
+RED = "%c[%sm" % [ESC, 31]
+RESET = "%c[0m" % ESC
+
+def dump_hline
+  puts(('-' * 80) + '-+-' + ('-' * 80))
+end
+
+def dump_captions
+  puts '%-80s | %s' % ["EXPECTED", "GOT"]
+end
+
+def dump_header
+  dump_hline
+  dump_captions
+end
+
+def dump_footer
+  dump_hline
+end
+
+def line_pairs(expected_lines, got_lines)
+  expected_lines.zip(got_lines).map { |words| words.map {|w| w ? w.rstrip : '' } }
+end
+
+def dump_diff(expected_lines, got_lines)
+  dump_header
+
+  line_pairs(expected_lines, got_lines).each do |a,b|
+    color_code = a == b ? GREEN : RED
+    puts "#{color_code}%-80s | %s#{RESET}" % [a,b]
+  end
+  dump_footer
+end