conveyTest successfully passes from "go test", but not in goconvey web browser

main.go

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"path"
	"strings"
)

var (
	exitCmd     = os.Exit
	exitOnError = flag.ExitOnError
	logFatalln  = log.Fatalln
	stdErr      = os.Stderr
	version     = "0.01"
)

// opts struct for command line options and setting initial variables
type opts struct {
	*flag.FlagSet
	help    *bool
	ip      *string
	port    *string
	version *bool
}

func cleanArgs(args []string) []string {
	var rArgs []string
NEXT:
	for _, a := range args {
		switch {
		case strings.HasPrefix(a, "-test"):
			continue NEXT
		case strings.HasPrefix(a, "-convey"):
			continue NEXT
		default:
			rArgs = append(rArgs, a)
		}
	}
	return rArgs
}

func (o *opts) setArgs() {
	if err := o.Parse(cleanArgs((os.Args[1:]))); err != nil {
		o.Usage()
	}

	switch {
	case *o.help:
		o.Usage()
		exitCmd(0)

	case *o.version:
		fmt.Printf(" Version:\t\t%s\n", version)
		exitCmd(0)
	}
}

// getOpts returns command line flags and values or displays help
func getOpts() *opts {
	flags := flag.NewFlagSet("pixelserv", exitOnError)
	flags.Usage = func() {
		fmt.Fprintf(stdErr, "Usage: %v [options]\n\n", path.Base(os.Args[0]))
		flags.PrintDefaults()
	}

	return &opts{
		help:    flags.Bool("h", false, "Display help"),
		ip:      flags.String("ip", "127.0.0.1", "IP address for "+path.Base(os.Args[0])+" to bind to"),
		port:    flags.String("port", "80", "Port number for "+path.Base(os.Args[0])+" to listen on"),
		FlagSet: flags,
		version: flags.Bool("version", false, "Display version"),
	}
}

func main() {
	o := getOpts()
	o.setArgs()
}

main_test.go

package main

import (
	"bytes"
	"flag"
	"fmt"
	"os"
	"path"
	"testing"

	. "github.com/smartystreets/goconvey/convey"
)

func TestOptsSetArgs(t *testing.T) {
	tTrue := true
	tFalse := false
	tStr := func(s string) *string {
		return &s
	}

	tests := []struct {
		// Test description.
		name string
		// Receiver fields.
		rFlagSet *flag.FlagSet
		rh       *bool
		rip      *string
		rport    *string
		rversion *bool
		// Parameters.
		fn func(int)
	}{
		{
			name:     "-h called",
			rFlagSet: &flag.FlagSet{},
			rh:       &tTrue,
			fn:       func(int) { return },
			rip:      tStr(""),
			rport:    tStr(""),
			rversion: &tFalse,
		},
		{
			name:     "-version called",
			rFlagSet: &flag.FlagSet{},
			rh:       &tFalse,
			fn:       func(int) { return },
			rip:      tStr(""),
			rport:    tStr(""),
			rversion: &tTrue,
		},
		{
			name:     "-ip and -port set",
			rFlagSet: &flag.FlagSet{},
			rh:       &tFalse,
			fn:       func(int) { return },
			rip:      tStr("192.168.168.1"),
			rport:    tStr("8080"),
			rversion: &tFalse,
		},
	}

	for _, tt := range tests {
		tt.rFlagSet.Usage = func() {
			fmt.Fprintf(os.Stderr, "Usage: %v [options]\n\n", path.Base(os.Args[0]))
			tt.rFlagSet.PrintDefaults()
		}
		o := &opts{
			FlagSet: tt.rFlagSet,
			help:    tt.rh,
			ip:      tt.rip,
			port:    tt.rport,
			version: tt.rversion,
		}

		exitCmd = func(int) { return }
		o.setArgs()
		Convey("Running main.setArgs() test", t, func() {
			So(*o.help, ShouldEqual, *tt.rh)
			So(*o.ip, ShouldEqual, *tt.rip)
			So(*o.port, ShouldEqual, *tt.rport)
			So(*o.version, ShouldEqual, *tt.rversion)
		})
	}
}

func TestGetOpts(t *testing.T) {
	Convey("Running main.getOpts() test", t, func() {
		act := new(bytes.Buffer)
		prog := path.Base(os.Args[0])
		want := `  -h	Display help
  -ip string
    	IP address for ` + prog + ` to bind to (default "127.0.0.1")
  -port string
    	Port number for ` + prog + ` to listen on (default "80")
  -version
    	Display version
`
		exitCmd = func(int) { return }

		os.Args = append(os.Args, "-h")
		o := getOpts()

		o.Init("pixelserv", flag.ContinueOnError)

		o.SetOutput(act)
		o.setArgs()

		So(fmt.Sprint(act), ShouldEqual, want)
	})
}