Ethereum Programming 14 tip author

tipper send 1 ether to author

//src/contracts/Decentragram.sol

pragma solidity ^0.5.0;

contract Decentragram {

  // Code goes here...

  string public name = "Decentragram";

  uint public imageCount = 0;

  mapping(uint => Image) public images;

  struct Image{

    uint id;

    string hash;

    string description;

    uint tipAmount;

    address payable author;

  }

  event ImageCreated(

    uint id,

    string hash,

    string description,

    uint tipAmount,

    address payable author

  );

  event ImageTipped(

    uint id,

    string hash,

    string description,

    uint tipAmount,

    address payable author

  );

  function uploadImage(string memory _imgHash, string memory _description) public {

    require(bytes(_imgHash).length > 0);

    require(bytes(_description).length > 0);

    require(msg.sender != address(0x0));

    imageCount++;

    images[imageCount] = Image(imageCount, _imgHash, _description, 0, msg.sender);

    emit ImageCreated(imageCount, _imgHash, _description, 0, msg.sender);

  }

  function tipImageOwner(uint _id) public payable{

    require(_id > 0 && _id <= imageCount);

    Image memory _image = images[_id];

    address payable _author = _image.author;

    address(_author).transfer(msg.value);

    _image.tipAmount = _image.tipAmount + msg.value;

    images[_id] = _image;

    emit ImageTipped(_id, _image.hash, _image.description, _image.tipAmount, _author);

  }

}

-------------------------

//test/test.js

const { assert } = require('chai')

const Decentragram = artifacts.require('./Decentragram.sol')

require('chai')

  .use(require('chai-as-promised'))

  .should()

contract('Decentragram', ([deployer, author, tipper]) => {

  let decentragram

  before(async () => {

    decentragram = await Decentragram.deployed()

  })

  describe('deployment', async () => {

    it('deploys successfully', async () => {

      const address = await decentragram.address

      assert.notEqual(address, 0x0)

      assert.notEqual(address, '')

      assert.notEqual(address, null)

      assert.notEqual(address, undefined)

    })

    it('has a name', async () => {

      const name = await decentragram.name()

      assert.equal(name, 'Decentragram')

    })

  })

  describe('images', async () => {

    let result, imageCount

    const hash = 'abc123'

    before(async () => {

      result = await decentragram.uploadImage(hash, 'Image description', { from: author })

      imageCount = await decentragram.imageCount()

    })

    it('create images', async () => {

      //console.log(result)

      //console.log(result.logs[0].args)

      const event = result.logs[0].args

      assert.equal(event.id.toNumber(), imageCount.toNumber(), 'id is correct')

      assert.equal(event.hash, hash, 'Hash is correct')

      assert.equal(event.description, 'Image description', 'description is correct')

      assert.equal(event.tipAmount, '0', 'tip amount is correct')

      assert.equal(event.author, author, 'author is correct')

      await decentragram.uploadImage('', 'Image description', { from: author }).should.be.rejected;

      await decentragram.uploadImage('Image hash', '', { from: author }).should.be.rejected;

      await decentragram.uploadImage('Image hash', 'Image description', { from: '' }).should.be.rejected;

    })

    it('lists images', async () => {

      const image = await decentragram.images(imageCount)

      assert.equal(image.id.toNumber(), imageCount.toNumber(), 'id is correct')

      assert.equal(image.hash, hash, 'Hash is correct')

      assert.equal(image.description, 'Image description', 'description is correct')

      assert.equal(image.tipAmount, '0', 'tip amount is correct')

      assert.equal(image.author, author, 'author is correct')

    })

    it('allows users to tip images', async () => {

      // Track the author balance before purchase

      let oldAuthorBalance

      oldAuthorBalance = await web3.eth.getBalance(author)

      oldAuthorBalance = new web3.utils.BN(oldAuthorBalance)

       //console.log(imageCount.toNumber(), author, tipper)

      result = await decentragram.tipImageOwner(imageCount, { from: tipper, value: web3.utils.toWei('1', 'Ether') })

      // SUCCESS

      const event = result.logs[0].args

      assert.equal(event.id.toNumber(), imageCount.toNumber(), 'id is correct')

      assert.equal(event.hash, hash, 'Hash is correct')

      assert.equal(event.description, 'Image description', 'description is correct')

      assert.equal(event.tipAmount, '1000000000000000000', 'tip amount is correct')

      assert.equal(event.author, author, 'author is correct')

      // Check that author received funds

      let newAuthorBalance

      newAuthorBalance = await web3.eth.getBalance(author)

      newAuthorBalance = new web3.utils.BN(newAuthorBalance)

      let tipImageOwner

      tipImageOwner = web3.utils.toWei('1', 'Ether')

      tipImageOwner = new web3.utils.BN(tipImageOwner)

      const expectedBalance = oldAuthorBalance.add(tipImageOwner)

      assert.equal(newAuthorBalance.toString(), expectedBalance.toString())

      // FAILURE: Tries to tip a image that does not exist

      await decentragram.tipImageOwner(99, { from: tipper, value: web3.utils.toWei('1', 'Ether') }).should.be.rejected;

    })

  })

})

------------------

//logs

Contract: Decentragram

    deployment

      √ deploys successfully

      √ has a name (136ms)

    images

      √ create images (1092ms)

      √ lists images (104ms)

      √ allows users to tip images (602ms)

  5 passing (3s)

reference:

https://www.youtube.com/watch?v=XLahq4qyors