zenspec 0.1.0

data/lib/zenspec/matchers/interactor_matchers.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "rspec/expectations"
+
+module Zenspec
+  module Matchers
+    module InteractorMatchers
+      # Matcher for checking if an interactor succeeds
+      #
+      # @example
+      #   expect(result).to succeed
+      #   expect(result).to succeed.with_data(expected_value)
+      #   expect(result).to succeed.with_context(:key, value)
+      #   expect(MyInteractor).to succeed.with_context(:user, user)
+      #
+      RSpec::Matchers.define :succeed do
+        match do |actual|
+          @result = get_result(actual)
+          return false if @result.failure?
+
+          return false if @expected_data && @result.data != @expected_data
+
+          if @context_checks
+            @context_checks.all? do |key, value|
+              @result.public_send(key) == value
+            end
+          else
+            true
+          end
+        end
+
+        chain :with_data do |expected_data|
+          @expected_data = expected_data
+        end
+
+        chain :with_context do |key, value|
+          @context_checks ||= {}
+          @context_checks[key] = value
+        end
+
+        failure_message do
+          if @result.failure?
+            "expected interactor to succeed, but it failed with errors: #{@result.errors}"
+          elsif @expected_data && @result.data != @expected_data
+            "expected data to be #{@expected_data.inspect}, got #{@result.data.inspect}"
+          elsif @context_checks
+            failed_checks = @context_checks.reject { |key, value| @result.public_send(key) == value }
+            "expected context to match #{@context_checks.inspect}, but #{failed_checks.inspect} did not match"
+          end
+        end
+
+        private
+
+        def get_result(actual)
+          if actual.is_a?(Class) && actual.ancestors.include?(Interactor)
+            actual.call
+          else
+            actual
+          end
+        end
+      end
+
+      # Matcher for checking if an interactor fails
+      #
+      # @example
+      #   expect(result).to fail_interactor
+      #   expect(result).to fail_interactor.with_error("invalid_input")
+      #   expect(result).to fail_interactor.with_errors("error1", "error2")
+      #   expect(MyInteractor).to fail_interactor.with_error("not_found")
+      #
+      RSpec::Matchers.define :fail_interactor do
+        match do |actual|
+          @result = get_result(actual)
+          return false if @result.success?
+
+          if @expected_error_codes && !@expected_error_codes.empty?
+            actual_codes = error_codes(@result)
+            @expected_error_codes.all? { |code| actual_codes.include?(code) }
+          else
+            true
+          end
+        end
+
+        chain :with_error do |error_code|
+          @expected_error_codes ||= []
+          @expected_error_codes << error_code
+        end
+
+        chain :with_errors do |*error_codes|
+          @expected_error_codes ||= []
+          @expected_error_codes.concat(error_codes)
+        end
+
+        failure_message do
+          if @result.success?
+            "expected interactor to fail, but it succeeded"
+          else
+            actual_codes = error_codes(@result)
+            "expected errors to include #{@expected_error_codes.inspect}, got #{actual_codes.inspect}"
+          end
+        end
+
+        def get_result(actual)
+          if actual.is_a?(Class) && actual.ancestors.include?(Interactor)
+            actual.call
+          else
+            actual
+          end
+        end
+
+        def error_codes(result)
+          return [] unless result.errors
+
+          if result.errors.is_a?(Array)
+            result.errors.map { |e| e.is_a?(Hash) ? e[:code] : e.to_s }.compact
+          else
+            []
+          end
+        end
+      end
+
+      # Matcher for checking if a result has a specific error code
+      #
+      # @example
+      #   expect(result).to have_error_code("invalid_input")
+      #
+      RSpec::Matchers.define :have_error_code do |expected_code|
+        match do |result|
+          error_codes(result).include?(expected_code)
+        end
+
+        failure_message do |result|
+          "expected errors to include #{expected_code.inspect}, got #{error_codes(result).inspect}"
+        end
+
+        def error_codes(result)
+          return [] unless result.errors
+
+          if result.errors.is_a?(Array)
+            result.errors.map { |e| e.is_a?(Hash) ? e[:code] : e.to_s }.compact
+          else
+            []
+          end
+        end
+      end
+
+      # Matcher for checking if a result has multiple error codes
+      #
+      # @example
+      #   expect(result).to have_error_codes("error1", "error2")
+      #
+      RSpec::Matchers.define :have_error_codes do |*expected_codes|
+        match do |result|
+          actual_codes = error_codes(result)
+          expected_codes.all? { |code| actual_codes.include?(code) }
+        end
+
+        failure_message do |result|
+          "expected errors to include #{expected_codes.inspect}, got #{error_codes(result).inspect}"
+        end
+
+        def error_codes(result)
+          return [] unless result.errors
+
+          if result.errors.is_a?(Array)
+            result.errors.map { |e| e.is_a?(Hash) ? e[:code] : e.to_s }.compact
+          else
+            []
+          end
+        end
+      end
+
+      # Matcher for checking if context has a specific key/value
+      #
+      # @example
+      #   expect(result).to set_context(:data)
+      #   expect(result).to set_context(:data, expected_value)
+      #   expect(result).to set_context(:user).to(user)
+      #
+      RSpec::Matchers.define :set_context do |key, value = nil|
+        match do |result|
+          return false unless result.respond_to?(key)
+
+          actual_value = result.public_send(key)
+
+          if @expected_value
+            actual_value == @expected_value
+          elsif !value.nil?
+            actual_value == value
+          else
+            !actual_value.nil?
+          end
+        end
+
+        chain :to do |expected_value|
+          @expected_value = expected_value
+        end
+
+        failure_message do |result|
+          if !result.respond_to?(key)
+            "expected context to have key #{key.inspect}"
+          elsif @expected_value || !value.nil?
+            expected = @expected_value || value
+            "expected context[#{key.inspect}] to be #{expected.inspect}, got #{result.public_send(key).inspect}"
+          else
+            "expected context[#{key.inspect}] to be set"
+          end
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Zenspec::Matchers::InteractorMatchers
+end

data/lib/zenspec/matchers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "matchers/interactor_matchers"
+require_relative "matchers/graphql_matchers"
+require_relative "matchers/graphql_type_matchers"
+
+module Zenspec
+  module Matchers
+    # This module serves as a namespace for all Zenspec matchers
+    # Individual matcher modules are loaded from their respective files
+  end
+end

data/lib/zenspec/progress_loader.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Zenspec
+  # Docker-style progress loader for displaying progress in terminal
+  # Displays progress bars similar to Docker's layer download progress
+  #
+  # @example Basic usage
+  #   loader = Zenspec::ProgressLoader.new(total: 10, description: "Running tests")
+  #   10.times do |i|
+  #     loader.update(i + 1)
+  #     sleep(0.1)
+  #   end
+  #   loader.finish
+  #
+  # @example With custom width
+  #   loader = Zenspec::ProgressLoader.new(total: 100, width: 50)
+  #   loader.update(50, description: "Processing files 50/100")
+  #
+  class ProgressLoader
+    attr_reader :current, :total, :width
+
+    # Default width for the progress bar
+    DEFAULT_WIDTH = 40
+
+    # @param total [Integer] Total number of items to process
+    # @param width [Integer] Width of the progress bar in characters
+    # @param description [String] Initial description text
+    # @param output [IO] Output stream (defaults to STDERR)
+    def initialize(total:, width: DEFAULT_WIDTH, description: nil, output: $stderr)
+      @total = total
+      @width = width
+      @current = 0
+      @description = description
+      @output = output
+      @finished = false
+      @start_time = Time.now
+    end
+
+    # Update the progress
+    # @param current [Integer] Current progress value
+    # @param description [String, nil] Optional description to display
+    def update(current, description: nil)
+      @current = current
+      @description = description if description
+      render unless @finished
+    end
+
+    # Increment progress by one
+    # @param description [String, nil] Optional description to display
+    def increment(description: nil)
+      update(@current + 1, description: description)
+    end
+
+    # Mark the progress as finished
+    # @param description [String, nil] Final description to display
+    def finish(description: nil)
+      @current = @total
+      @description = description if description
+      @finished = true
+      render
+      @output.puts # New line after completion
+    end
+
+    # Calculate current percentage
+    # @return [Integer] Percentage (0-100)
+    def percentage
+      return 100 if @total.zero?
+
+      ((@current.to_f / @total) * 100).round
+    end
+
+    # Calculate elapsed time
+    # @return [Float] Elapsed time in seconds
+    def elapsed_time
+      Time.now - @start_time
+    end
+
+    # Calculate estimated time remaining
+    # @return [Float, nil] Estimated time remaining in seconds, or nil if cannot estimate
+    def estimated_time_remaining
+      return nil if @current.zero?
+
+      elapsed = elapsed_time
+      rate = @current.to_f / elapsed
+      remaining_items = @total - @current
+      remaining_items / rate
+    end
+
+    # Format time duration
+    # @param seconds [Float] Time in seconds
+    # @return [String] Formatted time string
+    def format_time(seconds)
+      return "0s" if seconds.nil? || seconds.zero?
+
+      if seconds < 60
+        "#{seconds.round}s"
+      elsif seconds < 3600
+        minutes = (seconds / 60).round
+        "#{minutes}m"
+      else
+        hours = (seconds / 3600).round
+        "#{hours}h"
+      end
+    end
+
+    private
+
+    # Render the progress bar
+    def render
+      bar = build_progress_bar
+      counter = "#{@current}/#{@total}"
+      percent = "#{percentage}%"
+      time_info = build_time_info
+
+      # Build the complete line
+      parts = [bar, percent, counter]
+      parts << @description if @description
+      parts << time_info if time_info && !@finished
+
+      line = parts.join(" ")
+
+      # Clear the line and print
+      @output.print "\r\e[K#{line}"
+      @output.flush
+    end
+
+    # Build the progress bar string
+    # @return [String] Progress bar visualization
+    def build_progress_bar
+      return "[#{' ' * @width}]" if @total.zero?
+
+      filled_width = ((@current.to_f / @total) * @width).round
+      empty_width = @width - filled_width
+
+      filled = "=" * [filled_width - 1, 0].max
+      arrow = filled_width.positive? ? ">" : ""
+      empty = " " * empty_width
+
+      "[#{filled}#{arrow}#{empty}]"
+    end
+
+    # Build time information string
+    # @return [String, nil] Time information or nil
+    def build_time_info
+      elapsed = elapsed_time
+      remaining = estimated_time_remaining
+
+      if remaining && remaining.positive?
+        "#{format_time(elapsed)}/#{format_time(remaining + elapsed)}"
+      elsif elapsed > 1 # Only show elapsed if more than 1 second
+        format_time(elapsed)
+      end
+    end
+  end
+end

data/lib/zenspec/railtie.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Zenspec
+  class Railtie < Rails::Railtie
+    railtie_name :zenspec
+
+    rake_tasks do
+      # Add rake tasks if needed in the future
+    end
+
+    initializer "zenspec.configure_rspec" do
+      # Automatically configure zenspec matchers and helpers when Rails loads
+      if defined?(RSpec)
+        RSpec.configure do |config|
+          # Include matchers
+          config.include Zenspec::Matchers::InteractorMatchers
+          config.include Zenspec::Matchers::GraphQLMatchers
+          config.include Zenspec::Matchers::GraphQLTypeMatchers
+
+          # Include helpers
+          config.include Zenspec::Helpers::GraphQLHelpers
+        end
+      end
+    end
+  end
+end

data/lib/zenspec/shoulda_config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Configure Shoulda Matchers if available
+begin
+  require "shoulda/matchers"
+
+  Shoulda::Matchers.configure do |config|
+    config.integrate do |with|
+      with.test_framework :rspec
+      with.library :active_record if defined?(ActiveRecord)
+      with.library :active_model if defined?(ActiveModel)
+      with.library :action_controller if defined?(ActionController)
+    end
+  end
+rescue LoadError
+  # Shoulda matchers not available, skip configuration
+end

data/lib/zenspec/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zenspec
+  VERSION = "0.1.0"
+end

data/lib/zenspec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "zenspec/version"
+require_relative "zenspec/matchers"
+require_relative "zenspec/helpers"
+require_relative "zenspec/shoulda_config"
+require_relative "zenspec/progress_loader"
+
+# Load Railtie if Rails is available
+require_relative "zenspec/railtie" if defined?(Rails::Railtie)
+
+module Zenspec
+  class Error < StandardError; end
+end

data/sig/zenspec.rbs

@@ -0,0 +1,4 @@
+module Zenspec
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: zenspec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wilson Anciro
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: interactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: A collection of RSpec matchers for testing GraphQL queries and Interactor
+  service objects.
+email:
+- konekred@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/progress_loader_demo.rb
+- lib/zenspec.rb
+- lib/zenspec/formatters/progress_bar_formatter.rb
+- lib/zenspec/formatters/progress_formatter.rb
+- lib/zenspec/helpers.rb
+- lib/zenspec/helpers/graphql_helpers.rb
+- lib/zenspec/matchers.rb
+- lib/zenspec/matchers/graphql_matchers.rb
+- lib/zenspec/matchers/graphql_type_matchers.rb
+- lib/zenspec/matchers/interactor_matchers.rb
+- lib/zenspec/progress_loader.rb
+- lib/zenspec/railtie.rb
+- lib/zenspec/shoulda_config.rb
+- lib/zenspec/version.rb
+- sig/zenspec.rbs
+homepage: https://github.com/zyxzen/zenspec
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zyxzen/zenspec
+  source_code_uri: https://github.com/zyxzen/zenspec
+  changelog_uri: https://github.com/zyxzen/zenspec/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RSpec matchers for GraphQL, Interactor, and other common testing patterns
+test_files: []