Struct TestDag

pub struct TestDag {
    pub dag: NameDag,
    pub seg_size: usize,
    pub dir: TempDir,
    pub output: Arc<Mutex<Vec<String>>>,
}

Dag structure for testing purpose.

Fields

dag: NameDag

seg_size: usize

dir: TempDir

output: Arc<Mutex<Vec<String>>>

Implementations

impl TestDag

pub fn new() -> Self

Creates a TestDag for testing. Side effect of the TestDag will be removed on drop.

pub fn draw(text: &str) -> Self

Crates a TestDag using the given ASCII.

This is just new, followed by drawdag, with an extra rule that comments like “# master: M” at the end can be used to specify master heads .

pub async fn draw_client(text: &str) -> Self

Similar to draw but creates a lazy client so all vertexes in the master group are lazy.

pub fn new_with_segment_size(seg_size: usize) -> Self

Creates a TestDag with a specific segment size.

pub fn reopen(&mut self)

Reopen the dag. Drop in-memory state including caches.

pub fn drawdag(&mut self, text: &str, master_heads: &[&str])

Add vertexes to the graph. Does not resolve vertexes remotely.

pub async fn drawdag_async(&mut self, text: &str, master_heads: &[&str])

Add vertexes to the graph. Async version that might resolve vertexes remotely on demand.

pub fn drawdag_with_limited_heads( &mut self, text: &str, master_heads: &[&str], heads: Option<&[&str]>, )

Add vertexes to the graph.

If heads is set, ignore part of the graph. Only consider specified heads.

pub async fn drawdag_with_limited_heads_async( &mut self, text: &str, master_heads: &[&str], heads: Option<&[&str]>, validate: bool, )

pub async fn flush(&mut self, master_heads: &str)

Flush space-separated master heads.

pub fn annotate_ascii(&self, text: &str) -> String

Replace ASCII with Ids in the graph.

pub fn render_segments(&self) -> String

Render the segments.

pub fn render_graph(&self) -> String

Render the graph.

pub async fn client(&self) -> TestDag

Use this DAG as the “server”, return the “client” Dag that has lazy Vertexes.

pub fn set_remote(&mut self, server_dag: &Self)

Update remote protocol to use the (updated) server graph.

pub fn with_remote(self, server_dag: &Self) -> Self

Alternative syntax of set_remote.

pub async fn client_cloned_data(&self) -> TestDag

Similar to client, but also clone the Dag from the server.

pub async fn pull_ff_master( &mut self, server: &Self, old_master: impl Into<Vertex>, new_master: impl Into<Vertex>, ) -> Result<()>

Pull from the server Dag using the master fast forward fast path.

pub async fn strip(&mut self, names: &'static str)

Strip space-separated vertexes.

pub fn remote_protocol( &self, output: Arc<Mutex<Vec<String>>>, ) -> Arc<dyn RemoteIdConvertProtocol>

Remote protocol used to resolve Id <-> Vertex remotely using the test dag as the “server”.

Logs of the remote access will be written to output.

pub fn debug_segments(&self, level: Level, group: Group) -> String

Describe segments at the given level and group as a string.

pub fn output(&self) -> Vec<String>

Output of remote protocols since the last call.

pub fn contains_vertex_locally(&self, name: impl Into<Vertex>) -> bool

Check that a vertex exists locally.