¿Cómo probar rápidamente una función de Solidez?

Una forma es usar Remix , el compilador en tiempo real Solidity basado en navegador y Solidity en tiempo de ejecución (anteriormente llamado browser-solidity).

1. Pega el código en Remix .
2. Envuelva la función dentro de a contractsi es necesario. (Ejemplo: contract C { ... }.)
3. Haga clic en la Contractpestaña y luego Createpara instanciar el contrato.
4. Introduzca la entrada deseada junto a la función.
   • Para bytes1... bytes32, use una cadena hexadecimal entrecomillada, ejemplo "0xabcdef"para bytes3.
   • Para bytes, use una matriz de cadenas hexadecimales , ejemplo: ["0xab", "0xcd", "0xef"].
   • Para strings, asegúrese de que estén citados.
   • Para números grandes , asegúrese de que también estén citados.
   • Para una matriz, use [], ejemplo:["hello", 42, "0xabcd"]
5. Haga clic en la función para obtener el resultado. El resultado está codificado en ABI .

Aquí hay una captura de pantalla de ejemplo :

Yo personalmente uso Dapple para escribir pruebas unitarias de Solidity. Tiene la ventaja de no requerir una capa de marco de prueba de Javascript, por lo que puede permanecer completamente en Solidity. Además, puedo usarlo para probar contratos que usan importaciones, lo que no estoy seguro de que sea posible en Solidity basado en el navegador de chriseth.

Editar: la respuesta aceptada es definitivamente una mejor opción para alguien que solo busca probar el idioma. Sigo sosteniendo que Dapple es una mejor opción para las personas como yo, a las que les gusta permanecer en la línea de comandos y que podrían querer realizar una prueba rápida para arrojar algo de luz sobre algunos de los rincones más oscuros del lenguaje. (Es posible que subestime fácilmente mi preferencia por la línea de comandos. Es un poco ridículo y se extiende a la eliminación de secuencias de comandos breves para que pueda consultar los sitios web sin tener que cambiar a un navegador).

Dicho esto, desde que respondí esta pregunta, encontré una herramienta llamada Solidity REPL que hace exactamente lo que su nombre indica: te da un Solidity REPL en la línea de comando. Para jugar con el lenguaje y hacer comprobaciones rápidas de cordura, como se podría hacer con algo como Python, recomiendo esa herramienta sobre Dapple.

Hay algunas formas de probar los contratos de Solidity. La más fácil, al menos en mi opinión, es la prueba de caja negra con Truffle . Los contratos tienden a ser relativamente pequeños y autónomos, por lo que las pruebas de caja negra parecen apropiadas aquí.

Truffle te permite escribir pruebas unitarias en Javascript usando Pudding , una extensión de web3, Mocha y Chai . Una prueba típica se ve así:

contract('MetaCoin', function(accounts) {
  it("should put 10000 MetaCoin in the first account", function(done) {
    // Get a reference to the deployed MetaCoin contract, as a JS object.
    var meta = MetaCoin.deployed();

    // Get the MetaCoin balance of the first account, and assert that it's 10000.
    meta.getBalance.call(accounts[0]).then(function(balance) {
      assert.equal(balance.valueOf(), 10000, "10000 wasn't in the first account");
    }).then(done).catch(done);
  });
});

Si solo está buscando una forma realmente rápida de probar el código y jugar en el navegador, puede usar https://ethfiddle.com/

(Divulgación completa: soy parte del equipo que lo construyó).

Encontré que la interfaz de usuario de Remix era complicada y exagerada en muchos casos, cuando la mayoría de las veces todo lo que quería hacer era 1) ejecutar y probar rápidamente un código de contrato que encontré en línea, y 2) compartir el código de contrato con otras personas sin necesitan copiarlo/pegarlo en otro lugar para poder ejecutarlo. Así que construimos una alternativa que se enfoca principalmente en la simplicidad y el intercambio.

Aquí hay una demostración rápida:

Otra opción es usar la implementación de EthereumJ. Recientemente lanzamos la versión 1.2.0 y tiene una característica agradable especialmente para estos casos. Puede consultar la muestra aquí

StandaloneBlockchain bc = new StandaloneBlockchain();

SolidityContract contract = bc.submitNewContract(
       "contract A { uint a; ... }"
);

contract.callFunction("funcName", "arg1", 2, new byte[] {1,2,3}, "arg4");
bc.createBlock()

System.out.println("Result: " + contract.callConstFunction("getResultFunc"));

La forma más sencilla de probar, depurar un poco y jugar rápidamente es, en mi humilde opinión, solidity-repl , ya que su objetivo es exactamente probar rápidamente el código de Solidity.

Creo que ese proyecto responde mejor a lo que pide el texto de su pregunta y, para ser honesto, percibo un sesgo en el que escribió la pregunta con su propia respuesta futura en mente, para que la aceptara. Por lo menos , la remixetiqueta en la misma pregunta es un indicador bastante convincente. :)

Entonces, si bien sus criterios para la "respuesta esperada" a su propia pregunta son subjetivos y no se pueden cuestionar, todavía dejo solidity-repl aquí porque otras personas probablemente vendrán aquí con una pregunta similar en mente y encontrarán que esa herramienta es una mejor ajuste.

Si solo está interesado en Solidity, Dapple, como ya se ha respondido, proporciona el mejor marco para las pruebas unitarias.

Pero si está desarrollando en .Net/Nethereum, puede hacer pruebas de integración como sigue de su contrato de solidez:

var contract = web3.Eth.GetContract(abi, receipt.ContractAddress); var test = contract.GetFunction("test4"); Assert.True(await test.CallAsync<bool(BigInteger.Parse("3457987492347979798742")));

Deberá haber implementado ya su contrato en su red de prueba. En el ejemplo anterior, ya conocemos el ABI (almacenado en una cadena) y usamos la dirección del contrato del recibo para inicializar el contrato.

También es importante probar los eventos de su contrato, por ejemplo, en el evento de transferencia ERC20 puede tener una prueba como esta:

var allTransfersFilter = await transfersEvent.CreateFilterAsync(new BlockParameter(3000)); var eventLogsAll = await transfersEvent.GetAllChanges<Transfer>(allTransfersFilter);

Assert.Equal(1, eventLogsAll.Count); var transferLog = eventLogsAll.First(); Assert.Equal(transferLog.Log.TransactionIndex.HexValue, transferReceipt.TransactionIndex.HexValue); Assert.Equal(transferLog.Log.BlockNumber.HexValue, transferReceipt.BlockNumber.HexValue); Assert.Equal(transferLog.Event.AddressTo, newAddress); Assert.Equal(transferLog.Event.Value, (ulong)1000);

Arriba estamos recuperando un evento, validando la coincidencia de transacciones y la coincidencia de atributos de eventos específicos, como la dirección donde se envía la cantidad y el valor.

En primer lugar, te sugiero que escribas tu código en un IDE como SublimeText . Luego usaría Remix para verificar que su sintaxis sea correcta y que se compile.

La gente ha mencionado Truffle , pero en mi opinión solo cambia la curva de aprendizaje. Truffle usa testrpc detrás de escena que puede configurar y usar de forma independiente. Le sugiero que se tome el tiempo para aprender todas las piezas del rompecabezas.

Dicho todo esto, testrpc solo simula la funcionalidad. Siempre sugeriría que pruebe sus contratos en un entorno 'real'. La red de prueba de Ropsten es la mejor red de prueba para esto.

EthTools.com (mi empresa creó esto) tiene una herramienta para enviar contratos a la cadena y luego interactuar con ellos. Puede verificar que su funcionalidad funciona interactuando con el contrato y verificando que obtiene las respuestas correctas. Puede hacer esto en la red de prueba de ropsten o en la red principal (como mejor le parezca).

Aquí hay algunos videos:

• Envío de un contrato a la cadena de bloques usando EthTools.com
• Interactuar con un contrato de Ethereum usando EthTools.com