How to test solidity smart contracts with ruby, RSpec and Etherium.rb

TheSmartnik — Wed, 30 Mar 2022 17:15:36 +0000

I recently tried testing solidity contracts with rspec and wanted to share results since I haven't really found anyone documenting the process.

Why?

Initially, I just wanted to test whether it's possible because I like ruby and try to stick it anywhere I can. Result turned out to be pretty good, though. I haven't found any big differences with truffle suite.

Without further ado. Naive implementation

Prerequisites

Install ganache with npm -g ganache-cli
Install solidity compiler. If you're on mac you can just use brew install solidity. If not here is a link to documentation

Our smart contract

For this tutorial. We'll use a simple hello world contract. located in contracts/greeter.sol

pragma solidity >= 0.8.11;

contract Greeter {
  string private _greeting = "Hello, World!";
  address public owner;

  constructor() {
    owner = msg.sender;
  }

  function greet() external view returns(string memory) {
    return _greeting;
  }

  function setSuperGreeting(string calldata greeting) external {
    require(msg.sender == owner, "Only owner");
    _greeting = greeting;
  }
}

As you can see it allows to read from block and write from a blockchain. Simple but good enough for our tests.

Our test

Spec setup

First, we'd need to start ganache with just

> ganache-cli

Then following etherium.rb documentation all we need to do is

Create local client

client = Ethereum::HttpClient.new('http://localhost:8545')

Create instance of our contract by providing path to a file and instance of a client

Ethereum::Contract.create(file: "greeter.sol", client: client)

Deploy contract

contract.deploy_and_wait

Our initial setup will look like this

require 'spec_helper.rb'

RSpec.describe 'Greeter' do
  let(:client) { Ethereum::HttpClient.new('http://localhost:8545') }
  let(:contract) { Ethereum::Contract.create(file: "contracts/greeter.sol", client: client) }

  before { contract.deploy_and_wait }

Asserts

First, let's test our greet method. To read from a blockchain with etherium.rb we'll need to use call like so contract.call.method_name. Our test case will look like this

it 'reads greeting' do
  expect(contract.call.greet).to eq("Hello, World!")
end

To change state of the blockchain we need to use transaction like so contract.transact_and_wait.method_name.

Here is an example of our next assertion

it 'changes message' do
  contract.transact_and_wait.set_super_greeting("Yo")

  expect(contract.call.greet).to eq("Yo")
end

Our whole spec will look like this

require 'spec_helper'

RSpec.describe 'Greeter' do
  let(:client) { Ethereum::HttpClient.new('http://localhost:8545') }
  let(:contract) { Ethereum::Contract.create(file: "contracts/greeter.sol", client: client) }

  before { contract.deploy_and_wait }

  it 'sets greeting' do
    expect(contract.call.greet).to eq("Hello, World!")
  end

  it 'changes message' do
    contract.transact_and_wait.set_super_greeting("Yo")

    expect(contract.call.greet).to eq("Yo")
  end
end

Running

> bundle exec rspec

2 examples, 0 failures

As you can see it's super easy only a couple drawbacks.

Need to start ganache by hand
No easy access to accounts

Next Iteration

To overcome the above drawbacks I've created a simple gem. It'll start ganache before the tests and provide access to accounts

Require gem

Let's add our gem to a Gemfile

gem 'rspec-eth'

and require it in spec_helper.rb with

require 'rspec/eth'

Change spec

All you need to do now to make code work is add type: :smart_contract. RSpec::Eth provides a few methods that'll make our specs even simple. We now can remove client and contract. As the gem will guess contract location by spec location.

Updated version

require 'spec_helper'

RSpec.describe 'Greeter', type: :smart_contract do
  before { contract.deploy_and_wait }

  it 'sets greeting' do
    expect(contract.call.greet).to eq("Hello, World!")
  end

  it 'changes message' do
    contract.transact_and_wait.set_super_greeting("Yo")

    expect(contract.call.greet).to eq("Yo")
  end
end

Now stop ganache if it's still running and try running specs again

> bundle exec rspec

2 examples, 0 failures

Conclusion

It's still a work in progress and the process can be improved by adding extra configuration options and contract-specific matchers. However, if you like me love using ruby whenever you can, I believe truffle isn't the only toolset you can use for testing smart contracts

Things I wish I knew before creating my first Udemy course

TheSmartnik — Mon, 07 Mar 2022 18:10:03 +0000

For a couple of years, I've wanted to create a course on Udemy. Finally, during the pandemic I was able to dedicate a few months to create one. A few months ago, I've published it and got a few hard-earned lessons I want to share. Things that would have saved me days and weeks of work. Practice makes perfect and I can't tell you how to create a great course (I mean mine is at most decent) but I'll tell you a few things that would hopefully save you time and improve the quality.

Tip 0. On mac, change resolution of your screen

Default resolution scale for mac is 16:10. Udemy video player expects 16:9. So, if you record in 16:10 you'll have only two options:

Add black borders
Udemy player will scale your video automatically and your users will get an image that will look like this

I've noticed it during the review, after I've recorded the whole thing. So, I had to scale all videos manually and chose which potions of a video to cut. Wouldn't recommend it to anyone.

Tip 1. Increase the font size in your editor and console

I prefer my font size to be dense and small but when recorded that way text is barely legible. Remember that not everyone will watch your videos full-screen and some will watch from their smartphones. Increasing the font size is a low hanging fruit for improving the quality of your videos.

Tip 2. Keep your videos under 15 min

One of the screen-casts I recorded lasted 30+ min. It was impossible to keep attention for such a long period of time. Even though I knew everything in the video it was still hard to keep up during the review. In the end I had to split videos in three to make it watchable.

Tip 3. Don't be afraid of cuts

For screen-casts, I shot both camera and screen. I thought that cutting video too often will look destructing and tried to avoid it. Instead, I tried to record an episode with one or a couple of takes max. It turned out to not be needed. Cuts are fine, on the other hand 'Uhms...', stutter and long pauses do destruct. As long as your content flows, do as many takes and cuts as needed.

Tip 4. Put important things in the center

The bottom of a video is covered by subtitles and the top is covered by UI elements. This may bite you when you show commands in a terminal, text editor, pretty much anywhere. Don't forget that and be careful.

Here you can see how UI and captions obstruct the view

Tip 5. It's ok to publish a somewhat ready course

When you publish the course and start to market it. People will buy your course but won't start to watch it until later. So, if you haven't recorded everything you planned it's still worth it to publish your course and finish a few weeks later.

That's about it. Hope you won't repeat my mistakes and your Udemy course will be a success 😉

DEV Community: TheSmartnik