webspicy 0.16.1 → 0.19.0

data/spec/unit/support/world/fixtures/array.json

@@ -0,0 +1,8 @@
+[
+  {
+    "name": "foo"
+  },
+  {
+    "name": "bar"
+  }
+]

data/spec/unit/support/world/fixtures/queue.rb

@@ -0,0 +1 @@
+Webspicy::SpecTests::Queue.new

data/spec/unit/support/world/fixtures/single.json

@@ -0,0 +1,11 @@
+{
+  "id": 1,
+  "name": "single",
+  "version": {
+    "major": "1",
+    "minor": "0"
+  },
+  "hobbies": [
+    { "name": "programming"}
+  ]
+}

data/spec/unit/support/world/fixtures/yaml.yml

@@ -0,0 +1,3 @@
+---
+id: 3
+name: 'YAML'

data/spec/unit/support/world/test_world.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Webspicy
+  module SpecTests
+    class Queue
+      include Webspicy::Support::World::Item
+
+    end
+  end
+end
+
+module Webspicy
+  module Support
+    describe World do
+
+      let(:config){
+        Configuration.new(restful_folder)
+      }
+
+      subject do
+        World.new Path.dir/"fixtures", config
+      end
+
+      it 'supports single objects' do
+        expect(subject.single.name).to eql("single")
+        expect(subject.single.version.minor).to eql("0")
+        expect(subject.single.hobbies[0].name).to eql("programming")
+      end
+
+      it 'supports yaml too' do
+        expect(subject.yaml.name).to eql("YAML")
+      end
+
+      it 'supports arrays' do
+        expect(subject.array[0].name).to eql("foo")
+        expect(subject.array[1].name).to eql("bar")
+      end
+
+      it 'allows setting new attributes on itself' do
+        subject.foo = "bar"
+        expect(subject.foo).to eql("bar")
+      end
+
+      it 'allows setting new attributes on existing objects' do
+        subject.single.foo = "bar"
+        expect(subject.single.foo).to eql("bar")
+      end
+
+      it 'supports ruby files and evaluates them' do
+        q = subject.queue
+        expect(q).to be_a(Webspicy::SpecTests::Queue)
+        expect(q.config).to be(config)
+      end
+    end
+  end
+end

data/spec/unit/test_configuration.rb

@@ -40,7 +40,7 @@ module Webspicy
       end
 
       it 'supports a single .yml file and returns a specific configuration instance' do
-        file = restful_folder/"todo/getTodo.yml"
+        file = restful_folder/"formaldef/todo/get.yml"
         c = Configuration.dress(file)
         expect(c).to be_a(Configuration)
         expect(c.folder).to eq(restful_folder)
@@ -48,6 +48,11 @@ module Webspicy
         expect(c.each_scope.to_a.first.each_specification.to_a.size).to eql(1)
       end
 
+      it 'exposes the world as a World instance' do
+        c = Configuration.dress(restful_folder)
+        expect(c.world).to be_a(Support::World)
+      end
+
       it 'yields the block with the configuration, if given' do
         seen = nil
         Configuration.dress(Path.dir/'configuration'){|c|
@@ -106,6 +111,7 @@ module Webspicy
         ENV['ROBUST'] = 'yes'
         config = Configuration.new
         expect(config.run_counterexamples?).to eql(true)
+        ENV.delete('ROBUST')
       end
 
       it 'ignores the environment is set explicitly' do
@@ -114,6 +120,7 @@ module Webspicy
           c.run_counterexamples = false
         end
         expect(config.run_counterexamples?).to eql(false)
+        ENV.delete('ROBUST')
       end
     end
 
@@ -130,6 +137,7 @@ module Webspicy
         expect(config.file_filter).to be_a(Regexp)
         expect(config.file_filter).to match("foo/bar/getTodo.yml")
         expect(config.file_filter).not_to match("foo/bar/getTodos.yml")
+        ENV.delete('RESOURCE')
       end
 
       it 'allows expressing a no match' do
@@ -138,6 +146,7 @@ module Webspicy
         expect(config.file_filter).to be_a(Proc)
         expect(config.file_filter.call("foo/bar/getTodos.yml")).to eq(true)
         expect(config.file_filter.call("foo/bar/getTodo.yml")).to eq(false)
+        ENV.delete('RESOURCE')
       end
 
       it 'ignores the environment if set explicitly' do
@@ -146,6 +155,7 @@ module Webspicy
           c.file_filter = nil
         end
         expect(config.file_filter).to be_nil
+        ENV.delete('RESOURCE')
       end
     end
 
@@ -160,6 +170,7 @@ module Webspicy
         ENV['METHOD'] = 'GET'
         config = Configuration.new
         expect(config.service_filter).to be_a(Proc)
+        ENV.delete('METHOD')
       end
 
       it 'ignores the environment is set explicitly' do
@@ -168,6 +179,36 @@ module Webspicy
           c.service_filter = nil
         end
         expect(config.service_filter).to be_nil
+        ENV.delete('METHOD')
+      end
+    end
+
+    describe 'insecure' do
+
+      it 'is false by default' do
+        config = Configuration.new
+        expect(config.insecure).to eql(false)
+      end
+
+      it 'is true if INSECURE is set to yes' do
+        ENV['INSECURE'] = 'yes'
+        config = Configuration.new
+        expect(config.insecure).to eql(true)
+        ENV.delete('INSECURE')
+      end
+
+      it 'is true if INSECURE is set to 1' do
+        ENV['INSECURE'] = '1'
+        config = Configuration.new
+        expect(config.insecure).to eql(true)
+        ENV.delete('INSECURE')
+      end
+
+      it 'is false if INSECURE is set to no' do
+        ENV['INSECURE'] = 'no'
+        config = Configuration.new
+        expect(config.insecure).to eql(false)
+        ENV.delete('INSECURE')
       end
     end
 
@@ -187,48 +228,56 @@ module Webspicy
         ENV['TAG'] = 'foo'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows no matching a single tag' do
         ENV['TAG'] = 'baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows setting multiple tags' do
         ENV['TAG'] = 'foo,baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows no matching any of multiple tags' do
         ENV['TAG'] = 'foi,baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows setting a single negative tag' do
         ENV['TAG'] = '!foo'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
       it 'allows not matching a single negative tag' do
         ENV['TAG'] = '!baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows mixing positive & negative tags and have a match' do
         ENV['TAG'] = 'foo,!baz'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(true)
+        ENV.delete('TAG')
       end
 
       it 'allows mixing positive & negative tags and have no match' do
         ENV['TAG'] = 'foo,!bar'
         expect(subject).to be_a(Proc)
         expect(subject.call(tc)).to eql(false)
+        ENV.delete('TAG')
       end
 
     end

data/spec/unit/tester/test_asserter.rb

@@ -3,10 +3,75 @@ require 'spec_helper'
 module Webspicy
   class Tester
     describe Asserter do
-      let(:asserter) { Asserter.new(target) }
+      describe '#includes' do
+        it 'returns nil when the value is found in an array' do
+          expect(Asserter.new([:a, 'foo', 99]).includes('', 'foo'))
+            .to eq nil
+        end
+
+        it 'returns nil when the assertion is identical to a non-array' do
+          expect(Asserter.new({ foo: Time.at(0) }).includes('', { foo: Time.at(0) }))
+            .to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([:a, 'foo', 99]).includes('', 42) }
+            .to raise_exception Failure,
+                                'Expected ["a","foo",99] to include 42'
+
+        end
+      end
+
+      describe '#notIncludes' do
+        it 'returns nil when the value is not found in an array' do
+          expect(Asserter.new([:a, 'foo', 99]).notIncludes('', 'boom'))
+            .to eq nil
+        end
+
+        it 'returns nil when the assertion and target are not identical' do
+          expect(Asserter.new({ foo: Time.at(0) }).notIncludes('', 'LOL'))
+            .to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([:a, 'foo', 99]).notIncludes('', 'foo') }
+            .to raise_exception Failure,
+                                'Expected ["a","foo",99] not to include foo'
+        end
+      end
+
+      describe '#empty' do
+        it 'returns nil when the target is empty' do
+          expect(Asserter.new([]).empty).to eq nil
+          expect(Asserter.new({}).empty).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new(['foo']).empty }
+            .to raise_exception Failure,
+                                'Expected ["foo"] to be empty'
+        end
+      end
+
+      describe '#notEmpty' do
+        it 'returns nil when the target is not empty' do
+          expect(Asserter.new(['foo']).notEmpty).to eq nil
+          expect(Asserter.new({ foo: 'bar' }).notEmpty).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([]).notEmpty }
+            .to raise_exception Failure,
+                                'Expected [] to be non empty'
+          expect { Asserter.new({}).notEmpty }
+            .to raise_exception Failure,
+                                'Expected {} to be non empty'
+        end
+      end
 
       describe '#size' do
         let(:target) { [1, 2, 3, 4] }
+        let(:asserter) { Asserter.new(target) }
 
         it 'returns nil when the assertion is true for a plain array' do
           expect(asserter.size('', 4)).to eq nil
@@ -14,7 +79,7 @@ module Webspicy
 
         it 'raises an exception with a descriptive message when the assertion is false' do
           expect { asserter.size('', 3) }
-            .to raise_exception RuntimeError, 'Expected [1,2,3,4] to have a size of 3, actual size is: 4'
+            .to raise_exception Failure, 'Expected [1,2,3,4] to have a size of 3, actual size is: 4'
         end
 
         context 'with a string' do
@@ -34,7 +99,7 @@ module Webspicy
 
           it 'raises an exception with a descriptive message when the assertion is false' do
             expect { asserter.size('foo/2/bar', 99) }
-              .to raise_exception RuntimeError,
+              .to raise_exception Failure,
                                   'Expected [10,11,12] to have a size of 99, actual size is: 3'
           end
 
@@ -45,6 +110,136 @@ module Webspicy
           end
         end
       end
+
+      describe '#idIn' do
+        it 'returns nil when the specified ids match exactly' do
+          expect(Asserter.new([{ id: 1 }, { id: 2 }]).idIn('', 1, 2)).to eq nil
+          expect(Asserter.new({ id: 123 }).idIn('', 123)).to eq nil
+
+          os = OpenStruct.new(id: 'foo')
+          expect(Asserter.new(os).idIn('', 'foo')).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 123, 125) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 123,125'
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 1, 2, 3) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 1,2,3'
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idIn('', 1) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to have ids 1'
+        end
+      end
+
+      describe '#idNotIn' do
+        it 'returns nil when the specified ids do not match exactly' do
+          expect(Asserter.new([{ id: 1 }, { id: 2 }]).idNotIn('', 123, 125)).to eq nil
+          expect(Asserter.new({ id: 123 }).idNotIn('', 1, 2, 3)).to eq nil
+          expect(Asserter.new({ id: 123 }).idNotIn('', 1)).to eq nil
+        end
+
+        it 'raises an exception with a descriptive message when the assertion is false' do
+          expect { Asserter.new([{ id: 1}, { id: 2}]).idNotIn('', 1, 2) }
+            .to raise_exception Failure,
+                                'Expected [{"id":1},{"id":2}] to not have ids 1,2'
+          expect { Asserter.new({ id: 1}).idNotIn('', 1) }
+            .to raise_exception Failure,
+                                'Expected {"id":1} to not have ids 1'
+
+          os = OpenStruct.new(id: 'foo')
+          expect { Asserter.new(os).idNotIn('', 'foo') }
+            .to raise_exception Failure,
+                                'Expected "#<OpenStruct id=\"foo\">"... to not have ids foo'
+        end
+      end
+    end
+
+    describe '#idFD' do
+      let(:target) do
+        [
+          { id: 1, a: 'a1', b: 'b1' },
+          { id: 2, a: 'a2', b: 'b2' }
+        ]
+      end
+
+      it 'returns nil when the element with specified id matches the expected keys-value pairs' do
+        expect(Asserter.new(target).idFD('', 2, { b: 'b2' })).to eq nil
+        expect(Asserter.new(target).idFD('', 2, { a: 'a2', b: 'b2' })).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new(target).idFD('', 2, { c: 'c2' }) }
+          .to raise_exception Failure,
+                              'Expected [{"id":1,"a":"a1","b":"b1"... ' \
+                              'to contain the key(s) and value(s) {:c=>"c2"}'
+        expect { Asserter.new(target).idFD('', 2, { b: 'b1' }) }
+          .to raise_exception Failure,
+                              'Expected [{"id":1,"a":"a1","b":"b1"... ' \
+                              'to contain the key(s) and value(s) {:b=>"b1"}'
+      end
+
+      it 'raises an exception with a descriptive message when no element with the specified id is present in target' do
+        expect { Asserter.new(target).idFD('', 3, { a: 'a3' }) }
+          .to raise_exception Failure,
+                              'Expected an element with id 3 to contain ' \
+                              'the key(s) and value(s) {:a=>"a3"}, '\
+                              'but there is no element with that id'
+      end
+    end
+
+    describe '#pathFD' do
+      let(:target) do
+        [
+          { a: 'a1', b: 'b1' },
+          { a: 'a2', b: 'b2' }
+        ]
+      end
+
+      it 'returns nil when the target matches the expected keys-value pairs' do
+        expect(Asserter.new(target).pathFD('0', { b: 'b1' })).to eq nil
+        expect(Asserter.new(target).pathFD('0', { a: 'a1', b: 'b1' })).to eq nil
+        expect(Asserter.new(target).pathFD('1', { b: 'b2' })).to eq nil
+        expect(Asserter.new(target).pathFD('1', { a: 'a2', b: 'b2' })).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new(target).pathFD('0', { c: 'c2' }) }
+          .to raise_exception Failure,
+                              'Expected {"a":"a1","b":"b1"} ' \
+                              'to contain the key(s) and value(s) {:c=>"c2"}'
+        expect { Asserter.new(target).pathFD('0', { b: 'b2' }) }
+          .to raise_exception Failure,
+                              'Expected {"a":"a1","b":"b1"} ' \
+                              'to contain the key(s) and value(s) {:b=>"b2"}'
+      end
+    end
+
+    describe '#match' do
+      it 'returns nil when the target matches the specified regexp' do
+        expect(Asserter.new('Empathise').match('', /path/)).to eq nil
+        expect(Asserter.new('Empathise').match('', /.mp/)).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new('Empathise').match('', /ize/) }
+          .to raise_exception Failure,
+                              'Expected "Empathise" to match /ize/'
+      end
+    end
+
+    describe '#notMatch' do
+      it 'returns nil when the target does not matche the specified regexp' do
+        expect(Asserter.new('Empathise').notMatch('', /ize/)).to eq nil
+        expect(Asserter.new('Empathise').notMatch('', /^path/)).to eq nil
+      end
+
+      it 'raises an exception when the assertion is false' do
+        expect { Asserter.new('Empathise').notMatch('', /path/) }
+          .to raise_exception Failure,
+                              'Expected "Empathise" not to match /path/'
+      end
     end
   end
 end