andromeda-std 1.0.0

The standard library for creating an Andromeda Digital Object
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

use crate::ado_contract::{modules::Module, ADOContract};
use crate::error::ContractError;
use cosmwasm_std::{Deps, Order, Uint64};
use cw_storage_plus::Bound;

impl<'a> ADOContract<'a> {
    /// Queries a module by its id.
    pub fn query_module(&self, deps: Deps, id: Uint64) -> Result<Module, ContractError> {
        let id = id.to_string();
        let module = self.module_info.load(deps.storage, &id)?;
        Ok(module)
    }

    /// Queries all of the module ids.
    pub fn query_module_ids(&self, deps: Deps) -> Result<Vec<String>, ContractError> {
        let module_idx = self.module_idx.may_load(deps.storage)?.unwrap_or(1);
        let min = Some(Bound::inclusive("1"));
        let module_ids: Result<Vec<String>, _> = self
            .module_info
            .keys(deps.storage, min, None, Order::Ascending)
            .take(module_idx as usize)
            .collect();
        Ok(module_ids?)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ado_contract::modules::Module;
    use cosmwasm_std::{testing::mock_dependencies, Addr};

    #[test]
    fn test_query_module() {
        let contract = ADOContract::default();
        let mut deps = mock_dependencies();

        contract
            .owner
            .save(deps.as_mut().storage, &Addr::unchecked("owner"))
            .unwrap();

        let module1 = Module::new("module_name1", "address1", true);

        let module2 = Module::new("module_name2", "address2", true);

        contract
            .module_info
            .save(deps.as_mut().storage, "1", &module1)
            .unwrap();

        contract
            .module_info
            .save(deps.as_mut().storage, "2", &module2)
            .unwrap();

        contract.module_idx.save(deps.as_mut().storage, &2).unwrap();

        let res = contract
            .query_module(deps.as_ref(), Uint64::from(1u64))
            .unwrap();

        assert_eq!(module1, res);

        let res = contract
            .query_module(deps.as_ref(), Uint64::from(2u64))
            .unwrap();

        assert_eq!(module2, res);

        let res = contract.query_module_ids(deps.as_ref()).unwrap();
        assert_eq!(vec![String::from("1"), String::from("2")], res);
    }
}