post-push-party 0.1.8

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

use super::{BonusTrack, PushContext, Reward, Tier};

/// base points earned per commit
pub struct CommitValue;

static TIERS: &[Tier] = &[
    Tier {
        cost: 0,
        reward: Reward::FlatPoints(1),
    },
    Tier {
        cost: 25,
        reward: Reward::FlatPoints(2),
    },
    Tier {
        cost: 200,
        reward: Reward::FlatPoints(3),
    },
    Tier {
        cost: 2_000,
        reward: Reward::FlatPoints(4),
    },
    Tier {
        cost: 20_000,
        reward: Reward::FlatPoints(5),
    },
];

impl BonusTrack for CommitValue {
    fn id(&self) -> &'static str {
        "commit_value"
    }

    fn name(&self) -> &'static str {
        "Commit Value"
    }

    fn description(&self) -> &'static str {
        "How many party points you earn per commit."
    }

    fn tiers(&self) -> &'static [Tier] {
        TIERS
    }

    fn applies(&self, _ctx: &PushContext) -> u32 {
        1 // always applies
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        bonus_track::Clock,
        git::Push,
        storage::{DbConnection, PushHistory},
    };

    #[test]
    fn tiers_start_free() {
        let tiers = CommitValue.tiers();
        assert_eq!(tiers[0].cost, 0);
        assert_eq!(tiers[0].reward, Reward::FlatPoints(1));
    }

    #[test]
    fn always_applies() {
        let conn = DbConnection::create_in_memory().unwrap();

        let push = Push::new(vec![]);
        let ctx = PushContext {
            push: &push,
            history: &PushHistory::new(&conn),
            clock: &Clock::default(),
        };
        assert_eq!(CommitValue.applies(&ctx), 1);
    }
}