# Acceptance criteria

_Requirement:_ CI broker can run its adapter.

given file shutdown.json

given file set-rid

when I run env HOME=../homedir python3 set-rid trigger.json testy

given an installed ci-broker

given file broker.yaml

when I run chmod +x dummy.sh

when I run sed -i 's/"auto"/false/' homedir/.radicle/config.json

then command is successful

~~~

_Requirement:_ If the CI broker can't connect to the Radicle node

control socket, it gives an error message that helps the user to

then stderr contains "ERROR: node control socket does not exist: xyzzy.sock"

~~~

_Requirement:_ If the CI broker is given a configuration file that it

can't understand, it gives an error message that explains the problem

This file is not YAML.

~~~

_Requirement:_ If the connection to the Radicle node, via its control

socket, breaks, the CI broker terminates with a message saying why.

given an installed ci-broker

given an installed synthetic-events

given file broker.yaml

when I run sed -i 's/"auto"/false/' homedir/.radicle/config.json

when I try to run env HOME=homedir RAD_HOME=homedir/.radicle RAD_SOCKET=synt.sock ci-broker broker.yaml

then stderr contains "connection to the node control socket broke"

~~~

_Requirement:_ The test suite can request the CI broker to shut down

cleanly, and it doesn't result in an error.

given an installed synthetic-events

given file shutdown.json

given file broker.yaml

when I run sed -i 's/"auto"/false/' homedir/.radicle/config.json

when I try to run env RUST_LOG=trace HOME=homedir RAD_HOME=homedir/.radicle RAD_SOCKET=synt.sock ci-broker broker.yaml

then command is successful

~~~

# Acceptance criteria for test tooling

Note also that the version of `nc` must support the `-U` option, which

in Debian means using the `netcat-openbsd` package.

~~~scenario

given an installed synthetic-events

then file synt.sock exists

when I run nc -U synt.sock

then file synt.sock does not exist

~~~

        debug!("send request to sub-process stdin");

        {

            let stdin = child.stdin.take().ok_or(AdapterError::StdinHandle)?;

        }

        // Get the child's stdout into a BufReader so that we can loop

        if let Some(line) = lines.next() {

            let line = line.map_err(AdapterError::ReadLine)?;

            debug!("first response {resp:#?}");

            match resp {

                Response::Triggered { run_id } => {

        if let Some(line) = lines.next() {

            let line = line.map_err(AdapterError::ReadLine)?;

            debug!("second response {resp:#?}");

            match resp {

                Response::Finished { result } => {

        if let Some(line) = lines.next() {

            let line = line.map_err(AdapterError::ReadLine)?;

            debug!("third response is too many {resp:#?}");

            return Err(AdapterError::TooMany(resp));

        } else {

#[derive(Debug, thiserror::Error)]

pub enum AdapterError {

    /// Error from spawning a sub-process.

    #[error("failed to spawn a CI adapter sub-process: {0}")]

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

"#;

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"failure"}'

"#;

        let mut run = run();

        let mut status = status_page();

        Ok(())

    }

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"failure"}'

echo woe be me 1>&2

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        assert!(x.is_err());

        assert_eq!(run.result(), Some(&RunResult::Failure));

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        Ok(())

    }

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

kill -9 $BASHPID

"#;

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        assert!(matches!(x, Err(AdapterError::Failed(_))));

        Ok(())

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

kill -9 $BASHPID

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        assert!(matches!(x, Err(AdapterError::Failed(_))));

        Ok(())

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success","bad":"field"}'

"#;

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        Ok(())

    }

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"finished","result":"success"}'

"#;

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        assert!(matches!(

            x,

            Err(AdapterError::NotTriggered(Response::Finished {

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

echo '{"response":"finished","result":"success"}'

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        assert!(matches!(

            x,

            Err(AdapterError::TooMany(Response::Finished {

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        match x {

            Err(AdapterError::SpawnAdapter(filename, e)) => {

                assert_eq!(bin, filename);

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

"#;

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        match x {

            Err(AdapterError::SpawnAdapter(filename, e)) => {

                assert_eq!(bin, filename);

        // loaded due to missing dynamic linker or library or such.

        const ADAPTER: &str = r#"#!/bin/does-not-exist

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

"#;

        let mut run = run();

        let mut status = status_page();

        let x = Adapter::new(&bin).run(&trigger_request()?, &mut run, &mut status);

        match x {

            Err(AdapterError::SpawnAdapter(filename, e)) => {

                assert_eq!(bin, filename);

use std::{

    env::current_exe,

    os::unix::net::UnixListener,

    path::PathBuf,

    process::{Command, Stdio},

use radicle::node::Event;

fn main() -> anyhow::Result<()> {

    let args = Args::parse();

    let exe = current_exe()?;

    if args.daemon {

        let mut events = vec![];

        for filename in args.events.iter() {

            let data = read(filename)?;

            let e: Event = serde_json::from_slice(&data)?;

            let mut e = serde_json::to_string(&e)?;

            events.push(e);

        }

        let listener = UnixListener::bind(&args.socket)?;

        if let Some(stream) = listener.incoming().next() {

            let mut stream = stream?;

            for e in events.iter() {

                stream.write_all(e.as_bytes())?;

            }

        }

        remove_file(&args.socket)?;

    } else {

        if args.socket.exists() {

            eprintln!("removing socket {}", args.socket.display());

        eprintln!("launching daemon");

        Command::new(exe)

            .arg("--daemon")

            .arg(&args.socket)

            .args(&args.events)

            .stdin(Stdio::null())

struct Args {

    #[clap(long)]

    daemon: bool,

    socket: PathBuf,

    events: Vec<PathBuf>,

}

//! This is type and module of its own to facilitate automated

//! testing.

use log::{debug, error, info};

use time::{macros::format_description, OffsetDateTime};

                    debug!("broker runs adapter");

                    if let Err(e) = adapter.run(trigger, &mut run, status) {

                        error!("failed to run adapter or it failed to run CI: {e}");

                    }

                    debug!("broker run {run:#?}");

    #[test]

    fn executes_adapter() -> TestResult<()> {

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

"#;

        log_in_tests();

        const ADAPTER: &str = r#"#!/bin/bash

echo '{"response":"triggered","run_id":{"id":"xyzzy"}}'

echo '{"response":"finished","result":"success"}'

echo woe be me 1>&2