clankerdiff-client 0.3.3

Renderer-independent local and remote diff client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use clankerdiff_client::{
    ClientState, ConnectionState, DiffSnapshot, RemoteError, RemoteErrorCode,
    protocol::{server::ServerEvent, shared::LIVE_PROTOCOL_VERSION},
};
use clankerdiff_core::{DiffScope, testing::DocumentBuilder};
use std::sync::Arc;

#[test]
fn reduces_initialization_then_documents() {
    let state = initialized().apply(&document(DiffScope::Staged));

    assert!(matches!(state.connection, ConnectionState::Connected));
    assert!(state.capabilities.repository && state.capabilities.submit);
    assert_eq!(
        state.snapshot.as_ref().expect("snapshot").scope,
        DiffScope::Staged
    );
}

#[test]
fn request_results_leave_state_untouched() {
    let state = initialized();
    assert_eq!(
        state.clone().apply(&ServerEvent::RequestResult(Ok(()))),
        state
    );
}

#[test]
fn health_replaces_only_the_error() {
    let error = RemoteError::new(RemoteErrorCode::Git, "git failed");
    let state = initialized().apply(&ServerEvent::Health {
        error: Some(error.clone()),
    });

    assert_eq!(state.error.as_ref(), Some(&error));
    assert!(matches!(state.connection, ConnectionState::Connected));
    assert!(
        state.capabilities.repository,
        "health does not affect capabilities"
    );

    assert_eq!(
        state.apply(&ServerEvent::Health { error: None }).error,
        None
    );
}

#[test]
fn a_terminal_error_fails_the_connection() {
    let failed = initialized().apply(&ServerEvent::Error(RemoteError::new(
        RemoteErrorCode::Watcher,
        "watcher stopped",
    )));

    assert!(matches!(failed.connection, ConnectionState::Failed(_)));
    assert!(!failed.capabilities.repository);
}

fn initialize() -> ServerEvent {
    ServerEvent::Initialize {
        protocol_version: LIVE_PROTOCOL_VERSION,
        repository_root: "/repo".to_owned(),
    }
}

fn document(scope: DiffScope) -> ServerEvent {
    ServerEvent::Document(Arc::new(DiffSnapshot {
        scope,
        document: DocumentBuilder::new().changed("a", "old", "new").build(),
    }))
}

fn initialized() -> ClientState {
    ClientState::default()
        .apply(&initialize())
        .apply(&document(DiffScope::Both))
}