hanami-devtools 2023.02.16

data/lib/hanami/devtools/integration/env.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "singleton"
+module RSpec
+  module Support
+    # Environment variables wrapper for:
+    #
+    #   * CLI commands
+    #   * Isolate `ENV` global state
+    #
+    # @since 0.2.0
+    #
+    # @see https://lucaguidi.com/2016/12/27/isolate-global-state/
+    class Env
+      include Singleton
+
+      def self.setup
+        instance.__send__(:setup)
+      end
+
+      def self.reset
+        instance.__send__(:setup)
+      end
+
+      def self.env
+        instance.to_h
+      end
+
+      def self.[](key)
+        instance[key]
+      end
+
+      def self.[]=(key, value)
+        instance[key] = value
+      end
+
+      def self.fetch_from_original(key)
+        instance.__send__(:original).fetch(key)
+      end
+
+      def initialize
+        @original = ENV.to_hash
+        @mutex    = Mutex.new
+        setup
+      end
+
+      def [](key)
+        synchronize do
+          env[key]
+        end
+      end
+
+      def []=(key, value)
+        synchronize do
+          env[key] = value
+        end
+      end
+
+      def to_h
+        env.dup
+      end
+
+      private
+
+      attr_reader :original, :env
+
+      ENV_VARS = %w[RUBYOPT RUBYLIB RUBY_ROOT RUBY_ENGINE RUBY_VERSION GEM_ROOT GEM_HOME GEM_PATH BUNDLE_GEMFILE].freeze
+
+      def setup
+        synchronize do
+          @env = {}
+        end
+
+        ENV_VARS.each do |var|
+          original_value = original.fetch(var, nil)
+          next if original_value.nil?
+
+          self[var] = original_value
+        end
+      end
+
+      def synchronize(&blk)
+        @mutex.synchronize(&blk)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    RSpec::Support::Env.setup
+  end
+
+  config.after do
+    RSpec::Support::Env.reset
+  end
+end

data/lib/hanami/devtools/integration/files.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "hanami/utils/files"
+
+module RSpec
+  module Support
+    # File manipulation utilities
+    #
+    # @since 0.2.0
+    module Files
+      private
+
+      def touch(path)
+        write(path, "")
+      end
+
+      def write(path, *content)
+        Pathname.new(path).dirname.mkpath
+        open(path, ::File::CREAT | ::File::WRONLY, *content)
+      end
+
+      def rewrite(path, *content)
+        open(path, ::File::TRUNC | ::File::WRONLY, *content)
+      end
+
+      def replace(path, target, replacement)
+        content = ::File.readlines(path)
+        content[index(content, path, target)] = "#{replacement}\n"
+
+        rewrite(path, content)
+      end
+
+      def replace_last(path, target, replacement)
+        content = ::File.readlines(path)
+        content[-index(content.reverse, path, target) - 1] = "#{replacement}\n"
+
+        rewrite(path, content)
+      end
+
+      def unshift(path, line)
+        content = ::File.readlines(path)
+        content.unshift("#{line}\n")
+
+        rewrite(path, content)
+      end
+
+      def append(path, contents)
+        content = ::File.readlines(path)
+        content << "#{contents}\n"
+
+        rewrite(path, content)
+      end
+
+      def remove_block(path, target) # rubocop:disable Metrics/AbcSize
+        content  = ::File.readlines(path)
+        starting = index(content, path, target)
+        line     = content[starting]
+        size     = line[/\A[[:space:]]*/].bytesize
+        closing  = (" " * size) + (target =~ /{/ ? "}" : "end")
+        ending   = starting + index(content[starting..-1], path, closing)
+
+        content.slice!(starting..ending)
+        rewrite(path, content)
+
+        remove_block(path, target) if containts?(content, target)
+      end
+
+      def remove_line(path, target)
+        Hanami::Utils::Files.remove_line(path, target)
+      end
+
+      def inject_line_before(path, target, contents)
+        Hanami::Utils::Files.inject_line_before(path, target, contents)
+      end
+
+      def inject_line_after(path, target, contents)
+        Hanami::Utils::Files.inject_line_after(path, target, contents)
+      end
+
+      def open(path, mode, *content)
+        ::File.open(path, mode) do |file|
+          file.write(Array(content).flatten.join)
+        end
+      end
+
+      def contents(path)
+        ::IO.read(Hanami.root.join(path))
+      end
+
+      def index(content, path, target)
+        line_number(content, target) or
+          raise ArgumentError.new("Cannot find `#{target}' inside `#{path}'.")
+      end
+
+      def containts?(content, target)
+        !line_number(content, target).nil?
+      end
+
+      def line_number(content, target)
+        content.index { |l| l.include?(target) }
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Files, type: :integration
+end

data/lib/hanami/devtools/integration/gemfile.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "digest"
+require "hanami/utils/files"
+
+module RSpec
+  module Support
+    # Gemfile utilities
+    #
+    # @since 0.2.0
+    module Gemfile
+      module_function
+
+      def changed?
+        return true unless gemfile.exist? && checksum.exist?
+
+        calculate_checksum(gemfile) != checksum.read
+      end
+
+      def write_checksum
+        Hanami::Utils::Files.write(checksum, calculate_checksum(gemfile))
+      end
+
+      def calculate_checksum(path)
+        return unless path.exist?
+        Digest::MD5.file(path).to_s
+      end
+
+      def gemfile
+        Pathname.new("Gemfile.lock")
+      end
+
+      def checksum
+        Pathname.new("tmp").join("gemfile")
+      end
+    end
+  end
+end

data/lib/hanami/devtools/integration/hanami_commands.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "hanami/devtools/integration/bundler"
+require "hanami/devtools/integration/files"
+require "hanami/devtools/integration/retry"
+require "hanami/devtools/integration/random_port"
+require "hanami/utils/string"
+
+module RSpec
+  module Support
+    # Run Hanami CLI commands
+    #
+    # @since 0.2.0
+    module HanamiCommands # rubocop:disable Metrics/ModuleLength
+      if defined?(Hanami::Environment)
+        LISTEN_ALL_HOST = Hanami::Environment::LISTEN_ALL_HOST
+        DEFAULT_PORT    = Hanami::Environment::DEFAULT_PORT
+      else
+        LISTEN_ALL_HOST = "0.0.0.0"
+        DEFAULT_PORT    = 2300
+      end
+
+      private
+
+      def rackup(args = {}, &blk)
+        args[:port] ||= RandomPort.call
+
+        bundle_exec "rackup -p #{args[:port]}" do |_, _, wait_thr|
+          exec_server_tests(args, wait_thr, &blk)
+        end
+      end
+
+      def server(args = {}, &blk)
+        args[:port] ||= RandomPort.call
+
+        hanami "server#{_hanami_server_args(args)}" do |_, _, wait_thr|
+          exec_server_tests(args, wait_thr, &blk)
+        end
+      end
+
+      def hanami(cmd, env: nil, &blk)
+        bundle_exec("hanami #{cmd}", env: env, &blk)
+      end
+
+      def console(args = "", &blk)
+        hanami "console#{args}", &blk
+      end
+
+      def db_console(&blk)
+        hanami "db console", &blk
+      end
+
+      def generate(target)
+        hanami "generate #{target}"
+      end
+
+      def destroy(target)
+        hanami "destroy #{target}"
+      end
+
+      def migrate
+        hanami "db migrate"
+      end
+
+      def generate_model(entity)
+        generate "model #{entity}"
+      end
+
+      def generate_migration(name, content) # rubocop:disable Metrics/AbcSize
+        # Check if the migration already exist because `hanami generate model`
+        migration = Dir.glob(Pathname.new("db").join("migrations", "*_#{name}.rb")).sort.last
+
+        # If it doesn't exist, generate it
+        if migration.nil?
+          sleep 1 # prevent two migrations to have the same timestamp
+          generate "migration #{name}"
+
+          migration = Dir.glob(Pathname.new("db").join("migrations", "**", "*.rb")).sort.last
+        end
+
+        # write the given content, then return the timestamp
+        rewrite(migration, content)
+        Integer(migration.scan(/[0-9]+/).first)
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Style/ClosingParenthesisIndentation
+      def generate_migrations
+        versions = []
+        versions << generate_migration("create_users", <<~CODE
+          Hanami::Model.migration do
+            change do
+              create_table :users do
+                primary_key :id
+                column :name, String
+              end
+            end
+          end
+CODE
+)
+
+        versions << generate_migration("add_age_to_users", <<~CODE
+          Hanami::Model.migration do
+            change do
+              add_column :users, :age, Integer
+            end
+          end
+CODE
+)
+        versions
+      end
+      # rubocop:enable Style/ClosingParenthesisIndentation
+      # rubocop:enable Metrics/MethodLength
+
+      def setup_model # rubocop:disable Metrics/MethodLength
+        generate_model     "book"
+        generate_migration "create_books", <<~CODE
+          Hanami::Model.migration do
+            change do
+              create_table :books do
+                primary_key :id
+                column :title, String
+              end
+            end
+          end
+        CODE
+
+        migrate
+      end
+
+      def exec_server_tests(args, wait_thr, &blk)
+        if block_given?
+          setup_capybara(args)
+          retry_exec(StandardError, &blk)
+        end
+      ensure
+        # Simulate Ctrl+C to stop the server
+        Process.kill "INT", wait_thr[:pid]
+      end
+
+      def setup_capybara(args)
+        host = args.fetch(:host, LISTEN_ALL_HOST)
+        port = args.fetch(:port, DEFAULT_PORT)
+
+        Capybara.configure do |config|
+          config.app_host = "http://#{host}:#{port}"
+        end
+      end
+
+      def _hanami_server_args(args)
+        return if args.empty?
+
+        result = args.map do |arg, value|
+          if value.nil?
+            "--#{arg}"
+          else
+            "--#{arg}=#{value}"
+          end
+        end.join(" ")
+
+        " #{result}"
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::HanamiCommands, type: :integration
+end

data/lib/hanami/devtools/integration/platform/engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "hanami/utils"
+
+module Platform
+  # Detect current Ruby engine: MRI or JRuby
+  #
+  # @since 0.2.0
+  module Engine
+    def self.engine?(name)
+      current == name
+    end
+
+    def self.current
+      if    ruby?  then :ruby
+      elsif jruby? then :jruby
+      end
+    end
+
+    class << self
+      private
+
+      def ruby?
+        RUBY_ENGINE == "ruby"
+      end
+
+      def jruby?
+        Hanami::Utils.jruby?
+      end
+    end
+  end
+end

data/lib/hanami/devtools/integration/platform/matcher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "dry/core/basic_object"
+
+module Platform
+  # Match current platform variables like Ruby engine, current database.
+  #
+  # @since 0.2.0
+  class Matcher
+    # Represents a failing match
+    #
+    # @since 0.2.0
+    class Nope < Dry::Core::BasicObject
+      def or(other, &blk)
+        blk.nil? ? other : blk.call # rubocop:disable Performance/RedundantBlockCall
+      end
+
+      def method_missing(*) # rubocop:disable Style/MethodMissing
+        self.class.new
+      end
+    end
+
+    def self.match(&blk)
+      catch :match do
+        new.__send__(:match, &blk)
+      end
+    end
+
+    def self.match?(os: Os.current, engine: Engine.current)
+      catch :match do
+        new.os(os).engine(engine) { true }.or(false)
+      end
+    end
+
+    def initialize
+      freeze
+    end
+
+    def os(name, &blk)
+      return nope unless os?(name)
+      block_given? ? resolve(&blk) : yep
+    end
+
+    def engine(name, &blk)
+      return nope unless engine?(name)
+      block_given? ? resolve(&blk) : yep
+    end
+
+    def default(&blk)
+      resolve(&blk)
+    end
+
+    private
+
+    def match(&blk)
+      instance_exec(&blk)
+    end
+
+    def nope
+      Nope.new
+    end
+
+    def yep
+      self.class.new
+    end
+
+    def resolve
+      throw :match, yield
+    end
+
+    def os?(name)
+      Os.os?(name)
+    end
+
+    def engine?(name)
+      Engine.engine?(name)
+    end
+  end
+end

data/lib/hanami/devtools/integration/platform/os.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Platform
+  # Detect current Operating System (OS): MacOS or Linux
+  #
+  # @since 0.2.0
+  module Os
+    def self.os?(name)
+      current == name
+    end
+
+    def self.current
+      case RbConfig::CONFIG["host_os"]
+      when /linux/  then :linux
+      when /darwin/ then :macos
+      end
+    end
+  end
+end

data/lib/hanami/devtools/integration/platform.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Matchers for current OS, Ruby engine.
+#
+# @since 0.2.0
+module Platform
+  require "hanami/devtools/integration/platform/os"
+  require "hanami/devtools/integration/platform/engine"
+  require "hanami/devtools/integration/platform/matcher"
+
+  def self.ci?
+    ENV.key?("CI")
+  end
+
+  def self.match(&blk)
+    Matcher.match(&blk)
+  end
+
+  def self.match?(**args)
+    Matcher.match?(**args)
+  end
+end

data/lib/hanami/devtools/integration/project_without_hanami_model.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "hanami/devtools/integration/with_clean_env_project"
+
+module RSpec
+  module Support
+    # Generate a project without `hanami-model`
+    #
+    # @since 0.2.0
+    module ProjectWithoutHanamiModel
+      private
+
+      def project_without_hanami_model(project = "bookshelf", args = {})
+        with_clean_env_project(project, args.merge(exclude_gems: ["hanami-model"])) do
+          replace "config/environment.rb", "hanami/model", ""
+          replace "Rakefile",              "hanami/rake_tasks", ""
+          yield
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::ProjectWithoutHanamiModel, type: :integration
+end

data/lib/hanami/devtools/integration/rack_test.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rack"
+require "rack/test"
+require "excon"
+require "hanami/devtools/integration/retry"
+
+module RSpec
+  module Support
+    # HTTP tests agains Rack endpoints
+    #
+    # @since 0.2.0
+    module RackTest
+      private
+
+      def app
+        Rack::Builder.new do
+          use Rack::Lint
+          run RSpec::Support::RackApp.new
+        end
+      end
+    end
+
+    # Testing Rack application
+    #
+    # @since 0.2.0
+    class RackApp
+      include RSpec::Support::Retry
+
+      def initialize
+        @connection = Excon.new(Capybara.app_host, persistent: true, read_timeout: 5)
+      end
+
+      def call(env)
+        retry_exec(Excon::Errors::SocketError) do
+          response(
+            request(env)
+          )
+        end
+      end
+
+      private
+
+      attr_reader :connection
+
+      def request(env)
+        connection.request(options(env))
+      end
+
+      def response(r)
+        [r.status, r.headers, [r.body]]
+      end
+
+      def options(env) # rubocop:disable Metrics/MethodLength
+        result = Hash[
+          method:  env["REQUEST_METHOD"],
+          path:    env["PATH_INFO"],
+          headers: {
+            "Content-Type" => env["CONTENT_TYPE"],
+            "Accept"       => env["HTTP_ACCEPT"]
+          }
+        ]
+
+        unless get?(env)
+          env["rack.input"].rewind
+          result[:body] = env["rack.input"].read
+        end
+
+        result
+      end
+
+      def get?(env)
+        %w[GET HEAD].include?(env["REQUEST_METHOD"])
+      end
+    end
+  end
+end
+
+Excon.defaults[:ssl_verify_peer] = false
+Excon.defaults[:ssl_verify_peer_host] = false
+# Excon.defaults[:ssl_version] = :SSLv3
+Excon.defaults[:middlewares].push(Excon::Middleware::RedirectFollower)
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods,      type: :integration
+  config.include RSpec::Support::RackTest, type: :integration
+end