geb 0.1.11

data/test/api tests/test_template.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+#
+# Tests the template class
+#
+# @title Geb - Test - Template
+# @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 TemplateTest < Geb::ApiTest
+
+  test "that template default initializes" do
+
+    template_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+    template_content = "This is a template file"
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(true)
+    File.stubs(:read).returns(template_content).once
+
+    template = Geb::Template.new(template_path)
+
+    assert_instance_of Geb::Template, template
+    assert_equal template.path, template_path
+    assert_equal template.content, template_content
+
+  end # test "that site default initializes"
+
+  test "that template constructor throws an error if the template file does not exist" do
+
+    template_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(false)
+
+    error = assert_raises Geb::Template::TemplateFileNotFound do
+      Geb::Template.new(template_path)
+    end
+
+    assert_includes error.message, "#{template_path}", "Error message does not include the template path"
+
+  end # test "that template constructor throws an error if the template file does not exist"
+
+  test "that template constructor throws an error if the template file cannot be read" do
+
+    template_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(true)
+    File.stubs(:read).raises(Errno::ENOENT)
+
+    assert_raises Geb::Template::TemplateFileReadFailure do
+      Geb::Template.new(template_path)
+    end
+
+  end # test "that template constructor throws an error if the template file cannot be read"
+
+  test "that self.load returns the template content when the template file exists" do
+
+    template_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+    template_content = "This is a template file"
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(true)
+    File.stubs(:read).returns(template_content)
+
+    template = Geb::Template.load(template_path)
+
+    assert_equal template_content, template.content
+
+  end # test "that self.load returns the template content when the template file exists"
+
+  test "that self.load returns a cached copy of the template if it was laoded previously" do
+
+    assert_empty Geb::Template.class_variable_set(:@@loaded_templates, {})
+
+    template_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+    template_content = "This is a template file"
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(true)
+    File.stubs(:read).returns(template_content).once
+
+    # assert the loaded_templates class variable is empty
+    assert_empty Geb::Template.class_variable_get(:@@loaded_templates)
+    template1 = Geb::Template.load(template_path)
+    assert_equal 1, Geb::Template.class_variable_get(:@@loaded_templates).length
+    template2 = Geb::Template.load(template_path)
+    assert_equal 1, Geb::Template.class_variable_get(:@@loaded_templates).length
+
+    assert_same template1, template2
+
+  end # test "that self.load returns a cached copy of the template if it was laoded previously"
+
+  test "that extract template path, finds the template path in the page content" do
+
+    # initalize the template path
+    original_template_path = "shared/templates/_site.html"
+
+    # generate multiline page content
+    page_content = <<-PAGE
+      <p>foobar</p>
+      <% template: #{original_template_path} %>
+      <p>foobar</p>
+    PAGE
+
+    template_path = Geb::Template.extract_template_path(page_content)
+
+    assert_equal original_template_path, template_path
+
+  end # test "that extract template path, finds the template path in the page content"
+
+  test "that extract template path, returns nil if no template path is found in the page content" do
+
+    # generate multiline page content
+    page_content = <<-PAGE
+      <p>foobar</p>
+      <p>foobar</p>
+    PAGE
+
+    template_path = Geb::Template.extract_template_path(page_content)
+
+    assert_nil template_path
+
+  end # test "that extract template path, returns nil if no template path is found in the page content"
+
+  test "that extract template path, returns the first entry when multiple template definitions are present" do
+
+    # initalize the template path
+    original_template_path = "shared/templates/_site.html"
+
+    # generate multiline page content
+    page_content = <<-PAGE
+      <p>foobar</p>
+      <% template: #{original_template_path} %>
+      <p>foobar</p>
+      <% template: shared/templates/_site2.html %>
+      <p>foobar</p>
+    PAGE
+
+    template_path = Geb::Template.extract_template_path(page_content)
+
+    assert_equal original_template_path, template_path
+
+  end # test "that extract template path, returns the first entry when multiple template definitions are present"
+
+  test "that extract sections for template, finds the sections in the page content" do
+
+    # initalize the sections
+    original_sections = {
+      "header" => "header content",
+      "footer" => "footer content"
+    }
+
+    # generate multiline page content
+    page_content = <<-PAGE
+      <p>foobar</p>
+      <% start: header %>
+      #{original_sections["header"]}
+      <% end: header %>
+      <p>foobar</p>
+      <% start: footer %>
+      #{original_sections["footer"]}
+      <% end: footer %>
+      <p>foobar</p>
+    PAGE
+
+    sections = Geb::Template.extract_sections_for_template(page_content)
+
+    assert_equal original_sections, sections
+
+  end # test "that extract sections for template, finds the sections in the page content"
+
+  test "that extract sections for template, returns an empty hash if no sections are found in the page content" do
+
+    # generate multiline page content
+    page_content = <<-PAGE
+      <p>foobar</p>
+      <p>foobar</p>
+    PAGE
+
+    sections = Geb::Template.extract_sections_for_template(page_content)
+
+    assert_empty sections
+
+  end # test "that extract sections for template, returns an empty hash if no sections are found in the page content"
+
+  test "that parse template, returns the template content and sections" do
+
+    original_template_path = "shared/templates/_site.html"
+
+    # initalize the sections
+    original_sections = {
+      "header" => "header content",
+      "footer" => "footer content"
+    }
+
+    # generate multiline template content
+    template_content = <<-TEMPLATEPAGE
+      <div class="header">
+      <%= insert: header %>
+      </div>
+      <div class="footer">
+      <%= insert: footer %>
+      </div>
+    TEMPLATEPAGE
+
+    parsed_template_content = <<-PARSEDTEMPLATEPAGE
+      <div class="header">
+      header content
+      </div>
+      <div class="footer">
+      footer content
+      </div>
+    PARSEDTEMPLATEPAGE
+
+    Geb::Template.any_instance.stubs(:template_file_exists?).returns(true)
+    File.stubs(:read).returns(template_content).once
+
+    template = Geb::Template.new(original_template_path)
+    output = template.parse(original_sections)
+
+    assert_equal parsed_template_content, output
+    refute_includes output, "<%= insert: header %>"
+    refute_includes output, "<%= insert: footer %>"
+
+  end # test "that parse template, returns the template content and sections"
+
+  test "that that template file exists method finds files" do
+
+    File.stubs(:read)
+
+    Dir.mktmpdir do |dir|
+
+      # generate a temporary file
+      file_path = File.join(dir, "template.html")
+      non_existent_file_path = File.join(dir, "non_existent_template.html")
+      File.write(file_path, "This is a template file")
+
+      Geb::Template.new(file_path)
+
+      assert_raises Geb::Template::TemplateFileNotFound do
+        Geb::Template.new(non_existent_file_path)
+      end # assert_raises
+
+    end # Dir.mktmpdir
+
+  end # test "that that template file exists method finds files"
+
+end # class TemplateTest < Geb::ApiTest

data/test/api tests/test_utilities.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+#
+# Tests the utilities class
+#
+# @title Geb - Test - Utilities
+# @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 UtilitiesTest < Minitest::Test
+
+  test "that Geb error raises a correct error message" do
+
+    # assert that the error message is correct
+    error = assert_raises(Geb::Error) do
+      raise Geb::Error.new("Custom Error", "Default Message")
+    end # assert_raises(Geb::Error)
+
+    assert_equal("Custom Error Default Message", error.message)
+
+  end # test "that Geb error raises a correct error message"
+
+  test "that log prints a message to the console and has a trailing newline" do
+
+      # setup a StringIO to capture standard output
+      original_stdout = $stdout
+      $stdout = StringIO.new
+
+      # call the log method
+      Geb.log("Test Message")
+
+      # assert that the message is correct
+      assert_equal("Test Message\n", $stdout.string)
+
+      # reset $stdout
+      $stdout = original_stdout
+
+  end # test "that log prints a message to the console and has a trailing newline"
+
+  test "that log_start prints a message to the console and does not have a trailing newline" do
+
+      # setup a StringIO to capture standard output
+      original_stdout = $stdout
+      $stdout = StringIO.new
+
+      # call the log method
+      Geb.log_start("Test Message")
+
+      # assert that the message is correct
+      assert_equal("Test Message", $stdout.string)
+
+      # reset $stdout
+      $stdout = original_stdout
+
+  end # test "that log_start prints a message to the console and does not have a trailing newline"
+
+  test "that logging can be suppressed" do
+
+    # setup a StringIO to capture standard output
+    original_stdout = $stdout
+    $stdout = StringIO.new
+
+    Geb.no_log do
+      Geb.log("Test Message")
+    end
+
+    assert_equal("", $stdout.string)
+
+    Geb.log("Test Message2")
+
+    assert_equal("Test Message2\n", $stdout.string)
+
+    # reset $stdout
+    $stdout = original_stdout
+
+  end # test "that logging can be suppressed"
+
+  test "that copy paths to directory copies files and directories to a destination directory" do
+
+    # initialize a temporary directory
+    Dir.mktmpdir do |tmpdir|
+
+      test_source_directory       = File.join(tmpdir, "source")
+      test_destination_directory  = File.join(tmpdir, "destination")
+      Dir.mkdir(test_source_directory)
+      Dir.mkdir(test_destination_directory)
+
+      file_paths = []
+      file_paths << File.join(test_source_directory, "folder1")
+      file_paths << File.join(test_source_directory, "folder2")
+      file_paths << File.join(test_source_directory, "folder2/subfolder1")
+      file_paths << File.join(test_source_directory, "folder2/subfolder2")
+      file_paths << File.join(test_source_directory, "file1.txt")
+      file_paths << File.join(test_source_directory, "file2.txt")
+      file_paths << File.join(test_source_directory, "folder2/file2-1.txt")
+      file_paths << File.join(test_source_directory, "folder2/file2-1.txt")
+      file_paths << File.join(test_source_directory, "folder2/subfolder2/files2-1-1.txt")
+      file_paths.each do |path|
+        if path !~ /\./
+          FileUtils.mkdir_p(path)
+        else
+          FileUtils.mkdir_p(File.dirname(path))
+          File.open(path, "w") do |file|
+            file.write("This is a dumny file path: #{path}")
+          end
+        end
+      end
+
+      Geb::copy_paths_to_directory(test_source_directory, file_paths, test_destination_directory, true)
+
+      file_paths.each do |path|
+        destination_path = path.gsub(test_source_directory, test_destination_directory)
+        if path !~ /\./
+          assert Dir.exist?(destination_path)
+        else
+          assert File.exist?(destination_path)
+        end
+      end
+
+    end # Dir.mktmpdir
+
+  end # test "that copy paths to directory copies files and directories to a destination directory"
+
+  test "that copy paths to directory raises an error if the file operations fail" do
+
+    # initialize a temporary directory
+    Dir.mktmpdir do |tmpdir|
+
+      test_source_directory       = File.join(tmpdir, "source")
+      test_destination_directory  = File.join(tmpdir, "destination")
+      Dir.mkdir(test_source_directory)
+      Dir.mkdir(test_destination_directory)
+
+      FileUtils.stubs(:mkdir_p).raises(Errno::EACCES)
+
+      file_paths = []
+      file_paths << File.join(test_source_directory, "folder1")
+      file_paths << File.join(test_source_directory, "folder2")
+      file_paths << File.join(test_source_directory, "folder2/subfolder1")
+      file_paths << File.join(test_source_directory, "folder2/subfolder2")
+      file_paths << File.join(test_source_directory, "file1.txt")
+      file_paths << File.join(test_source_directory, "file2.txt")
+      file_paths << File.join(test_source_directory, "folder2/file2-1.txt")
+      file_paths << File.join(test_source_directory, "folder2/file2-1.txt")
+      file_paths << File.join(test_source_directory, "folder2/subfolder2/files2-1-1.txt")
+
+      error = assert_raises(Geb::Error) do
+        Geb::copy_paths_to_directory(test_source_directory, file_paths, test_destination_directory, true)
+      end
+
+      assert_includes error.message, "Permission denied"
+      assert_includes error.message, "Failed to copy paths to directory"
+
+    end # Dir.mktmpdir
+
+  end # test "that copy paths to directory raises an error if the file operations fail"
+
+end # class UtilitiesTest < Geb::ApiTest

data/test/command tests/test_geb_build.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+#
+# Tests the build command class
+#
+# @title Geb - Test - Build 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 TestGebCommandBuild < Geb::CliTest
+
+  test "that the CLI api call works" do
+
+    copy_test_site()
+
+    command = Geb::CLI::Commands::Build.new
+
+    command_options = { skip_assets: false, skip_pages: false }
+
+    site_mock = mock('site')
+    site_mock.expects(:load).with(Dir.pwd)
+    site_mock.expects(:build_assets)
+    site_mock.expects(:build_pages)
+
+    Geb::Site.expects(:new).returns(site_mock)
+
+    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 the CLI api call works with skip_assets and skip_pages" do
+
+    copy_test_site()
+
+    command = Geb::CLI::Commands::Build.new
+
+    command_options = { skip_assets: true, skip_pages: true }
+
+    site_mock = mock('site')
+    site_mock.expects(:load).with(Dir.pwd)
+    site_mock.expects(:build_assets).never
+    site_mock.expects(:build_pages).never
+
+    Geb::Site.expects(:new).returns(site_mock)
+
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    command.call(**command_options)
+
+    assert_empty $stderr.string
+
+    assert_includes $stdout.string, "Skipping building pages as told"
+    assert_includes $stdout.string, "Skipping building assets as told"
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the CLI api call works with skip_assets and skip_pages"
+
+  test "that the CLI api call works and handles exceptions" do
+
+    # initialize new command instance
+    command = Geb::CLI::Commands::Build.new
+
+    command_options = { skip_assets: false, skip_pages: false }
+
+    Geb::Site.expects(:new).raises(Geb::Error.new("Test Error"))
+
+    # setup a StringIO to capture standard output and error
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    command.call(**command_options)
+
+    refute_empty $stderr.string
+    assert_includes $stderr.string, "Test Error"
+
+    $stdout = original_stdout
+    $stderr = original_stderr
+
+  end # test "that the CLI api call works and handles exceptions"
+
+  test "that command default executes" do
+
+    copy_test_site()
+
+    # call geb auto command and capture output and error
+    _, stderr, status = Open3.capture3('geb build')
+
+    # assert that the output contains the expected string
+    assert status.success?
+    assert_empty stderr
+
+  end # test "command line"
+
+  test "that command handles being executed in a non-site directory" do
+
+    # create a temporary directory
+    Dir.mktmpdir do |dir|
+
+      Dir.chdir(dir)
+
+      _, stderr, status = Open3.capture3('geb build')
+
+      assert status.success?
+      refute_empty stderr
+
+    end # Dir.mktmpdir
+
+  end # test "that command handles being executed in a non-site directory"
+
+  test "that command handles being executed with skip pages option" do
+
+    copy_test_site()
+
+    stdout, stderr, status = Open3.capture3('geb build --skip-pages')
+
+    assert status.success?
+    assert_empty stderr
+
+    assert_includes stdout, "Skipping building pages as told"
+
+  end # test "that command handles being executed with skip pages option"
+
+  test "that command handles being executed with skip assets option" do
+
+    copy_test_site()
+
+    stdout, stderr, status = Open3.capture3('geb build --skip-assets')
+
+    assert status.success?
+    assert_empty stderr
+
+    assert_includes stdout, "Skipping building assets as told"
+
+  end # test "that command handles being executed with skip assets option"
+
+  test "that command handles being executed with skip pages and skip assets options" do
+
+    copy_test_site()
+
+    stdout, stderr, status = Open3.capture3('geb build --skip-pages --skip-assets')
+
+    assert status.success?
+    assert_empty stderr
+
+    assert_includes stdout, "Skipping building pages as told"
+    assert_includes stdout, "Skipping building assets as told"
+    assert_includes stdout, "You told me to skip everything, so I did."
+
+  end # test "that command handles being executed with skip pages and skip assets options"
+
+  test "that the command actually builds the site" do
+
+    copy_test_site()
+
+    stdout, stderr, status = Open3.capture3('geb build')
+
+    assert status.success?
+    assert_empty stderr
+
+    assert_includes stdout, "Loading site from path #{Dir.pwd} ... done."
+    assert_includes stdout, "Found geb site at path #{Dir.pwd}"
+    assert_match(/Building \d* pages for/, stdout)
+    assert_includes stdout, "loading page"
+    assert_includes stdout, "loading template"
+    assert_includes stdout, "loading partial"
+    assert_includes stdout, "building page"
+    assert_match(/Done building \d* pages for/, stdout)
+    assert_includes stdout, "Clearing site output folder"
+    assert_includes stdout, "Outputting site to"
+    assert_includes stdout, "Building assets for"
+    assert_includes stdout, "Done building assets for"
+
+  end # test "that the command actually builds the site"
+
+end # class TestGebCommandBuild < Minitest::Test