rr-mux 0.1.0

A Request Response Multiplexer for building protocol handlers etc.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106


use std::sync::{Mutex, Arc};
use std::collections::VecDeque;
use std::fmt::Debug;

use futures::prelude::*;
use futures::future;

use crate::mux::Muxed;
use crate::connector::Connector;

/// MockResponse is a mocked request expectation
#[derive(Debug, PartialEq)]
pub struct MockRequest<ID, ADDR, REQ, RESP, ERR> {
    id: ID,
    to: ADDR,
    req: REQ,
    from: ADDR,
    resp: RESP,
    err: ERR,
}

/// MockResponse is a mocked response expectation
#[derive(Debug, PartialEq)]
pub struct MockResponse<ID, ADDR, RESP, ERR> {
    id: ID,
    to: ADDR,
    resp: RESP,
    err: ERR,
}

// MockTransaction is a transaction expectation
pub type MockTransaction<ID, ADDR, REQ, RESP, ERR> = Muxed<MockRequest<ID, ADDR, REQ, RESP, ERR>, MockResponse<ID, ADDR, RESP, ERR>>;

/// MockConnector provides an expectation based mock connector implementation
pub struct MockConnector<ID, ADDR, REQ, RESP, ERR> 
{
    transactions: Arc<Mutex<VecDeque<MockTransaction<ID, ADDR, REQ, RESP, ERR>>>>,
}

impl <ID, ADDR, REQ, RESP, ERR> MockConnector <ID, ADDR, REQ, RESP, ERR> 
where
    ID: PartialEq + Debug + 'static,
    ADDR: PartialEq + Debug + 'static,
    REQ: PartialEq + Debug + 'static,
    RESP: PartialEq + Debug + 'static,
    ERR: PartialEq + Debug + 'static,
{
    /// Create a new mock connector
    pub fn new() -> MockConnector<ID, ADDR, REQ, RESP, ERR> {
        MockConnector{transactions: Arc::new(Mutex::new(VecDeque::new()))}
    }

    /// Set expectations on the connector
    pub fn expect<E>(&mut self, transactions: E)
    where
        E: Into<VecDeque<MockTransaction<ID, ADDR, REQ, RESP, ERR>>>,
    {
        *self.transactions.lock().unwrap() = transactions.into();
    }

    /// Finalise expectations on the connector
    pub fn finalise(&mut self) {
        let transactions: Vec<_> = self.transactions.lock().unwrap().drain(..).collect();
        let expectations = Vec::<MockTransaction<ID, ADDR, REQ, RESP, ERR>>::new();
        assert_eq!(expectations, transactions, "not all transactions have been evaluated");
    }
}

impl <ID, ADDR, REQ, RESP, ERR> Connector <ID, ADDR, REQ, RESP, ERR> for MockConnector <ID, ADDR, REQ, RESP, ERR> 
where
    ID: PartialEq + Debug + 'static,
    ADDR: PartialEq + Debug + 'static,
    REQ: PartialEq + Debug + 'static,
    RESP: PartialEq + Debug + 'static,
    ERR: PartialEq + Debug + 'static,
{
    /// Make a request and return the pre-set response
    /// This checks the request against the specified expectations
    fn request(&mut self, _id: ID, addr: ADDR, req: REQ) -> Box<Future<Item=RESP, Error=ERR>> {
        
        let mut transactions = self.transactions.lock().unwrap();
        
        let transaction = transactions.pop_front().expect("no more transactions available");
        let request = transaction.req().expect("expected request");

        assert_eq!(request.to, addr, "destination mismatch");
        assert_eq!(request.req, req, "request mismatch");

        Box::new(future::ok(request.resp))
    }

    /// Make a response
    /// This checks the response against provided expectations
    fn respond(&mut self, _id: ID, addr: ADDR, resp: RESP) -> Box<Future<Item=(), Error=ERR>> {
        let mut transactions = self.transactions.lock().unwrap();

        let transaction = transactions.pop_front().expect("no more transactions available");
        let response = transaction.resp().expect("expected response");

        assert_eq!(response.to, addr, "destination mismatch");
        assert_eq!(response.resp, resp, "request mismatch");
        
        Box::new(future::ok(()))
    }
}