imports
#[test]
fn contract_to_contract() {
    // Create new IperApp.
    // Is possible to user default AppBuilder from cw-multi-test
    // adding api, ibc and stargate modules as following
    let neutron = AppBuilder::new()
        .with_api(MockApiBech32::new("neutron"))
        .with_ibc(IperIbcModule::default())
        .with_stargate(IperStargateModule::default())
        .build(no_init)
        .into_iper_app("neutron"); // transform App into IperApp

    // Or use IperAppBuilder
    let osmosis = IperAppBuilder::new("osmo")
        .build(no_init)
        .into_iper_app("osmosis");

    // Create an Ecosystem wih both neutron and osmosis app
    let eco = Ecosystem::default()
        .add_app(neutron.clone())
        .add_app(osmosis.clone());

    // Create a IperContract with
    // cw-multi-test ContractWrapper for default entry-points
    // IbcClosures for ibc entry-points
    let contract = IperContract::new(
        ContractWrapper::new(counter::execute, counter::instantiate, counter::query).to_contract(),
        Some(IbcClosures::new_as_ibc_contract(
            counter::ibc_channel_open,
            counter::ibc_channel_close,
            counter::ibc_channel_connect,
            counter::ibc_packet_receive,
            counter::ibc_packet_ack,
            counter::ibc_packet_timeout,
        )),
    );

    // Store code id using store_ibc_code functions of IperApp
    let code_id_neutron = neutron.borrow_mut().store_ibc_code(contract);

    let contract = IperContract::new(
        ContractWrapper::new(counter::execute, counter::instantiate, counter::query).to_contract(),
        Some(IbcClosures::new_as_ibc_contract(
            counter::ibc_channel_open,
            counter::ibc_channel_close,
            counter::ibc_channel_connect,
            counter::ibc_packet_receive,
            counter::ibc_packet_ack,
            counter::ibc_packet_timeout,
        )),
    );

    let code_id_osmosis = osmosis.borrow_mut().store_ibc_code(contract);

    // generate address for init contract
    let neutron_owner = neutron.borrow().app.api().addr_make("owner");
    let osmosis_owner = osmosis.borrow().app.api().addr_make("owner");

    // instantiate contracts using instantiate_contract from inner App of IperApp
    let neutron_addr = neutron
        .borrow_mut()
        .app
        .instantiate_contract(
            code_id_neutron,
            neutron_owner.clone(),
            &counter::InstantiateMsg {},
            &[],
            "label".to_string(),
            None,
        )
        .unwrap();

    let osmosis_addr = osmosis
        .borrow_mut()
        .app
        .instantiate_contract(
            code_id_osmosis,
            osmosis_owner,
            &counter::InstantiateMsg {},
            &[],
            "label".to_string(),
            None,
        )
        .unwrap();

    // Open a ibc channel using Ecosystem, specifing as port the two address instantiated.
    eco.open_ibc_channel(
        IbcChannelCreator::new(
            IbcPort::Contract(neutron_addr.clone()),
            IbcOrder::Unordered, // currently order has no impapact beside contract internal usage
            "version", // currently version has no impact beside contract internal usage
            "connection_id", // currently connection id has no impact contract internal usage
            "neutron",
        ),
        IbcChannelCreator::new(
            IbcPort::Contract(osmosis_addr.clone()),
            IbcOrder::Unordered,
            "version",
            "connection_id",
            "osmosis",
        ),
    )
    .unwrap();


    let msg = IbcMsg::SendPacket {
        channel_id: "channel-0".to_string(),
        // CounterPacketData::Ok means that on destination chain, the ack will be Ok
        data: to_json_binary(&CounterPacketData::Ok).unwrap(),
        timeout: IbcTimeout::with_timestamp(Timestamp::from_seconds(
            osmosis.borrow().app.block_info().time.seconds() + 1,
        )),
    };

    // Execute the contract using the ExecuteMsg variant SendPacket.
    // This testing contract basically append into the response the IbcMsg.
    // This will trigger the IbcModule, but since the source port is a contract,
    // only a packet will be emitted.
    neutron
        .borrow_mut()
        .app
        .execute_contract(
            neutron_owner,
            neutron_addr,
            &counter::ExecuteMsg::SendPacket(msg),
            &[],
        )
        .unwrap();

    // Is now possile relay the packet.
    // Using relay_all_packets from Ecosystem, all packets will be relayed.
    // When the first packet arrive on destination chain, the packet receive will be triggered.
    // If an ack packet will be emitted, the eco will relay it until any chains has no pending packet.
    eco.relay_all_packets().unwrap();

    // Query the contract Config, check if the counter_receive_dest has been increased
    // on destination chain
    let counter_receive_dest = osmosis
        .borrow()
        .app
        .wrap()
        .query_wasm_smart::<CounterConfig>(&osmosis_addr, &CounterQueryMsg::Config)
        .unwrap()
        .counter_packet_receive;

    assert_eq!(counter_receive_dest, 1);

    // Query the contract Config, check if the counter_src_ack_ok has been increased
    // on src chain
    let counter_src_ack_ok = neutron
        .borrow()
        .app
        .wrap()
        .query_wasm_smart::<CounterConfig>(&neutron_addr, &CounterQueryMsg::Config)
        .unwrap()
        .counter_packet_ack_ok;

    assert_eq!(counter_src_ack_ok, 1);
}