webspicy 0.16.1 → 0.19.0

data/lib/webspicy/support/data_object.rb

@@ -0,0 +1,25 @@
+module Webspicy
+  module Support
+    module DataObject
+
+      def initialize(raw)
+        @raw = raw
+      end
+      attr_accessor :raw
+      protected :raw, :raw=
+
+      def method_missing(name, *args, &bl)
+        if @raw.has_key?(name) && args.empty? && bl.nil?
+          @raw[name]
+        else
+          super
+        end
+      end
+
+      def to_info
+        @raw
+      end
+
+    end # module DataObject
+  end # module Support
+end # module Webspicy

data/lib/webspicy/support/hooks.rb

@@ -0,0 +1,65 @@
+module Webspicy
+  module Support
+    module Hooks
+
+      class Object
+        def initialize(config)
+          @config = config
+        end
+        attr_accessor :config
+        include Hooks
+      end
+
+      def self.for(config)
+        Object.new(config)
+      end
+
+      def fire_around(*args, &bl)
+        ls = config.listeners(:around_each)
+        if ls.size == 0
+          bl.call
+        elsif ls.size > 1
+          _fire_around(ls.first, ls[1..-1], args, &bl)
+        else
+          ls.first.call(*args, &bl)
+        end
+      end
+
+      def _fire_around(head, tail, args, &bl)
+        head.call(*args) do
+          if tail.empty?
+            bl.call
+          else
+            _fire_around(tail.first, tail[1..-1], args, &bl)
+          end
+        end
+      end
+      private :_fire_around
+
+      def fire_before_each(*args, &bl)
+        config.listeners(:before_each).each do |beach|
+          beach.call(*args, &bl)
+        end
+      end
+
+      def fire_after_each(*args, &bl)
+        config.listeners(:after_each).each do |aeach|
+          aeach.call(*args, &bl)
+        end
+      end
+
+      def fire_before_all(*args, &bl)
+        config.listeners(:before_all).each do |beach|
+          beach.call(*args, &bl)
+        end
+      end
+
+      def fire_after_all(*args, &bl)
+        config.listeners(:after_all).each do |aeach|
+          aeach.call(*args, &bl)
+        end
+      end
+
+    end # module Hooks
+  end # module Support
+end # module Webspicy

data/lib/webspicy/support/world.rb

@@ -0,0 +1,47 @@
+module Webspicy
+  module Support
+    class World < OpenStruct
+
+      def initialize(folder, config = nil)
+        super({})
+        @folder = folder
+        @config = config
+      end
+      attr_reader :folder, :config
+
+      def method_missing(name, *args, &bl)
+        return super if name =~ /=$/
+        file = ['json', 'yml', 'yaml', 'rb']
+          .map{|e| folder/"#{name}.#{e}" }
+          .find{|f| f.file? }
+        data = case file && file.ext
+        when /json/
+          JSON.parse(file.read, object_class: OpenStruct)
+        when /ya?ml/
+          JSON.parse(file.load.to_json, object_class: OpenStruct)
+        when /rb/
+          ::Kernel.eval(file.read).tap{|x|
+            x.config = self.config if x.is_a?(Item)
+          }
+        end
+        self.send(:"#{name}=", data)
+      end
+
+      def to_data(which)
+        case which
+        when Hash
+          OpenStruct.new(which)
+        when Array
+          which.map{|x| to_data(x) }
+        else
+          which
+        end
+      end
+
+      module Item
+        attr_accessor :config
+      end # module Item
+
+    end # class World
+  end # module Support
+end # module Webspicy

data/lib/webspicy/tester.rb

@@ -1,89 +1,148 @@
 module Webspicy
   class Tester
-    include Webspicy::Support::Colorize
+
+    class FailFast < Exception; end
 
     def initialize(config)
       @config = Configuration.dress(config)
-      @test_suite = load
+      @scope = nil
+      @hooks = nil
+      @client = nil
+      @spec_file = nil
+      @specification = nil
+      @service = nil
+      @test_case = nil
+      @invocation = nil
+      @reporter = default_reporter
     end
-    attr_reader :config
+    attr_reader :config, :scope, :hooks, :client
+    attr_reader :specification, :spec_file
+    attr_reader :service, :test_case
+    attr_reader :invocation, :result
+    attr_reader :reporter
 
-    def call(err=$stderr, out=$stdout)
-      $_rspec_core_load_started_at = nil
-      options = RSpec::Core::ConfigurationOptions.new(config.rspec_options)
-      conf = RSpec::Core::Configuration.new
-      RSpec::Core::Runner.new(options, conf).run(err, out)
+    def failfast?
+      config.failfast
     end
 
-  # protected
-
-    def load
-      tester = self
-      RSpec.reset
-      rspec_config!
-      RSpec.describe "" do
-        before(:all) do
-          tester.config.listeners(:before_all).each do |l|
-            l.call(tester.config)
-          end
-        end
-        after(:all) do
-          tester.config.listeners(:after_all).each do |l|
-            l.call(tester.config)
-          end
-        end
-        tester.config.each_scope do |scope|
-          client = scope.get_client
-          scope.each_specification do |specification|
-            scope.each_service(specification) do |service|
-              tester.rspec_service!(self, service, client, scope)
-            end
-          end
+    def default_reporter
+      @reporter = Reporter::Composite.new
+      #@reporter << Reporter::Progress.new
+      @reporter << Reporter::Documentation.new
+      @reporter << Reporter::Exceptions.new
+      @reporter << Reporter::Summary.new
+      @reporter << Reporter::ErrorCount.new
+    end
+
+    def call
+      reporter.init(self)
+      begin
+        run_config
+      rescue FailFast
+      end
+      reporter.report
+      reporter.find(Reporter::ErrorCount).report
+    end
+
+  private
+
+    def run_config
+      config.each_scope do |scope|
+        @scope = scope
+        @hooks = Support::Hooks.for(scope.config)
+        @client = scope.get_client
+        reporter.before_all
+        @hooks.fire_before_all(@scope, @client)
+        reporter.before_all_done
+        reporter.before_scope
+        run_scope
+        reporter.scope_done
+        reporter.after_all
+        @hooks.fire_after_all(@scope, @client)
+        reporter.after_all_done
+      end
+    end
+
+    def run_scope
+      scope.each_specification_file do |spec_file|
+        @specification = load_specification(spec_file)
+        if @specification
+          reporter.before_specification
+          run_specification
+          reporter.specification_done
+          reporter.spec_file_done
+        elsif failfast?
+          raise FailFast
         end
       end
-      self
     end
 
-    def rspec_service!(on, service, client, scope)
+    def load_specification(spec_file)
+      @spec_file = spec_file
+      reporter.before_spec_file
+      Webspicy.specification(spec_file.load, spec_file, scope)
+    rescue *PASSTHROUGH_EXCEPTIONS
+      raise
+    rescue Exception => e
+      reporter.spec_file_error(e)
+      nil
+    end
+
+    def run_specification
+      scope.each_service(specification) do |service|
+        @service = service
+        reporter.before_service
+        run_service
+        reporter.service_done
+      end
+    end
+
+    def run_service
       scope.each_testcase(service) do |test_case|
-        str = "#{service} #{test_case}"
-        str = colorize_highlight(str)
-        on.describe(str) do
-          include_examples 'a successful test case invocation', client, test_case
-        end
+        @test_case = test_case
+        reporter.before_test_case
+        run_test_case
+        reporter.test_case_done
       end
     end
 
-    def rspec_config!
-      RSpec.shared_examples "a successful test case invocation" do |client, test_case|
-
-        around(:each) do |example|
-          client.around(test_case) do
-            client.before(test_case)
-            test_case.instrument(client)
-            client.instrument(test_case)
-            @response = client.call(test_case)
-            @invocation = Tester::Invocation.new(test_case, @response, client)
-            example.run
-            client.after(test_case, @invocation)
-            @invocation
-          end
-        end
+    def run_test_case
+      hooks.fire_around(test_case, client) do
+        reporter.before_each
+        hooks.fire_before_each(test_case, client)
+        reporter.before_each_done
 
-        let(:invocation) do
-          @invocation
-        end
+        reporter.before_instrument
+        client.instrument(test_case)
+        reporter.instrument_done
 
-        it "meets its specification" do
-          raise "Test not ran" unless invocation.done?
-          invocation.rspec_assert!(self)
-        end
+        reporter.before_invocation
+        @invocation = client.call(test_case)
+        reporter.invocation_done
+
+        reporter.before_assertions
+        check_invocation
+        reporter.assertions_done
+
+        reporter.after_each
+        hooks.fire_after_each(test_case, @invocation, client)
+        reporter.after_each_done
+
+        raise FailFast if !result.success? and failfast?
       end
     end
 
+    def check_invocation
+      @result = Result.from(self)
+    end
+
   end # class Tester
 end # module Webspicy
+require_relative 'tester/reporter'
 require_relative 'tester/client'
 require_relative 'tester/invocation'
+require_relative 'tester/result'
+require_relative 'tester/failure'
 require_relative 'tester/assertions'
 require_relative 'tester/asserter'
+require_relative 'tester/file_checker'

data/lib/webspicy/tester/asserter.rb

@@ -78,14 +78,19 @@ module Webspicy
           expected = id
           id, path = path, ''
         end
-        unless @assertions.idFD(@target, path, id, expected)
-          _! "Expected #{_s(@target, path)} to meet FD #{expected.inspect}"
+        element = @assertions.element_with_id(@target, path, id)
+        unless element
+          _! "Expected an element with id #{id} to contain the key(s) and value(s) #{expected}, but there is no element with that id"
+        end
+
+        unless @assertions.idFD(element, expected)
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
       def pathFD(path, expected)
         unless @assertions.pathFD(@target, path, expected)
-          _! "#{expected.inspect} vs. #{_s(@target, path)}"
+          _! "Expected #{_s(@target, path)} to contain the key(s) and value(s) #{expected}"
         end
       end
 
@@ -121,7 +126,7 @@ module Webspicy
       end
 
       def _!(msg)
-        raise msg
+        raise Failure, msg
       end
 
     end # class Asserter

data/lib/webspicy/tester/assertions.rb

@@ -63,16 +63,15 @@ module Webspicy
         (ids.to_set & expected.to_set).empty?
       end
 
-      def idFD(target, path, id, expected = NO_ARG)
-        if expected == NO_ARG
-          expected = id
-          id, path = path, ''
-        end
+      def element_with_id(target, path, id)
         target = extract_path(target, path)
-        found = an_array(target).find{|t| t[:id] == id }
-        expected.keys.all?{|k|
-          value_equal(expected[k], found[k])
-        }
+        an_array(target).find { |t| t[:id] == id }
+      end
+
+      def idFD(element, expected) 
+        expected.keys.all? do |k|
+          value_equal(expected[k], element[k])
+        end
       end
 
       def pathFD(target, path, expected)

data/lib/webspicy/tester/client.rb

@@ -1,63 +1,43 @@
 module Webspicy
   class Tester
     class Client
+      extend Forwardable
 
       def initialize(scope)
         @scope = scope
       end
       attr_reader :scope
 
-      def config
-        scope.config
-      end
+      def_delegators :@scope, *[
+        :config
+      ]
 
-      def around(*args, &bl)
-        args << self
-        ls = config.listeners(:around_each)
-        if ls.size == 0
-          bl.call
-        elsif ls.size > 1
-          _around(ls.first, ls[1..-1], args, &bl)
-        else
-          ls.first.call(*args, &bl)
+      def find_and_call(method, url, mutation)
+        unless tc = scope.find_test_case(method, url)
+          raise Error, "No such service `#{method} #{url}`"
         end
+        mutated = tc.mutate(mutation)
+        instrumented = instrument(mutated)
+        call(instrumented)
       end
 
-      def _around(head, tail, args, &bl)
-        head.call(*args) do
-          if tail.empty?
-            bl.call
-          else
-            _around(tail.first, tail[1..-1], args, &bl)
-          end
+      def instrument(test_case)
+        service = test_case.service
+        service.preconditions.each do |pre|
+          pre.instrument(test_case, self) if pre.respond_to?(:instrument)
         end
-      end
-      private :_around
-
-      def instrument(*args, &bl)
-        args << self
+        service.postconditions.each do |post|
+          post.instrument(test_case, self) if post.respond_to?(:instrument)
+        end if test_case.example?
+        service.errconditions.each do |post|
+          post.instrument(test_case, self) if post.respond_to?(:instrument)
+        end if test_case.counterexample?
         config.listeners(:instrument).each do |i|
-          i.call(*args, &bl)
-        end
-      end
-
-      def before(*args, &bl)
-        args << self
-        config.listeners(:before_each).each do |beach|
-          beach.call(*args, &bl)
-        end
-      end
-
-      def after(*args, &bl)
-        args << self
-        config.listeners(:after_each).each do |aeach|
-          aeach.call(*args, &bl)
+          i.call(test_case, self)
         end
+        test_case
       end
 
     end # class Client
   end # class Tester
 end # module Webspicy
-require_relative 'client/support'
-require_relative 'client/http_client'
-require_relative 'client/rack_test_client'