sql/git: improve tests and fixes #68. (#76)

smola · ajnavarro · commit 92c144908ad2 · 2016-12-02T15:43:17.000+01:00
* sql: add utility functions Schema.CheckRow, RowIterToRows, NodetoRows. * git: homogeneize git tests for different tables, check schema conformance. * git: fix tree entries table. fixes #68. * mem: simplify tests. * sql: change Timestamp type to TimestampWithTimezone. * sql: use time.Time internally for TimestampWithTimezone. * git: adapt git tables for timestamp changes.
diff --git a/git/blobs_test.go b/git/blobs_test.go
@@ -3,38 +3,41 @@ package git
 import (
 	"testing"
 
+	"github.com/gitql/gitql/sql"
+
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/fixtures"
 )
 
-func TestBlobsTable(t *testing.T) {
+func TestBlobsTable_Name(t *testing.T) {
 	assert := assert.New(t)
 
 	f := fixtures.Basic().One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
-	assert.Nil(err)
+	table := getTable(assert, f, blobsTableName)
+	assert.Equal(blobsTableName, table.Name())
+}
 
-	db := NewDatabase("foo", r)
-	assert.NotNil(db)
+func TestBlobsTable_Children(t *testing.T) {
+	assert := assert.New(t)
 
-	tables := db.Tables()
-	table, ok := tables[blobsTableName]
-	assert.True(ok)
-	assert.NotNil(table)
-	assert.Equal(blobsTableName, table.Name())
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, blobsTableName)
 	assert.Equal(0, len(table.Children()))
+}
 
-	iter, err := table.RowIter()
-	assert.Nil(err)
-	assert.NotNil(iter)
+func TestBlobsTable_RowIter(t *testing.T) {
+	assert := assert.New(t)
+
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, blobsTableName)
 
-	row, err := iter.Next()
+	rows, err := sql.NodeToRows(table)
 	assert.Nil(err)
-	assert.NotNil(row)
+	assert.Len(rows, 10)
 
-	fields := row.Fields()
-	assert.NotNil(fields)
-	assert.IsType("", fields[0])
-	assert.IsType(int64(0), fields[1])
+	schema := table.Schema()
+	for idx, row := range rows {
+		err := schema.CheckRow(row)
+		assert.Nil(err, "row %d doesn't conform to schema", idx)
+	}
 }
diff --git a/git/commits.go b/git/commits.go
@@ -27,10 +27,10 @@ func (commitsTable) Schema() sql.Schema {
 		sql.Field{"hash", sql.String},
 		sql.Field{"author_name", sql.String},
 		sql.Field{"author_email", sql.String},
-		sql.Field{"author_time", sql.Timestamp},
+		sql.Field{"author_when", sql.TimestampWithTimezone},
 		sql.Field{"comitter_name", sql.String},
 		sql.Field{"comitter_email", sql.String},
-		sql.Field{"comitter_time", sql.Timestamp},
+		sql.Field{"comitter_when", sql.TimestampWithTimezone},
 		sql.Field{"message", sql.String},
 	}
 }
@@ -73,10 +73,10 @@ func commitToRow(c *git.Commit) sql.Row {
 		c.Hash.String(),
 		c.Author.Name,
 		c.Author.Email,
-		c.Author.When.Unix(),
+		c.Author.When,
 		c.Committer.Name,
 		c.Committer.Email,
-		c.Committer.When.Unix(),
+		c.Committer.When,
 		c.Message,
 	)
 }
diff --git a/git/commits_test.go b/git/commits_test.go
@@ -3,39 +3,41 @@ package git
 import (
 	"testing"
 
+	"github.com/gitql/gitql/sql"
+
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/fixtures"
 )
 
-func TestCommitsTable(t *testing.T) {
+func TestCommitsTable_Name(t *testing.T) {
 	assert := assert.New(t)
 
 	f := fixtures.Basic().One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
-	assert.Nil(err)
+	table := getTable(assert, f, commitsTableName)
+	assert.Equal(commitsTableName, table.Name())
+}
 
-	db := NewDatabase("foo", r)
-	assert.NotNil(db)
+func TestCommitsTable_Children(t *testing.T) {
+	assert := assert.New(t)
 
-	tables := db.Tables()
-	table, ok := tables[commitsTableName]
-	assert.True(ok)
-	assert.NotNil(table)
-	assert.Equal(commitsTableName, table.Name())
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, commitsTableName)
 	assert.Equal(0, len(table.Children()))
+}
 
-	iter, err := table.RowIter()
-	assert.Nil(err)
-	assert.NotNil(iter)
+func TestCommitsTable_RowIter(t *testing.T) {
+	assert := assert.New(t)
+
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, commitsTableName)
 
-	row, err := iter.Next()
+	rows, err := sql.NodeToRows(table)
 	assert.Nil(err)
-	assert.NotNil(row)
+	assert.Len(rows, 9)
 
-	fields := row.Fields()
-	assert.NotNil(fields)
-	assert.IsType("", fields[1])
-	assert.IsType("", fields[2])
-	assert.IsType(int64(0), fields[3])
+	schema := table.Schema()
+	for idx, row := range rows {
+		err := schema.CheckRow(row)
+		assert.Nil(err, "row %d doesn't conform to schema", idx)
+	}
 }
diff --git a/git/database_test.go b/git/database_test.go
@@ -1,8 +1,11 @@
 package git
 
 import (
+	"sort"
 	"testing"
 
+	"github.com/gitql/gitql/sql"
+
 	"github.com/stretchr/testify/assert"
 	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/fixtures"
@@ -12,29 +15,66 @@ func init() {
 	fixtures.RootFolder = "../../../../gopkg.in/src-d/go-git.v4/fixtures/"
 }
 
+const (
+	testDBName = "foo"
+)
+
 func TestDatabase_Tables(t *testing.T) {
 	assert := assert.New(t)
 
 	f := fixtures.Basic().One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
-	assert.Nil(err)
-
-	db := NewDatabase("foo", r)
-	assert.NotNil(db)
+	db := getDB(assert, f, testDBName)
 
 	tables := db.Tables()
-	_, ok := tables[commitsTableName]
-	assert.True(ok)
+	var tableNames []string
+	for key := range tables {
+		tableNames = append(tableNames, key)
+	}
+
+	sort.Strings(tableNames)
+	expected := []string{
+		commitsTableName,
+		referencesTableName,
+		treeEntriesTableName,
+		tagsTableName,
+		blobsTableName,
+	}
+	sort.Strings(expected)
+
+	assert.Equal(expected, tableNames)
 }
 
 func TestDatabase_Name(t *testing.T) {
 	assert := assert.New(t)
 
 	f := fixtures.Basic().One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
+	db := getDB(assert, f, testDBName)
+	assert.Equal(testDBName, db.Name())
+}
+
+func getDB(assert *assert.Assertions, fixture *fixtures.Fixture,
+	name string) sql.Database {
+
+	r, err := git.NewFilesystemRepository(fixture.DotGit().Base())
 	assert.Nil(err)
 
-	db := NewDatabase("foo", r)
+	db := NewDatabase(name, r)
+	assert.NotNil(db)
+
+	return db
+}
+
+func getTable(assert *assert.Assertions, fixture *fixtures.Fixture,
+	name string) sql.Table {
+
+	db := getDB(assert, fixture, "foo")
 	assert.NotNil(db)
 	assert.Equal(db.Name(), "foo")
+
+	tables := db.Tables()
+	table, ok := tables[name]
+	assert.True(ok, "table %s does not exist", table)
+	assert.NotNil(table)
+
+	return table
 }
diff --git a/git/references_test.go b/git/references_test.go
@@ -3,43 +3,41 @@ package git
 import (
 	"testing"
 
+	"github.com/gitql/gitql/sql"
+
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/fixtures"
 )
 
-func TestReferencesTable(t *testing.T) {
+func TestReferencesTable_Name(t *testing.T) {
 	assert := assert.New(t)
 
 	f := fixtures.Basic().One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
-	assert.Nil(err)
+	table := getTable(assert, f, referencesTableName)
+	assert.Equal(referencesTableName, table.Name())
+}
 
-	db := NewDatabase("foo", r)
-	assert.NotNil(db)
+func TestReferencesTable_Children(t *testing.T) {
+	assert := assert.New(t)
 
-	tables := db.Tables()
-	table, ok := tables[referencesTableName]
-	assert.True(ok)
-	assert.NotNil(table)
-	assert.Equal(referencesTableName, table.Name())
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, referencesTableName)
 	assert.Equal(0, len(table.Children()))
+}
 
-	iter, err := table.RowIter()
-	assert.Nil(err)
-	assert.NotNil(iter)
+func TestReferencesTable_RowIter(t *testing.T) {
+	assert := assert.New(t)
 
-	row, err := iter.Next()
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, referencesTableName)
+
+	rows, err := sql.NodeToRows(table)
 	assert.Nil(err)
-	assert.NotNil(row)
-
-	fields := row.Fields()
-	assert.NotNil(fields)
-	assert.IsType("", fields[0])
-	assert.IsType("", fields[1])
-	assert.IsType(true, fields[2])
-	assert.IsType(true, fields[3])
-	assert.IsType(true, fields[4])
-	assert.IsType(true, fields[5])
-	assert.IsType("", fields[6])
+	assert.Len(rows, 5)
+
+	schema := table.Schema()
+	for idx, row := range rows {
+		err := schema.CheckRow(row)
+		assert.Nil(err, "row %d doesn't conform to schema", idx)
+	}
 }
diff --git a/git/tags.go b/git/tags.go
@@ -28,7 +28,7 @@ func (tagsTable) Schema() sql.Schema {
 		sql.Field{"name", sql.String},
 		sql.Field{"tagger_email", sql.String},
 		sql.Field{"tagger_name", sql.String},
-		sql.Field{"tagger_when", sql.Timestamp},
+		sql.Field{"tagger_when", sql.TimestampWithTimezone},
 		sql.Field{"message", sql.String},
 		sql.Field{"target", sql.String},
 	}
diff --git a/git/tags_test.go b/git/tags_test.go
@@ -2,46 +2,42 @@ package git
 
 import (
 	"testing"
-	"time"
+
+	"github.com/gitql/gitql/sql"
 
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/fixtures"
 )
 
-func TestTagsTable(t *testing.T) {
+func TestTagsTable_Name(t *testing.T) {
 	assert := assert.New(t)
 
-	f := fixtures.ByTag("tags").One()
-	r, err := git.NewFilesystemRepository(f.DotGit().Base())
-	assert.Nil(err)
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, tagsTableName)
+	assert.Equal(tagsTableName, table.Name())
+}
 
-	db := NewDatabase("foo", r)
-	assert.NotNil(db)
+func TestTagsTable_Children(t *testing.T) {
+	assert := assert.New(t)
 
-	tables := db.Tables()
-	table, ok := tables[tagsTableName]
-	assert.True(ok)
-	assert.NotNil(table)
-	assert.Equal(tagsTableName, table.Name())
+	f := fixtures.Basic().One()
+	table := getTable(assert, f, tagsTableName)
 	assert.Equal(0, len(table.Children()))
+}
 
-	iter, err := table.RowIter()
-	assert.Nil(err)
-	assert.NotNil(iter)
+func TestTagsTable_RowIter(t *testing.T) {
+	assert := assert.New(t)
 
-	row, err := iter.Next()
+	f := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One()
+	table := getTable(assert, f, tagsTableName)
+
+	rows, err := sql.NodeToRows(table)
 	assert.Nil(err)
-	assert.NotNil(row)
-
-	fields := row.Fields()
-	assert.NotNil(fields)
-
-	assert.IsType("", fields[0])
-	assert.IsType("", fields[1])
-	assert.IsType("", fields[2])
-	assert.IsType("", fields[3])
-	assert.IsType(time.Time{}, fields[4])
-	assert.IsType("", fields[5])
-	assert.IsType("", fields[6])
+	assert.Len(rows, 4)
+
+	schema := table.Schema()
+	for idx, row := range rows {
+		err := schema.CheckRow(row)
+		assert.Nil(err, "row %d doesn't conform to schema", idx)
+	}
 }
diff --git a/git/tree_entries.go b/git/tree_entries.go
@@ -74,6 +74,7 @@ func (i *treeEntryIter) Next() (sql.Row, error) {
 
 		if i.ei >= len(i.t.Entries) {
 			i.t = nil
+			continue
 		}
 
 		e := i.t.Entries[i.ei]
diff --git a/git/tree_entries_test.go b/git/tree_entries_test.go
diff --git a/mem/table_test.go b/mem/table_test.go
diff --git a/sql/row.go b/sql/row.go
diff --git a/sql/type.go b/sql/type.go

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ func (tagsTable) Schema() sql.Schema {`
`28`	`28`	`sql.Field{"name", sql.String},`
`29`	`29`	`sql.Field{"tagger_email", sql.String},`
`30`	`30`	`sql.Field{"tagger_name", sql.String},`
`31`		`- sql.Field{"tagger_when", sql.Timestamp},`
	`31`	`+ sql.Field{"tagger_when", sql.TimestampWithTimezone},`
`32`	`32`	`sql.Field{"message", sql.String},`
`33`	`33`	`sql.Field{"target", sql.String},`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ func (i *treeEntryIter) Next() (sql.Row, error) {`
`74`	`74`
`75`	`75`	`if i.ei >= len(i.t.Entries) {`
`76`	`76`	`i.t = nil`
	`77`	`+ continue`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`e := i.t.Entries[i.ei]`