create_tests 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d22c903c194de3b4c00a889073f9bdf72ba97f7a68c083f871f5fd60905df812
-  data.tar.gz: 638d9efe9d13847ef0c918a2505aea709f6df4a7cb29bea6027fe4e081a96c57
+  metadata.gz: adf779b9d966308976925449218e2f71071441bc665a7c5ecdd79c9ec25c477e
+  data.tar.gz: 49cd07ebd23c1dd406ee5db3af61c3a761615ecec746c451d059717ad8a668dd
 SHA512:
-  metadata.gz: d8c090b7c8195479424bee5b5b0b41e3581deaa34b23e8a8736ff15bb2a548ab0a71f5f1da6b9dabb59bcd63100d8ffd31c353aadadbe9c178ccd69c486d1f4e
-  data.tar.gz: 533123ae7baaf838f831fe93e80ac076ab9dfee262af60029d2c8d442dea4193a660fdd1937fdc972556d89b60d1a903d611effc068d9fdd85cd69793470f55a
+  metadata.gz: 948a204d7595c2b5e5ddbd42e18029b870f0fd9212df3a20dd970b29416d69306332b2f31ecd57fc9b82d8a1ad3b6e15424312248a5c80d26f9ae0ca14e90f00
+  data.tar.gz: 9510e4c3f35eba997841db074bd32b8ef07712bacd88cda7bb49581deea70d1381148d833e3791c5b3c8b21a2d7259fb2fffacfae157dfd15080ad46ca9e5d9c

data/README.md

@@ -2,12 +2,13 @@
 
 [![Gem Version](https://badge.fury.io/rb/create_tests.svg)](https://rubygems.org/gems/create_tests)
 [![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 RSpec or Minitest 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.
 
 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).
 
@@ -28,8 +29,8 @@ The gem uses [rufo](https://github.com/ruby-formatter/rufo) to format generated
 After installation you can run using the command line executable or from Ruby code.
 
 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 `spec/` folder with one RSpec test file per API endpoint (or `test/` with `*_test.rb` when using Minitest)
+- A `spec/helper.rb` (or `test/helper.rb`) with stub methods for required parameters
 - A `settings/general.rb` with NiceHttp configuration boilerplate
 
 ### Command line
@@ -43,6 +44,10 @@ Usage: create_tests [requests_file] [options]
     -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
+        --spec_dir DIR      Output directory for test files (default: ./spec, or ./test with --minitest)
+        --settings_dir DIR  Output directory for settings (default: ./settings)
+        --only KIND         Generate only these test kinds (repeatable or comma-separated)
+        --minitest          Generate Minitest tests instead of RSpec
     -v, --version           Show version
 ```
 
@@ -78,11 +83,13 @@ For each API endpoint, `create_tests` generates up to 7 test types:
 
 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 data, uses `generate_n(5, :correct)` from nice_hash to test 5 different valid payload variations.
+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` to systematically test each data field being wrong one at a time, asserting the server rejects each one.
+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.
+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
 
@@ -90,7 +97,7 @@ For each API endpoint, `create_tests` generates up to 7 test types:
 
 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.
+- **append**: If the test file already exists, only missing tests will be added. Existing content is preserved. For `helper/setup.rb` and `helper/cleanup.rb`, only missing `setup_*` / `cleanup_*` methods are inserted; existing method bodies are left alone. If every method already exists, the file is not rewritten. 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.
 
@@ -119,12 +126,40 @@ result.each { |path, content| puts "#{path}: #{content.length} bytes" }
 
 ### spec_dir / settings_dir
 
-Custom output directories (default: `./spec` and `./settings`).
+Custom output directories (default: `./spec` and `./settings`). With `test: :minitest`, the default test directory is `./test` unless you pass an explicit `spec_dir`.
 
 ```ruby
 CreateTests.from "./requests/uber.yaml.rb", spec_dir: "./test/spec", settings_dir: "./test/config"
 ```
 
+### only
+
+Limit which example kinds are generated. Default `nil` means all kinds. Accepts a symbol, an array, or a comma-separated string. Unknown kinds raise.
+
+Kinds: `success`, `auth`, `required_params`, `mock`, `variations`, `invalid_fields`, `required_data`.
+
+```ruby
+CreateTests.from "./requests/uber.yaml.rb", only: [:success, :auth]
+CreateTests.from "./requests/uber.yaml.rb", only: "success,mock"
+```
+
+```bash
+create_tests ./requests/uber.yaml.rb --only success --only auth
+create_tests ./requests/uber.yaml.rb --only success,auth
+```
+
+### test / Minitest
+
+Default is `:rspec`. Pass `test: :minitest` (or `--minitest`) to generate Minitest files (`*_test.rb`) with `setup` / `teardown` instead of RSpec hooks, and `assert_*` / `refute_*` instead of `expect`.
+
+```ruby
+CreateTests.from "./requests/uber.yaml.rb", test: :minitest
+```
+
+```bash
+create_tests ./requests/uber.yaml.rb --minitest
+```
+
 ### cleanup
 
 Controls whether and how prerequisite setup/cleanup hooks are generated. Default: `:after_all`.
@@ -142,7 +177,7 @@ CreateTests.from "./requests/netapp.json.rb", cleanup: false        # no cleanup
 ```ruby
 before(:all) do
   @http = NiceHttp.new()
-  @volume_name = @volume_name + "-cre"
+  @volume_name = @volume_name + "-createorupda"
   expect(Helper.setup_capacity_pools(@http, ...).state).to eq "Succeeded"
   @request = Volumes.create_or_update(...)
 end
@@ -157,7 +192,7 @@ end
 
 ```ruby
 before(:all) do
-  @snapshot_name = @snapshot_name + "-del"
+  @snapshot_name = @snapshot_name + "-delete"
   expect(Helper.setup_volumes(@http, ...).state).to eq "Succeeded"
   @request = Snapshots.delete(...)
 end

data/bin/create_tests

@@ -37,6 +37,23 @@ optparse = OptionParser.new do |opts|
     options[:cleanup] = false
   end
 
+  opts.on("--spec_dir DIR", "Output directory for generated test files (default: ./spec, or ./test with --minitest)") do |dir|
+    options[:spec_dir] = dir
+  end
+
+  opts.on("--settings_dir DIR", "Output directory for generated settings files (default: ./settings)") do |dir|
+    options[:settings_dir] = dir
+  end
+
+  opts.on("--only KIND", "Generate only these test kinds (repeatable or comma-separated). Kinds: success, auth, required_params, mock, variations, invalid_fields, required_data") do |kind|
+    options[:only] ||= []
+    options[:only].concat(kind.split(",").map { |s| s.strip.to_sym })
+  end
+
+  opts.on("--minitest", "Generate Minitest tests instead of RSpec") do
+    options[:test] = :minitest
+  end
+
   opts.on("-v", "--version", "Show version") do
     puts "create_tests #{CreateTests::VERSION}"
     exit

data/lib/create-tests/create_helper.rb

@@ -125,5 +125,71 @@ class CreateTests
         end
         best
       end
+
+      # Append only missing setup_/cleanup_ methods from generated content into an
+      # existing file. Existing method bodies are left untouched.
+      # @return [Array(String, Boolean)] merged content and whether anything was added
+      private def append_missing_chain_methods(existing_txt, generated_txt)
+        method_blocks = extract_chain_method_blocks(generated_txt)
+        missing = method_blocks.reject { |blk| existing_txt.include?("def self.#{blk[:name]}(") }
+        return [existing_txt, false] if missing.empty?
+
+        output = existing_txt.dup
+        insert = missing.map { |blk| blk[:text] }.join
+
+        if output.match?(/\bmodule\s+Helper\b/)
+          if output.match?(/\s*end\s*\Z/)
+            output.sub!(/\s*end\s*\Z/, "\n#{insert}\nend\n")
+          else
+            output << "\n#{insert}"
+          end
+        else
+          # Preserve leading require (e.g. ostruct) from generated content when wrapping.
+          require_line = generated_txt[/^require[^\n]*\n/]
+          prefix = require_line && !output.include?(require_line.strip) ? require_line : ""
+          output = "#{prefix}module Helper\n#{output.chomp}\n#{insert}\nend\n"
+        end
+
+        [output, true]
+      end
+
+      private def extract_chain_method_blocks(generated_txt)
+        blocks = []
+        lines = generated_txt.lines
+        i = 0
+        while i < lines.size
+          if lines[i] =~ /\A#/
+            comment_start = i
+            i += 1 while i < lines.size && lines[i] =~ /\A#/
+            if i < lines.size && lines[i] =~ /\Adef self\.(setup_\w+|cleanup_\w+)\(/
+              name = $1
+              start = comment_start
+              i += 1
+              depth = 1
+              while i < lines.size && depth > 0
+                depth += 1 if lines[i] =~ /\A\s*def\b/
+                depth -= 1 if lines[i] =~ /\Aend\b/
+                i += 1
+              end
+              blocks << { name: name, text: lines[start...i].join }
+              next
+            end
+          elsif lines[i] =~ /\Adef self\.(setup_\w+|cleanup_\w+)\(/
+            name = $1
+            start = i
+            i += 1
+            depth = 1
+            while i < lines.size && depth > 0
+              depth += 1 if lines[i] =~ /\A\s*def\b/
+              depth -= 1 if lines[i] =~ /\Aend\b/
+              i += 1
+            end
+            blocks << { name: name, text: lines[start...i].join }
+            next
+          end
+          i += 1
+        end
+        blocks
+      end
     end
   end

data/lib/create-tests/create_test.rb

@@ -1,39 +1,58 @@
 
 class CreateTests
 
+  TEST_KINDS = %i[
+    success auth required_params mock variations invalid_fields required_data
+  ].freeze
+
   class << self
 
     # Return true or false and the test source code
-    private def create_test(module_txt, method_txt, method_obj, test_txt, settings_relative_path: '../../settings/general', cleanup: :after_all)
+    private def create_test(module_txt, method_txt, method_obj, test_txt, settings_relative_path: '../../settings/general', cleanup: :after_all, test: :rspec, only: nil)
       unless cleanup == false || [:after_all, :after_each].include?(cleanup)
         message = "** Wrong cleanup parameter: #{cleanup}"
         raise message
       end
 
-      modified = false      
+      only_kinds = normalize_only(only)
+
+      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 += ")"
       require 'nice_hash'
-      request = method_obj.call(*Array.new(params.size))
+      # 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 = ""
-      ## todo: add param in case of :append 
+      ## todo: add param in case of :append
       params.each do |p|
         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)
@@ -45,8 +64,7 @@ class CreateTests
       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}"
+      method_suffix = "-#{method_txt.to_s.gsub('_', '')[0, 12]}"
 
       setup_before_all_txt = ""
       setup_before_each_txt = ""
@@ -54,33 +72,39 @@ class CreateTests
       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"
+        setup_before_all_txt = "#{assert_eq("Helper.setup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')}).state", "'Succeeded'", test)}\n"
+        setup_before_each_txt = "#{assert_eq("Helper.setup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')}).state", "'Succeeded'", test)}\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"
+          after_each_txt = framework_hook(:after_each, "Helper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\n", test)
+          after_all_txt = framework_hook(:after_all, "unless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\n", test)
         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"
+        setup_before_all_txt = "#{assert_eq("Helper.setup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')}).state", "'Succeeded'", test)}\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"
+          after_all_txt = framework_hook(:after_all, "unless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\nend\n", test)
         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"
+        setup_before_all_txt = "#{assert_eq("Helper.setup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')}).state", "'Succeeded'", test)}\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"
+          after_each_txt = framework_hook(:after_each, "Helper.cleanup_#{target_resource[:resource]}(@http, #{target_resource[:params_up_to].join(', ')})\n", test)
+          after_all_txt = framework_hook(:after_all, "unless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\n", test)
         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"
+          after_all_txt = framework_hook(:after_all, "unless defined?(DONT_DELETE) && DONT_DELETE\nHelper.cleanup_#{parent_resource[:resource]}(@http, #{parent_resource[:params_up_to].join(', ')})\nend\n", test)
         end
       end
 
       if cleanup == :after_each && !after_all_txt.empty?
-        after_each_txt += after_all_txt.sub("after(:all)", "after(:each)")
-        after_all_txt = ""
+        if test == :minitest
+          # Minitest folds after(:all) into teardown; after_each mode just uses teardown body once.
+          after_each_txt += after_all_txt
+          after_all_txt = ""
+        else
+          after_each_txt += after_all_txt.sub("after(:all)", "after(:each)")
+          after_all_txt = ""
+        end
       end
 
-      if test_txt ==""
+      if test_txt == ""
         modified = true
 
         suffix_txt = ""
@@ -89,12 +113,15 @@ class CreateTests
           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"
+        if test == :minitest
+          output = build_minitest_skeleton(mod_name, method_txt, settings_relative_path, params_declaration_txt, suffix_txt, setup_before_all_txt, setup_before_each_txt, after_each_txt, after_all_txt, req_txt, is_delete, target_resource)
+        else
+          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 = "
+          output = "
         require_relative '#{settings_relative_path}'
         if defined?(#{mod_name}) and defined?(#{mod_name}.#{method_txt})
           RSpec.describe #{mod_name}, '##{method_txt}' do
@@ -104,147 +131,179 @@ class CreateTests
             @http.logger.info(\"\\n\#{'+'*50} Before All ends \#{'+'*50}\")
           end
           #{after_all_txt}#{after_each_txt}#{before_each_block}\n"
+        end
       else
         output = test_txt
-        if output.match?(/\s*end\s*end\s*end\s*\Z/)
-          output.gsub!(/\s*end\s*end\s*\Z/,"\n")
+        if test == :minitest
+          output.gsub!(/\s*end\s*\Z/, "\n")
+        elsif output.match?(/\s*end\s*end\s*end\s*\Z/)
+          output.gsub!(/\s*end\s*end\s*\Z/, "\n")
         else
-          output.gsub!(/\s*end\s*\Z/,"\n")
+          output.gsub!(/\s*end\s*\Z/, "\n")
         end
       end
 
 
       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
+      if include_kind?(only_kinds, :success) && request.key?(:responses) and request[:responses].size > 0
         code = request[:responses].keys[0]
-        title="it 'has correct structure in successful response' "
-        tests[title] = "do
+        title = example_title("has correct structure in successful response", test, trailing_space: true)
+        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)
+                #{assert_eq('resp.code', code, test)}\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] += "#{assert_be_true('result[:ok]', 'Structure mismatch: #{result[:diff]}', test)}\n"
+          end
+          tests[title] += "end\n"
+        else
+          tests[title] = "do
                 resp = @http.#{request[:method]}(@request)
-                expect(resp.code).to eq #{code}\n"
+                #{assert_eq('resp.code', code, test)}\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"
+          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] += "#{assert_be_true('result[:ok]', 'Structure mismatch: #{result[:diff]}', test)}\n"
+          end
+          tests[title] += "end\n"
         end
-        tests[title] += "end\n"
       end
 
-      title = "it 'doesn\\'t retrieve data if not authenticated'"
-      tests[title] = "do
+      if include_kind?(only_kinds, :auth)
+        title = example_title("doesn\\'t retrieve data if not authenticated", test)
+        tests[title] = "do
             http = NiceHttp.new()
             http.headers = {}
             resp = http.#{request[:method]}(@request)
-            expect(resp.code).to be_between('400', '499')\n"
-      if request.key?(:responses) and (request[:responses].keys.select{|c| c.to_s.to_i>=400&&c.to_s.to_i<=499}).size>0
-      tests[title] += "expect(NiceHash.compare_structure(@request.responses[resp.code.to_sym].data, resp.data.json)).to eq true
-        expect(resp.message).to eq @request.responses[resp.code.to_sym].message\n"
+            #{assert_between('resp.code', "'400'", "'499'", test)}\n"
+        if request.key?(:responses) and (request[:responses].keys.select{|c| c.to_s.to_i>=400&&c.to_s.to_i<=499}).size>0
+          tests[title] += "#{assert_eq('NiceHash.compare_structure(@request.responses[resp.code.to_sym].data, resp.data.json)', 'true', test)}
+        #{assert_eq('resp.message', '@request.responses[resp.code.to_sym].message', test)}\n"
+        end
+        tests[title] += "end\n"
       end
-      tests[title] += "end\n"
-            
-      if params.size > 0 or keywords_required.size >0
+
+      if include_kind?(only_kinds, :required_params) && (params.size > 0 or keywords_required.size >0)
         empty_param = ""
         params.each do |p|
           r = req_txt.gsub(/#{p}([),])/, '""\1')
           empty_param += "
                     request = #{r}
                     resp = @http.#{request[:method]}(request)
-                    expect(resp.code).to be_between('400', '499')\n"
+                    #{assert_between('resp.code', "'400'", "'499'", test)}\n"
                     if request.key?(:responses) and (request[:responses].keys.select{|c| c.to_s.to_i>=400&&c.to_s.to_i<=499}).size>0
-                      empty_param += "expect(resp.message).to match /\#{request.responses[resp.code.to_sym].message}/i\n"
+                      empty_param += "#{assert_match('resp.message', '/\#{request.responses[resp.code.to_sym].message}/i', test)}\n"
                     end
         end
-        if keywords_required.size > 0 
+        if keywords_required.size > 0
           r = req_txt.scan(/(.+)\(/).join
           empty_param += "
                     [:#{keywords_required.join(', :')}].each do |kw|
                       request = #{r}(kw => '')
                       resp = @http.#{request[:method]}(request)
-                      expect(resp.code).to be_between('400', '499')\n"
+                      #{assert_between('resp.code', "'400'", "'499'", test)}\n"
           if request.key?(:responses) and (request[:responses].keys.select{|c| c.to_s.to_i>=400&&c.to_s.to_i<=499}).size>0
-            empty_param += "expect(resp.message).to match /\#{request.responses[resp.code.to_sym].message}/i\n"
+            empty_param += "#{assert_match('resp.message', '/\#{request.responses[resp.code.to_sym].message}/i', test)}\n"
           end
           empty_param += "end\n"
         end
         empty_param += "end\n"
-        tests["it 'returns error if required parameter empty' "] = "do\n#{empty_param}"
+        tests[example_title("returns error if required parameter empty", test, trailing_space: true)] = "do\n#{empty_param}"
       end
 
-      if request.key?(:mock_response)
-        title = "it 'returns expected mock response' "
+      if include_kind?(only_kinds, :mock) && request.key?(:mock_response)
+        title = example_title("returns expected mock response", test, trailing_space: true)
         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"
+                #{assert_eq('resp.code', '@request[:mock_response][:code]', test)}
+                #{assert_eq('resp.message', '@request[:mock_response][:message]', test)}\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"
+          tests[title] += "#{assert_be_true('NiceHash.compare_structure(@request[:mock_response][:data], resp.data.json, true)', nil, test)}\n"
         end
         tests[title] += "end\n"
       end
 
-      if request.key?(:data) and [:post, :put, :patch].include?(request[:method])
-        title = "it 'handles multiple valid data variations' "
+      if include_kind?(only_kinds, :variations) && payload_source && [:post, :put, :patch].include?(request[:method])
+        title = example_title("handles multiple valid data variations", test, trailing_space: true)
         tests[title] = "do
-                @request[:data].generate_n(5, :correct).each do |generated_data|
+                @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)
+                  #{assert_between('resp.code.to_i', '200', '299', test)}
                 end
               end\n"
       end
 
-      if request.key?(:data)
-        title = "it 'returns error when individual data fields are invalid' "
+      if include_kind?(only_kinds, :invalid_fields) && payload_source
+        title = example_title("returns error when individual data fields are invalid", test, trailing_space: true)
         tests[title] = "do
-                wrong = @request[:data].generate(:correct, errors: :min_length)
-                NiceHash.change_one_by_one([@request[:data], :correct], wrong).each do |one_wrong|
+                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)
+                  #{assert_between('resp.code.to_i', '200', '299', test, negate: true)}
                 end
               end\n"
       end
 
-      if request.key?(:data) and request.key?(:data_required)
+      if include_kind?(only_kinds, :required_data) && 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')
+                  #{assert_between('resp.code', "'200'", "'299'", test, negate: true)}
                     if request.responses.key?(resp.code.to_sym)
-                      expect(resp.message).to match /\#{request.responses[resp.code.to_sym].message}/i
+                      #{assert_match('resp.message', '/\#{request.responses[resp.code.to_sym].message}/i', test)}
                     end
                 end
             "
         empty_param_data += "end\n"
-        tests["it 'returns error if required parameter on data empty' do\n"] = empty_param_data
+        tests[example_title("returns error if required parameter on data empty", test, with_do: true)] = empty_param_data
 
         missing_param_data = ""
         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')
+                  #{assert_between('resp.code', "'200'", "'299'", test, negate: true)}
                     if request.responses.key?(resp.code.to_sym)
-                      expect(resp.message).to match /\#{request.responses[resp.code.to_sym].message}/i
+                      #{assert_match('resp.message', '/\#{request.responses[resp.code.to_sym].message}/i', test)}
                     end
                 end
             "
         missing_param_data += "end\n"
-        tests["it 'returns error if required parameter on data missing' do\n"] = missing_param_data
+        tests[example_title("returns error if required parameter on data missing", test, with_do: true)] = missing_param_data
       end
 
       tests.each do |k,v|
-        unless output.include?(k.gsub(" '",' "').gsub("' ",'" ').gsub("\n",'').gsub(/\s+do$/,'').gsub(/^\s*it/,'')) or 
-          output.include?(k.gsub(' "'," '").gsub('" ',"' ").gsub("\n",'').gsub(/\s+do$/,'').gsub(/^\s*it/,''))
+        unless example_already_present?(output, k, test)
           modified = true
           message = " = test added #{k} for #{method_txt}"
           @logger.info message
@@ -252,15 +311,191 @@ class CreateTests
             puts message
             output +="# Appended #{Time.now.stamp}\n"
           end
-          output += "#{k}#{v}"
+          if test == :minitest
+            # keys are "def test_foo" and bodies start with "do\n...\nend"
+            body = v.sub(/\Ado\n/, "").sub(/\n?end\n?\z/, "\n")
+            output += "#{k}\n#{body}end\n"
+          else
+            output += "#{k}#{v}"
+          end
         end
       end
-      if output.include?('defined?(')
+      if test == :minitest
+        if output.include?('defined?(')
+          output += "\nend\nend"
+        else
+          output += "\nend"
+        end
+      elsif output.include?('defined?(')
         output += "\nend\nend"
       else
         output +="\nend"
       end
       return modified, output
     end
+
+    private def normalize_only(only)
+      return nil if only.nil?
+      list = case only
+             when Symbol then [only]
+             when String then only.split(",").map { |s| s.strip.to_sym }
+             when Array then only.map { |s| s.to_s.strip.to_sym }
+             else
+               raise "** Wrong only parameter: #{only}"
+             end
+      unknown = list - TEST_KINDS
+      unless unknown.empty?
+        raise "** Wrong only parameter: unknown kind(s) #{unknown.join(', ')}. Valid: #{TEST_KINDS.join(', ')}"
+      end
+      list
+    end
+
+    private def include_kind?(only_kinds, kind)
+      only_kinds.nil? || only_kinds.include?(kind)
+    end
+
+    private def example_title(description, test, trailing_space: false, with_do: false)
+      if test == :minitest
+        "def test_#{minitest_method_name(description)}"
+      else
+        space = trailing_space ? " " : ""
+        if with_do
+          "it '#{description}' do\n"
+        else
+          "it '#{description}'#{space}"
+        end
+      end
+    end
+
+    private def minitest_method_name(description)
+      description.gsub("\\'", "")
+                 .gsub(/[^a-zA-Z0-9]+/, "_")
+                 .gsub(/\A_+|_+\z/, "")
+                 .downcase
+    end
+
+    private def example_already_present?(output, key, test)
+      if test == :minitest
+        output.include?(key)
+      else
+        output.include?(key.gsub(" '", ' "').gsub("' ", '" ').gsub("\n", '').gsub(/\s+do$/, '').gsub(/^\s*it/, '')) ||
+          output.include?(key.gsub(' "', " '").gsub('" ', "' ").gsub("\n", '').gsub(/\s+do$/, '').gsub(/^\s*it/, ''))
+      end
+    end
+
+    private def assert_eq(actual, expected, test)
+      if test == :minitest
+        "assert_equal #{expected}, #{actual}"
+      else
+        "expect(#{actual}).to eq #{expected}"
+      end
+    end
+
+    private def assert_be_true(actual, message, test)
+      if test == :minitest
+        if message
+          "assert #{actual}, \"#{message}\""
+        else
+          "assert #{actual}"
+        end
+      else
+        if message
+          "expect(#{actual}).to be(true), \"#{message}\""
+        else
+          "expect(#{actual}).to be true"
+        end
+      end
+    end
+
+    private def assert_between(actual, low, high, test, negate: false)
+      if test == :minitest
+        if negate
+          "refute_includes (#{low}..#{high}), #{actual}"
+        else
+          "assert_includes (#{low}..#{high}), #{actual}"
+        end
+      else
+        if negate
+          "expect(#{actual}).not_to be_between(#{low}, #{high})"
+        else
+          "expect(#{actual}).to be_between(#{low}, #{high})"
+        end
+      end
+    end
+
+    private def assert_match(actual, pattern, test)
+      if test == :minitest
+        "assert_match #{pattern}, #{actual}"
+      else
+        "expect(#{actual}).to match #{pattern}"
+      end
+    end
+
+    private def framework_hook(kind, body, test)
+      if test == :minitest
+        # Stored as raw bodies; assembled into setup/teardown in the skeleton.
+        # Prefix with a marker so cleanup: :after_each merging can find them.
+        case kind
+        when :after_each then "TEARDOWN_EACH:#{body}"
+        when :after_all then "TEARDOWN_ALL:#{body}"
+        else body
+        end
+      else
+        case kind
+        when :after_each then "after(:each) do\n#{body}end\n"
+        when :after_all then "after(:all) do\n#{body}end\n"
+        else body
+        end
+      end
+    end
+
+    private def build_minitest_skeleton(mod_name, method_txt, settings_relative_path, params_declaration_txt, suffix_txt, setup_before_all_txt, setup_before_each_txt, after_each_txt, after_all_txt, req_txt, is_delete, target_resource)
+      class_name = "#{mod_name}#{camelize(method_txt.to_s)}Test"
+
+      teardown_each_body = after_each_txt.to_s.gsub(/\ATEARDOWN_EACH:/, "").gsub(/\ATEARDOWN_ALL:/, "")
+      # after_each_txt may contain both TEARDOWN_EACH and (after merge) TEARDOWN_ALL markers
+      each_parts = []
+      all_parts = []
+      [after_each_txt.to_s, after_all_txt.to_s].each do |chunk|
+        chunk.split(/(?=TEARDOWN_(?:EACH|ALL):)/).each do |part|
+          next if part.empty?
+          if part.start_with?("TEARDOWN_EACH:")
+            each_parts << part.sub(/\ATEARDOWN_EACH:/, "")
+          elsif part.start_with?("TEARDOWN_ALL:")
+            all_parts << part.sub(/\ATEARDOWN_ALL:/, "")
+          end
+        end
+      end
+
+      teardown_body = (each_parts + all_parts).join
+
+      setup_http = if is_delete && target_resource
+                     "@http = NiceHttp.new()\n"
+                   else
+                     ""
+                   end
+
+      # before(:all) work at start of setup; before(:each) after that.
+      # First test creates @http for non-delete; delete recreates in the each section.
+      "
+        require 'minitest/autorun'
+        require_relative '#{settings_relative_path}'
+        if defined?(#{mod_name}) and defined?(#{mod_name}.#{method_txt})
+          class #{class_name} < Minitest::Test
+          def setup
+            @http = NiceHttp.new()
+            #{params_declaration_txt}#{suffix_txt}#{setup_before_all_txt}@request = #{req_txt}
+            @http.logger.info(\"\\n\#{'+'*50} Before All ends \#{'+'*50}\")
+            #{setup_http}#{setup_before_each_txt}@http.logger.info(\"\\n\\n\#{'='*100}\\nTest: \#{name}\\n\#{'-'*100}\")
+          end
+          def teardown
+            #{teardown_body}
+          end
+"
+    end
+
+    private def camelize(snake)
+      snake.to_s.split("_").map(&:capitalize).join
+    end
   end
-end
+end

data/lib/create-tests/from.rb

@@ -6,18 +6,19 @@ class CreateTests
   # More info about Request Hashes: https://github.com/MarioRuiz/Request-Hash
   # @param requests_file [String]. Path and file name. Could be absolute or relative to project root folder.
   # @param type [Symbol]. (default :request_hash). The kind of content that requests_file contains.
-  # @param test [Symbol]. (default :rspec). What kind of tests we want to create
+  # @param test [Symbol]. (default :rspec). What kind of tests we want to create (:rspec or :minitest).
   # @param mode [Symbol]. (default :append). :overwrite, :append, :dont_overwrite. How we want to create the tests.
   #   :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 spec_dir [String]. (default './spec' for RSpec, './test' for Minitest). 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.
+  # @param only [Array, Symbol, String, nil]. (default nil = all). Limit which example kinds are generated.
   ##############################################################################
-  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)
+  def self.from(requests_file, type: :request_hash, test: :rspec, mode: :append, dry_run: false, return_data: false, spec_dir: nil, settings_dir: './settings', cleanup: :after_all, only: nil)
     no_write = dry_run || return_data
     @generated_data = {} if return_data
 
@@ -50,12 +51,17 @@ class CreateTests
       raise message
     end
 
-    unless [:rspec].include?(test)
+    unless [:rspec, :minitest].include?(test)
       message = "** Wrong test parameter: #{test}"
       @logger.fatal message
       raise message
     end
 
+    # Default output dir depends on framework; an explicit spec_dir is always honored.
+    if spec_dir.nil?
+      spec_dir = test == :minitest ? './test' : './spec'
+    end
+
     unless [:overwrite, :dont_overwrite, :append].include?(mode)
       message = "** Wrong mode parameter: #{mode}"
       @logger.fatal message
@@ -68,12 +74,16 @@ class CreateTests
       raise message
     end
 
+    # Validate only early so bad values fail before generation.
+    normalize_only(only)
+
     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_dir}/*/**_spec.rb"].size > 0
+      existing_tests = Dir["#{spec_dir}/*/**_spec.rb"] + Dir["#{spec_dir}/*/**_test.rb"]
+      if existing_tests.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
@@ -94,7 +104,7 @@ class CreateTests
     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_dir unless no_write or test != :rspec or Dir.exist?(spec_dir)
+    Dir.mkdir spec_dir unless no_write or Dir.exist?(spec_dir)
 
     add_settings = true
     settings_file = "#{settings_dir}/general.rb"
@@ -164,6 +174,8 @@ class CreateTests
       puts message unless no_write
     end
 
+    test_suffix = test == :minitest ? "_test.rb" : "_spec.rb"
+
     modules.each do |mod_txt|
       mod_name = mod_txt.scan(/::(\w+)$/).join
       folder = "#{spec_dir}/#{mod_name}"
@@ -174,7 +186,7 @@ class CreateTests
       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"
+        test_file = "#{folder}/#{method_txt}#{test_suffix}"
         if File.exist?(test_file) and mode==:dont_overwrite
           message = "** The file #{test_file} already exists so no content will be added to it.\n"
           message += "   Remove the test file to be able to be generated by create_tests or set mode: :overwrite, or mode: :append"
@@ -187,7 +199,7 @@ class CreateTests
             test_txt = ''
           end
           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)
+          modified, txt = create_test(mod_txt, method_txt, mod_obj.method(method_txt), test_txt, settings_relative_path: settings_from_test, cleanup: cleanup, test: test, only: only)
           if no_write
             @generated_data[test_file] = txt if return_data
           else
@@ -198,7 +210,7 @@ class CreateTests
             message = "- Test #{no_write ? 'would be created' : 'created'}: #{test_file}"
           elsif modified
             message = "- Test #{no_write ? 'would be updated' : 'updated'}: #{test_file}"
-          else 
+          else
             message = "- Test without changes: #{test_file}"
           end
           @logger.info message
@@ -234,13 +246,36 @@ class CreateTests
 
       if @setup_cleanup_resources.size > 0
         write_chain_file = lambda do |path, content, label|
-          if File.exist?(path) && mode != :overwrite
+          if File.exist?(path) && mode == :dont_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"
+            message += "   Remove the file to regenerate it or set mode: :overwrite or :append"
             @logger.warn message
             warn message
             return
           end
+
+          if File.exist?(path) && mode == :append
+            existing = File.read(path)
+            merged, changed = append_missing_chain_methods(existing, content)
+            unless changed
+              message = "- #{label} without changes: #{path}"
+              @logger.info message
+              return
+            end
+            content = merged
+            if no_write
+              @generated_data[path] = content if return_data
+              puts "- #{label} (dry run): #{path}" if dry_run
+            else
+              File.open(path, "w") { |file| file.write(content) }
+              system("rufo", path, out: File::NULL, err: File::NULL)
+              message = "- #{label} updated: #{path}"
+              @logger.info message
+              puts message
+            end
+            return
+          end
+
           if no_write
             @generated_data[path] = content if return_data
             puts "- #{label} (dry run): #{path}" if dry_run
@@ -279,4 +314,4 @@ class CreateTests
     resolved
   end
   private_class_method :resolve_pathname
-end
+end

data/lib/create-tests/resource_chain.rb

@@ -3,10 +3,16 @@ class CreateTests
 
   class << self
 
+    SKIP_CHAIN_SEGMENTS = %w[subscriptions resource_groups providers].freeze
+
     # 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).
     #
+    # Segments whose snake_case names are subscriptions, resource_groups, or
+    # providers are omitted from the setup/cleanup chain, but their parameters
+    # remain in params_up_to for later resources.
+    #
     # @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).
@@ -73,8 +79,14 @@ class CreateTests
         { resource: resource_name, param: matching_param, params_up_to: params_up_to }
       end
 
-      prerequisites = all_entries[0..-2]
-      target = all_entries.last
+      # Drop Azure infrastructure segments from the chain; keep their params in params_up_to.
+      real_entries = all_entries.reject { |e| SKIP_CHAIN_SEGMENTS.include?(e[:resource]) }
+
+      return [], nil if real_entries.empty?
+      return [], real_entries.first if real_entries.size == 1
+
+      prerequisites = real_entries[0..-2]
+      target = real_entries.last
 
       return prerequisites, target
     end

data/lib/create-tests/version.rb

@@ -1,3 +1,3 @@
 class CreateTests
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: create_tests
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Mario Ruiz
@@ -97,7 +97,10 @@ files:
 homepage: https://github.com/MarioRuiz/create_tests
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/MarioRuiz/create_tests/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/MarioRuiz/create_tests
+  bug_tracker_uri: https://github.com/MarioRuiz/create_tests/issues
 post_install_message: Thanks for installing! Visit us on https://github.com/MarioRuiz/create_tests
 rdoc_options: []
 require_paths: