Better testing

internal/api/lib_test.go

@@ -24,10 +24,6 @@ const (
 )
 
 func TestInitAndReleaseCache(t *testing.T) {
-	dataDir := "/foo"
-	_, err := InitCache(dataDir, TESTING_FEATURES, TESTING_CACHE_SIZE, TESTING_MEMORY_LIMIT)
-	require.Error(t, err)
-
 	tmpdir, err := ioutil.TempDir("", "wasmvm-testing")
 	require.NoError(t, err)
 	defer os.RemoveAll(tmpdir)
@@ -477,26 +473,25 @@ func TestExecuteUnreachable(t *testing.T) {
 func TestExecuteCpuLoop(t *testing.T) {
 	cache, cleanup := withCache(t)
 	defer cleanup()
-	checksum := createHackatomContract(t, cache)
+	checksum := createCyberpunkContract(t, cache)
 
 	gasMeter1 := NewMockGasMeter(TESTING_GAS_LIMIT)
 	igasMeter1 := types.GasMeter(gasMeter1)
 	// instantiate it with this store
 	store := NewLookup(gasMeter1)
 	api := NewMockAPI()
-	balance := types.Coins{types.NewCoin(250, "ATOM")}
-	querier := DefaultQuerier(MOCK_CONTRACT_ADDR, balance)
+	querier := DefaultQuerier(MOCK_CONTRACT_ADDR, nil)
 	env := MockEnvBin(t)
 	info := MockInfoBin(t, "creator")
 
-	msg := []byte(`{"verifier": "fred", "beneficiary": "bob"}`)
+	msg := []byte(`{}`)
 
 	start := time.Now()
 	res, cost, err := Instantiate(cache, checksum, env, info, msg, &igasMeter1, store, api, &querier, TESTING_GAS_LIMIT, TESTING_PRINT_DEBUG)
 	diff := time.Now().Sub(start)
 	require.NoError(t, err)
 	requireOkResponse(t, res, 0)
-	assert.Equal(t, uint64(0x13a78a36c), cost)
+	assert.Equal(t, uint64(0xd45091d0), cost)
 	t.Logf("Time (%d gas): %s\n", cost, diff)
 
 	// execute a cpu loop

libwasmvm/src/tests.rs

@@ -1,40 +1,19 @@
 #![cfg(test)]
 
-use serde::{Deserialize, Serialize};
 use tempfile::TempDir;
 
-use cosmwasm_std::coins;
 use cosmwasm_vm::testing::{mock_backend, mock_env, mock_info, mock_instance_with_gas_limit};
 use cosmwasm_vm::{
     call_execute_raw, call_instantiate_raw, capabilities_from_csv, to_vec, Cache, CacheOptions,
     InstanceOptions, Size,
 };
 
-static CONTRACT: &[u8] = include_bytes!("../../testdata/hackatom.wasm");
+static CYBERPUNK: &[u8] = include_bytes!("../../testdata/cyberpunk.wasm");
 const PRINT_DEBUG: bool = false;
 const MEMORY_CACHE_SIZE: Size = Size::mebi(200);
 const MEMORY_LIMIT: Size = Size::mebi(32);
 const GAS_LIMIT: u64 = 200_000_000_000; // ~0.2ms
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-pub struct InstantiateMsg {
-    pub verifier: String,
-    pub beneficiary: String,
-}
-
-fn make_instantiate_msg() -> (InstantiateMsg, String) {
-    let verifier = String::from("verifies");
-    let beneficiary = String::from("benefits");
-    let creator = String::from("creator");
-    (
-        InstantiateMsg {
-            verifier,
-            beneficiary,
-        },
-        creator,
-    )
-}
-
 #[test]
 fn handle_cpu_loop_with_cache() {
     let backend = mock_backend(&[]);
@@ -52,17 +31,15 @@ fn handle_cpu_loop_with_cache() {
     };
 
     // store code
-    let checksum = cache.save_wasm(CONTRACT).unwrap();
+    let checksum = cache.save_wasm(CYBERPUNK).unwrap();
 
     // instantiate
-    let (instantiate_msg, creator) = make_instantiate_msg();
     let env = mock_env();
-    let info = mock_info(&creator, &coins(1000, "cosm"));
+    let info = mock_info("creator", &[]);
     let mut instance = cache.get_instance(&checksum, backend, options).unwrap();
-    let raw_msg = to_vec(&instantiate_msg).unwrap();
     let raw_env = to_vec(&env).unwrap();
     let raw_info = to_vec(&info).unwrap();
-    let res = call_instantiate_raw(&mut instance, &raw_env, &raw_info, &raw_msg);
+    let res = call_instantiate_raw(&mut instance, &raw_env, &raw_info, b"{}");
     let gas_left = instance.get_gas_left();
     let gas_used = options.gas_limit - gas_left;
     println!("Init gas left: {}, used: {}", gas_left, gas_used);
@@ -71,8 +48,8 @@ fn handle_cpu_loop_with_cache() {
 
     // execute
     let mut instance = cache.get_instance(&checksum, backend, options).unwrap();
-    let raw_msg = r#"{"cpu_loop":{}}"#;
-    let res = call_execute_raw(&mut instance, &raw_env, &raw_info, raw_msg.as_bytes());
+    let raw_msg = br#"{"cpu_loop":{}}"#;
+    let res = call_execute_raw(&mut instance, &raw_env, &raw_info, raw_msg);
     let gas_left = instance.get_gas_left();
     let gas_used = options.gas_limit - gas_left;
     println!("Handle gas left: {}, used: {}", gas_left, gas_used);
@@ -84,24 +61,22 @@ fn handle_cpu_loop_with_cache() {
 #[test]
 fn handle_cpu_loop_no_cache() {
     let gas_limit = GAS_LIMIT;
-    let mut instance = mock_instance_with_gas_limit(CONTRACT, gas_limit);
+    let mut instance = mock_instance_with_gas_limit(CYBERPUNK, gas_limit);
 
     // instantiate
-    let (instantiate_msg, creator) = make_instantiate_msg();
     let env = mock_env();
-    let info = mock_info(&creator, &coins(1000, "cosm"));
-    let raw_msg = to_vec(&instantiate_msg).unwrap();
+    let info = mock_info("creator", &[]);
     let raw_env = to_vec(&env).unwrap();
     let raw_info = to_vec(&info).unwrap();
-    let res = call_instantiate_raw(&mut instance, &raw_env, &raw_info, &raw_msg);
+    let res = call_instantiate_raw(&mut instance, &raw_env, &raw_info, b"{}");
     let gas_left = instance.get_gas_left();
     let gas_used = gas_limit - gas_left;
     println!("Init gas left: {}, used: {}", gas_left, gas_used);
     assert!(res.is_ok());
 
     // execute
-    let raw_msg = r#"{"cpu_loop":{}}"#;
-    let res = call_execute_raw(&mut instance, &raw_env, &raw_info, raw_msg.as_bytes());
+    let raw_msg = br#"{"cpu_loop":{}}"#;
+    let res = call_execute_raw(&mut instance, &raw_env, &raw_info, raw_msg);
     let gas_left = instance.get_gas_left();
     let gas_used = gas_limit - gas_left;
     println!("Handle gas left: {}, used: {}", gas_left, gas_used);