# frozen_string_literal: true
require File.expand_path("../helper", __FILE__)
require "fileutils"

class TestRakeTask < Rake::TestCase # :nodoc:
  include Rake

  def setup
    super

    Task.clear
    Rake::TaskManager.record_task_metadata = true
  end

  def teardown
    Rake::TaskManager.record_task_metadata = false
    Rake.application.thread_pool.join

    super
  end

  def test_create
    arg = nil
    t = task(:name) { |task| arg = task; 1234 }
    assert_equal "name", t.name
    assert_equal [], t.prerequisites
    assert t.needed?
    t.execute(0)
    assert_equal t, arg
    assert_nil t.source
    assert_equal [], t.sources
    assert_equal 1, t.locations.size
    assert_match(/#{Regexp.quote(__FILE__)}/, t.locations.first)
  end

  def test_inspect
    t = task(foo: [:bar, :baz])
    assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
  end

  def test_invoke
    runlist = []
    t1 = task(t1: [:t2, :t3]) { |t| runlist << t.name; 3321 }
    task(:t2) { |t| runlist << t.name }
    task(:t3) { |t| runlist << t.name }
    assert_equal ["t2", "t3"], t1.prerequisites
    t1.invoke
    assert_equal ["t2", "t3", "t1"], runlist
  end

  def test_invoke_with_circular_dependencies
    runlist = []
    t1 = task(t1: [:t2]) { |t| runlist << t.name; 3321 }
    t2 = task(t2: [:t1]) { |t| runlist << t.name }
    assert_equal ["t2"], t1.prerequisites
    assert_equal ["t1"], t2.prerequisites
    ex = assert_raises RuntimeError do
      t1.invoke
    end
    assert_match(/circular dependency/i, ex.message)
    assert_match(/t1 => t2 => t1/, ex.message)
  end

  def test_dry_run_prevents_actions
    runlist = []
    t1 = task(:t1) { |t| runlist << t.name; 3321 }
    _, err = capture_output {
      Rake.application.set_default_options # reset trace output IO
      Rake.application.options.dryrun = true

      t1.invoke
    }
    assert_match(/execute .*t1/i, err)
    assert_match(/dry run/i, err)
    refute_match(/invoke/i, err)
    assert_equal [], runlist
  ensure
    Rake.application.options.dryrun = false
  end

  def test_tasks_can_be_traced
    t1 = task(:t1)
    _, err = capture_output {
      Rake.application.set_default_options # reset trace output IO
      Rake.application.options.trace = true

      t1.invoke
    }
    assert_match(/invoke t1/i, err)
    assert_match(/execute t1/i, err)
  ensure
    Rake.application.options.trace = false
  end

  def test_no_double_invoke
    runlist = []
    t1 = task(t1: [:t2, :t3]) { |t| runlist << t.name; 3321 }
    task(t2: [:t3]) { |t| runlist << t.name }
    task(:t3) { |t| runlist << t.name }
    t1.invoke
    assert_equal ["t3", "t2", "t1"], runlist
  end

  def test_already_invoked
    t1 = task(:t1) {}
    assert_equal false, t1.already_invoked
    t1.invoke
    assert_equal true, t1.already_invoked
  end

  def test_can_double_invoke_with_reenable
    runlist = []
    t1 = task(:t1) { |t| runlist << t.name }
    t1.invoke
    t1.reenable
    t1.invoke
    assert_equal ["t1", "t1"], runlist
  end

  def test_can_triple_invoke_after_exception_with_reenable
    raise_exception = true
    invoked         = 0

    t1 = task(:t1) do |t|
      invoked += 1
      next if !raise_exception

      raise_exception = false
      raise "Some error"
    end

    assert_raises(RuntimeError) { t1.invoke }
    assert_equal 1, invoked

    t1.reenable

    # actually invoke second time
    t1.invoke
    assert_equal 2, invoked

    # recognize already invoked and
    # don't raise pre-reenable exception
    t1.invoke
    assert_equal 2, invoked
  end

  def test_clear
    desc "a task"
    t = task("t", ["b"] => "a") {}
    t.clear
    assert t.prerequisites.empty?, "prerequisites should be empty"
    assert t.actions.empty?, "actions should be empty"
    assert_nil t.comment, "comments should be empty"
    assert_empty t.arg_names, "arg names should be empty"
  end

  def test_clear_prerequisites
    t = task("t" => ["a", "b"])
    assert_equal ["a", "b"], t.prerequisites
    t.clear_prerequisites
    assert_equal [], t.prerequisites
  end

  def test_clear_actions
    t = task("t") {}
    t.clear_actions
    assert t.actions.empty?, "actions should be empty"
  end

  def test_clear_comments
    desc "the original foo"
    task foo: [:x] do
      # Dummy action
    end

    task(:foo).clear_comments

    desc "a slightly different foo"
    task :foo

    assert_equal "a slightly different foo", task(:foo).comment
    assert_equal ["x"], task(:foo).prerequisites
    assert_equal 1, task(:foo).actions.size
  end

  def test_clear_args
    task :foo, [:x] do
      # Dummy action
    end

    task(:foo).clear_args

    task :foo

    assert_empty task(:foo).arg_names
  end

  def test_find
    task :tfind
    assert_equal "tfind", Task[:tfind].name
    ex = assert_raises(RuntimeError) { Task[:leaves] }
    assert_equal "Don't know how to build task 'leaves'" \
      " (See the list of available tasks with `rake --tasks`)", ex.message
  end

  def test_defined
    assert ! Task.task_defined?(:a)
    task :a
    assert Task.task_defined?(:a)
  end

  def test_multi_invocations
    runs = []
    p = proc do |t| runs << t.name end
    task({ t1: [:t2, :t3] }, &p)
    task({ t2: [:t3] }, &p)
    task(:t3, &p)
    Task[:t1].invoke
    assert_equal ["t1", "t2", "t3"], runs.sort
  end

  def test_task_list
    task :t2
    task t1: [:t2]
    assert_equal ["t1", "t2"], Task.tasks.map(&:name)
  end

  def test_task_gives_name_on_to_s
    task :abc
    assert_equal "abc", Task[:abc].to_s
  end

  def test_symbols_can_be_prerequisites
    task a: :b
    assert_equal ["b"], Task[:a].prerequisites
  end

  def test_strings_can_be_prerequisites
    task a: "b"
    assert_equal ["b"], Task[:a].prerequisites
  end

  def test_arrays_can_be_prerequisites
    task a: ["b", "c"]
    assert_equal ["b", "c"], Task[:a].prerequisites
  end

  def test_filelists_can_be_prerequisites
    task a: FileList.new.include("b", "c")
    assert_equal ["b", "c"], Task[:a].prerequisites
  end

  def test_prerequisite_tasks_returns_tasks_not_strings
    a = task a: ["b", "c"]
    b = task :b
    c = task :c
    assert_equal [b, c], a.prerequisite_tasks
  end

  def test_prerequisite_tasks_fails_if_prerequisites_are_undefined
    a = task a: ["b", "c"]
    task :b
    assert_raises(RuntimeError) do
      a.prerequisite_tasks
    end
  end

  def test_prerequisite_tasks_honors_namespaces
    task :b
    a = b = nil
    namespace "X" do
      a = task a: ["b", "c"]
      b = task :b
    end
    c = task :c

    assert_equal [b, c], a.prerequisite_tasks
  end

  def test_prerequisite_tasks_finds_tasks_with_same_name_outside_namespace
    b1 = nil
    namespace "a" do
      b1 = task b: "b"
    end
    b2 = task :b

    assert_equal [b2], b1.prerequisite_tasks
  end

  def test_prerequisite_tasks_in_nested_namespaces
    m = task :m
    a_c_m = a_b_m = a_m = nil
    namespace "a" do
      a_m = task :m

      namespace "b" do
        a_b_m = task m: "m"
      end

      namespace "c" do
        a_c_m = task m: "a:m"
      end
    end

    assert_equal [m], a_b_m.prerequisite_tasks
    assert_equal [a_m], a_c_m.prerequisite_tasks
  end

  def test_all_prerequisite_tasks_includes_all_prerequisites
    a = task a: "b"
    b = task b: ["c", "d"]
    c = task c: "e"
    d = task :d
    e = task :e

    assert_equal [b, c, d, e], a.all_prerequisite_tasks.sort_by { |t| t.name }
  end

  def test_all_prerequisite_tasks_does_not_include_duplicates
    a = task a: ["b", "c"]
    b = task b: "c"
    c = task :c

    assert_equal [b, c], a.all_prerequisite_tasks.sort_by { |t| t.name }
  end

  def test_all_prerequisite_tasks_includes_self_on_cyclic_dependencies
    a = task a: "b"
    b = task b: "a"

    assert_equal [a, b], a.all_prerequisite_tasks.sort_by { |t| t.name }
  end

  def test_timestamp_returns_now_if_all_prereqs_have_no_times
    a = task a: ["b", "c"]
    task :b
    task :c

    assert_in_delta Time.now, a.timestamp, 0.1, "computer too slow?"
  end

  def test_timestamp_returns_latest_prereq_timestamp
    a = task a: ["b", "c"]
    b = task :b
    c = task :c

    now = Time.now
    def b.timestamp() Time.now + 10 end
    def c.timestamp() Time.now + 5 end

    assert_in_delta now, a.timestamp, 0.1, "computer too slow?"
  end

  def test_always_multitask
    mx = Mutex.new
    result = []

    t_a = task(:a) do |t|
      sleep 0.2
      mx.synchronize { result << t.name }
    end

    t_b = task(:b) do |t|
      mx.synchronize { result << t.name }
    end

    t_c = task(c: [:a, :b]) do |t|
      mx.synchronize { result << t.name }
    end

    t_c.invoke

    # task should always run in order
    assert_equal ["a", "b", "c"], result

    [t_a, t_b, t_c].each(&:reenable)
    result.clear

    Rake.application.options.always_multitask = true
    t_c.invoke

    # with multitask, task 'b' should grab the mutex first
    assert_equal ["b", "a", "c"], result
  end

  def test_investigation_output
    t1 = task(t1: [:t2, :t3]) { |t| runlist << t.name; 3321 }
    task(:t2)
    task(:t3)
    out = t1.investigation
    assert_match(/class:\s*Rake::Task/, out)
    assert_match(/needed:\s*true/, out)
    assert_match(/pre-requisites:\s*--t[23]/, out)
  end

  # NOTE: Rail-ties uses comment=.
  def test_comment_setting
    t = task(:t, :name, :rev)
    t.comment = "A Comment"
    assert_equal "A Comment", t.comment
  end

  def test_comments_with_sentences_period
    desc "Comment 1. Comment 2."
    t = task(:t, :name, :rev)
    assert_equal "Comment 1", t.comment
  end

  def test_comments_with_sentences_exclamation_mark
    desc "An exclamation mark! Comment."
    t = task(:t, :name, :rev)
    assert_equal "An exclamation mark", t.comment
  end

  def test_comments_with_many_periods
    desc "This is a test...I think ... testing. Comment."
    t = task(:t, :name, :rev)
    assert_equal "This is a test...I think ... testing", t.comment
  end

  def test_comments_with_tabbed_sentences
    desc "Comment 1.\tComment 2."
    t = task(:t, :name, :rev)
    assert_equal "Comment 1", t.comment
  end

  def test_comments_with_decimal_points
    desc "Revision 1.2.3."
    t = task(:t, :name, :rev)
    assert_equal "Revision 1.2.3", t.comment
  end

  def test_comments_do_not_set
    t = task(:t, :name, :rev)
    assert_nil t.comment
  end

  def test_comments_is_nil
    t = task(:t, :name, :rev)
    t.comment = nil
    assert_nil t.comment
  end

  def test_extended_comments
    desc %{
      This is a comment.

      And this is the extended comment.
      name -- Name of task to execute.
      rev  -- Software revision to use.
    }
    t = task(:t, :name, :rev)
    assert_equal "[name,rev]", t.arg_description
    assert_equal "This is a comment", t.comment
    assert_match(/^\s*name -- Name/, t.full_comment)
    assert_match(/^\s*rev  -- Software/, t.full_comment)
    assert_match(/\A\s*This is a comment\.$/, t.full_comment)
  end

  def test_multiple_comments
    desc "line one"
    t = task(:t)
    desc "line two"
    task(:t)
    assert_equal "line one / line two", t.comment
  end

  def test_duplicate_comments
    desc "line one"
    t = task(:t)
    desc "line one"
    task(:t)
    assert_equal "line one", t.comment
  end

  def test_interspersed_duplicate_comments
    desc "line one"
    t = task(:t)
    desc "line two"
    task(:t)
    desc "line one"
    task(:t)
    assert_equal "line one / line two", t.comment
  end

  def test_source_is_first_prerequisite
    t = task t: ["preqA", "preqB"]
    assert_equal "preqA", t.source
  end

  def test_suggests_valid_rake_task_names
    task :test
    error = assert_raises(RuntimeError) { Task[:testt] }

    assert_match(/Don\'t know how to build task \'testt\'/, error.message)

    if defined?(::DidYouMean::SpellChecker) && defined?(::DidYouMean::Formatter)
      assert_match(/Did you mean\?  test/, error.message)
    end
  end

  def test_prereqs
    t = task(a: %w[b c d e])
    assert_equal %w[b c d e], t.prereqs
  end
end