Coverage for tests / cli / test_init_command.py: 100%

1"""Tests for the init command.""" 

2 

3from pathlib import Path 

4 

5from assertpy import assert_that 

6from click.testing import CliRunner 

7 

8from lintro.cli import cli 

9from lintro.cli_utils.commands.init import init_command 

10 

11 

12def test_init_command_help() -> None: 

13 """Test that init command displays help.""" 

14 runner = CliRunner() 

15 result = runner.invoke(cli, ["init", "--help"]) 

16 assert_that(result.exit_code).is_equal_to(0) 

17 assert_that(result.output).contains("Initialize Lintro configuration") 

18 assert_that(result.output).contains("--with-native-configs") 

19 

20 

21def test_init_creates_minimal_config() -> None: 

22 """Test that init --minimal creates minimal config.""" 

23 runner = CliRunner() 

24 with runner.isolated_filesystem(): 

25 result = runner.invoke(init_command, ["--minimal"]) 

26 assert_that(result.exit_code).is_equal_to(0) 

27 assert_that(Path(".lintro-config.yaml").exists()).is_true() 

28 

29 content = Path(".lintro-config.yaml").read_text() 

30 assert_that(content).contains("line_length: 88") 

31 # Minimal config should be shorter 

32 assert_that(len(content)).is_less_than(500) 

33 

34 

35def test_init_overwrites_with_force() -> None: 

36 """Test that init --force overwrites existing config.""" 

37 runner = CliRunner() 

38 with runner.isolated_filesystem(): 

39 # Create existing config 

40 Path(".lintro-config.yaml").write_text("existing: true") 

41 

42 result = runner.invoke(init_command, ["--force"]) 

43 assert_that(result.exit_code).is_equal_to(0) 

44 

45 # Content should be replaced 

46 content = Path(".lintro-config.yaml").read_text() 

47 assert_that(content).contains("line_length: 88") 

48 assert_that(content).does_not_contain("existing: true") 

49 

50 

51def test_with_native_configs_creates_all_files() -> None: 

52 """Test that --with-native-configs creates native tool config files.""" 

53 runner = CliRunner() 

54 with runner.isolated_filesystem(): 

55 result = runner.invoke(init_command, ["--with-native-configs"]) 

56 assert_that(result.exit_code).is_equal_to(0) 

57 

58 # Check all files were created 

59 assert_that(Path(".lintro-config.yaml").exists()).is_true() 

60 assert_that(Path(".markdownlint-cli2.jsonc").exists()).is_true() 

61 

62 

63def test_markdownlint_config_has_correct_content() -> None: 

64 """Test that .markdownlint-cli2.jsonc has correct content.""" 

65 runner = CliRunner() 

66 with runner.isolated_filesystem(): 

67 result = runner.invoke(init_command, ["--with-native-configs"]) 

68 assert_that(result.exit_code).is_equal_to(0) 

69 

70 # Use string assertions since JSONC files may contain comments 

71 content = Path(".markdownlint-cli2.jsonc").read_text() 

72 assert_that(content).contains('"config"') 

73 assert_that(content).contains("MD013") 

74 

75 

76def test_native_configs_skips_existing_without_force() -> None: 

77 """Test that native configs are skipped if they exist without --force.""" 

78 runner = CliRunner() 

79 with runner.isolated_filesystem(): 

80 # Create existing markdownlint config 

81 Path(".markdownlint-cli2.jsonc").write_text('{"existing": true}') 

82 

83 result = runner.invoke(init_command, ["--with-native-configs"]) 

84 assert_that(result.exit_code).is_equal_to(0) 

85 assert_that(result.output).contains("Skipped .markdownlint-cli2.jsonc") 

86 

87 # Original content should be preserved 

88 content = Path(".markdownlint-cli2.jsonc").read_text() 

89 assert_that(content).is_equal_to('{"existing": true}') 

90 

91 

92def test_output_shows_all_created_files() -> None: 

93 """Test that output lists all created files.""" 

94 runner = CliRunner() 

95 with runner.isolated_filesystem(): 

96 result = runner.invoke(init_command, ["--with-native-configs"]) 

97 assert_that(result.exit_code).is_equal_to(0) 

98 # Should show multiple files were created 

99 assert_that(result.output).matches(r"Created \d+ files") 

100 assert_that(result.output).contains(".lintro-config.yaml") 

101 assert_that(result.output).contains(".markdownlint-cli2.jsonc") 

102 

103 

104def test_init_via_cli() -> None: 

105 """Test that init works via the main CLI.""" 

106 runner = CliRunner() 

107 with runner.isolated_filesystem(): 

108 result = runner.invoke(cli, ["init"]) 

109 assert_that(result.exit_code).is_equal_to(0) 

110 assert_that(Path(".lintro-config.yaml").exists()).is_true()