spec_forge 0.1.0

data/lib/spec_forge/environment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Environment
+    attr_reader :environment, :framework
+
+    #
+    # Creates a new environment loader
+    #
+    # @param environment [Config::Environment] The environment to load
+    #
+    def initialize(environment = SpecForge.config.environment)
+      @environment = environment
+      @framework = environment.use
+    end
+
+    #
+    # Loads the environment
+    #
+    def load
+      load_framework
+      load_preload
+
+      self
+    end
+
+    private
+
+    def load_framework
+      case framework
+      when "rails"
+        load_rails
+      else
+        load_generic
+      end
+    end
+
+    def load_rails
+      path = SpecForge.root.join("config", "environment.rb")
+
+      if File.exist?(path)
+        require path
+      else
+        warn <<~WARNING.chomp
+          SpecForge warning: Config attribute "environment" set to "rails" but Rails environment (config/environment.rb) does not exist.
+          Factories or model-dependent features may not function as expected.
+            - For non-Rails projects, set your environment's 'models_path' or 'preload' in your config.yml
+            - To disable this warning, set 'environment: ""' in your config.yml.
+        WARNING
+      end
+    end
+
+    def load_generic
+      return unless environment.models_path? && environment.models_path.present?
+
+      models_path = SpecForge.root.join(environment.models_path)
+      return if !File.exist?(models_path)
+
+      Dir[models_path.join("**/*.rb")].each { |file| require file }
+    end
+
+    def load_preload
+      return unless environment.preload? && environment.preload.present?
+
+      path = SpecForge.root.join(environment.preload)
+      return if !File.exist?(path)
+
+      require path
+    end
+  end
+end

data/lib/spec_forge/error.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module SpecForge
+  # Pass into to_sentence
+  OR_CONNECTOR = {
+    last_word_connector: ", or ",
+    two_words_connector: " or ",
+    # This is a minor performance improvement to avoid locales being loaded
+    # This will need to be removed if locales are added
+    locale: false
+  }.freeze
+
+  private_constant :OR_CONNECTOR
+
+  class Error < StandardError; end
+
+  #
+  # Raised by Attribute::Faker when a provided classname does not exist in Faker
+  #
+  class InvalidFakerClassError < Error
+    CLASS_CHECKER = DidYouMean::SpellChecker.new(
+      dictionary: Faker::Base.descendants.map { |c| c.to_s.downcase.gsub!("::", ".") }
+    )
+
+    def initialize(input)
+      corrections = CLASS_CHECKER.correct(input)
+
+      super(<<~STRING.chomp
+        Undefined Faker class "#{input}". #{DidYouMean::Formatter.message_for(corrections)}
+
+        For available classes, please check https://github.com/faker-ruby/faker#generators.
+      STRING
+      )
+    end
+  end
+
+  #
+  # Raised by Attribute::Faker when a provided method for a Faker class does not exist.
+  #
+  class InvalidFakerMethodError < Error
+    def initialize(input, klass)
+      spell_checker = DidYouMean::SpellChecker.new(dictionary: klass.public_methods)
+      corrections = spell_checker.correct(input)
+
+      super(<<~STRING.chomp
+        Undefined Faker method "#{input}" for "#{klass}". #{DidYouMean::Formatter.message_for(corrections)}
+
+        For available methods for this class, please check https://github.com/faker-ruby/faker#generators.
+      STRING
+      )
+    end
+  end
+
+  #
+  # Raised by Attribute::Transform when the provided transform function is not valid
+  #
+  class InvalidTransformFunctionError < Error
+    def initialize(input)
+      # TODO: Update link to docs
+      super(<<~STRING.chomp
+        Undefined transform function "#{input}".
+
+        For available functions, please check https://github.com/itsthedevman/spec_forge.
+      STRING
+      )
+    end
+  end
+
+  #
+  # Raised by Attribute::Chainable when an step in the invocation chain is invalid
+  #
+  class InvalidInvocationError < Error
+    def initialize(step, object)
+      valid_operations =
+        case object
+        when ArrayLike
+          "Array index (0, 1, 2, etc.) or any Array methods (first, last, size, etc.)"
+        when HashLike
+          "Any Hash key: #{object.keys.join(", ")}"
+        else
+          "Any method available on #{object.class}"
+        end
+
+      super(<<~STRING.chomp
+        Cannot invoke "#{step}" on #{object.class}.
+
+        Valid operations include: #{valid_operations}
+      STRING
+      )
+    end
+  end
+
+  #
+  # An extended version of TypeError to make things easier when reporting invalid types
+  #
+  class InvalidTypeError < Error
+    def initialize(object, expected_type, **opts)
+      if expected_type.instance_of?(Array)
+        expected_type = expected_type.to_sentence(**OR_CONNECTOR)
+      end
+
+      message = "Expected #{expected_type}, got #{object.class}"
+      message += " for #{opts[:for]}" if opts[:for].present?
+
+      super(message)
+    end
+  end
+
+  #
+  # Raised by Attribute::Variable when the provided variable name is not defined
+  #
+  class MissingVariableError < Error
+    def initialize(variable_name)
+      super("Undefined variable \"#{variable_name}\" referenced in expectation")
+    end
+  end
+
+  #
+  # Raised by Normalizer when any errors are returned. Acts like a grouping of errors
+  #
+  class InvalidStructureError < Error
+    def initialize(errors)
+      message = errors.to_a.join_map("\n") do |error|
+        next error if error.is_a?(SpecForge::Error)
+
+        # Normal errors, let's get verbose
+        backtrace = SpecForge.backtrace_cleaner.clean(error.backtrace)
+        "#{error.inspect}\n  # ./#{backtrace.join("\n  # ./")}\n"
+      end
+
+      super(message)
+    end
+  end
+
+  #
+  # Raised by Attribute::Factory when an unknown build strategy is provided
+  #
+  class InvalidBuildStrategy < Error
+    def initialize(build_strategy)
+      valid_strategies = Attribute::Factory::BUILD_STRATEGIES.to_sentence(**OR_CONNECTOR)
+
+      super(<<~STRING.chomp
+        Unknown build strategy "#{build_strategy}" referenced in spec.
+
+        Valid strategies include: #{valid_strategies}
+      STRING
+      )
+    end
+  end
+end

data/lib/spec_forge/factory.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Factory
+    #
+    # Loads the factories from their yml files and registers them with FactoryBot
+    #
+    # @param path [String, Path] The base path where the factories directory are located
+    #
+    def self.load_and_register(base_path)
+      if (paths = SpecForge.config.factories.paths) && paths.size > 0
+        FactoryBot.definition_file_paths = paths
+      end
+
+      FactoryBot.find_definitions if SpecForge.config.factories.auto_discover?
+
+      factories = load_from_path(base_path.join("factories", "**/*.yml"))
+      factories.each(&:register)
+    end
+
+    #
+    # Loads any factories defined in the path. A single file can contain one or more factories
+    #
+    # @param path [String, Path] The path where the factories are located
+    #
+    # @return [Array<Factory>] An array of factories that were loaded.
+    #   Note: This factories have not been registered with FactoryBot.
+    #   See #register
+    #
+    def self.load_from_path(path)
+      factories = []
+
+      Dir[path].map do |file_path|
+        hash = YAML.load_file(file_path).deep_symbolize_keys
+
+        hash.each do |factory_name, factory_hash|
+          factory_hash[:name] = factory_name
+
+          factories << new(**factory_hash)
+        end
+      end
+
+      factories
+    end
+
+    ############################################################################
+
+    attr_reader :name, :input, :model_class, :variables, :attributes
+
+    #
+    # Creates a new Factory
+    #
+    # @param name [String] The name of the factory
+    # @param **input [Hash] Attributes to define the factory. See Normalizer::Factory
+    #
+    def initialize(name:, **input)
+      @name = name
+      input = Normalizer.normalize_factory!(input)
+
+      @input = input
+      @model_class = input[:model_class]
+
+      @variables = extract_variables(input)
+      @attributes = extract_attributes(input)
+    end
+
+    #
+    # Registers this factory with FactoryBot.
+    # Once registered, you can call FactoryBot.build and other methods
+    #
+    # @return [Self]
+    #
+    def register
+      dsl = FactoryBot::Syntax::Default::DSL.new
+
+      options = {}
+      options[:class] = model_class if model_class
+
+      # This creates the factory in FactoryBot
+      factory_forge = self
+      dsl.factory(name, options) do
+        factory_forge.attributes.each do |name, attribute|
+          add_attribute(name, &attribute.to_proc)
+        end
+      end
+
+      self
+    end
+
+    private
+
+    def extract_variables(input)
+      variables = Attribute.from(input[:variables])
+
+      # Update the variables that reference other variables lol
+      Attribute.bind_variables(variables, variables)
+    end
+
+    def extract_attributes(input)
+      attributes = Attribute.from(input[:attributes])
+      Attribute.bind_variables(attributes, variables)
+    end
+  end
+end

data/lib/spec_forge/http/backend.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module SpecForge
+  module HTTP
+    class Backend
+      attr_reader :connection
+
+      #
+      # Configures Faraday with the config values
+      #
+      # @param request [HTTP::Request]
+      #
+      def initialize(request)
+        @connection =
+          Faraday.new(url: request.base_url) do |builder|
+            # Authorization
+            builder.headers[request.authorization.header] = request.authorization.value
+
+            # Content-Type
+            if !request.headers.key?("Content-Type")
+              builder.request :json
+              builder.response :json
+            end
+
+            # Headers / Content Type
+            builder.headers.merge!(request.headers)
+
+            # Params
+            builder.params.merge!(request.query.resolve)
+          end
+      end
+
+      #
+      # Executes a DELETE request to <base_url>/<provided_url>
+      #
+      # @param url [String] The URL path to DELETE
+      # @param query [Hash] Any query attributes to send
+      # @param body [Hash]  Any body data to send
+      #
+      # @return [Hash] The response
+      #
+      def delete(url, query: {}, body: {})
+        connection.delete(url) { |request| update_request(request, query, body) }
+      end
+
+      #
+      # Executes a GET request to <base_url>/<provided_url>
+      #
+      # @param url [String] The URL path to GET
+      # @param query [Hash] Any query attributes to send
+      # @param body [Hash]  Any body data to send
+      #
+      # @return [Hash] The response
+      #
+      def get(url, query: {}, body: {})
+        connection.get(url) { |request| update_request(request, query, body) }
+      end
+
+      #
+      # Executes a PATCH request to <base_url>/<provided_url>
+      #
+      # @param url [String] The URL path to PATCH
+      # @param query [Hash] Any query attributes to send
+      # @param body [Hash]  Any body data to send
+      #
+      # @return [Hash] The response
+      #
+      def patch(url, query: {}, body: {})
+        connection.patch(url) { |request| update_request(request, query, body) }
+      end
+
+      #
+      # Executes a POST request to <base_url>/<provided_url>
+      #
+      # @param url [String] The URL path to POST
+      # @param query [Hash] Any query attributes to send
+      # @param body [Hash]  Any body data to send
+      #
+      # @return [Hash] The response
+      #
+      def post(url, query: {}, body: {})
+        connection.post(url) { |request| update_request(request, query, body) }
+      end
+
+      #
+      # Executes a PUT request to <base_url>/<provided_url>
+      #
+      # @param url [String] The URL path to PUT
+      # @param query [Hash] Any query attributes to send
+      # @param body [Hash]  Any body data to send
+      #
+      # @return [Hash] The response
+      #
+      def put(url, query: {}, body: {})
+        connection.put(url) { |request| update_request(request, query, body) }
+      end
+
+      private
+
+      def update_request(request, query, body)
+        request.params.merge!(query)
+        request.body = body.to_json
+      end
+    end
+  end
+end

data/lib/spec_forge/http/client.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SpecForge
+  module HTTP
+    class Client
+      attr_reader :request
+
+      #
+      # Creates a new HTTP client to middleman between the tests and the backend
+      #
+      # @param ** [Hash] Request attributes
+      #
+      def initialize(**)
+        @request = Request.new(**)
+        @adapter = Backend.new(request)
+      end
+
+      #
+      # Triggers an HTTP request to the URL
+      #
+      # @return [Hash] The response
+      #
+      def call
+        @adapter.public_send(
+          request.http_verb,
+          request.url,
+          query: request.query.transform_values(&:resolve),
+          body: request.body.transform_values(&:resolve)
+        )
+      end
+    end
+  end
+end

data/lib/spec_forge/http/request.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module SpecForge
+  module HTTP
+    attributes = [:base_url, :url, :http_method, :headers, :query, :body, :authorization]
+
+    class Request < Data.define(*attributes)
+      HEADER = /^[A-Z][A-Za-z0-9!-]*$/
+
+      #
+      # Initializes a new Request instance with the given options
+      #
+      # @param [Hash] options The options to create the Request with
+      #
+      # @option options [String] :url The request URL
+      #
+      # @option options [String, Verb] :http_method The HTTP method to use
+      #
+      # @option options [Hash] :headers Any headers
+      #
+      # @option options [Hash] :query The query parameters for the request (defaults to {})
+      #
+      # @option options [Hash] :body The request body (defaults to {})
+      #
+      def initialize(**options)
+        base_url = extract_base_url(options)
+        url = extract_url(options)
+        headers = normalize_headers(options)
+        http_method = normalize_http_method(options)
+        query = normalize_query(options)
+        body = normalize_body(options)
+        authorization = extract_authorization(options)
+
+        super(base_url:, url:, http_method:, headers:, query:, body:, authorization:)
+      end
+
+      def http_verb
+        http_method.name.downcase
+      end
+
+      private
+
+      def extract_base_url(options)
+        options[:base_url]&.value&.presence || SpecForge.config.base_url
+      end
+
+      def extract_url(options)
+        options[:url].value
+      end
+
+      def normalize_http_method(options)
+        method = options[:http_method].value.presence || "GET"
+
+        if method.is_a?(String)
+          Verb.from(method)
+        else
+          method
+        end
+      end
+
+      def normalize_headers(options)
+        headers = options[:headers].transform_keys do |key|
+          key = key.to_s
+
+          # If the key is already like a header, don't change it
+          if key.match?(HEADER)
+            key
+          else
+            # content_type => Content-Type
+            key.downcase.titleize.gsub(/\s+/, "-")
+          end
+        end
+
+        headers = Attribute.bind_variables(headers, options[:variables])
+        Attribute::ResolvableHash.new(headers)
+      end
+
+      def normalize_query(options)
+        query = Attribute.bind_variables(options[:query], options[:variables])
+        Attribute::ResolvableHash.new(query)
+      end
+
+      def normalize_body(options)
+        body = Attribute.bind_variables(options[:body], options[:variables])
+        Attribute::ResolvableHash.new(body)
+      end
+
+      def extract_authorization(options)
+        SpecForge.config.authorization.default
+      end
+    end
+  end
+end

data/lib/spec_forge/http/verb.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SpecForge
+  module HTTP
+    class Verb < Data.define(:name)
+      class Delete < Verb
+        def initialize = super(name: "DELETE")
+      end
+
+      class Get < Verb
+        def initialize = super(name: "GET")
+      end
+
+      class Patch < Verb
+        def initialize = super(name: "PATCH")
+      end
+
+      class Post < Verb
+        def initialize = super(name: "POST")
+      end
+
+      class Put < Verb
+        def initialize = super(name: "PUT")
+      end
+
+      DELETE = Delete.new
+      GET = Get.new
+      PATCH = Patch.new
+      POST = Post.new
+      PUT = Put.new
+
+      VERBS = {
+        delete: DELETE,
+        get: GET,
+        patch: PATCH,
+        post: POST,
+        put: PUT
+      }.freeze
+
+      #
+      # Retrieves the corresponding Verb instance based on the provided HTTP name
+      #
+      # @param name [String, Symbol] The HTTP name to look up (case-insensitive)
+      #
+      # @return [Verb, nil] The corresponding Verb instance, or nil if not found
+      #
+      def self.from(name)
+        VERBS[name.downcase.to_sym]
+      end
+
+      #
+      # Returns if this Verb name matches another Verb's name, or the name
+      # as a String or Symbol
+      #
+      # @param other [Object] The thing to check against this object
+      #
+      # @return [Boolean]
+      #
+      def ==(other)
+        case other
+        when Verb
+          name == other.name
+        when String, Symbol
+          self == self.class.from(other)
+        else
+          false
+        end
+      end
+
+      alias_method :to_s, :name
+
+      #
+      # Returns if this Verb is a DELETE
+      #
+      # @return [Boolean]
+      #
+      def delete?
+        name == "DELETE"
+      end
+
+      #
+      # Returns if this Verb is a GET
+      #
+      # @return [Boolean]
+      #
+      def get?
+        name == "GET"
+      end
+
+      #
+      # Returns if this Verb is a PATCH
+      #
+      # @return [Boolean]
+      #
+      def patch?
+        name == "PATCH"
+      end
+
+      #
+      # Returns if this Verb is a POST
+      #
+      # @return [Boolean]
+      #
+      def post?
+        name == "POST"
+      end
+
+      #
+      # Returns if this Verb is a PUT
+      #
+      # @return [Boolean]
+      #
+      def put?
+        name == "PUT"
+      end
+    end
+  end
+end

data/lib/spec_forge/http.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "http/backend"
+require_relative "http/client"
+require_relative "http/verb"
+require_relative "http/request"