create_tests 0.6.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c59ffb44e91a7402acf3d3384268d541e44e27d48ac395baa1387c1b20692a6
-  data.tar.gz: 131c739da1db5bb00bd586e1647bfa74a672dce6dd33ea0c7004b8e4e475d446
+  metadata.gz: 754317e21adff9283ea8d3424b46ee09de1f5a53d9e875b9388014e261f6d561
+  data.tar.gz: e70d64dddd1f4312c67149e7ca3761e1d5038332252e9c8a191427e53627c3b9
 SHA512:
-  metadata.gz: 3f1c1283a88fe41d8ae4abbdbe80cafa14d7874a89e62b30133160d945d602ea5785747f66103d646921f0e7025744e4aa60b087dbab2aef3af451e06905faad
-  data.tar.gz: dbb440e25eeeb45c5c22376f5fe474fca830a475b94e5ec042495cb61755b4b79a44c3709165deb756684fae2a8edaeb491ca719fcd019b2bce107ef3435f3c3
+  metadata.gz: 10f9687590b335bd26ab6bc039d9ad05eed6ca780608363c934db2a929f11ea229e267d95498935ac9755c4eb6bb4eec437b985d114efe747870e7371fc50dd5
+  data.tar.gz: '048048f6f02865499ee314d55841e9e3259fad8c9edcb74c6fb3937e508eb2ccbdebe9b49c6870fe1e8984a466410aa61f0ea7a6b03ef2dfbbe1f1eeabadd752'

data/README.md

@@ -1,22 +1,18 @@
 # CreateTests
 
 [![Gem Version](https://badge.fury.io/rb/create_tests.svg)](https://rubygems.org/gems/create_tests)
-[![Build Status](https://travis-ci.com/MarioRuiz/create_tests.svg?branch=master)](https://github.com/MarioRuiz/create_tests)
-[![Coverage Status](https://coveralls.io/repos/github/MarioRuiz/create_tests/badge.svg?branch=master)](https://coveralls.io/github/MarioRuiz/create_tests?branch=master)
+[![CI](https://github.com/MarioRuiz/create_tests/actions/workflows/ci.yml/badge.svg)](https://github.com/MarioRuiz/create_tests/actions/workflows/ci.yml)
+[![coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/MarioRuiz/create_tests/master/.github/badges/coverage.json)](https://github.com/MarioRuiz/create_tests/actions/workflows/ci.yml)
 ![Gem](https://img.shields.io/gem/dt/create_tests)
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/y/MarioRuiz/create_tests)
 ![GitHub last commit](https://img.shields.io/github/last-commit/MarioRuiz/create_tests)
 ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/MarioRuiz/create_tests)
 
+Create RSpec tests automatically from Request Hash files. Perfect to be used with the result from importing a Swagger / OpenAPI file using the [open_api_import](https://github.com/MarioRuiz/open_api_import) gem.
 
-Create Tests automatically from a Requests file. Perfect to be used with the result from importing a Swagger file using the open_api_import gem. Now we are supporting RSpec.
-
-More info about the Request Hashes: https://github.com/MarioRuiz/Request-Hash
-
-If you want to know how to import Swagger / Open API files in just a couple of seconds and transform them into Request Ruby Hashes: https://github.com/MarioRuiz/open_api_import
-
-We strongly recommend to use nice_http gem for your tests: https://github.com/MarioRuiz/nice_http
+We strongly recommend using [nice_http](https://github.com/MarioRuiz/nice_http) for your tests together with [nice_hash](https://github.com/MarioRuiz/nice_hash) and [string_pattern](https://github.com/MarioRuiz/string_pattern).
 
+More info about Request Hashes: https://github.com/MarioRuiz/Request-Hash
 
 ## Installation
 
@@ -24,51 +20,207 @@ Install it yourself as:
 
     $ gem install create_tests
 
+**Requirements:** Ruby >= 3.0
 
-Take in consideration create_tests gem is using the 'rufo' gem that executes in command line the `rufo` command. In case you experience any trouble with it, visit: https://github.com/ruby-formatter/rufo
+The gem uses [rufo](https://github.com/ruby-formatter/rufo) to format generated files. In case you experience any trouble with it, visit: https://github.com/ruby-formatter/rufo
 
 ## Usage
 
-After installation you can run using command line executable or just from Ruby.
+After installation you can run using the command line executable or from Ruby code.
 
-The execution will create an spec folder where you will have all the RSpec tests. Also it will be added to that file a `helper.rb` file.
+The execution will create:
+- A `spec/` folder with one RSpec test file per API endpoint
+- A `spec/helper.rb` with stub methods for required parameters
+- A `settings/general.rb` with NiceHttp configuration boilerplate
+
+### Command line
+
+```
+Usage: create_tests [requests_file] [options]
+
+    -n, --dont_overwrite    In case the test file exists it won't change anything
+    -w, --overwrite         In case the test file exists it will be overwritten
+    -a, --append            Only missing tests will be appended (default)
+    -d, --dry_run           Preview which files would be created or modified
+        --cleanup_each      Generate cleanup in after(:each) instead of after(:all)
+        --no_cleanup        Do not generate setup/cleanup hooks
+    -v, --version           Show version
+```
 
-Also a `settings` folder that will contain a `general.rb` file that will be required by the tests.
+Example:
 
-### Executable
+```bash
+create_tests ./requests/uber.yaml.rb
+```
 
-For help and see the options, run in command line / bash: `create_tests -h`
+Dry run (preview without writing files):
 
-Example: 
 ```bash
- create_tests ./requests/uber.yaml.rb
+create_tests ./requests/uber.yaml.rb --dry_run
+```
+
+### Ruby API
+
+```ruby
+require 'create_tests'
+
+CreateTests.from "./requests/uber.yaml.rb"
+```
+
+## Generated tests
+
+For each API endpoint, `create_tests` generates up to 7 test types:
+
+1. **"has correct structure in successful response"** -- Calls the endpoint and validates the response structure using `NiceHttp.validate_response` with diff details on failure.
+
+2. **"doesn't retrieve data if not authenticated"** -- Calls with empty headers and asserts a 4xx response.
+
+3. **"returns error if required parameter empty"** -- For each required parameter, sends an empty string and expects a 4xx response.
+
+4. **"returns expected mock response"** -- For endpoints with `mock_response` data (from `open_api_import`), validates the mock response matches the expected code, message, and structure.
+
+5. **"handles multiple valid data variations"** -- For POST/PUT/PATCH endpoints with a payload source, uses `generate_n(5, :correct)` from nice_hash to test 5 different valid payload variations. Prefers `:data_pattern` when present (real string_pattern / enum / range values from open_api_import); otherwise uses `:data`. Generated values are assigned to `request[:data]` before the call.
+
+6. **"returns error when individual data fields are invalid"** -- Uses `NiceHash.change_one_by_one` on `:data_pattern` (preferred) or `:data` to systematically test each field being wrong one at a time, asserting the server rejects each one.
+
+7. **"returns error if required parameter on data empty/missing"** -- For endpoints with `data_required`, tests both empty and missing values for each required data field. When `:data` is absent but `:data_examples` is present (common for form uploads), the first example is used as the body for success and required-data tests.
+
+Required keyword parameters from open_api_import `create_constants: true` (e.g. `def self.get_item(id: ID)`) get Helper stubs and are called as keywords (`id: @id`), same as positional required args.
+
+## Parameters
+
+### mode
+
+Accepts three options: `:overwrite`, `:dont_overwrite` and `:append`. Default: `:append`.
+
+- **append**: If the test file already exists, only missing tests will be added. Existing content is preserved, including `helper/setup.rb` and `helper/cleanup.rb`. If the file doesn't exist, it will be created with all tests.
+
+- **dont_overwrite**: If the test file exists, no changes will be made. If it doesn't exist, it will be created.
+
+- **overwrite**: The test file will be recreated from scratch. All previous content will be deleted.
+
+```ruby
+CreateTests.from "./requests/uber.yaml.rb", mode: :overwrite
 ```
 
-### Ruby file
-Write your ruby code on a file and in command line/bash: `ruby my_file.rb`
+### dry_run
 
-This is an example:
+Preview which files would be created or modified without writing anything to disk.
 
 ```ruby
-  require 'create_tests'
-  
-  CreateTests.from "./requests/uber.yaml.rb"
+CreateTests.from "./requests/uber.yaml.rb", dry_run: true
+```
+
+### return_data
 
+Return the generated code as a Hash (`{ filepath => content }`) without writing files. Useful for programmatic use.
+
+```ruby
+result = CreateTests.from "./requests/uber.yaml.rb", return_data: true
+result.each { |path, content| puts "#{path}: #{content.length} bytes" }
 ```
 
+### spec_dir / settings_dir
+
+Custom output directories (default: `./spec` and `./settings`).
+
+```ruby
+CreateTests.from "./requests/uber.yaml.rb", spec_dir: "./test/spec", settings_dir: "./test/config"
+```
+
+### cleanup
+
+Controls whether and how prerequisite setup/cleanup hooks are generated. Default: `:after_all`.
+
+When API endpoints have hierarchical paths (e.g. `/accounts/{account}/pools/{pool}/volumes/{volume}`), `create_tests` infers the dependency chain and generates production-ready test scaffolding with setup expectations, unique naming, and conditional cleanup.
+
+```ruby
+CreateTests.from "./requests/netapp.json.rb"                        # cleanup in after(:all) (default)
+CreateTests.from "./requests/netapp.json.rb", cleanup: :after_each  # move after(:all) cleanup into after(:each)
+CreateTests.from "./requests/netapp.json.rb", cleanup: false        # no cleanup generation
+```
+
+**For PUT/POST (create) endpoints** -- parents are set up, test creates the target:
+
+```ruby
+before(:all) do
+  @http = NiceHttp.new()
+  @volume_name = @volume_name + "-cre"
+  expect(Helper.setup_capacity_pools(@http, ...).state).to eq "Succeeded"
+  @request = Volumes.create_or_update(...)
+end
+after(:all) do
+  unless defined?(DONT_DELETE) && DONT_DELETE
+    Helper.cleanup_capacity_pools(@http, ...)
+  end
+end
+```
+
+**For DELETE endpoints** -- target is recreated before each test (since each test deletes it):
+
+```ruby
+before(:all) do
+  @snapshot_name = @snapshot_name + "-del"
+  expect(Helper.setup_volumes(@http, ...).state).to eq "Succeeded"
+  @request = Snapshots.delete(...)
+end
+before(:each) do |example|
+  @http = NiceHttp.new()
+  expect(Helper.setup_snapshots(@http, ...).state).to eq "Succeeded"
+end
+after(:each) do
+  Helper.cleanup_snapshots(@http, ...)
+end
+after(:all) do
+  unless defined?(DONT_DELETE) && DONT_DELETE
+    Helper.cleanup_volumes(@http, ...)
+  end
+end
+```
+
+**For GET/PATCH endpoints** -- target is set up once in `before(:all)`.
+
+Each setup method cascades to create its parents first (in `helper/setup.rb`):
+
+```ruby
+def self.setup_snapshots(http, ...)
+  setup_capacity_pools(http, ...)
+  # TODO: Create the snapshots resource
+  OpenStruct.new(state: "Succeeded")
+end
+```
+
+Cleanup cascades in reverse (in `helper/cleanup.rb`):
+
+```ruby
+def self.cleanup_snapshots(http, ...)
+  # TODO: Delete the snapshots resource
+  cleanup_capacity_pools(http, ...)
+end
+```
+
+Set `DONT_DELETE=true` in your environment to keep resources for debugging.
+
 ## Example
 
-On this example we will be creating tests for the Uber API using the Swagger / Open API file.
+Creating tests for the Uber API using a Swagger / OpenAPI file:
 
-1. Create a folder in your computer called for example `create_tests_example`
+1. Create a project folder:
 
-2. Copy the file that we have on `./example/requests/uber.yaml` into a folder called `requests` inside `create_tests_example folder`.
+```bash
+mkdir create_tests_example && cd create_tests_example
+```
+
+2. Copy the Swagger file into a `requests` folder (see `./example/requests/uber.yaml` in this repo).
+
+3. Convert the Swagger file into Request Hashes using [open_api_import](https://github.com/MarioRuiz/open_api_import):
 
-3. First we will convert this Swagger file into Requests Hashes by running from `create_tests_example` folder:
 ```bash
 open_api_import ./requests/uber.yaml -fT
 ```
-Now all the Request files were created on the `requests` folder:
+
+Output:
+
 ```
 ** Generated files that contain the code of the requests after importing the Swagger file: 
   - requests/uber.yaml_Products.rb
@@ -78,15 +230,16 @@ Now all the Request files were created on the `requests` folder:
    - requests/uber.yaml.rb 
 ```
 
-4. Now we will create the tests by running:
+4. Generate the tests:
+
 ```bash
 create_tests ./requests/uber.yaml.rb
 ```
 
-5. All your tests will be on `spec` folder, and a `general.rb` file inside `settings` folder was created and also take a look at your `helper.rb` file on `spec` folder.
+Output:
+
 ```
 - Logs: ./requests/uber.yaml.rb_create_tests.log
-** Pay attention, if any of the test files exist or the help file exist only will be added the tests, methods that are missing.
 - Settings: ./settings/general.rb
 - Test created: ./spec/User/profile_user_spec.rb
 - Test created: ./spec/User/activity_user_spec.rb
@@ -96,36 +249,18 @@ create_tests ./requests/uber.yaml.rb
 - Helper: ./spec/helper.rb
 ```
 
-You can see a reproduction of what we did before on here: https://github.com/MarioRuiz/create_tests/tree/master/example
-
-## Parameters
-
-The parameters can be supplied alone or with other parameters. In case a parameter is not supplied then it will be used the default value.
-
-### mode
-
-Accepts three different options: :overwrite, :dont_overwrite and :append. By default :append. 
-
-  append: In case the test file already exists will be only adding those tests that are missing from that file. If the test file doesn't exist, will be created and added all tests.
-
-  dont_overwrite: In case the test file exists any change will be done. If it doesn't exist then it will be created.
-
-  overwrite: In case the file exist you will loose the current code and a new code will be created. Take in consideration that all previous content will be deleted.
-  If it doesn't exist the test file then it will be created.
-
-```ruby
-  require 'create_tests'
-
-  CreateTests.from "./requests/uber.yaml.rb", mode: :overwrite
+5. Review `settings/general.rb` to configure your host and authentication, fill in the Helper methods in `spec/helper.rb`, then run:
 
+```bash
+rspec spec/ --format documentation
 ```
 
+See the full example: https://github.com/MarioRuiz/create_tests/tree/master/example
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/create_tests.
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/MarioRuiz/create_tests.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/create_tests

@@ -17,14 +17,31 @@ optparse = OptionParser.new do |opts|
     options[:mode] = :dont_overwrite
   end
 
-  opts.on("-w", "--overwrite", "In case the test file exists it will be ovewritten, so the previous content will deleted") do
+  opts.on("-w", "--overwrite", "In case the test file exists it will be overwritten, so the previous content will be deleted") do
     options[:mode] = :overwrite
   end
 
-  opts.on("-a", "--append", "In case the test file exists it will be ovewritten, so the previous content will deleted") do
+  opts.on("-a", "--append", "In case the test file exists only missing tests will be appended, existing content is preserved") do
     options[:mode] = :append
   end
 
+  opts.on("-d", "--dry_run", "Preview which files would be created or modified without writing anything") do
+    options[:dry_run] = true
+  end
+
+  opts.on("--cleanup_each", "Generate cleanup in after(:each) instead of after(:all)") do
+    options[:cleanup] = :after_each
+  end
+
+  opts.on("--no_cleanup", "Do not generate setup/cleanup hooks") do
+    options[:cleanup] = false
+  end
+
+  opts.on("-v", "--version", "Show version") do
+    puts "create_tests #{CreateTests::VERSION}"
+    exit
+  end
+
 end
 
 optparse.parse!

data/lib/create-tests/create_helper.rb

@@ -3,19 +3,30 @@ class CreateTests
 
     class << self
   
-      # Create the helper file
-      private def create_helper(params, helper_txt)
+      # Create the helper file (param stubs only).
+      # chain_requires: relative paths (from the helper file) for setup/cleanup, included only when those files are generated.
+      private def create_helper(params, helper_txt, settings_relative_path: '../settings/general', chain_requires: [])
+        chain_lines = chain_requires.map { |rel| "require_relative '#{rel}'\n" }.join
         if helper_txt == ""
           output = "# for the case we want to use it standalone, not inside the project
-                      require_relative '../settings/general' unless defined?(ROOT_DIR)
-          
+                      require_relative '#{settings_relative_path}' unless defined?(ROOT_DIR)
+                      #{chain_lines}
                       # On the methods you can pass the active http connection or none, then it will be created a new one.
                       # Examples from tests:
                       #   Helper.the_method_i_call(@http)
                       #   Helper.the_method_i_call()
                       module Helper\n"
         else
-          output = helper_txt
+          output = helper_txt.dup
+          missing = chain_requires.reject { |rel| output.include?("require_relative '#{rel}'") }
+          unless missing.empty?
+            insert = missing.map { |rel| "require_relative '#{rel}'\n" }.join
+            if output.include?("module Helper")
+              output.sub!("module Helper", "#{insert}module Helper")
+            else
+              output = insert + output
+            end
+          end
           output.gsub!(/\s*end\s*\Z/,"\n")
         end
   
@@ -33,5 +44,86 @@ class CreateTests
         output += "\nend"
   
       end
+
+      # Generate helper/setup.rb with cascading setup methods
+      private def create_setup_file(setup_cleanup_resources)
+        output = "require 'ostruct'\nmodule Helper\n"
+
+        ordered = deduplicate_resources(setup_cleanup_resources)
+
+        ordered.each do |res|
+          param_list = res[:params_up_to].map { |p| p.gsub("@", "") }.join(", ")
+          parent = find_parent_resource(res, ordered)
+
+          output += "# TODO: Create the #{res[:resource]} resource needed as prerequisite\n"
+          output += "def self.setup_#{res[:resource]}(http, #{param_list})\n"
+          if parent
+            parent_params = parent[:params_up_to].map { |p| p.gsub("@", "") }.join(", ")
+            output += "parent_result = setup_#{parent[:resource]}(http, #{parent_params})\n"
+            output += "return parent_result unless parent_result[:state] == 'Succeeded'\n"
+          end
+          output += 'http.logger.info "Helper.#{__method__}"'
+          output += "\n"
+          output += "OpenStruct.new(state: 'Succeeded')\n"
+          output += "end\n"
+        end
+
+        output += "\nend\n"
+      end
+
+      # Generate helper/cleanup.rb with cascading cleanup methods
+      private def create_cleanup_file(setup_cleanup_resources)
+        output = "module Helper\n"
+
+        ordered = deduplicate_resources(setup_cleanup_resources)
+
+        ordered.each do |res|
+          param_list = res[:params_up_to].map { |p| p.gsub("@", "") }.join(", ")
+          parent = find_parent_resource(res, ordered)
+
+          output += "# TODO: Delete the #{res[:resource]} resource after tests\n"
+          output += "def self.cleanup_#{res[:resource]}(http, #{param_list})\n"
+          output += 'http.logger.info "Helper.#{__method__}"'
+          output += "\n"
+          if parent
+            parent_params = parent[:params_up_to].map { |p| p.gsub("@", "") }.join(", ")
+            output += "cleanup_#{parent[:resource]}(http, #{parent_params})\n"
+          end
+          output += "end\n"
+        end
+
+        output += "\nend\n"
+      end
+
+      private def deduplicate_resources(resources)
+        seen = []
+        resources.each_with_object([]) do |res, arr|
+          next if seen.include?(res[:resource])
+          seen << res[:resource]
+          arr << res
+        end
+      end
+
+      # Find the actual parent resource by matching params_up_to as a proper prefix
+      private def find_parent_resource(resource, all_resources)
+        my_params = resource[:params_up_to]
+        return nil if my_params.size <= 1
+
+        parent_params = my_params[0..-2]
+        all_resources.reverse_each do |candidate|
+          return candidate if candidate[:params_up_to] == parent_params
+        end
+
+        best = nil
+        all_resources.each do |candidate|
+          next if candidate[:resource] == resource[:resource]
+          next unless candidate[:params_up_to].size < my_params.size
+          next unless candidate[:params_up_to] == my_params[0, candidate[:params_up_to].size]
+          if best.nil? || candidate[:params_up_to].size > best[:params_up_to].size
+            best = candidate
+          end
+        end
+        best
+      end
     end
   end

data/lib/create-tests/create_settings.rb

@@ -4,7 +4,7 @@ class CreateTests
     class << self
   
       # Create the settings file
-      private def create_settings(requests_file_orig, modules_to_include)
+      private def create_settings(requests_relative_path, modules_to_include, helper_relative_path: '../spec/helper.rb')
         output = "# required libraries
           require 'nice_http'
           require 'nice_hash'
@@ -22,12 +22,12 @@ class CreateTests
           NiceHttp.log = :file_run
           # Add here the headers for authentication for example
           NiceHttp.headers = {
-              Auhentication: 'Token'
+              Authentication: 'Token'
           }
   
           # Requests
-          require_relative '.#{requests_file_orig}'\n
-          require_relative '../spec/helper.rb'\n"
+          require_relative '#{requests_relative_path}'\n
+          require_relative '#{helper_relative_path}'\n"
   
         modules_to_include.each do |m|
           output += "include #{m}\n"

data/lib/create-tests/create_test.rb

@@ -4,22 +4,37 @@ class CreateTests
   class << self
 
     # Return true or false and the test source code
-    private def create_test(module_txt, method_txt, method_obj, test_txt)
+    private def create_test(module_txt, method_txt, method_obj, test_txt, settings_relative_path: '../../settings/general', cleanup: :after_all)
+      unless cleanup == false || [:after_all, :after_each].include?(cleanup)
+        message = "** Wrong cleanup parameter: #{cleanup}"
+        raise message
+      end
+
       modified = false      
       mod_name = module_txt.scan(/::(\w+)$/).join
       req_txt = "#{method_txt}("
       params = []
       keywords_required = []
+      keyreq_kwargs = {}
       method_obj.parameters.each do |p|
-        if p[0] == :req #required
+        if p[0] == :req #required positional
           params << "@#{p[1]}"
+        elsif p[0] == :keyreq
+          keywords_required << p[1]
+          keyreq_kwargs[p[1]] = nil
         elsif p[0] == :key and p[1].to_s.match?(/^[a-z]/i) and Object.const_defined?(p[1].to_s.upcase)
+          # create_constants: required path/query as keyword with UPCASE constant default
           keywords_required << p[1]
         end
       end
-      req_txt += params.join(", ")
+      call_parts = params.dup
+      keywords_required.each { |k| call_parts << "#{k}: @#{k}" }
+      req_txt += call_parts.join(", ")
       req_txt += ")"
-      request = eval("require 'nice_hash';#{module_txt}.#{req_txt}")
+      require 'nice_hash'
+      # Keyword-only methods (create_constants) must not receive nil positionals;
+      # :keyreq needs an explicit keyword so Method#call succeeds.
+      request = method_obj.call(*Array.new(params.size), **keyreq_kwargs)
 
       req_txt = "#{mod_name}.#{req_txt}"
       params_declaration_txt = ""
@@ -28,21 +43,80 @@ class CreateTests
         params_declaration_txt << "#{p} = Helper.#{p.gsub('@','')}(@http)\n"
         @params << p
       end
+      keywords_required.each do |k|
+        params_declaration_txt << "@#{k} = Helper.#{k}(@http)\n"
+        @params << "@#{k}"
+      end
+
+      all_params_for_chain = params + keywords_required.map { |k| "@#{k}" }
+      resource_chain, target_resource = extract_resource_chain(request, all_params_for_chain)
+      @setup_cleanup_resources ||= []
+      @setup_cleanup_resources.concat(resource_chain) unless resource_chain.empty?
+      @setup_cleanup_resources << target_resource if target_resource
+
+      is_delete = request[:method] == :delete
+      needs_target_setup = target_resource && [:delete, :get, :patch].include?(request[:method])
+      parent_resource = resource_chain.last
+
+      method_suffix = method_txt.to_s.split("_").map { |w| w[0..2] }.join[0..2]
+      method_suffix = "-#{method_suffix}"
+
+      setup_before_all_txt = ""
+      setup_before_each_txt = ""
+      after_each_txt = ""
+      after_all_txt = ""
+
+      if is_delete && target_resource && parent_resource
+        setup_before_all_txt = "expect(Helper.setup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')}).state).to eq 'Succeeded'\n"
+        setup_before_each_txt = "expect(Helper.setup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')}).state).to eq 'Succeeded'\n"
+        if cleanup
+          after_each_txt = "after(:each) do\nHelper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\nend\n"
+          after_all_txt = "after(:all) do\nunless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\nend\n"
+        end
+      elsif needs_target_setup && target_resource
+        setup_before_all_txt = "expect(Helper.setup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')}).state).to eq 'Succeeded'\n"
+        if cleanup
+          after_all_txt = "after(:all) do\nunless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\nend\nend\n"
+        end
+      elsif parent_resource
+        setup_before_all_txt = "expect(Helper.setup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')}).state).to eq 'Succeeded'\n"
+        if cleanup && target_resource
+          after_each_txt = "after(:each) do\nHelper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\nend\n"
+          after_all_txt = "after(:all) do\nunless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\nend\n"
+        elsif cleanup
+          after_all_txt = "after(:all) do\nunless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\nend\n"
+        end
+      end
+
+      if cleanup == :after_each && !after_all_txt.empty?
+        after_each_txt += after_all_txt.sub("after(:all)", "after(:each)")
+        after_all_txt = ""
+      end
 
       if test_txt ==""
         modified = true
+
+        suffix_txt = ""
+        if target_resource
+          target_param = target_resource[:params_up_to].last
+          suffix_txt = "#{target_param} = #{target_param} + \"#{method_suffix}\"\n"
+        end
+
+        before_each_block = "before(:each) do |example|\n"
+        before_each_block << "@http = NiceHttp.new()\n" if is_delete && target_resource
+        before_each_block << setup_before_each_txt
+        before_each_block << "@http.logger.info(\"\\n\\n\#{'='*100}\\nTest: \#{example.description}\\n\#{'-'*100}\")\nend\n"
+
         output = "
-        require_relative '../../settings/general'
+        require_relative '#{settings_relative_path}'
         if defined?(#{mod_name}) and defined?(#{mod_name}.#{method_txt})
           RSpec.describe #{mod_name}, '##{method_txt}' do
           before(:all) do
             @http = NiceHttp.new()
-            #{params_declaration_txt}@request = #{req_txt}
+            #{params_declaration_txt}#{suffix_txt}#{setup_before_all_txt}@request = #{req_txt}
             @http.logger.info(\"\\n\#{'+'*50} Before All ends \#{'+'*50}\")
           end
-          before(:each) do |example|
-              @http.logger.info(\"\\n\\n\#{'='*100}\\nTest: \#{example.description}\\n\#{'-'*100}\")
-          end\n"
+          #{after_all_txt}#{after_each_txt}#{before_each_block}\n"
       else
         output = test_txt
         if output.match?(/\s*end\s*end\s*end\s*\Z/)
@@ -55,22 +129,42 @@ class CreateTests
 
       tests = Hash.new()
 
+      has_data_examples = request.key?(:data_examples) &&
+                          request[:data_examples].is_a?(Array) &&
+                          !request[:data_examples].empty?
+      # Prefer data_pattern for variation/invalid-field tests; fall back to :data
+      payload_source = if request.key?(:data_pattern)
+                         ":data_pattern"
+                       elsif request.key?(:data)
+                         ":data"
+                       end
+
       # first response on responses is the one expected to be returned when success
       if request.key?(:responses) and request[:responses].size > 0
         code = request[:responses].keys[0]
         title="it 'has correct structure in successful response' "
-        tests[title] = "do
+        if !request.key?(:data) && has_data_examples
+          tests[title] = "do
+                request = @request.deep_copy
+                request[:data] = @request[:data_examples].first
+                resp = @http.#{request[:method]}(request)
+                expect(resp.code).to eq #{code}\n"
+          if request[:responses][code].is_a?(Hash) and request[:responses][code].key?(:data)
+            tests[title] +="result = NiceHttp.validate_response(resp, @request.responses._#{code}.data, include_diff: true)\n"
+            tests[title] +="expect(result[:ok]).to be(true), \"Structure mismatch: \#{result[:diff]}\"\n"
+          end
+          tests[title] += "end\n"
+        else
+          tests[title] = "do
                 resp = @http.#{request[:method]}(@request)
                 expect(resp.code).to eq #{code}\n"
 
-        if request[:responses][code].is_a?(Hash) and request[:responses][code].key?(:data)
-          if request.key?(:data_pattern)
-            tests[title] +="expect(NiceHash.compare_structure(@request.responses._#{code}.data, resp.data.json, true, @request.data_pattern)).to be true\n"
-          else
-            tests[title] +="expect(NiceHash.compare_structure(@request.responses._#{code}.data, resp.data.json, true)).to be true\n"
+          if request[:responses][code].is_a?(Hash) and request[:responses][code].key?(:data)
+            tests[title] +="result = NiceHttp.validate_response(resp, @request.responses._#{code}.data, include_diff: true)\n"
+            tests[title] +="expect(result[:ok]).to be(true), \"Structure mismatch: \#{result[:diff]}\"\n"
           end
+          tests[title] += "end\n"
         end
-        tests[title] += "end\n"
       end
 
       title = "it 'doesn\\'t retrieve data if not authenticated'"
@@ -113,12 +207,56 @@ class CreateTests
         tests["it 'returns error if required parameter empty' "] = "do\n#{empty_param}"
       end
 
-      if request.key?(:data) and request.key?(:data_required)
+      if request.key?(:mock_response)
+        title = "it 'returns expected mock response' "
+        tests[title] = "do
+                @http_mock = NiceHttp.new()
+                @http_mock.use_mocks = true
+                resp = @http_mock.#{request[:method]}(@request)
+                expect(resp.code).to eq @request[:mock_response][:code]
+                expect(resp.message).to eq @request[:mock_response][:message]\n"
+        if request[:mock_response].key?(:data)
+          tests[title] += "expect(NiceHash.compare_structure(@request[:mock_response][:data], resp.data.json, true)).to be true\n"
+        end
+        tests[title] += "end\n"
+      end
+
+      if payload_source && [:post, :put, :patch].include?(request[:method])
+        title = "it 'handles multiple valid data variations' "
+        tests[title] = "do
+                @request[#{payload_source}].generate_n(5, :correct).each do |generated_data|
+                  request = @request.deep_copy
+                  request[:data] = generated_data
+                  resp = @http.#{request[:method]}(request)
+                  expect(resp.code.to_i).to be_between(200, 299)
+                end
+              end\n"
+      end
+
+      if payload_source
+        title = "it 'returns error when individual data fields are invalid' "
+        tests[title] = "do
+                wrong = @request[#{payload_source}].generate(:correct, errors: :min_length)
+                NiceHash.change_one_by_one([@request[#{payload_source}], :correct], wrong).each do |one_wrong|
+                  request = @request.deep_copy
+                  request[:data] = one_wrong
+                  resp = @http.#{request[:method]}(request)
+                  expect(resp.code.to_i).not_to be_between(200, 299)
+                end
+              end\n"
+      end
+
+      if request.key?(:data_required) && (request.key?(:data) || has_data_examples)
+        seed_data_line = if !request.key?(:data) && has_data_examples
+                           "request[:data] = request[:data_examples].first\n                  "
+                         else
+                           ""
+                         end
         empty_param_data = ""
         empty_param_data += "
                 @request[:data_required].each do |p|
                   request = @request.deep_copy
-                  request.values_for[p] = ''
+                  #{seed_data_line}request.values_for[p] = ''
                   resp = @http.#{request[:method]}(request)
                   expect(resp.code).not_to be_between('200', '299')
                     if request.responses.key?(resp.code.to_sym)
@@ -133,7 +271,7 @@ class CreateTests
         missing_param_data += "
                 @request[:data_required].each do |p|
                   request = @request.deep_copy
-                  NiceHash.delete_nested(request[:data], p)
+                  #{seed_data_line}NiceHash.delete_nested(request[:data], p)
                   resp = @http.#{request[:method]}(request)
                   expect(resp.code).not_to be_between('200', '299')
                     if request.responses.key?(resp.code.to_sym)

data/lib/create-tests/from.rb

@@ -11,20 +11,27 @@ class CreateTests
   #   :overwrite, it will overwrite the test, settings, helper... files in case they exist so you will loose your original source code.
   #   :dont_overwrite, it will create only the files that don't exist previously
   #   :append, it will append or create the tests or helpers that corrently don't exist on every file, but it won't modify any other code.
+  # @param dry_run [Boolean]. (default false). Preview which files would be created or modified without writing anything.
+  # @param return_data [Boolean]. (default false). Return a Hash with generated file paths as keys and content as values, without writing files.
+  # @param spec_dir [String]. (default './spec'). Output directory for generated test files.
+  # @param settings_dir [String]. (default './settings'). Output directory for generated settings files.
+  # @param cleanup [Symbol, false]. (default :after_all). :after_all, :after_each, or false. Controls cleanup hook generation.
   ##############################################################################
-  def self.from(requests_file, type: :request_hash, test: :rspec, mode: :append)
+  def self.from(requests_file, type: :request_hash, test: :rspec, mode: :append, dry_run: false, return_data: false, spec_dir: './spec', settings_dir: './settings', cleanup: :after_all)
+    no_write = dry_run || return_data
+    @generated_data = {} if return_data
+
     begin
-      f = File.new("#{requests_file}_create_tests.log", "w")
-      f.sync = true
-      @logger = Logger.new f
-      puts "- Logs: #{requests_file}_create_tests.log"
+      f = File.new("#{requests_file}_create_tests.log", "w") unless no_write
+      f.sync = true if f
+      @logger = Logger.new(f)
+      puts "- Logs: #{requests_file}_create_tests.log" unless no_write
     rescue StandardError => e
       warn "** Not possible to create the Logger file"
       warn e
       @logger = Logger.new nil
     end
     @logger.info "requests_file: #{requests_file}, type: #{type}, test: #{test}, mode: #{mode}"
-    requests_file_orig = requests_file
 
     requests_file = if requests_file["./"].nil?
                       requests_file
@@ -55,12 +62,18 @@ class CreateTests
       raise message
     end
 
+    unless cleanup == false || [:after_all, :after_each].include?(cleanup)
+      message = "** Wrong cleanup parameter: #{cleanup}"
+      @logger.fatal message
+      raise message
+    end
+
     if mode == :overwrite
       message = "** Pay attention, if any of the files exist, will be overwritten"
       @logger.warn message
       warn message
     elsif mode == :append
-      if Dir["./spec/*/**_spec.rb"].size > 0
+      if Dir["#{spec_dir}/*/**_spec.rb"].size > 0
         message = "** Pay attention, if any of the test files exist or the help file exist only will be added the tests, methods that are missing."
         @logger.warn message
         warn message
@@ -68,13 +81,25 @@ class CreateTests
     end
 
     @params = Array.new
+    @setup_cleanup_resources = Array.new
+
+    require 'pathname'
+    # Resolve symlinks (e.g. macOS /tmp -> /private/tmp) so require_relative
+    # paths stay valid when settings/spec dirs live outside the project tree.
+    resolved_settings_dir = resolve_pathname(settings_dir)
+    resolved_spec_dir = resolve_pathname(spec_dir)
+    settings_path = resolved_settings_dir.join('general')
+    helper_path = resolved_spec_dir.join('helper.rb')
+    settings_from_helper = settings_path.relative_path_from(resolved_spec_dir).to_s
+    helper_from_settings = helper_path.relative_path_from(resolved_settings_dir).to_s
+    requests_from_settings = resolve_pathname(requests_file).relative_path_from(resolved_settings_dir).to_s
 
-    Dir.mkdir "./spec" unless test != :rspec or Dir.exist?("./spec")
+    Dir.mkdir spec_dir unless no_write or test != :rspec or Dir.exist?(spec_dir)
 
     add_settings = true
-    settings_file = "./settings/general.rb"
-    helper_file = './spec/helper.rb'
-    Dir.mkdir "./settings" unless Dir.exist?("./settings")
+    settings_file = "#{settings_dir}/general.rb"
+    helper_file = "#{spec_dir}/helper.rb"
+    Dir.mkdir settings_dir unless no_write or Dir.exist?(settings_dir)
     if File.exist?(settings_file) and mode!=:overwrite
       message = "** The file #{settings_file} already exists so no content will be added to it.\n"
       message += "   Remove the settings file to be able to be generated by create_tests or set mode: :overwrite"
@@ -97,8 +122,8 @@ class CreateTests
     end
 
     begin
-      eval("require '#{requests_file}'")
-    rescue Exception => stack
+      require requests_file
+    rescue StandardError => stack
       message = "\n\n** Error evaluating the ruby file containing the requests: \n" + stack.to_s
       @logger.fatal message
       raise message
@@ -126,22 +151,28 @@ class CreateTests
         mods_to_include << m.scan(/^(.+)::/).join
       end
       mods_to_include.uniq!
-      File.open(settings_file, "w") { |file| file.write(create_settings(requests_file_orig, mods_to_include)) }
+      settings_content = create_settings(requests_from_settings, mods_to_include, helper_relative_path: helper_from_settings)
+      if no_write
+        @generated_data[settings_file] = settings_content if return_data
+        puts "- Settings (dry run): #{settings_file}" if dry_run
+      else
+        File.open(settings_file, "w") { |file| file.write(settings_content) }
+        system("rufo", settings_file, out: File::NULL, err: File::NULL)
+      end
       message = "- Settings: #{settings_file}"
       @logger.info message
-      puts message
-      `rufo #{settings_file}`
+      puts message unless no_write
     end
 
     modules.each do |mod_txt|
       mod_name = mod_txt.scan(/::(\w+)$/).join
-      folder = "./spec/#{mod_name}"
-      unless Dir.exist?(folder)
+      folder = "#{spec_dir}/#{mod_name}"
+      unless no_write or Dir.exist?(folder)
         Dir.mkdir folder
         @logger.info "Created folder: #{folder}"
       end
-      mod_obj = eval("#{mod_txt}")
-      mod_methods_txt = eval ("#{mod_txt}.methods(false)")
+      mod_obj = Object.const_get(mod_txt)
+      mod_methods_txt = mod_obj.methods(false)
       mod_methods_txt.each do |method_txt|
         test_file = "#{folder}/#{method_txt}_spec.rb"
         if File.exist?(test_file) and mode==:dont_overwrite
@@ -155,13 +186,18 @@ class CreateTests
           else
             test_txt = ''
           end
-          modified, txt = create_test(mod_txt, method_txt, mod_obj.method(method_txt),test_txt)
-          File.open(test_file, "w") { |file| file.write(txt) }
-          `rufo #{test_file}`
+          settings_from_test = settings_path.relative_path_from(resolve_pathname(folder)).to_s
+          modified, txt = create_test(mod_txt, method_txt, mod_obj.method(method_txt), test_txt, settings_relative_path: settings_from_test, cleanup: cleanup)
+          if no_write
+            @generated_data[test_file] = txt if return_data
+          else
+            File.open(test_file, "w") { |file| file.write(txt) }
+            system("rufo", test_file, out: File::NULL, err: File::NULL)
+          end
           if test_txt == ""
-            message = "- Test created: #{test_file}"
+            message = "- Test #{no_write ? 'would be created' : 'created'}: #{test_file}"
           elsif modified
-            message = "- Test updated: #{test_file}"
+            message = "- Test #{no_write ? 'would be updated' : 'updated'}: #{test_file}"
           else 
             message = "- Test without changes: #{test_file}"
           end
@@ -175,11 +211,72 @@ class CreateTests
 
     if add_helper
       @params.uniq!
-      File.open(helper_file, "w") { |file| file.write(create_helper(@params, helper_txt)) }
-      message = "- Helper: #{helper_file}"
-      @logger.info message
-      puts message
-      `rufo #{helper_file}`
+      helper_dir = "./helper"
+      chain_requires = []
+      if @setup_cleanup_resources.size > 0
+        spec_pathname = Pathname.new(spec_dir)
+        chain_requires = [
+          Pathname.new("#{helper_dir}/setup").relative_path_from(spec_pathname).to_s,
+          Pathname.new("#{helper_dir}/cleanup").relative_path_from(spec_pathname).to_s,
+        ]
+      end
+      helper_content = create_helper(@params, helper_txt, settings_relative_path: settings_from_helper, chain_requires: chain_requires)
+      if no_write
+        @generated_data[helper_file] = helper_content if return_data
+        puts "- Helper (dry run): #{helper_file}" if dry_run
+      else
+        File.open(helper_file, "w") { |file| file.write(helper_content) }
+        system("rufo", helper_file, out: File::NULL, err: File::NULL)
+        message = "- Helper: #{helper_file}"
+        @logger.info message
+        puts message
+      end
+
+      if @setup_cleanup_resources.size > 0
+        write_chain_file = lambda do |path, content, label|
+          if File.exist?(path) && mode != :overwrite
+            message = "** The file #{path} already exists so it will be left unchanged.\n"
+            message += "   Remove the file to regenerate it or set mode: :overwrite"
+            @logger.warn message
+            warn message
+            return
+          end
+          if no_write
+            @generated_data[path] = content if return_data
+            puts "- #{label} (dry run): #{path}" if dry_run
+          else
+            Dir.mkdir helper_dir unless Dir.exist?(helper_dir)
+            File.open(path, "w") { |file| file.write(content) }
+            system("rufo", path, out: File::NULL, err: File::NULL)
+            message = "- #{label}: #{path}"
+            @logger.info message
+            puts message
+          end
+        end
+
+        write_chain_file.call("#{helper_dir}/setup.rb", create_setup_file(@setup_cleanup_resources), "Helper setup")
+        write_chain_file.call("#{helper_dir}/cleanup.rb", create_cleanup_file(@setup_cleanup_resources), "Helper cleanup")
+      end
+    end
+
+    return @generated_data if return_data
+  end
+
+  # Expand path and resolve symlinks for existing ancestors so relative
+  # require paths stay valid across mounts like macOS /tmp -> /private/tmp.
+  def self.resolve_pathname(path)
+    pn = Pathname.new(File.expand_path(path.to_s))
+    return pn.realpath if pn.exist?
+
+    missing = []
+    current = pn
+    until current.exist? || current.root?
+      missing.unshift(current.basename)
+      current = current.dirname
     end
+    resolved = current.exist? ? current.realpath : current
+    missing.each { |part| resolved += part }
+    resolved
   end
+  private_class_method :resolve_pathname
 end

data/lib/create-tests/get_modules.rb

@@ -6,13 +6,13 @@ class CreateTests
     # fex: ['Swagger::UberApi::V1_0_0::Products', 'Swagger::UberApi::V1_0_0::Cities']
     private def get_modules(mod)
       modules = []
-      mod = eval(mod) if mod.kind_of?(String)
+      mod = Object.const_get(mod) if mod.is_a?(String)
       mod.constants.each do |m|
-        o = eval ("#{mod}::#{m}.constants")
-        if o.size == 0
+        child = mod.const_get(m)
+        if child.constants.empty?
           modules << "#{mod}::#{m}"
         else
-          modules = get_modules("#{mod}::#{m}")
+          modules += get_modules("#{mod}::#{m}")
         end
       end
       modules

data/lib/create-tests/resource_chain.rb

@@ -0,0 +1,88 @@
+
+class CreateTests
+
+  class << self
+
+    # Extracts the resource dependency chain from a request path.
+    # Works with both placeholder paths ({param}) and interpolated paths
+    # (where params are resolved, possibly to empty strings).
+    #
+    # @param request [Hash] Request hash containing :path and :method keys
+    # @param params [Array<String>] Positional parameter names (e.g. ["@subscription_id", "@pool_name"])
+    # @return [Array<Hash>, Hash|nil] Two values: prerequisite chain array and target resource hash (or nil).
+    #   Each hash has keys: resource (String), param (String), params_up_to (Array)
+    private def extract_resource_chain(request, params)
+      return [], nil unless request.key?(:path)
+      return [], nil if params.size < 2
+
+      path = request[:path].split("?").first
+      param_names = params.map { |p| p.gsub("@", "") }
+
+      placeholder_mode = path.include?("{")
+
+      if placeholder_mode
+        segments = path.split("/").reject(&:empty?)
+        resource_pairs = []
+        i = 0
+        while i < segments.size
+          seg = segments[i]
+          next_seg = segments[i + 1]
+          if next_seg && next_seg.match?(/\A\{.+\}\z/)
+            placeholder = next_seg.gsub(/[{}]/, "")
+            resource_pairs << { segment: seg, placeholder: placeholder }
+            i += 2
+          else
+            i += 1
+          end
+        end
+      else
+        segments = path.split("/")
+        segments.shift if segments.first == ""
+
+        resource_pairs = []
+        param_idx = 0
+        i = 0
+        while i < segments.size && param_idx < param_names.size
+          seg = segments[i]
+          next_seg = segments[i + 1]
+          if seg != "" && (next_seg.nil? || next_seg == "")
+            resource_pairs << { segment: seg, placeholder: param_names[param_idx] }
+            param_idx += 1
+            i += 2
+          else
+            i += 1
+          end
+        end
+      end
+
+      return [], nil if resource_pairs.size <= 1
+
+      all_entries = resource_pairs.each_with_index.map do |pair, idx|
+        resource_name = to_snake_case(pair[:segment])
+
+        matching_param = param_names.find { |p| p == pair[:placeholder] || p.end_with?("_#{pair[:placeholder]}") || p.include?(pair[:placeholder]) }
+        matching_param ||= pair[:placeholder]
+
+        params_up_to = []
+        (0..idx).each do |j|
+          ph = resource_pairs[j][:placeholder]
+          mp = param_names.find { |p| p == ph || p.end_with?("_#{ph}") || p.include?(ph) }
+          params_up_to << "@#{mp || ph}"
+        end
+
+        { resource: resource_name, param: matching_param, params_up_to: params_up_to }
+      end
+
+      prerequisites = all_entries[0..-2]
+      target = all_entries.last
+
+      return prerequisites, target
+    end
+
+    private def to_snake_case(str)
+      str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .downcase
+    end
+  end
+end

data/lib/create-tests/version.rb

@@ -0,0 +1,3 @@
+class CreateTests
+  VERSION = "1.1.0"
+end

data/lib/create_tests.rb

@@ -1,8 +1,10 @@
 
 require "logger"
 
+require_relative 'create-tests/version'
 require_relative 'create-tests/create_helper'
 require_relative 'create-tests/create_settings'
 require_relative 'create-tests/create_test'
 require_relative 'create-tests/from'
 require_relative 'create-tests/get_modules'
+require_relative 'create-tests/resource_chain'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: create_tests
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 1.1.0
 platform: ruby
 authors:
 - Mario Ruiz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rufo
@@ -30,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +57,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
 description: CreateTests -- Create Tests automatically from a Requests file. Perfect
   to be used with the result from importing a Swagger file using the open_api_import
   gem
@@ -78,6 +91,8 @@ files:
 - lib/create-tests/create_test.rb
 - lib/create-tests/from.rb
 - lib/create-tests/get_modules.rb
+- lib/create-tests/resource_chain.rb
+- lib/create-tests/version.rb
 - lib/create_tests.rb
 homepage: https://github.com/MarioRuiz/create_tests
 licenses:
@@ -91,15 +106,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.3
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: CreateTests -- Create Tests automatically from a Requests file. Perfect to
   be used with the result from importing a Swagger file using the open_api_import