tng 0.2.3 → 0.2.4

data/lib/tng/services/test_generator.rb

@@ -12,7 +12,7 @@ module Tng
       GENERATE_TESTS_PATH = "cli/tng_rails/contents/generate_tests"
       CONTENT_RESPONSES_PATH = "cli/tng_rails/content_responses"
       POLL_INTERVAL_SECONDS = 5 # Poll every 5 seconds
-      MAX_POLL_DURATION_SECONDS = 360 # 6 minutes total
+      MAX_POLL_DURATION_SECONDS = 420 # 7 minutes total
 
       def initialize(http_client)
         @http_client = http_client
@@ -21,79 +21,36 @@ module Tng
       end
 
       def run_for_controller_method(controller, method_info)
-        start_time = Time.now
-
-        response = Tng.send_request_for_controller(
-          controller[:name],
-          controller[:path],
-          method_info[:name],
-          Tng::Utils.fixture_content,
-          Tng::Services::UserAppConfig.config_with_source,
-          Tng::Services::UserAppConfig.base_url,
-          Tng::Services::UserAppConfig.api_key
-        )
-
-        job_data = JSON.parse(response.body)
-        job_id = job_data["job_id"]
-
-        return unless job_id
-
-        result = poll_for_completion(job_id)
-
-        return unless result
-
-        end_time = Time.now
-        generation_time = end_time - start_time
-
-        file_result = Tng::Utils.save_test_file(result.to_json)
-        return unless file_result
-
-        file_result.merge(generation_time: generation_time)
+        generate_test_for_type(controller, method_info, :controller)
       end
 
       def run_for_model_method(model, method_info)
-        start_time = Time.now
-
-        response = Tng.send_request_for_model(
-          model[:name],
-          model[:path],
-          method_info[:name],
-          Tng::Utils.fixture_content,
-          Tng::Services::UserAppConfig.config_with_source,
-          Tng::Services::UserAppConfig.base_url,
-          Tng::Services::UserAppConfig.api_key
-        )
-
-        job_data = JSON.parse(response.body)
-        job_id = job_data["job_id"]
-
-        return unless job_id
-
-        result = poll_for_completion(job_id)
-
-        return unless result
-
-        end_time = Time.now
-        generation_time = end_time - start_time
+        generate_test_for_type(model, method_info, :model)
+      end
 
-        file_result = Tng::Utils.save_test_file(result.to_json)
-        return unless file_result
+      def run_for_service_method(service, method_info)
+        generate_test_for_type(service, method_info, :service)
+      end
 
-        file_result.merge(generation_time: generation_time)
+      def run_for_other_method(other_file, method_info)
+        generate_test_for_type(other_file, method_info, :other)
       end
 
-      def run_for_service_method(service, method_info)
+      private
+
+      def generate_test_for_type(file_object, method_info, type)
         start_time = Time.now
 
-        response = Tng.send_request_for_service(
-          service[:name],
-          service[:path],
-          method_info[:name],
-          Tng::Utils.fixture_content,
-          Tng::Services::UserAppConfig.config_with_source,
-          Tng::Services::UserAppConfig.base_url,
-          Tng::Services::UserAppConfig.api_key
-        )
+        response = send_request_for_type(file_object, method_info, type)
+        return unless response
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          error_icon = Tng::UI::Theme.icon(:error)
+          error_color = Tng::UI::Theme.color(:error)
+          puts "#{error_icon} #{@pastel.decorate("Request failed:",
+                                                 error_color)} #{response.error&.message || "Unknown error"}"
+          return
+        end
 
         job_data = JSON.parse(response.body)
         job_id = job_data["job_id"]
@@ -113,103 +70,34 @@ module Tng
         file_result.merge(generation_time: generation_time)
       end
 
-      def run_for_other_method(other_file, method_info)
-        start_time = Time.now
+      def send_request_for_type(file_object, method_info, type)
+        config = request_config
+        name = file_object[:name] || File.basename(file_object[:path], ".rb")
+
+        case type
+        when :controller
+          Tng.send_request_for_controller(name, file_object[:path], method_info[:name], *config)
+        when :model
+          Tng.send_request_for_model(name, file_object[:path], method_info[:name], *config)
+        when :service
+          Tng.send_request_for_service(name, file_object[:path], method_info[:name], *config)
+        when :other
+          Tng.send_request_for_other(name, file_object[:path], method_info[:name], *config)
+        end
+      end
 
-        response = Tng.send_request_for_other(
-          other_file[:name] || File.basename(other_file[:path], ".rb"),
-          other_file[:path],
-          method_info[:name],
+      def request_config
+        [
           Tng::Utils.fixture_content,
           Tng::Services::UserAppConfig.config_with_source,
           Tng::Services::UserAppConfig.base_url,
           Tng::Services::UserAppConfig.api_key
-        )
-
-        job_data = JSON.parse(response.body)
-        job_id = job_data["job_id"]
-
-        return unless job_id
-
-        result = poll_for_completion(job_id)
-
-        return unless result
-
-        end_time = Time.now
-        generation_time = end_time - start_time
-
-        file_result = Tng::Utils.save_test_file(result.to_json)
-        return unless file_result
-
-        file_result.merge(generation_time: generation_time)
-      end
-
-      private
-
-      def send_request_and_save_test(payload)
-        job_id = submit_async_job(payload)
-        return unless job_id
-
-        result = poll_for_completion(job_id)
-        return unless result
-
-        Tng::Utils.save_test_file(result.to_json)
-      rescue StandardError => e
-        debug_log("Async request failed: #{e.message}") if debug_enabled?
-        puts "❌ Failed to generate test: #{e.message}"
-        nil
-      end
-
-      def submit_async_job(payload)
-        marshaled = Marshal.dump(payload)
-        compressed = Zlib::Deflate.deflate(marshaled)
-        response = @http_client.post_binary(GENERATE_TESTS_PATH, compressed)
-
-        if response.is_a?(HTTPX::ErrorResponse)
-          debug_log("Processing test failed") if debug_enabled?
-          puts "❌ Failed to submit test generation job: #{response.error&.message}"
-          return
-        end
-
-        job_data = JSON.parse(response.body)
-        job_id = job_data["job_id"]
-
-        debug_log("Processing test with id: #{job_id}") if debug_enabled?
-
-        job_id
-      rescue JSON::ParserError => e
-        debug_log("Failed to parse API response: #{e.message}") if debug_enabled?
-        puts "❌ Failed to parse API response. Please retry."
+        ]
       end
 
       def poll_for_completion(job_id)
         start_time = Time.current
-
-        rocket_icon = Tng::UI::Theme.icon(:rocket)
-        success_color = Tng::UI::Theme.color(:success)
-        primary_color = Tng::UI::Theme.color(:primary)
-        muted_color = Tng::UI::Theme.color(:muted)
-
-        complete_char = @pastel.decorate("▓", success_color)
-        incomplete_char = @pastel.decorate("░", muted_color)
-        head_char = @pastel.decorate("▶", success_color)
-
-        progress_bar = TTY::ProgressBar.new(
-          "#{rocket_icon} #{@pastel.decorate("Generating tests",
-                                             primary_color)} #{@pastel.decorate("[:bar]",
-                                                                                :white)} #{@pastel.decorate(":status",
-                                                                                                            muted_color)} #{@pastel.decorate(
-                                                                                                              "(:elapsed)", muted_color
-                                                                                                            )}",
-          total: nil,
-          complete: complete_char,
-          incomplete: incomplete_char,
-          head: head_char,
-          width: 40,
-          clear: true,
-          frequency: 10,  # Update 10 times per second for smooth animation
-          interval: 1     # Show elapsed time updates every second
-        )
+        progress_bar = create_progress_bar
 
         loop do
           seconds_elapsed = (Time.current - start_time).to_i
@@ -220,16 +108,7 @@ module Tng
             return
           end
 
-          status_text = case seconds_elapsed
-                        when 0..15 then "initializing..."
-                        when 16..45 then "analyzing code structure..."
-                        when 46..90 then "generating test cases..."
-                        when 91..150 then "optimizing test logic..."
-                        when 151..210 then "refining assertions..."
-                        when 211..270 then "formatting output..."
-                        when 271..330 then "finalizing tests..."
-                        else "completing generation..."
-                        end
+          status_text = determine_status_text(seconds_elapsed)
           progress_bar.advance(1, status: status_text)
 
           sleep(POLL_INTERVAL_SECONDS)
@@ -275,6 +154,47 @@ module Tng
         end
       end
 
+      def create_progress_bar
+        rocket_icon = Tng::UI::Theme.icon(:rocket)
+        success_color = Tng::UI::Theme.color(:success)
+        primary_color = Tng::UI::Theme.color(:primary)
+        muted_color = Tng::UI::Theme.color(:muted)
+
+        complete_char = @pastel.decorate("\u2593", success_color)
+        incomplete_char = @pastel.decorate("\u2591", muted_color)
+        head_char = @pastel.decorate("\u25B6", success_color)
+
+        TTY::ProgressBar.new(
+          "#{rocket_icon} #{@pastel.decorate("Generating tests",
+                                             primary_color)} #{@pastel.decorate("[:bar]",
+                                                                                :white)} #{@pastel.decorate(":status",
+                                                                                                            muted_color)} #{@pastel.decorate(
+                                                                                                              "(:elapsed)", muted_color
+                                                                                                            )}",
+          total: nil,
+          complete: complete_char,
+          incomplete: incomplete_char,
+          head: head_char,
+          width: 40,
+          clear: true,
+          frequency: 10,  # Update 10 times per second for smooth animation
+          interval: 1     # Show elapsed time updates every second
+        )
+      end
+
+      def determine_status_text(seconds_elapsed)
+        case seconds_elapsed
+        when 0..15 then "initializing..."
+        when 16..45 then "analyzing code structure..."
+        when 46..90 then "generating test cases..."
+        when 91..150 then "optimizing test logic..."
+        when 151..210 then "refining assertions..."
+        when 211..270 then "formatting output..."
+        when 271..330 then "finalizing tests..."
+        else "completing generation..."
+        end
+      end
+
       def debug_enabled?
         ENV["DEBUG"] == "1"
       end

data/lib/tng/ui/authentication_warning_display.rb

@@ -119,54 +119,4 @@ class AuthenticationWarningDisplay
         method.key?(:auth_type) && !method[:auth_type].to_s.strip.empty?
     end
   end
-
-  def build_missing_items_list
-    issues = []
-
-    if Tng.authentication_enabled && authentication_methods_empty?
-      issues << @pastel.public_send(Tng::UI::Theme.color(:error), "  • authentication_methods array is empty")
-    end
-
-    if !authentication_methods_empty? && !authentication_methods_valid?
-      issues << @pastel.public_send(Tng::UI::Theme.color(:error), "  • authentication_methods contains invalid entries")
-
-      Tng.authentication_methods.each_with_index do |method, index|
-        next if method.is_a?(Hash)
-
-        issues << @pastel.public_send(Tng::UI::Theme.color(:muted), "    - Entry #{index + 1}: not a valid hash")
-        next
-      end
-
-      Tng.authentication_methods.each_with_index do |method, index|
-        next unless method.is_a?(Hash)
-
-        if !method.key?(:method) || method[:method].to_s.strip.empty?
-          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
-                                        "    - Entry #{index + 1}: missing or empty 'method'")
-        end
-
-        if !method.key?(:file_location) || method[:file_location].to_s.strip.empty?
-          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
-                                        "    - Entry #{index + 1}: missing or empty 'file_location'")
-        end
-
-        if !method.key?(:auth_type) || method[:auth_type].to_s.strip.empty?
-          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
-                                        "    - Entry #{index + 1}: missing or empty 'auth_type'")
-        end
-      end
-    end
-
-    unless Tng.authentication_enabled
-      issues << @pastel.public_send(Tng::UI::Theme.color(:warning),
-                                    "  • authentication_enabled is set to false")
-    end
-
-    if issues.empty?
-      @pastel.public_send(Tng::UI::Theme.color(:muted),
-                          "  • Configuration appears valid")
-    else
-      issues.join("\n")
-    end
-  end
 end

data/lib/tng/ui/theme.rb

@@ -13,6 +13,7 @@ module Tng
 
         # Action icons
         rocket: "🚀",
+        run: "▶",
         wave: "👋",
         stats: "📊",
         config: "📋",
@@ -174,7 +175,7 @@ module Tng
         return false if ENV["BUNDLE_GEMFILE"]
         return false if $PROGRAM_NAME&.include?("bundle")
         return false if $PROGRAM_NAME&.include?("rails") && ARGV.any? { |arg| %w[server console runner].include?(arg) }
-        
+
         ENV["TNG_CLI"] == "true" || $PROGRAM_NAME&.include?("tng")
       end
 

data/lib/tng/utils.rb

@@ -321,5 +321,144 @@ module Tng
         false
       end
     end
+
+    # Test result parsing methods
+    def self.parse_rspec_json_results(output, exit_code, pastel, terminal_width)
+      # Parse RSpec JSON output
+      json_data = JSON.parse(output)
+      summary = json_data["summary"] || json_data
+
+      total = summary["example_count"] || summary["total_examples"] || 0
+      failures = summary["failure_count"] || summary["failures"] || 0
+      pending = summary["pending_count"] || summary["pending"] || 0
+      errors = summary["errors_outside_of_examples_count"] || 0
+
+      passed = total - failures - pending - errors
+
+      display_test_counts(passed, failures + errors, pending, total, exit_code.zero?, pastel, terminal_width)
+    rescue JSON::ParserError
+      # Fallback to text parsing if JSON fails
+      puts center_text_static(
+        pastel.decorate("JSON parsing failed, falling back to text parsing",
+                        Tng::UI::Theme.color(:warning)), terminal_width
+      )
+      parse_rspec_results(output, exit_code, pastel, terminal_width)
+    end
+
+    def self.parse_rspec_results(output, exit_code, pastel, terminal_width)
+      # RSpec output example: "7 examples, 2 failures"
+      # or "Finished in 0.12345 seconds (files took 0.01234 seconds to load)"
+      # "7 examples, 2 failures, 1 pending"
+
+      lines = output.lines
+      summary_line = lines.find { |line| line.match?(/\d+ examples?,/) }
+
+      if summary_line
+        # Extract numbers from summary
+        match = summary_line.match(/(\d+) examples?, (\d+) failures?(?:, (\d+) pending)?/)
+        if match
+          total = match[1].to_i
+          failures = match[2].to_i
+          pending = match[3].to_i || 0
+          passed = total - failures - pending
+
+          display_test_counts(passed, failures, pending, total, exit_code == 0, pastel, terminal_width)
+        else
+          puts center_text_static(pastel.decorate("Could not parse RSpec results", Tng::UI::Theme.color(:error)),
+                                  terminal_width)
+          puts center_text_static(output.lines.last.strip, terminal_width) if output.lines.any?
+        end
+      else
+        puts center_text_static(pastel.decorate("No test results found", Tng::UI::Theme.color(:warning)),
+                                terminal_width)
+      end
+    end
+
+    def self.parse_minitest_results(output, exit_code, pastel, terminal_width)
+      # Minitest output example: "7 tests, 15 assertions, 2 failures, 1 errors, 0 skips"
+      # or "Run options: --seed 12345"
+      # "7 tests, 2 assertions, 0 failures, 0 errors, 0 skips"
+
+      lines = output.lines
+      # Look for summary line - could be "X tests" or "X runs"
+      summary_line = lines.find { |line| line.match?(/\d+ (?:tests?|runs?),/) }
+
+      if summary_line
+        # Extract numbers from summary - handle both "tests" and "runs" format
+        match = summary_line.match(/(\d+) (?:tests?|runs?), (\d+) assertions?, (\d+) failures?, (\d+) errors?, (\d+) skips?/)
+        if match
+          total = match[1].to_i
+          failures = match[3].to_i
+          errors = match[4].to_i
+          skips = match[5].to_i
+          passed = total - failures - errors - skips
+
+          display_test_counts(passed, failures + errors, skips, total, exit_code.zero?, pastel, terminal_width)
+        else
+          puts center_text_static(pastel.decorate("Could not parse Minitest results", Tng::UI::Theme.color(:error)),
+                                  terminal_width)
+          puts center_text_static("Expected format: 'X tests, Y assertions, Z failures, A errors, B skips'",
+                                  terminal_width)
+          puts center_text_static("Got: #{summary_line.strip}", terminal_width)
+        end
+      else
+        puts center_text_static(pastel.decorate("No test results found", Tng::UI::Theme.color(:warning)),
+                                terminal_width)
+        puts center_text_static("Looking for line with test counts...", terminal_width)
+        # Show last few lines for debugging
+        last_lines = output.lines.last(3).map(&:strip).join(" | ")
+        puts center_text_static("Last lines: #{last_lines}", terminal_width) if output.lines.any?
+      end
+    end
+
+    def self.display_test_counts(passed, failed, skipped, total, success, pastel, terminal_width)
+      passed_icon = pastel.decorate(Tng::UI::Theme.icon(:success), Tng::UI::Theme.color(:primary))
+      failed_icon = pastel.decorate(Tng::UI::Theme.icon(:error), Tng::UI::Theme.color(:primary))
+      skipped_icon = pastel.decorate("⏭️", Tng::UI::Theme.color(:accent))
+      total_icon = pastel.decorate(Tng::UI::Theme.icon(:marker), Tng::UI::Theme.color(:primary))
+
+      passed_text = pastel.decorate("#{passed_icon} #{passed} passed", Tng::UI::Theme.color(:success))
+      failed_text = pastel.decorate("#{failed_icon} #{failed} failed", Tng::UI::Theme.color(:error))
+      skipped_text = if skipped.positive?
+                       pastel.decorate("#{skipped_icon} #{skipped} skipped",
+                                       Tng::UI::Theme.color(:warning))
+                     else
+                       nil
+                     end
+      total_text = pastel.decorate("#{total_icon} #{total} total", Tng::UI::Theme.color(:secondary))
+
+      results = [passed_text, failed_text, skipped_text, total_text].compact.join(", ")
+      puts center_text_static(results, terminal_width)
+
+      # Overall result
+      overall_msg = if success
+                      pastel.decorate("#{Tng::UI::Theme.icon(:success)} All tests passed!", Tng::UI::Theme.color(:success))
+                    else
+                      pastel.decorate("#{Tng::UI::Theme.icon(:error)} Some tests failed", Tng::UI::Theme.color(:error))
+                    end
+      puts center_text_static(overall_msg, terminal_width)
+    end
+
+    def self.center_text_static(text, width = 80)
+      lines = text.split("\n")
+      lines.map do |line|
+        # Remove ANSI color codes for length calculation
+        clean_line = line.gsub(/\e\[[0-9;]*m/, "")
+        padding = [(width - clean_line.length) / 2, 0].max
+        " " * padding + line
+      end.join("\n")
+    end
+
+    def self.format_generation_time(seconds)
+      if seconds < 1
+        "#{(seconds * 1000).round}ms"
+      elsif seconds < 60
+        "#{seconds.round(1)}s"
+      else
+        minutes = (seconds / 60).floor
+        remaining_seconds = (seconds % 60).round
+        "#{minutes}m #{remaining_seconds}s"
+      end
+    end
   end
 end

data/lib/tng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tng
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tng
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - ralucab
@@ -219,6 +219,7 @@ files:
 - lib/tng/railtie.rb
 - lib/tng/services/direct_generation.rb
 - lib/tng/services/extract_methods.rb
+- lib/tng/services/file_type_detector.rb
 - lib/tng/services/test_generator.rb
 - lib/tng/services/testng.rb
 - lib/tng/services/user_app_config.rb
@@ -271,7 +272,7 @@ post_install_message: "┌ TNG ────────────────
   \                                                            │\n│  • bundle exec
   tng --help  - Show help information                 │\n│                                                                    │\n│
   \ \U0001F4A1 Generate tests for individual methods with precision            │\n└────────────────────────────────────────────────────────────
-  v0.2.3 ┘\n"
+  v0.2.4 ┘\n"
 rdoc_options: []
 require_paths:
 - lib