nec_mock_server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbf6ba4bd3541234bfd1bc9b98cc95672174c8a2
+  data.tar.gz: b079b4358a68b89072d8f12a77cd6c6e28652028
+SHA512:
+  metadata.gz: 6f7853a2f37895c03c94490bff7f051b01b4adae4bf9ff9a5cbb2ff7c441c48f70144738fcacee4e104490de241aa8880c7e1a4ef28d96891464df1542dd71f0
+  data.tar.gz: eeffd2706f79733a1260febf0ef9e6744596c34de7f68ac3dd40098fbe8cef530c993720b80c8fd67089b93c2f6321fffefd354c16b4e02ae7b708b6fdcf3f66

data/lib/nec_mock_server.rb

@@ -0,0 +1,13 @@
+require 'rack'
+require 'rack/server'
+require 'json'
+require 'fileutils'
+
+module NEC
+
+end
+
+
+Dir[File.dirname(__FILE__) + '/nec_mock_server/*.rb'].each do |file|
+  require(file.gsub('\\', '/').split('/lib/').last[0..-4])
+end

data/lib/nec_mock_server/mock_server.rb

@@ -0,0 +1,248 @@
+module NEC
+
+  ###
+  # Module of Mock Server
+  module MockServer
+
+    ###
+    # Server class. Represent main class of module #MockServe
+    class Server
+
+      attr_reader :router, :app
+
+      ###
+      # The method creates new instance of Rack::Server
+      #
+      # @param [MockServer::Router] router
+      # @param [Hash] application_opts
+      # @option application_opts [String] :application_name
+      # @option opts [Regexp] :matcher Define how to split parts of all request URL. Default is to #MATCHERS[:base]
+      # @option opts [Boolean] :only_registered_awid If set to true all requests that wasn't call on registered awid (by sys/iniAppWorkspace) will be rejected
+      # @option opts [Hash{TID => Array<AWID>}] :awids
+      # @option opts [Hash{TID => Array<ASIDS>}] :asids
+      def initialize(router, application_opts = {})
+        @router = (router || Router).new(application_opts[:application_name])
+        @app = Application.new(@router, application_opts)
+      end
+
+      ###
+      # The method stars server of instance
+      #
+      # @param [Numeric] port
+      # @param [String] host Default to 'localhost'
+      def run!(port, host = 'localhost')
+        @server = Rack::Server.start(app: @app, Port: port, Host: host)
+      end
+    end
+
+    ###
+    # Class represent trivial application to handle requests by defined router.
+    class Application
+
+      MATCHERS = {
+          base: /:\d+(\/(?<product>[\-\w]+)){0,1}(\/(?<tid>\w+)\-(?<awid>\w+)){0,1}(?<resource>(\/\w+)+)(\?(?<parameters>.*)){0,1}/
+      }
+
+      REGISTER_AWID_RESOURCE = '/sys/initAppWorkspace'
+
+      attr_reader :awids, :asids
+
+      ###
+      # The method create new instance of Application
+      #
+      # @param [MockServer::Router] router
+      # @param [Hash] opts
+      # @option opts [Regexp] :matcher Define how to split parts of all request URL. Default is to #MATCHERS[:base]
+      # @option opts [Boolean] :only_registered_awid If set to true all requests that wasn't call on registered awid (by sys/iniAppWorkspace) will be rejected
+      # @option opts [Hash{TID => Array<AWID>}] :awids
+      # @option opts [Hash{TID => Array<ASIDS>}] :asids
+      def initialize(router, opts = {})
+        @router = router
+        @only_registered_awid = opts[:only_registered_awid]
+        @url_parts_matcher = opts.fetch(:matcher) {MATCHERS[:base]}
+        @awids = opts.fetch(:awids){ {} }
+        @asids = opts.fetch(:asids){ {} }
+      end
+
+      ###
+      # The method prepare request and process request
+      #
+      # @param [Hash] env
+      def call(env)
+        request = Rack::Request.new(env)
+        serve_request(request)
+      end
+
+      ###
+      # The method handle received request.
+      #
+      # @param [Rack::Request] request
+      def serve_request(request)
+        parts = get_url_parts(request.url)
+
+        begin
+          io = request.body
+          data = io.read
+        ensure
+          io.close if io && io.respond_to?(:close) && io.respond_to?(:closed?) && !io.closed?
+        end
+
+        if parts[:resource] && parts[:resource] == REGISTER_AWID_RESOURCE
+          process_sys_init_app_workspace(parts, data)
+        end
+
+        if @only_registered_awid
+          return @router.no_registered_awid(parts[:tid], parts[:awid]) unless is_registered_resource?(parts[:tid], parts[:awid])
+        end
+
+        @router.route(parts, data)
+      end
+
+      private
+
+      def is_registered_awid?(tid, awid)
+        @awids[tid] && !(@awids[tid] & [awid]).empty?
+      end
+
+      def is_registered_asid?(tid, asid)
+        @awids[tid] && !(asids[tid] & [asid]).empty?
+      end
+
+      def is_registered_resource?(tid, awid)
+        is_registered_awid?(tid, awid) || is_registered_asid?(tid, awid)
+      end
+
+      def process_sys_init_app_workspace(parts, data)
+        hash = data.is_a?(Hash) ? data : JSON.parse(data.to_s, symbolize_names: true)
+
+        @awids[parts[:tid]] ||= []
+        @awids[parts[:tid]] << hash[:awid] if (@awids[parts[:tid]] & [hash[:awid]]).empty?
+
+        @asids[parts[:tid]] ||= []
+        @asids[parts[:tid]] << parts[:awid] if (@awids[parts[:tid]] & [parts[:awid]]).empty?
+
+        nil
+      end
+
+      ###
+      # The method helps to parse request url
+      def get_url_parts(path)
+        result = path.match(@url_parts_matcher)
+        result ? result.names.map {|name| name.to_sym}.zip(result.captures).to_h : {resource: ''}
+      end
+    end
+
+    ###
+    # Class represents all routes that application can served.
+    # For customize own mock application is necessary to create own router class by inheritance of this class
+    class Router
+
+      DEFAULT_APPLICATION_NAME = "Mock Server"
+
+      CONTENT_TYPES = {
+          text: {
+              plain: "text/plain"
+          },
+          application: {
+              json: "application/json"
+          }
+      }
+
+      DEFAULT_HEADER = {"Content-Type" => CONTENT_TYPES[:text][:plain]}
+      JSON_HEADER = {"Content-Type" => CONTENT_TYPES[:application][:json]}
+
+      ###
+      # The method create new instance of router
+      #
+      # @param [String] application_name
+      def initialize(application_name)
+        @application_name = application_name || DEFAULT_APPLICATION_NAME
+      end
+
+      ###
+      # The method process all operation on defined request URL and return response data
+      #
+      # @param [Hash] parts All parts find by specified matcher of URL request
+      # @param [String] request_data Received data by request
+      def route(parts, request_data)
+        case parts[:resource]
+          when "/", ""
+            home
+          when "/error"
+            error("Application exception")
+          else
+            not_found(parts[:resource])
+        end
+      end
+
+      ###
+      # The method represent default home route on "/" or ""
+      # Return 200 OK a and #application_name
+      def home
+        ok(@application_name)
+      end
+
+      ###
+      # The method represent base success response, 200 OK
+      #
+      # @param [Object] body Body of response
+      # @param [Hash] headers Headers of response
+      #
+      # @return [Array] response_data
+      def ok(body = nil, headers = DEFAULT_HEADER)
+        prepare_response_data(200, headers, body)
+      end
+
+      ###
+      # The method represent base not found response, 404 Not Found
+      #
+      # @param [String] resource Resource is required route part, which was no defined.
+      #
+      # @return [Array] response_data
+      def not_found(resource)
+        prepare_response_data(404, DEFAULT_HEADER, "Undefined Mock Server resource '#{resource}' for #{@application_name}")
+      end
+
+      ###
+      # The method represent specific not found response for request on no registered pair tid-awid
+      #
+      # @param [String] tid
+      # @param [String] awid
+      def no_registered_awid(tid, awid)
+        prepare_response_data(404, DEFAULT_HEADER, "Mock Server has no registered TID-AWID '#{tid}-#{awid}' for #{@application_name}")
+      end
+
+      ###
+      # The method represent base server error response, 500 Internal Server Error
+      #
+      # @param [Object] body Body of response
+      # @param [Hash] headers Headers of response
+      #
+      # @return [Array] response_data
+      def error(body, headers = DEFAULT_HEADER)
+        prepare_response_data(500, headers, body)
+      end
+
+      private
+
+      ###
+      # The method prepare response data as Array
+      #
+      # @param [String] http_code
+      # @param [Hash] headers
+      # @param [Object] body
+      #
+      # @param [Array] response_data
+      def prepare_response_data(http_code, headers, body)
+        body = body.nil? ? '' : body
+        body = body.to_json if body.is_a?(Hash)
+        body = body.to_s unless body.is_a?(String)
+
+        [http_code, headers.nil? ? DEFAULT_HEADER : headers, [body]]
+      end
+    end
+
+
+  end
+
+end

data/lib/nec_mock_server/mock_server_starter.rb

@@ -0,0 +1,46 @@
+module NEC
+  class MockServerStarter
+
+    RUN_SCRIPT_NAME = 'run.rb'
+
+    ###
+    # Create new instance of SubAppUnitTestHelper
+    #
+    # @param [String] sub_app_dir_path
+    # @param [Hash] opts
+    # @option opts [String] :run_scrip_name Default is #RUN_SCRIPT_NAME
+    def initialize(sub_app_dir_path, opts = {})
+      @path = File.expand_path(sub_app_dir_path, File.dirname(__FILE__))
+      @run_scrip_name = opts.fetch(:run_scrip_name) {RUN_SCRIPT_NAME}
+    end
+
+    ###
+    # The method start another sub application by defined path
+    # Sub app will be started in new command line with irb
+    #
+    def run!
+      create_threat
+    end
+
+    ###
+    # The method terminate exists thread of sub app
+    def stop
+      warn('! Method has no function implementation !')
+      # fixme how to stop thread with cmd window | some process kill by pid ...
+      @thread.terminate if @thread
+    end
+
+    private
+
+    ###
+    # The method create new thread for sub app and start it in new cmd window.
+    def create_threat
+      stop
+
+      @thread = Thread.new {
+        system("cd #{@path} && start irb -I . -r #{@run_scrip_name}")
+      }
+    end
+
+  end
+end

data/lib/nec_mock_server/version.rb

@@ -0,0 +1,3 @@
+module NECMockServerHelper
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: nec_mock_server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marek Filteš
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: NEC helper gem to create Unit Test mock server of sub application
+email:
+- marek.files@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nec_mock_server.rb
+- lib/nec_mock_server/mock_server.rb
+- lib/nec_mock_server/mock_server_starter.rb
+- lib/nec_mock_server/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.2
+signing_key: 
+specification_version: 4
+summary: NEC Mock Server
+test_files: []