dry-web-roda 0.6.0 → 0.6.1

data/spec/support/app.rb

@@ -0,0 +1,64 @@
+require "net/http"
+require "uri"
+require "waitutil"
+require_relative "silently"
+
+module RSpec
+  module Support
+    module App
+      private
+
+      class RunningApp
+        attr_reader :port
+
+        def initialize(port)
+          @port = port
+        end
+
+        def get(path)
+          Net::HTTP.get(uri(path))
+        end
+
+        private
+
+        def uri(path)
+          URI("http://0.0.0.0:#{port}#{path}")
+        end
+      end
+
+      def run_app(host: "0.0.0.0", port: "30333", timeout: 5)
+        cmd = "bundle exec rackup -o 0.0.0.0 -p #{port} config.ru"
+        out = Tempfile.new("dry-web-roda-out")
+
+        pid = fork {
+          Bundler.with_clean_env do
+            exec cmd, out: out.path, err: out.path
+          end
+        }
+
+        WaitUtil.wait_for_condition "app available on #{host}:#{port}", timeout_sec: timeout do
+          begin
+            result = WaitUtil.send(:is_tcp_port_open, host, port, WaitUtil::DEFAULT_DELAY_SEC)
+
+            result || begin
+              out.rewind
+              [false, "#{cmd} failed:\n#{out.read}"]
+            end
+          rescue SocketError
+            out.rewind
+            [false, "#{cmd} failed:\n#{out.read}"]
+          end
+        end
+
+        yield RunningApp.new(port)
+      ensure
+        Process.kill "TERM", pid
+        Process.wait pid
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::App, type: :cli
+end

data/spec/support/bundler.rb

@@ -0,0 +1,113 @@
+require 'open3'
+require 'pathname'
+require_relative 'env'
+require_relative 'silently'
+require_relative 'files'
+
+module RSpec
+  module Support
+    module Bundler
+      def self.root
+        Pathname.new(__dir__).join("..", "..")
+      end
+
+      def self.cache
+        root.join("vendor", "cache")
+      end
+
+      def self.setup
+        return if cache.exist?
+
+        with_clean_env do
+          RSpec::Support.silently "./script/setup"
+        end
+      end
+
+      def self.with_clean_env(&blk)
+        ::Bundler.with_clean_env(&blk)
+      end
+
+      private
+
+      attr_reader :out, :err, :exitstatus
+
+      def setup_gemfile(gems: [], exclude_gems: [], path: "Gemfile")
+        filtered_content = ::File.readlines(path).
+                             drop(1).
+                             reject { |l| exclude_gems.any? { |g| l.include?(g) } }
+
+        content = ["source 'file://#{cache}'\n"] + filtered_content + gems.map { |g| "gem #{g}\n" }
+
+        rewrite(path, content)
+      end
+
+      def bundle_install
+        bundle "install --local --no-cache --retry 0 --no-color"
+      end
+
+      def bundle_exec(cmd, env: nil, &blk)
+        bundle("exec #{cmd}", env: env, &blk)
+      end
+
+      def bundle(cmd, env: nil, &blk)
+        ruby_bin   = which("ruby")
+        bundle_bin = which("bundle")
+        rack_env = "RACK_ENV=#{env} " unless env.nil?
+
+        system_exec("#{rack_env}#{ruby_bin} -I#{load_paths} #{bundle_bin} #{cmd}", &blk)
+      end
+
+      # Adapted from Bundler source code
+      #
+      # Bundler is released under MIT license
+      # https://github.com/bundler/bundler/blob/master/LICENSE.md
+      #
+      # A special "thank you" goes to Bundler maintainers and contributors.
+      #
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def system_exec(cmd)
+        Open3.popen3(RSpec::Support::Env.env, cmd) do |stdin, stdout, stderr, wait_thr|
+          yield stdin, stdout, wait_thr if block_given?
+          stdin.close
+
+          @exitstatus = wait_thr && wait_thr.value.exitstatus
+          @out = Thread.new { stdout.read }.value.strip
+          @err = Thread.new { stderr.read }.value.strip
+        end
+
+        (@all_output ||= "") << [
+          "$ #{cmd.to_s.strip}",
+          out,
+          err,
+          @exitstatus ? "# $? => #{@exitstatus}" : "",
+          "\n"
+        ].reject(&:empty?).join("\n")
+
+        @out
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def load_paths
+        [root.join('lib'), root.join('spec')].join(':')
+      end
+
+      def root
+        RSpec::Support::Bundler.root
+      end
+
+      def cache
+        RSpec::Support::Bundler.cache
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Bundler, type: :cli
+
+  config.before(:all, type: :cli) do
+    RSpec::Support::Bundler.setup
+  end
+end

data/spec/support/cli.rb

@@ -0,0 +1,47 @@
+require "aruba"
+require "aruba/api"
+require "pathname"
+
+module RSpec
+  module Support
+    module Cli
+      def self.included(spec)
+        spec.before do
+          aruba = Pathname.new(Dir.pwd).join('tmp', 'aruba')
+          aruba.rmtree if aruba.exist?
+
+          setup_aruba
+        end
+      end
+
+      private
+
+      def run_command(cmd, output = nil, exit_status: 0)
+        run_simple "bundle exec #{cmd}", fail_on_error: false
+
+        match_output(output)
+        expect(last_command_started).to have_exit_status(exit_status)
+      end
+
+      def match_output(output)
+        case output
+        when String
+          expect(all_output).to include(output)
+        when Regexp
+          expect(all_output).to match(output)
+        when Array
+          output.each { |o| match_output(o) }
+        end
+      end
+
+      def all_output
+        all_commands.map(&:output).join("\n")
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Aruba::Api,          type: :cli
+  config.include RSpec::Support::Cli, type: :cli
+end

data/spec/support/directories.rb

@@ -0,0 +1,37 @@
+require "fileutils"
+
+module RSpec
+  module Support
+    module Directory
+      private
+
+      def with_directory(directory)
+        current = Dir.pwd
+        target  = Pathname.new(Dir.pwd).join(directory)
+
+        Dir.chdir(target)
+        yield
+      ensure
+        Dir.chdir(current)
+      end
+
+      def with_tmp_directory
+        dir = Pathname.new("tmp").join("aruba")
+
+        with_directory(dir) do
+          yield
+        end
+      ensure
+        FileUtils.rm_rf(dir)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Directory, type: :cli
+
+  config.before :suite do
+    Pathname.new(Dir.pwd).join("tmp").mkpath
+  end
+end

data/spec/support/env.rb

@@ -0,0 +1,84 @@
+require 'singleton'
+require 'thread'
+
+module RSpec
+  module Support
+    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
+
+      def setup
+        synchronize do
+          @env = {}
+        end
+
+        self["GEM_ROOT"] = original["GEM_ROOT"]
+        self["GEM_HOME"] = original["GEM_HOME"]
+        self["GEM_PATH"] = original["GEM_PATH"]
+      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/spec/support/files.rb

@@ -0,0 +1,59 @@
+module RSpec
+  module Support
+    module Files
+      private
+
+      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 open(path, mode, *content)
+        ::File.open(path, mode) do |file|
+          file.write(Array(content).flatten.join)
+        end
+      end
+
+      def index(content, path, target)
+        content.index { |l| l.include?(target) } or
+          raise ArgumentError.new("Cannot find `#{target}' inside `#{path}'.")
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Files, type: :cli
+end

data/spec/support/project.rb

@@ -0,0 +1,60 @@
+require "waitutil"
+require_relative 'env'
+require_relative 'silently'
+require_relative 'bundler'
+require_relative 'directories'
+
+module RSpec
+  module Support
+    module Project
+      private
+
+      KNOWN_ARGUMENTS = [:arch].freeze
+
+      def with_project(name = "sandbox", **args)
+        with_tmp_directory do
+          create_project name, args
+
+          within_project_directory(name) do
+            setup_gemfile
+            bundle_install
+            yield
+          end
+        end
+      end
+
+      def within_project_directory(project)
+        cd(project.to_s) do
+          # Aruba resets ENV and its API to set new env vars is broken.
+          #
+          # We need to manually setup the following env vars:
+          #
+          # ENV["PATH"] is required by Capybara's selenium/poltergeist drivers
+          ENV["PATH"] = RSpec::Support::Env.fetch_from_original("PATH")
+          # Bundler on CI can't find HOME and it fails to run Hanami commands
+          ENV["HOME"] = RSpec::Support::Env.fetch_from_original("HOME")
+
+          yield
+        end
+      end
+
+      def create_project(name, args)
+        silently "dry-web-roda new #{name} #{_create_project_args(args)}"
+      end
+
+      def _create_project_args(args)
+        return if args.empty?
+
+        flags = args.dup.keep_if { |k, _| KNOWN_ARGUMENTS.include?(k) }
+
+        flags.map { |arg, value|
+          "--#{arg}=#{value}"
+        }.join(" ")
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Support::Project, type: :cli
+end