Add integration tests for require_braces #106 (#127)

Also introduce an option `-Dtest_focus_on_rule=<rule_name>` to only run
integration tests for a specific rule, which is useful when working on
individual rules as the entire suite takes a bit longer to run.

Author: KurtWagner

.github/workflows/coverage.yml

@@ -21,7 +21,7 @@ jobs:
     # Can't use 24 - see https://github.com/SimonKagstrom/kcov/issues/473
     runs-on: ubuntu-22.04
     name: Test coverage
-    timeout-minutes: 4
+    timeout-minutes: 5
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4

.github/workflows/linux.yml

@@ -19,7 +19,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     name: Test Linux
-    timeout-minutes: 5
+    timeout-minutes: 10
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4

.github/workflows/windows.yml

@@ -19,7 +19,7 @@ jobs:
   test:
     runs-on: windows-latest
     name: Test Windows
-    timeout-minutes: 6
+    timeout-minutes: 10
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4

README.md

@@ -410,6 +410,12 @@ All tests:
 zig build test
 ```
 
+To focus on a single rule when running integration tests:
+
+```shell
+zig build integration-test -Dtest_focus_on_rule=require_braces
+```
+
 ### Run lint on self
 
 ```shell

build.zig

@@ -190,7 +190,8 @@ const StepBuilder = struct {
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
-    const coverage = b.option(bool, "coverage", "Generate a coverage report with kcov");
+    const test_coverage = b.option(bool, "coverage", "Generate a coverage report with kcov");
+    const test_focus_on_rule = b.option([]const u8, "test_focus_on_rule", "Only run integration tests for this rule");
 
     const zlinter_lib_module = b.addModule("zlinter", .{
         .root_source_file = b.path("src/lib/zlinter.zig"),
@@ -216,7 +217,7 @@ pub fn build(b: *std.Build) void {
 
     const unit_tests_exe = b.addTest(.{
         .root_module = zlinter_lib_module,
-        .use_llvm = coverage,
+        .use_llvm = test_coverage,
     });
 
     // --------------------------------------------------------------------
@@ -263,6 +264,9 @@ pub fn build(b: *std.Build) void {
     install_coverage.step.dependOn(&merge_coverage.step);
 
     const run_integration_tests = b.addSystemCommand(&.{ b.graph.zig_exe, "build", "test" });
+    if (test_focus_on_rule) |r| {
+        run_integration_tests.addArg(b.fmt("-Dtest_focus_on_rule={s}", .{r}));
+    }
     run_integration_tests.setCwd(b.path("./integration_tests"));
     run_integration_tests.has_side_effects = true;
 
@@ -297,7 +301,7 @@ pub fn build(b: *std.Build) void {
     integration_check_step.dependOn(&run_integration_check.step);
 
     const unit_test_step = b.step("unit-test", "Run unit tests");
-    if (coverage orelse false) {
+    if (test_coverage orelse false) {
         const cover_run = std.Build.Step.Run.create(b, "Unit test coverage");
         cover_run.addArgs(&.{ kcov_bin, "--clean", "--collect-only" });
         cover_run.addPrefixedDirectoryArg("--include-pattern=", b.path("src"));
@@ -314,10 +318,10 @@ pub fn build(b: *std.Build) void {
         const test_rule_exe = b.addTest(.{
             .name = b.fmt("{s}_unit_test_coverage", .{rule_import.name}),
             .root_module = rule_import.module,
-            .use_llvm = coverage,
+            .use_llvm = test_coverage,
         });
 
-        if (coverage orelse false) {
+        if (test_coverage orelse false) {
             const cover_run = std.Build.Step.Run.create(b, "Unit test coverage");
             cover_run.addArgs(&.{ kcov_bin, "--clean", "--collect-only" });
             cover_run.addPrefixedDirectoryArg("--include-pattern=", b.path("src"));

integration_tests/build.zig

@@ -4,6 +4,7 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    const test_focus_on_rule = b.option([]const u8, "test_focus_on_rule", "Only run tests for this rule");
     const test_step = b.step("test", "Run tests");
 
     const test_cases_path = b.path("test_cases/").getPath3(b, null).sub_path;
@@ -39,6 +40,12 @@ pub fn build(b: *std.Build) !void {
             std.log.err("Test case file skipped as its invalid: {s}", .{item.path});
             continue;
         }];
+        if (test_focus_on_rule) |r| {
+            if (!std.mem.eql(u8, rule_name, r)) {
+                std.log.warn("Skipping {s}", .{rule_name});
+                continue;
+            }
+        }
         run_integration_test.addArg(rule_name);
 
         const test_name = item.basename[0..(item.basename.len - input_suffix.len)];

integration_tests/test_cases/require_braces/ignored.input.zig

@@ -0,0 +1,12 @@
+// Situations that are normally errors but under certain situations are ignored.
+pub fn ignored() void {
+    const x = 10;
+
+    const label = if (x > 10) "over 10" else "under 10";
+    _ = label;
+
+    return if (x > 20)
+        "over 20"
+    else
+        "under 20";
+}

integration_tests/test_cases/require_braces/ignored.input.zon

@@ -0,0 +1,6 @@
+.{
+    .if_statement = .{
+        .severity = .@"error",
+        .requirement = .all,
+    },
+}

integration_tests/test_cases/require_braces/ignored.lint_expected.stdout

@@ -0,0 +1 @@
+No issues!

integration_tests/test_cases/require_braces/require_braces.input.zig

@@ -0,0 +1,80 @@
+pub fn main() void {
+    var val: u32 = 0;
+
+    // If statements:
+    if (val < 10) val += 1;
+    // zig fmt: off
+    if (val < 10) { val += 1; }
+    // zig fmt: on
+    if (val < 10) {
+        val += 1;
+    }
+    if (val < 10)
+        val += 1
+    else if (val < 10) {
+        val += 1;
+        val += 1;
+    } else {
+        val += 1;
+    }
+
+    // While statements:
+    while (val < 10) val += 1;
+    // zig fmt: off
+    while (val < 10) { val += 1; }
+    // zig fmt: on
+    while (val < 10) {
+        val += 1;
+    }
+    while (val < 10)
+        val += 1;
+    while (val < 10) {
+        val += 1;
+        val += 1;
+    }
+
+    // For statements:
+    for (0..1) |i| val += i;
+    // zig fmt: off
+    for (0..1) |i| { val += i; }
+    // zig fmt: on
+    for (0..1) |i| {
+        val += i;
+    }
+    for (0..1) |i|
+        val += i;
+    for (0..1) |i| {
+        val += i;
+        val += i;
+    }
+
+    // Defer
+    defer {
+        val = 0;
+    }
+    defer val = 1;
+    defer {
+        val = 1;
+        val = 2;
+    }
+    // zig fmt: off
+    defer { val = 1; }
+    // zig fmt: on
+
+    // Switch
+    switch (val) {
+        0 => val = 1,
+        1 => {
+            val = 2;
+        },
+        2 => {
+            val = 3;
+            val = 4;
+        },
+        // zig fmt: off
+        3 => { val = 5; },
+        // zig fmt: on
+        4 => {},
+        else => {},
+    }
+}