ev_lib 0.3.2

EV-invest shared Rust libraries, one per feature
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! End-to-end usage of the `architecture` kernel from an external consumer,
//! modelling a tiny bounded context the way `domain`/`backend` do.
#![cfg(feature = "architecture")]

use std::sync::Mutex;

use ev_lib::architecture::{AggregateRoot, Entity, Gateway, Id, Reader, Repository, Specification, UnitOfWork};

type BlogId = Id<BlogTag>;
trait BlogRepository: Repository<Aggregate = Blog> + Reader<Aggregate = Blog> {
	fn create(&self, blog: Blog);
	fn find(&self, id: BlogId) -> Option<Blog>;
}
struct BlogTag;

#[derive(Clone)]
struct Blog {
	id: BlogId,
	published: bool,
	words: u32,
}

impl Entity for Blog {
	type Id = BlogId;

	fn id(&self) -> BlogId {
		self.id
	}
}

impl AggregateRoot for Blog {
	const NAME: &'static str = "blog";
}

// --- Specifications: a reusable rule and a composed one ---------------------

struct Published;
impl Specification<Blog> for Published {
	fn holds(&self, blog: &Blog) -> bool {
		blog.published
	}
}

#[test]
fn specifications_compose() {
	let long = |b: &Blog| b.words >= 1_000;
	let featured = Published.and(long);

	let a = Blog {
		id: BlogId::new(),
		published: true,
		words: 2_000,
	};
	let b = Blog {
		id: BlogId::new(),
		published: false,
		words: 2_000,
	};
	let c = Blog {
		id: BlogId::new(),
		published: true,
		words: 10,
	};

	assert!(featured.holds(&a));
	assert!(!featured.holds(&b));
	assert!(!featured.holds(&c));
	assert!(Published.not().holds(&b));
}

// --- Repository / Reader markers on a concrete adapter ----------------------

#[derive(Default)]
struct InMemoryBlogs {
	rows: Mutex<Vec<Blog>>,
}

impl Repository for InMemoryBlogs {
	type Aggregate = Blog;
}
impl Reader for InMemoryBlogs {
	type Aggregate = Blog;
}

impl BlogRepository for InMemoryBlogs {
	fn create(&self, blog: Blog) {
		self.rows.lock().unwrap().push(blog);
	}

	fn find(&self, id: BlogId) -> Option<Blog> {
		self.rows.lock().unwrap().iter().find(|b| b.id() == id).cloned()
	}
}

#[test]
fn repository_is_object_safe_and_round_trips() {
	let repo: &dyn BlogRepository = &InMemoryBlogs::default();
	let id = BlogId::new();
	repo.create(Blog { id, published: true, words: 1 });

	assert!(repo.find(id).is_some());
	assert!(repo.find(BlogId::new()).is_none());
	assert_eq!(Blog::NAME, "blog");
}

// --- Gateway marker on an external system -----------------------------------

struct FakeLedger;
impl Gateway for FakeLedger {}

#[test]
fn gateway_is_a_marker() {
	fn assert_gateway<G: Gateway>(_: &G) {}
	assert_gateway(&FakeLedger);
}

// --- UnitOfWork: consumed on commit -----------------------------------------

struct Tx;

#[async_trait::async_trait]
impl UnitOfWork for Tx {
	type Error = std::convert::Infallible;

	async fn commit(self: Box<Self>) -> Result<(), Self::Error> {
		Ok(())
	}

	async fn rollback(self: Box<Self>) -> Result<(), Self::Error> {
		Ok(())
	}
}

#[tokio::test]
async fn unit_of_work_commits() {
	let uow: Box<dyn UnitOfWork<Error = std::convert::Infallible>> = Box::new(Tx);
	uow.commit().await.unwrap();
}