tshield 0.10.0.0 → 0.11.0.0

data/lib/tshield/request_matching.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'tshield/request'
+
+DEFAULT_SESSION = 'no-session'
+
+module TShield
+  # Class to check request matching
+  class RequestMatching
+    attr_reader :matched
+
+    def initialize(path, options = {})
+      super()
+      @path = path
+      @options = options
+      @options[:session] ||= DEFAULT_SESSION
+      @options[:method] ||= 'GET'
+
+      klass = self.class
+      klass.load_stubs unless klass.stubs
+    end
+
+    def match_request
+      @matched = find_stub
+      return unless matched
+
+      TShield::Response.new(matched['body'],
+                            matched['headers'],
+                            matched['status'])
+    end
+
+    private
+
+    def find_stub
+      stubs = self.class.stubs
+      result = filter_stubs(stubs[@options[:session]])
+      return result if result
+
+      filter_stubs(stubs[DEFAULT_SESSION]) unless @options[:session] == DEFAULT_SESSION
+    end
+
+    def filter_by_method(stubs)
+      stubs.select { |stub| stub['method'] == @options[:method] }
+    end
+
+    def filter_by_headers(stubs)
+      stubs.select { |stub| self.class.include_headers(stub['headers'], @options[:headers]) }
+    end
+
+    def filter_by_query(stubs)
+      stubs.select { |stub| self.class.include_query(stub['query'], @options[:raw_query] || '') }
+    end
+
+    def filter_stubs(stubs)
+      result = filter_by_query(filter_by_headers(filter_by_method(stubs[@path] || [])))
+      result[0]['response'] unless result.empty?
+    end
+
+    class << self
+      attr_reader :stubs
+
+      def load_stubs
+        @stubs = {}
+        Dir.glob('matching/**/*.json').each do |entry|
+          load_stub(entry)
+        end
+      end
+
+      def load_stub(file)
+        content = JSON.parse File.open(file).read
+        content.each do |stub|
+          stub_session_name = init_stub_session(stub)
+
+          if stub['stubs']
+            load_items(stub['stubs'] || [], stub_session_name)
+          else
+            load_item(stub, stub_session_name)
+          end
+        end
+      end
+
+      def init_stub_session(stub)
+        stub_session_name = stub['session'] || DEFAULT_SESSION
+        stubs[stub_session_name] ||= {}
+        stub_session_name
+      end
+
+      def load_items(items, session_name)
+        items.each { |item| load_item(item, session_name) }
+      end
+
+      def load_item(item, session_name)
+        stubs[session_name][item['path']] ||= []
+        stubs[session_name][item['path']] << item
+      end
+
+      def include_headers(stub_headers, request_headers)
+        request_headers ||= {}
+        stub_headers ||= {}
+        result = stub_headers.reject { |key, value| request_headers[key.to_rack_name] == value }
+        result.empty? || stub_headers.empty?
+      end
+
+      def include_query(stub_query, raw_query)
+        request_query = build_query_hash(raw_query)
+        stub_query ||= {}
+        result = stub_query.reject { |key, value| request_query[key] == value.to_s }
+        result.empty? || stub_query.empty?
+      end
+
+      def build_query_hash(raw_query)
+        params = {}
+        raw_query.split('&').each do |query|
+          key, value = query.split('=')
+          params[key] = value
+        end
+
+        params
+      end
+    end
+  end
+end

data/lib/tshield/request_vcr.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'json'
+require 'byebug'
+
+require 'digest/sha1'
+
+require 'tshield/configuration'
+require 'tshield/options'
+require 'tshield/request'
+require 'tshield/response'
+
+module TShield
+  # Module to write and read saved responses
+  class RequestVCR < TShield::Request
+    attr_reader :response
+
+    def initialize(path, options = {})
+      super()
+      @path = path
+      @options = options
+
+      request_configuration = configuration.request
+      @options[:timeout] = request_configuration['timeout']
+      @options[:verify] = request_configuration['verify_ssl']
+      request
+    end
+
+    def request
+      unless @options[:raw_query].nil? || @options[:raw_query].empty?
+        @path = "#{@path}?#{@options[:raw_query]}"
+      end
+
+      @url = "#{domain}#{@path}"
+
+      if exists
+        @response = current_response
+        @response.original = false
+      else
+        @method = method
+        configuration.get_before_filters(domain).each do |filter|
+          @method, @url, @options = filter.new.filter(@method, @url, @options)
+        end
+
+        raw = HTTParty.send(@method.to_s, @url, @options)
+
+        configuration.get_after_filters(domain).each do |filter|
+          raw = filter.new.filter(raw)
+        end
+
+        @response = save(raw)
+
+        @response.original = true
+      end
+      current_session[:counter].add(@path, method) if current_session
+      @response
+    end
+
+    private
+
+    def domain
+      @domain ||= configuration.get_domain_for(@path)
+    end
+
+    def name
+      @name ||= configuration.get_name(domain)
+    end
+
+    def save(raw_response)
+      headers = {}
+      raw_response.headers.each do |k, v|
+        headers[k] = v unless configuration.not_save_headers(domain).include? k
+      end
+
+      content = {
+        body: raw_response.body,
+        status: raw_response.code,
+        headers: headers
+      }
+
+      write(content)
+
+      TShield::Response.new(raw_response.body, headers, raw_response.code)
+    end
+
+    def saved_content
+      return @saved_content if @saved_content
+
+      @saved_content = JSON.parse(File.open(headers_destiny).read)
+      @saved_content['body'] = File.open(content_destiny).read unless @saved_content['body']
+      @saved_content
+    end
+
+    def file_exists
+      session = current_session
+      @content_idx = session ? session[:counter].current(@path, method) : 0
+      File.exist?(content_destiny)
+    end
+
+    def exists
+      file_exists && configuration.cache_request?(domain)
+    end
+
+    def current_response
+      TShield::Response.new(saved_content['body'],
+                            saved_content['headers'] || [],
+                            saved_content['status'] || 200)
+    end
+
+    def key
+      @key ||= Digest::SHA1.hexdigest "#{@url}|#{method}"
+    end
+
+    def write(content)
+      content_file = File.open(content_destiny, 'w')
+      content_file.write(content[:body])
+      content_file.close
+
+      body = content.delete :body
+
+      headers_file = File.open(headers_destiny, 'w')
+      headers_file.write(JSON.pretty_generate(content))
+      headers_file.close
+
+      content[:body] = body
+    end
+
+    def safe_dir(url)
+      if url.size > 225
+        path = url.gsub(/(\?.*)/, '')
+        params = Digest::SHA1.hexdigest Regexp.last_match(1)
+        "#{path.gsub(%r{/}, '-').gsub(/^-/, '')}?#{params}"
+      else
+        url.gsub(%r{/}, '-').gsub(/^-/, '')
+      end
+    end
+  end
+end

data/lib/tshield/response.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module TShield
+  # Response Object
   class Response
-    attr_accessor :body, :headers, :status, :original
+    attr_accessor :original
+    attr_reader :body, :headers, :status
 
     def initialize(body, headers, status)
       @body = body

data/lib/tshield/server.rb

@@ -3,6 +3,7 @@
 require 'sinatra'
 require 'haml'
 
+require 'tshield/options'
 require 'tshield/controllers/requests'
 require 'tshield/controllers/sessions'
 
@@ -15,6 +16,7 @@ module TShield
     set :public_dir, File.join(File.dirname(__FILE__), 'assets')
     set :views, File.join(File.dirname(__FILE__), 'views')
     set :bind, '0.0.0.0'
+    set :port, TShield::Options.instance.port
 
     def self.register_resources
       load_controllers
@@ -26,8 +28,6 @@ module TShield
       return unless File.exist?('controllers')
 
       Dir.entries('controllers').each do |entry|
-        require 'byebug'
-        debugger
         next if entry =~ /^\.\.?$/
 
         entry.gsub!('.rb', '')

data/lib/tshield/version.rb

@@ -4,7 +4,7 @@ module TShield
   # Control version of gem
   class Version
     MAJOR = 0
-    MINOR = 10
+    MINOR = 11
     PATCH = 0
     PRE = 0
 

data/spec/spec_helper.rb

@@ -9,6 +9,8 @@ SimpleCov.start
 require 'httparty'
 require 'webmock/rspec'
 
+require 'tshield/extensions/string_extensions'
+
 RSpec.configure do |config|
   config.before(:each) do
     allow(File).to receive(:join).and_return(

data/spec/tshield/configuration_spec.rb

@@ -29,6 +29,12 @@ describe TShield::Configuration do
         )
       end
 
+      it 'recover skip query params' do
+        expect(@configuration.domains['example.org']['skip_query_params']).to(
+          include('a')
+        )
+      end
+
       context 'on load filters' do
         it 'recover filters for a domain' do
           expect(@configuration.get_filters('example.org')).to eq([ExampleFilter])

data/spec/tshield/fixtures/config/tshield.yml

@@ -9,6 +9,8 @@ domains:
     paths:
       - '/api/one'
       - '/api/two'
+    skip_query_params:
+      - 'a'
   'example.com':
     name: 'example.com'
     paths:

data/spec/tshield/fixtures/matching/example.json

@@ -0,0 +1,55 @@
+[{
+    "method": "GET",
+    "path": "/matching/example",
+    "query": {
+      "query1": "value"
+    },
+    "response": {
+      "status": 200,
+      "headers": {},
+      "body": "query content"
+    }
+  },
+  {
+    "method": "GET",
+    "path": "/matching/example",
+    "response": {
+      "status": 200,
+      "headers": {},
+      "body": "body content"
+    }
+  },
+  {
+    "method": "POST",
+    "path": "/matching/example",
+    "headers": {
+      "header1": "value"
+    },
+    "response": {
+      "status": 201,
+      "headers": {},
+      "body": "headers content"
+    }
+  },
+  {
+    "method": "POST",
+    "path": "/matching/example",
+    "response": {
+      "status": 201,
+      "headers": {},
+      "body": "post content"
+    }
+  },
+  {
+    "session": "a-session",
+    "stubs": [{
+      "method": "GET",
+      "path": "/matching/example",
+      "response": {
+        "status": 200,
+        "headers": {},
+        "body": "body content in session"
+      }
+    }]
+  }
+]

data/spec/tshield/options_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: false
+
+require 'optparse'
+require 'tshield/options'
+require 'spec_helper'
+
+describe TShield::Options do
+  context 'with parsing' do
+    before :each do
+      options_parser = double
+      @opts = double
+
+      allow(OptionParser).to receive(:new)
+        .and_return(options_parser)
+        .and_yield(@opts)
+
+      allow(options_parser).to receive(:parse!)
+
+      allow(@opts).to receive(:banner=)
+      allow(@opts).to receive(:on)
+      allow(@opts).to receive(:on_tail)
+    end
+
+    it 'should recover default port' do
+      TShield::Options.init
+      expect(TShield::Options.instance.port).to eql(4567)
+    end
+
+    it 'should recover custom port' do
+      allow(@opts).to receive(:on)
+        .with('-p', '--port [PORT]', 'Sinatra port')
+        .and_yield('4568')
+
+      TShield::Options.init
+      expect(TShield::Options.instance.port).to eql(4568)
+    end
+  end
+end

data/spec/tshield/request_matching_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'tshield/configuration'
+require 'tshield/request_matching'
+require 'tshield/response'
+
+describe TShield::RequestMatching do
+  before :each do
+    @configuration = double
+    allow(TShield::Configuration)
+      .to receive(:singleton).and_return(@configuration)
+  end
+
+  context 'matching path' do
+    before :each do
+      allow(Dir).to receive(:glob)
+        .and_return(['spec/tshield/fixtures/matching/example.json'])
+    end
+
+    context 'on loading stubs' do
+      before :each do
+        @request_matching = TShield::RequestMatching.new('/')
+      end
+      context 'for path /matching/example' do
+        it 'should map path' do
+          expect(@request_matching.class.stubs[DEFAULT_SESSION]).to include('/matching/example')
+        end
+        context 'on settings' do
+          before :each do
+            @entry = @request_matching.class.stubs[DEFAULT_SESSION]['/matching/example'][0]
+          end
+          it 'should answer for the method GET' do
+            expect(@entry['method']).to include('GET')
+          end
+          it 'should have response body' do
+            expect(@entry['response']['body']).to include('query content')
+          end
+        end
+      end
+    end
+
+    context 'on matching request' do
+      context 'on match' do
+        before :each do
+          @request_matching = TShield::RequestMatching.new('/matching/example', method: 'GET')
+        end
+        it 'should return response object' do
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('body content')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(200)
+        end
+      end
+      context 'on match by path and method' do
+        before :each do
+          @request_matching = TShield::RequestMatching
+                              .new('/matching/example', method: 'POST')
+        end
+        it 'should return response object' do
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('post content')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(201)
+        end
+      end
+      context 'on match by path and method and headers' do
+        before :each do
+          @request_matching = TShield::RequestMatching
+                              .new('/matching/example',
+                                   method: 'POST',
+                                   headers: { 'HTTP_HEADER1' => 'value' })
+        end
+        it 'should return response object' do
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('headers content')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(201)
+        end
+      end
+      context 'on match by path and method and query' do
+        before :each do
+          @request_matching = TShield::RequestMatching
+                              .new('/matching/example',
+                                   method: 'GET',
+                                   raw_query: 'query1=value')
+        end
+        it 'should return response object' do
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('query content')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(200)
+        end
+      end
+      context 'on not match' do
+        before :each do
+          @request_matching = TShield::RequestMatching.new('/')
+        end
+        it 'should return nil' do
+          expect(@request_matching.match_request).to be_nil
+        end
+      end
+    end
+    context 'on session' do
+      context 'load session infos' do
+        before :each do
+          @request_matching = TShield::RequestMatching.new('/')
+        end
+
+        it 'should map path' do
+          expect(@request_matching.class.stubs['a-session']).to include('/matching/example')
+        end
+      end
+      context 'on match' do
+        it 'should return response object from session settings' do
+          @request_matching = TShield::RequestMatching.new('/matching/example',
+                                                           method: 'GET',
+                                                           session: 'a-session')
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('body content in session')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(200)
+        end
+        it 'should return response object from default settings' do
+          @request_matching = TShield::RequestMatching.new('/matching/example',
+                                                           method: 'POST',
+                                                           session: 'a-session')
+          @response = @request_matching.match_request
+          expect(@response.body).to eql('post content')
+          expect(@response.headers).to eql({})
+          expect(@response.status).to eql(201)
+        end
+      end
+    end
+  end
+end