sozu_command_lib/

response.rs

use std::{cmp::Ordering, collections::BTreeMap, fmt, net::SocketAddr};

use crate::{
    proto::command::{
        AddBackend, FilteredTimeSerie, Header, HeaderPredicate, HstsConfig, LoadBalancingParams,
        PathRule, PathRuleKind, RequestHttpFrontend, RequestTcpFrontend, RequestUdpFrontend,
        Response, ResponseContent, ResponseStatus, RulePosition, RunState, WorkerResponse,
    },
    state::ClusterId,
};

impl Response {
    pub fn new(
        status: ResponseStatus,
        message: String,
        content: Option<ResponseContent>,
    ) -> Response {
        Response {
            status: status as i32,
            message,
            content,
        }
    }
}

/// An HTTP or HTTPS frontend, as used *within* Sōzu
#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct HttpFrontend {
    /// Send a 401, DENY, if cluster_id is None
    pub cluster_id: Option<ClusterId>,
    pub address: SocketAddr,
    pub hostname: String,
    #[serde(default)]
    #[serde(skip_serializing_if = "is_default_path_rule")]
    pub path: PathRule,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub method: Option<String>,
    #[serde(default)]
    pub position: RulePosition,
    pub tags: Option<BTreeMap<String, String>>,
    /// Resolved frontend-level policy carried over from
    /// [`RequestHttpFrontend`]. The router consults these to build a
    /// `Route::Frontend(Rc<Frontend>)` when any are non-default,
    /// otherwise falls back to the legacy `Route::ClusterId` /
    /// `Route::Deny` shapes.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<i32>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect_scheme: Option<i32>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect_template: Option<String>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rewrite_host: Option<String>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rewrite_path: Option<String>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rewrite_port: Option<u32>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub required_auth: Option<bool>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub headers: Vec<Header>,
    /// Resolved per-frontend HSTS (RFC 6797) policy. `None` means inherit
    /// the listener default at frontend-add time in the worker.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hsts: Option<HstsConfig>,
    /// Header predicates the request must all satisfy for this frontend to
    /// match (sozu-proxy/sozu#1253). Part of the frontend's identity.
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub header_predicates: Vec<HeaderPredicate>,
}

impl fmt::Debug for HttpFrontend {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let tags_count = self.tags.as_ref().map(BTreeMap::len);
        let tags_len = self.tags.as_ref().map(|tags| {
            tags.iter().fold(0usize, |total, (key, value)| {
                total.saturating_add(key.len()).saturating_add(value.len())
            })
        });
        let headers_len = self.headers.iter().fold(0usize, |total, header| {
            total
                .saturating_add(header.key.len())
                .saturating_add(header.val.len())
        });

        f.debug_struct("HttpFrontend")
            .field("cluster_id_len", &self.cluster_id.as_deref().map(str::len))
            .field("address", &self.address)
            .field("hostname_len", &self.hostname.len())
            .field("path_kind", &self.path.kind)
            .field("path_len", &self.path.value.len())
            .field("method_len", &self.method.as_ref().map(String::len))
            .field("position", &self.position)
            .field("tags_count", &tags_count)
            .field("tags_len", &tags_len)
            .field("redirect", &self.redirect)
            .field("required_auth", &self.required_auth)
            .field("redirect_scheme", &self.redirect_scheme)
            .field(
                "redirect_template_len",
                &self.redirect_template.as_ref().map(String::len),
            )
            .field(
                "rewrite_host_len",
                &self.rewrite_host.as_ref().map(String::len),
            )
            .field(
                "rewrite_path_len",
                &self.rewrite_path.as_ref().map(String::len),
            )
            .field("rewrite_port", &self.rewrite_port)
            .field("headers_count", &self.headers.len())
            .field("headers_len", &headers_len)
            .field("hsts", &self.hsts)
            .field("header_predicates_count", &self.header_predicates.len())
            .finish_non_exhaustive()
    }
}

impl From<HttpFrontend> for RequestHttpFrontend {
    fn from(val: HttpFrontend) -> Self {
        let source_address = val.address;
        let source_hostname = val.hostname.clone();
        let request_frontend = RequestHttpFrontend {
            cluster_id: val.cluster_id.as_deref().map(str::to_owned),
            address: val.address.into(),
            hostname: val.hostname,
            path: val.path,
            method: val.method,
            position: val.position.into(),
            tags: val.tags.unwrap_or_default(),
            redirect: val.redirect,
            redirect_scheme: val.redirect_scheme,
            redirect_template: val.redirect_template,
            rewrite_host: val.rewrite_host,
            rewrite_path: val.rewrite_path,
            rewrite_port: val.rewrite_port,
            required_auth: val.required_auth,
            headers: val.headers,
            hsts: val.hsts,
            header_predicates: val.header_predicates,
        };

        // POST: the proto-encoded address decodes back to the source SocketAddr
        // and the hostname is unchanged — the in-Sōzu → wire conversion must be
        // routing-preserving (the SocketAddress ⇔ SocketAddr round-trip is
        // exercised in request.rs; here we tie the frontend identity to it).
        debug_assert_eq!(
            SocketAddr::from(request_frontend.address),
            source_address,
            "frontend address must round-trip through the proto encoding"
        );
        debug_assert_eq!(
            request_frontend.hostname, source_hostname,
            "frontend hostname must survive the proto conversion"
        );
        request_frontend
    }
}

impl From<Backend> for AddBackend {
    fn from(val: Backend) -> Self {
        let source_address = val.address;
        let source_cluster_id = val.cluster_id.clone();
        let source_backend_id = val.backend_id.clone();
        let add_backend = AddBackend {
            cluster_id: val.cluster_id.to_string(),
            backend_id: val.backend_id,
            address: val.address.into(),
            sticky_id: val.sticky_id,
            load_balancing_parameters: val.load_balancing_parameters,
            backup: val.backup,
            unix_path: val.unix_path,
        };

        // POST: backend identity (cluster + backend id) and the wire address
        // are preserved — a backend that changed cluster/id/address here would
        // be registered under the wrong key and never receive (or steal)
        // traffic.
        debug_assert_eq!(
            *add_backend.cluster_id, *source_cluster_id,
            "backend cluster_id must survive the proto conversion"
        );
        debug_assert_eq!(
            add_backend.backend_id, source_backend_id,
            "backend_id must survive the proto conversion"
        );
        debug_assert_eq!(
            SocketAddr::from(add_backend.address),
            source_address,
            "backend address must round-trip through the proto encoding"
        );
        add_backend
    }
}

impl PathRule {
    pub fn prefix<S>(value: S) -> Self
    where
        S: ToString,
    {
        let rule = Self {
            kind: PathRuleKind::Prefix.into(),
            value: value.to_string(),
        };
        // POST: the encoded kind decodes back to the Prefix variant — the proto
        // i32 must round-trip or the router would misclassify the match type.
        debug_assert_eq!(
            PathRuleKind::try_from(rule.kind),
            Ok(PathRuleKind::Prefix),
            "prefix() must encode a Prefix-kind rule"
        );
        rule
    }

    pub fn regex<S>(value: S) -> Self
    where
        S: ToString,
    {
        let rule = Self {
            kind: PathRuleKind::Regex.into(),
            value: value.to_string(),
        };
        debug_assert_eq!(
            PathRuleKind::try_from(rule.kind),
            Ok(PathRuleKind::Regex),
            "regex() must encode a Regex-kind rule"
        );
        rule
    }

    /// A `REGEX_PATH` rule (sozu-proxy/sozu#1909): `value` is matched,
    /// anchored at both ends, against the request path up to its first `?`,
    /// so the query string never takes part in the match.
    pub fn regex_path<S>(value: S) -> Self
    where
        S: ToString,
    {
        let rule = Self {
            kind: PathRuleKind::RegexPath.into(),
            value: value.to_string(),
        };
        debug_assert_eq!(
            PathRuleKind::try_from(rule.kind),
            Ok(PathRuleKind::RegexPath),
            "regex_path() must encode a RegexPath-kind rule"
        );
        rule
    }

    pub fn equals<S>(value: S) -> Self
    where
        S: ToString,
    {
        let rule = Self {
            kind: PathRuleKind::Equals.into(),
            value: value.to_string(),
        };
        debug_assert_eq!(
            PathRuleKind::try_from(rule.kind),
            Ok(PathRuleKind::Equals),
            "equals() must encode an Equals-kind rule"
        );
        rule
    }

    pub fn from_cli_options(
        path_prefix: Option<String>,
        path_regex: Option<String>,
        path_equals: Option<String>,
        path_regex_path: Option<String>,
    ) -> Self {
        // PRE: prefix takes precedence over regex, which takes precedence over
        // equals, which takes precedence over the path-only regex. Capture
        // which arms are populated so the post-condition can assert the
        // precedence actually fired.
        let had_prefix = path_prefix.is_some();
        let had_regex = path_regex.is_some();
        let had_equals = path_equals.is_some();
        let had_regex_path = path_regex_path.is_some();
        let rule = match (path_prefix, path_regex, path_equals, path_regex_path) {
            (Some(prefix), _, _, _) => PathRule {
                kind: PathRuleKind::Prefix as i32,
                value: prefix,
            },
            (None, Some(regex), _, _) => PathRule {
                kind: PathRuleKind::Regex as i32,
                value: regex,
            },
            (None, None, Some(equals), _) => PathRule {
                kind: PathRuleKind::Equals as i32,
                value: equals,
            },
            (None, None, None, Some(regex_path)) => PathRule {
                kind: PathRuleKind::RegexPath as i32,
                value: regex_path,
            },
            _ => PathRule::default(),
        };

        // POST: a present prefix wins outright; absent a prefix, a present
        // regex wins. The resolved kind must reflect that precedence so two
        // simultaneously-set CLI flags can never silently pick the wrong rule.
        debug_assert!(
            !had_prefix || rule.kind == PathRuleKind::Prefix as i32,
            "a path prefix must produce a Prefix rule regardless of other flags"
        );
        debug_assert!(
            had_prefix || !had_regex || rule.kind == PathRuleKind::Regex as i32,
            "absent a prefix, a regex must produce a Regex rule"
        );
        debug_assert!(
            had_prefix
                || had_regex
                || had_equals
                || !had_regex_path
                || rule.kind == PathRuleKind::RegexPath as i32,
            "alone, a path-only regex must produce a RegexPath rule"
        );
        debug_assert!(
            had_regex_path || rule.kind != PathRuleKind::RegexPath as i32,
            "a RegexPath rule can only come from a path-only regex flag"
        );
        rule
    }
}

pub fn is_default_path_rule(p: &PathRule) -> bool {
    PathRuleKind::try_from(p.kind) == Ok(PathRuleKind::Prefix) && p.value.is_empty()
}

impl fmt::Display for PathRule {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match PathRuleKind::try_from(self.kind) {
            Ok(PathRuleKind::Prefix) => write!(f, "prefix '{}'", self.value),
            Ok(PathRuleKind::Regex) => write!(f, "regexp '{}'", self.value),
            Ok(PathRuleKind::Equals) => write!(f, "equals '{}'", self.value),
            Ok(PathRuleKind::RegexPath) => write!(f, "path-only regexp '{}'", self.value),
            Err(_) => write!(f, ""),
        }
    }
}

/// A TCP frontend, as used *within* Sōzu
#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct TcpFrontend {
    pub cluster_id: ClusterId,
    pub address: SocketAddr,
    /// custom tags to identify the frontend in the access logs
    pub tags: BTreeMap<String, String>,
    /// SNI hostname to match against the TLS ClientHello (exact hostname or a
    /// single leading `*.` wildcard label). `None` matches regardless of SNI.
    #[serde(default)]
    pub sni: Option<String>,
    /// ALPN protocol names this frontend matches; empty is the catch-all for
    /// its `sni` on this listener.
    #[serde(default)]
    pub alpn: Vec<String>,
}

impl From<TcpFrontend> for RequestTcpFrontend {
    fn from(val: TcpFrontend) -> Self {
        let source_address = val.address;
        let source_cluster_id = val.cluster_id.clone();
        let source_sni = val.sni.clone();
        let source_alpn = val.alpn.clone();
        let request_frontend = RequestTcpFrontend {
            cluster_id: val.cluster_id.to_string(),
            address: val.address.into(),
            tags: val.tags,
            sni: val.sni,
            alpn: val.alpn,
        };

        // POST: cluster identity and the wire address are preserved across the
        // proto conversion (same routing guarantee as the HTTP frontend path).
        debug_assert_eq!(
            *request_frontend.cluster_id, *source_cluster_id,
            "TCP frontend cluster_id must survive the proto conversion"
        );
        debug_assert_eq!(
            SocketAddr::from(request_frontend.address),
            source_address,
            "TCP frontend address must round-trip through the proto encoding"
        );
        // POST: SNI/ALPN routing identity is preserved across the proto
        // conversion — losing either here would silently misroute or
        // over-match traffic on this frontend's listener.
        debug_assert_eq!(
            request_frontend.sni, source_sni,
            "TCP frontend sni must survive the proto conversion"
        );
        debug_assert_eq!(
            request_frontend.alpn, source_alpn,
            "TCP frontend alpn must survive the proto conversion"
        );
        request_frontend
    }
}

/// A UDP frontend, as used *within* Sōzu
#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct UdpFrontend {
    pub cluster_id: ClusterId,
    pub address: SocketAddr,
    /// custom tags to identify the frontend in the access logs
    pub tags: BTreeMap<String, String>,
}

impl From<UdpFrontend> for RequestUdpFrontend {
    fn from(val: UdpFrontend) -> Self {
        RequestUdpFrontend {
            cluster_id: val.cluster_id.to_string(),
            address: val.address.into(),
            tags: val.tags,
        }
    }
}

/// A backend, as used *within* Sōzu
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Backend {
    pub cluster_id: ClusterId,
    pub backend_id: String,
    pub address: SocketAddr,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sticky_id: Option<String>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub load_balancing_parameters: Option<LoadBalancingParams>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub backup: Option<bool>,
    /// UNIX domain socket dialed instead of `address`, see
    /// `AddBackend::unix_path` (`command/src/command.proto`).
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unix_path: Option<String>,
}

impl Ord for Backend {
    fn cmp(&self, o: &Backend) -> Ordering {
        // INV: Equal can only be returned when every keyed field compares
        // Equal — the tuple of field orderings is the source of truth, and the
        // `.then(...)` fold must not collapse two distinct backends to Equal
        // (which would let one silently evict the other from a BTree key set).
        // Computed inline (no recursion into `cmp`) so it stays cheap.
        let fields_all_equal = self.cluster_id == o.cluster_id
            && self.backend_id == o.backend_id
            && self.sticky_id == o.sticky_id
            && self.load_balancing_parameters == o.load_balancing_parameters
            && self.backup == o.backup
            && self.unix_path == o.unix_path
            && self.address == o.address;

        let ordering = self
            .cluster_id
            .cmp(&o.cluster_id)
            .then(self.backend_id.cmp(&o.backend_id))
            .then(self.sticky_id.cmp(&o.sticky_id))
            .then(
                self.load_balancing_parameters
                    .cmp(&o.load_balancing_parameters),
            )
            .then(self.backup.cmp(&o.backup))
            .then(self.unix_path.cmp(&o.unix_path))
            .then(socketaddr_cmp(&self.address, &o.address));

        debug_assert_eq!(
            ordering == Ordering::Equal,
            fields_all_equal,
            "Backend::cmp returns Equal iff every keyed field is equal"
        );
        ordering
    }
}

impl PartialOrd for Backend {
    fn partial_cmp(&self, other: &Backend) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Backend {
    pub fn to_add_backend(self) -> AddBackend {
        let source_address = self.address;
        let source_backend_id = self.backend_id.clone();
        let add_backend = AddBackend {
            cluster_id: self.cluster_id.to_string(),
            address: self.address.into(),
            sticky_id: self.sticky_id,
            backend_id: self.backend_id,
            load_balancing_parameters: self.load_balancing_parameters,
            backup: self.backup,
            unix_path: self.unix_path,
        };

        // POST: identity (backend id) and wire address are preserved — same
        // routing guarantee as the `From<Backend>` path, kept in lockstep.
        debug_assert_eq!(
            add_backend.backend_id, source_backend_id,
            "backend_id must survive to_add_backend"
        );
        debug_assert_eq!(
            SocketAddr::from(add_backend.address),
            source_address,
            "backend address must round-trip through to_add_backend"
        );
        add_backend
    }
}

impl fmt::Display for RunState {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

pub type MessageId = String;

impl WorkerResponse {
    pub fn ok<T>(id: T) -> Self
    where
        T: ToString,
    {
        Self {
            id: id.to_string(),
            message: String::new(),
            status: ResponseStatus::Ok.into(),
            content: None,
        }
    }

    pub fn ok_with_content<T>(id: T, content: ResponseContent) -> Self
    where
        T: ToString,
    {
        Self {
            id: id.to_string(),
            status: ResponseStatus::Ok.into(),
            message: String::new(),
            content: Some(content),
        }
    }

    pub fn error<T, U>(id: T, error: U) -> Self
    where
        T: ToString,
        U: ToString,
    {
        Self {
            id: id.to_string(),
            message: error.to_string(),
            status: ResponseStatus::Failure.into(),
            content: None,
        }
    }

    pub fn processing<T>(id: T) -> Self
    where
        T: ToString,
    {
        Self {
            id: id.to_string(),
            message: String::new(),
            status: ResponseStatus::Processing.into(),
            content: None,
        }
    }

    pub fn with_status<T>(id: T, status: ResponseStatus) -> Self
    where
        T: ToString,
    {
        Self {
            id: id.to_string(),
            message: String::new(),
            status: status.into(),
            content: None,
        }
    }

    pub fn is_failure(&self) -> bool {
        self.status == ResponseStatus::Failure as i32
    }
}

impl fmt::Display for WorkerResponse {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}-{:?}", self.id, self.status)
    }
}

impl fmt::Display for FilteredTimeSerie {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // `last_minute` / `last_hour` are prost `repeated uint32`, so they are
        // `Vec<u32>` and not `[u32; 60]`: six fixed 10-wide windows indexed a
        // series that holds fewer samples out of range. `chunks(10)` renders
        // the exact same six windows for a full series and simply stops early
        // for a short one.
        writeln!(f, "FilteredTimeSerie {{")?;
        writeln!(f, "last_second: {},", self.last_second)?;
        writeln!(f, "last_minute:")?;
        for window in self.last_minute.chunks(10) {
            writeln!(f, "{window:?}")?;
        }
        writeln!(f, "last_hour:")?;
        for window in self.last_hour.chunks(10) {
            writeln!(f, "{window:?}")?;
        }
        write!(f, "}}")
    }
}

fn socketaddr_cmp(a: &SocketAddr, b: &SocketAddr) -> Ordering {
    let ordering = a.ip().cmp(&b.ip()).then(a.port().cmp(&b.port()));
    // INV: two socket addresses compare Equal iff both IP and port match —
    // the `.then` fold must not declare distinct (ip, port) pairs equal, which
    // would make two different backends indistinguishable to the BTree key.
    debug_assert_eq!(
        ordering == Ordering::Equal,
        a.ip() == b.ip() && a.port() == b.port(),
        "socketaddr_cmp is Equal iff ip and port both match"
    );
    ordering
}

#[cfg(test)]
mod tests {
    //! `FilteredTimeSerie::last_minute` / `last_hour` are prost
    //! `repeated uint32` (`command.proto`), i.e. `Vec<u32>` and NOT
    //! `[u32; 60]` — nothing in the type or the wire format guarantees the 60
    //! samples the `Display` impl used to slice with six fixed 10-wide windows.
    //!
    //! To SEE THESE RED (regression proof): restore the pre-fix body of
    //! `FilteredTimeSerie`'s [`std::fmt::Display`] impl, the six
    //! `&self.last_minute[0..10] … [50..60]` / `&self.last_hour[..]` fixed
    //! windows — the short-series expectation below then panics with
    //! `range end index 10 out of range for slice of length 3`.
    use crate::proto::command::{FilteredTimeSerie, PathRule, PathRuleKind};

    /// `--path-regex-path` (sozu-proxy/sozu#1909) builds a `REGEX_PATH` rule
    /// when it is the only path flag, and ranks below the three older flags.
    #[test]
    fn the_path_only_regex_cli_flag_builds_a_regex_path_rule_and_ranks_last() {
        let some = |v: &str| Some(v.to_owned());
        assert_eq!(
            PathRule::from_cli_options(None, None, None, some("^/a$")),
            PathRule::regex_path("^/a$"),
        );
        assert_eq!(
            PathRule::from_cli_options(None, None, some("/e"), some("^/a$")),
            PathRule::equals("/e"),
        );
        assert_eq!(
            PathRule::from_cli_options(None, some("/r"), None, some("^/a$")),
            PathRule::regex("/r"),
        );
        assert_eq!(
            PathRule::from_cli_options(some("/p"), None, None, some("^/a$")),
            PathRule::prefix("/p"),
        );
        assert_eq!(
            PathRule::regex_path("/x").to_string(),
            "path-only regexp '/x'",
            "the frontend listing names the kind",
        );
        assert_eq!(
            PathRuleKind::try_from(PathRule::regex_path("/x").kind),
            Ok(PathRuleKind::RegexPath)
        );
    }

    #[test]
    fn a_series_shorter_than_sixty_samples_renders_instead_of_panicking() {
        let serie = FilteredTimeSerie {
            last_second: 42,
            last_minute: vec![1, 2, 3],
            last_hour: vec![],
        };

        let rendered = serie.to_string();

        assert!(
            rendered.contains("last_second: 42"),
            "the rendering must keep its header, got {rendered:?}"
        );
        assert!(
            rendered.contains("[1, 2, 3]"),
            "a partial minute window must render the samples it has, got {rendered:?}"
        );
    }

    #[test]
    fn a_full_series_still_renders_six_windows_per_serie() {
        // The layout the six fixed windows produced must not drift: one header
        // line, one label per serie, six 10-sample windows each, one closing
        // brace.
        let serie = FilteredTimeSerie {
            last_second: 7,
            last_minute: (0..60).collect(),
            last_hour: (0..60).collect(),
        };

        let rendered = serie.to_string();
        let lines: Vec<&str> = rendered.lines().collect();

        assert_eq!(
            lines.len(),
            17,
            "1 header + 1 label + 6 windows + 1 label + 6 windows + 1 brace, got {rendered:?}"
        );
        assert_eq!(lines[2], "last_minute:");
        assert_eq!(lines[3], "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
        assert_eq!(lines[8], "[50, 51, 52, 53, 54, 55, 56, 57, 58, 59]");
        assert_eq!(lines[9], "last_hour:");
        assert_eq!(lines[16], "}");
    }
}