diff_tests.mq

include "test"
| include "diff"
|

# -- diff_lines --

def test_diff_lines_no_changes():
  let r = diff_lines("a\nb\nc", "a\nb\nc")
  | assert_false(has_changes(r))
end

def test_diff_lines_replace():
  let r = diff_lines("a\nb\nc", "a\nx\nc")
  | assert_eq(added(r), ["x"])
  | assert_eq(removed(r), ["b"])
  | assert_eq(unchanged(r), ["a", "c"])
end

def test_diff_lines_insert_only():
  let r = diff_lines("a\nb", "a\nb\nc")
  | assert_eq(added(r), ["c"])
  | assert_eq(removed(r), [])
end

def test_diff_lines_delete_only():
  let r = diff_lines("a\nb\nc", "a\nc")
  | assert_eq(removed(r), ["b"])
  | assert_eq(added(r), [])
end

# -- diff_words --

def test_diff_words_replace():
  let r = diff_words("the quick fox", "the slow fox")
  | assert_eq(added(r), ["slow"])
  | assert_eq(removed(r), ["quick"])
  | assert_eq(unchanged(r), ["the", "fox"])
end

def test_diff_words_collapses_whitespace():
  let r = diff_words("a   b", "a b")
  | assert_false(has_changes(r))
end

# -- diff_chars --

def test_diff_chars_replace():
  let r = diff_chars("cat", "cut")
  | assert_eq(removed(r), ["a"])
  | assert_eq(added(r), ["u"])
end

# -- diff_array --

def test_diff_array_numbers():
  let r = diff_array([1, 2, 3], [1, 4, 3])
  | assert_eq(removed(r), [2])
  | assert_eq(added(r), [4])
end

def test_diff_array_empty_inputs():
  let r = diff_array([], [])
  | assert_false(has_changes(r))
  | assert_eq(r, [])
end

# -- predicates --

def test_is_equal():
  assert_true(is_equal({"tag": "equal", "value": "x"}))
  | assert_false(is_equal({"tag": "insert", "value": "x"}))
end

def test_is_added():
  assert_true(is_added({"tag": "insert", "value": "x"}))
  | assert_false(is_added({"tag": "delete", "value": "x"}))
end

def test_is_removed():
  assert_true(is_removed({"tag": "delete", "value": "x"}))
  | assert_false(is_removed({"tag": "insert", "value": "x"}))
end

# -- stat --

def test_stat():
  let r = diff_lines("a\nb\nc", "a\nx\nc")
  | let s = stat(r)
  | assert_eq(s["added"], 1)
  | assert_eq(s["removed"], 1)
  | assert_eq(s["unchanged"], 2)
end

# -- rendering --

def test_to_unified():
  let r = diff_lines("a\nb", "a\nx")
  | assert_eq(to_unified(r), "  a\n- b\n+ x")
end

def test_to_unified_no_changes():
  let r = diff_lines("a\nb", "a\nb")
  | assert_eq(to_unified(r), "  a\n  b")
end

def test_to_markdown_wraps_in_diff_fence():
  let r = diff_lines("a", "b")
  | let out = to_markdown_string(to_markdown(r))
  | assert_true(contains(out, "```diff"))
  | assert_true(contains(out, "- a"))
  | assert_true(contains(out, "+ b"))
end