// hmmmm: interface-wise, this tests that FinderNode.Add() returns an
// object whose CommandString() behaves sensibly... but in
// implementation terms, it's really a test of FuList.CommandString()
func Test_FinderNode_Add_CommandString(t *testing.T) {
finder1 := NewFinderNode("*.c", "*.h")
finder2 := NewFinderNode("doc/???.txt")
finder3 := NewFinderNode()
sum1, err := finder1.Add(finder2)
assert.Nil(t, err)
assert.Equal(t, "'*.c' '*.h' 'doc/???.txt'", sum1.CommandString())
sum2, err := finder3.Add(sum1)
assert.Nil(t, err)
assert.Equal(t, "'*.c' '*.h' 'doc/???.txt'", sum2.CommandString())
assert.False(t, sum1.Equal(sum2))
sum2b, err := finder3.Add(sum1)
assert.Nil(t, err)
assert.True(t, sum2.Equal(sum2b),
"expected equal ListNodes:\nsum2 = %T %v\nsum2b = %T %v",
sum2, sum2, sum2b, sum2b)
// This is a silly thing to do, and perhaps we should filter out
// the duplicate patterns... but I don't think so. If the user
// constructs something silly, we do something silly.
sum3, err := sum1.Add(sum2)
assert.Nil(t, err)
assert.Equal(t,
"'*.c' '*.h' 'doc/???.txt' '*.c' '*.h' 'doc/???.txt'",
sum3.CommandString())
}
func Test_FuFunction_CheckArgs_minmax(t *testing.T) {
fn := NewVariadicFunction("bar", 2, 4, nil)
val := MakeFuString("a")
args := MakeBasicArgs(nil, []FuObject{val}, nil)
err := fn.CheckArgs(args)
assert.Equal(t,
"function bar() requires at least 2 arguments (got 1)", err.Error())
// 2 args are good
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Nil(t, err)
// 3 args are good
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Nil(t, err)
// 4 args are good
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Nil(t, err)
// but 5 args is *right out*
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Equal(t,
"function bar() takes at most 4 arguments (got 5)", err.Error())
}
// full successful build, then try some incremental rebuilds
func Test_BuildState_BuildTargets_rebuild(t *testing.T) {
sig := []byte{0}
db, goal, opts := fullBuild(t, sig)
// now the rebuild, after marking all nodes unchanged
graph, executed := setupBuild(true, sig)
expect := []buildexpect{}
bstate := NewBuildState(graph, db, opts)
err := bstate.BuildTargets(goal)
assert.Nil(t, err)
assertBuild(t, graph, expect, *executed)
// again, but this time change one source file (misc.h, forcing
// rebuilds of misc.o and tool1.o -- but those two will appear
// unchanged, so we short-circuit the build and do *not* rebuild
// tool1)
graph, executed = setupBuild(true, sig)
graph.Lookup("misc.h").(*dag.StubNode).SetSignature([]byte{1})
expect = []buildexpect{
{"tool1.o", dag.BUILT},
{"misc.o", dag.BUILT},
}
bstate = NewBuildState(graph, db, opts)
err = bstate.BuildTargets(goal)
assert.Nil(t, err)
assertBuild(t, graph, expect, *executed)
}
func TestMirroring(t *testing.T) {
if !IsMirrorHostDefined() {
t.Skip("mirror host is not defined")
}
conn := ConnectToTestDb(t)
if conn == nil {
return
}
defer conn.Close()
rst, err := conn.Exec("select * from authors")
assert.Nil(t, err)
assert.NotNil(t, rst)
assert.Equal(t, 1, len(rst))
assert.Equal(t, 23, len(rst[0].Rows))
assert.Equal(t, 23, rst[0].RowsAffected)
err = failover(conn)
if err != nil {
fmt.Printf("failover error %s %s %s\n", err, conn.Error, conn.Message)
assert.Nil(t, err)
}
rst, err = conn.Exec("select * from authors")
assert.Nil(t, err)
assert.NotNil(t, rst)
assert.Equal(t, 1, len(rst))
assert.Equal(t, 23, len(rst[0].Rows))
assert.Equal(t, 23, rst[0].RowsAffected)
}
func Test_FuFunction_CheckArgs_fixed(t *testing.T) {
val := MakeFuString("a")
args := MakeBasicArgs(nil, []FuObject{}, nil)
fn := NewFixedFunction("meep", 0, nil)
err := fn.CheckArgs(args)
assert.Nil(t, err)
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Equal(t,
"function meep() takes no arguments (got 1)", err.Error())
fn = NewFixedFunction("foo", 2, nil)
args.args = args.args[:0]
err = fn.CheckArgs(args)
assert.Equal(t,
"function foo() takes exactly 2 arguments (got 0)", err.Error())
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Equal(t,
"function foo() takes exactly 2 arguments (got 1)", err.Error())
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Nil(t, err)
args.args = append(args.args, val)
err = fn.CheckArgs(args)
assert.Equal(t,
"function foo() takes exactly 2 arguments (got 3)", err.Error())
}
func TestExecute(t *testing.T) {
conn := ConnectToTestDb(t)
if conn == nil {
return
}
defer conn.Close()
rst, err := conn.Exec("select 1")
assert.Nil(t, err)
assert.NotNil(t, rst)
assert.Equal(t, 1, len(rst))
rst, err = conn.Exec("select missing")
assert.NotNil(t, err)
assert.Nil(t, rst)
rst, err = conn.Exec("print 'pero'")
assert.Nil(t, err)
assert.NotNil(t, rst)
assert.True(t, strings.Contains(conn.Message, "pero"))
assert.Equal(t, 1, len(rst))
assert.Equal(t, 0, len(rst[0].Rows))
rst, err = conn.Exec("sp_help 'authors'")
assert.Nil(t, err)
assert.NotNil(t, rst)
assert.Equal(t, 9, len(rst))
}
func TestDuplicateKeys(t *testing.T) {
worker, err := idworker.NewIdWorker(1, 1)
assert.Nil(t, err)
const MAXIDS = 100000
var ids [MAXIDS]uint64
start := time.Now()
for i := 0; i < MAXIDS; i++ {
id, err := worker.Next()
assert.Nil(t, err)
ids[i] = id
}
for i := 1; i < MAXIDS; i++ {
if ids[i-1] > ids[i] {
t.Errorf("next id %v is smaller then previous one %v", ids[i], ids[i-1])
}
}
end := time.Now()
delta := float64(end.UnixNano()-start.UnixNano()) / float64(1000*1000)
t.Logf("Execution time: %fms\n", delta)
t.Logf("Ids/sec: %f\n", float64(MAXIDS)/delta)
}
func TestPathMatchHandler(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
var called bool = false
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
called = true
return nil
}))
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := h.WillHandle(ctx1)
assert.True(t, will)
h.Handle(ctx1)
assert.True(t, called, "Method should be called")
assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).(objects.Map).Get("id"))
ctx2 := context_test.MakeTestContextWithPath("/collection")
will, _ = h.WillHandle(ctx2)
assert.False(t, will)
assert.Nil(t, ctx2.Data().Get(context.DataKeyPathParameters))
h.BreakCurrentPipeline = true
shouldStop, handleErr := h.Handle(ctx2)
assert.Nil(t, handleErr)
assert.True(t, shouldStop)
assert.True(t, called, "Handler func should get called")
}
func TestDuplicate(t *testing.T) {
total := 1000 * 1000
data := make(map[uint64]int)
sf, err := Default()
assert.Nil(t, err)
var id, pre uint64
for i := 0; i < total; i++ {
id, err = sf.Next()
assert.Nil(t, err)
if id < pre {
t.Errorf("id %v is samller than previous one %v", id, pre)
}
pre = id
count := data[id]
if count > 0 {
t.Errorf("duplicate id %v %d", id, count)
}
data[id] = count + 1
}
length := len(data)
t.Logf("map length %v", length)
if length != total {
t.Errorf("legth does not match want %v actual %d", total, length)
}
}
func Test_FileNode_Add(t *testing.T) {
node0 := NewFileNode("foo/bar")
node1 := NewFileNode("foo/baz")
obj0 := types.MakeFuString(".c")
obj1 := types.MakeStringList("a", "b")
var err error
var expect types.FuObject
var actual types.FuObject
// node + node = list of nodes
expect = types.MakeFuList(node0, node1)
actual, err = node0.Add(node1)
assert.Nil(t, err)
assert.True(t, expect.Equal(actual))
// node + string = new node
expect = NewFileNode("foo/bar.c")
actual, err = node0.Add(obj0)
assert.Nil(t, err)
assert.True(t, expect.Equal(actual))
// node + list = flattened list
expect = types.MakeFuList(
node0, types.MakeFuString("a"), types.MakeFuString("b"))
actual, err = node0.Add(obj1)
assert.Nil(t, err)
assert.True(t, expect.Equal(actual))
}
func Test_FuString_Add_strings(t *testing.T) {
s1 := MakeFuString("hello")
s2 := MakeFuString("world")
var result FuObject
var err error
// s1 + s1
result, err = s1.Add(s1)
assert.Nil(t, err)
assert.Equal(t, "hellohello", result.(FuString).value)
// s1 + s2
result, err = s1.Add(s2)
assert.Nil(t, err)
assert.Equal(t, "helloworld", result.(FuString).value)
// s1 + s2 + s1 + s2
// (equivalent to ((s1.Add(s2)).Add(s1)).Add(s2), except we have
// to worry about error handling)
result, err = s1.Add(s2)
assert.Nil(t, err)
result, err = result.Add(s1)
assert.Nil(t, err)
result, err = result.Add(s2)
assert.Nil(t, err)
assert.Equal(t, "helloworldhelloworld", result.(FuString).value)
// neither s1 nor s2 is affected by all this adding
assert.Equal(t, "hello", s1.value)
assert.Equal(t, "world", s2.value)
}
func Test_FuString_ActionExpand(t *testing.T) {
ns := makeNamespace("foo", "hello", "meep", "blorf")
input := MakeFuString("meep meep!")
output, err := input.ActionExpand(ns, nil)
assert.Nil(t, err)
assert.Equal(t, input, output)
input = MakeFuString("meep $foo blah")
output, err = input.ActionExpand(ns, nil)
assert.Nil(t, err)
assert.Equal(t, "meep hello blah", output.ValueString())
input = MakeFuString("hello ${foo} $meep")
output, err = input.ActionExpand(ns, nil)
assert.Nil(t, err)
assert.Equal(t, "hello hello blorf", output.ValueString())
ns.Assign("foo", nil)
output, err = input.ActionExpand(ns, nil)
assert.Nil(t, err)
assert.Equal(t, "hello blorf", output.ValueString())
ns.Assign("foo", MakeFuString("ping$pong"))
output, err = input.ActionExpand(ns, nil)
assert.Equal(t, "undefined variable 'pong' in string", err.Error())
assert.Nil(t, output)
}
func TestTimeSpParams(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_sp_time_sp_params", `@p1 datetime as
insert into tm (tm) values(@p1)
select @p1, 123
return 0`)
assert.Nil(t, err)
f := func(tmIn time.Time) {
var tmOut time.Time
var i int
rst, err := conn.ExecSp("test_sp_time_sp_params", tmIn)
assert.Nil(t, err)
assert.NotNil(t, rst)
rst.Next()
rst.Scan(&tmOut, &i)
assert.Equal(t, tmIn.UTC(), tmOut.UTC())
if !tmIn.Equal(tmOut) {
t.Errorf("%s != %s", tmIn, tmOut)
}
}
f(time.Unix(1404856799, 0))
f(time.Unix(1404856800, 0))
f(time.Unix(1404856801, 0))
f(time.Unix(1404856799, 0).UTC())
f(time.Unix(1404856800, 0).UTC())
f(time.Unix(1404856801, 0).UTC())
}
func TestGoSqlDbQuery(t *testing.T) {
db, err := open()
assert.Nil(t, err)
rows, err := db.Query("SELECT au_fname, au_lname name FROM authors WHERE au_lname = ? order by au_id", "Ringer")
assert.Nil(t, err)
testRingers(t, rows)
}
func TestExecSpInputParams2(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_input_params2", "@p1 nvarchar(255), @p2 varchar(255), @p3 nvarchar(255), @p4 nchar(10), @p5 varbinary(10) as select @p1, @p2, @p3, @p4, @p5; return")
assert.Nil(t, err)
want := "£¢§‹›†€"
wantp2 := "abc"
wantp3 := "šđčćžabc"
wantp4 := "šđčćžabcde"
wantp3 = "FK Ventspils v Nõmme Kalju FC"
wantp5 := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
rst, err := conn.ExecSp("test_input_params2", want, wantp2, wantp3, wantp4, wantp5)
assert.Nil(t, err)
assert.NotNil(t, rst)
if rst == nil {
return
}
assert.True(t, rst.HasResults())
var got, gotp2, gotp3, gotp4 string
var gotp5 []byte
result := rst.results[0]
result.Next()
result.Scan(&got, &gotp2, &gotp3, &gotp4, &gotp5)
assert.Equal(t, want, got)
assert.Equal(t, wantp2, gotp2)
assert.Equal(t, wantp3, gotp3)
assert.Equal(t, wantp4, gotp4)
assert.Equal(t, wantp5, gotp5)
//PrintResults(rst.Results)
}
func TestNewDateTypesParam(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_sp_with_datetimeoffset_param", `
(@p1 datetimeoffset, @p2 date, @p3 time, @p4 datetime2) as
DECLARE @datetime datetime = @p1;
SELECT @datetime, @p1, @p2, @p3, @p4
return `)
assert.Nil(t, err)
p1 := "2025-12-10 12:32:10.1237000 +01:00"
p2 := "2025-12-10"
p3 := "12:30"
p4 := "2025-12-10 12:32:10"
rst, err := conn.ExecSp("test_sp_with_datetimeoffset_param", p1, p2, p3, p4)
assert.Nil(t, err)
assert.NotNil(t, rst)
rst.Next()
var op1, op2, op3, op4 string
var dt time.Time
err = rst.Scan(&dt, &op1, &op2, &op3, &op4)
assert.Nil(t, err)
assert.Equal(t, "2025-12-10T12:32:10+01:00", dt.Format(time.RFC3339))
assert.Equal(t, "2025-12-10 12:32:10.1237000 +01:00", op1)
assert.Equal(t, "2025-12-10", op2)
assert.Equal(t, "12:30:00.0000000", op3)
assert.Equal(t, "2025-12-10 12:32:10.0000000", op4)
}
func TestMarshal(t *testing.T) {
v := &TestStruct{
IntField: 5,
String: "str",
SubStruct: SubStruct{
A: true,
Ptr: &SubStruct{
A: false,
Ints: []int{1, 2},
},
},
Slice: []*SubStruct{
&SubStruct{A: false}, &SubStruct{A: true},
},
}
scheme := safeDescribe(t, &v)
result, err := scheme.Marshal(v)
assert.Nil(t, err)
assert.Equal(t, result["int_field"], 5)
assert.Equal(t, result["string"], "str")
sub1 := result["sub_struct"].(map[string]interface{})
assert.Equal(t, sub1["a"], true)
assert.Equal(t, sub1["ints"], []int(nil))
sub2 := sub1["ptr"].(map[string]interface{})
assert.Equal(t, sub2["a"], false)
assert.Equal(t, sub2["ints"], []interface{}{1, 2})
slice := result["slice"].([]interface{})
assert.Equal(t, len(slice), 2)
assert.Equal(t, slice[0].(map[string]interface{})["a"], false)
assert.Equal(t, slice[1].(map[string]interface{})["a"], true)
v2 := &MapStruct{
Map: map[string]*SubStruct{
"a": &SubStruct{},
"b": &SubStruct{A: true},
},
}
scheme2 := safeDescribe(t, &v2)
result, err = scheme2.Marshal(v2)
assert.Nil(t, err)
m := result["map"].(map[string]interface{})
assert.Equal(t, len(m), 2)
v3 := &OmitEmptyStruct{A: 5}
scheme3 := safeDescribe(t, &v3)
result, err = scheme3.Marshal(v3)
assert.Nil(t, err)
assert.Equal(t, len(result), 1)
assert.Equal(t, result["a"], 5)
}
func Test_FileNode_Expand(t *testing.T) {
ns := types.NewValueMap()
node := NewFileNode("foobar")
xnode, err := node.ActionExpand(ns, nil)
assert.Nil(t, err)
assert.Equal(t, node, xnode)
err = node.NodeExpand(ns)
assert.Nil(t, err)
assert.Equal(t, "foobar", node.Name())
// test that ActionExpand() follows variable references
node = NewFileNode("$foo$bar")
xnode, err = node.ActionExpand(ns, nil)
assert.Equal(t, "undefined variable 'foo' in string", err.Error())
// make it so "$foo$bar" expands to "$foo", and ensure that
// expansion stops there
// XXX argh: currently this expands to "'$'foo": hmmmmm
// ns.Assign("foo", types.MakeFuString("$"))
// ns.Assign("bar", types.MakeFuString("foo"))
// xnode, err = node.ActionExpand(ns, nil)
// assert.Nil(t, err)
// assert.Equal(t, "$foo", xnode.String())
}
func Test_mkdir(t *testing.T) {
cleanup := testutils.Chtemp()
defer cleanup()
// mkdir() happily accepts an empty argument list, to allow for
// cases where a user-defined list becomes the arg list, and it
// just happens to be empty
pargs := []types.FuObject{}
args := RuntimeArgs{
BasicArgs: types.MakeBasicArgs(nil, pargs, nil),
}
result, errs := fn_mkdir(args)
assert.Nil(t, result)
assert.Equal(t, 0, len(errs))
assert.Equal(t, []string{}, dirContents("."))
// easiest case: create a single dir
pargs = types.MakeStringList("foo").List()
args.SetArgs(pargs)
result, errs = fn_mkdir(args)
assert.Nil(t, result)
assert.Equal(t, 0, len(errs))
assert.Equal(t, []string{"foo"}, dirContents("."))
assert.True(t, isDir("foo"))
// create multiple dirs, including "foo" which already exists
pargs = types.MakeStringList("meep/meep/meep", "foo", "meep/beep").List()
args.SetArgs(pargs)
result, errs = fn_mkdir(args)
assert.Nil(t, result)
assert.Equal(t, 0, len(errs))
assert.Equal(t, []string{"foo", "meep"}, dirContents("."))
assert.True(t, isDir("foo"))
assert.True(t, isDir("meep/meep"))
assert.True(t, isDir("meep/meep/meep"))
assert.True(t, isDir("meep/beep"))
// now with an error in the middle of the list (*but* we still
// create the other requested dirs!)
testutils.TouchFiles("meep/zap")
pargs = types.MakeStringList("meep/bap", "meep/zap/zip", "foo/bar").List()
args.SetArgs(pargs)
result, errs = fn_mkdir(args)
assert.Nil(t, result)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "mkdir meep/zap: not a directory", errs[0].Error())
assert.True(t, isDir("meep/bap"))
assert.True(t, isDir("foo/bar"))
// finally, with multiple errors
pargs = append(pargs, types.MakeFuString("meep/zap/blop"))
args.SetArgs(pargs)
result, errs = fn_mkdir(args)
assert.Nil(t, result)
assert.Equal(t, 2, len(errs))
assert.Equal(t, "mkdir meep/zap: not a directory", errs[0].Error())
assert.Equal(t, "mkdir meep/zap: not a directory", errs[1].Error())
}
func TestExecSpInputParams(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_input_params", "@p1 int = 0, @p2 int, @p3 as varchar(10), @p4 datetime, @p5 varbinary(10) = null as select @p1 = @p1 + @p2; return @p1")
assert.Nil(t, err)
rst, err := conn.ExecSp("test_input_params", 123, 234, "pero", time.Now(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0})
assert.Nil(t, err)
assert.False(t, rst.HasResults())
assert.Equal(t, 357, rst.Status())
}
func TestExecSpResults(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_results", " as select 1 one; select 2 two; return 456")
assert.Nil(t, err)
rst, err := conn.ExecSp("test_results")
assert.Nil(t, err)
assert.Equal(t, 2, len(rst.results))
assert.Equal(t, 456, rst.Status())
}
func TestExecSpReturnValue(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_return_value", " as return 123")
assert.Nil(t, err)
rst, err := conn.ExecSp("test_return_value")
assert.Nil(t, err)
assert.False(t, rst.HasResults())
assert.Equal(t, 123, rst.Status())
}
func Test_prepareCall(t *testing.T) {
// this is never going to be called, so it's OK that it's nil
var fn_dummy func(argsource types.ArgSource) (types.FuObject, []error)
var dummy1, dummy2 types.FuCallable
dummy1 = types.NewFixedFunction("dummy1", 0, fn_dummy)
dummy2 = types.NewFixedFunction("dummy1", 1, fn_dummy)
rt := minimalRuntime()
ns := rt.Namespace()
ns.Assign("dummy1", dummy1)
ns.Assign("dummy2", dummy2)
ns.Assign("x", types.MakeFuString("whee!"))
noargs := []dsl.ASTExpression{}
onearg := []dsl.ASTExpression{dsl.NewASTString("\"meep\"")}
var astcall *dsl.ASTFunctionCall
var callable types.FuCallable
var args RuntimeArgs
var errs []error
// correct (no args) call to dummy1()
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("dummy1"), noargs)
callable, args, errs = rt.prepareCall(astcall)
assert.Equal(t, 0, len(errs))
assert.Equal(t, dummy1, callable)
assert.Equal(t, []types.FuObject{}, args.Args())
// and to dummy2()
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("dummy2"), onearg)
callable, args, errs = rt.prepareCall(astcall)
assert.Equal(t, 0, len(errs))
assert.Equal(t, dummy2, callable)
assert.Equal(t, []types.FuObject{types.MakeFuString("meep")}, args.Args())
// attempt to call dummy2() incorrectly (1 arg, but it's an undefined name)
astcall = dsl.NewASTFunctionCall(
dsl.NewASTName("dummy2"),
[]dsl.ASTExpression{dsl.NewASTName("bogus")})
callable, _, errs = rt.prepareCall(astcall)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "name not defined: 'bogus'", errs[0].Error())
// attempt to call non-existent function
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("bogus"), noargs)
callable, _, errs = rt.prepareCall(astcall)
assert.Nil(t, callable)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "name not defined: 'bogus'", errs[0].Error())
// attempt to call something that is not a function
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("x"), noargs)
callable, _, errs = rt.prepareCall(astcall)
assert.Nil(t, callable)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "not a function or method: 'x'", errs[0].Error())
}
func TestGoSqlDbQueryRow(t *testing.T) {
db, err := open()
assert.Nil(t, err)
row := db.QueryRow("SELECT au_fname, au_lname name FROM authors WHERE au_id = ?", "172-32-1176")
var firstName, lastName string
err = row.Scan(&firstName, &lastName)
assert.Nil(t, err)
assert.Equal(t, firstName, "Johnson")
assert.Equal(t, lastName, "White")
}
func testRingers(t *testing.T, rows *sql.Rows) {
var firstName, lastName string
rows.Next()
err := rows.Scan(&firstName, &lastName)
assert.Nil(t, err)
assert.Equal(t, firstName, "Anne")
rows.Next()
err = rows.Scan(&firstName, &lastName)
assert.Nil(t, err)
assert.Equal(t, firstName, "Albert")
}
func TestGoSqlPrepareQuery(t *testing.T) {
//t.Skip()
db, err := open()
assert.Nil(t, err)
assert.NotNil(t, db)
stmt, err := db.Prepare("SELECT au_fname, au_lname name FROM authors WHERE au_lname = ? order by au_id")
assert.Nil(t, err)
rows, err := stmt.Query("Ringer")
assert.Nil(t, err)
testRingers(t, rows)
}
func Test_FuFunction_CheckArgs_unlimited(t *testing.T) {
fn := NewVariadicFunction("println", 0, -1, nil)
val := MakeFuString("a")
args := MakeBasicArgs(nil, []FuObject{val}, nil)
err := fn.CheckArgs(args)
assert.Nil(t, err)
args.args = append(args.args, val, val, val, val)
err = fn.CheckArgs(args)
assert.Nil(t, err)
}
func Test_println(t *testing.T) {
cleanup1 := testutils.Chtemp()
defer cleanup1()
rfile, err := os.Create("stdout")
if err != nil {
panic(err)
}
// save a copy of stdout in another fd
stdout_fd := int(os.Stdout.Fd())
save_stdout, err := syscall.Dup(stdout_fd)
if err != nil {
panic(err)
}
// redirect stdout to rfile
err = syscall.Dup2(int(rfile.Fd()), stdout_fd)
if err != nil {
panic(err)
}
cleanup2 := func() {
rfile.Close()
err = syscall.Dup2(save_stdout, stdout_fd)
if err != nil {
panic(err)
}
syscall.Close(save_stdout)
}
defer cleanup2()
args := RuntimeArgs{
BasicArgs: types.MakeBasicArgs(nil, []types.FuObject{}, nil),
}
result, errs := fn_println(args)
assert.Nil(t, result)
assert.Equal(t, 0, len(errs))
data, err := ioutil.ReadFile("stdout")
assert.Nil(t, err)
assert.Equal(t, "\n", string(data))
rfile.Truncate(0)
rfile.Seek(0, 0)
args.SetArgs(types.MakeStringList("hello", "world").List())
fn_println(args)
data, err = ioutil.ReadFile("stdout")
assert.Nil(t, err)
assert.Equal(t, "hello world\n", string(data))
rfile.Truncate(0)
rfile.Seek(0, 0)
}
func Test_translateGlob(t *testing.T) {
tests := []struct {
glob string
re string
}{
{"", "$"},
{"foo", "foo$"},
{"foo/bar", "foo/bar$"},
{"foo?bar", "foo[^/]bar$"},
{"*.c", "[^/]*\\.c$"},
{"foo[abc]", "foo[abc]$"},
{"foo[a-m]*.bop", "foo[a-m][^/]*\\.bop$"},
{"foo/**/bar", "foo/.*/bar$"},
{"**/foo/bar", ".*/foo/bar$"},
{"foo/bar/**", "foo/bar/.*$"},
{"foo/**/bar/**/baz/**", "foo/.*/bar/.*/baz/.*$"},
}
for _, pair := range tests {
actual, err := translateGlob(pair.glob)
assert.Nil(t, err)
assert.Equal(t, pair.re, actual)
}
// make sure one of those regexps actually works as intended
pat, err := translateGlob("foo[a-m]/p*g/*.[ch]")
assert.Nil(t, err)
re, err := regexp.Compile("^" + pat)
assert.Nil(t, err)
match := []string{
"foom/pong/bop.c",
"foog/pig/abc.c",
"foog/pig/a.c.-af#@0(.h",
"foob/pg/a_b&.c",
}
for _, fn := range match {
assert.Equal(t, fn, re.FindString(fn))
}
nomatch := []string{
"foo/pong/bop.c",
"foom/pongx/bop.c",
"foom/pong/bop.cpp",
"foom/pong/bop.c/x",
"fooz/pong/bop.c",
"foom/pg/bop.d",
}
for _, fn := range nomatch {
assert.Equal(t, "", re.FindString(fn))
}
}
func TestStoredProcedureNotExists(t *testing.T) {
conn := ConnectToTestDb(t)
err := createProcedure(conn, "test_sp_not_exists", `as return`)
assert.Nil(t, err)
rst, err := conn.ExecSp("test_sp_not_exists")
assert.Nil(t, err)
assert.NotNil(t, rst)
_, err = conn.Exec("drop procedure test_sp_not_exists")
assert.Nil(t, err)
rst, err = conn.ExecSp("test_sp_not_exists")
assert.NotNil(t, err)
assert.Nil(t, rst)
}