Add --force protection and EXE tests

Author: schneems

CHANGELOG.md

@@ -1,5 +1,6 @@
 ## HEAD
 
+- Change: Non-empty directories for success or failure paths will now halt execution unless `--force` is used
 - Change: The CLI command `rundoc build --path <path>` is now `rundoc <path>`
 - Change: `rundoc.depend_on` is removed in favor of `:::-- rundoc.require` (https://github.com/zombocom/rundoc/pull/58)
 - Change: `Rundoc.project_root=` is removed, please use `Rundoc.after_build` instead (https://github.com/zombocom/rundoc/pull/58)

CONTRIBUTING.md

@@ -21,5 +21,5 @@ $ bundle exec standardrb
 ## Run the local cli
 
 ```
-$ bin/rundoc build --path <path/to/rundoc.md>
+$ bin/rundoc <path/to/rundoc.md>
 ```

lib/rundoc/cli.rb

@@ -10,21 +10,24 @@ module DEFAULTS
       OUTPUT_FILENAME = "README.md"
       SCREENSHOTS_DIR = "screenshots"
     end
-    attr_reader :io, :on_success_dir, :on_failure_dir, :dotenv_path, :cli_cmd, :cli_args
+
+    attr_reader :io, :on_success_dir, :on_failure_dir, :dotenv_path, :cli_cmd, :cli_args, :force
     attr_reader :execution_context, :after_build_context
 
     def initialize(
       source_path:,
       io: $stderr,
       cli_cmd: $0,
       cli_args: $*,
+      force: false,
       dotenv_path: nil,
       on_success_dir: nil,
       on_failure_dir: nil,
       output_filename: nil,
       screenshots_dir: nil
     )
       @io = io
+      @force = force
       @cli_cmd = cli_cmd
       @cli_args = cli_args
 
@@ -62,6 +65,10 @@ def initialize(
       end
     end
 
+    def force?
+      self.force
+    end
+
     # Ensures that the value passed in cannot escape the current directory
     #
     # Examples:
@@ -108,13 +115,30 @@ def prepend_cli_banner(contents)
       HEREDOC
     end
 
+    def check_directories_empty!
+      [on_success_dir, on_failure_dir].each do |dir|
+        dir.mkpath
+
+        next if Dir.empty?(dir)
+
+        if force?
+          io.puts "## WARNING: #{dir} is not empty, it may be cleared due to running with the `--force` flag"
+        else
+          raise "## ABORTING: #{dir} is not empty, clear it or re-run with `--force` flag"
+        end
+      end
+    end
+
     def call
       io.puts "## Running your docs"
       load_dotenv
+      check_directories_empty!
 
       source_contents = execution_context.source_path.read
-      io.puts "## Clearing on failure directory #{on_failure_dir}"
-      FileUtils.remove_entry_secure(on_failure_dir) if on_failure_dir.exist?
+      if on_failure_dir.exist? && !Dir.empty?(on_failure_dir)
+        io.puts "## Clearing on failure directory #{on_failure_dir}"
+        FileUtils.remove_entry_secure(on_failure_dir)
+      end
 
       io.puts "## Working dir is #{execution_context.output_dir}"
       Dir.chdir(execution_context.output_dir) do
@@ -147,7 +171,7 @@ def call
     end
 
     private def on_fail
-      io.puts "## Rundoc failed, debug contents are in #{on_failure_dir}"
+      io.puts "## Failed, debug contents are in #{on_failure_dir}"
       on_failure_dir.mkpath
 
       copy_dir_contents(
@@ -157,7 +181,7 @@ def call
     end
 
     private def on_success(output)
-      io.puts "## Rundoc was successful, sanitizing output"
+      io.puts "## Success! sanitizing output"
       Rundoc.sanitize!(output)
       output = prepend_cli_banner(output)
 
@@ -184,7 +208,7 @@ def call
         to: on_success_dir
       )
 
-      io.puts "## RUNdoc is done"
+      io.puts "## Finished"
     end
 
     def copy_dir_contents(from:, to:)

lib/rundoc/cli_argument_parser.rb

@@ -131,6 +131,10 @@ def to_cli
         opts.on("--dotenv-path <path>", "Path to a `.env` file to load environment variable, relative to current working directory.") do |v|
           options[:dotenv_path] = v
         end
+
+        opts.on("--force", "Delete contents of the success/failure dirs even if they're not empty") do |v|
+          options[:force] = v
+        end
       end
     end
   end

test/integration/after_build_test.rb

@@ -25,6 +25,8 @@ def test_modifies_directory_structure
         assert dir.join("project").join("lol").exist?
         assert dir.join("project").join("lol").join("rofl.txt").exist?
 
+        FileUtils.remove_entry_secure(dir.join("project"))
+
         source_path.write <<~EOF
           ```
           :::-- rundoc.configure

test/system/exe_cli_test.rb

@@ -5,6 +5,185 @@ def exe_path
     root_dir.join("bin").join("rundoc")
   end
 
+  def test_help
+    output = run!("#{exe_path} --help")
+    assert output.include?("Usage:")
+  end
+
+  def test_force_fail_dir_protection
+    Dir.mktmpdir do |dir|
+      key = SecureRandom.hex
+      dir = Pathname(dir)
+      rundoc = dir.join("RUNDOC.md")
+      rundoc.write "Done"
+
+      not_empty = dir.join("tmp").tap(&:mkpath).join("not_empty.txt")
+      not_empty.write("Not empty")
+
+      run!("#{exe_path} #{rundoc}", raise_on_nonzero_exit: false)
+      assert !$?.success?
+
+      assert not_empty.exist?
+
+      run!("#{exe_path} #{rundoc} --force", raise_on_nonzero_exit: false)
+      assert $?.success?
+      assert !not_empty.exist?
+    end
+  end
+
+  def test_force_success_dir_protection
+    Dir.mktmpdir do |dir|
+      key = SecureRandom.hex
+      dir = Pathname(dir)
+
+      rundoc = dir.join("RUNDOC.md")
+      rundoc.write "Done"
+
+      not_empty = dir.join("project").tap(&:mkpath).join("not_empty.txt")
+      not_empty.write("Not empty")
+
+      run!("#{exe_path} #{rundoc}", raise_on_nonzero_exit: false)
+      assert !$?.success?
+
+      assert not_empty.exist?
+
+      run!("#{exe_path} #{rundoc} --force", raise_on_nonzero_exit: false)
+      assert $?.success?
+      assert !not_empty.exist?
+    end
+  end
+
+  def test_dotenv
+    Dir.mktmpdir do |dir|
+      key = SecureRandom.hex
+      dir = Pathname(dir)
+      dotenv = dir.join("another").join("directory").tap(&:mkpath).join(".env")
+
+      dotenv.write <<~EOF
+        FLORP="#{key}"
+      EOF
+
+      rundoc = dir.join("RUNDOC.md")
+      rundoc.write <<~EOF
+        ```
+        :::>> $ echo $FLORP
+        ```
+      EOF
+
+      run!("#{exe_path} #{rundoc} --dotenv-path #{dotenv}")
+
+      readme = dir.join("project")
+        .tap {|p| assert p.exist? }
+        .join("README.md")
+        .tap {|p| assert p.exist? }
+
+      actual = strip_autogen_warning(readme.read)
+      expected = <<~EOF
+        ```
+        $ echo $FLORP
+        #{key}
+        ```
+      EOF
+      assert_equal expected.strip, actual.strip
+    end
+  end
+
+  def test_screenshots_dir
+    Dir.mktmpdir do |dir|
+      dir = Pathname(dir)
+      rundoc = dir.join("RUNDOC.md")
+      screenshots_dirname = "lol_screenshots"
+      rundoc.write <<~EOF
+        ```
+        :::>> website.visit(name: "example", url: "http://example.com")
+        :::>> website.screenshot(name: "example")
+        ```
+      EOF
+
+      run!("#{exe_path} #{rundoc} --screenshots-dir #{screenshots_dirname}")
+
+      screenshots_dir = dir.join("project")
+        .tap {|p| assert p.exist? }
+        .join(screenshots_dirname)
+        .tap {|p| assert p.exist? }
+
+
+      readme = dir.join("project").join("README.md").read
+      actual = strip_autogen_warning(readme)
+
+      expected = "![Screenshot of http://example.com/](#{screenshots_dirname}/screenshot_1.png)"
+      assert_equal expected, actual.strip
+    end
+  end
+
+  def test_output_filename
+    Dir.mktmpdir do |dir|
+      dir = Pathname(dir)
+      rundoc = dir.join("RUNDOC.md")
+      failure_dir = dir.join("lol")
+      rundoc.write "Done"
+
+      assert !failure_dir.exist?
+
+      run!("#{exe_path} #{rundoc} --output-filename tutorial.md")
+
+      tutorial_md = dir.join("project")
+        .tap {|p| assert p.exist? }
+        .join("tutorial.md")
+        .tap {|p| assert p.exist? }
+
+      actual = strip_autogen_warning(tutorial_md.read)
+      expected = "Done"
+
+      assert_equal expected.strip, actual.strip
+    end
+  end
+
+  def test_on_failure_dir
+    Dir.mktmpdir do |dir|
+      dir = Pathname(dir)
+      rundoc = dir.join("RUNDOC.md")
+      failure_dir = dir.join("lol")
+      rundoc.write <<~EOF
+        ```
+        :::>> $ touch lol.txt
+        :::>> $ echo "hello world" && exit 1
+        ```
+      EOF
+
+      assert !failure_dir.exist?
+
+      run!("#{exe_path} #{rundoc} --on-failure-dir #{failure_dir}", raise_on_nonzero_exit: false)
+      assert !$?.success?
+
+      assert failure_dir.exist?
+      assert !Dir.exist?(dir.join("tmp"))
+      assert failure_dir.join("lol.txt").exist?
+    end
+  end
+
+  def test_on_success_dir
+    Dir.mktmpdir do |dir|
+      dir = Pathname(dir)
+      rundoc = dir.join("RUNDOC.md")
+      success_dir = dir.join("lol")
+      rundoc.write "Done"
+
+      assert !success_dir.exist?
+      run!("#{exe_path} #{rundoc} --on-success-dir #{success_dir}")
+
+      assert success_dir.exist?
+      assert !Dir.exist?(dir.join("project"))
+
+      readme = success_dir.join("README.md")
+      actual = strip_autogen_warning(readme.read)
+      expected = "Done"
+
+      assert_equal expected.strip, actual.strip
+    end
+  end
+
+
   def test_simple_file
     Dir.mktmpdir do |dir|
       dir = Pathname(dir)