tasker-engine 1.0.0

data/lib/generators/tasker/templates/jwt_authenticator_spec.rb.erb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= class_name %>Authenticator, type: :model do
+  let(:secret) { 'test-secret-key-32-characters-minimum!' }
+  let(:algorithm) { 'HS256' }
+  let(:user_class) { '<%= user_model_class %>' }
+
+  let(:options) do
+    {
+      secret: secret,
+      algorithm: algorithm,
+      header_name: 'Authorization',
+      user_class: user_class
+    }
+  end
+
+  let(:authenticator) { described_class.new(options) }
+  let(:controller) { instance_double('ActionController::Base') }
+  let(:request) { instance_double('ActionDispatch::Request') }
+  let(:headers) { {} }
+
+  before do
+    allow(controller).to receive(:request).and_return(request)
+    allow(request).to receive(:headers).and_return(headers)
+  end
+
+  describe '#initialize' do
+    it 'sets configuration options' do
+      expect(authenticator.send(:secret)).to eq(secret)
+      expect(authenticator.send(:algorithm)).to eq(algorithm)
+      expect(authenticator.send(:header_name)).to eq('Authorization')
+      expect(authenticator.send(:user_class)).to eq(user_class)
+    end
+
+    it 'uses default values when options are not provided' do
+      authenticator = described_class.new
+      expect(authenticator.send(:algorithm)).to eq('HS256')
+      expect(authenticator.send(:header_name)).to eq('Authorization')
+      expect(authenticator.send(:user_class)).to eq('<%= user_model_class %>')
+    end
+  end
+
+  describe '#authenticate!' do
+    context 'when user is authenticated' do
+      let(:user) { double('User', id: 1) }
+
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(user)
+      end
+
+      it 'returns true' do
+        expect(authenticator.authenticate!(controller)).to be true
+      end
+    end
+
+    context 'when user is not authenticated' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(nil)
+      end
+
+      it 'raises AuthenticationError' do
+        expect do
+          authenticator.authenticate!(controller)
+        end.to raise_error(Tasker::Authentication::AuthenticationError, 'Invalid or missing JWT token')
+      end
+    end
+  end
+
+  describe '#current_user' do
+    let(:user_id) { 1 }
+    let(:user) { double('User', id: user_id) }
+    let(:payload) { { 'user_id' => user_id, 'iat' => Time.current.to_i, 'exp' => 1.hour.from_now.to_i } }
+    let(:token) { JWT.encode(payload, secret, algorithm) }
+
+    before do
+      # Mock the user model
+      user_model = double('UserModel')
+      allow(user_class).to receive(:constantize).and_return(user_model)
+      allow(user_model).to receive(:find_by).with(id: user_id).and_return(user)
+    end
+
+    context 'with valid Bearer token' do
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+      end
+
+      it 'returns the authenticated user' do
+        expect(authenticator.current_user(controller)).to eq(user)
+      end
+
+      it 'memoizes the result' do
+        expect(authenticator.current_user(controller)).to eq(user)
+        expect(authenticator.current_user(controller)).to eq(user) # Should not decode again
+      end
+    end
+
+    context 'with valid raw token' do
+      before do
+        headers['Authorization'] = token
+      end
+
+      it 'returns the authenticated user' do
+        expect(authenticator.current_user(controller)).to eq(user)
+      end
+    end
+
+    context 'with token using sub claim' do
+      let(:payload) { { 'sub' => user_id, 'iat' => Time.current.to_i, 'exp' => 1.hour.from_now.to_i } }
+
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+      end
+
+      it 'returns the authenticated user' do
+        expect(authenticator.current_user(controller)).to eq(user)
+      end
+    end
+
+    context 'with missing Authorization header' do
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'with empty Authorization header' do
+      before do
+        headers['Authorization'] = ''
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'with expired token' do
+      let(:payload) { { 'user_id' => user_id, 'iat' => 2.hours.ago.to_i, 'exp' => 1.hour.ago.to_i } }
+
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'with invalid signature' do
+      let(:wrong_secret) { 'wrong-secret-key' }
+      let(:token) { JWT.encode(payload, wrong_secret, algorithm) }
+
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'with malformed token' do
+      before do
+        headers['Authorization'] = 'Bearer invalid.token.format'
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'when user is not found' do
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+        user_model = double('UserModel')
+        allow(user_class).to receive(:constantize).and_return(user_model)
+        allow(user_model).to receive(:find_by).with(id: user_id).and_return(nil)
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'when user model raises an error' do
+      before do
+        headers['Authorization'] = "Bearer #{token}"
+        allow(user_class).to receive(:constantize).and_raise(NameError, 'User class not found')
+      end
+
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+  end
+
+  describe '#authenticated?' do
+    context 'when current_user returns a user' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(double('User'))
+      end
+
+      it 'returns true' do
+        expect(authenticator.authenticated?(controller)).to be true
+      end
+    end
+
+    context 'when current_user returns nil' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(nil)
+      end
+
+      it 'returns false' do
+        expect(authenticator.authenticated?(controller)).to be false
+      end
+    end
+  end
+
+  describe '#validate_configuration' do
+    context 'with valid configuration' do
+      it 'returns no errors' do
+        errors = authenticator.validate_configuration(options)
+        expect(errors).to be_empty
+      end
+    end
+
+    context 'with missing secret' do
+      let(:invalid_options) { options.merge(secret: nil) }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include('JWT secret is required')
+      end
+    end
+
+    context 'with short secret' do
+      let(:invalid_options) { options.merge(secret: 'short') }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include('JWT secret should be at least 32 characters for security')
+      end
+    end
+
+    context 'with invalid algorithm' do
+      let(:invalid_options) { options.merge(algorithm: 'INVALID') }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include(/JWT algorithm must be one of/)
+      end
+    end
+
+    context 'with invalid user class' do
+      let(:invalid_options) { options.merge(user_class: 'NonExistentUser') }
+
+      it 'returns validation error' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include(/not found/)
+      end
+    end
+  end
+
+  describe '.generate_test_token' do
+    let(:payload) { { user_id: 1, name: 'Test User' } }
+
+    it 'generates a valid JWT token' do
+      token = described_class.generate_test_token(payload, secret: secret)
+
+      decoded_payload = JWT.decode(token, secret, true, { algorithm: 'HS256' }).first
+      expect(decoded_payload['user_id']).to eq(1)
+      expect(decoded_payload['name']).to eq('Test User')
+      expect(decoded_payload['iat']).to be_present
+      expect(decoded_payload['exp']).to be_present
+    end
+
+    it 'sets expiration to 1 hour from now' do
+      token = described_class.generate_test_token(payload, secret: secret)
+
+      decoded_payload = JWT.decode(token, secret, true, { algorithm: 'HS256' }).first
+      expected_exp = Time.current.to_i + 1.hour.to_i
+      expect(decoded_payload['exp']).to be_within(5).of(expected_exp)
+    end
+  end
+
+  describe 'interface compliance' do
+    it 'includes the authentication interface' do
+      expect(described_class.included_modules).to include(Tasker::Authentication::Interface)
+    end
+
+    it 'responds to required interface methods' do
+      expect(authenticator).to respond_to(:authenticate!)
+      expect(authenticator).to respond_to(:current_user)
+      expect(authenticator).to respond_to(:authenticated?)
+      expect(authenticator).to respond_to(:validate_configuration)
+    end
+  end
+end

data/lib/generators/tasker/templates/metrics_subscriber.rb.erb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+# <%= class_name %>Subscriber - Specialized Metrics Collection
+#
+# This subscriber collects metrics from Tasker workflow events for operational monitoring.
+# It follows OpenTelemetry best practices by focusing on aggregated metrics for dashboards
+# and alerting, while leaving detailed tracing to TelemetrySubscriber.
+#
+<% if subscribed_events.any? -%>
+# Monitoring these events:
+<% subscribed_events.each do |event| -%>
+#   - <%= event %>
+<% end -%>
+<% end -%>
+#
+# Architecture:
+#   - TelemetrySubscriber: Creates OpenTelemetry spans for debugging
+#   - <%= class_name %>Subscriber: Records metrics for operational monitoring
+#   - Custom Subscribers: Handle business logic integrations
+#
+# Usage:
+#   <%= class_name %>Subscriber.subscribe(Tasker::Events::Publisher.instance)
+#
+class <%= class_name %>Subscriber < Tasker::Events::Subscribers::BaseSubscriber
+<% if subscribed_events.any? -%>
+  # Subscribe to metrics-relevant events
+  subscribe_to <%= subscribed_events.map { |e| "'#{e}'" }.join(', ') %>
+
+<% handler_methods.each do |method| -%>
+  # Collect metrics from <%= method[:event] %> events
+  #
+  # @param event [Hash] Event payload containing event data
+  # @return [void]
+  def <%= method[:method_signature] %>
+    # Extract standardized metrics using BaseSubscriber helpers
+<% if method[:event].include?('completed') -%>
+    timing = extract_timing_metrics(event)
+    tags = extract_metric_tags(event)
+
+    # Record completion metrics
+    record_completion_metrics(timing, tags)
+<% elsif method[:event].include?('failed') -%>
+    error = extract_error_metrics(event)
+    tags = extract_metric_tags(event)
+
+    # Record error metrics
+    record_error_metrics(error, tags)
+<% else -%>
+    # Extract relevant data for this event type
+    tags = extract_metric_tags(event)
+
+    # TODO: Implement specific metrics for <%= method[:event] %>
+    # record_custom_metrics(event, tags)
+<% end -%>
+
+    # Log for debugging (remove in production)
+    Rails.logger.debug "Recorded metrics for <%= method[:event] %>: #{safe_get(event, :task_id)}"
+  end
+
+<% end -%>
+<% else -%>
+  # TODO: Add event subscriptions for metrics collection
+  # subscribe_to 'task.completed', 'task.failed', 'step.completed', 'step.failed'
+
+  # Example metrics handler:
+  # def handle_task_completed(event)
+  #   timing = extract_timing_metrics(event)
+  #   tags = extract_metric_tags(event)
+  #   record_completion_metrics(timing, tags)
+  # end
+<% end -%>
+  private
+
+  # Record completion metrics for tasks/steps
+  #
+  # @param timing [Hash] Timing metrics from extract_timing_metrics
+  # @param tags [Array<String>] Metric tags for categorization
+  # @return [void]
+  def record_completion_metrics(timing, tags)
+    # Duration histogram for percentile analysis
+    record_histogram('tasker.execution.duration', timing[:execution_duration], tags)
+
+    # Completion counter for rate calculations
+    record_counter('tasker.completed', 1, tags)
+
+    # Step count gauge for workflow complexity tracking
+    if timing[:step_count] > 0
+      record_gauge('tasker.workflow.step_count', timing[:step_count], tags)
+    end
+
+    # Success rate calculation data
+    if timing[:failed_steps] > 0
+      record_gauge('tasker.workflow.failed_steps', timing[:failed_steps], tags)
+      record_gauge('tasker.workflow.success_rate',
+        calculate_success_rate(timing[:completed_steps], timing[:failed_steps]), tags)
+    end
+  end
+
+  # Record error metrics for failed tasks/steps
+  #
+  # @param error [Hash] Error metrics from extract_error_metrics
+  # @param tags [Array<String>] Metric tags for categorization
+  # @return [void]
+  def record_error_metrics(error, tags)
+    # Error counter with type categorization
+    error_tags = tags + ["error_type:#{error[:error_type]}"]
+    record_counter('tasker.errors', 1, error_tags)
+
+    # Retry tracking
+    if error[:attempt_number] > 1
+      record_counter('tasker.retries', 1, tags + ["attempt:#{error[:attempt_number]}"])
+    end
+
+    # Final failure tracking (when retries exhausted)
+    if error[:final_failure]
+      record_counter('tasker.final_failures', 1, error_tags)
+    end
+
+    # Retryable vs non-retryable error breakdown
+    retryable_tag = error[:is_retryable] ? 'retryable' : 'non_retryable'
+    record_counter('tasker.error_types', 1, tags + ["retryable:#{retryable_tag}"])
+  end
+
+  # Calculate success rate percentage
+  #
+  # @param completed [Integer] Number of completed steps
+  # @param failed [Integer] Number of failed steps
+  # @return [Float] Success rate as percentage (0.0-100.0)
+  def calculate_success_rate(completed, failed)
+    total = completed + failed
+    return 100.0 if total == 0
+
+    (completed.to_f / total.to_f) * 100.0
+  end
+
+  # ===============================
+  # METRICS BACKEND INTEGRATION
+  # ===============================
+  # Customize these methods for your metrics system
+
+  # Record a histogram/timing metric
+  #
+  # @param name [String] Metric name
+  # @param value [Numeric] Metric value
+  # @param tags [Array<String>] Metric tags
+  # @return [void]
+  def record_histogram(name, value, tags = [])
+    # TODO: Replace with your metrics system
+    # Examples:
+
+    # StatsD/DataDog:
+    # StatsD.histogram(name, value, tags: tags)
+
+    # Prometheus (via prometheus-client gem):
+    # histogram = Prometheus::Client.registry.get(name.tr('.', '_').to_sym)
+    # histogram.observe(value, labels: tags_to_labels(tags))
+
+    # Custom HTTP metrics endpoint:
+    # MetricsClient.post('/metrics', { name: name, value: value, tags: tags, type: 'histogram' })
+
+    # For now, log the metric (replace this in production)
+    Rails.logger.info "METRIC[histogram] #{name}: #{value} #{tags.join(',')}"
+  end
+
+  # Record a counter metric
+  #
+  # @param name [String] Metric name
+  # @param value [Numeric] Increment value (usually 1)
+  # @param tags [Array<String>] Metric tags
+  # @return [void]
+  def record_counter(name, value, tags = [])
+    # TODO: Replace with your metrics system
+    # Examples:
+
+    # StatsD/DataDog:
+    # StatsD.increment(name, value, tags: tags)
+
+    # Prometheus:
+    # counter = Prometheus::Client.registry.get(name.tr('.', '_').to_sym)
+    # counter.increment(by: value, labels: tags_to_labels(tags))
+
+    # For now, log the metric (replace this in production)
+    Rails.logger.info "METRIC[counter] #{name}: +#{value} #{tags.join(',')}"
+  end
+
+  # Record a gauge metric
+  #
+  # @param name [String] Metric name
+  # @param value [Numeric] Current value
+  # @param tags [Array<String>] Metric tags
+  # @return [void]
+  def record_gauge(name, value, tags = [])
+    # TODO: Replace with your metrics system
+    # Examples:
+
+    # StatsD/DataDog:
+    # StatsD.gauge(name, value, tags: tags)
+
+    # Prometheus:
+    # gauge = Prometheus::Client.registry.get(name.tr('.', '_').to_sym)
+    # gauge.set(value, labels: tags_to_labels(tags))
+
+    # For now, log the metric (replace this in production)
+    Rails.logger.info "METRIC[gauge] #{name}: #{value} #{tags.join(',')}"
+  end
+
+  # Convert tags array to labels hash for Prometheus
+  #
+  # @param tags [Array<String>] Tags in "key:value" format
+  # @return [Hash] Labels hash for Prometheus
+  def tags_to_labels(tags)
+    labels = {}
+    tags.each do |tag|
+      key, value = tag.split(':', 2)
+      labels[key.to_sym] = value if key && value
+    end
+    labels
+  end
+end
+
+# Example integration patterns:
+#
+# 1. StatsD/DataDog Integration:
+#    ```ruby
+#    def record_histogram(name, value, tags = [])
+#      StatsD.histogram(name, value, tags: tags)
+#    end
+#    ```
+#
+# 2. Prometheus Integration:
+#    ```ruby
+#    def record_counter(name, value, tags = [])
+#      counter = Prometheus::Client.registry.get(name.tr('.', '_').to_sym)
+#      counter.increment(by: value, labels: tags_to_labels(tags))
+#    end
+#    ```
+#
+# 3. Custom HTTP Metrics:
+#    ```ruby
+#    def record_metric(type, name, value, tags)
+#      MetricsAPI.post('/metrics', {
+#        type: type,
+#        name: name,
+#        value: value,
+#        tags: tags,
+#        timestamp: Time.current.to_i
+#      })
+#    end
+#    ```
+#
+# 4. Multiple Backends:
+#    ```ruby
+#    def record_histogram(name, value, tags = [])
+#      StatsD.histogram(name, value, tags: tags) if defined?(StatsD)
+#      Prometheus.histogram(name, value, tags) if prometheus_enabled?
+#      CustomMetrics.track(name, value, tags) if custom_metrics_enabled?
+#    end
+#    ```