Merge pull request src-d#246 from kamichidu/fix-leaking

refs src-d#245 add test to check connection leaking

Author: mcuadros

store.go

@@ -439,6 +439,7 @@ func (s *Store) Reload(schema Schema, record Record) error {
 	if err != nil {
 		return err
 	}
+	defer rows.Close()
 
 	rs := NewResultSet(rows, false, nil, columns...)
 	if !rs.Next() {

tests/common_test.go

@@ -22,6 +22,10 @@ type BaseTestSuite struct {
 	db      *sql.DB
 	schemas []string
 	tables  []string
+
+	// the count of opened connections.
+	// this will be set in the SetupTest function.
+	openConnectionsBeforeTest int
 }
 
 func NewBaseSuite(schemas []string, tables ...string) BaseTestSuite {
@@ -41,6 +45,11 @@ func (s *BaseTestSuite) SetupSuite() {
 		panic(fmt.Sprintf("It was unable to connect to the DB.\n%s\n", err))
 	}
 
+	// set all connections will be closed immediately.
+	// this is required to check connections are leaked or not.
+	// because database/sql keep connection in the pool by default.
+	db.SetMaxIdleConns(0)
+
 	s.db = db
 }
 
@@ -49,6 +58,9 @@ func (s *BaseTestSuite) TearDownSuite() {
 }
 
 func (s *BaseTestSuite) SetupTest() {
+	// save current open connection count for detecting that connection was leaked while a test.
+	s.openConnectionsBeforeTest = s.db.Stats().OpenConnections
+
 	if len(s.tables) == 0 {
 		return
 	}
@@ -57,6 +69,12 @@ func (s *BaseTestSuite) SetupTest() {
 }
 
 func (s *BaseTestSuite) TearDownTest() {
+	openConnections := s.db.Stats().OpenConnections
+	leakedConnections := openConnections - s.openConnectionsBeforeTest
+	if leakedConnections > 0 {
+		s.Fail(fmt.Sprintf("%d database connections were leaked", leakedConnections))
+	}
+
 	if len(s.tables) == 0 {
 		return
 	}
@@ -113,6 +131,24 @@ func (s *BaseTestSuite) resultOrError(res interface{}, err error) bool {
 	return true
 }
 
+func (s *BaseTestSuite) resultsOrError(res interface{}, err error) bool {
+	if reflect.ValueOf(res).Kind() != reflect.Slice {
+		panic("resultsOrError expects res is a slice")
+	}
+
+	if err == nil && res == nil {
+		s.Fail("FindAll should return an error or a documents, but nothing was returned")
+		return false
+	}
+
+	if err != nil && res != nil {
+		s.Fail("FindAll should return only an error or a documents, but it was returned both")
+		return false
+	}
+
+	return true
+}
+
 func envOrDefault(key string, def string) string {
 	v := os.Getenv(key)
 	if v == "" {

tests/resultset_test.go

@@ -128,6 +128,7 @@ func (s *ResulsetSuite) TestResultSetForEachError() {
 
 	s.NotPanics(func() {
 		rs := store.MustFind(NewResultSetFixtureQuery())
+		defer rs.Close()
 		err := rs.ForEach(func(*ResultSetFixture) error {
 			return fail
 		})

tests/store_test.go

@@ -89,6 +89,7 @@ func (s *StoreSuite) TestStoreMustFind() {
 	query := NewStoreFixtureQuery()
 	s.NotPanics(func() {
 		rs := store.MustFind(query)
+		defer rs.Close()
 		s.NotNil(rs)
 	})
 }
@@ -111,6 +112,64 @@ func (s *StoreSuite) TestStoreFindOneReturnValues() {
 	s.resultOrError(doc, err)
 }
 
+func (s *StoreSuite) TestStoreFindAllReturnValues() {
+	store := NewStoreWithConstructFixtureStore(s.db)
+	s.Nil(store.Insert(NewStoreWithConstructFixture("foo")))
+	s.Nil(store.Insert(NewStoreWithConstructFixture("bar")))
+
+	notFoundQuery := NewStoreWithConstructFixtureQuery()
+	notFoundQuery.Where(kallax.Eq(Schema.ResultSetFixture.ID, kallax.NewULID()))
+	docs, err := store.FindAll(notFoundQuery)
+	s.resultsOrError(docs, err)
+	s.NotPanics(func() {
+		s.Equal(0, len(docs))
+	})
+
+	docs, err = store.FindAll(NewStoreWithConstructFixtureQuery().Order(kallax.Asc(Schema.StoreWithConstructFixture.Foo)))
+	s.resultsOrError(docs, err)
+	s.NotPanics(func() {
+		s.Equal(2, len(docs))
+		s.Equal("bar", docs[0].Foo)
+		s.Equal("foo", docs[1].Foo)
+	})
+}
+
+func (s *StoreSuite) TestStoreCount() {
+	store := NewStoreWithConstructFixtureStore(s.db)
+	s.Nil(store.Insert(NewStoreWithConstructFixture("foo")))
+	s.Nil(store.Insert(NewStoreWithConstructFixture("bar")))
+
+	notFoundQuery := NewStoreWithConstructFixtureQuery()
+	notFoundQuery.Where(kallax.Eq(Schema.ResultSetFixture.ID, kallax.NewULID()))
+	count, err := store.Count(notFoundQuery)
+	s.Nil(err)
+	s.NotPanics(func() {
+		s.Equal(int64(0), count)
+	})
+
+	count, err = store.Count(NewStoreWithConstructFixtureQuery())
+	s.Nil(err)
+	s.NotPanics(func() {
+		s.Equal(int64(2), count)
+	})
+}
+
+func (s *StoreSuite) TestStoreReload() {
+	store := NewStoreWithConstructFixtureStore(s.db)
+	s.Nil(store.Insert(NewStoreWithConstructFixture("bar")))
+
+	doc, err := store.FindOne(NewStoreWithConstructFixtureQuery().FindByFoo("bar").Select(Schema.StoreWithConstructFixture.ID))
+	s.Nil(err)
+	s.NotPanics(func() {
+		s.Equal("", doc.Foo)
+	})
+	err = store.Reload(doc)
+	s.Nil(err)
+	s.NotPanics(func() {
+		s.Equal("bar", doc.Foo)
+	})
+}
+
 func (s *StoreSuite) TestStoreInsertUpdateMustFind() {
 	store := NewStoreWithConstructFixtureStore(s.db)