Struct TestDag 

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

Dag structure for testing purpose.

Fields

dag: Dag

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 add_one_vertex(&mut self, name: &str, parents: &str)

Add one vertex to the non-master group. parents is split by whitespaces.

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<Set>, new_master: impl Into<Set>, ) -> Result<()>

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

pub async fn export_pull_data( &self, common: impl Into<Set>, heads: impl Into<Set>, ) -> Result<CloneData<Vertex>>

Generate the “pull data”. This is intended to be called from a “server”.

pub async fn import_pull_data( &mut self, pull_data: CloneData<Vertex>, head_opts: impl Into<VertexListWithOptions>, ) -> Result<()>

Imports the “pull data”. This is intended to be called from a “client”.

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.

Methods from Deref<Target = Dag>

pub async fn set_managed_virtual_group( &mut self, items: Option<Vec<(Vertex, Vec<Vertex>)>>, ) -> Result<()>

Set the content of the VIRTUAL group that survives reloading.

items is a list of vertexes and parents. The vertexes MUST be unique and not already exist in non-VIRTUAL groups. This assumption is used as an optimization to avoid remote lookups.

Existing content of the VIRTUAL group will be cleared before inserting items. So this API feels declarative. As a comparison, add_heads is imperative.

This function calls maybe_recreate_virtual_group immediately to clear and update contents in the VIRTUAL group. maybe_recreate_virtual_group will be called automatically after graph changing operations: add_heads_and_flush, strip, flush, import_pull_data.

pub fn set_remote_protocol( &mut self, protocol: Arc<dyn RemoteIdConvertProtocol>, )

Set the remote protocol for converting between Id and Vertex remotely.

This is usually used on “sparse” (“lazy”) Dag where the IdMap is incomplete for vertexes in the master groups.

pub fn dag(&self) -> &IdDag<IS>

pub fn map(&self) -> &M

Trait Implementations

impl Deref for TestDag

type Target = AbstractDag<IdDag<IndexedLogStore>, IdMap, IndexedLogDagPath, DagState>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TestDag

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.