mirror of
https://github.com/status-im/status-go.git
synced 2025-02-06 11:56:01 +00:00
281b304edb
This change moves our e2e tests into a separate package to make room for proper unit and integration tests. This is Phase 1 described in #371. Changes: Makefile has separate directives to run unit/integration tests and e2e tests, CI runs unit/integration tests first and then e2e tests, E2e tests are in reliability order, i.e. the least reliable tests are run in the end to be sure that nothing else is broken, Some tests are fixed or quarantined.
134 lines
3.5 KiB
Go
134 lines
3.5 KiB
Go
package looptask
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/robertkrimen/otto"
|
|
"github.com/status-im/status-go/geth/jail/internal/loop"
|
|
"github.com/status-im/status-go/geth/jail/internal/vm"
|
|
)
|
|
|
|
// IdleTask is designed to sit in a loop and keep it active, without doing any
|
|
// work.
|
|
type IdleTask struct {
|
|
ID int64
|
|
}
|
|
|
|
// NewIdleTask creates a new IdleTask object.
|
|
func NewIdleTask() *IdleTask {
|
|
return &IdleTask{}
|
|
}
|
|
|
|
// SetID sets the ID of an IdleTask.
|
|
func (i *IdleTask) SetID(ID int64) { i.ID = ID }
|
|
|
|
// GetID gets the ID of an IdleTask.
|
|
func (i IdleTask) GetID() int64 { return i.ID }
|
|
|
|
// Cancel does nothing on an IdleTask, as there's nothing to clean up.
|
|
func (i IdleTask) Cancel() {}
|
|
|
|
// Execute always returns an error for an IdleTask, as it should never
|
|
// actually be run.
|
|
func (i IdleTask) Execute(vm *vm.VM, l *loop.Loop) error {
|
|
return errors.New("Idle task should never execute")
|
|
}
|
|
|
|
// EvalTask schedules running an otto.Script. It has two channels for
|
|
// communicating the result of the execution.
|
|
type EvalTask struct {
|
|
ID int64
|
|
Script interface{}
|
|
Value chan otto.Value
|
|
Error chan error
|
|
SoftError bool
|
|
}
|
|
|
|
// NewEvalTask creates a new EvalTask for a given otto.Script, creating two
|
|
// buffered channels for the response.
|
|
func NewEvalTask(s interface{}) *EvalTask {
|
|
return &EvalTask{
|
|
Script: s,
|
|
Value: make(chan otto.Value, 1),
|
|
Error: make(chan error, 1),
|
|
}
|
|
}
|
|
|
|
// SetID sets the ID of an EvalTask.
|
|
func (e *EvalTask) SetID(ID int64) { e.ID = ID }
|
|
|
|
// GetID gets the ID of an EvalTask.
|
|
func (e EvalTask) GetID() int64 { return e.ID }
|
|
|
|
// Cancel does nothing for an EvalTask, as there's nothing to clean up.
|
|
func (e EvalTask) Cancel() {}
|
|
|
|
// Execute runs the EvalTask's otto.Script in the vm provided, pushing the
|
|
// resultant return value and error (or nil) into the associated channels.
|
|
// If the execution results in an error, it will return that error.
|
|
func (e EvalTask) Execute(vm *vm.VM, l *loop.Loop) error {
|
|
v, err := vm.Run(e.Script)
|
|
e.Value <- v
|
|
e.Error <- err
|
|
|
|
if e.SoftError {
|
|
return nil
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// CallTask schedules an otto.Value (which should be a function) to be called
|
|
// with a specific set of arguments. It has two channels for communicating the
|
|
// result of the call.
|
|
type CallTask struct {
|
|
ID int64
|
|
Function otto.Value
|
|
Args []interface{}
|
|
Value chan otto.Value
|
|
Error chan error
|
|
SoftError bool
|
|
}
|
|
|
|
// NewCallTask creates a new CallTask object for a given otto.Value (which
|
|
// should be a function) and set of arguments, creating two buffered channels
|
|
// for the response.
|
|
func NewCallTask(fn otto.Value, args ...interface{}) *CallTask {
|
|
return &CallTask{
|
|
Function: fn,
|
|
Args: args,
|
|
Value: make(chan otto.Value, 1),
|
|
Error: make(chan error, 1),
|
|
}
|
|
}
|
|
|
|
// SetID sets the ID of a CallTask.
|
|
func (c *CallTask) SetID(ID int64) { c.ID = ID }
|
|
|
|
// GetID gets the ID of a CallTask.
|
|
func (c CallTask) GetID() int64 { return c.ID }
|
|
|
|
// Cancel does nothing for a CallTask, as there's nothing to clean up.
|
|
func (c CallTask) Cancel() {}
|
|
|
|
// Execute calls the associated function (not necessarily in the given vm),
|
|
// pushing the resultant return value and error (or nil) into the associated
|
|
// channels. If the call results in an error, it will return that error.
|
|
func (c CallTask) Execute(vm *vm.VM, l *loop.Loop) error {
|
|
// vm is not used directly here, but underlying
|
|
// FunctionCall in CallTask likely does use it,
|
|
// so we must to guard it here
|
|
vm.Lock()
|
|
defer vm.Unlock()
|
|
|
|
v, err := c.Function.Call(otto.NullValue(), c.Args...)
|
|
c.Value <- v
|
|
c.Error <- err
|
|
|
|
if c.SoftError {
|
|
return nil
|
|
}
|
|
|
|
return err
|
|
}
|