lbryio/chainquery

View on GitHub
e2e/e2e.go

Summary

Maintainability
A
0 mins
Test Coverage
package e2e

import (
    "database/sql"
    "os"
    "time"

    "github.com/lbryio/chainquery/model"
    "github.com/volatiletech/sqlboiler/v4/queries/qm"

    "github.com/lbryio/lbry.go/v2/extras/errors"

    "github.com/lbryio/chainquery/daemon"
    "github.com/lbryio/chainquery/daemon/jobs"
    "github.com/lbryio/chainquery/lbrycrd"

    "github.com/sirupsen/logrus"
)

const claimAmount = 0.5

// StartE2ETesting launches the test suite
func StartE2ETesting() {
    go daemon.DoYourThing()
    logrus.Info("Started E2E tests")
    testBasicClaimCreation()
    increment(10)
    createChannelWithClaims()
    increment(1)
    jobs.ClaimTrieSync()
    jobs.CertificateSync()
    exitOnErr(jobs.SyncClaimCntInChannel())
    time.Sleep(2 * time.Second)
    exitOnErr(checkCertValid([]string{"claim1", "claim2", "claim3"}))
    testClaimCount()
    testImageMetadata()
    testVideoMetaData()
    daemon.ShutdownDaemon()
}

func createChannelWithClaims() {

    channel, key, err := createChannel("@MyChannel")
    if err != nil {
        exit(1, err)
    }

    logrus.Info(lbrycrd.GenerateBlocks(1))

    claimResponse, err := lbrycrd.GetClaimsForName("@MyChannel")
    if err != nil {
        exit(1, err)
    }

    claim1, err := newStreamClaim("title1", "description2")
    if err != nil {
        exit(1, err)
    }

    claim2, err := newStreamClaim("title1", "description2")
    if err != nil {
        exit(1, err)
    }
    claim3, err := newStreamClaim("title1", "description2")
    if err != nil {
        exit(1, err)
    }

    rawTx, err := getEmptyTx(claimAmount * 3)
    if err != nil {
        exit(1, err)
    }

    exitOnErr(signClaim(rawTx, *key, claim1, channel, claimResponse.Claims[0].ClaimID))
    exitOnErr(signClaim(rawTx, *key, claim2, channel, claimResponse.Claims[0].ClaimID))
    exitOnErr(signClaim(rawTx, *key, claim3, channel, claimResponse.Claims[0].ClaimID))

    exitOnErr(addClaimToTx(rawTx, claim1, "claim1"))
    exitOnErr(addClaimToTx(rawTx, claim2, "claim2"))
    exitOnErr(addClaimToTx(rawTx, claim3, "claim3"))

    chainHash, err := signTxAndSend(rawTx)
    if err != nil {
        exit(1, err)
    }

    logrus.Info("Tx:", chainHash.String())

}

func exit(code int, err error) {
    logrus.Error(err, "\n", errors.FullTrace(err))
    os.Exit(code)
}

func exitOnErr(err error) {
    if err != nil {
        exit(1, errors.Err(err))
    }
}

func increment(blocks ...int) {
    if len(blocks) > 0 {
        hash, err := lbrycrd.GenerateBlocks(int64(blocks[0]))
        exitOnErr(err)
        _, err = checkForBlock(hash[len(hash)-1])
        exitOnErr(err)
    }
}

func test(run func(), check func() error, blocks uint) {
    height, err := lbrycrd.GetBlockCount()
    exitOnErr(errors.Err(err))
    run()
    increment(int(blocks + 1))
    //wait x blocks
    reached := make(chan bool)
    ticker := time.NewTicker(100 * time.Millisecond)
    go func() {
        for range ticker.C {
            block, err := model.Blocks(qm.OrderBy("height DESC"), qm.Limit(1)).OneG()
            exitOnErr(errors.Err(err))
            if (block.Height - *height) >= uint64(blocks+1) {
                logrus.Infof("Block %d reached from %d", block.Height, *height)
                reached <- true
                ticker.Stop()
            }
        }
    }()
    <-reached
    exitOnErr(check())
}

func verify(test bool, message string) {
    var err error
    if !test {
        err = errors.Err(message)
    }
    exitOnErr(err)
}

func checkForBlock(blockHash string) (bool, error) {
    start := time.Now()
    ticker := time.NewTicker(500 * time.Millisecond)
    for t := range ticker.C {
        tx, err := model.Blocks(model.BlockWhere.Hash.EQ(blockHash)).OneG()
        if err != nil && err != sql.ErrNoRows {
            return false, errors.Err(err)
        }
        if tx != nil {
            ticker.Stop()
            return true, nil
        }
        if start.Add(5 * time.Minute).Before(t) {
            return false, nil
        }
    }
    return false, nil
}

func testClaimCount() {
    channel, err := model.Claims(model.ClaimWhere.Name.EQ("@MyChannel")).OneG()
    exitOnErr(err)
    if channel == nil {
        exit(1, errors.Err("Could not find channel @MyChannel"))
    }
    if channel.ClaimCount != 3 {
        exit(1, errors.Err("@MyChannel only has %d claims and should have 3", channel.ClaimCount))
    }
}