More tests, more refactoring, more reflection (ugh)

repositories/album_repository.go

@@ -10,7 +10,7 @@ type Album struct {
 
 func NewAlbumRepository() *Album {
 	r := &Album{}
-	r.table = "album"
+	r.init("album", &models.Album{})
 	return r
 }
 
@@ -22,9 +22,9 @@ func (r *Album) Put(m *models.Album) error {
 }
 
 func (r *Album) Get(id string) (*models.Album, error) {
-	rec := &models.Album{}
+	var rec interface{}
-	err := r.loadEntity(id, rec)
+	rec, err := r.readEntity(id)
-	return rec, err
+	return rec.(*models.Album), err
 }
 
 func (r *Album) GetByName(name string) (*models.Album, error) {

repositories/artist_repository.go

@@ -10,7 +10,7 @@ type Artist struct {
 
 func NewArtistRepository() *Artist {
 	r := &Artist{}
-	r.table = "artist"
+	r.init("artist", &models.Artist{})
 	return r
 }
 
@@ -22,9 +22,9 @@ func (r *Artist) Put(m *models.Artist) error {
 }
 
 func (r *Artist) Get(id string) (*models.Artist, error) {
-	rec := &models.Artist{}
+	var rec interface{}
-	err := r.loadEntity(id, rec)
+	rec, err := r.readEntity(id)
-	return rec, err
+	return rec.(*models.Artist), err
 }
 
 func (r *Artist) GetByName(name string) (*models.Artist, error) {

repositories/base_repository.go

@@ -9,9 +9,23 @@ import (
 	"reflect"
 )
 
-
 type BaseRepository struct {
-	table string
+	table      string
+	entityType reflect.Type
+	fieldNames []string
+}
+
+func (r *BaseRepository) init(table string, entity interface{}) {
+	r.table = table
+	r.entityType = reflect.TypeOf(entity).Elem()
+
+	h, _ := utils.ToMap(entity)
+	r.fieldNames = make([]string, len(h))
+	i := 0
+	for k, _ := range h {
+		r.fieldNames[i] = k
+		i++
+	}
 }
 
 // TODO Use annotations to specify fields to be used
@@ -67,31 +81,69 @@ func (r *BaseRepository) getParent(entity interface{}) (table string, id string)
 	return "", ""
 }
 
-func (r *BaseRepository) loadEntity(id string, entity interface{}) error {
+func (r *BaseRepository) getFieldKeys(id string) [][]byte {
 	recordPrefix := fmt.Sprintf("%s:%s:", r.table, id)
-
+	var fieldKeys = make([][]byte, len(r.fieldNames))
-	h, _ := utils.ToMap(entity)
+	for i, n := range r.fieldNames {
-	var fieldKeys = make([][]byte, len(h))
+		fieldKeys[i] = []byte(recordPrefix + n)
-	var fieldNames = make([]string, len(h))
-	i := 0
-	for k, _ := range h {
-		fieldNames[i] = k
-		fieldKeys[i] = []byte(recordPrefix + k)
-		i++
 	}
+	return fieldKeys
+}
+
+func (r* BaseRepository) newInstance() interface{} {
+	return reflect.New(r.entityType).Interface()
+}
+
+func (r *BaseRepository) readEntity(id string) (interface{}, error) {
+	entity := r.newInstance()
+
+	fieldKeys := r.getFieldKeys(id)
 
 	res, err := db().MGet(fieldKeys...)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	var record = make(map[string]interface{}, len(res))
+	err = r.toEntity(res, entity)
-	for i, v := range res {
+	return entity, err
+}
+
+func (r *BaseRepository) toEntity(response [][]byte, entity interface{}) error {
+	var record = make(map[string]interface{}, len(response))
+	for i, v := range response {
 		var value interface{}
 		if err := json.Unmarshal(v, &value); err != nil {
 			return err
 		}
-		record[string(fieldNames[i])] = value
+		record[string(r.fieldNames[i])] = value
 	}
 
 	return utils.ToStruct(record, entity)
 }
+
+// TODO Optimize it! Probably very slow (and confusing!)
+func (r *BaseRepository) loadAll(entities interface{}) error {
+	total, err := r.CountAll()
+	if (err != nil) {
+		return err
+	}
+
+	reflected := reflect.ValueOf(entities).Elem()
+
+	setName := r.table + "s:all"
+	response, err := db().XSSort([]byte(setName), 0, 0, true, true, nil, r.getFieldKeys("*"))
+	if (err != nil) {
+		return err
+	}
+	numFields := len(r.fieldNames)
+	for i := 0; i < total; i++ {
+		start := i * numFields
+		entity := reflect.New(r.entityType).Interface()
+
+		if err := r.toEntity(response[start:start + numFields], entity); err != nil {
+			return err
+		}
+		reflected.Set(reflect.Append(reflected, reflect.ValueOf(entity).Elem()))
+	}
+
+	return nil
+}

repositories/base_repository_test.go

@@ -5,10 +5,11 @@ import (
 	. "github.com/smartystreets/goconvey/convey"
 	"github.com/deluan/gosonic/tests"
 	"fmt"
+	"strconv"
 )
 
 type TestEntity struct {
-	Id string
+	Id   string
 	Name string
 }
 
@@ -18,12 +19,17 @@ func shouldBeEqual(actualStruct interface{}, expectedStruct ...interface{}) stri
 	return ShouldEqual(actual, expected)
 }
 
+func createRepo() *BaseRepository{
+	repo := &BaseRepository{}
+	repo.init("test", &TestEntity{})
+	return repo
+}
+
 func TestBaseRepository(t *testing.T) {
 	tests.Init(t, false)
 
 	Convey("Subject: NewId", t, func() {
-
+		repo := createRepo()
-		repo := &BaseRepository{table: "test_table"}
 
 		Convey("When I call NewId with a name", func() {
 			Id := repo.NewId("a name")
@@ -57,8 +63,7 @@ func TestBaseRepository(t *testing.T) {
 	Convey("Subject: saveOrUpdate/loadEntity/CountAll", t, func() {
 
 		Convey("Given an empty DB", func() {
-			dropDb()
+			repo := createRepo()
-			repo := &BaseRepository{table: "test"}
 
 			Convey("When I save a new entity", func() {
 				entity := &TestEntity{"123", "My Name"}
@@ -74,8 +79,7 @@ func TestBaseRepository(t *testing.T) {
 				})
 
 				Convey("And this entity should be equal to the the saved one", func() {
-					actualEntity := &TestEntity{}
+					actualEntity, _ := repo.readEntity("123")
-					repo.loadEntity("123", actualEntity)
 					So(actualEntity, shouldBeEqual, entity)
 				})
 
@@ -84,8 +88,7 @@ func TestBaseRepository(t *testing.T) {
 		})
 
 		Convey("Given a table with one entity", func() {
-			dropDb()
+			repo := createRepo()
-			repo := &BaseRepository{table: "test"}
 			entity := &TestEntity{"111", "One Name"}
 			repo.saveOrUpdate(entity.Id, entity)
 
@@ -110,8 +113,8 @@ func TestBaseRepository(t *testing.T) {
 				})
 
 				Convey("And the entity should be updated", func() {
-					actualEntity := &TestEntity{}
+					e, _ := repo.readEntity("111")
-					repo.loadEntity("111", actualEntity)
+					actualEntity := e.(*TestEntity)
 					So(actualEntity.Name, ShouldEqual, newEntity.Name)
 				})
 
@@ -119,5 +122,34 @@ func TestBaseRepository(t *testing.T) {
 
 		})
 
+		Convey("Given a table with 3 entities", func() {
+			repo := createRepo()
+			for i := 1; i <= 3; i++ {
+				e := &TestEntity{strconv.Itoa(i), fmt.Sprintf("Name %d", i)}
+				repo.saveOrUpdate(e.Id, e)
+			}
+
+			Convey("When I call loadAll", func() {
+				var es = make([]TestEntity, 0)
+				err := repo.loadAll(&es)
+				Convey("Then It should not return any error", func() {
+					So(err, ShouldBeNil)
+				})
+				Convey("And I should get 3 entities", func() {
+					So(len(es), ShouldEqual, 3)
+				})
+				Convey("And the values should be retrieved", func() {
+					for _, e := range es {
+						So(e.Id, ShouldBeIn, []string{"1", "2", "3"})
+						So(e.Name, ShouldBeIn, []string{"Name 1", "Name 2", "Name 3"})
+					}
+				})
+			})
+		})
+
+		Reset(func() {
+			dropDb()
+		})
+
 	})
 }

repositories/index_repository.go

@@ -2,7 +2,7 @@ package repositories
 
 import (
 	"github.com/deluan/gosonic/models"
-"errors"
+	"errors"
 )
 
 type ArtistIndex struct {
@@ -11,7 +11,7 @@ type ArtistIndex struct {
 
 func NewArtistIndexRepository() *ArtistIndex {
 	r := &ArtistIndex{}
-	r.table = "index"
+	r.init("index", &models.ArtistIndex{})
 	return r
 }
 
@@ -22,14 +22,16 @@ func (r *ArtistIndex) Put(m *models.ArtistIndex) error {
 	return r.saveOrUpdate(m.Id, m)
 }
 
-func (r*ArtistIndex) Get(id string) (*models.ArtistIndex, error) {
+func (r *ArtistIndex) Get(id string) (*models.ArtistIndex, error) {
-	entity := &models.ArtistIndex{}
+	var rec interface{}
-	err := r.loadEntity(id, entity)
+	rec, err := r.readEntity(id)
-	return entity, err
+	return rec.(*models.ArtistIndex), err
 }
 
-func (r*ArtistIndex) GetAll() ([]*models.ArtistIndex, error) {
+func (r *ArtistIndex) GetAll() ([]models.ArtistIndex, error) {
-	return nil, errors.New("Not Implemented")
+	var indices = make([]models.ArtistIndex, 30)
+	err := r.loadAll(&indices)
+	return indices, err
 }
 
 

repositories/index_repository_test.go

@@ -1 +1,50 @@
 package repositories
+
+import (
+	"testing"
+	. "github.com/smartystreets/goconvey/convey"
+	"github.com/deluan/gosonic/tests"
+	"github.com/deluan/gosonic/models"
+"strconv"
+)
+
+func TestIndexRepository(t *testing.T) {
+
+	tests.Init(t, false)
+
+	Convey("Subject: NewIndexRepository", t, func() {
+		repo := NewArtistIndexRepository()
+		Convey("It should be able to read and write to the database", func() {
+			i := &models.ArtistIndex{Id: "123"}
+
+			repo.Put(i)
+			s,_ := repo.Get("123")
+
+			So(s, shouldBeEqual, i)
+		})
+		Convey("Given that I have 4 records", func() {
+			for i := 1; i <= 4; i++ {
+				e := &models.ArtistIndex{Id: strconv.Itoa(i)}
+				repo.Put(e)
+			}
+
+			Convey("When I call GetAll", func() {
+				indices, err  := repo.GetAll()
+				Convey("Then It should not return any error", func() {
+					So(err, ShouldBeNil)
+				})
+				SkipConvey("And It should return 4 entities", func() {
+					So(len(indices), ShouldEqual, 4)
+				})
+				SkipConvey("And the values should be retrieved", func() {
+					for _, e := range indices {
+						So(e.Id, ShouldBeIn, []string{"1", "2", "3", "4"})
+					}
+				})
+			})
+		})
+		Reset(func() {
+			dropDb()
+		})
+	})
+}

repositories/media_file_repository.go

@@ -10,7 +10,7 @@ type MediaFile struct {
 
 func NewMediaFileRepository() *MediaFile {
 	r := &MediaFile{}
-	r.table = "mediafile"
+	r.init("mediafile", &models.MediaFile{})
 	return r
 }