dekopon-shell 0.35.0

Sandboxed bash-flavored script interpreter whose commands dispatch to Dekopon capabilities
Documentation
use std::sync::atomic::{AtomicUsize, Ordering};

use super::extra::ExtraStream;
use crate::{
    CapabilityCallResult, CapabilityInvoker, CommandProposal, ExitCode,
    builtins::{CommandFailure, FatalError, test_support::NoCapabilities},
    limits::{Budget, LimitExceeded, Limits},
    pipe::{self, PipeReader, WriteOutcome},
};

fn arguments(command: ExtraStream) -> Vec<String> {
    match command {
        ExtraStream::Cut => vec!["-c".into(), "1".into()],
        ExtraStream::Uniq | ExtraStream::Wc | ExtraStream::Sort => Vec::new(),
    }
}

#[test]
fn four_text_commands_charge_each_small_pipe_chunk() {
    for command in [
        ExtraStream::Cut,
        ExtraStream::Uniq,
        ExtraStream::Wc,
        ExtraStream::Sort,
    ] {
        let (mut writer, mut reader) = pipe::pipe();
        for _ in 0..5 {
            assert_eq!(writer.write(b"x\n"), WriteOutcome::Accepted);
        }
        drop(writer);
        let mut budget = Budget::start(Limits {
            max_steps: 2,
            ..Limits::default()
        });
        let failure = command
            .run(
                &arguments(command),
                &mut reader,
                &mut budget,
                &NoCapabilities,
                |_| Ok(true),
            )
            .expect_err("the third small chunk exhausts the step budget");
        assert!(matches!(
            failure,
            CommandFailure::Fatal(FatalError::Limit(LimitExceeded::Steps { maximum: 2 }))
        ));
    }
}

#[test]
fn four_text_commands_notice_cancellation_between_chunks() {
    struct CancelAfterFirst(AtomicUsize);
    impl CapabilityInvoker for CancelAfterFirst {
        fn granted(&self) -> Vec<String> {
            Vec::new()
        }
        fn invoke(
            &self,
            _: CommandProposal,
            _streams: crate::Streams,
            _tree: &crate::TreeContext,
        ) -> CapabilityCallResult {
            unreachable!()
        }
        fn cancelled(&self) -> bool {
            self.0.fetch_add(1, Ordering::SeqCst) > 0
        }
    }
    for command in [
        ExtraStream::Cut,
        ExtraStream::Uniq,
        ExtraStream::Wc,
        ExtraStream::Sort,
    ] {
        let mut reader = PipeReader::from_bytes(vec![b'x'; 2 * pipe::CHUNK_BYTES]);
        let invoker = CancelAfterFirst(AtomicUsize::new(0));
        let mut budget = Budget::start(Limits::default());
        let failure = command
            .run(
                &arguments(command),
                &mut reader,
                &mut budget,
                &invoker,
                |_| Ok(true),
            )
            .expect_err("second read notices cancellation");
        assert!(matches!(
            failure,
            CommandFailure::Fatal(FatalError::Limit(LimitExceeded::Cancelled))
        ));
        assert_eq!(invoker.0.load(Ordering::SeqCst), 2);
    }
}

#[test]
fn cut_selects_characters_from_a_near_limit_line_without_retaining_copies() {
    let text = "é".repeat(2048);
    let mut reader = PipeReader::from_bytes(text.as_bytes().to_vec());
    let mut budget = Budget::start(Limits {
        max_value_bytes: text.len() as u64,
        ..Limits::default()
    });
    let mut output = Vec::new();
    let result = ExtraStream::Cut.run(
        &["-c".into(), "2-3".into()],
        &mut reader,
        &mut budget,
        &NoCapabilities,
        |part| {
            output.extend_from_slice(part);
            Ok(true)
        },
    );
    assert_eq!(
        result.expect("only the pending line needs retention"),
        ExitCode::SUCCESS
    );
    assert_eq!(output, "éé".as_bytes());
    assert!(budget.charge_value_bytes(text.len() as u64).is_ok());
}

#[test]
fn streaming_cut_selects_unsorted_overlapping_fields_and_characters() {
    for (arguments, input, expected) in [
        (vec!["-d", ":", "-f", "3,1-2,2"], "a:b:c:d\n", "a:b:c\n"),
        (vec!["-c", "3,1-2,2"], "éßγδ\n", "éßγ\n"),
    ] {
        let mut reader = PipeReader::from_bytes(input.as_bytes().to_vec());
        let mut budget = Budget::start(Limits::default());
        let mut output = Vec::new();
        ExtraStream::Cut
            .run(
                &arguments
                    .iter()
                    .map(|arg| (*arg).to_owned())
                    .collect::<Vec<_>>(),
                &mut reader,
                &mut budget,
                &NoCapabilities,
                |part| {
                    output.extend_from_slice(part);
                    Ok(true)
                },
            )
            .expect("selected spans stream");
        assert_eq!(output, expected.as_bytes());
    }
}

fn sorted(arguments: &[&str], input: &str) -> Result<String, CommandFailure> {
    let mut reader = PipeReader::from_bytes(input.as_bytes().to_vec());
    let mut budget = Budget::start(Limits::default());
    let mut output = Vec::new();
    ExtraStream::Sort.run(
        &arguments
            .iter()
            .map(|arg| (*arg).to_owned())
            .collect::<Vec<_>>(),
        &mut reader,
        &mut budget,
        &NoCapabilities,
        |part| {
            output.extend_from_slice(part);
            Ok(true)
        },
    )?;
    Ok(String::from_utf8(output).expect("sort emits text"))
}

#[test]
fn streaming_sort_orders_text_lexicographically() {
    assert_eq!(
        sorted(&[], "pear\napple\nfig\n").expect("sort"),
        "apple\nfig\npear\n"
    );
    assert_eq!(sorted(&[], "b\na").expect("sort"), "a\nb");
}

#[test]
fn streaming_sort_orders_numeric_keys_before_reversing() {
    assert_eq!(
        sorted(&["-n"], "10\n9\n100\n").expect("sort"),
        "9\n10\n100\n"
    );
    assert_eq!(sorted(&[], "10\n9\n100\n").expect("sort"), "10\n100\n9\n");
}

#[test]
fn streaming_sort_reverse_and_unique_compose() {
    assert_eq!(sorted(&["-r"], "a\nc\nb\n").expect("sort"), "c\nb\na\n");
    assert_eq!(sorted(&["-u"], "b\na\nb\n").expect("sort"), "a\nb\n");
    assert_eq!(
        sorted(&["-n", "-r", "-u"], "2\n1\n2\n").expect("sort"),
        "2\n1\n"
    );
}

#[test]
fn streaming_sort_orders_nan_keys_as_text_before_numbers() {
    assert_eq!(
        sorted(&["-n"], "5\nnan\n3\nNaN\n1\n").expect("sort"),
        "NaN\nnan\n1\n3\n5\n"
    );
}

#[test]
fn streaming_sort_refuses_unsupported_flags() {
    let failure = sorted(&["-k", "2"], "a\n").expect_err("key sorting is unsupported");
    assert!(matches!(failure, CommandFailure::Status { message, .. } if message.contains("-k")));
}

#[test]
fn sorted_lines_hold_their_charges_until_the_command_finishes() {
    let mut budget = Budget::start(Limits {
        max_value_bytes: 3,
        ..Limits::default()
    });
    let mut reader = PipeReader::from_bytes(b"a\nb\n".to_vec());
    let failure = ExtraStream::Sort
        .run(&[], &mut reader, &mut budget, &NoCapabilities, |_| Ok(true))
        .expect_err("two retained two-byte lines do not fit in three bytes");
    assert!(matches!(
        failure,
        CommandFailure::Fatal(FatalError::Limit(LimitExceeded::ValueBytes { .. }))
    ));
    let mut reader = PipeReader::from_bytes(b"a\nb\n".to_vec());
    let mut budget = Budget::start(Limits {
        max_value_bytes: 4,
        ..Limits::default()
    });
    for _ in 0..2 {
        assert_eq!(
            ExtraStream::Sort
                .run(&[], &mut reader, &mut budget, &NoCapabilities, |_| Ok(true))
                .expect("retained bytes are refunded"),
            ExitCode::SUCCESS
        );
        reader = PipeReader::from_bytes(b"a\nb\n".to_vec());
    }
}