Delete multiple tasks using one command

[strogiyotec]

Hey, it would be nice to have an ability to delete multiple tasks using one command. So instead of

pomo delete 1
pomo delete 2

We can use pomo delete 1 2 I already implemented it in my fork , will be glad to create pull request as soon as my first one will be approved

[kevinschoon]

Thank you @strogiyotec, happy to accept your PR, the first one is just about ready.

[strogiyotec]

@kevinschoon I will do a research how to test cli apps in golang (I have never done it before, only for Java based apps), for now the method that we are interested in (_delete) is tight to main and can't be tested without cli instance , so I would either write a mock for cli or write a test for main method but in this case I can't inject custom config . What do you think ?

[kevinschoon]

The tests for this library aren't really very robust so yeah I can see the challenge. Ideally we could create a mock driver but that might be too involved for testing some simple functionality. I would be fine accepting a PR with the change as long as we can verify it locally and then creating another PR to improve the test coverage.

In case it is useful I copied a mock SQL driver I wrote for another project below, there are probably better libraries around for this too.

// MockDriver implements a fake SQL driver for testing.
type MockDriver struct {
    t *testing.T
    // expected SQL query
    query string
    // results holds values that are
    // returned from a database query
    results struct {
        // column names for each row of values
        columns []string
        // each value for each row
        values [][]driver.Value
    }
    // args holds expected values
    args struct {
        // values we expect to be given
        // to the database
        values [][]driver.Value
    }
}

func (m MockDriver) Open(name string) (driver.Conn, error) {
    stmt := &MockStmt{
        t:      m.t,
        values: m.args.values,
        rows: &MockRows{
            t:       m.t,
            columns: m.results.columns,
            values:  m.results.values,
        },
    }
    return &MockConn{
        t:     m.t,
        stmt:  stmt,
        query: m.query,
    }, nil
}

type MockRows struct {
    t       *testing.T
    idx     int
    columns []string
    values  [][]driver.Value
}

func (m *MockRows) Next(dest []driver.Value) error {
    if m.idx == len(m.values) {
        return io.EOF
    }
    for i := 0; i < len(dest); i++ {
        dest[i] = m.values[m.idx][i]
    }
    m.idx++
    return nil
}

func (m MockRows) Close() error { return nil }

func (m MockRows) Columns() []string { return m.columns }

type MockTx struct{}

func (m MockTx) Commit() error { return nil }

func (m MockTx) Rollback() error { return nil }

type MockStmt struct {
    t      *testing.T
    rows   *MockRows
    idx    int
    values [][]driver.Value
}

func (s MockStmt) Close() error { return nil }

func (s MockStmt) NumInput() int {
    if len(s.values) > 0 {
        return len(s.values[0])
    }
    return 0
}

func (s *MockStmt) Exec(args []driver.Value) (driver.Result, error) {
    for i, arg := range args {
        if s.values[s.idx][i] != arg {
            s.t.Errorf("arg %t != %t", arg, s.values[s.idx][i])
        }
    }
    s.idx++
    return nil, nil
}

func (s MockStmt) Query(args []driver.Value) (driver.Rows, error) {
    return s.rows, nil
}

type MockConn struct {
    t     *testing.T
    query string
    stmt  *MockStmt
}

func (m MockConn) Prepare(query string) (driver.Stmt, error) {
    if query != m.query {
        m.t.Errorf("invalid query: %s != %s", query, m.query)
    }
    return m.stmt, nil
}

func (c MockConn) Close() error { return nil }
func (c MockConn) Begin() (driver.Tx, error) {
    return &MockTx{}, nil
}

var (
    _ driver.Conn = (*MockConn)(nil)
    _ driver.Rows = (*MockRows)(nil)
    _ driver.Tx   = (*MockTx)(nil)
    _ driver.Stmt = (*MockStmt)(nil)
    _ driver.Conn = (*MockConn)(nil)
)