vigia 0.0.9 → 0.1.0

data/lib/vigia/http_client/rest_client.rb

@@ -3,8 +3,12 @@ module Vigia
     class RestClient
       attr_accessor :code, :headers, :body
 
-      def initialize(http_options)
-        @http_options = http_options
+      def initialize(http_client_options)
+        @http_client_options = http_client_options
+      end
+
+      def run
+        cache_or_perform_request
       end
 
       def run!
@@ -13,32 +17,50 @@ module Vigia
 
       private
 
-      # :nocov:
+      # FIXME move cache to HttpClient::Base
+      def cache_or_perform_request
+        if cache.has_key?(request_key)
+          cache[request_key]
+        else
+          @@cache[request_key] = perform_request
+        end
+      end
+
+      def cache
+        @@cache ||= {}
+      end
+
+      def request_key
+        hash = @http_client_options.to_h.select do |k,v|
+          [ :headers, :method, :url, :payload ].include?(k)
+        end
+        Digest::MD5.hexdigest(hash.to_s)
+      end
+
       def parse_request(rest_client_result)
-        {
-          code: rest_client_result.code,
+        Vigia::HttpClient::ClientRequest.new(
+          code:    rest_client_result.code,
           headers: rest_client_result.headers,
-          body: rest_client_result.body
-        }
+          body:    rest_client_result.body
+        )
       end
 
       def error_request(exception)
-        {
-          code: exception.http_code, # Todo. Parse each exception
+        Vigia::HttpClient::ClientRequest.new(
+          code:    exception.http_code, # Todo. Parse each exception
           headers: exception.response.headers,
-          body: exception.response
-        }
+          body:    exception.http_body
+        )
       end
 
       def perform_request
         begin
-          request = ::RestClient::Request.execute(@http_options)
+          request = ::RestClient::Request.execute(@http_client_options.to_h)
           parse_request(request)
         rescue ::RestClient::Exception => exception
           error_request(exception)
         end
       end
-      # :nocov:
     end
   end
 end

data/lib/vigia/parameters.rb

@@ -1,22 +1,33 @@
 module Vigia
   class Parameters
 
-    attr_reader :resource, :action
+    attr_reader :parameters
 
-    def initialize(resource, action)
-      @resource = resource
-      @action   = action
+    def initialize(parameters)
+      @parameters = parameters
+      validate
     end
 
     def to_hash
-      all.each_with_object({}) do |parameter, collection|
-        collection[parameter.name] = parameter.example_value
-        collection
+      @parameters.each_with_object({}) do |parameter, hash|
+        hash.merge!(parameter[:name] => parameter[:value])
       end
     end
 
-    def all
-      resource.parameters.collection + action.parameters.collection
+    def validate
+      return if required_parameters.empty?
+
+      raise("Missing parameters #{ missing_parameters.join(',') }") unless missing_parameters.empty?
+    end
+
+    private
+
+    def required_parameters
+      parameters.select{ |k| k[:required] == true }
+    end
+
+    def missing_parameters
+      required_parameters.select{ |k| k[:value].nil? || k[:value].empty? }.map{ |k| k[:name] }
     end
   end
 end

data/lib/vigia/rspec.rb

@@ -1,15 +1,13 @@
 module Vigia
   class Rspec
     class << self
-      def apib
-        Vigia.config.blueprint.apib
+      def adapter
+        @@adapter
       end
 
       def include_shared_folders
         require_custom_examples
         require "#{ __dir__ }/spec/support/utils"
-        require "#{ __dir__ }/spec/support/shared_examples/skip_example"
-        require "#{ __dir__ }/spec/support/shared_examples/apib_example"
       end
 
       private
@@ -22,26 +20,45 @@ module Vigia
       end
     end
 
-    # Run `Vigia.spec_folder` spec file
     def run!
-      with_options do
+      with_rspec_options do
         RSpec::Core::Runner::run(
-          [ Vigia.spec_folder ], $stderr, $stdout)
+          [ Vigia.spec_folder ], Vigia.config.stderr, Vigia.config.stdout)
       end
     end
 
-    private
+    def start_tests(rspec)
+      with_rspec_options do
+        set_global_memoizers(rspec)
+
+        Vigia::Sail::Group.setup_and_run_primary(rspec)
+      end
+    end
 
-    # ToDo: Do we need rspec config?
+    def set_global_memoizers(rspec)
+      instance = adapter
+      rspec.let(:client)  { Vigia.config.http_client_class.new(http_client_options) }
+      rspec.let(:result)  { client.run }
+      rspec.let(:result!) { client.run! }
+      rspec.let(:adapter) { instance }
+    end
+
+    def adapter
+      @@adapter ||= Vigia.config.adapter.instance
+    end
 
-    def with_options &block
+    private
+
+    def with_rspec_options
       RSpec.configure do |config|
-        config.before(:each) do |example|
-        end
-        config.before(:suite) do
-        end
+        configure_vigia_rspec(config)
       end
       yield
     end
+
+    def configure_vigia_rspec(rspec_config)
+      return unless Vigia.config.rspec_config_block.respond_to?(:call)
+      Vigia.config.rspec_config_block.call(rspec_config)
+    end
   end
 end

data/lib/vigia/sail/context.rb

@@ -0,0 +1,67 @@
+module Vigia
+  module Sail
+    class Context < RSpecObject
+
+      def run
+        instance = self
+        rspec.context instance.to_s do
+          instance.with_hooks(self) do
+            let(:http_client_options) { instance.set_http_client_options(self) }
+            let(:expectations)        { instance.set_expectations(self) }
+
+            instance.run_examples(self)
+            instance.run_shared_examples(self)
+          end
+        end
+      end
+
+      def set_http_client_options(in_let_context)
+        Vigia::HttpClient::Options.build(self, in_let_context)
+      end
+
+      def set_expectations(in_let_context)
+        Vigia::HttpClient::ExpectedRequest.new.tap do |instance|
+          expectations.each do |name|
+            option_object  = options[:expectations][name]
+            instance[name] = contextual_object(object: option_object, context: in_let_context)
+          end
+          instance
+        end
+      end
+
+      def run_examples(in_context)
+        Vigia::Sail::Example.run_in_context(self, in_context)
+      end
+
+      def run_shared_examples(in_context)
+        if custom_examples.any?
+          custom_examples.each do |example_name|
+            in_context.include_examples example_name
+          end
+        end
+      end
+
+      def to_s
+        "context #{ name }"
+      end
+
+      private
+
+      def custom_examples
+        Vigia.config.custom_examples.each_with_object([]) do |custom_example, collection|
+           collection << custom_example[:name] if custom_example[:filter] == :all
+           collection
+        end
+      end
+
+      def expectations
+        (options[:expectations] || {}).keys & default_expectations
+      end
+
+      def default_expectations
+        [ :code, :headers, :body ]
+      end
+    end
+  end
+end
+

data/lib/vigia/sail/example.rb

@@ -0,0 +1,65 @@
+module Vigia
+  module Sail
+    class Example < Vigia::Sail::RSpecObject
+      class << self
+        def register(name, options)
+          @collection = {} if collection.nil?
+          @collection.merge!(name => options)
+        end
+
+        def run_in_context(context, rspec_context)
+          @collection.each do |name, options|
+            setup_and_run(name, rspec_context) if example_contexts_include?(context, options[:contexts])
+          end
+        end
+
+        def example_contexts_include?(context, enabled_contexts)
+          [ *(enabled_contexts || :default) ].include?(context.name)
+        end
+      end
+
+      def run
+        instance = self
+        rspec.it instance do
+          skip              if instance.skip?(self)     || (respond_to?(:skip?)     and send(:skip?))
+          skip('__vigia__') if instance.disabled?(self) || (respond_to?(:disabled?) and send(:disabled?))
+
+          instance_exec(&instance.expectation)
+        end
+      end
+
+      def expectation
+        must_be_a_block(options[:expectation], "Example `#{ name }` expectation must be a block")
+      end
+
+      def to_s
+        return contextual_object(option_name: :description) if options[:description]
+
+        name.to_s
+      end
+
+      def skip?(in_context)
+        return false unless options[:skip_if]
+        contextual_object(option_name: :skip_if, context: in_context)
+      end
+
+      def disabled?(in_context)
+        return false unless options[:disable_if]
+        contextual_object(option_name: :disable_if, context: in_context)
+      end
+    end
+  end
+end
+
+
+Vigia::Sail::Example.register(
+  :code_match,
+  description: 'has the expected HTTP code',
+  expectation: -> { expect(result.code).to be(expectations.code) }
+)
+
+Vigia::Sail::Example.register(
+  :include_headers,
+  description: 'includes the expected headers',
+  expectation: -> { expect(result[:headers]).to include(expectations[:headers]) }
+)

data/lib/vigia/sail/group.rb

@@ -0,0 +1,47 @@
+module Vigia
+  module Sail
+    class Group < Vigia::Sail::RSpecObject
+      class << self
+        def setup_and_run_primary(rspec)
+          name, options  = collection.select{ |k,v| v[:primary] == true }.first
+          instance = new(name, options, rspec)
+          instance.run
+        end
+      end
+
+      def run
+        described_objects.each_with_index do |object, index|
+          group_instance = create_group_instance(object, index)
+          rspec.describe group_instance do
+            let(group_instance.group.name) { group_instance.described_object }
+
+            group_instance.run(self)
+          end
+        end
+      end
+
+      def children
+        [ *options[:children] ] || []
+      end
+
+      def contexts
+        [ *options[:contexts] ] || []
+      end
+
+      def described_objects
+        contextual_object(option_name: :describes) || []
+      end
+
+      def create_group_instance(object, index)
+        instance_name = "#{ name }#{ index }"
+        Vigia::Sail::GroupInstance.new(instance_name, options, rspec).tap do |instance|
+          instance.define_singleton_method("#{ name }", -> { object })
+          instance.parent_object    = rspec.described_class.described_object unless options[:primary]
+          instance.described_object = object
+          instance.description      = (options[:description] || object.to_s)
+          instance.group            = self
+        end
+      end
+    end
+  end
+end

data/lib/vigia/sail/group_instance.rb

@@ -0,0 +1,24 @@
+module Vigia
+  module Sail
+    class GroupInstance < Vigia::Sail::RSpecObject
+
+      attr_accessor :parent_object, :described_object, :group, :description
+
+      def run(rspec_context)
+        with_hooks(rspec_context) do
+          group.children.each do |group_name|
+            Vigia::Sail::Group.setup_and_run(group_name, rspec_context)
+          end
+
+          group.contexts.each do |context_name|
+            Vigia::Sail::Context.setup_and_run(context_name, rspec_context)
+          end
+        end
+      end
+
+      def to_s
+        description.respond_to?(:call) ? instance_exec(&description) : description
+      end
+    end
+  end
+end

data/lib/vigia/sail/rspec_object.rb

@@ -0,0 +1,73 @@
+module Vigia
+  module Sail
+    class RSpecObject
+      class << self
+        attr_accessor :collection
+
+        def setup_and_run(name, rspec)
+          name, options  = collection.select{ |k,v| k == name }.first
+          instance       = new(name, options, rspec)
+          instance.run
+        end
+      end
+
+      attr_reader :name, :options, :rspec
+
+      def initialize(name, options, rspec)
+        @name    = name
+        @options = options
+        @rspec   = rspec
+
+      end
+
+      def execute_hook(filter_name, rspec_context)
+        hooks_for_object(filter_name).each do |hook|
+          rspec_context.instance_exec(&hook)
+        end
+      end
+
+      def hooks_for_object(filter_name)
+        config_hooks(filter_name) + object_hooks(filter_name)
+      end
+
+      def with_hooks(rspec_context)
+        execute_hook(:before, rspec_context)
+        yield
+        execute_hook(:after, rspec_context)
+      end
+
+      def contextual_object(option_name: nil, object: nil, context: nil)
+        context ||= rspec.described_class
+        object  ||= options[option_name]
+        case object
+        when Symbol
+          context.adapter.send(object)
+        when Proc
+          context.instance_exec(&object)
+        else
+          object
+        end
+      end
+
+      private
+
+      def must_be_a_block(block, error_message)
+        return block if block.respond_to?(:call)
+        raise error_message
+      end
+
+      def object_hooks(filter_name)
+        option_name = "#{ filter_name }_#{ self.class.name.split('::').last.downcase }".to_sym
+        [ *options[option_name] ].compact
+
+      end
+
+      def config_hooks(filter_name)
+        Vigia.config.hooks.each_with_object([]) do |hook, collection|
+          next unless self.is_a?(hook[:rspec_class]) and filter_name == hook[:filter]
+          collection << hook[:block]
+        end
+      end
+    end
+  end
+end

data/lib/vigia/spec/api_spec.rb

@@ -3,29 +3,5 @@
 describe Vigia::Rspec do
 
   described_class.include_shared_folders
-
-  described_class.apib.resource_groups.each do |resource_group|
-    describe description_for(resource_group) do
-      resource_group.resources.each do |resource|
-        describe description_for(resource) do
-          resource.actions.each do |action|
-            describe description_for(action) do
-              action.examples.each do |apib_example|
-                runner_example  = Vigia::Example.new(
-                                    resource: resource,
-                                    action: action,
-                                    apib_example: apib_example)
-
-                if runner_example.skip?
-                  include_examples 'skip example', runner_example
-                else
-                  include_examples 'apib example', runner_example
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
+  described_class.new.start_tests(self)
 end

data/lib/vigia/spec/support/utils.rb

@@ -1,20 +1,7 @@
 # encoding: utf-8
 
-def description_for object
-  case object
-  when RedSnow::ResourceGroup
-    "Resource Group: #{ object.name }"
-  when RedSnow::Resource
-    "Resource: #{ object.name } (#{ object.uri_template })"
-  when RedSnow::Action
-    "Action: #{ object.name } (#{ object.method })"
-  when RedSnow::Payload
-    "Response: #{ object.name }"
-  end
-end
-
 def format_error(result, expectation)
-  <<-FORMATTED_ERROR 
+  <<-FORMATTED_ERROR
 
   Expected:
 

data/lib/vigia/url.rb

@@ -8,41 +8,25 @@ module Vigia
     # ApiBluprint uses RFC6570 in all its resource's uri_templates
     # https://github.com/apiaryio/api-blueprint/blob/master/API%20Blueprint%20Specification.md#1-uri-templates
     def initialize(apib_uri_template)
-      @uri_template = ::URITemplate.new(:rfc6570, apib_uri_template)
+      @uri_template = Addressable::Template.new(apib_uri_template)
     end
 
     def expand(parameters)
-      validate(parameters) # if Vigia.config.validate_url_parameters?
-
-      absolute_url uri_template.expand(parameters.to_hash)
+      absolute_url uri_template.expand(valid_parameters(parameters).to_hash)
     end
 
     def absolute_url path
       URI.join(host, path).to_s
     end
 
-    def validate(parameters)
-      return if required_template_parameters.empty?
-
-      missing_parameters = required_template_parameters - valid_paremeters(parameters)
-
-      raise("Uri template #{ @uri_template } needs parameter/s #{ missing_parameters.join(',') }") unless missing_parameters.empty?
-    end
-
     def host
       Vigia.config.host
     end
 
     private
 
-    def valid_paremeters(parameters)
-      parameters.to_hash.delete_if{|_,v| v.nil? || v.empty? }.keys
-    end
-
-    def required_template_parameters
-      uri_template.tokens.select{
-        |token| token.is_a?(URITemplate::RFC6570::Expression::Basic)
-      }.map(&:variables).flatten
+    def valid_parameters(parameters)
+      Vigia::Parameters.new(parameters)
     end
   end
 end

data/lib/vigia/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Vigia
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/lib/vigia.rb

@@ -3,15 +3,21 @@
 require 'redsnow'
 require 'rspec'
 require 'rest_client'
-require 'uri_template'
+require 'addressable/template'
 
-require_relative 'vigia/blueprint'
+require_relative 'vigia/adapter'
+require_relative 'vigia/adapters/blueprint'
 require_relative 'vigia/config'
-require_relative 'vigia/example'
-require_relative 'vigia/headers'
+require_relative 'vigia/http_client/options'
 require_relative 'vigia/http_client/rest_client'
+require_relative 'vigia/http_client/requests'
 require_relative 'vigia/parameters'
 require_relative 'vigia/rspec'
+require_relative 'vigia/sail/rspec_object'
+require_relative 'vigia/sail/example'
+require_relative 'vigia/sail/context'
+require_relative 'vigia/sail/group'
+require_relative 'vigia/sail/group_instance'
 require_relative 'vigia/url'
 require_relative 'vigia/version'
 
@@ -23,7 +29,7 @@ module Vigia
     def configure
       @config = Vigia::Config.new
       yield @config
-      @config.validate!
+      @config.apply
     end
     def spec_folder
       File.join(__dir__, 'vigia', 'spec')