/tests/list.zig at b1606ed65fbb7d975ff044d2b7247ea44a556e78

// Copyright (C) 2025 Shota FUJI
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
//
// SPDX-License-Identifier: GPL-3.0-only

const std = @import("std");

const config = @import("config");

const ListOptions = struct {
    bin: []const u8,
    utc: bool = false,
    longitude: []const u8 = "31.132484E",
    latitude: []const u8 = "29.977435N",
    days: ?[]const u8 = "3",
    tz: []const u8 = "UTC",
    event: ?enum { sunset, sunrise } = null,
    twilight: ?[]const u8 = null,
    twilight_angle: ?[]const u8 = null,
    offset: ?[]const u8 = null,
};

fn list(allocator: std.mem.Allocator, opts: ListOptions) !std.process.Child.RunResult {
    var env = std.process.EnvMap.init(allocator);
    defer env.deinit();

    try env.put("TZ", opts.tz);

    var args = std.ArrayList([]const u8).init(allocator);
    defer args.deinit();

    try args.append(opts.bin);
    if (opts.utc) {
        try args.append("utc");
    }

    if (opts.offset) |offset| {
        try args.append("offset");
        try args.append(offset);
    }

    try args.append("list");
    if (opts.days) |days| {
        try args.append(days);
    }
    try args.append(opts.latitude);
    try args.append(opts.longitude);

    if (opts.event) |e| {
        try args.append(@tagName(e));
    }

    if (opts.twilight) |t| {
        try args.append(t);
    }

    if (opts.twilight_angle) |angle| {
        try args.append("angle");
        try args.append(angle);
    }

    return try std.process.Child.run(.{
        .allocator = allocator,
        .argv = args.items,
        .env_map = &env,
    });
}

test {
    const legacy = try list(std.testing.allocator, .{ .bin = config.legacy_bin });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{ .bin = config.new_bin });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should have same default DAYS" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .days = null,
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .days = null,
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same on non-UTC timezone" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Asia/Tokyo",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Asia/Tokyo",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same with UTC flag" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same on printing only sunrise" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunrise,
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunrise,
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same on printing only sunset" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same even with twilight angle set" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .twilight = "civil",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .twilight = "civil",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same on custom twilight angle" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .twilight_angle = "2.1",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .twilight_angle = "2.1",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same with an offset" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .offset = "00:30",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .offset = "00:30",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "Should behave same with a negative offset" {
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .offset = "-11:00",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Paris",
        .utc = true,
        .event = .sunset,
        .offset = "-11:00",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "From original USAGE.txt: Example 2" {
    // List civil sunrise and sunset times for today and next 6 days. Moscow.
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Europe/Moscow",
        .twilight = "civil",
        .days = "7",
        .latitude = "55.752163N",
        .longitude = "37.617524E",
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Europe/Moscow",
        .twilight = "civil",
        .days = "7",
        .latitude = "55.752163N",
        .longitude = "37.617524E",
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}

test "From original USAGE.txt: Example 4" {
    // List next 7 days sunrise times, custom +3 degree twilight angle, default location.
    // Uses GMT; as any change in daylight saving over the specified period is not considered.
    const legacy = try list(std.testing.allocator, .{
        .bin = config.legacy_bin,
        .tz = "Asia/Tokyo",
        .twilight_angle = "3",
        .days = "7",
        .event = .sunrise,
        .utc = true,
    });
    defer std.testing.allocator.free(legacy.stderr);
    defer std.testing.allocator.free(legacy.stdout);

    const new = try list(std.testing.allocator, .{
        .bin = config.new_bin,
        .tz = "Asia/Tokyo",
        .twilight_angle = "3",
        .days = "7",
        .event = .sunrise,
        .utc = true,
    });
    defer std.testing.allocator.free(new.stderr);
    defer std.testing.allocator.free(new.stdout);

    try std.testing.expectEqual(legacy.term.Exited, new.term.Exited);
    try std.testing.expectEqualStrings(legacy.stderr, new.stderr);
    try std.testing.expectEqualStrings(legacy.stdout, new.stdout);
}