Merge pull request #13 from bradcypert/bradcypert/add-thread-pool

Add threadpool, break out reporter

Author: bradcypert

README.md

@@ -41,5 +41,13 @@ Fail: 1
 There are some gaps in this implementation at this point (these are things I plan to address):
 
 1. There is not currently a way to pipe the response from a previous request into the next request. This is limiting as you often may need an ID from a previous request to make the next request.
-2. Currently, everything runs serially. The plan is to run each file in isolation against a thread pool. This will happen eventually, so if you start writing tests today, write them with this in mind (dont try to get fancy with sequencing of test files).
-3. Not all of the assertion types specified in the [specification](./HTTPSpec.md) are implemented yet.
+2. Not all of the assertion types specified in the [specification](./HTTPSpec.md) are implemented yet.
+
+# Configuration
+
+Do you have the need for speed? Tests are ran against a thread-pool and you can configure the number of jobs in said pool! Use the `HTTP_THREAD_COUNT` env var to specify the number of jobs in the pool.
+
+Example:
+```bash
+HTTP_THREAD_COUNT=4 httpspec ./my_project/httptests/
+```

src/main.zig

@@ -1,13 +1,17 @@
 const std = @import("std");
+const clap = @import("clap");
+
 const HttpParser = @import("./httpfile/parser.zig");
 const Client = @import("./httpfile/http_client.zig");
 const AssertionChecker = @import("./httpfile/assertion_checker.zig");
-const clap = @import("clap");
+const TestReporter = @import("./reporters/test_reporter.zig");
 
 pub fn main() !void {
     var debug = std.heap.DebugAllocator(.{}){};
     defer _ = debug.deinit();
 
+    const threads = std.process.parseEnvVarInt("HTTP_THREAD_COUNT", usize, 10) catch 1;
+
     const allocator = debug.allocator();
 
     const params = comptime clap.parseParamsComptime(
@@ -66,51 +70,65 @@ pub fn main() !void {
         }
     }
 
-    var test_count: usize = 0;
-    var test_pass: usize = 0;
-    var test_fail: usize = 0;
     // TODO: This is simple, but completely serial. Ideally, we'd span this across multiple threads.
-    for (files.items) |pos| {
-        test_count += 1;
-        var has_failure = false;
+
+    var pool: std.Thread.Pool = undefined;
+    try pool.init(.{
+        .allocator = allocator,
+        .n_jobs = threads,
+    });
+    defer pool.deinit();
+
+    var wg: std.Thread.WaitGroup = .{};
+    var reporter = TestReporter.BasicReporter.init();
+
+    for (files.items) |path| {
         // TODO: Each one gets its own areana?
-        std.io.getStdOut().writer().print("Running test {d}: {s}\n", .{ test_count, pos }) catch |err| {
-            std.debug.print("Error writing to stdout: {}\n", .{err});
-            return err;
-        };
-        var items = try HttpParser.parseFile(allocator, pos);
-        const owned_items = try items.toOwnedSlice();
-        defer allocator.free(owned_items);
-        var client = Client.HttpClient.init(allocator);
-        defer client.deinit();
-        for (owned_items) |*owned_item| {
-            defer owned_item.deinit(allocator);
-            var responses = try client.execute(owned_item);
-            defer responses.deinit();
-            // Check assertions
-            AssertionChecker.check(owned_item, responses) catch {
-                has_failure = true;
-                break;
-            };
-        }
-        if (!has_failure) {
-            test_pass += 1;
-        } else {
-            test_fail += 1;
-        }
+        pool.spawnWg(&wg, runTest, .{ allocator, &reporter, path });
     }
 
-    std.io.getStdOut().writer().print(
-        \\
-        \\All {d} tests ran successfully!
-        \\
-        \\Pass: {d}
-        \\Fail: {d}
-        \\
-    , .{ test_count, test_pass, test_fail }) catch |err| {
-        std.debug.print("Error writing to stdout: {}\n", .{err});
-        return err;
+    wg.wait();
+    reporter.report(std.io.getStdOut().writer());
+}
+
+fn runTest(allocator: std.mem.Allocator, reporter: *TestReporter.BasicReporter, path: []const u8) void {
+    var has_failure = false;
+
+    reporter.incTestCount();
+    var items = HttpParser.parseFile(allocator, path) catch |err| {
+        reporter.incTestInvalid();
+        std.debug.print("Failed to parse file {s}: {s}\n", .{ path, @errorName(err) });
+        return;
+    };
+    const owned_items = items.toOwnedSlice() catch |err| {
+        // TODO: This seems like an US error, not an invalid test error.
+        reporter.incTestInvalid();
+        std.debug.print("Failed to convert items to owned slice in file {s}: {s}\n", .{ path, @errorName(err) });
+        return;
     };
+    defer allocator.free(owned_items);
+
+    var client = Client.HttpClient.init(allocator);
+    defer client.deinit();
+    for (owned_items) |*owned_item| {
+        defer owned_item.deinit(allocator);
+        var responses = client.execute(owned_item) catch |err| {
+            reporter.incTestInvalid();
+            std.debug.print("Failed to execute request in file {s}: {s}\n", .{ path, @errorName(err) });
+            return;
+        };
+        defer responses.deinit();
+        // Check assertions
+        AssertionChecker.check(owned_item, responses) catch {
+            has_failure = true;
+            break;
+        };
+    }
+    if (!has_failure) {
+        reporter.incTestPass();
+    } else {
+        reporter.incTestFail();
+    }
 }
 
 // List all HTTP files in the given directory and its subdirectories

src/reporters/test_reporter.zig

@@ -0,0 +1,54 @@
+const std = @import("std");
+
+pub const BasicReporter = struct {
+    test_count: usize,
+    test_pass: usize,
+    test_fail: usize,
+    test_invalid: usize,
+    m: std.Thread.Mutex,
+
+    pub fn init() BasicReporter {
+        return .{
+            .test_count = 0,
+            .test_pass = 0,
+            .test_fail = 0,
+            .test_invalid = 0,
+            .m = std.Thread.Mutex{},
+        };
+    }
+
+    pub fn report(self: *BasicReporter, writer: anytype) void {
+        writer.print(
+            \\
+            \\All {d} tests ran successfully!
+            \\
+            \\Pass: {d}
+            \\Fail: {d}
+            \\Invalid: {d}
+            \\
+        , .{ self.test_count, self.test_pass, self.test_fail, self.test_invalid }) catch |err| {
+            std.debug.print("Error writing to stdout: {}\n", .{err});
+        };
+    }
+
+    pub fn incTestCount(self: *BasicReporter) void {
+        self.m.lock();
+        defer self.m.unlock();
+        self.test_count += 1;
+    }
+    pub fn incTestPass(self: *BasicReporter) void {
+        self.m.lock();
+        defer self.m.unlock();
+        self.test_pass += 1;
+    }
+    pub fn incTestFail(self: *BasicReporter) void {
+        self.m.lock();
+        defer self.m.unlock();
+        self.test_fail += 1;
+    }
+    pub fn incTestInvalid(self: *BasicReporter) void {
+        self.m.lock();
+        defer self.m.unlock();
+        self.test_invalid += 1;
+    }
+};