forked from yvv/decision
2306 lines
112 KiB
Rust
2306 lines
112 KiB
Rust
//! The vote, grouped, and the vote on the Ğ1 chain (ADR 0008): sealed by the
|
|
//! server, confirmed by reading an indexer — here a small simulated indexer that
|
|
//! answers the GraphQL query in the shape of the real one
|
|
//! (`tests/fixtures/indexer-merci.json`, relevé on indexer.duniter.org).
|
|
|
|
use axum::body::Body;
|
|
use axum::extract::State;
|
|
use axum::http::{Request, StatusCode, header};
|
|
use axum::response::{IntoResponse, Response};
|
|
use axum::routing::post;
|
|
use axum::{Json, Router};
|
|
use http_body_util::BodyExt;
|
|
use ld_engine::address::{self, G1_PREFIX};
|
|
use ld_engine::ballot::{blake2_256, to_hex};
|
|
use ld_server::config::VoteChain;
|
|
use ld_server::{AppState, CSRF_HEADER, CSRF_VALUE, Config, app, ballots, open_db, seed};
|
|
use serde_json::{Value, json};
|
|
use std::sync::{Arc, Mutex};
|
|
use tower::ServiceExt;
|
|
|
|
// Substrate's well-known development keys, as Ğ1 addresses: no real account is touched.
|
|
const VOTE_ACCOUNT: &str = "g1L5EYvvSBaYuQCPW78bHxYcvHfmWAqHYe3Gsrp9SV4kWZaEM"; // Dave
|
|
const ALICE: &str = "g1Pn1geRZnHcVdWdKkoYwQrAARDTXK1D7H3zuXj7GNayT1thu";
|
|
const ALICE_GENERIC: &str = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
|
|
const BOB: &str = "g1NCrQaFReZcbUW8pKsazfWFCKNSdrTomnDraUMybJc4DFF5g";
|
|
const CHARLIE: &str = "g1NFWUkPTyZWE77YUrfBKfAhV9W81qmgdD17v1NGhb1EjYFqi";
|
|
const OTHER: &str = "g1QBoGEqZuxL77pF4rMa25f1cH6HAxwgBq66zZu76JPqsaVgj"; // Eve
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// A simulated indexer
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[derive(Default)]
|
|
struct Chain {
|
|
comments: Vec<Value>,
|
|
silent: bool,
|
|
asked: usize,
|
|
/// The last final block, served as `squidStatus.height`; `None`: every block is final.
|
|
finalized: Option<u32>,
|
|
/// An indexer that ignores the filter it is given (the hash only holds).
|
|
lax: bool,
|
|
/// The filters the server asked with, in order.
|
|
filters: Vec<Value>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct Indexer {
|
|
chain: Arc<Mutex<Chain>>,
|
|
url: String,
|
|
}
|
|
|
|
/// Who signed, and the identity of that account, as the indexer serves it.
|
|
struct Signer<'a> {
|
|
account: &'a str,
|
|
identity: Option<(u32, &'a str, bool)>,
|
|
}
|
|
|
|
/// What the real indexer's `filter` keeps, for the two filters the server may ask.
|
|
fn kept_by(node: &Value, filter: &Value) -> bool {
|
|
if let Some(author) = filter["authorId"]["equalTo"].as_str()
|
|
&& node["author"]["id"] != author
|
|
{
|
|
return false;
|
|
}
|
|
let some = &filter["transfersByCommentId"]["some"];
|
|
if some.is_null() {
|
|
return true;
|
|
}
|
|
let min: u64 = some["amount"]["greaterThanOrEqualTo"].as_str().and_then(|a| a.parse().ok()).unwrap_or(0);
|
|
node["transfersByCommentId"]["nodes"].as_array().into_iter().flatten().any(|t| {
|
|
some["toId"]["equalTo"].as_str().is_none_or(|to| t["toId"] == to)
|
|
&& t["amount"].as_str().and_then(|a| a.parse::<u64>().ok()).is_some_and(|a| a >= min)
|
|
})
|
|
}
|
|
|
|
/// The size of a page: `first: N` in the query, as the server writes it.
|
|
fn page_size(query: &str) -> usize {
|
|
query
|
|
.split("first:")
|
|
.nth(1)
|
|
.and_then(|rest| rest.trim_start().split(|c: char| !c.is_ascii_digit()).next())
|
|
.and_then(|n| n.parse().ok())
|
|
.unwrap_or(100)
|
|
}
|
|
|
|
async fn graphql(State(chain): State<Arc<Mutex<Chain>>>, Json(body): Json<Value>) -> Response {
|
|
let mut c = chain.lock().expect("lock");
|
|
c.asked += 1;
|
|
if c.silent {
|
|
return StatusCode::BAD_GATEWAY.into_response();
|
|
}
|
|
let vars = &body["variables"];
|
|
let hash = vars["hash"].as_str().unwrap_or_default().to_owned();
|
|
let filter = vars["filter"].clone();
|
|
c.filters.push(filter.clone());
|
|
let mut nodes: Vec<Value> = c
|
|
.comments
|
|
.iter()
|
|
.filter(|n| format!("0x{}", to_hex(&blake2_256(n["remark"].as_str().unwrap_or_default().as_bytes()))) == hash)
|
|
.filter(|n| c.lax || kept_by(n, &filter))
|
|
.cloned()
|
|
.collect();
|
|
nodes.sort_by_key(|n| (n["blockNumber"].as_u64(), n["id"].as_str().map(str::to_owned)));
|
|
// Pages, as PostGraphile serves them: `first`, then `after` the cursor of the last one.
|
|
let start: usize =
|
|
vars["after"].as_str().and_then(|a| a.strip_prefix("at:")).and_then(|n| n.parse().ok()).unwrap_or(0);
|
|
let page: Vec<Value> =
|
|
nodes.iter().skip(start).take(page_size(body["query"].as_str().unwrap_or_default())).cloned().collect();
|
|
let end = start + page.len();
|
|
Json(json!({ "data": {
|
|
"squidStatus": { "height": c.finalized.unwrap_or(1_000_000_000) },
|
|
"txComments": {
|
|
"pageInfo": { "hasNextPage": end < nodes.len(), "endCursor": format!("at:{end}") },
|
|
"nodes": page,
|
|
},
|
|
} }))
|
|
.into_response()
|
|
}
|
|
|
|
impl Indexer {
|
|
async fn start() -> Self {
|
|
let chain = Arc::new(Mutex::new(Chain::default()));
|
|
let router = Router::new().route("/v1/graphql", post(graphql)).with_state(chain.clone());
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("bind");
|
|
let addr = listener.local_addr().expect("addr");
|
|
tokio::spawn(async move { axum::serve(listener, router).await.expect("serve") });
|
|
Self { chain, url: format!("http://{addr}/v1/graphql") }
|
|
}
|
|
|
|
/// A transaction on the chain: the remark, signed by `signer`, with its transfers.
|
|
fn add(&self, block: u32, event: u32, remark: &str, signer: Signer<'_>, transfers: &[(&str, u64)]) {
|
|
let identity =
|
|
signer.identity.map(|(index, name, member)| json!({ "index": index, "name": name, "isMember": member }));
|
|
let transfers: Vec<Value> = transfers
|
|
.iter()
|
|
.map(|(to, amount)| json!({ "fromId": signer.account, "toId": to, "amount": amount.to_string() }))
|
|
.collect();
|
|
self.chain.lock().expect("lock").comments.push(json!({
|
|
"id": format!("{block:010}-abcde-{event:06}"), "blockNumber": block, "remark": remark,
|
|
"author": { "id": signer.account, "identity": identity },
|
|
"transfersByCommentId": { "nodes": transfers },
|
|
}));
|
|
}
|
|
|
|
/// The usual vote: 0.1 Ğ1 to the vote account.
|
|
fn pay(&self, block: u32, remark: &str, signer: Signer<'_>) {
|
|
self.add(block, 1, remark, signer, &[(VOTE_ACCOUNT, 10)]);
|
|
}
|
|
|
|
fn silent(&self, on: bool) {
|
|
self.chain.lock().expect("lock").silent = on;
|
|
}
|
|
|
|
fn asked(&self) -> usize {
|
|
self.chain.lock().expect("lock").asked
|
|
}
|
|
|
|
/// The chain is final up to this block.
|
|
fn finalized(&self, block: Option<u32>) {
|
|
self.chain.lock().expect("lock").finalized = block;
|
|
}
|
|
|
|
fn lax(&self, on: bool) {
|
|
self.chain.lock().expect("lock").lax = on;
|
|
}
|
|
|
|
fn filters(&self) -> Vec<Value> {
|
|
self.chain.lock().expect("lock").filters.clone()
|
|
}
|
|
}
|
|
|
|
fn alice() -> Signer<'static> {
|
|
Signer { account: ALICE, identity: Some((9001, "Alice", true)) }
|
|
}
|
|
|
|
fn chain_config(indexer: &Indexer) -> Config {
|
|
let mut cfg = Config::for_tests();
|
|
cfg.indexers = vec![indexer.url.clone()];
|
|
cfg.vote = VoteChain::new(VOTE_ACCOUNT, 10, vec!["wss://node.invalid".into()], None);
|
|
cfg
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// A client of the API
|
|
// ---------------------------------------------------------------------------
|
|
|
|
struct Client {
|
|
router: axum::Router,
|
|
cookie: Option<String>,
|
|
}
|
|
|
|
impl Client {
|
|
async fn new(cfg: Config) -> (Self, AppState) {
|
|
let db = open_db("sqlite::memory:").await.expect("db");
|
|
let state = AppState::new(cfg, db).await.expect("state");
|
|
seed::ensure(&state).await.expect("seed");
|
|
(Self { router: app(state.clone()), cookie: None }, state)
|
|
}
|
|
|
|
fn other(&self) -> Self {
|
|
Self { router: self.router.clone(), cookie: None }
|
|
}
|
|
|
|
async fn call(&mut self, method: &str, uri: &str, body: Option<Value>) -> (StatusCode, Value) {
|
|
let (status, _, value) = self.call_with_headers(method, uri, body).await;
|
|
(status, value)
|
|
}
|
|
|
|
async fn call_with_headers(
|
|
&mut self,
|
|
method: &str,
|
|
uri: &str,
|
|
body: Option<Value>,
|
|
) -> (StatusCode, axum::http::HeaderMap, Value) {
|
|
let mut req = Request::builder().method(method).uri(uri).header(CSRF_HEADER, CSRF_VALUE);
|
|
if let Some(c) = &self.cookie {
|
|
req = req.header(header::COOKIE, c);
|
|
}
|
|
let req = match body {
|
|
Some(b) => req.header(header::CONTENT_TYPE, "application/json").body(Body::from(b.to_string())),
|
|
None => req.body(Body::empty()),
|
|
}
|
|
.expect("request");
|
|
let res = self.router.clone().oneshot(req).await.expect("response");
|
|
let status = res.status();
|
|
if let Some(set) = res.headers().get(header::SET_COOKIE) {
|
|
let raw = set.to_str().expect("cookie").split(';').next().unwrap_or_default().to_owned();
|
|
if raw.starts_with("ld_session=") {
|
|
self.cookie = Some(raw);
|
|
}
|
|
}
|
|
let headers = res.headers().clone();
|
|
let bytes = res.into_body().collect().await.expect("body").to_bytes();
|
|
(status, headers, serde_json::from_slice(&bytes).unwrap_or(Value::Null))
|
|
}
|
|
|
|
async fn ok(&mut self, method: &str, uri: &str, body: Option<Value>) -> Value {
|
|
let (s, v) = self.call(method, uri, body).await;
|
|
assert_eq!(s, StatusCode::OK, "{method} {uri}: {v}");
|
|
v
|
|
}
|
|
|
|
async fn login(&mut self, name: &str) {
|
|
self.ok("POST", "/api/auth/dev", Some(json!({ "name": name, "admin": false }))).await;
|
|
}
|
|
|
|
async fn login_admin(&mut self, name: &str) {
|
|
self.ok("POST", "/api/auth/dev", Some(json!({ "name": name, "admin": true }))).await;
|
|
}
|
|
|
|
async fn doc(&mut self, group: &str) -> Value {
|
|
let g = self.ok("GET", &format!("/api/groups/{group}"), None).await;
|
|
let id = g["docs"][0]["id"].as_str().expect("doc").to_owned();
|
|
self.ok("GET", &format!("/api/docs/{id}"), None).await
|
|
}
|
|
|
|
/// A pending ballot for `lines` (version id, choice).
|
|
async fn ballot(&mut self, doc: &Value, lines: &[(&str, Option<&str>)], author: Option<&str>) -> Value {
|
|
let id = doc["doc"]["id"].as_str().expect("id");
|
|
let lines: Vec<Value> = lines.iter().map(|(p, c)| json!({ "proposalId": p, "choice": c })).collect();
|
|
self.ok("POST", &format!("/api/docs/{id}/ballots"), Some(json!({ "lines": lines, "author": author }))).await["ballot"]
|
|
.clone()
|
|
}
|
|
|
|
async fn status(&mut self, ballot: &Value) -> Value {
|
|
let id = ballot["id"].as_str().expect("id");
|
|
self.ok("GET", &format!("/api/ballots/{id}"), None).await["ballot"].clone()
|
|
}
|
|
}
|
|
|
|
/// The quorum of an article set to 2, as its author — an administrator, for a text of the
|
|
/// seed — sets it before the first vote (ADR 0013). In the test group, where the quorum
|
|
/// of every level is 1 and one voice passes, one voice of two then no longer does.
|
|
async fn two_voices(state: &AppState, group: &str, code: &str) {
|
|
let n = sqlx::query(
|
|
"UPDATE units SET quorum = 2 WHERE code = ? AND doc_id IN (SELECT id FROM documents WHERE group_slug = ?)",
|
|
)
|
|
.bind(code)
|
|
.bind(group)
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("quorum")
|
|
.rows_affected();
|
|
assert_eq!(n, 1, "{group} {code}");
|
|
}
|
|
|
|
/// A web of two members and the quorum 2 at every level of a document, for the test
|
|
/// only (ADR 0013): two voices pass, one never does.
|
|
async fn small_web(state: &AppState, doc_id: &str) {
|
|
sqlx::query("UPDATE documents SET vote_floor = 1, quorums = '[2,2,2,2,2]' WHERE id = ?")
|
|
.bind(doc_id)
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("quorums");
|
|
sqlx::query(
|
|
"INSERT INTO settings (key, value, updated_at) VALUES ('wot_size', '2', '2026-11-02T00:00:00Z')
|
|
ON CONFLICT(key) DO UPDATE SET value = '2'",
|
|
)
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("web");
|
|
}
|
|
|
|
fn unit<'a>(doc: &'a Value, code: &str) -> &'a Value {
|
|
doc["units"].as_array().expect("units").iter().find(|u| u["code"] == code).expect("unit")
|
|
}
|
|
|
|
/// The id of a version: `inForce`, or the n-th open proposal.
|
|
fn version(doc: &Value, code: &str, which: &str) -> String {
|
|
let u = unit(doc, code);
|
|
let v = if which == "inForce" { &u["inForce"] } else { &u["proposals"][which.parse::<usize>().expect("n")] };
|
|
v["id"].as_str().expect("id").to_owned()
|
|
}
|
|
|
|
/// The version as the document shows it now, by id.
|
|
fn find<'a>(doc: &'a Value, id: &str) -> &'a Value {
|
|
doc["units"]
|
|
.as_array()
|
|
.expect("units")
|
|
.iter()
|
|
.flat_map(|u| std::iter::once(&u["inForce"]).chain(u["proposals"].as_array().expect("p").iter()))
|
|
.find(|p| p["id"] == id)
|
|
.expect("version")
|
|
}
|
|
|
|
fn tally(doc: &Value, id: &str) -> (u64, u64) {
|
|
pair(&find(doc, id)["tally"])
|
|
}
|
|
|
|
fn pair(t: &Value) -> (u64, u64) {
|
|
(t["for"].as_u64().expect("for"), t["against"].as_u64().expect("against"))
|
|
}
|
|
|
|
/// The part of the totals shown still waiting for its proof (ADR 0012).
|
|
fn pending(doc: &Value, id: &str) -> (u64, u64) {
|
|
pair(&find(doc, id)["tallyPending"])
|
|
}
|
|
|
|
/// What adoption counts: never an intention without proof.
|
|
async fn counted(state: &AppState, doc: &Value, id: &str) -> (u32, u32) {
|
|
let st = ld_server::docs::load_state(state, doc["doc"]["id"].as_str().expect("doc")).await.expect("state");
|
|
let t = st.tally(id);
|
|
(t.for_votes, t.against)
|
|
}
|
|
|
|
/// « Ton vote » and where it stands.
|
|
fn mine<'a>(doc: &'a Value, id: &str) -> (Option<&'a str>, Option<&'a str>) {
|
|
let p = find(doc, id);
|
|
(p["myVote"].as_str(), p["myVoteState"].as_str())
|
|
}
|
|
|
|
/// The messages of a session about its ballots (ADR 0012): (kind, ballot id).
|
|
async fn ballot_messages(c: &mut Client) -> Vec<(String, String)> {
|
|
let m = c.ok("GET", "/api/messages", None).await;
|
|
m["messages"]
|
|
.as_array()
|
|
.expect("messages")
|
|
.iter()
|
|
.filter(|m| m["topic"] == "ballot")
|
|
.map(|m| (m["kind"].as_str().expect("kind").to_owned(), m["ballot"]["id"].as_str().expect("id").to_owned()))
|
|
.collect()
|
|
}
|
|
|
|
async fn rewind_check(state: &AppState) {
|
|
// The page asks often, the indexer is read at most every few seconds: tests rewind that clock.
|
|
sqlx::query("UPDATE ballots SET checked_at = NULL").execute(&state.db).await.expect("rewind");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// The vote on the chain
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test]
|
|
async fn a_grouped_ballot_is_sealed_then_confirmed_by_the_indexer() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
// Monnaie libre votes on the chain; this session may ask for a ballot.
|
|
assert_eq!(doc["vote"]["way"], "chain");
|
|
assert_eq!(doc["vote"]["open"], true);
|
|
assert_eq!(doc["canVote"], true);
|
|
assert_eq!(doc["vote"]["chain"]["account"], VOTE_ACCOUNT);
|
|
assert_eq!(doc["vote"]["chain"]["amount"], 10);
|
|
assert_eq!(doc["vote"]["chain"]["test"], false);
|
|
|
|
let i1 = version(&doc, "I1", "0");
|
|
let e3 = version(&doc, "E3", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for")), (&e3, Some("against"))], Some(ALICE_GENERIC)).await;
|
|
let comment = b["comment"].as_str().expect("comment");
|
|
assert!(comment.starts_with("ld1:") && comment.len() == 68 && comment[4..].bytes().all(|x| x.is_ascii_hexdigit()));
|
|
assert_eq!(b["status"], "pending");
|
|
assert_eq!(b["account"], VOTE_ACCOUNT);
|
|
assert_eq!(b["author"], ALICE, "the bound account, written as a Ğ1 address");
|
|
assert_eq!(b["lines"], 2);
|
|
// What the server keeps: the lines, the salt, and the seal they make.
|
|
let (digest, salt): (String, String) =
|
|
sqlx::query_as("SELECT digest, salt FROM ballots").fetch_one(&state.db).await.expect("ballot");
|
|
assert_eq!(format!("ld1:{digest}"), comment);
|
|
assert_eq!(salt.len(), 32);
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id");
|
|
let lines = [
|
|
ld_engine::ballot::Line { proposal_id: i1.clone(), revision: 1, choice: ld_engine::ballot::Choice::For },
|
|
ld_engine::ballot::Line { proposal_id: e3.clone(), revision: 1, choice: ld_engine::ballot::Choice::Against },
|
|
];
|
|
assert_eq!(ld_engine::ballot::seal(doc_id, Some(ALICE), &lines, &salt).expect("seal").comment, comment);
|
|
|
|
// Nothing on the chain yet: the intention is seen at once — her vote, the totals
|
|
// shown — and waits for its proof; adoption does not count it (ADR 0012).
|
|
assert_eq!(c.status(&b).await["status"], "pending");
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&doc, &i1), pending(&doc, &i1)), ((1, 0), (1, 0)));
|
|
assert_eq!((tally(&doc, &e3), pending(&doc, &e3)), ((0, 1), (0, 1)));
|
|
assert_eq!(counted(&state, &doc, &i1).await, (0, 0));
|
|
assert_eq!(mine(&doc, &i1), (Some("for"), Some("pending")));
|
|
assert_eq!(find(&doc, &i1)["myBallot"]["status"], "pending");
|
|
assert_eq!(find(&doc, &i1)["myBallot"]["choice"], "for");
|
|
|
|
// The transaction lands: one transaction for both lines.
|
|
indexer.pay(3_400_000, comment, alice());
|
|
rewind_check(&state).await;
|
|
let s = c.status(&b).await;
|
|
assert_eq!(s["status"], "confirmed", "{s}");
|
|
assert_eq!(s["voter"], "Alice");
|
|
assert_eq!(s["block"], 3_400_000);
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&doc, &i1), pending(&doc, &i1)), ((1, 0), (0, 0)));
|
|
assert_eq!(tally(&doc, &e3), (0, 1));
|
|
assert_eq!(counted(&state, &doc, &i1).await, (1, 0));
|
|
// The session that asked sees « ton vote », confirmed on the chain.
|
|
assert_eq!(mine(&doc, &i1), (Some("for"), Some("recorded")));
|
|
assert_eq!(find(&doc, &i1)["myVoteChain"], true);
|
|
assert!(find(&doc, &i1)["myBallot"].is_null());
|
|
assert_eq!(find(&doc, &e3)["myVote"], "against");
|
|
// The vote counts for the Ğ1 identity of the signer, created as a member.
|
|
let row: (String, String, bool, Option<String>) =
|
|
sqlx::query_as("SELECT kind, display_name, g1_member, address FROM identities WHERE id = 'idty:9001'")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("identity");
|
|
assert_eq!(row, ("g1".into(), "Alice".into(), true, Some(ALICE.into())));
|
|
let voters: Vec<(String, String)> = sqlx::query_as("SELECT identity_id, source FROM votes ORDER BY proposal_id")
|
|
.fetch_all(&state.db)
|
|
.await
|
|
.expect("votes");
|
|
assert!(voters.iter().all(|(who, source)| who == "idty:9001" && source == "chain"), "{voters:?}");
|
|
// One voice never makes a text pass: at level 2, the quorum 12, the 11 voters missing
|
|
// counted as against — 9 « pour » are asked (ADR 0013).
|
|
let e = &find(&doc, &i1)["evaluation"];
|
|
assert_eq!((e["quorum"].as_u64(), e["required"].as_u64(), e["yesNeeded"].as_u64()), (Some(12), Some(9), Some(9)));
|
|
assert_eq!(e["reached"], false);
|
|
// Someone else sees the totals, not the vote.
|
|
let mut yvv = c.other();
|
|
yvv.login("Yvv").await;
|
|
let seen = yvv.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&seen, &i1), (1, 0));
|
|
assert!(find(&seen, &i1)["myVote"].is_null());
|
|
// Asked again, a confirmed ballot stays as it is.
|
|
rewind_check(&state).await;
|
|
assert_eq!(c.status(&b).await["status"], "confirmed");
|
|
assert_eq!(
|
|
yvv.call("GET", &format!("/api/ballots/{}", b["id"].as_str().expect("id")), None).await.0,
|
|
StatusCode::NOT_FOUND
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn one_voice_on_the_chain_never_adopts_in_monnaie_libre() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Yvv").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let p = version(&doc, "E3", "0");
|
|
let b = c.ballot(&doc, &[(&p, Some("for"))], None).await;
|
|
indexer.pay(100, b["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&b).await;
|
|
assert_eq!(s["status"], "confirmed");
|
|
assert_eq!(s["entered"], json!([]));
|
|
let d = c.ok("GET", &format!("/api/proposals/{p}"), None).await;
|
|
// Level 3, the quorum 50: 39 « pour » of 50 voters, the 49 missing counted as against.
|
|
assert_eq!(d["proposal"]["evaluation"]["quorum"], 50);
|
|
assert_eq!(d["proposal"]["evaluation"]["required"], 39);
|
|
assert_eq!(d["proposal"]["evaluation"]["wellRated"], true);
|
|
assert_eq!(d["proposal"]["myVote"], "for");
|
|
assert_eq!(d["proposal"]["myVoteChain"], true);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_silent_indexer_keeps_the_ballot_pending() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(100, b["comment"].as_str().expect("comment"), alice());
|
|
indexer.silent(true);
|
|
assert_eq!(c.status(&b).await["status"], "pending");
|
|
assert!(indexer.asked() >= 1);
|
|
// Asked again at once: the indexer is not read again before a few seconds.
|
|
let asked = indexer.asked();
|
|
assert_eq!(c.status(&b).await["status"], "pending");
|
|
assert_eq!(indexer.asked(), asked);
|
|
// The background task reads it again; silent still, nothing changes.
|
|
assert_eq!(ballots::sweep(&state).await.expect("sweep"), 1);
|
|
assert_eq!(c.status(&b).await["status"], "pending");
|
|
// The indexer is back.
|
|
indexer.silent(false);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "confirmed");
|
|
assert_eq!(ballots::sweep(&state).await.expect("sweep"), 0, "nothing left to read");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_signer_who_is_not_a_member_is_refused_and_told() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let former = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(
|
|
100,
|
|
former["comment"].as_str().expect("c"),
|
|
Signer { account: BOB, identity: Some((42, "Bob", false)) },
|
|
);
|
|
let nobody = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(101, nobody["comment"].as_str().expect("c"), Signer { account: BOB, identity: None });
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&former).await;
|
|
assert_eq!((s["status"].as_str(), s["reason"].as_str()), (Some("refused"), Some("not_member")));
|
|
let s = c.status(&nobody).await;
|
|
assert_eq!((s["status"].as_str(), s["reason"].as_str()), (Some("refused"), Some("no_identity")));
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&doc, &i1), (0, 0));
|
|
// The page says so on the version.
|
|
assert_eq!(find(&doc, &i1)["myBallot"]["status"], "refused");
|
|
assert_eq!(find(&doc, &i1)["myBallot"]["reason"], "no_identity");
|
|
let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM identities WHERE id = 'idty:42'")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("n");
|
|
assert_eq!(n, 0, "no identity is created for a refused ballot");
|
|
// And in her messages, once each (ADR 0012).
|
|
let mut told = ballot_messages(&mut c).await;
|
|
told.sort();
|
|
let mut expected = vec![
|
|
("ballot_refused".to_owned(), id_of(&former).to_owned()),
|
|
("ballot_refused".to_owned(), id_of(&nobody).to_owned()),
|
|
];
|
|
expected.sort();
|
|
assert_eq!(told, expected);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(ballot_messages(&mut c).await.len(), 2);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_wrong_amount_or_recipient_is_refused() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
// Bound to the wallet that signs: its own transaction without the transfer is refused, and told.
|
|
let short = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
indexer.add(100, 1, short["comment"].as_str().expect("c"), alice(), &[(VOTE_ACCOUNT, 9)]);
|
|
let elsewhere = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
indexer.add(101, 1, elsewhere["comment"].as_str().expect("c"), alice(), &[(OTHER, 10)]);
|
|
let remark_only = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
indexer.add(102, 1, remark_only["comment"].as_str().expect("c"), alice(), &[]);
|
|
// Unbound (Ğecko): an unpaid comment settles nothing — anyone could send it for free.
|
|
let gecko = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.add(103, 1, gecko["comment"].as_str().expect("c"), alice(), &[(VOTE_ACCOUNT, 9)]);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
for b in [&short, &elsewhere, &remark_only] {
|
|
let s = c.status(b).await;
|
|
assert_eq!((s["status"].as_str(), s["reason"].as_str()), (Some("refused"), Some("transfer")), "{s}");
|
|
}
|
|
assert_eq!(c.status(&gecko).await["status"], "pending");
|
|
// The refused ones are set aside; the Ğecko code still waits: its intention shows, uncounted.
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&doc, &i1), pending(&doc, &i1)), ((1, 0), (1, 0)));
|
|
assert_eq!(counted(&state, &doc, &i1).await, (0, 0));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn confirming_twice_changes_nothing() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(100, b["comment"].as_str().expect("c"), alice());
|
|
// The page and the background task at once.
|
|
let row = sqlx::query_as::<_, ballots::BallotRow>(
|
|
"SELECT id, doc_id, requested_by, author, digest, remark_hash, account, amount, status, reason, voter_id, block,
|
|
entered, created_at, expires_at, checked_at FROM ballots",
|
|
)
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("row");
|
|
let (a, b2) = tokio::join!(ballots::check(&state, &row), ballots::check(&state, &row));
|
|
a.expect("check");
|
|
b2.expect("check");
|
|
ballots::check(&state, &row).await.expect("again");
|
|
assert_eq!(c.status(&b).await["status"], "confirmed");
|
|
let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM votes").fetch_one(&state.db).await.expect("n");
|
|
assert_eq!(n, 1);
|
|
assert_eq!(tally(&c.doc("monnaie-libre").await, &i1), (1, 0));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn the_last_one_stands_in_the_order_of_the_chain() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let e1 = version(&doc, "E1", "0");
|
|
// Three ballots of the same person, signed in this order on the chain: for (I1, E1), against (I1), none (E1).
|
|
let first = c.ballot(&doc, &[(&i1, Some("for")), (&e1, Some("for"))], None).await;
|
|
let second = c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
let third = c.ballot(&doc, &[(&e1, None)], None).await;
|
|
// The most recent is confirmed first; the oldest last, as when an indexer lags behind.
|
|
indexer.pay(300, third["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
indexer.add(200, 4, second["comment"].as_str().expect("c"), alice(), &[(VOTE_ACCOUNT, 10)]);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&doc, &i1), tally(&doc, &e1)), ((0, 1), (0, 0)));
|
|
indexer.add(200, 2, first["comment"].as_str().expect("c"), alice(), &[(VOTE_ACCOUNT, 10)]);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
for b in [&first, &second, &third] {
|
|
assert_eq!(c.status(b).await["status"], "confirmed");
|
|
}
|
|
// Block 200 event 2 comes before block 200 event 4, before block 300: the first ballot
|
|
// decides nothing any more. I1 stays « against »; E1 stays withdrawn, never brought back.
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&doc, &i1), (0, 1));
|
|
assert_eq!(tally(&doc, &e1), (0, 0));
|
|
assert_eq!(find(&doc, &i1)["myVote"], "against");
|
|
assert!(find(&doc, &e1)["myVote"].is_null());
|
|
// A new ballot, later on the chain, decides again.
|
|
let fourth = c.ballot(&doc, &[(&e1, Some("against"))], None).await;
|
|
indexer.pay(301, fourth["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(tally(&c.doc("monnaie-libre").await, &e1), (0, 1));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_revision_changed_meanwhile_leaves_the_vote_to_reconfirm() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let created = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/proposals"),
|
|
Some(json!({ "title": "Joignabilité", "body": "Je m'engage à rester joignable par mes certifieurs.", "submit": true })),
|
|
)
|
|
.await;
|
|
let p = created["id"].as_str().expect("id").to_owned();
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let b = c.ballot(&doc, &[(&p, Some("for"))], None).await;
|
|
// The author changes its meaning before the transaction is confirmed.
|
|
let edit = c
|
|
.ok(
|
|
"PATCH",
|
|
&format!("/api/proposals/{p}"),
|
|
Some(
|
|
json!({ "title": "Joignabilité", "body": "Je m'engage à répondre à mes certifieurs sous huit jours." }),
|
|
),
|
|
)
|
|
.await;
|
|
assert_eq!(edit["edit"], "substantive");
|
|
indexer.pay(100, b["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "confirmed");
|
|
// The vote was cast on revision 1: it waits to be reconfirmed, as any vote does.
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&doc, &p), (0, 0));
|
|
assert_eq!(find(&doc, &p)["myVote"], "for");
|
|
assert_eq!(find(&doc, &p)["myVoteStale"], true);
|
|
let rev: i64 = sqlx::query_scalar("SELECT revision FROM votes WHERE proposal_id = ?")
|
|
.bind(&p)
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("vote");
|
|
assert_eq!(rev, 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_bound_ballot_ignores_a_copy_of_its_remark_by_another_account() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
let comment = b["comment"].as_str().expect("c");
|
|
// Charlie copies the remark seen in the pool and gets it in first.
|
|
indexer.pay(99, comment, Signer { account: CHARLIE, identity: Some((7, "Charlie", true)) });
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "pending", "a copy settles nothing");
|
|
indexer.pay(100, comment, alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&b).await;
|
|
assert_eq!((s["status"].as_str(), s["voter"].as_str()), (Some("confirmed"), Some("Alice")));
|
|
let voters: Vec<String> =
|
|
sqlx::query_scalar("SELECT identity_id FROM votes").fetch_all(&state.db).await.expect("v");
|
|
assert_eq!(voters, ["idty:9001"]);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_ballot_not_seen_in_time_is_let_go() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let expires = b["expiresAt"].as_str().expect("expires");
|
|
assert!(
|
|
expires > ld_server::util::in_seconds(23 * 3600).as_str()
|
|
&& expires <= ld_server::util::in_seconds(24 * 3600).as_str()
|
|
);
|
|
sqlx::query("UPDATE ballots SET expires_at = ?")
|
|
.bind(ld_server::util::in_seconds(-1))
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("age");
|
|
// Read one last time at its end: nothing on the chain, it is let go.
|
|
assert_eq!(ballots::sweep(&state).await.expect("sweep"), 1);
|
|
assert_eq!(c.status(&b).await["status"], "expired");
|
|
assert_eq!(ballots::sweep(&state).await.expect("sweep"), 0, "nothing left to read");
|
|
// Seen on the chain afterwards: too late, it no longer counts.
|
|
indexer.pay(100, b["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "expired");
|
|
assert_eq!(find(&c.doc("monnaie-libre").await, &i1)["myBallot"]["status"], "expired");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_ballot_the_wallet_refused_to_sign_is_let_go_at_once() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let first = c.ballot(&doc, &[(&i1, Some("against"))], Some(ALICE)).await;
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
assert_eq!(find(&c.doc("monnaie-libre").await, &i1)["myBallot"]["id"], b["id"]);
|
|
// Another session may not let it go.
|
|
let mut other = c.other();
|
|
other.login("Yvv").await;
|
|
let (s, _) = other.call("DELETE", &format!("/api/ballots/{}", b["id"].as_str().expect("id")), None).await;
|
|
assert_eq!(s, StatusCode::NOT_FOUND);
|
|
// Its own session does: no longer waiting, and it says nothing under the article.
|
|
let dropped = c.ok("DELETE", &format!("/api/ballots/{}", b["id"].as_str().expect("id")), None).await;
|
|
assert_eq!(
|
|
(dropped["ballot"]["status"].as_str(), dropped["ballot"]["reason"].as_str()),
|
|
(Some("expired"), Some("dropped"))
|
|
);
|
|
assert_eq!(find(&c.doc("monnaie-libre").await, &i1)["myBallot"]["id"], first["id"]);
|
|
// A confirmed ballot is never let go.
|
|
indexer.pay(100, first["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let kept = c.ok("DELETE", &format!("/api/ballots/{}", first["id"].as_str().expect("id")), None).await;
|
|
assert_eq!(kept["ballot"]["status"], "confirmed");
|
|
let now = c.doc("monnaie-libre").await;
|
|
assert_eq!((find(&now, &i1)["myVote"].as_str(), find(&now, &i1)["myBallot"].is_null()), (Some("against"), true));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_session_sees_its_own_ballots_only() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut chiara, state) = Client::new(chain_config(&indexer)).await;
|
|
chiara.login("Chiara").await;
|
|
let mut other = chiara.other();
|
|
other.login("Yvv").await;
|
|
let doc = chiara.doc("monnaie-libre").await;
|
|
let (i1, e1) = (version(&doc, "I1", "0"), version(&doc, "E1", "0"));
|
|
// Both sign with the same wallet (one person, two sessions): two ballots, two versions.
|
|
let a = chiara.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let b = other.ballot(&doc, &[(&e1, Some("against"))], None).await;
|
|
indexer.pay(100, a["comment"].as_str().expect("c"), alice());
|
|
indexer.pay(101, b["comment"].as_str().expect("c"), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let mine = chiara.doc("monnaie-libre").await;
|
|
assert_eq!((find(&mine, &i1)["myVote"].as_str(), find(&mine, &e1)["myVote"].as_str()), (Some("for"), None));
|
|
let theirs = other.doc("monnaie-libre").await;
|
|
assert_eq!((find(&theirs, &i1)["myVote"].as_str(), find(&theirs, &e1)["myVote"].as_str()), (None, Some("against")));
|
|
// « Décisions » counts the same way (33 articles, the title, 7 orders with something to decide).
|
|
let d = chiara.ok("GET", "/api/groups/monnaie-libre/decisions", None).await;
|
|
assert_eq!(d["canVote"], true);
|
|
assert_eq!((d["docs"][0]["toVote"].as_u64(), d["docs"][0]["withoutMyVote"].as_u64()), (Some(41), Some(40)));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn thirty_nine_voices_on_the_chain_make_a_text_pass_and_an_objection_holds_it() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let e4 = version(&doc, "E4", "0");
|
|
let e5 = version(&doc, "E5", "0");
|
|
let reason = "Ces deux textes disent le contraire l'un de l'autre.";
|
|
let e1 = version(&doc, "E1", "0");
|
|
// Level 3, the quorum 50 (ADR 0013): 39 « pour » with no « contre ».
|
|
let needed = find(&doc, &e4)["evaluation"]["yesNeeded"].as_u64().expect("yesNeeded");
|
|
assert_eq!(needed, 39);
|
|
let needed = u8::try_from(needed).expect("n");
|
|
let keys: Vec<String> = (1..=needed).map(|n| address::encode(G1_PREFIX, &[n; 32])).collect();
|
|
let mut last = Value::Null;
|
|
let mut luna = c.other();
|
|
luna.login("Luna").await;
|
|
for (n, account) in keys.iter().enumerate() {
|
|
// The last voice comes from another session: its intention is seen at once.
|
|
let last_one = n + 1 == keys.len();
|
|
let asker = if last_one { &mut luna } else { &mut c };
|
|
let b = asker.ballot(&doc, &[(&e4, Some("for")), (&e5, Some("for"))], None).await;
|
|
if last_one {
|
|
// Thirty-nine voices shown, thirty-eight proven: nothing enters before the proof.
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e4), pending(&d, &e4)), ((39, 0), (1, 0)));
|
|
assert_eq!(counted(&state, &d, &e4).await, (38, 0));
|
|
let id = d["doc"]["id"].as_str().expect("id");
|
|
assert!(ld_server::adoption::run(&state, id).await.expect("run").is_empty());
|
|
assert_ne!(unit(&c.doc("monnaie-libre").await, "E4")["inForce"]["id"], e4.as_str());
|
|
}
|
|
let index = 10_000 + u32::try_from(n).expect("n");
|
|
indexer.pay(
|
|
1_000 + index,
|
|
b["comment"].as_str().expect("c"),
|
|
Signer { account, identity: Some((index, "Membre", true)) },
|
|
);
|
|
if n + 1 == keys.len() {
|
|
// The last ballot is signed; before the chain confirms it, an objection holds
|
|
// E5 back against the seed proposal E1, written before it (ADR 0010, 0011): no new ballot may hold it.
|
|
let o = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/proposals/{e5}/objections"),
|
|
Some(json!({ "otherId": e1, "kind": "contredit", "reason": reason })),
|
|
)
|
|
.await;
|
|
assert_eq!(o["heldId"], e5.as_str());
|
|
let id = doc["doc"]["id"].as_str().expect("id");
|
|
let (s, v) = c
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{id}/ballots"),
|
|
Some(json!({ "lines": [{ "proposalId": e5, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("objection")));
|
|
}
|
|
last = b;
|
|
if n % 10 == 9 {
|
|
// A session holds at most 20 pending ballots: the background task confirms on the way.
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
}
|
|
if n + 2 == keys.len() {
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&d, &e4), (38, 0));
|
|
assert!(find(&d, &e4)["enteredAt"].is_null(), "38 voices: one short of the 39 the quorum 50 asks");
|
|
assert_eq!(find(&d, &e4)["evaluation"]["missing"], 1);
|
|
}
|
|
}
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = luna.status(&last).await;
|
|
assert_eq!(s["status"], "confirmed");
|
|
assert_eq!(s["entered"][0]["code"], "E4", "{s}");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(unit(&d, "E4")["inForce"]["id"], e4.as_str());
|
|
// Sealed before the objection, proven after it: its *for* on E5 is set aside
|
|
// (ADR 0012, revising 0010) — its *for* on E4 counts. Luna is told.
|
|
assert_eq!(tally(&d, &e5), (38, 0));
|
|
assert_eq!(find(&d, &e5)["votable"], false);
|
|
assert!(unit(&d, "E5")["inForce"].is_null(), "an objection holds it back");
|
|
let outcomes: Vec<(String, Option<String>)> =
|
|
sqlx::query_as("SELECT proposal_id, outcome FROM ballot_lines WHERE ballot_id = ? ORDER BY proposal_id = ?")
|
|
.bind(id_of(&last))
|
|
.bind(&e5)
|
|
.fetch_all(&state.db)
|
|
.await
|
|
.expect("lines");
|
|
assert_eq!(outcomes, [(e4.clone(), Some("counted".into())), (e5.clone(), Some("objection".into()))]);
|
|
assert_eq!(ballot_messages(&mut luna).await, [("ballot_objection".to_owned(), id_of(&last).to_owned())]);
|
|
let seen = luna.doc("monnaie-libre").await;
|
|
let held = &find(&seen, &e5)["myBallot"];
|
|
assert_eq!((held["status"].as_str(), held["reason"].as_str()), (Some("refused"), Some("objection")));
|
|
assert_eq!(mine(&seen, &e4), (Some("for"), Some("recorded")));
|
|
}
|
|
|
|
/// Yvv, 2026-11-01: « Retirer ou "contre" ». On the chain too, a held version takes a
|
|
/// ballot against it or a withdrawal, never a *for* — alone or among free lines.
|
|
#[tokio::test]
|
|
async fn on_the_chain_a_held_version_takes_against_and_withdrawal_never_for() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let (e1, e4, e5) = (version(&doc, "E1", "0"), version(&doc, "E4", "0"), version(&doc, "E5", "0"));
|
|
let o = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/proposals/{e5}/objections"),
|
|
Some(json!({ "otherId": e1, "kind": "contredit", "reason": "Ces deux textes disent le contraire." })),
|
|
)
|
|
.await;
|
|
assert_eq!(o["heldId"], e5.as_str());
|
|
let uri = format!("/api/docs/{doc_id}/ballots");
|
|
let refused = (StatusCode::CONFLICT, Some("objection"));
|
|
for lines in [
|
|
json!([{ "proposalId": e5, "choice": "for" }]),
|
|
json!([{ "proposalId": e4, "choice": "for" }, { "proposalId": e5, "choice": "for" }]),
|
|
] {
|
|
let (s, v) = c.call("POST", &uri, Some(json!({ "lines": lines }))).await;
|
|
assert_eq!((s, v["error"].as_str()), refused, "{lines}");
|
|
}
|
|
// Against the held one, for a free one: sealed, then confirmed by the chain.
|
|
let b = c.ballot(&doc, &[(&e4, Some("for")), (&e5, Some("against"))], None).await;
|
|
indexer.pay(200, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "confirmed");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e4), tally(&d, &e5)), ((1, 0), (0, 1)));
|
|
assert_eq!(find(&d, &e5)["myVote"], "against");
|
|
// A withdrawal: the last ballot stands.
|
|
let w = c.ballot(&doc, &[(&e5, None)], None).await;
|
|
indexer.pay(201, comment_of(&w), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&w).await["status"], "confirmed");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&d, &e5), (0, 0));
|
|
assert!(find(&d, &e5)["myVote"].is_null());
|
|
assert!(unit(&d, "E5")["inForce"].is_null(), "held, it never enters");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// After the independent review of 74f96be (lot B2): its probes, kept as tests
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async fn db_status(state: &AppState, id: &str) -> (String, Option<String>) {
|
|
sqlx::query_as("SELECT status, reason FROM ballots WHERE id = ?").bind(id).fetch_one(&state.db).await.expect("row")
|
|
}
|
|
|
|
fn id_of(b: &Value) -> &str {
|
|
b["id"].as_str().expect("id")
|
|
}
|
|
|
|
fn comment_of(b: &Value) -> &str {
|
|
b["comment"].as_str().expect("comment")
|
|
}
|
|
|
|
async fn age(state: &AppState, set: &str, seconds: i64, id: &str) {
|
|
sqlx::query(&format!("UPDATE ballots SET {set} = ? WHERE id = ?"))
|
|
.bind(ld_server::util::in_seconds(seconds))
|
|
.bind(id)
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("age");
|
|
}
|
|
|
|
/// P5: the `author` field was decoded in a time that grows as the square of its
|
|
/// length, on a thread of the server (250 000 characters: 32 s).
|
|
#[tokio::test]
|
|
async fn a_long_author_is_refused_at_once() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, _) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let i1 = version(&doc, "I1", "0");
|
|
// The body may hold 256 KiB: an author of 250 000 characters passes it.
|
|
for n in [80_000usize, 250_000] {
|
|
let body = json!({ "lines": [{ "proposalId": i1, "choice": "for" }], "author": "z".repeat(n) });
|
|
let t = std::time::Instant::now();
|
|
let (s, v) = c.call("POST", &format!("/api/docs/{doc_id}/ballots"), Some(body)).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::BAD_REQUEST, Some("author")));
|
|
assert!(t.elapsed() < std::time::Duration::from_secs(1), "{n} characters: {:?}", t.elapsed());
|
|
}
|
|
}
|
|
|
|
/// P1: the background task read the same 50 oldest pending ballots at every pass;
|
|
/// a vote paid behind them was never confirmed, then expired.
|
|
#[tokio::test]
|
|
async fn the_background_task_reaches_every_pending_ballot() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut a, state) = Client::new(chain_config(&indexer)).await;
|
|
a.login("Anna").await;
|
|
let doc = a.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let mut b = a.other();
|
|
b.login("Bruno").await;
|
|
let mut c = a.other();
|
|
c.login("Carla").await;
|
|
for _ in 0..20 {
|
|
a.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
b.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
}
|
|
for _ in 0..10 {
|
|
c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
}
|
|
let mut dora = a.other();
|
|
dora.login("Dora").await;
|
|
let mine = dora.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
indexer.pay(100, comment_of(&mine), alice());
|
|
// 51 pending, at most 50 read per pass: the least recently read come first.
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&mine)).await.0, "confirmed");
|
|
let unread: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM ballots WHERE checked_at IS NULL")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("n");
|
|
assert_eq!(unread, 0, "every pending ballot was read");
|
|
}
|
|
|
|
/// P2: `DELETE` freed the place at once — one session made 100 ballots and 3 500 lines.
|
|
#[tokio::test]
|
|
async fn letting_ballots_go_does_not_lift_the_cap() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut a, state) = Client::new(chain_config(&indexer)).await;
|
|
a.login("Anna").await;
|
|
let doc = a.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let i1 = version(&doc, "I1", "0");
|
|
for _ in 0..20 {
|
|
let b = a.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
a.ok("DELETE", &format!("/api/ballots/{}", id_of(&b)), None).await;
|
|
}
|
|
let one = json!({ "lines": [{ "proposalId": i1, "choice": "for" }] });
|
|
let url = format!("/api/docs/{doc_id}/ballots");
|
|
let (s, v) = a.call("POST", &url, Some(one.clone())).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("too_many_ballots")));
|
|
// The cap holds for the identity, whatever the session.
|
|
let mut again = a.other();
|
|
again.login("Anna").await;
|
|
assert_eq!(again.call("POST", &url, Some(one.clone())).await.0, StatusCode::CONFLICT);
|
|
// An hour later, there is room again.
|
|
sqlx::query("UPDATE ballots SET settled_at = ? WHERE reason = 'dropped'")
|
|
.bind(ld_server::util::in_seconds(-3601))
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("age");
|
|
let kept = a.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
// Let go more than a day ago: purged, lines and all; the pending one stays.
|
|
sqlx::query("UPDATE ballots SET settled_at = ? WHERE reason = 'dropped'")
|
|
.bind(ld_server::util::in_seconds(-(24 * 3600 + 1)))
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("age");
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let count = || async {
|
|
sqlx::query_as::<_, (i64, i64)>("SELECT (SELECT COUNT(*) FROM ballots), (SELECT COUNT(*) FROM ballot_lines)")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("n")
|
|
};
|
|
assert_eq!(count().await, (1, 1));
|
|
// Not seen on the chain in time: it says so under the article for a week, then it is purged.
|
|
age(&state, "expires_at", -3601 - 5, id_of(&kept)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&kept)).await.0, "expired");
|
|
age(&state, "settled_at", -6 * 24 * 3600, id_of(&kept)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(count().await, (1, 1));
|
|
age(&state, "settled_at", -8 * 24 * 3600, id_of(&kept)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(count().await, (0, 0));
|
|
}
|
|
|
|
/// P3: a bare copy of the remark — free to send — refused a Ğecko ballot for good.
|
|
#[tokio::test]
|
|
async fn an_unbound_ballot_is_not_settled_by_an_unpaid_copy() {
|
|
let indexer = Indexer::start().await;
|
|
// An indexer that does not filter: the rule of the engine holds alone.
|
|
indexer.lax(true);
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.add(99, 1, comment_of(&b), Signer { account: OTHER, identity: None }, &[]);
|
|
indexer.add(
|
|
99,
|
|
2,
|
|
comment_of(&b),
|
|
Signer { account: CHARLIE, identity: Some((7, "Charlie", true)) },
|
|
&[(VOTE_ACCOUNT, 9)],
|
|
);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(c.status(&b).await["status"], "pending", "an unpaid copy settles nothing");
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&b).await;
|
|
assert_eq!((s["status"].as_str(), s["voter"].as_str()), (Some("confirmed"), Some("Alice")), "{s}");
|
|
assert_eq!(tally(&c.doc("monnaie-libre").await, &i1), (1, 0));
|
|
}
|
|
|
|
/// P4, the limit that stays (ADR 0008): a paid copy, earlier on the chain, takes
|
|
/// an unbound ballot — its lines count for the one who paid.
|
|
#[tokio::test]
|
|
async fn an_unbound_ballot_can_be_taken_by_a_paid_copy() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(99, comment_of(&b), Signer { account: CHARLIE, identity: Some((7, "Charlie", true)) });
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&b).await;
|
|
assert_eq!((s["status"].as_str(), s["voter"].as_str()), (Some("confirmed"), Some("Charlie")));
|
|
let voters: Vec<String> =
|
|
sqlx::query_scalar("SELECT identity_id FROM votes").fetch_all(&state.db).await.expect("v");
|
|
assert_eq!(voters, ["idty:7"]);
|
|
}
|
|
|
|
/// Point 5 of the review: a pending ballot older than a confirmed vote on the same
|
|
/// line no longer shows under the article.
|
|
#[tokio::test]
|
|
async fn an_older_pending_ballot_never_hides_a_newer_confirmed_vote() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
// A Ğecko code shown, never paid; then a vote from the wallet, confirmed.
|
|
c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
let newer = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
indexer.pay(100, comment_of(&newer), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(find(&d, &i1)["myVote"], "for");
|
|
assert!(find(&d, &i1)["myBallot"].is_null(), "{}", find(&d, &i1)["myBallot"]);
|
|
let p = c.ok("GET", &format!("/api/proposals/{i1}"), None).await;
|
|
assert!(p["proposal"]["myBallot"].is_null());
|
|
// A ballot asked after the vote shows, waiting.
|
|
let after = c.ballot(&doc, &[(&i1, Some("against"))], Some(ALICE)).await;
|
|
assert_eq!(find(&c.doc("monnaie-libre").await, &i1)["myBallot"]["id"], after["id"]);
|
|
}
|
|
|
|
/// Point 6: only a comment in a final block counts, or refuses.
|
|
#[tokio::test]
|
|
async fn a_comment_counts_once_its_block_is_final() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
let r = c.ballot(&doc, &[(&i1, Some("for"))], Some(BOB)).await;
|
|
indexer.finalized(Some(99));
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
indexer.add(
|
|
100,
|
|
2,
|
|
comment_of(&r),
|
|
Signer { account: BOB, identity: Some((42, "Bob", false)) },
|
|
&[(VOTE_ACCOUNT, 10)],
|
|
);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&b)).await.0, "pending");
|
|
assert_eq!(db_status(&state, id_of(&r)).await.0, "pending");
|
|
// Her latest intention shows; nothing is counted before a final block.
|
|
let doc = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&doc, &i1), pending(&doc, &i1)), ((1, 0), (1, 0)));
|
|
assert_eq!(counted(&state, &doc, &i1).await, (0, 0));
|
|
indexer.finalized(Some(100));
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&b)).await.0, "confirmed");
|
|
assert_eq!(db_status(&state, id_of(&r)).await, ("refused".into(), Some("not_member".into())));
|
|
}
|
|
|
|
/// Point 6: the search by hash went no further than 20 comments; copies could hide the real one.
|
|
#[tokio::test]
|
|
async fn copies_never_hide_the_real_comment() {
|
|
let indexer = Indexer::start().await;
|
|
// An indexer that would not filter: pages, one after the other.
|
|
indexer.lax(true);
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], Some(ALICE)).await;
|
|
for n in 0..120 {
|
|
indexer.pay(100 + n, comment_of(&b), Signer { account: CHARLIE, identity: Some((7, "Charlie", true)) });
|
|
}
|
|
indexer.pay(300, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let s = c.status(&b).await;
|
|
assert_eq!((s["status"].as_str(), s["voter"].as_str()), (Some("confirmed"), Some("Alice")), "{s}");
|
|
// The indexer is asked for what may settle: the comments of the bound account;
|
|
// for a Ğecko code, those paid to the vote account.
|
|
indexer.lax(false);
|
|
c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let filters = indexer.filters();
|
|
assert!(filters.iter().any(|f| f["authorId"]["equalTo"] == ALICE), "{filters:?}");
|
|
assert!(
|
|
filters.iter().any(|f| {
|
|
let some = &f["transfersByCommentId"]["some"];
|
|
some["toId"]["equalTo"] == VOTE_ACCOUNT && some["amount"]["greaterThanOrEqualTo"] == "10"
|
|
}),
|
|
"{filters:?}"
|
|
);
|
|
}
|
|
|
|
/// Point 5: a Ğecko code keeps its ballot; the background task settles it, the
|
|
/// page closed — even paid at the last moment, read once more at its end.
|
|
#[tokio::test]
|
|
async fn a_gecko_ballot_is_settled_by_the_background_task_even_at_its_end() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
age(&state, "expires_at", -5, id_of(&b)).await;
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&b)).await.0, "confirmed");
|
|
// Its end come while no indexer answers: kept and read again, for an hour at most.
|
|
let late = c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
age(&state, "expires_at", -5, id_of(&late)).await;
|
|
indexer.silent(true);
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&late)).await.0, "pending");
|
|
age(&state, "expires_at", -3601, id_of(&late)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&late)).await.0, "expired");
|
|
}
|
|
|
|
/// Point 7: the research note promises everyone can check their own vote with its
|
|
/// salt. The receipt goes to the one who asked, never to anyone else.
|
|
#[tokio::test]
|
|
async fn the_receipt_is_for_the_one_who_asked_and_proves_the_vote() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let (i1, e3) = (version(&doc, "I1", "0"), version(&doc, "E3", "0"));
|
|
let b = c.ballot(&doc, &[(&i1, Some("for")), (&e3, Some("against"))], Some(ALICE_GENERIC)).await;
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let url = format!("/api/ballots/{}/receipt", id_of(&b));
|
|
let (s, headers, r) = c.call_with_headers("GET", &url, None).await;
|
|
assert_eq!(s, StatusCode::OK, "{r}");
|
|
let disposition = headers.get(header::CONTENT_DISPOSITION).and_then(|h| h.to_str().ok()).unwrap_or_default();
|
|
assert!(disposition.starts_with("attachment;") && disposition.contains(".json"), "{disposition}");
|
|
assert_eq!(
|
|
(r["format"].as_str(), r["status"].as_str(), r["block"].as_u64(), r["voter"].as_str()),
|
|
(Some("ld1"), Some("confirmed"), Some(100), Some("Alice"))
|
|
);
|
|
assert_eq!((r["comment"].as_str(), r["author"].as_str()), (Some(comment_of(&b)), Some(ALICE)));
|
|
// It holds: its lines and its salt seal the remark the chain carries.
|
|
let lines: Vec<ld_engine::ballot::Line> = r["lines"]
|
|
.as_array()
|
|
.expect("lines")
|
|
.iter()
|
|
.map(|l| ld_engine::ballot::Line {
|
|
proposal_id: l["proposalId"].as_str().expect("p").into(),
|
|
revision: u32::try_from(l["revision"].as_u64().expect("r")).expect("r"),
|
|
choice: ld_engine::ballot::Choice::parse(l["choice"].as_str().expect("c")).expect("c"),
|
|
})
|
|
.collect();
|
|
assert_eq!(lines.len(), 2);
|
|
let doc_id = r["doc"].as_str().expect("doc");
|
|
let salt = r["salt"].as_str().expect("salt");
|
|
let sealed = ld_engine::ballot::seal(doc_id, r["author"].as_str(), &lines, salt).expect("seal");
|
|
assert_eq!(
|
|
(sealed.comment.as_str(), sealed.remark_hash.as_str()),
|
|
(comment_of(&b), r["remarkHash"].as_str().expect("h"))
|
|
);
|
|
assert_eq!(
|
|
r["canonical"].as_str(),
|
|
Some(ld_engine::ballot::canonical(doc_id, r["author"].as_str(), &lines, salt).expect("c").as_str())
|
|
);
|
|
// Each line says which article it is.
|
|
assert!(r["lines"].as_array().expect("l").iter().any(|l| l["article"] == "I1"));
|
|
// In her history, never in anyone else's.
|
|
let mine = c.ok("GET", "/api/ballots", None).await;
|
|
assert_eq!((mine["ballots"][0]["id"].as_str(), mine["ballots"][0]["lines"].as_u64()), (Some(id_of(&b)), Some(2)));
|
|
assert_eq!(mine["ballots"][0]["status"], "confirmed");
|
|
let mut yvv = c.other();
|
|
yvv.login("Yvv").await;
|
|
assert_eq!(yvv.call("GET", &url, None).await.0, StatusCode::NOT_FOUND);
|
|
assert_eq!(yvv.ok("GET", "/api/ballots", None).await["ballots"], json!([]));
|
|
let mut nobody = c.other();
|
|
assert_eq!(nobody.call("GET", &url, None).await.0, StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
/// Point 8: an identity known only from a vote on the chain does not hold its name
|
|
/// against a person who joins by a team link; a Ğ1 identity that signed in does.
|
|
#[tokio::test]
|
|
async fn a_name_known_only_from_a_chain_vote_stays_free() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut admin, state) = Client::new(chain_config(&indexer)).await;
|
|
admin.login_admin("Yvv").await;
|
|
let doc = admin.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
for (block, signer) in [(100, alice()), (101, Signer { account: CHARLIE, identity: Some((9003, "Charlie", true)) })]
|
|
{
|
|
let b = admin.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
indexer.pay(block, comment_of(&b), signer);
|
|
}
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
// Charlie has since signed in with his Ğ1 identity.
|
|
sqlx::query("UPDATE identities SET last_seen_at = ? WHERE id = 'idty:9003'")
|
|
.bind(ld_server::util::now())
|
|
.execute(&state.db)
|
|
.await
|
|
.expect("seen");
|
|
let link = json!({ "label": "Équipe", "groups": ["essai"], "days": 30, "maxUses": 5 });
|
|
let v = admin.ok("POST", "/api/access/team-links", Some(link)).await;
|
|
let token = v["link"].as_str().expect("link").split('#').nth(1).expect("token").to_owned();
|
|
let mut charlie = admin.other();
|
|
let (s, v) = charlie.call("POST", "/api/auth/team", Some(json!({ "token": token, "name": "charlie" }))).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("name_taken")));
|
|
let mut alice = admin.other();
|
|
let (s, v) = alice.call("POST", "/api/auth/team", Some(json!({ "token": token, "name": "Alice" }))).await;
|
|
assert_eq!(s, StatusCode::OK, "{v}");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn voices_on_the_chain_bring_an_order_then_a_title_into_force() {
|
|
// The modules (ADR 0009) are voted like articles: in a basket, in one transaction.
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let order = doc["modules"]["orders"]
|
|
.as_array()
|
|
.expect("orders")
|
|
.iter()
|
|
.find(|o| o["section"] == "conclusion")
|
|
.expect("conclusion")
|
|
.clone();
|
|
let (k1, k2) = (unit(&doc, "K1")["id"].as_str().expect("K1"), unit(&doc, "K2")["id"].as_str().expect("K2"));
|
|
assert_eq!(order["members"], json!([k1, k2]));
|
|
let o = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/units/{}/order", order["id"].as_str().expect("id")),
|
|
Some(json!({ "order": [k2, k1] })),
|
|
)
|
|
.await["id"]
|
|
.as_str()
|
|
.expect("order")
|
|
.to_owned();
|
|
let title_unit = doc["modules"]["title"]["id"].as_str().expect("title").to_owned();
|
|
let t = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/units/{title_unit}/title"),
|
|
Some(json!({ "title": "Acte d'engagement de certification" })),
|
|
)
|
|
.await["id"]
|
|
.as_str()
|
|
.expect("title")
|
|
.to_owned();
|
|
let doc = c.doc("monnaie-libre").await;
|
|
// Each on the quorum of its level (ADR 0013): the order at level 2 (quorum 12) asks 9
|
|
// « pour », the title at level 4 (quorum 50) 43.
|
|
let mut needed = Vec::new();
|
|
for id in [&o, &t] {
|
|
let d = c.ok("GET", &format!("/api/proposals/{id}"), None).await;
|
|
needed.push(d["proposal"]["evaluation"]["yesNeeded"].as_u64().expect("yesNeeded"));
|
|
}
|
|
assert_eq!(needed, [9, 43]);
|
|
let keys: Vec<String> = (1..=43u8).map(|n| address::encode(G1_PREFIX, &[n; 32])).collect();
|
|
let mut sent = Vec::new();
|
|
for (n, account) in keys.iter().enumerate() {
|
|
let b = c.ballot(&doc, &[(&o, Some("for")), (&t, Some("for"))], None).await;
|
|
let index = 20_000 + u32::try_from(n).expect("n");
|
|
indexer.pay(
|
|
2_000 + index,
|
|
b["comment"].as_str().expect("c"),
|
|
Signer { account, identity: Some((index, "Membre", true)) },
|
|
);
|
|
sent.push(b);
|
|
if n % 10 == 9 {
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
}
|
|
}
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
// What entered at each confirmation, in the order of the chain.
|
|
let mut entered: Vec<(usize, String, String)> = Vec::new();
|
|
for (n, b) in sent.iter().enumerate() {
|
|
let s = c.status(b).await;
|
|
assert_eq!(s["status"], "confirmed", "{s}");
|
|
for e in s["entered"].as_array().expect("entered") {
|
|
entered.push((n + 1, e["code"].as_str().expect("code").into(), e["kind"].as_str().expect("kind").into()));
|
|
}
|
|
}
|
|
assert_eq!(
|
|
entered,
|
|
[(9, "ordre.conclusion".into(), "order".into()), (43, "titre".into(), "title".into())],
|
|
"the ninth voice, then the forty-third"
|
|
);
|
|
let d = c.doc("monnaie-libre").await;
|
|
let (p1, p2) = (unit(&d, "K1")["position"].as_f64().expect("p"), unit(&d, "K2")["position"].as_f64().expect("p"));
|
|
assert!(p2 < p1, "K2 now reads before K1");
|
|
assert_eq!(d["doc"]["title"]["fr"], "Acte d'engagement de certification");
|
|
assert_eq!(d["modules"]["title"]["inForce"]["translations"]["en"]["stale"], true, "the English title, to review");
|
|
// The adoptions keep what entered, by kind.
|
|
let kinds: Vec<String> =
|
|
sqlx::query_scalar("SELECT kind FROM adoptions ORDER BY kind").fetch_all(&state.db).await.expect("k");
|
|
assert_eq!(kinds, ["order", "title"]);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Without the chain, and in managed groups
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test]
|
|
async fn without_a_vote_account_monnaie_libre_votes_in_simulation_and_the_test_group_still_votes() {
|
|
let (mut c, _) = Client::new(Config::for_tests()).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
// The chain closed: the vote is simulated, written by the server (ADR 0012).
|
|
assert_eq!(doc["vote"]["way"], "server");
|
|
assert_eq!(doc["vote"]["open"], true);
|
|
assert_eq!(doc["vote"]["simulated"], true);
|
|
assert!(doc["vote"]["reason"].is_null());
|
|
assert!(doc["vote"]["chain"].is_null());
|
|
assert_eq!(doc["canVote"], true);
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let i1 = version(&doc, "I1", "0");
|
|
let (s, v) = c
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/ballots"),
|
|
Some(json!({ "lines": [{ "proposalId": i1, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("chain_vote_off")));
|
|
let essai = c.doc("essai").await;
|
|
assert_eq!((essai["vote"]["way"].as_str(), essai["vote"]["open"].as_bool()), (Some("server"), Some(true)));
|
|
assert_eq!(essai["vote"]["simulated"], false);
|
|
let p = version(&essai, "I1", "0");
|
|
c.ok("POST", &format!("/api/proposals/{p}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
let essai = c.doc("essai").await;
|
|
assert_eq!(mine(&essai, &p), (Some("for"), Some("recorded")));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn in_monnaie_libre_nobody_votes_on_the_server() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, _) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let p = version(&doc, "E3", "0");
|
|
for choice in [json!("for"), Value::Null] {
|
|
let (s, v) = c.call("POST", &format!("/api/proposals/{p}/vote"), Some(json!({ "choice": choice }))).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("chain_only")));
|
|
}
|
|
let (s, v) = c
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/votes"),
|
|
Some(json!({ "lines": [{ "proposalId": p, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("chain_only")));
|
|
// And no ballot in a group that votes on the server.
|
|
let essai = c.doc("essai").await;
|
|
let id = essai["doc"]["id"].as_str().expect("id").to_owned();
|
|
let q = version(&essai, "E3", "0");
|
|
let (s, v) = c
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{id}/ballots"),
|
|
Some(json!({ "lines": [{ "proposalId": q, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("server_vote")));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn what_a_ballot_may_not_hold() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, _) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let i1 = version(&doc, "I1", "0");
|
|
let essai = c.doc("essai").await;
|
|
let elsewhere = version(&essai, "I1", "0");
|
|
for (lines, author, code) in [
|
|
(json!([]), Value::Null, "lines"),
|
|
(
|
|
json!([{ "proposalId": i1, "choice": "for" }, { "proposalId": i1, "choice": "against" }]),
|
|
Value::Null,
|
|
"lines",
|
|
),
|
|
(json!([{ "proposalId": elsewhere, "choice": "for" }]), Value::Null, "lines"),
|
|
(json!([{ "proposalId": i1, "choice": "maybe" }]), Value::Null, "choice"),
|
|
(json!([{ "proposalId": i1, "choice": "for" }]), json!("g1NotAnAddress"), "author"),
|
|
] {
|
|
let (s, v) = c
|
|
.call("POST", &format!("/api/docs/{doc_id}/ballots"), Some(json!({ "lines": lines, "author": author })))
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::BAD_REQUEST, Some(code)), "{lines}");
|
|
}
|
|
// A session holds a bounded number of pending ballots.
|
|
for _ in 0..20 {
|
|
c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
}
|
|
let (s, v) = c
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/ballots"),
|
|
Some(json!({ "lines": [{ "proposalId": i1, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("too_many_ballots")));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_grouped_vote_in_a_managed_group_is_one_write() {
|
|
let (mut a, state) = Client::new(Config::for_tests()).await;
|
|
a.login("Yvv").await;
|
|
let mut b = a.other();
|
|
b.login("Chiara").await;
|
|
for code in ["E4", "E5", "E6"] {
|
|
two_voices(&state, "essai", code).await;
|
|
}
|
|
let doc = a.doc("essai").await;
|
|
let id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let (e4, e5, e6) = (version(&doc, "E4", "0"), version(&doc, "E5", "0"), version(&doc, "E6", "0"));
|
|
let lines = json!([
|
|
{ "proposalId": e4, "choice": "for" }, { "proposalId": e5, "choice": "against" }, { "proposalId": e6, "choice": "for" },
|
|
]);
|
|
let v = a.ok("POST", &format!("/api/docs/{id}/votes"), Some(json!({ "lines": lines }))).await;
|
|
assert_eq!(v["count"], 3);
|
|
assert!(v["entered"].as_array().expect("e").is_empty(), "one voice of two, on a quorum of 2");
|
|
// All or nothing: one line that does not hold, and no line is written.
|
|
let (s, _) = b
|
|
.call(
|
|
"POST",
|
|
&format!("/api/docs/{id}/votes"),
|
|
Some(
|
|
json!({ "lines": [{ "proposalId": e4, "choice": "for" }, { "proposalId": "nope", "choice": "for" }] }),
|
|
),
|
|
)
|
|
.await;
|
|
assert_eq!(s, StatusCode::BAD_REQUEST);
|
|
let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM votes WHERE identity_id = 'dev:chiara'")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("n");
|
|
assert_eq!(n, 0);
|
|
// The second voice of a group of two: E4 and E6 enter at once; withdrawing in the same gesture.
|
|
let lines = json!([
|
|
{ "proposalId": e4, "choice": "for" }, { "proposalId": e6, "choice": "for" }, { "proposalId": e5, "choice": null },
|
|
]);
|
|
let v = b.ok("POST", &format!("/api/docs/{id}/votes"), Some(json!({ "lines": lines }))).await;
|
|
let mut codes: Vec<&str> = v["entered"].as_array().expect("e").iter().filter_map(|e| e["code"].as_str()).collect();
|
|
codes.sort_unstable();
|
|
assert_eq!(codes, ["E4", "E6"]);
|
|
let doc = a.doc("essai").await;
|
|
assert_eq!(tally(&doc, &e5), (0, 1));
|
|
assert_eq!(find(&doc, &e5)["myVote"], "against");
|
|
assert_eq!(find(&doc, &e5)["myVoteChain"], false);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// The buffer of the votes (ADR 0012): the intention at once, the proof of the
|
|
// chain, the reconciliation; the simulation while the chain is closed
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[tokio::test]
|
|
async fn a_simulated_vote_in_monnaie_libre_is_seen_at_once_in_my_vote_and_the_totals() {
|
|
let (mut c, state) = Client::new(Config::for_tests()).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let (i1, e3, e4) = (version(&doc, "I1", "0"), version(&doc, "E3", "0"), version(&doc, "E4", "0"));
|
|
// One vote, without a wallet: written by the server, simulated.
|
|
let v = c.ok("POST", &format!("/api/proposals/{i1}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
assert_eq!((v["simulated"].as_bool(), v["entered"].as_array().map(Vec::len)), (Some(true), Some(0)));
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(tally(&d, &i1), (1, 0));
|
|
assert_eq!(pending(&d, &i1), (0, 0), "nothing waits for the chain: the simulated confirmer proved it");
|
|
assert_eq!(pair(&find(&d, &i1)["tallySimulated"]), (1, 0));
|
|
assert_eq!(mine(&d, &i1), (Some("for"), Some("simulated")));
|
|
assert_eq!(find(&d, &i1)["myVoteChain"], false);
|
|
// By default a simulated vote counts like a proven one, adoption included.
|
|
assert_eq!(counted(&state, &d, &i1).await, (1, 0));
|
|
// Through the same buffer: a sealed ballot, simulated, proven at block 0, for the session.
|
|
let row: (String, String, Option<i64>, Option<String>, String) =
|
|
sqlx::query_as("SELECT mode, status, block, voter_id, requested_by FROM ballots")
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("ballot");
|
|
assert_eq!((row.0.as_str(), row.1.as_str(), row.2), ("simulated", "confirmed", Some(0)));
|
|
assert_eq!(row.3.as_deref(), Some(row.4.as_str()), "the voice of the session: there is no wallet");
|
|
let source: String = sqlx::query_scalar("SELECT source FROM votes").fetch_one(&state.db).await.expect("vote");
|
|
assert_eq!(source, "simulated");
|
|
// A grouped vote: one ballot, every line; then a withdrawal.
|
|
let lines = json!([{ "proposalId": e3, "choice": "against" }, { "proposalId": e4, "choice": "for" }]);
|
|
let v = c.ok("POST", &format!("/api/docs/{doc_id}/votes"), Some(json!({ "lines": lines }))).await;
|
|
assert_eq!((v["count"].as_u64(), v["simulated"].as_bool()), (Some(2), Some(true)));
|
|
c.ok("POST", &format!("/api/proposals/{i1}/vote"), Some(json!({ "choice": null }))).await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), tally(&d, &e3), tally(&d, &e4)), ((0, 0), (0, 1), (1, 0)));
|
|
assert_eq!(mine(&d, &i1), (None, None));
|
|
assert_eq!(mine(&d, &e3), (Some("against"), Some("simulated")));
|
|
// Someone else sees the totals, never the vote.
|
|
let mut yvv = c.other();
|
|
yvv.login("Yvv").await;
|
|
let seen = yvv.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&seen, &e3), mine(&seen, &e3)), ((0, 1), (None, None)));
|
|
// Her ballots, marked simulated, with a receipt.
|
|
let history = c.ok("GET", "/api/ballots", None).await;
|
|
let list = history["ballots"].as_array().expect("ballots");
|
|
assert_eq!(list.len(), 3);
|
|
assert!(
|
|
list.iter().all(|b| b["mode"] == "simulated" && b["status"] == "confirmed" && b["block"].is_null()),
|
|
"{history}"
|
|
);
|
|
let id = list[0]["id"].as_str().expect("id");
|
|
let r = c.ok("GET", &format!("/api/ballots/{id}/receipt"), None).await;
|
|
assert_eq!(r["mode"], "simulated");
|
|
// No ballot to sign while the chain is closed.
|
|
let one = json!({ "lines": [{ "proposalId": i1, "choice": "for" }] });
|
|
let (s, v) = c.call("POST", &format!("/api/docs/{doc_id}/ballots"), Some(one)).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("chain_vote_off")));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn shown_but_never_adopted_when_simulated_votes_are_switched_off_for_adoption() {
|
|
// Yvv may choose « simulé = affiché, jamais compté pour l'adoption » (ADR 0012).
|
|
for adopts in [true, false] {
|
|
let mut cfg = Config::for_tests();
|
|
cfg.simulated_adopts = adopts;
|
|
let (mut a, state) = Client::new(cfg).await;
|
|
a.login("Anna").await;
|
|
let doc = a.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
small_web(&state, &doc_id).await;
|
|
let e4 = version(&doc, "E4", "0");
|
|
let mut b = a.other();
|
|
b.login("Bruno").await;
|
|
a.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
let v = b.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
let entered = !v["entered"].as_array().expect("entered").is_empty();
|
|
let d = a.doc("monnaie-libre").await;
|
|
assert_eq!(pair(&find(&d, &e4)["tallySimulated"]), (2, 0), "shown either way");
|
|
assert_eq!(counted(&state, &d, &e4).await, if adopts { (2, 0) } else { (0, 0) });
|
|
assert_eq!(entered, adopts, "adopts = {adopts}");
|
|
}
|
|
}
|
|
|
|
/// Yvv, 2026-11-02: « Il compte, puis s'efface ». Opening the chain sets nothing
|
|
/// aside; the act « supprime » does, and examines again what the simulated votes
|
|
/// brought into force, with the proven votes only (`simulation::discard`).
|
|
#[tokio::test]
|
|
async fn opening_the_chain_sets_nothing_aside_the_act_does_and_examines_again_what_entered() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
small_web(&state, &doc_id).await;
|
|
let (e4, e5, e6) = (version(&doc, "E4", "0"), version(&doc, "E5", "0"), version(&doc, "E6", "0"));
|
|
// The seed proposal of I1 (ADR 0011), and a rival written before the votes.
|
|
let seed_i1 = version(&doc, "I1", "0");
|
|
let i1_unit = unit(&doc, "I1")["id"].as_str().expect("unit").to_owned();
|
|
let rival = c
|
|
.ok(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/proposals"),
|
|
Some(json!({ "unitId": i1_unit, "title": "Raison d'être", "body": "Un autre texte pour I1, voté en simulation.", "submit": true })),
|
|
)
|
|
.await["id"]
|
|
.as_str()
|
|
.expect("rival")
|
|
.to_owned();
|
|
// The chain open: one proven voice on E5, one on E6 — not enough to enter; two on
|
|
// the seed proposal of I1, which enters on proven votes alone.
|
|
let charlie = Signer { account: CHARLIE, identity: Some((9003, "Charlie", true)) };
|
|
for (p, block, signer) in [(&e5, 100, alice()), (&e6, 101, charlie)] {
|
|
let b = c.ballot(&doc, &[(p, Some("for")), (&seed_i1, Some("for"))], None).await;
|
|
indexer.pay(block, comment_of(&b), signer);
|
|
}
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(unit(&d, "I1")["inForce"]["id"], seed_i1.as_str());
|
|
assert!(unit(&d, "E5")["inForce"].is_null() && unit(&d, "E6")["inForce"].is_null());
|
|
// The chain closed: Luna, Bruno and Marc vote in simulation; E4, E5, E6 enter, and
|
|
// the rival of I1, three voices against two, takes the place of the seed proposal.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": false }))).await;
|
|
let mut luna = c.other();
|
|
luna.login("Luna").await;
|
|
let mut bruno = c.other();
|
|
bruno.login("Bruno").await;
|
|
let mut marc = c.other();
|
|
marc.login("Marc").await;
|
|
let lines = json!([
|
|
{ "proposalId": e4, "choice": "for" }, { "proposalId": e5, "choice": "for" },
|
|
{ "proposalId": e6, "choice": "for" }, { "proposalId": rival, "choice": "for" },
|
|
]);
|
|
luna.ok("POST", &format!("/api/docs/{doc_id}/votes"), Some(json!({ "lines": lines }))).await;
|
|
let lines = json!([{ "proposalId": e4, "choice": "for" }, { "proposalId": rival, "choice": "for" }]);
|
|
bruno.ok("POST", &format!("/api/docs/{doc_id}/votes"), Some(json!({ "lines": lines }))).await;
|
|
marc.ok("POST", &format!("/api/proposals/{rival}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
for (code, id) in [("E4", &e4), ("E5", &e5), ("E6", &e6), ("I1", &rival)] {
|
|
assert_eq!(unit(&d, code)["inForce"]["id"], id.as_str(), "{code}");
|
|
}
|
|
// The chain opens again: nothing is set aside by itself — the simulated votes still count, marked.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": true }))).await;
|
|
let d = luna.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e5), pair(&find(&d, &e5)["tallySimulated"])), ((2, 0), (1, 0)));
|
|
assert_eq!(mine(&d, &e5), (Some("for"), Some("simulated")));
|
|
let (s, v) = luna.call("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": null }))).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("chain_only")));
|
|
// A second proven voice on E6, after it entered.
|
|
let b = c.ballot(&d, &[(&e6, Some("for"))], None).await;
|
|
indexer.pay(200, comment_of(&b), Signer { account: OTHER, identity: Some((9004, "Eve", true)) });
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
// Told first, nothing changed.
|
|
let told = ld_server::simulation::discard(&state, false).await.expect("dry run");
|
|
assert_eq!((told.applied, told.ballots, told.votes), (false, 3, 7));
|
|
let verdicts = |list: &[ld_server::simulation::Reexamined]| {
|
|
let mut v: Vec<(String, bool, bool)> = list.iter().map(|r| (r.code.clone(), r.holds, r.returned)).collect();
|
|
v.sort();
|
|
v
|
|
};
|
|
let expected_told: Vec<(String, bool, bool)> =
|
|
[("E4", false, false), ("E5", false, false), ("E6", true, false), ("I1", false, false)]
|
|
.iter()
|
|
.map(|(c, h, r)| ((*c).to_owned(), *h, *r))
|
|
.collect();
|
|
assert_eq!(verdicts(&told.reexamined), expected_told);
|
|
assert_eq!(unit(&c.doc("monnaie-libre").await, "E5")["inForce"]["id"], e5.as_str());
|
|
// Done: the simulated votes are gone; what does not hold on the proven votes returns.
|
|
let done = ld_server::simulation::discard(&state, true).await.expect("act");
|
|
let expected_done: Vec<(String, bool, bool)> =
|
|
[("E4", false, true), ("E5", false, true), ("E6", true, false), ("I1", false, true)]
|
|
.iter()
|
|
.map(|(c, h, r)| ((*c).to_owned(), *h, *r))
|
|
.collect();
|
|
assert_eq!(verdicts(&done.reexamined), expected_done);
|
|
let d = luna.doc("monnaie-libre").await;
|
|
assert!(unit(&d, "E4")["inForce"].is_null() && unit(&d, "E5")["inForce"].is_null());
|
|
assert_eq!(unit(&d, "E6")["inForce"]["id"], e6.as_str(), "two proven voices: it stays");
|
|
assert_eq!(unit(&d, "I1")["inForce"]["id"], seed_i1.as_str(), "the text it had displaced comes back");
|
|
assert_eq!(find(&d, &rival)["status"], "open");
|
|
assert_eq!((tally(&d, &e5), mine(&d, &e5)), ((1, 0), (None, None)));
|
|
let left: (i64, i64) = sqlx::query_as(
|
|
"SELECT (SELECT COUNT(*) FROM votes WHERE source = 'simulated'), (SELECT COUNT(*) FROM ballots WHERE mode = 'simulated')",
|
|
)
|
|
.fetch_one(&state.db)
|
|
.await
|
|
.expect("left");
|
|
assert_eq!(left, (0, 0));
|
|
let mut adopted: Vec<String> =
|
|
sqlx::query_scalar("SELECT proposal_id FROM adoptions").fetch_all(&state.db).await.expect("adoptions");
|
|
adopted.sort();
|
|
let mut kept = vec![seed_i1.clone(), e6.clone()];
|
|
kept.sort();
|
|
assert_eq!(adopted, kept, "the adoptions that do not hold are void; those on proven votes alone stay");
|
|
// Once is enough.
|
|
let again = ld_server::simulation::discard(&state, true).await.expect("again");
|
|
assert_eq!((again.ballots, again.reexamined.len()), (0, 0));
|
|
// Never without the dev login.
|
|
let mut cfg = chain_config(&indexer);
|
|
cfg.dev_login = false;
|
|
let (mut other, _) = Client::new(cfg).await;
|
|
let (s, _) = other.call("POST", "/api/dev/vote-chain", Some(json!({ "open": false }))).await;
|
|
assert_eq!(s, StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn an_intention_never_confirmed_is_set_aside_and_told() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
// A vote proven first: « contre ».
|
|
let first = c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
indexer.pay(100, comment_of(&first), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
// Then « pour », never paid: it takes the place of « contre » in the totals shown, for a while.
|
|
let b = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), pending(&d, &i1), counted(&state, &d, &i1).await), ((1, 0), (1, 0), (0, 1)));
|
|
assert_eq!(mine(&d, &i1), (Some("for"), Some("pending")));
|
|
// Someone else sees the totals shown, intention included.
|
|
let mut yvv = c.other();
|
|
yvv.login("Yvv").await;
|
|
assert_eq!(tally(&yvv.doc("monnaie-libre").await, &i1), (1, 0));
|
|
// Its window passes: set aside, and said — under the article, and in her messages.
|
|
age(&state, "expires_at", -5, id_of(&b)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&b)).await.0, "expired");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), pending(&d, &i1)), ((0, 1), (0, 0)));
|
|
assert_eq!(mine(&d, &i1), (Some("against"), Some("recorded")), "the vote of before stays");
|
|
assert_eq!(find(&d, &i1)["myBallot"]["status"], "expired");
|
|
assert_eq!(ballot_messages(&mut c).await, [("ballot_expired".to_owned(), id_of(&b).to_owned())]);
|
|
let m = c.ok("GET", "/api/messages", None).await;
|
|
let message = &m["messages"][0];
|
|
assert_eq!((message["done"].as_bool(), message["gestures"].as_array().map(Vec::len)), (Some(true), Some(0)));
|
|
assert_eq!(message["ballot"]["lines"][0]["code"], "I1");
|
|
assert_eq!(message["ballot"]["lines"][0]["choice"], "for");
|
|
assert_eq!(m["unread"], 1);
|
|
// A ballot the wallet never signed is let go at once: nothing to tell.
|
|
let dropped = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
assert_eq!(tally(&c.doc("monnaie-libre").await, &i1), (1, 0));
|
|
c.ok("DELETE", &format!("/api/ballots/{}", id_of(&dropped)), None).await;
|
|
assert_eq!(tally(&c.doc("monnaie-libre").await, &i1), (0, 1));
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(ballot_messages(&mut c).await.len(), 1);
|
|
// Purged a week later, its message goes with it.
|
|
age(&state, "settled_at", -8 * 24 * 3600, id_of(&b)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(ballot_messages(&mut c).await.len(), 0);
|
|
assert_eq!(c.ok("GET", "/api/messages/unread", None).await["unread"], 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn two_votes_of_one_identity_from_two_sessions_the_chain_keeps_the_last() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut chiara, state) = Client::new(chain_config(&indexer)).await;
|
|
chiara.login("Chiara").await;
|
|
let mut other = chiara.other();
|
|
other.login("Yvv").await;
|
|
let doc = chiara.doc("monnaie-libre").await;
|
|
let i1 = version(&doc, "I1", "0");
|
|
// One person, one wallet, two sessions: « pour » here, « contre » there.
|
|
let a = chiara.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let b = other.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
// Before the proofs, each intention counts for its session (ADR 0012, the cost).
|
|
assert_eq!(tally(&chiara.doc("monnaie-libre").await, &i1), (1, 1));
|
|
// On the chain, « pour » comes last; the indexer reads it first.
|
|
indexer.pay(200, comment_of(&a), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
indexer.pay(100, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let both = (db_status(&state, id_of(&a)).await.0, db_status(&state, id_of(&b)).await.0);
|
|
assert_eq!(both, ("confirmed".into(), "confirmed".into()));
|
|
// One voice: the last in the order of the chain.
|
|
let d = chiara.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), pending(&d, &i1), counted(&state, &d, &i1).await), ((1, 0), (0, 0), (1, 0)));
|
|
let outcomes: Vec<(String, Option<String>)> =
|
|
sqlx::query_as("SELECT ballot_id, outcome FROM ballot_lines ORDER BY ballot_id = ?")
|
|
.bind(id_of(&a))
|
|
.fetch_all(&state.db)
|
|
.await
|
|
.expect("lines");
|
|
assert_eq!(
|
|
outcomes,
|
|
[(id_of(&b).to_owned(), Some("superseded".into())), (id_of(&a).to_owned(), Some("counted".into()))]
|
|
);
|
|
let votes: Vec<(String, String)> =
|
|
sqlx::query_as("SELECT identity_id, choice FROM votes").fetch_all(&state.db).await.expect("votes");
|
|
assert_eq!(votes, [("idty:9001".to_owned(), "for".to_owned())]);
|
|
// The session whose vote was overtaken sees no vote of its own; nothing to tell.
|
|
let theirs = other.doc("monnaie-libre").await;
|
|
assert_eq!(mine(&theirs, &i1), (None, None));
|
|
assert!(ballot_messages(&mut other).await.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_for_proven_while_an_objection_holds_the_version_is_set_aside() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let (e1, e5) = (version(&doc, "E1", "0"), version(&doc, "E5", "0"));
|
|
// Proven first: « contre » on E5.
|
|
let before = c.ballot(&doc, &[(&e5, Some("against"))], None).await;
|
|
indexer.pay(100, comment_of(&before), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
// « Pour », sealed: seen at once in place of « contre ».
|
|
let b = c.ballot(&doc, &[(&e5, Some("for"))], None).await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e5), mine(&d, &e5)), ((1, 0), (Some("for"), Some("pending"))));
|
|
// An objection holds E5 back: the *for* still waiting weighs nothing.
|
|
let mut luna = c.other();
|
|
luna.login("Luna").await;
|
|
luna.ok(
|
|
"POST",
|
|
&format!("/api/proposals/{e5}/objections"),
|
|
Some(json!({ "otherId": e1, "kind": "contredit", "reason": "Ces deux textes disent le contraire." })),
|
|
)
|
|
.await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e5), pending(&d, &e5)), ((0, 1), (0, 0)));
|
|
// The chain proves it now: set aside; « contre » stays; she is told.
|
|
indexer.pay(200, comment_of(&b), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&b)).await.0, "confirmed");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e5), counted(&state, &d, &e5).await), ((0, 1), (0, 1)));
|
|
assert_eq!(mine(&d, &e5), (Some("against"), Some("recorded")));
|
|
let held = &find(&d, &e5)["myBallot"];
|
|
assert_eq!((held["status"].as_str(), held["reason"].as_str()), (Some("refused"), Some("objection")));
|
|
assert_eq!(ballot_messages(&mut c).await, [("ballot_objection".to_owned(), id_of(&b).to_owned())]);
|
|
// A withdrawal, proven while held, counts.
|
|
let w = c.ballot(&doc, &[(&e5, None)], None).await;
|
|
indexer.pay(300, comment_of(&w), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &e5), mine(&d, &e5)), ((0, 0), (None, None)));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_waiting_intention_counts_as_my_vote_in_decisions() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, _) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let without = |d: &Value| d["docs"][0]["withoutMyVote"].as_u64();
|
|
let before = without(&c.ok("GET", "/api/groups/monnaie-libre/decisions", None).await);
|
|
let i1 = version(&doc, "I1", "0");
|
|
c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let after = without(&c.ok("GET", "/api/groups/monnaie-libre/decisions", None).await);
|
|
assert_eq!(after, before.map(|n| n - 1));
|
|
}
|
|
|
|
/// The evaluation as the engine gives it for these totals, on this version's letters.
|
|
async fn judged(state: &AppState, doc: &Value, id: &str, shown: (u32, u32)) -> Value {
|
|
let st = ld_server::docs::load_state(state, doc["doc"]["id"].as_str().expect("doc")).await.expect("state");
|
|
let p = st.proposals.iter().find(|p| p.id == id).expect("version");
|
|
let u = st.units.iter().find(|u| u.id == p.unit_id).expect("unit");
|
|
let tally = ld_engine::threshold::Tally { for_votes: shown.0, against: shown.1 };
|
|
let e = ld_engine::threshold::evaluate(tally, st.electorate, &st.params(u, p)).expect("evaluation");
|
|
serde_json::to_value(e).expect("json")
|
|
}
|
|
|
|
/// What adoption judges: never an intention, simulated votes by default (ADR 0012).
|
|
async fn adopted_evaluation(state: &AppState, doc: &Value, id: &str) -> Value {
|
|
let st = ld_server::docs::load_state(state, doc["doc"]["id"].as_str().expect("doc")).await.expect("state");
|
|
let p = st.proposals.iter().find(|p| p.id == id).expect("version");
|
|
let u = st.units.iter().find(|u| u.id == p.unit_id).expect("unit");
|
|
serde_json::to_value(st.evaluation(u, p).expect("evaluation")).expect("json")
|
|
}
|
|
|
|
/// The quorum (ADR 0013) is judged on the totals shown — votes recorded, pending and
|
|
/// simulated, the vote one sees as one's own replaced by one's intention: `quorum`,
|
|
/// `yesNeeded`, `noNeeded` and `missing` are those of the totals shown. Adoption counts
|
|
/// the proven votes and the simulated ones (`SIMULATED_ADOPTS`), never an intention.
|
|
#[tokio::test]
|
|
async fn the_quorum_is_judged_on_the_totals_shown_and_adoption_never_on_an_intention() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
// I1, a seed proposal at level 2: the quorum 12, 9 « pour » at no vote.
|
|
let i1 = version(&doc, "I1", "0");
|
|
assert_eq!(find(&doc, &i1)["evaluation"], judged(&state, &doc, &i1, (0, 0)).await);
|
|
assert_eq!(find(&doc, &i1)["evaluation"]["yesNeeded"], 9);
|
|
// Proven: « contre ». Then « pour », sealed, not yet proven: it takes the place of
|
|
// « contre » in the totals shown, and in the evaluation shown.
|
|
let first = c.ballot(&doc, &[(&i1, Some("against"))], None).await;
|
|
indexer.pay(100, comment_of(&first), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), pending(&d, &i1), counted(&state, &d, &i1).await), ((1, 0), (1, 0), (0, 1)));
|
|
let shown = find(&d, &i1)["evaluation"].clone();
|
|
assert_eq!(shown, judged(&state, &d, &i1, (1, 0)).await, "on the totals shown");
|
|
assert_eq!((shown["cast"].as_u64(), shown["missing"].as_u64()), (Some(1), Some(8)));
|
|
let adoption = adopted_evaluation(&state, &d, &i1).await;
|
|
assert_eq!(adoption, judged(&state, &d, &i1, (0, 1)).await, "adoption: the proven « contre » only");
|
|
assert!(adoption["missing"].as_u64() > Some(8), "the intention never brings adoption closer: {adoption}");
|
|
// The detail says the same, and its five levels are asked at the votes shown.
|
|
let detail = c.ok("GET", &format!("/api/proposals/{i1}"), None).await;
|
|
assert_eq!(detail["proposal"]["evaluation"], shown);
|
|
assert!(detail["levels"].as_array().expect("levels").iter().all(|l| l["cast"] == 1), "{detail}");
|
|
// The chain closed: a simulated « pour » counts in both, like a proven vote.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": false }))).await;
|
|
let mut luna = c.other();
|
|
luna.login("Luna").await;
|
|
luna.ok(
|
|
"POST",
|
|
&format!("/api/docs/{doc_id}/votes"),
|
|
Some(json!({ "lines": [{ "proposalId": i1, "choice": "for" }] })),
|
|
)
|
|
.await;
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!((tally(&d, &i1), pending(&d, &i1), counted(&state, &d, &i1).await), ((2, 0), (1, 0), (1, 1)));
|
|
assert_eq!(find(&d, &i1)["evaluation"], judged(&state, &d, &i1, (2, 0)).await);
|
|
assert_eq!(adopted_evaluation(&state, &d, &i1).await, judged(&state, &d, &i1, (1, 1)).await);
|
|
}
|
|
|
|
/// « Un vote existe » (ADR 0013, `quorum::voted_units`), for every state of the buffer
|
|
/// (ADR 0012): an intention still pending, a proven line whatever became of it (a
|
|
/// withdrawal, a vote overtaken, a *for* set aside by an objection), a simulated vote,
|
|
/// a simulated withdrawal — the history of the ballots keeps their trace. A ballot the
|
|
/// wallet never signed, one never seen on the chain in time, one the chain refused, is
|
|
/// no vote.
|
|
#[tokio::test]
|
|
async fn a_vote_exists_for_every_state_of_the_buffer() {
|
|
let indexer = Indexer::start().await;
|
|
let (mut c, state) = Client::new(chain_config(&indexer)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
let unit_id = |code: &str| unit(&doc, code)["id"].as_str().expect("unit").to_owned();
|
|
let exists = |u: String| {
|
|
let state = state.clone();
|
|
async move { ld_server::quorum::a_vote_exists(&state, &u).await.expect("query") }
|
|
};
|
|
let (i1, e1, e2, e3, e4) = (
|
|
version(&doc, "I1", "0"),
|
|
version(&doc, "E1", "0"),
|
|
version(&doc, "E2", "0"),
|
|
version(&doc, "E3", "0"),
|
|
version(&doc, "E4", "0"),
|
|
);
|
|
for code in ["I1", "E1", "E2", "E3", "E4"] {
|
|
assert!(!exists(unit_id(code)).await, "{code}: nobody voted yet");
|
|
}
|
|
// A ballot the wallet never signed: nothing.
|
|
let dropped = c.ballot(&doc, &[(&i1, Some("for"))], None).await;
|
|
assert!(exists(unit_id("I1")).await, "an intention pending is a vote already");
|
|
c.ok("DELETE", &format!("/api/ballots/{}", id_of(&dropped)), None).await;
|
|
assert!(!exists(unit_id("I1")).await, "let go at once: no vote");
|
|
// Never seen on the chain in time: no vote.
|
|
let late = c.ballot(&doc, &[(&e2, Some("for"))], None).await;
|
|
age(&state, "expires_at", -2 * 3600, id_of(&late)).await;
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(db_status(&state, id_of(&late)).await.0, "expired");
|
|
assert!(!exists(unit_id("E2")).await);
|
|
// Proven, then withdrawn on the chain: no row in `votes`, the trace stays.
|
|
let a = c.ballot(&doc, &[(&e1, Some("for"))], None).await;
|
|
indexer.pay(100, comment_of(&a), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let w = c.ballot(&doc, &[(&e1, None)], None).await;
|
|
indexer.pay(101, comment_of(&w), alice());
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(counted(&state, &c.doc("monnaie-libre").await, &e1).await, (0, 0));
|
|
assert!(exists(unit_id("E1")).await, "a vote withdrawn leaves its trace");
|
|
// The chain closed: a simulated vote; a simulated vote, then withdrawn.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": false }))).await;
|
|
c.ok("POST", &format!("/api/proposals/{e3}/vote"), Some(json!({ "choice": "against" }))).await;
|
|
assert!(exists(unit_id("E3")).await, "a simulated vote");
|
|
c.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
c.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": null }))).await;
|
|
assert_eq!(counted(&state, &c.doc("monnaie-libre").await, &e4).await, (0, 0));
|
|
assert!(exists(unit_id("E4")).await, "a simulated vote withdrawn leaves its trace");
|
|
// The quorum is held: the author (an administrator, for a text of the seed) may not set it.
|
|
let mut admin = c.other();
|
|
admin.login_admin("Yvv").await;
|
|
for code in ["E1", "E3", "E4"] {
|
|
let (s, v) =
|
|
admin.call("PUT", &format!("/api/units/{}/quorum", unit_id(code)), Some(json!({ "quorum": 20 }))).await;
|
|
assert_eq!((s, v["error"].as_str()), (StatusCode::CONFLICT, Some("voted")), "{code}");
|
|
}
|
|
let (s, _) =
|
|
admin.call("PUT", &format!("/api/units/{}/quorum", unit_id("E2")), Some(json!({ "quorum": 20 }))).await;
|
|
assert_eq!(s, StatusCode::OK, "E2: no vote");
|
|
// The act « supprime » sets every simulated vote aside: with them, their trace.
|
|
ld_server::simulation::discard(&state, true).await.expect("act");
|
|
assert!(!exists(unit_id("E3")).await && !exists(unit_id("E4")).await);
|
|
assert!(exists(unit_id("E1")).await, "a proven trace stays");
|
|
let _ = doc_id;
|
|
}
|
|
|
|
/// A bare repository of the texts, for the publication (ADR 0011, 0012).
|
|
struct Texts {
|
|
dir: std::path::PathBuf,
|
|
bare: std::path::PathBuf,
|
|
}
|
|
|
|
impl Texts {
|
|
fn new(name: &str) -> Self {
|
|
let dir = std::env::temp_dir().join(format!("ld-v-{name}-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
std::fs::create_dir_all(&dir).expect("dir");
|
|
let bare = dir.join("textes.git");
|
|
let ok = std::process::Command::new("git").args(["init", "-q", "--bare"]).arg(&bare).status().expect("git");
|
|
assert!(ok.success());
|
|
Self { dir, bare }
|
|
}
|
|
|
|
/// A configuration that publishes there; `simulated`: `LD_PUBLISH_SIMULATED`.
|
|
fn config(&self, mut cfg: Config, simulated: bool) -> Config {
|
|
cfg.data_dir = self.dir.join("data");
|
|
cfg.publish = Some(ld_server::config::Publish {
|
|
remote: self.bare.display().to_string(),
|
|
branch: "main".into(),
|
|
key: self.dir.join("data/keys/publish_ed25519"),
|
|
author_name: "libreDecision".into(),
|
|
author_email: "decision@example.org".into(),
|
|
without_articles: false,
|
|
simulated,
|
|
});
|
|
cfg
|
|
}
|
|
|
|
/// The French text of the Acte as the repository has it; `None`: nothing published.
|
|
fn french(&self) -> Option<String> {
|
|
let out = std::process::Command::new("git")
|
|
.arg("-C")
|
|
.arg(&self.bare)
|
|
.args(["show", "main:monnaie-libre/acte-engagement-certification/fr.md"])
|
|
.output()
|
|
.expect("git show");
|
|
out.status.success().then(|| String::from_utf8(out.stdout).expect("utf8"))
|
|
}
|
|
}
|
|
|
|
impl Drop for Texts {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.dir);
|
|
}
|
|
}
|
|
|
|
/// A body of a version, as the document shows it.
|
|
fn body_of(doc: &Value, id: &str) -> String {
|
|
find(doc, id)["body"].as_str().expect("body").to_owned()
|
|
}
|
|
|
|
/// Yvv, 2026-11-03: « Pas avant des votes prouvés ». A text that enters by simulated
|
|
/// votes is in force on the site, but sends nothing to the repository of the texts:
|
|
/// the publication waits until everything in effect holds on the proven votes alone —
|
|
/// the re-examination of the act « supprime » (`simulation`), told only.
|
|
#[tokio::test]
|
|
async fn a_text_entered_by_simulated_votes_is_in_force_but_never_published_before_proven_votes() {
|
|
let indexer = Indexer::start().await;
|
|
let texts = Texts::new("proven");
|
|
let (mut c, state) = Client::new(texts.config(chain_config(&indexer), false)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
small_web(&state, &doc_id).await;
|
|
let (e4, e5) = (version(&doc, "E4", "0"), version(&doc, "E5", "0"));
|
|
// The chain closed: two simulated « pour », E4 enters — in force on the site.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": false }))).await;
|
|
for name in ["Luna", "Bruno"] {
|
|
let mut s = c.other();
|
|
s.login(name).await;
|
|
s.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
}
|
|
assert_eq!(unit(&c.doc("monnaie-libre").await, "E4")["inForce"]["id"], e4.as_str());
|
|
ld_server::publish::pass(&state).await.expect("pass");
|
|
assert!(texts.french().is_none(), "not before proven votes");
|
|
let publication = &c.doc("monnaie-libre").await["doc"]["publication"];
|
|
assert_eq!((publication["state"].as_str(), publication["waitsFor"].as_str()), (Some("suspended"), Some("proven")));
|
|
// The chain open: E5 enters on two proven votes — E4 still does not hold on them: nothing goes out.
|
|
c.ok("POST", "/api/dev/vote-chain", Some(json!({ "open": true }))).await;
|
|
let charlie = Signer { account: CHARLIE, identity: Some((9003, "Charlie", true)) };
|
|
for (block, signer) in [(100, alice()), (101, charlie)] {
|
|
let b = c.ballot(&doc, &[(&e5, Some("for"))], None).await;
|
|
indexer.pay(block, comment_of(&b), signer);
|
|
}
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
let d = c.doc("monnaie-libre").await;
|
|
assert_eq!(unit(&d, "E5")["inForce"]["id"], e5.as_str());
|
|
ld_server::publish::pass(&state).await.expect("pass");
|
|
assert!(texts.french().is_none(), "E4 does not hold on the proven votes yet");
|
|
// The act « supprime »: E4 returns among the proposals; what is in force holds on the
|
|
// proven votes alone — it goes out.
|
|
ld_server::simulation::discard(&state, true).await.expect("act");
|
|
ld_server::publish::pass(&state).await.expect("pass");
|
|
let fr = texts.french().expect("published");
|
|
let (b4, b5) = (body_of(&d, &e4), body_of(&d, &e5));
|
|
assert!(fr.contains(b5.lines().next().expect("line")), "{fr}");
|
|
assert!(!fr.contains(b4.lines().next().expect("line")), "{fr}");
|
|
assert_eq!(c.doc("monnaie-libre").await["doc"]["publication"]["state"], "done");
|
|
}
|
|
|
|
/// Yvv may choose the other way (`LD_PUBLISH_SIMULATED=1`): published anyway.
|
|
#[tokio::test]
|
|
async fn with_the_switch_a_text_entered_by_simulated_votes_is_published() {
|
|
let texts = Texts::new("switch");
|
|
let (mut c, state) = Client::new(texts.config(Config::for_tests(), true)).await;
|
|
c.login("Chiara").await;
|
|
let doc = c.doc("monnaie-libre").await;
|
|
let doc_id = doc["doc"]["id"].as_str().expect("id").to_owned();
|
|
small_web(&state, &doc_id).await;
|
|
let e4 = version(&doc, "E4", "0");
|
|
for name in ["Luna", "Bruno"] {
|
|
let mut s = c.other();
|
|
s.login(name).await;
|
|
s.ok("POST", &format!("/api/proposals/{e4}/vote"), Some(json!({ "choice": "for" }))).await;
|
|
}
|
|
ld_server::publish::pass(&state).await.expect("pass");
|
|
let fr = texts.french().expect("published");
|
|
assert!(fr.contains(body_of(&doc, &e4).lines().next().expect("line")), "{fr}");
|
|
}
|
|
|
|
/// Production runs the migrations up to 0008 (M5, `3f10a0e`), its vote on the chain off.
|
|
/// The image of now applies 0009, 0010 and 0011, in this order; 0010 rewrites no row —
|
|
/// a ballot of before stays a ballot of the chain, its lines without outcome, the votes
|
|
/// as they were — and the first start writes nothing of the buffer.
|
|
#[tokio::test]
|
|
async fn on_a_base_like_production_the_three_migrations_pass_in_order_and_0010_rewrites_nothing() {
|
|
use sqlx::sqlite::SqliteConnectOptions;
|
|
use std::str::FromStr;
|
|
let options = SqliteConnectOptions::from_str("sqlite::memory:").expect("url").foreign_keys(true);
|
|
let pool = sqlx::sqlite::SqlitePoolOptions::new().max_connections(1).connect_with(options).await.expect("pool");
|
|
let mut before = sqlx::migrate!("./migrations");
|
|
before.migrations = before.migrations.iter().filter(|m| m.version <= 8).cloned().collect::<Vec<_>>().into();
|
|
before.run(&pool).await.expect("up to 0008");
|
|
let tables = |pool: sqlx::SqlitePool| async move {
|
|
let ballots: Vec<(String, String, Option<i64>)> =
|
|
sqlx::query_as("SELECT id, status, block FROM ballots ORDER BY id")
|
|
.fetch_all(&pool)
|
|
.await
|
|
.expect("ballots");
|
|
let lines: Vec<(String, String, String)> =
|
|
sqlx::query_as("SELECT ballot_id, proposal_id, choice FROM ballot_lines ORDER BY ballot_id")
|
|
.fetch_all(&pool)
|
|
.await
|
|
.expect("lines");
|
|
let votes: Vec<(String, String, String, String, Option<String>)> = sqlx::query_as(
|
|
"SELECT proposal_id, identity_id, choice, source, ballot_id FROM votes ORDER BY proposal_id, identity_id",
|
|
)
|
|
.fetch_all(&pool)
|
|
.await
|
|
.expect("votes");
|
|
(ballots, lines, votes)
|
|
};
|
|
// The rows the image of before writes: a document, a ballot of the chain confirmed
|
|
// with its line and its vote, and one pending.
|
|
for sql in [
|
|
"INSERT INTO groups (slug, name, policy, hidden, position) VALUES ('monnaie-libre', 'Monnaie libre', 'g1-members', 0, 0)",
|
|
"INSERT INTO documents (id, group_slug, slug, title, summary, source_lang, vote_floor, created_at)
|
|
VALUES ('d1', 'monnaie-libre', 'acte', '{\"fr\":\"Acte\"}', '{}', 'fr', 50, '2026-10-21T00:00:00Z')",
|
|
"INSERT INTO units (id, doc_id, code, section, position, inertia, created_at) VALUES ('u1', 'd1', 'E4', 'fondamental', 1, '3', '2026-10-21T00:00:00Z')",
|
|
"INSERT INTO proposals (id, unit_id, kind, title, body, status, origin, revision, created_at, updated_at)
|
|
VALUES ('p1', 'u1', 'text', 'E4', 'Un texte.', 'open', 'seed', 1, '2026-10-21T00:00:00Z', '2026-10-21T00:00:00Z')",
|
|
"INSERT INTO identities (id, kind, display_name, created_at) VALUES ('dev:chiara', 'dev', 'Chiara', '2026-10-21T00:00:00Z')",
|
|
"INSERT INTO identities (id, kind, display_name, g1_member, created_at) VALUES ('idty:9001', 'g1', 'Alice', 1, '2026-10-21T00:00:00Z')",
|
|
"INSERT INTO ballots (id, doc_id, requested_by, salt, digest, remark_hash, account, amount, status, voter_id, block,
|
|
event_index, created_at, expires_at, settled_at)
|
|
VALUES ('b1', 'd1', 'dev:chiara', 's1', 'h1', '0xr1', 'g1vote', 10, 'confirmed', 'idty:9001', 100, 1,
|
|
'2026-11-01T00:00:00Z', '2026-11-02T00:00:00Z', '2026-11-01T00:01:00Z')",
|
|
"INSERT INTO ballot_lines (ballot_id, proposal_id, revision, choice) VALUES ('b1', 'p1', 1, 'for')",
|
|
"INSERT INTO votes (proposal_id, identity_id, choice, revision, cast_at, source, block, event_index, ballot_id)
|
|
VALUES ('p1', 'idty:9001', 'for', 1, '2026-11-01T00:01:00Z', 'chain', 100, 1, 'b1')",
|
|
"INSERT INTO ballots (id, doc_id, requested_by, salt, digest, remark_hash, account, amount, status, created_at, expires_at)
|
|
VALUES ('b2', 'd1', 'dev:chiara', 's2', 'h2', '0xr2', 'g1vote', 10, 'pending', '2026-11-03T00:00:00Z', '2099-01-01T00:00:00Z')",
|
|
"INSERT INTO ballot_lines (ballot_id, proposal_id, revision, choice) VALUES ('b2', 'p1', 1, 'against')",
|
|
] {
|
|
sqlx::query(sql).execute(&pool).await.unwrap_or_else(|e| panic!("{sql}: {e}"));
|
|
}
|
|
let written = tables(pool.clone()).await;
|
|
// The image of now.
|
|
let state = AppState::new(Config::for_tests(), pool.clone()).await.expect("state");
|
|
let mut all = sqlx::migrate!("./migrations");
|
|
all.set_ignore_missing(true);
|
|
all.run(&pool).await.expect("0009 to 0011");
|
|
let order: Vec<i64> = sqlx::query_scalar("SELECT version FROM _sqlx_migrations ORDER BY rowid")
|
|
.fetch_all(&pool)
|
|
.await
|
|
.expect("order");
|
|
assert_eq!(order, (1..=11).collect::<Vec<i64>>(), "0009, then 0010, then 0011");
|
|
assert_eq!(tables(pool.clone()).await, written, "no row rewritten");
|
|
let added: Vec<(String, String, Option<String>)> = sqlx::query_as(
|
|
"SELECT b.id, b.mode, l.outcome FROM ballots b JOIN ballot_lines l ON l.ballot_id = b.id ORDER BY b.id",
|
|
)
|
|
.fetch_all(&pool)
|
|
.await
|
|
.expect("columns");
|
|
assert_eq!(added, [("b1".into(), "chain".into(), None), ("b2".into(), "chain".into(), None)]);
|
|
let index: i64 =
|
|
sqlx::query_scalar("SELECT COUNT(*) FROM sqlite_master WHERE type = 'index' AND name = 'ballots_doc'")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.expect("index");
|
|
assert_eq!(index, 1);
|
|
// The first start, the chain closed: the watcher passes, nothing of the buffer is written.
|
|
ballots::sweep(&state).await.expect("sweep");
|
|
assert_eq!(tables(pool.clone()).await, written);
|
|
let simulated: i64 = sqlx::query_scalar(
|
|
"SELECT (SELECT COUNT(*) FROM ballots WHERE mode = 'simulated') + (SELECT COUNT(*) FROM votes WHERE source = 'simulated')
|
|
+ (SELECT COUNT(*) FROM messages WHERE topic = 'ballot')",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.expect("simulated");
|
|
assert_eq!(simulated, 0);
|
|
// The ballots of before read as they did: a vote of the chain, recorded; the one
|
|
// pending, an intention that takes its place in the totals shown only.
|
|
let mine = ballots::my_votes(&state, "dev:chiara", "d1").await.expect("mine");
|
|
assert_eq!(mine.get("p1").map(|v| (v.choice.as_str(), v.source.as_str())), Some(("for", "chain")));
|
|
let st = ld_server::docs::load_state(&state, "d1").await.expect("state");
|
|
let pair = |t: ld_engine::threshold::Tally| (t.for_votes, t.against);
|
|
assert_eq!(
|
|
(pair(st.tally("p1")), pair(st.shown_tally("p1")), pair(st.pending_tally("p1"))),
|
|
((1, 0), (0, 1), (0, 1))
|
|
);
|
|
}
|