spec_forge 0.1.0

data/lib/spec_forge/attribute.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# Need to be first
+require_relative "attribute/parameterized"
+require_relative "attribute/chainable"
+require_relative "attribute/resolvable"
+
+# Doesn't matter
+require_relative "attribute/factory"
+require_relative "attribute/faker"
+require_relative "attribute/literal"
+require_relative "attribute/matcher"
+require_relative "attribute/resolvable_array"
+require_relative "attribute/resolvable_hash"
+require_relative "attribute/transform"
+require_relative "attribute/variable"
+
+module SpecForge
+  class Attribute
+    #
+    # Binds variables to Attribute objects
+    #
+    # @param input [Array, Hash, Attribute] The input to loop through or bind to
+    # @param variables [Hash] Any variables to available to assign
+    #
+    # @return [Array, Hash, Attribute] The input with bounded variables
+    #
+    def self.bind_variables(input, variables = {})
+      case input
+      when ArrayLike
+        input.each { |v| v.bind_variables(variables) }
+      when HashLike
+        input.each_value { |v| v.bind_variables(variables) }
+      when Attribute
+        input.bind_variables(variables)
+      end
+
+      input
+    end
+
+    #
+    # Creates an Attribute instance based on the input value's type and content.
+    # Recursively converts Array and Hash
+    #
+    # @param value [Object] The input value to convert into an Attribute
+    #
+    # @return [Attribute] A new Attribute instance of the appropriate subclass
+    #
+    def self.from(value)
+      case value
+      when String
+        from_string(value)
+      when HashLike
+        from_hash(value)
+      when Attribute
+        value
+      when ArrayLike
+        array = value.map { |v| Attribute.from(v) }
+        Attribute::ResolvableArray.new(array)
+      else
+        Literal.new(value)
+      end
+    end
+
+    #
+    # Creates an Attribute instance from a string, handling any macros
+    #
+    # @param string [String] The input string
+    #
+    # @return [Attribute]
+    #
+    # @private
+    #
+    def self.from_string(string)
+      case string
+      when Faker::KEYWORD_REGEX
+        Faker.new(string)
+      when Variable::KEYWORD_REGEX
+        Variable.new(string)
+      when Matcher::KEYWORD_REGEX
+        Matcher.new(string)
+      when Factory::KEYWORD_REGEX
+        Factory.new(string)
+      else
+        Literal.new(string)
+      end
+    end
+
+    #
+    # Creates an Attribute instance from a hash, handling any macros
+    #
+    # @param hash [Hash] The input hash
+    #
+    # @return [Attribute]
+    #
+    # @private
+    #
+    def self.from_hash(hash)
+      # Determine if the hash is an expanded macro call
+      has_macro = ->(h, regex) { h.any? { |k, _| k.match?(regex) } }
+
+      if has_macro.call(hash, Transform::KEYWORD_REGEX)
+        Transform.from_hash(hash)
+      elsif has_macro.call(hash, Faker::KEYWORD_REGEX)
+        Faker.from_hash(hash)
+      elsif has_macro.call(hash, Matcher::KEYWORD_REGEX)
+        Matcher.from_hash(hash)
+      elsif has_macro.call(hash, Factory::KEYWORD_REGEX)
+        Factory.from_hash(hash)
+      else
+        hash = hash.transform_values { |v| Attribute.from(v) }
+        Attribute::ResolvableHash.new(hash)
+      end
+    end
+
+    attr_reader :input
+
+    #
+    # @param input [Object] Anything
+    #
+    def initialize(input)
+      @input = input
+    end
+
+    #
+    # Returns the processed value of the input
+    #
+    # For literals, this is the input itself.
+    # For generated values (Faker, Transform), this is the result of their operations.
+    #
+    # @return [Object] The processed value of this attribute
+    #
+    # @raise [RuntimeError] if not implemented by subclass
+    #
+    def value
+      raise "not implemented"
+    end
+
+    #
+    # Returns the fully evaluated result, recursively resolving any nested attributes
+    # Note: This method can only be called once to ensure data is correct across the board
+    # You can still call #value if you need a new value
+    #
+    # @return [Object] The resolved value
+    #
+    # @example Simple literal
+    #   attr = Attribute::Literal.new("hello")
+    #   attr.resolve # => "hello"
+    #
+    # @example Nested array with faker
+    #   attr = Attribute::Literal.new(["faker.number.positive", ["faker.name.first_name"]])
+    #   attr.resolve # => [42, ["Jane"]]
+    #
+    def resolve
+      # Past test for the variable
+      @resolved ||= __resolve(value)
+    end
+
+    #
+    # Wraps the call to #resolve in a proc. Used with FactoryBot
+    #
+    # @return [Proc]
+    #
+    def to_proc
+      this = self # kek - what are we, javascript?
+      -> { this.resolve }
+    end
+
+    #
+    # Compares this attributes input to other
+    #
+    # @param other [Object, Attribute] If another Attribute, the input will be compared
+    #
+    # @return [Boolean]
+    #
+    def ==(other)
+      other =
+        if other.is_a?(Attribute)
+          other.input
+        else
+          other
+        end
+
+      input == other
+    end
+
+    #
+    # Used to bind variables to self or any sub attributes
+    #
+    # @param variables [Hash] A hash of variable attributes
+    #
+    def bind_variables(_variables)
+    end
+
+    protected
+
+    def __resolve(value)
+      case value
+      when ArrayLike
+        value.map(&:resolve)
+      when HashLike
+        value.transform_values(&:resolve)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/spec_forge/cli/actions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class CLI
+    module Actions
+      def self.included(base)
+        base.define_method(:actions) do
+          @actions ||= ActionContext.new
+        end
+      end
+    end
+
+    class ActionContext < Thor
+      include Thor::Actions
+
+      def initialize(...)
+        self.class.source_root(File.expand_path("../../templates", __dir__))
+        self.destination_root = SpecForge.root
+        self.options = {}
+      end
+    end
+  end
+end

data/lib/spec_forge/cli/command.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class CLI
+    class Command
+      include CLI::Actions
+
+      class << self
+        attr_writer(*%i[
+          command_name
+          syntax
+          description
+          summary
+          options
+        ])
+
+        #
+        # The command's name
+        #
+        # @param name [String] The name of the command
+        #
+        def command_name(name)
+          self.command_name = name
+        end
+
+        #
+        # The command's syntax
+        #
+        # @param syntax [String]
+        #
+        def syntax(syntax)
+          self.syntax = syntax
+        end
+
+        #
+        # The command's description, long form
+        #
+        # @param description [String]
+        #
+        def description(description)
+          self.description = description
+        end
+
+        #
+        # The command's summary, short form
+        #
+        # @param summary [String]
+        #
+        def summary(summary)
+          self.summary = summary
+        end
+
+        #
+        # Defines an example on how to use the command
+        #
+        # @param command [String] The example
+        # @param description [String] Description of the example
+        #
+        def example(command, description)
+          @examples ||= []
+
+          # Commander wants it backwards
+          @examples << [description, command]
+        end
+
+        #
+        # Defines a command flag (-f, --force)
+        #
+        def option(*args, &block)
+          @options ||= []
+
+          @options << [args, block]
+        end
+
+        #
+        # Defines any aliases for this command
+        #
+        # @param *aliases [Array<String>]
+        #
+        def aliases(*aliases)
+          @aliases ||= []
+
+          @aliases += aliases
+        end
+
+        #
+        # Registers the command with Commander
+        #
+        # @param context [Commander::Command]
+        #
+        # @private
+        #
+        def register(context)
+          raise "Missing command name" if @command_name.nil?
+
+          context.command(@command_name) do |c|
+            c.syntax = @syntax
+            c.summary = @summary
+            c.description = @description
+            c.examples = @examples if @examples
+
+            @options&.each do |opts, block|
+              c.option(*opts, &block)
+            end
+
+            c.action { |args, opts| new(args, opts).call }
+          end
+
+          @aliases&.each do |alii|
+            context.alias_command(alii, @command_name)
+          end
+        end
+      end
+
+      attr_reader :arguments, :options
+
+      #
+      # @param arguments [Array] Any positional arguments
+      # @param options [Hash] Any flag arguments
+      #
+      def initialize(arguments, options)
+        @arguments = arguments
+        @options = options
+      end
+    end
+  end
+end

data/lib/spec_forge/cli/init.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class CLI
+    class Init < Command
+      command_name "init"
+      syntax "init"
+      summary "Initializes directory structure and configuration files"
+
+      def call
+        base_path = SpecForge.forge
+        actions.empty_directory "#{base_path}/factories"
+        actions.empty_directory "#{base_path}/specs"
+
+        actions.template(
+          "config.tt",
+          SpecForge.root.join(base_path, "config.yml"),
+          context: binding
+        )
+      end
+
+      def default_authorization_value
+        <<~STRING.chomp
+          Bearer <%= ENV.fetch("API_TOKEN", "") %>
+        STRING
+      end
+    end
+  end
+end

data/lib/spec_forge/cli/new.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class CLI
+    class New < Command
+      command_name "new"
+      summary "Create a new spec or factory"
+
+      syntax "new <type> <name>"
+
+      example "new spec users",
+        "Creates a new spec located at 'spec_forge/specs/users.yml'"
+
+      example "new factory user",
+        "Creates a new factory located at 'spec_forge/factories/user.yml'"
+
+      example "generate spec accounts",
+        "Uses the generate alias (shorthand 'g') instead of 'new'"
+
+      aliases :generate, :g
+
+      def call
+        type = arguments.first.downcase
+        name = arguments.second
+
+        # Cleanup
+        name.delete_suffix!(".yml") if name.end_with?(".yml")
+        name.delete_suffix!(".yaml") if name.end_with?(".yaml")
+
+        case type
+        when "spec"
+          create_new_spec(name)
+        when "factory"
+          create_new_factory(name)
+        end
+      end
+
+      private
+
+      def create_new_spec(name)
+        actions.create_file(
+          SpecForge.forge.join("specs", "#{name}.yml"),
+          generate_spec(name)
+        )
+      end
+
+      def create_new_factory(name)
+        actions.create_file(
+          SpecForge.forge.join("factories", "#{name}.yml"),
+          generate_factory(name)
+        )
+      end
+
+      def generate_spec(name)
+        plural_name = name.pluralize
+        singular_name = name.singularize
+
+        base_spec = {url: ""}
+        base_constraint = {expect: {status: 200}}
+
+        hash = {
+          ##################################################
+          "index_#{plural_name}" => base_spec.merge(
+            url: "/#{plural_name}",
+            expectations: [base_constraint]
+          ),
+          ##################################################
+          "show_#{singular_name}" => base_spec.merge(
+            url: "/#{plural_name}/{id}",
+            expectations: [
+              base_constraint.merge(expect: {status: 404}),
+              base_constraint.deep_merge(
+                query: {id: 1},
+                expect: {
+                  json: {
+                    name: "kind_of.string",
+                    email: /\w+@example\.com/i
+                  }
+                }
+              )
+            ]
+          ),
+          ##################################################
+          "create_#{singular_name}" => base_spec.merge(
+            url: "/#{plural_name}",
+            method: "post",
+            expectations: [
+              base_constraint.merge(expect: {status: 400}),
+              base_constraint.deep_merge(
+                variables: {
+                  name: "faker.name.name",
+                  role: "user"
+                },
+                body: {name: "variables.name"},
+                expect: {
+                  json: {name: "variables.name", role: "variables.role"}
+                }
+              )
+            ]
+          ),
+          ##################################################
+          "update_#{singular_name}" => base_spec.merge(
+            url: "/#{plural_name}/{id}",
+            method: "patch",
+            query: {id: 1},
+            variables: {
+              number: {
+                "faker.number.between" => {from: 100_000, to: 999_999}
+              }
+            },
+            expectations: [
+              base_constraint.deep_merge(
+                body: {number: "variables.number"},
+                expect: {
+                  json: {name: "kind_of.string", number: "kind_of.integer"}
+                }
+              )
+            ]
+          ),
+          ##################################################
+          "destroy_#{singular_name}" => base_spec.merge(
+            url: "/#{plural_name}/{id}",
+            method: "delete",
+            query: {id: 1},
+            expectations: [
+              base_constraint
+            ]
+          )
+        }
+
+        generate_yaml(hash)
+      end
+
+      def generate_factory(name)
+        singular_name = name.singularize
+
+        hash = {
+          singular_name => {
+            class: singular_name.titleize,
+            attributes: {
+              attribute: "value"
+            }
+          }
+        }
+
+        generate_yaml(hash)
+      end
+
+      def generate_yaml(hash)
+        result = hash.deep_stringify_keys.join_map("\n") do |key, value|
+          {key => value}.to_yaml
+            .sub!("---\n", "")
+            .gsub("!ruby/regexp ", "")
+        end
+
+        result.delete!("\"")
+        result
+      end
+    end
+  end
+end

data/lib/spec_forge/cli/run.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class CLI
+    class Run < Command
+      command_name "run"
+      syntax "run"
+      summary "Runs all specs"
+
+      # option "-n", "--no-docs", "Do not generate OpenAPI documentation on completion"
+
+      def call
+        SpecForge.run
+      end
+    end
+  end
+end

data/lib/spec_forge/cli.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "cli/actions"
+require_relative "cli/command"
+require_relative "cli/init"
+require_relative "cli/new"
+require_relative "cli/run"
+
+module SpecForge
+  class CLI
+    include Commander::Methods
+
+    COMMANDS = [Init, New, Run]
+
+    #
+    # Runs the CLI
+    #
+    # @private
+    #
+    def run
+      program :name, "SpecForge"
+      program :version, SpecForge::VERSION
+      program :description, "Write expressive API tests in YAML with the power of RSpec matchers"
+
+      register_commands
+
+      default_command :run
+
+      run!
+    end
+
+    #
+    # Registers the commands with Commander
+    #
+    # @private
+    #
+    def register_commands
+      COMMANDS.each do |command_class|
+        command_class.register(self)
+      end
+    end
+  end
+end

data/lib/spec_forge/config.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SpecForge
+  #
+  # Represents `config.yml`
+  #
+  class Config < Struct.new(:base_url, :authorization, :factories, :environment)
+    #
+    # authorization: {}
+    #
+    class Authorization < Struct.new(:header, :value)
+      attr_predicate :header, :value
+    end
+
+    #
+    # factories: {}
+    #
+    class Factories < Struct.new(:paths, :auto_discover)
+      attr_predicate :paths, :auto_discover
+    end
+
+    #
+    # environment: {}
+    #
+    class Environment < Struct.new(:use, :preload, :models_path)
+      attr_predicate :use, :preload, :models_path
+
+      def initialize(string_or_hash)
+        use, preload, models_path = "", "", ""
+
+        # "rails" or other preset
+        if string_or_hash.is_a?(String)
+          use = string_or_hash
+        else
+          string_or_hash => {use:, preload:, models_path:}
+        end
+
+        super(use:, preload:, models_path:)
+      end
+    end
+
+    ############################################################################
+
+    #
+    # Creates a config with the user's config overlaid on the default
+    #
+    def initialize
+      config = Normalizer.default_config.deep_merge(load_from_file)
+      normalized = Normalizer.normalize_config!(config)
+
+      super(
+        base_url: normalized.delete(:base_url),
+        authorization: transform_authorization(normalized),
+        factories: transform_factories(normalized),
+        environment: transform_environment(normalized)
+      )
+    end
+
+    private
+
+    def load_from_file
+      path = SpecForge.forge.join("config.yml")
+      return unless File.exist?(path)
+
+      erb = ERB.new(File.read(path)).result
+      YAML.safe_load(erb, aliases: true, symbolize_names: true)
+    end
+
+    def transform_authorization(hash)
+      # The intention for authorization hash is to support different authorization schemes
+      # authorization: {default: {}, admin: {}, dev: {}}
+      # But I won't know exactly what will be defined - `to_struct` will handle that.
+      hash[:authorization].transform_values { |v| Authorization.new(**v) }.to_struct
+    end
+
+    def transform_factories(hash)
+      Factories.new(**hash[:factories])
+    end
+
+    def transform_environment(hash)
+      Environment.new(hash[:environment])
+    end
+  end
+end