rails_proof 1.0.0

data/lib/rails_proof/ai_test_writer.rb

@@ -0,0 +1,51 @@
+module RailsProof
+  class AiTestWriter
+    class InvalidConcern < StandardError; end
+
+    attr_reader :test_class_name, :superclass, :concerns
+
+    def initialize(test_class_name:, superclass:, concerns:)
+      @test_class_name = test_class_name
+      @superclass = superclass
+      @concerns = concerns
+    end
+
+    def render
+      concerns.map do |concern|
+        indent(test_code_for(concern), 2)
+      end.join("\n\n")
+    end
+
+    def render_test_file
+      [
+        'require "test_helper"',
+        "",
+        "class #{test_class_name} < #{superclass}",
+        render,
+        "end",
+        ""
+      ].join("\n")
+    end
+
+    private
+
+    def test_code_for(concern)
+      code = concern[:test_code] || concern["test_code"]
+
+      unless code.is_a?(String) && code.strip.present?
+        raise InvalidConcern,
+          "AI test concern must include test_code"
+      end
+
+      code.strip
+    end
+
+    def indent(source, spaces)
+      prefix = " " * spaces
+
+      source.lines.map do |line|
+        line.strip.empty? ? line : "#{prefix}#{line}"
+      end.join
+    end
+  end
+end

data/lib/rails_proof/controller_inspector.rb

@@ -0,0 +1,44 @@
+module RailsProof
+  class ControllerInspector
+    attr_reader :controller_class, :route_set
+
+    def initialize(controller_class, route_set: Rails.application.routes)
+      @controller_class = controller_class
+      @route_set = route_set
+    end
+
+    def controller_name
+      controller_class.name
+    end
+
+    def controller_path
+      controller_class.controller_path
+    end
+
+    def actions
+      @actions ||= controller_class.action_methods.sort
+    end
+
+    def routes
+      @routes ||= route_set.routes.filter_map do |route|
+        defaults = route.defaults
+
+        next unless defaults[:controller] == controller_path
+        next unless actions.include?(defaults[:action])
+
+        {
+          name: route.name,
+          verb: route.verb.to_s,
+          path: normalize_path(route.path.spec.to_s),
+          action: defaults[:action]
+        }
+      end
+    end
+
+    private
+
+    def normalize_path(path)
+      path.delete_suffix("(.:format)")
+    end
+  end
+end

data/lib/rails_proof/controller_test_coverage_plan.rb

@@ -0,0 +1,79 @@
+module RailsProof
+  class ControllerTestCoveragePlan
+    attr_reader :controller_test_plan, :test_inspector
+
+    def initialize(controller_test_plan, test_inspector)
+      @controller_test_plan = controller_test_plan
+      @test_inspector = test_inspector
+    end
+
+    def covered_concerns
+      @covered_concerns ||= controller_test_plan.concerns.select do |concern|
+        covered?(concern)
+      end
+    end
+
+    def missing_concerns
+      @missing_concerns ||= controller_test_plan.concerns.reject do |concern|
+        covered?(concern)
+      end
+    end
+
+    def covered_count
+      covered_concerns.count
+    end
+
+    def missing_count
+      missing_concerns.count
+    end
+
+    private
+
+    def covered?(concern)
+      test_names.any? do |test_name|
+        matches_concern?(test_name, concern)
+      end
+    end
+
+    def test_names
+      @test_names ||= test_inspector.test_cases.map do |test_case|
+        normalize(test_case[:name])
+      end
+    end
+
+    def matches_concern?(test_name, concern)
+      return false unless concern[:type] == :controller_response
+
+      action = normalize(concern[:action])
+
+      test_name.include?(action) &&
+        response_language?(test_name)
+    end
+
+    def response_language?(test_name)
+      [
+        "get",
+        "post",
+        "patch",
+        "put",
+        "delete",
+        "response",
+        "respond",
+        "success",
+        "successful"
+      ].any? do |word|
+        test_name.split.include?(word)
+      end
+    end
+
+    def normalize(value)
+      value
+        .to_s
+        .downcase
+        .tr("_", " ")
+        .gsub(/[^a-z0-9\s]/, " ")
+        .split
+        .join(" ")
+    end
+  end
+end

data/lib/rails_proof/controller_test_plan.rb

@@ -0,0 +1,28 @@
+module RailsProof
+  class ControllerTestPlan
+    attr_reader :inspector
+
+    def initialize(inspector)
+      @inspector = inspector
+    end
+
+    def concerns
+      @concerns ||= inspector.routes.filter_map do |route|
+        next if route[:name].to_s.empty?
+
+        {
+          type: :controller_response,
+          verb: route[:verb],
+          path: route[:path],
+          route_name: route[:name],
+          action: route[:action],
+          description: "#{route[:verb]} #{route[:path]} responds successfully"
+        }
+      end
+    end
+
+    def count
+      concerns.count
+    end
+  end
+end

data/lib/rails_proof/controller_test_writer.rb

@@ -0,0 +1,66 @@
+module RailsProof
+  class ControllerTestWriter
+    attr_reader :controller_class_name, :concerns
+
+    def initialize(controller_class_name:, concerns:)
+      @controller_class_name = controller_class_name
+      @concerns = concerns
+    end
+
+    def render
+      concerns.map do |concern|
+        indent(render_concern(concern), 2)
+      end.join("\n\n")
+    end
+
+    def render_test_file
+      [
+        'require "test_helper"',
+        "",
+        "class #{controller_class_name}Test < ActionDispatch::IntegrationTest",
+        render,
+        "end",
+        ""
+      ].join("\n")
+    end
+
+    private
+
+    def render_concern(concern)
+      case concern[:type]
+      when :controller_response
+        render_response_test(concern)
+      else
+        raise ArgumentError,
+          "Unsupported controller test concern: #{concern.inspect}"
+      end
+    end
+
+    def render_response_test(concern)
+      verb = concern.fetch(:verb).downcase
+      route_name = concern.fetch(:route_name)
+      action = concern.fetch(:action)
+
+      unless route_name
+        raise ArgumentError,
+          "Cannot generate controller test without a named route: #{concern.inspect}"
+      end
+
+      <<~RUBY.chomp
+        test "should #{verb} #{action}" do
+          #{verb} #{route_name}_url
+
+          assert_response :success
+        end
+      RUBY
+    end
+
+    def indent(source, spaces)
+      prefix = " " * spaces
+
+      source.lines.map do |line|
+        line.strip.empty? ? line : "#{prefix}#{line}"
+      end.join
+    end
+  end
+end

data/lib/rails_proof/model_inspector.rb

@@ -0,0 +1,50 @@
+module RailsProof
+  class ModelInspector
+    attr_reader :model_class
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    def model_name
+      model_class.name
+    end
+
+    def table_name
+      model_class.table_name
+    end
+
+    def columns
+      @columns ||= model_class.columns.map do |column|
+        {
+          name: column.name,
+          type: column.type,
+          null: column.null,
+          default: column.default
+        }
+      end
+    end
+
+    def associations
+      @associations ||= model_class.reflect_on_all_associations.map do |association|
+        {
+          macro: association.macro,
+          name: association.name,
+          class_name: association.class_name,
+          foreign_key: association.foreign_key,
+          options: association.options
+        }
+      end
+    end
+
+    def validators
+      @validators ||= model_class.validators.map do |validator|
+        {
+          class_name: validator.class.name,
+          attributes: validator.attributes,
+          options: validator.options
+        }
+      end
+    end
+  end
+end

data/lib/rails_proof/model_test_plan.rb

@@ -0,0 +1,61 @@
+module RailsProof
+  class ModelTestPlan
+    attr_reader :inspector
+
+    def initialize(inspector)
+      @inspector = inspector
+    end
+
+    def concerns
+      @concerns ||= association_concerns + validation_concerns
+    end
+
+    def count
+      concerns.count
+    end
+
+    private
+
+    def association_concerns
+      inspector.associations.map do |association|
+        {
+          type: :association,
+          macro: association[:macro],
+          name: association[:name],
+          description: "#{association[:macro]} :#{association[:name]}"
+        }
+      end
+    end
+
+    def validation_concerns
+      inspector.validators.flat_map do |validator|
+        next [] unless presence_validator?(validator)
+
+        validator[:attributes].filter_map do |attribute|
+          next if implicit_belongs_to_presence?(attribute)
+
+          {
+            type: :validation,
+            validation: :presence,
+            attribute: attribute,
+            description: "validates presence of #{attribute}"
+          }
+        end
+      end
+    end
+
+    def presence_validator?(validator)
+      validator[:class_name].end_with?("PresenceValidator")
+    end
+
+    def implicit_belongs_to_presence?(attribute)
+      belongs_to_association_names.include?(attribute)
+    end
+
+    def belongs_to_association_names
+      @belongs_to_association_names ||= inspector.associations.filter_map do |association|
+        association[:name] if association[:macro] == :belongs_to
+      end
+    end
+  end
+end

data/lib/rails_proof/open_ai_client.rb

@@ -0,0 +1,189 @@
+require "json"
+
+module RailsProof
+  class OpenAiClient
+    class Error < StandardError; end
+
+    DEFAULT_MODEL = "gpt-5.6"
+
+    RESPONSE_SCHEMA = {
+      type: :object,
+      properties: {
+        suggestions: {
+          type: :array,
+          items: {
+            type: :object,
+            properties: {
+              kind: {
+                type: :string,
+                enum: %w[coverage contract_check]
+              },
+              name: { type: :string },
+              reason: { type: :string },
+              test_code: { type: :string }
+            },
+            required: %w[kind name reason test_code],
+            additionalProperties: false
+          }
+        }
+      },
+      required: %w[suggestions],
+      additionalProperties: false
+    }.freeze
+
+    attr_reader :model
+
+    def initialize(
+      model: ENV.fetch("RAILSPROOF_OPENAI_MODEL", DEFAULT_MODEL),
+      sdk_client: nil
+    )
+      @model = model
+      @sdk_client = sdk_client
+    end
+
+    def suggest_tests(context:)
+      response = client.responses.create(
+        model: model,
+        input: [
+          {
+            role: :system,
+            content: system_prompt
+          },
+          {
+            role: :user,
+            content: JSON.generate(context)
+          }
+        ],
+        text: {
+          format: {
+            type: :json_schema,
+            name: "rails_proof_test_suggestions",
+            strict: true,
+            schema: RESPONSE_SCHEMA
+          }
+        }
+      )
+
+      parse_suggestions(response.output_text)
+    rescue Error
+      raise
+    rescue StandardError => error
+      raise Error, "OpenAI request failed: #{error.message}"
+    end
+
+    private
+
+    def client
+      @sdk_client ||= begin
+        require "openai"
+
+        OpenAI::Client.new
+      rescue LoadError
+        raise Error,
+          "OpenAI client is not installed. Add the openai gem to use AI planning."
+      end
+    end
+
+    def system_prompt
+      <<~PROMPT
+        You are RailsProof's AI test planner and Minitest test generator.
+
+        Analyze Rails 8.1+ application code for meaningful Minitest coverage
+        that deterministic Rails inspection cannot already identify.
+
+        RailsProof has two kinds of AI-generated tests:
+
+        1. coverage
+           The implementation and apparent public contract agree. Generate a
+           test that verifies meaningful behavior implemented by the source.
+
+        2. contract_check
+           Strong evidence in the supplied source suggests that the apparent
+           public contract may disagree with the implementation. Generate a
+           test for the apparent intended contract, even when the current
+           implementation is likely to make that test fail.
+
+        Do not assume that the current implementation is correct merely
+        because it is the code that was supplied.
+
+        Look for strong local evidence of an implementation/contract mismatch,
+        including:
+        - method names whose semantics conflict with the implementation
+        - comments or surrounding code that contradict the implementation
+        - predicates whose implementation appears opposite to their name
+        - exact/equality semantics implemented as partial matching, or the
+          reverse
+        - state-changing method names whose implementation changes the wrong
+          state
+        - error-signaling method names whose implementation silently ignores
+          the error condition
+        - branches whose outcomes appear reversed relative to the public API
+
+        A contract_check must be supported by strong evidence in the supplied
+        source. Do not invent product requirements or speculate about behavior
+        when the intended contract is genuinely ambiguous.
+
+        If you identify behavior as a possible contract mismatch, do NOT also
+        generate a coverage test whose purpose is merely to lock that
+        suspicious implementation into the test suite.
+
+        Suggest only additional tests justified by the supplied source and
+        runtime context.
+
+        Do not duplicate deterministic concerns RailsProof already identified.
+
+        Do not suggest behavior that is already adequately covered by the
+        supplied existing tests.
+
+        Focus especially on:
+        - branches and conditional behavior
+        - custom public methods
+        - edge cases
+        - nil and blank handling
+        - state transitions
+        - persistence behavior
+        - side effects
+        - error conditions
+        - interactions between application objects
+        - possible implementation/contract disagreements
+
+        For every suggestion, generate the actual Minitest code needed to
+        exercise that behavior.
+
+        Each suggestion must have:
+        - kind: either "coverage" or "contract_check"
+        - name: a concise Minitest-style test description
+        - reason: why that behavior deserves a test
+        - test_code: exactly one complete Minitest test block
+
+        For a contract_check, the reason must explicitly describe:
+        - the evidence for the apparent contract
+        - how the implementation appears to disagree with that contract
+
+        test_code must:
+        - begin with a Minitest test declaration
+        - contain exactly one test block
+        - be valid Ruby
+        - contain no class declaration
+        - contain no require statement
+        - contain no Markdown code fences
+        - use only application behavior supported by the supplied context
+        - avoid assuming fixtures, factories, helpers, or methods not shown
+          in the supplied context
+      PROMPT
+    end
+
+    def parse_suggestions(output_text)
+      parsed = JSON.parse(output_text)
+      suggestions = parsed.fetch("suggestions")
+
+      unless suggestions.is_a?(Array)
+        raise Error, "OpenAI response suggestions must be an array"
+      end
+
+      suggestions
+    rescue JSON::ParserError, KeyError => error
+      raise Error, "Invalid OpenAI response: #{error.message}"
+    end
+  end
+end

data/lib/rails_proof/railtie.rb

@@ -0,0 +1,4 @@
+module RailsProof
+  class Railtie < ::Rails::Railtie
+  end
+end