hephaestus 0.6.3 → 0.7.0

data/lib/hephaestus/middleware/openapi_validation.rb

@@ -0,0 +1,89 @@
+# typed: false
+# frozen_string_literal: true
+
+require "openapi_first"
+
+module Hephaestus
+  module Middleware
+    class OpenapiValidation
+      API_PATH_PREFIX = "/api/"
+      API_SPEC_PATH = Rails.root.join("lib/schemas/api/2023-03-06/openapi.json")
+
+      def initialize(app, ignore_path: "/settings", match_path: API_PATH_PREFIX, limit_methods_to: nil, spec: API_SPEC_PATH)
+        @app = app
+        @ignore_path = ignore_path
+        @match_path = match_path
+        @limit_methods_to = limit_methods_to
+        @spec = OpenapiFirst.load(spec)
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        return @app.call(env) if request.path.include?(@ignore_path)
+        return @app.call(env) unless request.path.starts_with?(@match_path)
+
+        return @app.call(env) if @limit_methods_to.present? && @limit_methods_to.exclude?(request.request_method)
+
+        begin
+          # force content-type to JSON
+          env["CONTENT_TYPE"] = "application/json" if env["CONTENT_TYPE"] != "application/json"
+
+          validated_request = @spec.validate_request(request)
+
+          return @app.call(env) if validated_request.valid?
+
+          case validated_request.error
+          when OpenapiFirst::Schema::ValidationError
+            error_arr = format_arr(validated_request.error.errors.map(&:message))
+            Rails.logger.error(error_arr) if print_user_api_errors?
+            [Hephaestus::HTTP::BAD_REQUEST_I, { "Content-Type" => "application/json" }, [error_arr]]
+          else
+            case validated_request.error.type
+            when :not_found
+              [Hephaestus::HTTP::NOT_FOUND_I, { "Content-Type" => "application/json" }, [format_str("Not Found")]]
+            else
+              error_message = if validated_request.error.errors.present?
+                format_arr(validated_request.error.errors.map(&:message))
+              else
+                format_str(validated_request.error.message)
+              end
+
+              Rails.logger.error(error_message) if print_user_api_errors?
+              [Hephaestus::HTTP::BAD_REQUEST_I, { "Content-Type" => "application/json" }, [error_message]]
+            end
+          end
+        rescue StandardError => e
+          raise e unless Rails.env.production?
+
+          Rails.logger.error(
+            "openapi.request_validation.error",
+            path: request.path,
+            method: request.env["REQUEST_METHOD"],
+            error_message: e.message,
+          )
+        end
+      end
+
+      private def format_str(error)
+        {
+          errors: [
+            {
+              message: error,
+            },
+          ],
+        }.to_json
+      end
+
+      private def format_arr(errors)
+        {
+          errors: errors.each_with_object([]) do |error, arr|
+            arr << {
+              message: error,
+            }
+          end,
+        }.to_json
+      end
+    end
+  end
+end

data/lib/hephaestus/middleware/tracing_attributes.rb

@@ -0,0 +1,50 @@
+# typed: false
+# frozen_string_literal: true
+
+require "opentelemetry"
+require "active_support/parameter_filter"
+
+module Hephaestus
+  module Middleware
+    class TracingAttributes
+      attr_reader :app
+
+      HTTP_REQUEST_CONTENT_LENGTH = "http.request_content_length"
+      HTTP_REQUEST_BODY = "http.request.body"
+
+      def initialize(app)
+        @app = app
+        @filterer = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env.dup)
+
+        OpenTelemetry::Trace.current_span.add_attributes({
+          "version" => Hephaestus::Engine::GIT_SHA,
+          HTTP_REQUEST_CONTENT_LENGTH => env["CONTENT_LENGTH"].to_i,
+          HTTP_REQUEST_BODY => process_tracing_body(request),
+        })
+
+        app.call(env)
+      end
+
+      def process_tracing_body(request)
+        if Rails.configuration.respond_to?(:tracing_body_filters)
+          Rails.configuration.tracing_body_filters.each do |path, filter|
+            next unless request.path.starts_with?(path)
+
+            result = filter.call(request)
+
+            return result if result.is_a?(String)
+
+            return result.to_json
+          end
+        end
+
+        params = request.params
+        @filterer.filter(params).to_json
+      end
+    end
+  end
+end

data/lib/hephaestus/middleware.rb

@@ -0,0 +1,7 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module Middleware
+  end
+end

data/lib/hephaestus/support/hephaestus/api.rb

@@ -0,0 +1,105 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module API
+    module TestHelpers
+      include Rack::Test::Methods
+
+      def plug(method, path, headers: {}, version: Rails.configuration.yetto_api_version, body: {}, parse: true)
+        prepended_path = prepend_plug_path(version, path)
+
+        http_call(method, prepended_path, headers: headers, version: version, body: body, parse: true)
+      end
+
+      def api(method, path, headers: {}, version: Rails.configuration.yetto_api_version, body: {}, parse: true)
+        prepended_path = prepend_api_path(version, path)
+
+        http_call(method, prepended_path, headers: headers, version: version, body: body, parse: true)
+      end
+
+      def http_call(method, path, headers: {}, version: nil, body: {}, parse: true)
+        # explicitly assert headers cannot be nil
+        if headers.nil?
+          send(method, path, body.to_json)
+        else
+          headers["HTTP_ACCEPT"] ||= headers.fetch("HTTP_ACCEPT", "application/json")
+          headers["CONTENT_TYPE"] ||= headers.fetch("CONTENT_TYPE", "application/json")
+          body = body.to_json if headers["CONTENT_TYPE"] == "application/json"
+          send(method, path, body, headers)
+        end
+
+        JSON.parse(last_response.body) if last_response.body.present? && parse
+      end
+
+      def assert_response(expected_status, expected_body = nil)
+        expected_status = case expected_status
+        when :ok, :okay
+          Hephaestus::HTTP::OK_I
+        when :created
+          Hephaestus::HTTP::CREATED_I
+        when :no_content
+          Hephaestus::HTTP::NO_CONTENT_I
+        when :redirect
+          Hephaestus::HTTP::FOUND_I
+        when :bad_request
+          Hephaestus::HTTP::BAD_REQUEST_I
+        when :unauthorized
+          Hephaestus::HTTP::UNAUTHORIZED_I
+        when :forbidden
+          Hephaestus::HTTP::FORBIDDEN_I
+        when :not_found
+          Hephaestus::HTTP::NOT_FOUND_I
+        when :not_acceptable
+          Hephaestus::HTTP::NOT_ACCEPTABLE_I
+        when :service_unavailable
+          Hephaestus::HTTP::SERVICE_UNAVAILABLE_I
+        else
+          raise ArgumentError, "Unknown status: #{expected_status}"
+        end
+
+        assert_equal(expected_status, last_response.status)
+      end
+
+      def prepend_plug_path(version, path)
+        "/#{plug_shortname}/#{version}#{path}"
+      end
+
+      def prepend_api_path(version, path)
+        "/api/#{version}#{path}"
+      end
+
+      def headers(event, body)
+        case event
+        when :after_create
+          {
+            Hephaestus::Headers::HEADER_EVENT => "after_create",
+            Hephaestus::Headers::HEADER_RECORD_TYPE => "plug_installation",
+          }
+        when :after_update_plug_installation
+          {
+            Hephaestus::Headers::HEADER_EVENT => "after_update",
+            Hephaestus::Headers::HEADER_RECORD_TYPE => "plug_installation",
+          }
+        when :after_update_inbox
+          {
+            Hephaestus::Headers::HEADER_EVENT => "after_update",
+            Hephaestus::Headers::HEADER_RECORD_TYPE => "inbox",
+          }
+        when :after_update_organization
+          {
+            Hephaestus::Headers::HEADER_EVENT => "after_update",
+            Hephaestus::Headers::HEADER_RECORD_TYPE => "organization",
+          }
+        when :after_destroy_plug_installation
+          {
+            Hephaestus::Headers::HEADER_EVENT => "after_destroy",
+            Hephaestus::Headers::HEADER_RECORD_TYPE => "plug_installation",
+          }
+        else
+          {}
+        end.merge(Hephaestus::Headers::HEADER_SIGNATURE => yetto_auth_header(body))
+      end
+    end
+  end
+end

data/lib/hephaestus/support/hephaestus/webmocks/browser_webmock.rb

@@ -0,0 +1,21 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module Webmocks
+    module BrowserWebmock
+      def browser_mock(status: 200)
+        browser_mock = Object.new
+        Ferrum::Browser.stubs(:new).returns(browser_mock)
+        browser_mock.stubs(:go_to)
+        browser_mock.stubs(:quit)
+        response_mock = Ferrum::Network::Response.new("", "")
+        response_mock.stubs(:wait_for_idle).returns(true)
+        network_response_mock = Object.new
+        browser_mock.stubs(:network).returns(network_response_mock)
+        network_response_mock.stubs(:response).returns(response_mock)
+        response_mock.stubs(:status).returns(status)
+      end
+    end
+  end
+end

data/lib/hephaestus/support/hephaestus/webmocks/slack_webmock.rb

@@ -0,0 +1,21 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module Webmocks
+    module SlackWebmock
+      def assert_requested_send_to_slack_log
+        assert_requested(:post, "https://slack.com/the_log_room")
+      end
+
+      def stub_send_to_slack_log
+        stub_request(:post, "https://slack.com/the_log_room")
+          .to_return(
+            status: 200,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: {}.to_json,
+          )
+      end
+    end
+  end
+end

data/lib/hephaestus/support/hephaestus/webmocks/yetto_webmock.rb

@@ -0,0 +1,195 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module Webmocks
+    module YettoWebmock
+      def yetto_auth_header(payload, signing_secret = SIGNING_SECRET)
+        "sha256=#{OpenSSL::HMAC.hexdigest(Hephaestus::ValidatesFromYetto::SHA256_DIGEST, signing_secret, payload.to_json)}"
+      end
+
+      def assert_requested_post_access_token(plug_installation_id, times: 1)
+        assert_requested(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/plug/installations/#{plug_installation_id}/access_tokens", times: times)
+      end
+
+      def stub_post_access_token(plug_installation_id)
+        response = {
+          token: Faker::Alphanumeric.alphanumeric(number: 26).upcase,
+        }
+
+        stub_request(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/plug/installations/#{plug_installation_id}/access_tokens")
+          .to_return(
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_get_plug_installation(plug_installation_id, times: 1)
+        assert_requested(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}", times:)
+      end
+
+      def stub_get_plug_installation(plug_installation_id, response: {}, status: 200)
+        stub_request(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}")
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_update_plug_installation(plug_installation_id)
+        assert_requested(:patch, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}")
+      end
+
+      def assert_not_requested_update_plug_installation(plug_installation_id)
+        assert_requested(:patch, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}", times: 0)
+      end
+
+      def stub_update_plug_installation(plug_installation_id, params, response: {}, status: 200)
+        stub_post_access_token(plug_installation_id)
+
+        response[:plug_installation] = { id: plug_installation_id }
+
+        stub_request(:patch, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}")
+          .with(
+            body: params,
+          )
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_create_conversation(plug_installation_id, inbox_id)
+        assert_requested(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/conversations")
+      end
+
+      def stub_create_conversation(plug_installation_id, inbox_id, payload, response: {})
+        stub_post_access_token(plug_installation_id)
+
+        response[:plug_installation] = { id: plug_installation_id }
+
+        stub_request(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/conversations")
+          .with(
+            body: payload,
+          )
+          .to_return(
+            status: 200,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_get_plug_installations(filter: "")
+        assert_requested(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/plug/installations?#{filter}")
+      end
+
+      def stub_get_plug_installations(response, status: 200, filter: "")
+        stub_request(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/plug/installations?#{filter}")
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_get_messages_in_inbox(plug_installation_id, inbox_id, filter: "")
+        assert_requested(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/messages?#{filter}")
+      end
+
+      def stub_get_messages_in_inbox(plug_installation_id, inbox_id, response, filter: "")
+        stub_post_access_token(plug_installation_id)
+        stub_request(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/messages?#{filter}")
+          .to_return(
+            status: 200,
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_get_messages_in_conversation(plug_installation_id, conversation_id, filter: "")
+        assert_requested(:get, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages?#{filter}")
+      end
+
+      def stub_get_messages_in_conversation(plug_installation_id, conversation_id, response, status: 200, filter: "")
+        stub_post_access_token(plug_installation_id)
+
+        stub_request(:get, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages?#{filter}")
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def stub_add_message_to_conversation(plug_installation_id, conversation_id, payload, response: {}, status: 200)
+        stub_post_access_token(plug_installation_id)
+
+        response[:plug_installation] = { id: plug_installation_id }
+
+        stub_request(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages")
+          .with(
+            body: payload,
+          )
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+
+      def assert_requested_add_message_to_conversation(plug_installation_id, conversation_id)
+        assert_requested(:post, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages")
+      end
+
+      def assert_requested_create_message(plug_installation_id, message_id)
+        assert_requested(:post, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/messages/#{message_id}/replies")
+      end
+
+      def stub_create_message(plug_installation_id, message_id, payload)
+        stub_post_access_token(plug_installation_id)
+
+        stub_request(:post, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/messages/#{message_id}/replies")
+          .with(
+            body: payload,
+          )
+          .to_return(
+            status: 200,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: {}.to_json,
+          )
+      end
+
+      def assert_requested_update_message(plug_installation_id, message_id)
+        assert_requested(:patch, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/messages/#{message_id}")
+      end
+
+      def stub_update_message(plug_installation_id, message_id, payload)
+        stub_post_access_token(plug_installation_id)
+        stub_request(:patch, "#{::Hephaestus::YettoService::YETTO_API_VERSION_TLD}/messages/#{message_id}")
+          .with(
+            body: payload,
+          )
+          .to_return(
+            status: 200,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: {}.to_json,
+          )
+      end
+
+      def assert_requested_find_message_in_conversation_by_metadata(plug_installation_id, conversation_id)
+        assert_requested(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages?#{filter}")
+      end
+
+      def stub_find_message_in_conversation(plug_installation_id, conversation_id, response, status: 200, filter: "")
+        stub_post_access_token(plug_installation_id)
+
+        stub_request(:get, "#{Hephaestus::YettoService::YETTO_API_VERSION_TLD}/conversations/#{conversation_id}/messages?#{filter}")
+          .to_return(
+            status: status,
+            headers: { content_type: "application/json; charset=utf-8" },
+            body: response.to_json,
+          )
+      end
+    end
+  end
+end

data/lib/hephaestus/support/rails.rb

@@ -0,0 +1,35 @@
+# typed: false
+# frozen_string_literal: true
+
+module ActiveSupport
+  class TestCase
+    # Run tests in parallel with specified workers
+    parallelize(workers: :number_of_processors)
+
+    def setup
+      @organization_id ||= "org_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+      @plug_installation_id ||= "pli_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+      @inbox_id ||= "ibx_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+      @plug_id ||= "plg_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+      @message_id ||= "msg_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+      @conversation_id ||= "cnv_#{Faker::Alphanumeric.alphanumeric(number: 26).upcase}"
+    end
+
+    def file_fixture_path(dir, name)
+      Rails.root.join("test", "fixtures", "files", dir, name)
+    end
+
+    def assert_expected_args(expected_args)
+      lambda do |job_args_arr|
+        job_args_arr.first.each do |actual_args|
+          actual_key = actual_args.first
+          actual_value = actual_args.second
+
+          expected_value = expected_args[actual_key]
+
+          assert_equal(expected_value, actual_value, "Expected `#{actual_key}` to be `#{expected_value.nil? ? "nil" : expected_value}`, but was `#{actual_value.nil? ? "nil" : actual_value}`")
+        end
+      end
+    end
+  end
+end

data/lib/hephaestus/test_helper.rb

@@ -0,0 +1,45 @@
+# typed: false
+# frozen_string_literal: true
+
+ENV["RAILS_ENV"] ||= "test"
+
+require_relative File.join($LOAD_PATH.last, "..", "config", "environment.rb")
+
+module Hephaestus
+  module TestHelper
+    require "minitest/autorun"
+    require "minitest/pride"
+
+    require "debug" if ENV.fetch("DEBUG", false)
+
+    if ENV["COVERAGE"] == "1"
+      require "simplecov"
+      require "simplecov-console"
+
+      SimpleCov.start("rails")
+
+      # do not crash on failure; we want a distinct job to report the coverage error
+      module SimpleCov
+        class << self
+          def result_exit_status(_)
+            SimpleCov::ExitCodes::SUCCESS
+          end
+        end
+      end
+    end
+
+    require "webmock"
+    require "httpx/adapters/webmock"
+    require "webmock/minitest"
+    WebMock.enable!
+    WebMock.disable_net_connect!(allow_localhost: true)
+
+    require_relative "support/rails"
+
+    # Load everything else from engine's test/support
+    Dir[File.expand_path("support/hephaestus/**/*.rb", __dir__)].each { |rb| require(rb) }
+
+    # https://github.com/freerange/mocha#rails
+    require "mocha/minitest"
+  end
+end

data/lib/hephaestus/version.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 module Hephaestus
-  VERSION = "0.6.3"
-  RAILS_VERSION = "~> 7.0"
+  VERSION = "0.7.0"
+  RAILS_VERSION = ">= 8.0"
   RUBY_VERSION = File
     .read("#{File.dirname(__FILE__)}/../../.ruby-version")
     .strip

data/lib/hephaestus.rb

@@ -10,6 +10,7 @@ end
 require "debug" if debugging?
 
 require "hephaestus/version"
+require "hephaestus/engine"
 require "hephaestus/exit_on_failure"
 
 require "hephaestus/generators/app_generator"

data/lib/tasks/hephaestus_tasks.rake

@@ -0,0 +1,7 @@
+# typed: false
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :hephaestus do
+#   # Task goes here
+# end

data/lib/tasks/package.rake

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+require "rubygems/package_task"
+
+GEMSPEC = Bundler.load_gemspec(File.join(__dir__, "..", "..", "hephaestus.gemspec")) unless defined?(GEMSPEC)
+gem_path = Gem::PackageTask.new(GEMSPEC).define
+desc "Package the ruby gem"
+task "package" => [gem_path]

data/lib/tasks/rubocop.rake

@@ -0,0 +1,6 @@
+# typed: false
+# frozen_string_literal: true
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new

data/lib/version.rb

@@ -0,0 +1,6 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  VERSION = "0.1.0"
+end

data/templates/app/controllers/app_controller.rb

@@ -48,6 +48,7 @@ class AppController < ApplicationController
           text_content: text_body,
           is_public: true,
           author: {
+            version: "2023-03-06",
             name: from_email,
           },
           attachments: bparam_attachments,