schemamama 0.3.0

A lightweight database schema migration system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#[macro_use]
extern crate schemamama;

use schemamama::{Adapter, Migration, Migrator, Version};
use std::cell::RefCell;
use std::collections::BTreeSet;

struct DummyAdapter {
    versions: RefCell<BTreeSet<Version>>
}

impl DummyAdapter {
    pub fn new() -> DummyAdapter {
        DummyAdapter { versions: RefCell::new(BTreeSet::new()) }
    }

    pub fn is_migrated(&self, version: Version) -> bool {
        self.versions.borrow().contains(&version)
    }
}

impl Adapter for DummyAdapter {
    type MigrationType = Migration;
    type Error = ();

    fn current_version(&self) -> Result<Option<Version>, ()> {
        Ok(self.versions.borrow().iter().last().map(|v| *v))
    }

    fn migrated_versions(&self) -> Result<BTreeSet<Version>, ()> {
        Ok(self.versions.borrow().iter().cloned().collect())
    }

    fn apply_migration(&self, migration: &Migration) -> Result<(), ()> {
        self.versions.borrow_mut().insert(migration.version());
        Ok(())
    }

    fn revert_migration(&self, migration: &Migration) -> Result<(), ()> {
        self.versions.borrow_mut().remove(&migration.version());
        Ok(())
    }
}

struct FirstMigration;
migration!(FirstMigration, 10, "first migration");
struct SecondMigration;
migration!(SecondMigration, 20, "second migration");

#[test]
fn test_registration() {
    let mut migrator = Migrator::new(DummyAdapter::new());
    assert_eq!(migrator.first_version(), None);
    assert_eq!(migrator.last_version(), None);
    migrator.register(Box::new(SecondMigration));
    migrator.register(Box::new(FirstMigration));
    assert_eq!(migrator.first_version(), Some(10));
    assert_eq!(migrator.last_version(), Some(20));
    let mut versions = BTreeSet::new();
    versions.insert(10);
    versions.insert(20);
    assert_eq!(migrator.registered_versions(), versions);
}

#[test]
fn test_version_registered() {
    let mut migrator = Migrator::new(DummyAdapter::new());
    assert_eq!(migrator.version_registered(10), false);
    migrator.register(Box::new(FirstMigration));
    assert_eq!(migrator.version_registered(10), true);
}

#[test]
fn test_migrate() {
    let mut migrator = Migrator::new(DummyAdapter::new());
    migrator.register(Box::new(FirstMigration));
    migrator.register(Box::new(SecondMigration));
    assert_eq!(migrator.current_version().unwrap(), None);
    migrator.up(Some(20)).unwrap();
    assert_eq!(migrator.current_version().unwrap(), Some(20));
    migrator.down(Some(10)).unwrap();
    assert_eq!(migrator.current_version().unwrap(), Some(10));
    migrator.down(None).unwrap();
    assert_eq!(migrator.current_version().unwrap(), None);
    migrator.up(None).unwrap();
    assert_eq!(migrator.current_version().unwrap(), Some(20));
}

#[test]
fn test_retroactive_migrations() {
    let mut migrator = Migrator::new(DummyAdapter::new());
    migrator.register(Box::new(SecondMigration));
    migrator.up(Some(20)).unwrap();
    assert_eq!(migrator.current_version().unwrap(), Some(20));
    assert!(migrator.adapter().is_migrated(20));
    assert!(!migrator.adapter().is_migrated(10));
    migrator.register(Box::new(FirstMigration));
    migrator.up(Some(20)).unwrap();
    assert_eq!(migrator.current_version().unwrap(), Some(20));
    assert!(migrator.adapter().is_migrated(20));
    assert!(migrator.adapter().is_migrated(10));
}