geb 0.1.11

data/test/command tests/test_geb_upload.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+#
+# Tests the upload command class
+#
+# @title Geb - Test - Upload Command
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+require "test_helper"
+
+class TestGebCommandUpload < Geb::CliTest
+
+  test "that the CLI api call works" do
+
+    copy_test_site()
+
+    command = Geb::CLI::Commands::Upload.new
+
+    command_options = { }
+
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    Open3.expects(:popen3).returns(["", "", ""])
+
+    command.call(**command_options)
+
+    assert_empty $stderr.string
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the CLI api call works"
+
+  test "that the Open3 block executes correctly" do
+
+    copy_test_site()
+
+    command = Geb::CLI::Commands::Upload.new
+
+    command_options = { }
+
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    mock_stdout = StringIO.new("mocked stdout line 1\nmocked stdout line 2\n")
+    mock_stderr = StringIO.new("mocked stderr line 1\nmocked stderr line 2\n")
+    mock_wait_thr = mock('wait_thr')
+    mock_wait_thr.stubs(:value) #.returns(mock('status', exitstatus: 0))
+
+    Open3.stubs(:popen3).yields(nil, mock_stdout, mock_stderr, mock_wait_thr)
+
+    command.call(**command_options)
+
+    assert_empty $stderr.string
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the Open3 block executes correctly"
+
+  test "that the command executes correctly with exception" do
+
+    copy_test_site()
+
+    command = Geb::CLI::Commands::Upload.new
+
+    command_options = { }
+
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    Geb::Site.expects(:new).raises(Geb::Error.new("Site not loaded"))
+
+    command.call(**command_options)
+
+    assert_match(/Site not loaded/, $stderr.string)
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the command executes correctly with exception"
+
+end # class TestGebCommandUpload < Minitest::Test

data/test/command tests/test_geb_version.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+#
+# Tests the version command class
+#
+# @title Geb - Test - Version Command
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+require "test_helper"
+
+class TestGebCommandVersion < Geb::CliTest
+
+  test "that the CLI api call works" do
+
+    command = Geb::CLI::Commands::Version.new
+
+    command_options = {  }
+
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    command.call(**command_options)
+
+    assert_empty $stderr.string
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the CLI api call works"
+
+  test "that command default executes" do
+
+    # call geb auto command and capture output and error
+    stdout, stderr, status = Open3.capture3('geb version')
+
+    # assert that the output contains the expected string
+    assert status.success?
+    assert_includes stdout, "Geb version #{Geb::VERSION}"
+    assert_empty stderr
+
+  end # test "command line"
+
+  test "that Geb version specified in Geb module and gemspec are the same" do
+
+    gemspec_path = File.expand_path('../../../geb.gemspec', __FILE__)
+    @gemspec = Gem::Specification.load(gemspec_path)
+
+    assert_equal @gemspec.version.to_s, Geb::VERSION
+
+  end
+
+end # class TestGebCommandVersion < Minitest::Test

data/test/support/geb_api_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+#
+# This is a Api test base class for Geb.  It provides a consistant setup and
+# teardown for API tests. Currently just stubs the Geb::log and Geb::log_start
+# as not to polute the test output with logging.
+#
+# @title Geb - Test Support - API Test
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class ApiTest < Minitest::Test
+
+    # Common setup logic
+    # redirects stdout and stderr to StringIO
+    # creates a temporary directory and changes to it
+    def setup
+
+      # suppress Geb logger output
+      Geb.stubs(:log)
+      Geb.stubs(:log_start)
+
+    end # def setup
+
+    # Common teardown logic
+    # redirects stdout and stderr back to their original state
+    # changes back to the original directory
+    def teardown
+
+    end # def teardown
+
+  end # class CliTest < Minitest::Test
+
+end # module Geb

data/test/support/geb_cli_test.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+#
+# This is a CLI test base class for Geb.  It provides a consistant setup and
+# teardown for CLI tests. Current setup and teardown handle the following
+# tasks:
+#  - It checks the version of the command being tested on the setup and asserts
+#    that the version number in Geb::Version is the same as running command `geb version`
+#  - Creates a temporary directory and changes to it, removes it after the test
+#  - Sets up a proxy server if the PROXY_PORT is defined, stops server after the test
+#
+# @title Geb - Test Support - CLI Test
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class CliTest < Minitest::Test
+
+    PROXY_PORT = 8888
+
+    # Common setup logic
+    # redirects stdout and stderr to StringIO
+    # creates a temporary directory and changes to it
+    def setup
+
+      # setup a temporary directory and change to it
+      @temp_dir = Dir.mktmpdir
+      @original_dir = Dir.pwd
+      Dir.chdir(@temp_dir)
+
+      # initialize the proxy instance
+      @proxy = nil
+
+      # make sure the version of the command being tested is the latest code version
+      assert_geb_command_version()
+
+    end # def setup
+
+    # Common teardown logic
+    # redirects stdout and stderr back to their original state
+    # changes back to the original directory
+    def teardown
+
+      Dir.chdir(@original_dir)
+      FileUtils.remove_entry @temp_dir
+
+      # stop the web server if it is defined and running
+      @proxy.stop if @proxy && @proxy.running?
+
+    end # def teardown
+
+    # Starts the proxy server if the PROXY_PORT is defined
+    def start_proxy
+
+      # start the proxy server only if the PROXY_PORT is defined
+      if PROXY_PORT
+
+        # start the web server
+        @proxy = Geb::Test::WebServerProxy.new(PROXY_PORT, debug: false)
+        @proxy.start
+
+      end # if PROXY_PORT
+
+      # return the proxy instance
+      return @proxy
+
+    end # def start_proxy
+
+    # copy the test site into the current directory
+    def copy_test_site
+
+        # get the test site path
+        test_site_path = File.expand_path(File.join(__dir__, '..', 'files/test-site'))
+
+        # copy the test site contents into the current directory
+        FileUtils.cp_r(File.join(test_site_path, '.'), Dir.pwd)
+
+    end # def copy_test_site
+
+    # compare the output of the command with the expected internal Geb version
+    def assert_geb_command_version
+
+      # call the geb version command and capture output and error
+      stdout, _, status = Open3.capture3("geb version")
+
+      # assert that the output contains the expected string
+      assert status.success?
+      assert_includes stdout, "Geb version #{Geb::VERSION}"
+
+    end # def assert_geb_command_version
+
+    # run the command with a timeout and a break condition, useful for testing
+    # processes that may hang or run indefinitely
+    # @param command [String] the command to run
+    # @param timeout [Integer] the timeout in seconds
+    # @param break_condition [Proc] a block that will be called with the output and error
+    # @yieldparam output [String] the output of the command
+    # @yieldparam error_output [String] the error output of the command
+    def run_command_with_timeout(command, timeout: 10, break_condition: nil, event: nil)
+
+      # initialize the output and error output
+      output, error_output = "", ""
+
+      # run the command with a timeout
+      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+
+        # lets make sure we can safely kill the command
+        begin
+
+          # initialize a flag indicating if the event was executed
+          event_executed = false
+
+          # Timeout the command after the specified time
+          Timeout.timeout(timeout) do
+
+            # read the output and error output until the break condition is met or the timeout is reached
+            loop do
+
+              # lets do this safely
+              begin
+
+                # read the output and error output
+                output        += stdout.read_nonblock(4028) rescue ""
+                error_output  += stderr.read_nonblock(4028) rescue ""
+
+                # call the event if it is defined and has not been executed
+                if event && !event_executed
+                  Thread.new do
+                    event_executed = event.call(output, error_output)
+                  end
+                end # if
+
+                # break if the break condition is met. call the break condition lambda
+                # passed in as parameter with the output and error output
+                break if break_condition && break_condition.call(output, error_output)
+
+              rescue IO::WaitReadable
+
+                # wait for the IO to be readable
+                IO.select([stdout, stderr])
+
+                retry
+
+              rescue EOFError
+
+                # break if the command has finished
+                break
+
+              end # begin rescue
+            end # loop
+          end # Timeout.timeout
+
+        ensure
+
+          # gracefully shutdown the process and wait for it to terminate
+          Process.kill("INT", wait_thr.pid)
+          wait_thr.value
+
+        end # begin ensure
+      end # Open3.popen3
+
+      # yield to the block if it is given and return the output and error output,
+      # this is where test assertions should be made
+      yield output, error_output if block_given?
+
+    end # def run_command_with_timeout
+
+
+    # run the command with a timeout and a break condition, useful for testing
+    # processes that may hang or run indefinitely
+    # @param command [String] the command to run
+    # @param timeout [Integer] the timeout in seconds
+    # @param break_condition [Proc] a block that will be called with the output and error
+    # @yieldparam output [String] the output of the command
+    # @yieldparam error_output [String] the error output of the command
+    def run_command_with_timeout2(command, timeout: 10, break_condition: nil, event: nil)
+
+      # initialize the output and error output
+      output, error_output = "", ""
+
+      # initialize a flag indicating if the event was executed
+      event_executed = false
+
+      # initialize a new mutex
+      mutex = Mutex.new
+
+      # initialise a condition variable for signaling
+      condition_variable = ConditionVariable.new
+
+      event_thread = Thread.new do
+        event.call
+      end
+
+      # run the command with within a thread
+      command_thread = Thread.new do
+
+        # run the command with a timeout
+        Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+
+          # lets make sure we can safely kill the command
+          begin
+
+            # Timeout the command after the specified time
+            Timeout.timeout(timeout) do
+
+              # read the output and error output until the break condition is met or the timeout is reached
+              loop do
+
+                # lets do this safely
+                begin
+
+                  # synchronize the mutex
+                  mutex.synchronize do
+
+                  # read the output and error output
+                    output        += stdout.read_nonblock(4028) rescue ""
+                    error_output  += stderr.read_nonblock(4028) rescue ""
+
+                  end # mutex.synchronize
+
+                  # break if the break condition is met. call the break condition lambda
+                  # passed in as parameter with the output and error output
+                  if break_condition && break_condition.call(output, error_output, event_executed)
+                    condition_variable.signal
+                    break
+                  end
+
+                rescue IO::WaitReadable
+
+                  # wait for the IO to be readable
+                  IO.select([stdout, stderr])
+
+                  retry
+
+                rescue EOFError
+
+                  # break if the command has finished
+                  break
+
+                end # begin rescue
+              end # loop
+              condition_variable.signal
+            end # Timeout.timeout
+
+          ensure
+
+            # gracefully shutdown the process and wait for it to terminate
+            Process.kill("INT", wait_thr.pid)
+            wait_thr.value
+
+          end # begin ensure
+        end # Open3.popen3
+
+      end # Thread.new
+
+       # wait for the thread to finish or timeout
+      mutex.synchronize do
+        unless condition_variable.wait(mutex, timeout)
+          # Timeout reached, kill the thread
+          Thread.kill(command_thread)
+          Thread.kill(event_thread)
+        end
+      end
+
+      # yield to the block if it is given and return the output and error output,
+      # this is where test assertions should be made
+      yield output, error_output if block_given?
+
+    end # def run_command_with_timeout
+
+  end # class CliTest < Minitest::Test
+
+end # module Geb

data/test/support/geb_minitest_ext.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# Minitest extensions for Geb, mostly syntax sugar for tests.
+#
+# @title Geb - Test Support - Minitest Extensions
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+
+# create some syntax sugar for the tests. It turns the default way to define tests as methods,
+# into a more readable form.
+# @example
+#
+# class TestSomething < Minitest::Test
+#
+#   # this is the default way to define a test
+#   def test_this_is_a_test
+#     assert true
+#   end
+#
+#   # isn't this better, this will be converted to test_this_is_a_test
+#   test "this is a test" do
+#     assert true
+#   end
+#
+# end
+#
+class Minitest::Test
+  def self.test(description, &block)
+    define_method("test_#{description.gsub(/\s+/, '_')}", &block)
+  end # def self.test
+end # class Minitest::Test

data/test/support/geb_test_helpers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+#
+# A collection of Geb test helper methods:
+#
+#  assert_stdout_match            - asserts that the standard output matches a pattern
+#  refute_stdout_match            - asserts that the standard output does not match a pattern
+#  assert_stderr_match            - asserts that the standard error matches a pattern
+#  refute_stderr_match            - asserts that the standard error does not match a pattern
+#  assert_cli_registered_command  - asserts that a command is registered in the CLI registry
+#  assert_cli_option              - asserts that a command has a specific option defined
+#  assert_folder_copied           - asserts that a folder has been copied to another folder
+#
+# @title Geb - Test Support - Test Helpers
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+
+def assert_stdout_match(p_match)
+
+  $stdout.rewind
+  output = $stdout.string
+  assert_match p_match, output
+
+end # def assert_stdout_match
+
+def refute_stdout_match(p_match)
+
+  $stdout.rewind
+  output = $stdout.string
+  refute_match p_match, output
+
+end # def refute_stdout_match
+
+def assert_stderr_match(p_match)
+
+  $stderr.rewind
+  output = $stderr.string
+  assert_match p_match, output
+
+end # def assert_stderr_match
+
+def refute_stderr_match(p_match)
+
+  $stderr.rewind
+  output = $stderr.string
+  refute_match p_match, output
+
+end # def refute_stderr_match
+
+def assert_cli_registered_command(p_registry, p_command, p_class)
+
+  command_lookup = p_registry.get([p_command])
+  assert command_lookup.found?, "Command '#{p_command}' should be registered"
+
+  assert_equal p_class, command_lookup.command
+
+end # def assert_cli_registered_command
+
+def assert_cli_option(p_command_class, p_option_name, p_type, p_default)
+
+  option = p_command_class.options.find { |o| o.name == p_option_name }
+  command_name = p_command_class.name.split("::").last
+
+  # make sure the option is defined
+  refute_nil    option,                     "#{command_name} command should have a #{p_option_name} option."
+  assert_equal  p_type, option.type,        "#{command_name} command #{p_option_name} option should be #{p_type}."
+  assert_equal  p_default, option.default,  "#{command_name} command #{p_option_name} option should default to #{p_default}." unless p_default.nil?
+  refute_nil    option.desc,                "#{command_name} command #{p_option_name} option should have a description."
+  refute_empty  option.desc,                "#{command_name} command #{p_option_name} option description should not be empty."
+
+end # def assert_cli_option
+
+# check if a folder has been copied to another folder
+def assert_folder_copied(folder_from, folder_to)
+
+  folder_from_entries = Dir.glob("#{folder_from}/**/*", File::FNM_DOTMATCH).map { |e| e.sub("#{folder_from}/", '') }.reject { |e| e == '.' || e == '..' }
+  folder_to_entries =   Dir.glob("#{folder_to}/**/*", File::FNM_DOTMATCH).map { |e| e.sub("#{folder_to}/", '') }.reject { |e| e == '.' || e == '..' }
+
+  assert (folder_from_entries - folder_to_entries).empty?
+
+end # def assert_folder_copied