Add session_test.go

batch_test.go

@@ -6,72 +6,18 @@ import (
 )
 
 func TestBatchMock(t *testing.T) {
- var m = &BatchMock{}
+ var m, e = &BatchMock{}, fmt.Errorf("e")
 
- for _, test := range []error{nil, fmt.Errorf("a")} {
- t.Log("Test:", test)
- m.Reset()
- m.When("Execute").Return(test)
-
- if v := m.Execute(); v != test {
- t.Errorf("Actual %v, expected %v", v, test)
- }
- }
-
- for _, test := range []struct {
- s []interface{}
- b bool
- i Iterator
- e error
- }{
- {nil, false, (*iterator)(nil), nil},
- {[]interface{}{1}, true, iterator{}, fmt.Errorf("a")},
- } {
- t.Log("Test:", test)
- m.Reset()
- m.When("ExecuteTransaction", test.s).Return(test.b, test.i, test.e)
-
- if b, i, e := m.ExecuteTransaction(test.s...); b != test.b {
- t.Errorf("Actual %v, expected %v", b, test.b)
- } else if i != test.i {
- t.Errorf("Actual %v, expected %v", i, test.i)
- } else if e != test.e {
- t.Errorf("Actual %v, expected %v", e, test.e)
- }
- }
-
- for _, test := range []struct {
- m map[string]interface{}
- b bool
- i Iterator
- e error
- }{
- {nil, false, (*iterator)(nil), nil},
- {map[string]interface{}{"a": "b"}, true, iterator{}, fmt.Errorf("c")},
- } {
- t.Log("Test:", test)
- m.Reset()
- m.When("ExecuteTransactionMap", test.m).Return(test.b, test.i, test.e)
-
- if b, i, e := m.ExecuteTransactionMap(test.m); b != test.b {
- t.Errorf("Actual %v, expected %v", b, test.b)
- } else if i != test.i {
- t.Errorf("Actual %v, expected %v", i, test.i)
- } else if e != test.e {
- t.Errorf("Actual %v, expected %v", e, test.e)
- }
- }
-
- for _, test := range []struct {
- s string
- i []interface{}
+ testMock(t, m, &m.Mock, []struct {
+ method string
+ arguments []interface{}
+ results []interface{}
  }{
- {"", nil},
- {"a", []interface{}{1}},
- } {
- t.Log("Test:", test)
- m.Reset()
- m.When("Query", test.s, test.i).Return()
- m.Query(test.s, test.i...)
- }
+ {"Execute", nil, []interface{}{nil}},
+ {"Execute", nil, []interface{}{e}},
+ {"ExecuteTransaction", []interface{}{[]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
+ {"ExecuteTransaction", []interface{}{[]interface{}{1}}, []interface{}{true, &iterator{}, e}},
+ {"ExecuteTransactionMap", []interface{}{map[string]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
+ {"ExecuteTransactionMap", []interface{}{map[string]interface{}{"a": 1}}, []interface{}{true, &iterator{}, e}},
+ })
 }

iterator_test.go

@@ -6,47 +6,18 @@ import (
 )
 
 func TestIteratorMock(t *testing.T) {
- var m = &IteratorMock{}
+ var m, e = &IteratorMock{}, fmt.Errorf("e")
 
- for _, test := range []error{nil, fmt.Errorf("a")} {
- t.Log("Test:", test)
- m.Reset()
- m.When("Close").Return(test)
-
- if v := m.Close(); v != test {
- t.Errorf("Actual %v, expected %v", v, test)
- }
- }
-
- for _, test := range []struct {
- in []interface{}
- out bool
- }{
- {nil, false},
- {[]interface{}{1}, true},
- } {
- t.Log("Test:", test)
- m.Reset()
- m.When("Scan", test.in).Return(test.out)
-
- if v := m.Scan(test.in...); v != test.out {
- t.Errorf("Actual %v, expected %v", v, test.out)
- }
- }
-
- for _, test := range []struct {
- in map[string]interface{}
- out bool
+ testMock(t, m, &m.Mock, []struct {
+ method string
+ arguments []interface{}
+ results []interface{}
  }{
- {nil, false},
- {map[string]interface{}{"a": "b"}, true},
- } {
- t.Log("Test:", test)
- m.Reset()
- m.When("ScanMap", test.in).Return(test.out)
-
- if v := m.ScanMap(test.in); v != test.out {
- t.Errorf("Actual %v, expected %v", v, test.out)
- }
- }
+ {"Close", nil, []interface{}{nil}},
+ {"Close", nil, []interface{}{e}},
+ {"Scan", []interface{}{[]interface{}(nil)}, []interface{}{false}},
+ {"Scan", []interface{}{[]interface{}{1}}, []interface{}{true}},
+ {"ScanMap", []interface{}{map[string]interface{}(nil)}, []interface{}{false}},
+ {"ScanMap", []interface{}{map[string]interface{}{"a": 1}}, []interface{}{true}},
+ })
 }

session.go

@@ -95,7 +95,7 @@ func (m SessionMock) QueryScanMap(statement string, arguments []interface{}, res
 
 // QueryScanMapTransaction implements Session.
 func (m SessionMock) QueryScanMapTransaction(statement string, arguments []interface{}, results map[string]interface{}) (bool, error) {
- var r = m.Called(statement, arguments)
+ var r = m.Called(statement, arguments, results)
 
  return r.Bool(0), r.Error(1)
 }

session_test.go

@@ -0,0 +1,78 @@
+package gockle
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+
+ "github.com/gocql/gocql"
+ "github.com/maraino/go-mock"
+)
+
+func TestSessionMock(t *testing.T) {
+ var m, e = &SessionMock{}, fmt.Errorf("e")
+
+ testMock(t, m, &m.Mock, []struct {
+ method string
+ arguments []interface{}
+ results []interface{}
+ }{
+ {"Close", nil, nil},
+ {"Columns", []interface{}{"", ""}, []interface{}{map[string]gocql.TypeInfo(nil), nil}},
+ {"Columns", []interface{}{"a", "b"}, []interface{}{map[string]gocql.TypeInfo{"c": gocql.NativeType{}}, e}},
+ {"QueryBatch", []interface{}{BatchKind(0)}, []interface{}{(*batch)(nil)}},
+ {"QueryBatch", []interface{}{BatchKind(1)}, []interface{}{&batch{}}},
+ {"QueryExecute", []interface{}{"", []interface{}(nil)}, []interface{}{nil}},
+ {"QueryExecute", []interface{}{"a", []interface{}{1}}, []interface{}{e}},
+ {"QueryIterate", []interface{}{"", []interface{}(nil)}, []interface{}{(*iterator)(nil)}},
+ {"QueryIterate", []interface{}{"a", []interface{}{1}}, []interface{}{iterator{}}},
+ {"QueryScan", []interface{}{"", []interface{}(nil), []interface{}(nil)}, []interface{}{nil}},
+ {"QueryScan", []interface{}{"a", []interface{}{1}, []interface{}{1}}, []interface{}{e}},
+ {"QueryScanMap", []interface{}{"", []interface{}(nil), map[string]interface{}(nil)}, []interface{}{nil}},
+ {"QueryScanMap", []interface{}{"a", []interface{}{1}, map[string]interface{}{"b": 2}}, []interface{}{e}},
+ {"QueryScanMapTransaction", []interface{}{"", []interface{}(nil), map[string]interface{}(nil)}, []interface{}{false, nil}},
+ {"QueryScanMapTransaction", []interface{}{"a", []interface{}{1}, map[string]interface{}{"b": 2}}, []interface{}{true, e}},
+ {"QuerySliceMap", []interface{}{"", []interface{}(nil)}, []interface{}{[]map[string]interface{}(nil), nil}},
+ {"QuerySliceMap", []interface{}{"a", []interface{}{1}}, []interface{}{[]map[string]interface{}{{"b": 2}}, e}},
+ {"Tables", []interface{}{""}, []interface{}{[]string(nil), nil}},
+ {"Tables", []interface{}{"a"}, []interface{}{[]string{"b"}, e}},
+ })
+}
+
+func testMock(t *testing.T, i interface{}, m *mock.Mock, tests []struct {
+ method string
+ arguments []interface{}
+ results []interface{}
+}) {
+ var v = reflect.ValueOf(i)
+
+ for _, test := range tests {
+ t.Log("Test:", test)
+ m.Reset()
+ m.When(test.method, test.arguments...).Return(test.results...)
+
+ var vs []reflect.Value
+
+ for _, a := range test.arguments {
+ vs = append(vs, reflect.ValueOf(a))
+ }
+
+ var method = v.MethodByName(test.method)
+
+ if method.Type().IsVariadic() {
+ vs = method.CallSlice(vs)
+ } else {
+ vs = method.Call(vs)
+ }
+
+ var is []interface{}
+
+ for _, v := range vs {
+ is = append(is, v.Interface())
+ }
+
+ if !reflect.DeepEqual(is, test.results) {
+ t.Errorf("Actual %v, expected %v", is, test.results)
+ }
+ }
+}