workflow tests

workflow/datastore.go

@@ -54,7 +54,7 @@ func addWhereFilters(stmt string, params ...interface{}) string {
 
 	if len(where) != 0 {
 		whereFilter := strings.Join(where, ",")
-		stmt = fmt.Sprintf("%s WHERE %s", selectProfilesStmt, whereFilter)
+		stmt = fmt.Sprintf("%s WHERE %s", stmt, whereFilter)
 	}
 	return stmt
 }

workflow/workflow_store.go

@@ -3,7 +3,6 @@ package workflow
 import (
 	"database/sql"
 	"fmt"
-	"strings"
 
 	"github.com/pkg/errors"
 )
@@ -13,7 +12,7 @@ var (
 	createWorkflowStmt = `INSERT INTO workflows (name) VALUES ($1) 
 						 ON CONFLICT ON CONSTRAINT workflows_name_key DO NOTHING
 						 RETURNING workflow_uuid;`
-	selectWorkflowsStmt = `SELECT workflow_uuid, name FROM profiles`
+	selectWorkflowsStmt = `SELECT workflow_uuid, name FROM workflows`
 )
 
 // WrkflowUUID is a filter we can add as a parameter to narrow down the list of returned results
@@ -34,12 +33,10 @@ func (store pgStore) CreateWorkflow(wf *Workflow) (*Workflow, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "pgStore create workflow")
 	}
-
 	profiles := wf.Profiles
 	if err := store.addProfiles(wf.UUID, profiles...); err != nil {
 		return nil, err
 	}
-
 	return wf, nil
 }
 
@@ -47,7 +44,6 @@ func (store pgStore) addProfiles(wfUUID string, profiles ...Profile) error {
 	if len(profiles) == 0 {
 		return nil
 	}
-
 	for _, prf := range profiles {
 		if err := store.addProfile(wfUUID, prf.UUID); err != nil {
 			return err
@@ -69,18 +65,7 @@ func (store pgStore) addProfile(wfUUID, pfUUID string) error {
 
 func (store pgStore) Workflows(params ...interface{}) ([]Workflow, error) {
 	stmt := selectWorkflowsStmt
-	var where []string
-	for _, param := range params {
-		if f, ok := param.(whereer); ok {
-			where = append(where, f.where())
-		}
-	}
-
-	if len(where) != 0 {
-		whereFilter := strings.Join(where, ",")
-		stmt = fmt.Sprintf("%s WHERE %s", selectWorkflowsStmt, whereFilter)
-	}
-
+	stmt = addWhereFilters(stmt, params...)
 	var workflows []Workflow
 	err := store.Select(&workflows, stmt)
 	if err != nil {

workflow/workflow_store_test.go

@@ -4,20 +4,47 @@ import (
 	"math/rand"
 	"reflect"
 	"testing"
+	"testing/quick"
 )
 
-func TestDatastoreWorkflows(t *testing.T) {
-	// ds := datastore(t)
+func TestRetrieveWorkflows(t *testing.T) {
+	ds := datastore(t)
 	defer teardown()
-}
-
-func (wf Workflow) Generate(rand *rand.Rand, size int) reflect.Value {
-	name := randomString(16)
-	randomWorkflow := Workflow{
-		Name: name,
+	testWorkflows := addTestWorkflows(t, ds, 5)
+	workflows, err := ds.Workflows()
+	if err != nil {
+		t.Fatal(err)
 	}
 
-	return reflect.ValueOf(randomWorkflow)
+	if len(workflows) != 5 {
+		t.Error("expected", 5, "got", len(workflows))
+	}
+
+	for _, p := range testWorkflows {
+		byUUID, err := ds.Workflows(WrkflowUUID{p.UUID})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(byUUID) != 1 {
+			t.Log("filtering by UUID should only return 1 result")
+			t.Fatal("expected", 1, "got", len(byUUID))
+		}
+
+		uuid := byUUID[0].UUID
+		if p.UUID != uuid {
+			t.Log("result should have the same UUID as the one in the query")
+			t.Fatal("expected", p.UUID, "got", uuid)
+
+		}
+	}
+
+	// test with error
+	badUUIDQuery := ProfileUUID{"bad_uuid"}
+	_, err = ds.Workflows(badUUIDQuery)
+	if err == nil {
+		t.Fatal("expected an error but got nil")
+
+	}
 }
 
 var createWorkflowTests = []struct {
@@ -53,6 +80,25 @@ var createWorkflowTests = []struct {
 	},
 }
 
+func TestDatastoreCreateWorkflowWithProfiles(t *testing.T) {
+	ds := datastore(t)
+	defer teardown()
+	testProfiles := addTestProfiles(t, ds, 5)
+
+	wf := &Workflow{
+		Name:     "has_profiles",
+		Profiles: testProfiles,
+	}
+	wf, err := ds.CreateWorkflow(wf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if wf.UUID == "" {
+		t.Fatal("expected nonempty uuid result")
+	}
+
+}
+
 func TestDatastoreCreateWorkflow(t *testing.T) {
 	ds := datastore(t)
 	defer teardown()
@@ -73,6 +119,39 @@ func TestDatastoreCreateWorkflow(t *testing.T) {
 				t.Fatal("expected", tt.testErr, "got", err)
 			}
 		}
-		// check profiles
 	}
 }
+
+func addTestWorkflows(t *testing.T, ds Datastore, numWorkflows int) []Workflow {
+	var workflows []Workflow
+	for i := 0; i < numWorkflows; i++ {
+		input := randomWorkflow()
+		newWorkflow, err := ds.CreateWorkflow(&input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		workflows = append(workflows, *newWorkflow)
+	}
+	return workflows
+
+}
+
+func randomWorkflow() Workflow {
+	vrf, ok := quick.Value(reflect.TypeOf(Workflow{}), rand.New(rand.NewSource(1)))
+	if !ok {
+		panic("randomProfile: no value")
+	}
+	if f, ok := vrf.Interface().(Workflow); ok {
+		return f
+	}
+	return Workflow{}
+}
+
+func (wf Workflow) Generate(rand *rand.Rand, size int) reflect.Value {
+	name := randomString(16)
+	randomWorkflow := Workflow{
+		Name: name,
+	}
+
+	return reflect.ValueOf(randomWorkflow)
+}