rspec-junklet 2.0.1 → 2.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDRhMTA4YzAzZmE4ZDZkMzY3NmYzNjU3NzQzNTQ3YzJiOGIzODA3Nw==
+    NTBkNmE5YzhiNjBkZTE5MTE4OWM5YzAxMzI1NzIwMmUxMjEzNTljOA==
   data.tar.gz: !binary |-
-    ODZjMjRiZDQ0MGNhNDI0YzMzNWMxNWIzMTViODY2ZGMwMDY3OWJmYQ==
+    ZWIxZjZkNTg2NmVhMmVlYjYzYTdkMWJhMDdhYTc4YTIwZmY5MzhkNg==
 SHA512:
   metadata.gz: !binary |-
-    ZjFkZTY3NjY0MmU4MTFhOWFhYmViMDI5YjZkODEwZTM0MTEzYjI4NzI1YzI1
-    NWI3MmViMWJkMTExMWZjOWVjNjIzMTliMDk0NjlkYzc5ZDQwZGM2ZGFhMTgx
-    MmFjYjA2YzE3NTUwYjQxMmRlY2NkMzMxNTFjMWQ3MTc4MWIwYTA=
+    NmEzM2E4OWJiMWUyOGY4MDM0YWNjN2ZhODlhN2ZkOWM4NjEyOThhMjFkMjM3
+    MmYyOWVkMzU4ZDc2ODIzYTZhYzVmZTdhZTM3YjkyNzE0MmRkNjhmYzAxOTBh
+    OTg1ZjI0ZTk5ODE4NWRmOTA1ZmY1NDA3ODE1Zjg5ZDc2YWEyNWU=
   data.tar.gz: !binary |-
-    YzM4MzhlMzMxNWI0NDE4MmViZTQyNTk0YzJlZDY4ZDUwNTIxNGY4ZDI2NTk5
-    NjBkYzI4Zjg3ZTY1OTAxMTc5M2RkNjRlMGJkNmY4ZmY4MTcxMzA4ZWUzOWYz
-    NDAwM2I4YTUxNmI2Y2JlYjNjMzZlZWM0ZmE5MjIwYWU5N2M4YzE=
+    YjVhMjU5ODEwNzYzZTg3MTk5YzZhODA4MWU1NTA3NjY5NjRmMGM0ZDdjMjc5
+    NzhiMzJjYjgwYTEyMTcxNzlhYTEyMTA4ODRlOTg0YWE5MWZhOTVlZDBjYWE2
+    OTg3MzdkMmUxZGY2OGE0NjEwZGNlYjg0Y2Y1YWE0ZTllMTBlZmU=

data/README.md

@@ -7,7 +7,8 @@ or `junk 4`.
 Junklet data is fixture data that:
 
 * We essentially don't care about,
-* But we might want to test for equality somewhere later,
+* But we might need it to conform to a certain format,
+* And we might want to test for equality somewhere later,
 * And we might need to be unique between runs in case a spec crashes and
 SQLServer fails to clean up the test database
 
@@ -230,6 +231,21 @@ let(:otherside) { junk :bool, exclude: coinflip } # Look I never said
 *VERY IMPORTANT CAVEAT* If you exclude all of the possibilities from the random
 key space, junk will cheerfully go into an infinite loop.
 
+### Size
+
+Size constrains the size of the output. It works differently depending on the
+type of junk:
+
+* Number of Digits: as documented above, `junk :int, size: 4` will return a
+4-digit number beginning with 1-9.
+* Number of Repetitions: For Enumerable and Array junk, where the value of the
+junk is obtained by picking an element at random, size will make junk return an
+array containing that many random selections. The same goes for proc, only it
+will be called that number of times. Note that excluders and formatters will be
+applied to each element of the array as well.
+
+
+
 ### Format
 
 A format can be applied to junk data after generation. This lets you change the

data/lib/rspec/junklet/junk.rb

@@ -52,11 +52,16 @@ module RSpec
         # FIXME: Raise Argument error unless *args.size is 0-2
         # FIXME: If arg 1 is a hash, it's the options hash, raise
         #        ArgumentError unless args.size == 1
+
+        # TODO: Nice-to-have feature: if args.second is an :int, assume size.
+
         # FIXME: If arg 2 present, Raise Argument error unless it's a
         #        hash.
+
         # FIXME: Figure out what our valid options are and parse them;
         #        raise errors if present.
 
+        repeat = 0
         junk_types = [Symbol, Array, Enumerable, Proc]
         if args.size > 0 && junk_types.any? {|klass| args.first.is_a?(klass) }
           type = args.shift
@@ -118,27 +123,42 @@ module RSpec
           when :bool
             generator = -> { [true, false].sample }
           when Array, Enumerable
+            repeat = opts[:size] if opts[:size]
             generator = -> { type.to_a.sample }
           when Proc
+            repeat = opts[:size] if opts[:size]
             generator = type
           else
             raise "Unrecognized junk type: '#{type}'"
           end
 
-          begin
-            val = formatter.call(generator.call)
-          end while excluder.call(val)
+          val = if repeat.zero?
+                  value(generator, formatter, excluder)
+                else
+                  repeat.times.map {
+                    value(generator, formatter, excluder)
+                  }
+                end
           val
         else
           size = args.first.is_a?(Numeric) ? args.first : 32
           # hex returns size*2 digits, because it returns a 0..255 byte
-          # as a hex pair. But when we want junt, we want *bytes* of
+          # as a hex pair. But when we want junk, we want *bytes* of
           # junk. Get (size+1)/2 chars, which will be correct for even
           # sizes and 1 char too many for odds, so trim off with
           # [0...size] (note three .'s to trim off final char)
           SecureRandom.hex((size+1)/2)[0...size]
         end
       end
+
+      private
+
+      def value(generator, formatter, excluder)
+        begin
+          v = formatter.call(generator.call)
+        end while excluder.call(v)
+        v
+      end
     end
   end
 end

data/lib/rspec/junklet/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Junklet
-    VERSION = "2.0.1"
+    VERSION = "2.1.0"
   end
 end

data/lib/rspec/junklet.rb

@@ -2,10 +2,9 @@ require_relative "./junklet/version"
 require_relative "./junklet/junk"
 require_relative "./junklet/junklet"
 
-if RSpec.respond_to?(:configure)
-  RSpec.configure do |config|
-    config.extend(RSpec::Junklet::Junklet)
-    config.extend(RSpec::Junklet::Junk) # when metaprogramming cases, you may need junk in ExampleGroups
-    config.include(RSpec::Junklet::Junk)
-  end
+# Automatically hook into RSpec when you `include "rspec-junklet"`
+RSpec.configure do |config|
+  config.extend(RSpec::Junklet::Junklet) # This lets us say junklet() in describes and contexts
+  config.extend(RSpec::Junklet::Junk)    # This lets us say junk() in describes and contexts
+  config.include(RSpec::Junklet::Junk)   # This lets us say junk() in lets
 end

data/spec/lib/rspec/examples_spec.rb

@@ -1,13 +1,10 @@
 require 'spec_helper'
 
-# This spec file is a documentation/example spec showing how various ways to use
-# Junklet. It was the original spec before I extracted out the classes of
-# Junklet, but still serves as a functional, high-level spec plus it's a good
-# collection of examples so here you go.
+# Because rspec-junklet extends RSpec, this spec file actually EXERCISES
+# rspec-junklet instead of testing it directly. You can treat it like a list of
+# examples or a cheatsheet for how to try things.
 
 describe RSpec::Junklet do
-  specify { expect(subject).to be }
-
   let(:hex_regex) { /[\da-f]{32}/ }
 
   describe '.junklet' do
@@ -26,6 +23,10 @@ describe RSpec::Junklet do
     context "with multiple args" do
       junklet :trash, :toss, :crud, :crap
 
+      # FIXME: if we were to stub out junk here, these examples
+      # could be changed to read
+      # expect(trash).to eq("trash_1234567809etc")
+      # which would document the output MUCH more clearly
       specify { expect(trash).to match /^trash_/ }
       specify { expect(trash).to match hex_regex }
       specify { expect(toss).to match /^toss_/ }
@@ -77,32 +78,61 @@ describe RSpec::Junklet do
       end
     end
 
+    shared_examples_for "repeatable junk" do
+      it "returns an array" do
+        expect(subject).to be_a(Array)
+      end
+
+      it "returns an array of that size" do
+        expect(subject.size).to eq(3)
+      end
+
+      it "each element of the array is junk" do
+        expect(subject.all? {|i| [0,1,2].include? i}).to be_truthy
+      end
+    end
+
     context "with type: array" do
-      let(:junk_ray) { junk [:a, :b, :c] }
+      subject { junk [:a, :b, :c] }
       it "returns a random element of the array" do
-        expect([:a, :b, :c]).to include(junk_ray)
+        expect([:a, :b, :c]).to include(subject)
       end
 
       context "with excludes" do
-        let(:junk_ray) { junk [:a, :b, :c], exclude: [:a, :b] }
-        specify { expect(junk_ray).to eq(:c) }
+        let(:subject) { junk [:a, :b, :c], exclude: [:a, :b] }
+        it "does not return excluded values" do
+          expect(subject).to eq(:c)
+        end
+      end
+
+      context "with size" do
+        subject { junk [0, 1, 2], size: 3 }
+        it_behaves_like "repeatable junk"
       end
     end
 
     context "with type: Proc" do
-      let(:junk_proc) { junk(->{ rand(3) }) }
-      specify { expect([0,1,2]).to include(junk_proc) }
+      subject { junk(->{ rand(3) }) }
+      it "calls the proc" do
+        expect([0, 1, 2]).to include(subject)
+      end
 
-      context "with excludes" do
-        let(:junk_proc) { junk(->{ rand(3) }, exclude: [0,2]) }
-        specify { expect(junk_proc).to eq(1) }
+      context "with size" do
+        subject { junk(->{ rand(3) }, size: 3 ) }
+        it_behaves_like "repeatable junk"
       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)
+      subject { junk 0..2 }
+
+      it "takes a sample from the enumerable" do
+        expect([0,1,2]).to include(subject)
+      end
+
+      context "with size" do
+        subject { junk 0..2, size: 3 }
+        it_behaves_like "repeatable junk"
       end
     end
 

data/spec/lib/rspec/junklet/junk_spec.rb

@@ -170,6 +170,11 @@ describe JunkSpy do
     end
 
 
+    # BUG: this special case of format does not work:
+    # doubled_string = junk 6, format: ->(x) { x * 2 })
+    # expect(doubled_string.size).to eq(12) # nope, it's 6
+    # junk 6, format: ->(x) { x.upcase } # also returns x unmodified
+
     context "when format is a Proc" do
       let(:junk) { subject.junk [3], format: ->(x) { x * 3 } }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-junklet
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - David Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2016-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler