Merge pull request #14 from bradcypert/bradcypert/not-equals

Add support for NotEquals assertions

Author: bradcypert

build.zig

@@ -44,6 +44,41 @@ pub fn build(b: *std.Build) void {
 
     const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
 
+    // Automatically find all Zig files in src/ and subdirectories and add test steps for each
+    var zig_files = std.ArrayList([]const u8).init(b.allocator);
+    defer zig_files.deinit();
+    findZigFiles(b, &zig_files, "src") catch unreachable;
+
+    var test_run_steps = std.ArrayList(*std.Build.Step).init(b.allocator);
+    defer test_run_steps.deinit();
+
+    for (zig_files.items) |zig_file| {
+        // Skip main.zig since it's already covered by exe_unit_tests
+        if (std.mem.endsWith(u8, zig_file, "/main.zig")) continue;
+        const test_artifact = b.addTest(.{ .root_source_file = b.path(zig_file), .target = target, .optimize = optimize });
+        const run_test = b.addRunArtifact(test_artifact);
+        test_run_steps.append(&run_test.step) catch unreachable;
+    }
+
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&run_exe_unit_tests.step);
+    for (test_run_steps.items) |step| {
+        test_step.dependOn(step);
+    }
+}
+
+fn findZigFiles(b: *std.Build, files: *std.ArrayList([]const u8), dir_path: []const u8) !void {
+    var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
+    defer dir.close();
+    var it = dir.iterate();
+    while (try it.next()) |entry| {
+        if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".zig")) {
+            const full_path = try std.fs.path.join(b.allocator, &[_][]const u8{ dir_path, entry.name });
+            try files.append(full_path);
+        } else if (entry.kind == .directory and !std.mem.eql(u8, entry.name, ".") and !std.mem.eql(u8, entry.name, "..")) {
+            const subdir = try std.fs.path.join(b.allocator, &[_][]const u8{ dir_path, entry.name });
+            defer b.allocator.free(subdir);
+            try findZigFiles(b, files, subdir);
+        }
+    }
 }

src/httpfile/assertion_checker.zig

@@ -22,7 +22,6 @@ pub fn check(request: *HttpParser.HttpRequest, response: Client.HttpResponse) !v
                 } else if (std.mem.startsWith(u8, assertion.key, "header[\"")) {
                     // Extract the header name from the assertion key
                     const header_name = assertion.key[8 .. assertion.key.len - 2];
-
                     const actual_value = response.headers.get(header_name);
                     if (actual_value == null or !std.ascii.eqlIgnoreCase(actual_value.?, assertion.value)) {
                         stderr.print("[Fail] Expected header \"{s}\" to be \"{s}\", got \"{s}\"\n", .{ header_name, assertion.value, actual_value orelse "null" }) catch return error.HeaderMismatch;
@@ -33,6 +32,32 @@ pub fn check(request: *HttpParser.HttpRequest, response: Client.HttpResponse) !v
                     return error.InvalidAssertionKey;
                 }
             },
+            .not_equal => {
+                if (std.ascii.eqlIgnoreCase(assertion.key, "status")) {
+                    const assert_status_code = try std.fmt.parseInt(u16, assertion.value, 10);
+                    if (response.status == try std.meta.intToEnum(http.Status, assert_status_code)) {
+                        stderr.print("[Fail] Expected status code to NOT equal {d}, got {d}\n", .{ assert_status_code, @intFromEnum(response.status.?) }) catch return error.StatusCodesMatchButShouldnt;
+                        return error.StatusCodesMatchButShouldnt;
+                    }
+                } else if (std.ascii.eqlIgnoreCase(assertion.key, "body")) {
+                    if (std.mem.eql(u8, response.body, assertion.value)) {
+                        stderr.print("[Fail] Expected body content to NOT equal \"{s}\", got \"{s}\"\n", .{ assertion.value, response.body }) catch return error.BodyContentMatchesButShouldnt;
+                        return error.BodyContentMatchesButShouldnt;
+                    }
+                } else if (std.mem.startsWith(u8, assertion.key, "header[\"")) {
+                    // Extract the header name from the assertion key
+                    const header_name = assertion.key[8 .. assertion.key.len - 2];
+                    const actual_value = response.headers.get(header_name);
+                    if (actual_value != null and std.ascii.eqlIgnoreCase(actual_value.?, assertion.value)) {
+                        stderr.print("[Fail] Expected header \"{s}\" to NOT equal \"{s}\", got \"{s}\"\n", .{ header_name, assertion.value, actual_value orelse "null" }) catch return error.HeaderMatchesButShouldnt;
+                        return error.HeaderMatchesButShouldnt;
+                    }
+                } else {
+                    stderr.print("[Fail] Invalid assertion key: {s}\n", .{assertion.key}) catch return error.InvalidAssertionKey;
+                    return error.InvalidAssertionKey;
+                }
+            },
+
             // .header => {
             //     // assertion.key is header[""] so we need to
             //     // parse it out of the quotes
@@ -101,7 +126,56 @@ test "HttpParser parses assertions" {
         .assertion_type = .equal,
     });
 
-    const request = HttpParser.HttpRequest{
+    var request = HttpParser.HttpRequest{
+        .method = .GET,
+        .url = "https://api.example.com",
+        .headers = std.ArrayList(http.Header).init(allocator),
+        .assertions = assertions,
+        .body = null,
+    };
+
+    var response_headers = std.StringHashMap([]const u8).init(allocator);
+    try response_headers.put("content-type", "application/json");
+    defer response_headers.deinit();
+
+    const body = try allocator.dupe(u8, "Response body content");
+    defer allocator.free(body);
+    const response = Client.HttpResponse{
+        .status = http.Status.ok,
+        .headers = response_headers,
+        .body = body,
+        .allocator = allocator,
+    };
+
+    try check(&request, response);
+}
+
+test "HttpParser handles NotEquals" {
+    const allocator = std.testing.allocator;
+
+    var assertions = std.ArrayList(HttpParser.Assertion).init(allocator);
+    defer assertions.deinit();
+
+    try assertions.append(HttpParser.Assertion{
+        .key = "status",
+        .value = "400",
+        .assertion_type = .not_equal,
+    });
+
+    try assertions.append(HttpParser.Assertion{
+        .key = "body",
+        .value = "Response body content!!!",
+        .assertion_type = .not_equal,
+    });
+
+    // TODO: This should also work with header[\"Content-Type\"] as the key
+    try assertions.append(HttpParser.Assertion{
+        .key = "header[\"content-type\"]",
+        .value = "application/xml",
+        .assertion_type = .not_equal,
+    });
+
+    var request = HttpParser.HttpRequest{
         .method = .GET,
         .url = "https://api.example.com",
         .headers = std.ArrayList(http.Header).init(allocator),
@@ -122,5 +196,5 @@ test "HttpParser parses assertions" {
         .allocator = allocator,
     };
 
-    try check(request, response);
+    try check(&request, response);
 }

src/httpfile/http_client.zig

@@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
 const Uri = std.Uri;
 const httpfiles = @import("./parser.zig");
 
+/// Represents an HTTP response, including status, headers, and body.
 pub const HttpResponse = struct {
     status: ?http.Status,
     headers: std.StringHashMap([]const u8),
@@ -33,6 +34,7 @@ pub const HttpResponse = struct {
     }
 };
 
+/// HTTP client for executing requests defined in httpfiles.HttpRequest.
 pub const HttpClient = struct {
     allocator: Allocator,
     client: http.Client,
@@ -48,69 +50,55 @@ pub const HttpClient = struct {
         self.client.deinit();
     }
 
+    /// Executes a single HTTP request and returns the response.
     pub fn execute(self: *HttpClient, request: *const httpfiles.HttpRequest) !HttpResponse {
         if (request.method == null) {
             return error.MissingHttpMethod;
         }
 
-        // Parse the URL
         const uri = try Uri.parse(request.url);
-
         var server_header_buf: [4096]u8 = undefined;
 
-        // Create the HTTP request
         var req = try self.client.open(request.method.?, uri, .{
             .server_header_buffer = &server_header_buf,
             .extra_headers = request.headers.items,
         });
         defer req.deinit();
 
-        // Set content length if we have a body
         if (request.body) |body| {
             req.transfer_encoding = .{ .content_length = body.len };
-        } else {
-            //req.transfer_encoding = .{ .content_length = 0 };
         }
 
-        // Send the request
         try req.send();
 
-        // Send body if present
         if (request.body) |body| {
             try req.writeAll(body);
         }
 
         try req.finish();
-
-        // Wait for response
         try req.wait();
 
-        // Read the response
         var response = HttpResponse.init(self.allocator);
         response.status = req.response.status;
 
-        // Copy response headers
         var header_iterator = req.response.iterateHeaders();
         while (header_iterator.next()) |header| {
             const name = try self.allocator.dupe(u8, header.name);
             const value = try self.allocator.dupe(u8, header.value);
             try response.headers.put(name, value);
         }
 
-        // Read response body
         const body_reader = req.reader();
-        const body_content = try body_reader.readAllAlloc(self.allocator, std.math.maxInt(usize));
-        response.body = body_content;
+        response.body = try body_reader.readAllAlloc(self.allocator, std.math.maxInt(usize));
 
         return response;
     }
 
+    /// Executes multiple HTTP requests and returns an array of responses.
     pub fn executeRequests(self: *HttpClient, requests: []const httpfiles.HttpRequest) !ArrayList(HttpResponse) {
         var responses = ArrayList(HttpResponse).init(self.allocator);
         errdefer {
-            for (responses.items) |*response| {
-                response.deinit();
-            }
+            for (responses.items) |*response| response.deinit();
             responses.deinit();
         }
 
@@ -123,7 +111,7 @@ pub const HttpClient = struct {
     }
 };
 
-// Utility function to print response details
+// Utility function for backwards compatibility.
 pub fn printResponse(response: *const HttpResponse) void {
     std.debug.print("Status: {d}\n", .{response.status});
     std.debug.print("Headers:\n");
@@ -140,7 +128,6 @@ test "HttpClient basic functionality" {
     var client = HttpClient.init(allocator);
     defer client.deinit();
 
-    // Create a simple GET request
     var request = httpfiles.HttpRequest.init(allocator);
     defer request.deinit(allocator);
 
@@ -151,10 +138,8 @@ test "HttpClient basic functionality" {
     // isn't really intended either. Either way, need to look into this further.
     request.url = try allocator.dupe(u8, "https://httpbin.org/status/200");
 
-    // Execute the request
     var response = try client.execute(&request);
     defer response.deinit();
 
-    // Check that we got a 200 status
     try std.testing.expectEqual(http.Status.ok, response.status.?);
 }