all the tests

src/state.rs

@@ -120,6 +120,12 @@ pub mod tests {
             .unwrap();
     }
 
+    pub fn set_eligible(storage: &mut dyn Storage, addresses: Vec<&str>) {
+        eligible_subscriptions(storage)
+            .save(&to_addresses(addresses))
+            .unwrap();
+    }
+
     pub fn set_accepted(storage: &mut dyn Storage, addresses: Vec<&str>) {
         accepted_subscriptions(storage)
             .save(&to_addresses(addresses))

src/subscribe.rs

@@ -51,7 +51,9 @@ pub fn try_propose_subscription(
         if eligible { 1 } else { 0 },
     );
 
-    Ok(Response::new().add_submessage(create_sub))
+    Ok(Response::new()
+        .add_submessage(create_sub)
+        .add_attribute("eligible", format!("{}", eligible)))
 }
 
 fn attributes(deps: Deps<ProvenanceQuery>, lp: &Addr) -> HashSet<String> {
@@ -157,6 +159,8 @@ pub fn try_accept_subscriptions(
             }
 
             pending.remove(&accept.subscription);
+        } else {
+            return contract_error("subscription must either be pending or eligible");
         }
 
         accepted.insert(accept.subscription.clone());
@@ -194,13 +198,13 @@ mod tests {
     use crate::msg::QueryMsg;
     use crate::msg::RaiseState;
     use crate::query::query;
-    use crate::state::accepted_subscriptions_read;
     use crate::state::config;
     use crate::state::pending_subscriptions_read;
-    use crate::state::tests::set_pending;
     use crate::state::tests::to_addresses;
     use crate::state::tests::{asset_exchange_storage_read, set_accepted};
+    use crate::state::tests::{set_eligible, set_pending};
     use crate::state::State;
+    use crate::state::{accepted_subscriptions_read, eligible_subscriptions_read};
     use cosmwasm_std::coins;
     use cosmwasm_std::from_binary;
     use cosmwasm_std::testing::mock_env;
@@ -232,7 +236,7 @@ mod tests {
     }
 
     #[test]
-    fn propose_subscription() {
+    fn propose_pending_subscription() {
         let mut deps = default_deps(None);
 
         // propose a sub as lp
@@ -266,10 +270,64 @@ mod tests {
         );
         assert_eq!(0, funds.len());
         assert_eq!("establish subscription", label);
+        assert_eq!(
+            "false",
+            res.attributes
+                .iter()
+                .find(|attr| attr.key == "eligible")
+                .unwrap()
+                .value
+        );
+    }
+
+    #[test]
+    fn propose_eligible_subscription() {
+        let mut deps = default_deps(None);
+        deps.querier.with_attributes("lp", &[("506c", "", "")]);
+
+        // propose a sub as lp
+        let res = execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info("lp", &[]),
+            HandleMsg::ProposeSubscription {
+                initial_commitment: Some(100),
+            },
+        )
+        .unwrap();
+
+        // verify instantiate message
+        assert_eq!(1, res.messages.len());
+        let (admin, code_id, msg, funds, label) =
+            instantiate_args::<SubInstantiateMsg>(msg_at_index(&res, 0));
+        assert_eq!("cosmos2contract", admin.clone().unwrap());
+        assert_eq!(&100, code_id);
+        assert_eq!(
+            SubInstantiateMsg {
+                admin: Addr::unchecked("marketpalace"),
+                lp: Addr::unchecked("lp"),
+                commitment_denom: String::from("commitment_coin"),
+                investment_denom: String::from("investment_coin"),
+                capital_denom: String::from("stable_coin"),
+                capital_per_share: 100,
+                initial_commitment: Some(100),
+            },
+            msg
+        );
+        assert_eq!(0, funds.len());
+        assert_eq!("establish subscription", label);
+        assert_eq!(
+            "true",
+            res.attributes
+                .iter()
+                .find(|attr| attr.key == "eligible")
+                .unwrap()
+                .value
+        );
     }
 
     #[test]
-    fn close_subscriptions_pending() {
+    fn close_pending_subscriptions() {
         let mut deps = default_deps(None);
         set_pending(&mut deps.storage, vec!["sub_1"]);
 
@@ -294,6 +352,32 @@ mod tests {
         )
     }
 
+    #[test]
+    fn close_eligible_subscriptions() {
+        let mut deps = default_deps(None);
+        set_eligible(&mut deps.storage, vec!["sub_1"]);
+
+        // close sub as gp
+        execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info("gp", &[]),
+            HandleMsg::CloseSubscriptions {
+                subscriptions: to_addresses(vec!["sub_1"]),
+            },
+        )
+        .unwrap();
+
+        // verify pending sub is removed
+        assert_eq!(
+            0,
+            eligible_subscriptions_read(&deps.storage)
+                .load()
+                .unwrap()
+                .len()
+        )
+    }
+
     #[test]
     fn close_subscriptions_accepted_no_commitment() {
         let mut deps = default_deps(None);
@@ -399,7 +483,7 @@ mod tests {
     }
 
     #[test]
-    fn accept_subscription() {
+    fn accept_pending_subscription() {
         let mut deps = mock_sub_state();
         deps.querier.base.with_attributes("lp", &[("506c", "", "")]);
         config(&mut deps.storage)
@@ -446,11 +530,80 @@ mod tests {
         )
     }
 
+    #[test]
+    fn accept_eligible_subscription() {
+        let mut deps = mock_sub_state();
+        deps.querier.base.with_attributes("lp", &[("506c", "", "")]);
+        config(&mut deps.storage)
+            .save(&State::test_default())
+            .unwrap();
+        set_eligible(&mut deps.storage, vec!["sub_1"]);
+
+        // accept pending sub as gp
+        execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info("gp", &[]),
+            HandleMsg::AcceptSubscriptions {
+                subscriptions: vec![AcceptSubscription {
+                    subscription: Addr::unchecked("sub_1"),
+                    commitment_in_capital: 20_000,
+                }]
+                .into_iter()
+                .collect(),
+            },
+        )
+        .unwrap();
+
+        // assert that the sub has moved from pending review to accepted
+        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetState {}).unwrap();
+        let state: RaiseState = from_binary(&res).unwrap();
+        assert_eq!(0, state.eligible_subscriptions.len());
+        assert_eq!(1, state.accepted_subscriptions.len());
+
+        // verify asset exchange exists
+        assert_eq!(
+            &AssetExchange {
+                investment: None,
+                commitment_in_shares: Some(200),
+                capital: None,
+                date: None,
+            },
+            asset_exchange_storage_read(&mut deps.storage)
+                .load(Addr::unchecked("sub_1").as_bytes())
+                .unwrap()
+                .iter()
+                .next()
+                .unwrap()
+        )
+    }
+
     #[test]
     fn accept_subscription_bad_actor() {
         let mut deps = mock_sub_state();
         set_pending(&mut deps.storage, vec!["sub_1"]);
 
+        // accept pending sub as bad actor
+        let res = execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info("bad_actor", &[]),
+            HandleMsg::AcceptSubscriptions {
+                subscriptions: vec![AcceptSubscription {
+                    subscription: Addr::unchecked("sub_1"),
+                    commitment_in_capital: 20_000,
+                }]
+                .into_iter()
+                .collect(),
+            },
+        );
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn accept_subscription_not_pending_or_eligible() {
+        let mut deps = mock_sub_state();
+
         // accept pending sub as gp
         let res = execute(
             deps.as_mut(),