spec_forge 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 658fd0830ce9179c1fe7ea880e2ed8196ccbc47bc8b244f6fc40c458ca900cca
-  data.tar.gz: 3658379f52f23ffa362ded1c50b28e052911b6602ac3a3bed02b1fd9c8ee334c
+  metadata.gz: 2f51faa712bafdcb48e3940273ec494eb3f39e43c0d122ff0a6f97e425026438
+  data.tar.gz: fe5cf7dff0a44cf5cfc466189fb38c3ed66da21637e18ebcdb44e31f9f6a8b73
 SHA512:
-  metadata.gz: ebcdfd4e02d965049cabd1a18b7897665800dc8081149aa4554433e7083296f0121d76f4ec474b527fdd8df0da1c71170c9c10c5cff1a108f8704b7f14e7104f
-  data.tar.gz: ad3b84d27b9e7ab62dc902ad2a5d41a77670286aaba9a635ccebf5735061fa725e8d46daf62fd75562a35688d62b3dc595a597b9e38ec965f5273fdc27a2aabb
+  metadata.gz: be068681e3c2ce8b2f62fa21ae03281d40b34c19e190acce4f90796dd526197b6ae54cc6edaa04d6715e347a67e2c193e2b99b0e16e45b47b3183915001790f3
+  data.tar.gz: 644f2c1a49d3ed45a201cb53d731176a418c134679f324ef96f331427481643b2744bd6c27c0f326df32c1db751c412137ad209a3f0b0ce3add9cc68eb6a660e

data/.standard.yml

@@ -1,3 +1,7 @@
 # For available configuration options, see:
 #   https://github.com/standardrb/standard
 ruby_version: 3.3
+ignore:
+  - ".direnv/**/*"
+  - "vendor/**/*"
+  - "spec/integration/**/*"

data/CHANGELOG.md

@@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+<!--
 ## [Unreleased]
 
 ### Added
@@ -12,6 +13,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 ### Removed
+-->
+
+## [Unreleased]
+
+### Added
+
+### Changed
+
+### Removed
+
+## [0.5.0] - 12025-02-28
+
+### Added
+
+- Added support for testing array responses via `json`
+- Added check to block RSpec overwrites from running with internal tests
+- Added debugging access to `expected_json_class` variable.
+- Added support for FactoryBot list strategies through the new `size` attribute
+  ```yaml
+  variables:
+    users:
+      factory.user:
+        size: 10  # Creates 10 user records
+  ```
+  - All FactoryBot list methods now supported:
+    - `create_list` (default)
+    - `build_list`
+    - `build_stubbed_list`
+    - `attributes_for_list`
+    - `build_pair`
+    - `create_pair`
+  - Comprehensive documentation available in the [Factory Lists wiki](https://github.com/itsthedevman/spec_forge/wiki/Factory-Lists)
+
+### Changed
+
+- Updated `Constraint` to use `include` for testing Hashes and `contains_exactly` for testing Arrays
+- Better handling of positional and keyword argument passing for `Matcher` and `Faker` attributes
 
 ## [0.4.0] - 12025-02-22
 
@@ -88,7 +126,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial commit
 
-[unreleased]: https://github.com/itsthedevman/spec_forge/compare/v0.4.0...HEAD
+[unreleased]: https://github.com/itsthedevman/spec_forge/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/itsthedevman/spec_forge/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/itsthedevman/spec_forge/compare/v0.3.2...v0.4.0
 [0.3.2]: https://github.com/itsthedevman/spec_forge/compare/v0.3.0...v0.3.2
 [0.3.0]: https://github.com/itsthedevman/spec_forge/compare/v0.2.0...v0.3.0

data/README.md

@@ -23,11 +23,11 @@ That's a complete test. No Ruby code, no configuration files, no HTTP client set
 
 SpecForge shines when you need:
 
-1. **Accessible API Testing**: Non-developers can write and maintain tests without Ruby knowledge. The YAML syntax reads like documentation.
-2. **Living Documentation**: Tests serve as clear, maintainable documentation of your API's expected behavior.
-3. **Power Without Complexity**: Get the benefits of Ruby-based tests (dynamic data, factories, matchers) without writing Ruby code.
-4. **Quick Setup**: Start testing APIs without configuring HTTP clients or writing boilerplate code.
-5. **Gradual Adoption**: Use alongside your existing test suite. Keep complex tests in RSpec while making simple API tests more accessible.
+1. **Living Documentation**: Tests serve as clear, maintainable documentation of your API's expected behavior.
+2. **Power Without Complexity**: Get the benefits of Ruby-based tests (dynamic data, factories, matchers) without writing Ruby code.
+3. **Quick Setup**: Start testing APIs without configuring HTTP clients or writing boilerplate code.
+4. **Gradual Adoption**: Use alongside your existing test suite. Keep complex tests in RSpec while making simple API tests more accessible.
+5. **Accessible API Testing**: Non-developers can write and maintain tests without Ruby knowledge. The YAML syntax reads like documentation.
 
 ## When Not to Use SpecForge
 
@@ -38,75 +38,6 @@ Consider alternatives when you need:
 3. **Custom Response Validation**: For validation logic beyond what matchers provide.
 4. **Complex Non-JSON Testing**: While SpecForge handles basic XML/HTML responses (coming soon), complex validation might need specialized tools.
 
-## Roadmap
-
-Current development priorities:
-- [ ] Array support for `json` expectations
-- [ ] Negated matchers: `matcher.not`
-- [ ] `create_list/build_list` factory strategies
-- [ ] `transform.map` support
-- [ ] XML/HTML response handling
-- [ ] OpenAPI generation from tests
-- [x] Support for running individual specs
-- [x] Improved error handling
-
-Have a feature request? Open an issue on GitHub!
-
-## Looking for a Software Engineer?
-
-I'm currently looking for opportunities where I can tackle meaningful problems and help build reliable software while mentoring the next generation of developers. If you're looking for a senior engineer with full-stack Rails expertise and a passion for clean, maintainable code, let's talk!
-
-[bryan@itsthedevman.com](mailto:bryan@itsthedevman.com)
-
-## Table of Contents
-
-- [Compatibility](#compatibility)
-- [Installation](#installation)
-- [Getting Started](#getting-started)
-- [Forging Your First Test](#forging-your-first-test)
-- [Running Tests](#running-tests)
-  - [Targeting Specific Files](#targeting-specific-files)
-  - [Targeting Specific Specs](#targeting-specific-specs)
-  - [Targeting Individual Expectations](#targeting-individual-expectations)
-- [Configuration](#configuration)
-  - [Basic Configuration](#basic-configuration)
-  - [Framework Integration](#framework-integration)
-  - [Factory Configuration](#factory-configuration)
-  - [Debug Configuration](#debug-configuration)
-  - [Test Framework Configuration](#test-framework-configuration)
-  - [Configuration Inheritance](#configuration-inheritance)
-- [Writing Tests](#writing-tests)
-  - [Basic Structure](#basic-structure)
-  - [Testing Response Data](#testing-response-data)
-  - [Multiple Expectations](#multiple-expectations)
-  - [Request Data](#request-data)
-  - [Path Parameters](#path-parameters)
-- [Dynamic Features](#dynamic-features)
-  - [Variables](#variables)
-  - [Transformations](#transformations)
-  - [Chaining Support](#chaining-support)
-- [Factory Support](#factory-support)
-  - [Automatic Discovery](#automatic-discovery)
-  - [Custom Factory Paths](#custom-factory-paths)
-  - [Build Strategies](#build-strategies)
-  - [YAML Factory Definitions](#yaml-factory-definitions)
-- [RSpec Matchers](#rspec-matchers)
-  - ["be" namespace](#be-namespace)
-  - ["kind_of" namespace](#kind_of-namespace)
-  - ["matchers" namespace](#matchers-namespace)
-- [How Tests Work](#how-tests-work)
-- [Contributing](#contributing)
-- [License](#license)
-- [Credits](#credits)
-
-Also see: [API Documentation](https://itsthedevman.com/docs/spec_forge)
-
-## Compatibility
-
-Currently tested on:
-- MRI Ruby 3.2+
-- NixOS (see `flake.nix` for details)
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -135,587 +66,55 @@ Initialize the required directory structure:
 spec_forge init
 ```
 
-Or with bundle:
-```bash
-bundle exec spec_forge init
-```
-
-This creates the `spec_forge` directory containing factory definitions, test specifications, and global configuration.
-
-## Forging Your First Test
-
-Let's write a simple test to verify a user endpoint. Create a new spec file:
+Create your first test:
 
 ```bash
 spec_forge new spec users
 ```
 
-This creates `spec_forge/specs/users.yml`. Here's a basic example:
-
-```yaml
-get_user:
-  path: /users/1
-  method: GET
-  expectations:
-  - expect:
-      status: 200
-      json:
-        id: 1
-        name: kind_of.string
-        email: /@/
-```
-
-Run your tests with:
+Run your tests:
 
 ```bash
 spec_forge run
 ```
 
-Since `run` is the default command, you can just use:
-
-```bash
-spec_forge
-```
-
-## Running Tests
-
-As your test suite grows, you'll want more control over which tests to run.
-
-#### Targeting Specific Files
-
-When working on a specific feature, run tests from a single file:
-
-```bash
-spec_forge users # Runs all tests in specs/users.yml
-```
-
-#### Targeting Specific Specs
-
-Focus on a specific endpoint by running a single spec:
-
-```bash
-spec_forge users:destroy_user # Runs all expectations in the destroy_user spec
-```
-
-#### Targeting Individual Expectations
-
-You can also run individual expectations within a spec. The format depends on whether the expectation has a name:
-
-```yaml
-# specs/users.yml
-destroy_user:
-  path: /users/:id
-  method: delete
-  expectations:
-  - expect: # Unnamed expectation
-      status: 200
-  - name: "Destroys a User" # Named expectation
-    expect:
-      status: 200
-```
-
-For named expectations:
-```bash
-# Format: <file>:<spec>:'<verb> <path> - <name>'
-spec_forge users:destroy_user:'DELETE /users/:id - Destroys a User'
-```
-
-For unnamed expectations:
-```bash
-# Format: <file>:<spec>:'<verb> <path>'
-spec_forge users:destroy_user:'DELETE /users/:id'
-```
-
-**Note**: When targeting an unnamed expectation, SpecForge executes all matching expectations within that spec. This means if you have multiple unnamed expectations with the same verb and path, they will all run.
-
-## Configuration
-
-### Basic Configuration
-
-When you initialize SpecForge, it creates a `forge_helper.rb` file in your `spec_forge` directory. This serves as your central configuration file:
-
-```ruby
-SpecForge.configure do |config|
-  # Base URL for all requests
-  config.base_url = "http://localhost:3000"
-
-  # Default headers sent with every request
-  config.headers = {
-    "Authorization" => "Bearer #{ENV.fetch("API_TOKEN", "")}",
-    "Accept" => "application/json"
-  }
-
-  # Optional: Default query parameters for all requests
-  config.query = {
-    api_key: ENV["API_KEY"]
-  }
-end
-```
-
-### Framework Integration
-
-SpecForge works seamlessly with Rails and RSpec:
-
-```ruby
-# Rails Integration
-require_relative "../config/environment"
-
-# RSpec Integration (includes your existing configurations)
-require_relative "../spec/spec_helper"
-
-# Load custom files (models, libraries, etc)
-Dir[File.join(__dir__, "..", "lib", "**", "*.rb")].sort.each { |f| require f }
-```
-
-### Factory Configuration
-
-SpecForge provides flexible configuration options for working with FactoryBot factories:
-
-```ruby
-SpecForge.configure do |config|
-  # Disable auto-discovery if needed (default: true)
-  config.factories.auto_discover = false
-
-  # Add custom factory paths (appends to default paths)
-  config.factories.paths += ["lib/factories"]
-end
-```
-
-### Debug Configuration
-
-Enable debugging by adding `debug: true` (aliases: `breakpoint`, `pry`) at either the spec or expectation level:
-
-```ruby
-SpecForge.configure do |config|
-  # Custom debug handler (defaults to printing state overview)
-  config.on_debug { binding.pry }  # Requires 'pry' gem
-end
-```
-
-```yaml
-get_users:
-  debug: true  # Debug all expectations in this spec
-  path: /users
-  expectations:
-  - expect:
-      status: 200
-  - debug: true  # Debug just this expectation
-    expect:
-      status: 404
-      json:
-        error: kind_of.string
-```
-
-When debugging, you have access to:
-- `expectation` - Current expectation being validated
-- `variables` - Resolved variables for the current expectation
-- `request` - Request details (url, method, headers, etc.)
-- `response` - Full response including headers, status, and parsed body
-- `expected_status` - Expected HTTP status code
-- `expected_json` - Expected JSON structure with matchers
-
-Or call `self` from an interactive session to see everything as a hash
-
-### Test Framework Configuration
-
-Access RSpec's configuration through the `specs` attribute:
-
-```ruby
-SpecForge.configure do |config|
-  # Setup before all tests
-  config.specs.before(:suite) do
-    DatabaseCleaner.strategy = :truncation
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  # Wrap each test
-  config.specs.around do |example|
-    DatabaseCleaner.cleaning do
-      example.run
-    end
-  end
-end
-```
-
-### Configuration Inheritance
-
-All configuration options can be overridden at three levels (in order of precedence):
-
-1. Individual expectation
-2. Spec level
-3. Global configuration (forge_helper.rb)
-
-For example:
-
-```yaml
-# Override at spec level
-get_user:
-  base_url: https://staging.example.com
-  headers:
-    x_custom_header: "overridden" # Underscore keys automatically convert to "X-Custom-Header"
-
-  expectations:
-  # Override for a specific expectation
-  - base_url: https://prod.example.com
-    headers:
-      X-Custom-Header: "expectation-specific" # HTTP-style headers used as-is
-    expect:
-      status: 200
-```
-
-## Writing Tests
-
-### Basic Structure
-
-Every spec needs a path, HTTP method, and at least one expectation:
-
-```yaml
-show_user:
-  path: /users/1
-  method: GET  # Optional for GET requests
-  expectations:
-  - expect:
-      status: 200
-```
-
-### Testing Response Data
-
-Verify the response JSON:
-
-```yaml
-show_user:
-  path: /users/1
-  expectations:
-  - expect:
-      status: 200
-      json:
-        id: 1
-        name: kind_of.string
-        role: admin
-```
-
-### Multiple Expectations
-
-Each expectation can override any spec-level setting:
-
-```yaml
-show_user:
-  path: /users/1
-  expectations:
-  - expect:
-      status: 200
-      json:
-        id: 1
-        role: admin
-  - path: /users/999  # Overrides spec-level path
-    expect:
-      status: 404
-```
-
-### Request Data
-
-Add query parameters and body data:
-
-```yaml
-create_user:
-  path: /users
-  method: POST
-  query:  # or "params" if you prefer
-    team_id: 123
-  body:   # or "data" if you prefer
-    name: John Doe
-    email: john@example.com
-  expectations:
-  - expect:
-      status: 201
-```
+## Documentation
 
-### Path Parameters
+For comprehensive documentation, visit the [SpecForge Wiki](https://github.com/itsthedevman/spec_forge/wiki) which includes:
 
-Use placeholders for dynamic path parameters:
+- [Getting Started Guide](https://github.com/itsthedevman/spec_forge/wiki/Getting-Started)
+- [Configuration Options](https://github.com/itsthedevman/spec_forge/wiki/Configuration)
+- [Writing Tests](https://github.com/itsthedevman/spec_forge/wiki/Writing-Tests)
+- [Dynamic Features](https://github.com/itsthedevman/spec_forge/wiki/Dynamic-Features)
+- [Factory Support](https://github.com/itsthedevman/spec_forge/wiki/Factory-Support)
+- [RSpec Matchers](https://github.com/itsthedevman/spec_forge/wiki/RSpec-Matchers)
 
-```yaml
-show_user:
-  path: /users/{id}  # Use {id} or :id
-  query:
-    id: 1  # Replaces the placeholder
-  expectations:
-  - expect:
-      status: 200
-```
-
-## Dynamic Features
-
-### Variables
-
-Variables let you define and reuse values:
-
-```yaml
-list_posts:
-  variables:
-    author: factories.user
-    category_name: faker.lorem.word
-  query:
-    author_id: variables.author.id
-    category: variables.category_name
-  expectations:
-  - expect:
-      status: 200
-      json:
-        posts:
-          matcher.include:
-          - author:
-              id: variables.author.id
-              name: variables.author.name
-            category: variables.category_name
-```
-
-### Transformations
-
-Transform data using built-in helpers:
-
-```yaml
-create_user:
-  variables:
-    first_name: faker.name.first_name
-    last_name: faker.name.last_name
-    full_name:
-      transform.join:
-      - variables.first_name
-      - " "
-      - variables.last_name
-  body:
-    name: variables.full_name
-    email: faker.internet.email
-```
-
-### Chaining
-
-Access nested attributes and methods through chaining:
-
-```yaml
-list_posts:
-  variables:
-    # Factory chaining examples
-    owner: factories.user              # Creates a user
-    name: factories.user.name          # Gets just the name
-    company: variables.owner.company   # Access factory attributes
-
-    # Variable chaining for relationships
-    first_post: variables.user.posts.first
-
-    # You can use array indices directly
-    comment_author: variables.first_post.comments.2.author.name
-
-    # Faker method chaining
-    lowercase_email: faker.internet.email.downcase
-    title_name: faker.name.first_name.titleize
-```
-
-### Factory Build Strategies
-
-Control how factories create objects and customize their attributes:
-
-```yaml
-create_user:
-  variables:
-    # Default strategy (create)
-    regular_user: factories.user
-
-    # Custom build strategy and attributes
-    custom_user:
-      factory.user:
-        strategy: build    # 'create' (default) or 'build'
-        attributes:
-          name: "Custom Name"
-          email: faker.internet.email
-```
+Also see the [API Documentation](https://itsthedevman.com/docs/spec_forge).
 
-## Factory Support
-
-### Automatic Discovery
-
-SpecForge automatically discovers factories in standard paths:
-
-```ruby
-SpecForge.configure do |config|
-  # Disable automatic factory discovery if needed (default: true)
-  config.factories.auto_discover = false
-end
-```
-
-### Custom Factory Paths
-
-Add custom paths to the factory search list:
-
-```ruby
-SpecForge.configure do |config|
-  # Add custom factory paths (appends to default paths)
-  # Ignored if `auto_discovery` is false
-  config.factories.paths += ["lib/factories"]
-end
-```
-
-### Factory Build Strategies
-
-Control how factories create objects and customize their attributes:
-
-```yaml
-create_user:
-  variables:
-    # Default strategy (create)
-    regular_user: factories.user
-
-    # Custom build strategy and attributes
-    custom_user:
-      factory.user:
-        strategy: build    # 'create' (default) or 'build'
-        attributes:
-          name: "Custom Name"
-          email: faker.internet.email
-```
-
-### YAML Factory Definitions
-
-Define factories in YAML with a simple declarative syntax:
-
-```yaml
-# spec_forge/factories/user.yml
-user:
-  class: User  # Optional model class name
-  variables:
-    department: faker.company.department
-    team_size:
-      faker.number.between:
-        from: 5
-        to: 20
-  attributes:
-    name: faker.name.name
-    email: faker.internet.email
-    role: admin
-    department: variables.department
-    team_count: variables.team_size
-```
-
-## RSpec Matchers
-
-### "be" namespace
-
-```yaml
-expect:
-  json:
-    # Simple predicates
-    active: be.true
-    deleted: be.false
-    description: be.nil
-    tags: be.empty
-    email: be.present
-
-    # Comparisons
-    price:
-      be.greater_than: 18
-    stock:
-      be.less_than_or_equal: 100
-    rating:
-      be.between:
-      - 1
-      - 5
-
-    # Dynamic predicate methods
-    published: be.published
-    admin: be.admin
-```
-
-### "kind_of" namespace
-
-```yaml
-expect:
-  json:
-    id: kind_of.integer
-    name: kind_of.string
-    metadata: kind_of.hash
-    scores: kind_of.array
-```
-
-### "matchers" namespace
-
-```yaml
-expect:
-  json:
-    tags:
-      matcher.include:
-      - featured
-      - published
-
-    slug: /^[a-z0-9-]+$/    # Shorthand for matching regexes
-
-    config:
-      matcher.have_key: api_version
-```
-
-## How Tests Work
-
-When you write a YAML spec, SpecForge converts it into an RSpec test structure. For example, this YAML:
-
-```yaml
-create_user:
-  path: /users
-  method: POST
-  variables:
-    full_name: faker.name.name
-  body:
-    name: variables.full_name
-  expectations:
-  - expect:
-      status: 201
-      json:
-        name: variables.full_name
-```
+## Roadmap
 
-Becomes this RSpec test:
+Current development priorities:
+- [ ] Negated matchers: `matcher.not`
+- [ ] `create_list/build_list` factory strategies
+- [ ] `transform.map` support
+- [ ] XML/HTML response handling
+- [ ] OpenAPI generation from tests
+- [x] Array support for `json` expectations
+- [x] Support for running individual specs
+- [x] Improved error handling
 
-```ruby
-RSpec.describe "create_user" do
-  describe "POST /users" do
-    let(:full_name) { Faker::Name.name }
-
-    let!(:expected_status) { 201 }
-    let!(:expected_json) do
-      {
-        name: eq(full_name)
-      }
-    end
-
-    subject(:response) do
-      post("/users", body: { name: full_name })
-    end
-
-    it do
-      expect(response.status).to eq(expected_status)
-      expect(response.body).to include(expected_json)
-    end
-  end
-end
-```
+Have a feature request? Open an issue on GitHub!
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b feature/my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin feature/my-new-feature`)
-5. Create new Pull Request
-
-Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+Contributions are welcome! See the [Contributing Guide](https://github.com/itsthedevman/spec_forge/wiki/Contributing) for details on how to get started.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
-## Changelog
-
-See [CHANGELOG.md](CHANGELOG.md) for a list of changes.
+## Looking for a Software Engineer?
 
-## Credits
+I'm currently looking for opportunities where I can tackle meaningful problems and help build reliable software while mentoring the next generation of developers. If you're looking for a senior engineer with full-stack Rails expertise and a passion for clean, maintainable code, let's talk!
 
-- Author: Bryan "itsthedevman"
+[bryan@itsthedevman.com](mailto:bryan@itsthedevman.com)

data/lib/spec_forge/attribute/factory.rb

@@ -7,11 +7,27 @@ module SpecForge
 
       KEYWORD_REGEX = /^factories\./i
 
-      BUILD_STRATEGIES = %w[
+      # These are the base strategies that can be provided either with or without size
+      # stubbed will be transformed into build_stubbed
+      BASE_STRATEGIES = %w[
         build
         create
+        build_stubbed
         attributes_for
+      ].freeze
+
+      # All available build strategies that are accepted
+      BUILD_STRATEGIES = %w[
+        attributes_for
+        attributes_for_list
+        build
+        build_list
+        build_pair
         build_stubbed
+        build_stubbed_list
+        create
+        create_list
+        create_pair
       ].freeze
 
       alias_method :factory_name, :header
@@ -34,17 +50,53 @@ module SpecForge
 
       def base_object
         attributes = arguments[:keyword]
+
+        # Default functionality is to create ("factory.user")
         return FactoryBot.create(factory_name) if attributes.blank?
 
-        # Determine build strat
-        build_strategy = attributes[:build_strategy].resolve_value
+        build_arguments = construct_factory_parameters(attributes)
+        FactoryBot.public_send(*build_arguments)
+      end
+
+      def construct_factory_parameters(attributes)
+        build_strategy, list_size = determine_build_strategy(attributes)
+
+        # This is set up for the base strategies + _pair
+        # FactoryBot.create(factory_name, **attributes)
+        build_arguments = [
+          build_strategy,
+          factory_name,
+          **attributes[:attributes].resolve_value
+        ]
+
+        # Insert the list size after the strategy
+        # FactoryBot.create_list(factory_name, list_size, **attributes)
+        if build_strategy.end_with?("_list")
+          build_arguments.insert(2, list_size)
+        end
+
+        build_arguments
+      end
+
+      def determine_build_strategy(attributes)
+        # Determine build strat, and unfreeze
+        build_strategy = +attributes[:build_strategy].resolve_value
+        list_size = attributes[:size].resolve_value
 
         # stubbed => build_stubbed
-        build_strategy.prepend("build_") if build_strategy == "stubbed"
+        build_strategy.prepend("build_") if build_strategy.start_with?("stubbed")
+
+        # create + size => create_list
+        # build + size => build_list
+        # build_stubbed + size => build_stubbed_list
+        # attributes_for + size => attributes_for_list
+        if list_size.positive? && BASE_STRATEGIES.include?(build_strategy)
+          build_strategy += "_list"
+        end
+
         raise InvalidBuildStrategy, build_strategy unless BUILD_STRATEGIES.include?(build_strategy)
 
-        attributes = attributes[:attributes].resolve_value
-        FactoryBot.public_send(build_strategy, factory_name, **attributes)
+        [build_strategy, list_size]
       end
     end
   end

data/lib/spec_forge/attribute/faker.rb

@@ -25,10 +25,10 @@ module SpecForge
       private
 
       def base_object
-        if uses_positional_arguments?(faker_method)
-          faker_method.call(*arguments[:positional].resolve)
-        elsif uses_keyword_arguments?(faker_method)
-          faker_method.call(**arguments[:keyword].resolve)
+        if (positional = arguments[:positional]) && positional.present?
+          faker_method.call(*positional.resolve)
+        elsif (keyword = arguments[:keyword]) && keyword.present?
+          faker_method.call(**keyword.resolve)
         else
           faker_method.call
         end

data/lib/spec_forge/attribute/matcher.rb

@@ -44,14 +44,14 @@ module SpecForge
       end
 
       def value
-        if uses_positional_arguments?(matcher_method)
-          positional = arguments[:positional].resolve.each do |value|
+        if (positional = arguments[:positional]) && positional.present?
+          positional = positional.resolve.each do |value|
             value.deep_stringify_keys! if value.respond_to?(:deep_stringify_keys!)
           end
 
           matcher_method.call(*positional)
-        elsif uses_keyword_arguments?(matcher_method)
-          matcher_method.call(**arguments[:keyword].resolve.deep_stringify_keys)
+        elsif (keyword = arguments[:keyword]) && keyword.present?
+          matcher_method.call(**keyword.resolve.deep_stringify_keys)
         else
           matcher_method.call
         end

data/lib/spec_forge/attribute/parameterized.rb

@@ -63,14 +63,6 @@ module SpecForge
       def prepare_arguments!
         @arguments = Attribute.from(arguments)
       end
-
-      def uses_positional_arguments?(method)
-        method.parameters.any? { |a| [:req, :opt, :rest].include?(a.first) }
-      end
-
-      def uses_keyword_arguments?(method)
-        method.parameters.any? { |a| [:keyreq, :key, :keyrest].include?(a.first) }
-      end
     end
   end
 end

data/lib/spec_forge/attribute.rb

@@ -18,6 +18,8 @@ require_relative "attribute/variable"
 
 module SpecForge
   class Attribute
+    include Resolvable
+
     #
     # Binds variables to Attribute objects
     #
@@ -191,9 +193,9 @@ module SpecForge
     def __resolve(value)
       case value
       when ArrayLike
-        value.map(&:resolve)
+        value.map(&resolvable_proc)
       when HashLike
-        value.transform_values(&:resolve)
+        value.transform_values(&resolvable_proc)
       else
         value
       end

data/lib/spec_forge/configuration.rb

@@ -30,9 +30,6 @@ module SpecForge
     def initialize
       config = Normalizer.default_configuration
 
-      # Allows me to modify the error backtrace reporting within rspec
-      RSpec.configuration.instance_variable_set(:@backtrace_formatter, BacktraceFormatter)
-
       config[:base_url] = "http://localhost:3000"
       config[:factories] = Factories.new
       config[:specs] = RSpec.configuration

data/lib/spec_forge/core_ext/rspec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+return if defined?(SPEC_FORGE_INTERNAL_TESTING)
+
 module RSpec
   module Core
     module Notifications

data/lib/spec_forge/normalizer/constraint.rb

@@ -8,7 +8,7 @@ module SpecForge
           type: Integer
         },
         json: {
-          type: Hash,
+          type: [Hash, Array],
           default: {}
         }
       }.freeze

data/lib/spec_forge/normalizer/factory_reference.rb

@@ -12,6 +12,11 @@ module SpecForge
           type: String,
           aliases: %i[strategy],
           default: "create"
+        },
+        size: {
+          type: Integer,
+          aliases: %i[count],
+          default: 0
         }
       }.freeze
     end

data/lib/spec_forge/runner.rb

@@ -7,6 +7,9 @@ module SpecForge
       # Runs any specs
       #
       def run
+        # Allows me to modify the error backtrace reporting within rspec
+        RSpec.configuration.instance_variable_set(:@backtrace_formatter, BacktraceFormatter)
+
         RSpec::Core::Runner.disable_autorun!
         RSpec::Core::Runner.run([], $stderr, $stdout)
       end
@@ -29,7 +32,8 @@ module SpecForge
               constraints = expectation.constraints
 
               let!(:expected_status) { constraints.status.resolve }
-              let!(:expected_json) { constraints.json.resolve.deep_stringify_keys }
+              let!(:expected_json) { constraints.json.resolve }
+              let!(:expected_json_class) { expected_json&.expected.class }
 
               before do
                 # Ensure all variables are called and resolved, in case they are not referenced
@@ -50,9 +54,9 @@ module SpecForge
                 expect(response.status).to eq(expected_status)
 
                 # JSON check
-                if constraints.json.size > 0
-                  expect(response.body).to be_kind_of(Hash)
-                  expect(response.body).to include(expected_json)
+                if expected_json
+                  expect(response.body).to be_kind_of(expected_json_class)
+                  expect(response.body).to expected_json
                 end
               end
             end
@@ -119,6 +123,7 @@ module SpecForge
           - variables: Current variable definitions
           - expected_status: Expected HTTP status code (#{expected_status})
           - expected_json: Expected response body
+          - expected_json_class: Expected response body class
           - request: HTTP request details (method, url, headers, body)
           - response: HTTP response
 

data/lib/spec_forge/spec/expectation/constraint.rb

@@ -11,10 +11,10 @@ module SpecForge
         # Creates a new Constraint
         #
         # @param status [Integer] The expected HTTP status code
-        # @param json [Hash] The expected JSON with matchers
+        # @param json [Hash, Array] The expected JSON with matchers
         #
         def initialize(status:, json:)
-          super(status:, json: normalize_hash(json))
+          super(status:, json: convert_to_matchers(json))
         end
 
         def to_h
@@ -23,20 +23,24 @@ module SpecForge
 
         private
 
-        def normalize_hash(hash)
-          hash =
-            hash.transform_values do |attribute|
-              case attribute
-              when Attribute::Regex
-                Attribute.from("matcher.match" => attribute.resolve)
-              when Attribute::Literal
-                Attribute.from("matcher.eq" => attribute.resolve)
-              else
-                attribute
-              end
-            end
+        def convert_to_matchers(value)
+          # This makes it easier to check if json was provided
+          return Attribute.from(nil) if value.blank?
 
-          Attribute.from(hash)
+          case value
+          when HashLike
+            value = value.transform_values { |i| convert_to_matchers(i) }
+            Attribute.from("matcher.include" => value)
+          when ArrayLike
+            value = value.map { |i| convert_to_matchers(i) }
+            Attribute.from("matcher.contain_exactly" => value)
+          when Attribute::Regex
+            Attribute.from("matcher.match" => value)
+          when Attribute::Literal
+            Attribute.from("matcher.eq" => value)
+          else
+            value
+          end
         end
       end
     end

data/lib/spec_forge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SpecForge
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec_forge/forge_helper.rb

@@ -1,37 +1,48 @@
 # frozen_string_literal: true
 
-## Using Rails? Uncomment to load your app
-# ENV["RAILS_ENV"] ||= "test"
-# require_relative "../config/environment"
+##########################################
+# Framework Integration
+##########################################
 
-## Not using Rails? Load anything you need here
-# Dir[SpecForge.root.join("lib", "my_api", "models", "**/*.rb")].sort.each { |path| require path }
+# Rails Integration
+# require_relative "../config/environment"
 
-## Using RSpec? Uncomment to use your existing configurations
+# RSpec Integration (includes your existing configurations)
 # require_relative "../spec/spec_helper"
 
+# Custom requires (models, libraries, etc)
+# Dir[File.join(__dir__, "..", "lib", "**", "*.rb")].sort.each { |f| require f }
+
+##########################################
+# Configuration
+##########################################
+
 SpecForge.configure do |config|
-  ## Base URL prefix for all API requests. All test paths will be appended to this URL
+  # Base configuration
   config.base_url = "http://localhost:3000"
 
-  ## Default request headers - commonly used for authentication and content negotiation
-  api_token = ENV.fetch("API_TOKEN", "")
+  # Default request headers
   config.headers = {
-    "Authorization" => "Bearer #{api_token}"
+    "Authorization" => "Bearer #{ENV.fetch("API_TOKEN", "")}"
   }
 
-  ## Default query parameters - useful for API keys or additional request context
-  # config.query = {api_token:}
-
-  ## Factory configuration options
-  ##
-  ## Enable/disable automatic factory discovery. When enabled, SpecForge will automatically
-  ## load factories from FactoryBot's default paths. Note: Factories defined in
-  ## "spec_forge/factories" are always loaded regardless of this setting.
-  # config.factories.auto_discover = false  # Default: true
-
-  ##
-  ## Additional paths, relative to the project folder, for discovering FactoryBot factories
-  ## By default, FactoryBot looks in "spec/factories" and "test/factories"
-  # config.factories.paths += ["custom/factories/path"]
+  # Optional: Default query parameters
+  # config.query = {api_key: ENV['API_KEY']}
+
+  # Factory configuration
+  # config.factories.auto_discover = false        # Default: true
+  # config.factories.paths += ["lib/factories"]   # Adds to default paths
+
+  # Debug configuration
+  # Available in specs with debug: true (aliases: breakpoint, pry)
+  # Defaults to printing state overview (-> { puts inspect })
+  # Available context: expectation, variables, request, response,
+  #                   expected_status, expected_json
+  # config.on_debug { binding.pry }
+
+  # Test Framework Configuration
+  # Useful for database cleaners, test data setup, etc
+  # config.specs.before(:suite) { }
+  # config.specs.around { |example| example.run }
+  # config.specs.formatter = :documentation
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spec_forge
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Bryan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-23 00:00:00.000000000 Z
+date: 2025-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport