fakeit 0.6.1 → 0.8.0

data/lib/fakeit.rb

@@ -4,17 +4,18 @@ require 'open-uri'
 require 'base64'
 require 'openapi_parser'
 require 'faker'
+require 'regexp-examples'
 require 'rack'
 require 'logger'
 require 'rainbow'
 
-Dir.glob(File.join(File.dirname(__FILE__), 'fakeit', '**/*.rb')).sort.each { require _1 }
+Dir.glob(File.join(File.dirname(__FILE__), 'fakeit', '**/*.rb')).each { require _1 }
 
 module Fakeit
   class << self
     def build(spec_file, options)
       Rack::Builder.new do
-        run App.create(spec_file, options)
+        run App::AppBuilder.new(spec_file, options).build
       end
     end
   end

data/lib/fakeit/app/app_builder.rb

@@ -0,0 +1,23 @@
+module Fakeit
+  module App
+    class AppBuilder
+      def initialize(spec_file, options)
+        @config_route = Routes::ConfigRoute.new(options)
+        @openapi_route = Routes::OpenapiRoute.new(spec_file)
+      end
+
+      def build
+        proc do |env|
+          request = Rack::Request.new(env)
+
+          case request.path_info
+          when '/__fakeit_config__'
+            @config_route.call(request)
+          else
+            @openapi_route.call(request, @config_route.options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fakeit/app/helpers/body_parser.rb

@@ -0,0 +1,32 @@
+module Fakeit
+  module App
+    module Helpers
+      class BodyParser
+        class << self
+          def parse(request)
+            case request.media_type
+            when %r{^application/.*json}
+              { media_type: request.media_type, data: parse_json(request.body.read) }
+            when 'multipart/form-data'
+              { media_type: request.media_type, data: parse_form_data(request.params) }
+            else
+              { media_type: request.media_type, data: request.body.read }
+            end
+          end
+
+          private
+
+          def parse_json(body)
+            body.empty? ? {} : JSON.parse(body)
+          rescue StandardError
+            raise Fakeit::Validation::ValidationError, 'Invalid json payload'
+          end
+
+          def parse_form_data(params)
+            params.transform_values { |v| v.instance_of?(Hash) && v[:tempfile] ? v[:tempfile].read : v }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fakeit/app/helpers/response_builder.rb

@@ -0,0 +1,19 @@
+module Fakeit
+  module App
+    module Helpers
+      class ResponseBuilder
+        class << self
+          def error(code, err) = [code, { 'Content-Type' => 'application/json' }, [{ message: err.message }.to_json]]
+
+          def not_found = [404, {}, ['Not Found']]
+
+          def method_not_allowed = [405, {}, ['Method Not Allowed']]
+
+          def unsupported_media_type = [415, {}, ['Unsupported Media Type']]
+
+          def ok(body) = [200, { 'Content-Type' => 'application/json' }, [body.to_json]]
+        end
+      end
+    end
+  end
+end

data/lib/fakeit/app/options.rb

@@ -14,6 +14,16 @@ module Fakeit
       def use_static?(type: nil, property: nil)
         @static || @static_types.include?(type) || @static_properties.include?(property)
       end
+
+      def to_hash
+        {
+          permissive: @permissive,
+          use_example: @use_example,
+          static: @static,
+          static_types: @static_types,
+          static_properties: @static_properties
+        }
+      end
     end
   end
 end

data/lib/fakeit/app/routes/config_route.rb

@@ -0,0 +1,36 @@
+module Fakeit
+  module App
+    module Routes
+      class ConfigRoute
+        attr_reader :options
+
+        def initialize(options) = @options = options
+
+        def call(request)
+          case [request.request_method, request.media_type]
+          in ['GET', _]
+            Fakeit::App::Helpers::ResponseBuilder.ok(@options.to_hash)
+          in ['PUT', 'application/json']
+            update(request)
+          in ['PUT', _]
+            Fakeit::App::Helpers::ResponseBuilder.unsupported_media_type
+          else
+            Fakeit::App::Helpers::ResponseBuilder.method_not_allowed
+          end
+        end
+
+        private
+
+        def update(request)
+          body = Fakeit::App::Helpers::BodyParser.parse(request)[:data]
+          @options = Fakeit::App::Options.new(**body.transform_keys(&:to_sym))
+
+          Fakeit::App::Helpers::ResponseBuilder.ok(@options.to_hash)
+        rescue ArgumentError => e
+          Logger.warn(Rainbow(e.message).red)
+          Fakeit::App::Helpers::ResponseBuilder.error(422, e)
+        end
+      end
+    end
+  end
+end

data/lib/fakeit/app/routes/openapi_route.rb

@@ -0,0 +1,52 @@
+module Fakeit
+  module App
+    module Routes
+      class OpenapiRoute
+        def initialize(spec_file) = @specification = Fakeit::Openapi::Specification.new(spec_file)
+
+        def call(request, options)
+          @specification
+            .operation(request.request_method.downcase.to_sym, request.path_info, options)
+            .then { _1 ? handle(_1, request, options) : Fakeit::App::Helpers::ResponseBuilder.not_found }
+        end
+
+        private
+
+        def handle(operation, request, options)
+          validate(operation, request)
+          response(operation)
+        rescue Fakeit::Validation::ValidationError => e
+          Logger.warn(Rainbow(e.message).red)
+          options.permissive ? response(operation) : Fakeit::App::Helpers::ResponseBuilder.error(418, e)
+        end
+
+        def response(operation) = [operation.status, operation.headers, [operation.body]]
+
+        def validate(operation, request)
+          operation.validate(
+            body: Helpers::BodyParser.parse(request),
+            params: parse_query(request.query_string),
+            headers: headers(request)
+          )
+        end
+
+        def headers(request)
+          request
+            .each_header
+            .select { |k, _| k.start_with? 'HTTP_' }
+            .map { |k, v| [k.sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-'), v] }
+            .to_h
+        end
+
+        def parse_query(query_string)
+          rack_query = Rack::Utils.parse_nested_query(query_string)
+          cgi_query = CGI.parse(query_string)
+
+          rack_query.merge(cgi_query.slice(*rack_query.keys)) do |_, oldval, newval|
+            newval.is_a?(Array) && newval.size > 1 ? newval : oldval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fakeit/core_extensions/reference.rb

@@ -0,0 +1,9 @@
+require 'fakeit/openapi/schema'
+
+module OpenAPIParser
+  module Schemas
+    class Reference
+      def to_example(_) = raise(Fakeit::Openapi::ReferenceError, "Invalid $ref at \"#{ref}\"")
+    end
+  end
+end

data/lib/fakeit/core_extensions/schema.rb

@@ -7,9 +7,7 @@ module OpenAPIParser
 
       alias old_type type
 
-      def type
-        old_type || inferred_type
-      end
+      def type = old_type || inferred_type
 
       private
 

data/lib/fakeit/logger.rb

@@ -1,4 +1,3 @@
 module Fakeit
-  STDOUT.sync = true
-  Logger = ::Logger.new(STDOUT)
+  Logger = ::Logger.new($stderr)
 end

data/lib/fakeit/middleware/recorder.rb

@@ -1,9 +1,7 @@
 module Fakeit
   module Middleware
     class Recorder
-      def initialize(app)
-        @app = app
-      end
+      def initialize(app) = @app = app
 
       def call(env)
         env
@@ -20,9 +18,7 @@ module Fakeit
           &.tap { |body| body.rewind }
       end
 
-      def log_response(response)
-        Logger.info("Response body: #{response[2].first}")
-      end
+      def log_response(response) = Logger.info("Response body: #{response[2].first}")
     end
   end
 end

data/lib/fakeit/openapi/example/array_example.rb

@@ -33,25 +33,15 @@ module Fakeit
         end
       end
 
-      def add_depth(example_options)
-        { **example_options, depth: example_options[:depth] + 1 }
-      end
+      def add_depth(example_options) = { **example_options, depth: example_options[:depth] + 1 }
 
-      def need_retry?(item, result, retries)
-        uniqueItems && result.include?(item) && retries.positive?
-      end
+      def need_retry?(item, result, retries) = uniqueItems && result.include?(item) && retries.positive?
 
-      def non_empty_size
-        [min_array, 1].max
-      end
+      def non_empty_size = [min_array, 1].max
 
-      def min_array
-        minItems || 1
-      end
+      def min_array = minItems || 1
 
-      def max_array(depth)
-        maxItems || min_array + (depth > 1 ? 2 : 9)
-      end
+      def max_array(depth) = maxItems || min_array + (depth > 1 ? 2 : 9)
     end
   end
 end

data/lib/fakeit/openapi/example/integer_example.rb

@@ -29,21 +29,13 @@ module Fakeit
         end
       end
 
-      def int_rand_begin
-        min_int / int_multiple + int_rand_begin_adjust
-      end
+      def int_rand_begin = min_int / int_multiple + int_rand_begin_adjust
 
-      def int_rand_end
-        max_int / int_multiple
-      end
+      def int_rand_end = max_int / int_multiple
 
-      def int_rand_begin_adjust
-        (min_int % int_multiple).zero? ? 0 : 1
-      end
+      def int_rand_begin_adjust = (min_int % int_multiple).zero? ? 0 : 1
 
-      def int_multiple
-        multipleOf || 1
-      end
+      def int_multiple = multipleOf || 1
 
       def min_int
         if minimum

data/lib/fakeit/openapi/example/number_example.rb

@@ -14,35 +14,22 @@ module Fakeit
 
       private
 
-      def static_number_example
-        (num_rand_end * num_multiple)
-          .then { multipleOf ? _1 : _1.round(2) }
-      end
+      def static_number_example = (num_rand_end * num_multiple).then { multipleOf ? _1 : _1.round(2) }
 
       def random_number_example
         (Faker::Number.between(from: num_rand_begin, to: num_rand_end) * num_multiple)
           .then { multipleOf ? _1 : _1.round(2) }
       end
 
-      def num_rand_begin
-        multipleOf ? (min_num / multipleOf).ceil : min_num
-      end
+      def num_rand_begin = multipleOf ? (min_num / multipleOf).ceil : min_num
 
-      def num_rand_end
-        multipleOf ? (max_num / multipleOf).floor : max_num
-      end
+      def num_rand_end = multipleOf ? (max_num / multipleOf).floor : max_num
 
-      def num_multiple
-        multipleOf || 1
-      end
+      def num_multiple = multipleOf || 1
 
-      def min_num
-        (minimum || MIN_NUM).to_f.ceil(2)
-      end
+      def min_num = (minimum || MIN_NUM).to_f.ceil(2)
 
-      def max_num
-        (maximum || MAX_NUM).to_f.floor(2)
-      end
+      def max_num = (maximum || MAX_NUM).to_f.floor(2)
     end
   end
 end

data/lib/fakeit/openapi/example/string_example.rb

@@ -27,6 +27,8 @@ module Fakeit
       }.freeze
 
       def string_example(example_options)
+        @string_pattern ||= Regexp.new(pattern) if pattern
+
         if example_options[:use_static][type: 'string', property: example_options[:property]]
           static_string_example
         else
@@ -39,7 +41,7 @@ module Fakeit
       def static_string_example
         fixed_faker do
           if enum then enum.to_a.first
-          elsif pattern then Faker::Base.regexify(pattern)
+          elsif pattern then static_string_pattern
           elsif format then static_string_format
           elsif length_constraint then static_string_with_length
           else 'string'
@@ -56,43 +58,37 @@ module Fakeit
 
       def random_string_example
         if enum then enum.to_a.sample
-        elsif pattern then Faker::Base.regexify(pattern)
+        elsif pattern then random_string_pattern
         elsif format then random_string_format
         elsif length_constraint then string_with_length
         else Faker::Book.title
         end
       end
 
-      def static_string_with_length
-        '1' * max_string_length
-      end
+      def static_string_with_length = '1' * max_string_length
 
-      def static_string_format
-        (STATIC_FORMAT_HANDLERS[format] || method(:unknown_format))[]
-      end
+      def static_string_format = (STATIC_FORMAT_HANDLERS[format] || method(:unknown_format))[]
 
-      def length_constraint
-        minLength || maxLength
+      def static_string_pattern
+        @static_string_pattern ||= @string_pattern.examples(
+          max_repeater_variance: 1, max_group_results: 1, max_results_limit: 1
+        ).first
       end
 
-      def string_with_length
-        Faker::Internet.username(specifier: min_string_length..max_string_length)
-      end
+      def length_constraint = minLength || maxLength
 
-      def min_string_length
-        minLength || 0
-      end
+      def string_with_length = Faker::Internet.username(specifier: min_string_length..max_string_length)
 
-      def max_string_length
-        maxLength || min_string_length + 10
-      end
+      def min_string_length = minLength || 0
 
-      def random_string_format
-        (RANDOM_FORMAT_HANDLERS[format] || method(:unknown_format))[]
-      end
+      def max_string_length = maxLength || min_string_length + 10
+
+      def random_string_format = (RANDOM_FORMAT_HANDLERS[format] || method(:unknown_format))[]
+
+      def random_string_pattern = @random_string_pattern ||= @string_pattern.random_example(max_repeater_variance: 1)
 
       def unknown_format
-        Fakeit::Logger.info("Unknown string format: #{format}")
+        Logger.info("Unknown string format: #{format}")
         'Unknown string format'
       end
     end

data/lib/fakeit/openapi/operation.rb

@@ -7,9 +7,7 @@ module Fakeit
         @app_options = app_options
       end
 
-      def status
-        response.first.to_i
-      end
+      def status = response.first.to_i
 
       def headers
         response_headers
@@ -26,9 +24,7 @@ module Fakeit
           .to_s
       end
 
-      def validate(**request_parts)
-        @validator.validate(**request_parts)
-      end
+      def validate(...) = @validator.validate(...)
 
       private
 
@@ -36,25 +32,15 @@ module Fakeit
         { use_example: @app_options.use_example, use_static: @app_options.method(:use_static?), depth: 0 }
       end
 
-      def response_content
-        response.last.content&.find { |k, _| k =~ %r{^application/.*json} }
-      end
+      def response_content = response.last.content&.find { |k, _| k =~ %r{^application/.*json} }
 
-      def response_schema
-        response_content&.last
-      end
+      def response_schema = response_content&.last
 
-      def response_content_type
-        response_content&.first
-      end
+      def response_content_type = response_content&.first
 
-      def response_headers
-        response.last.headers
-      end
+      def response_headers = response.last.headers
 
-      def response
-        @request_operation.operation_object.responses.response.min
-      end
+      def response = @request_operation.operation_object.responses.response.min
     end
   end
 end