Merge pull request #3887 from Joshua-Anderson/backend-testing

tests(deisctl): Add tests to backend package

Author: carmstrong

deisctl/backend/fleet/create.go

@@ -92,7 +92,7 @@ func (c *FleetClient) createServiceUnit(component string, num int) (name string,
 	if err != nil {
 		return "", nil, err
 	}
-	uf, err = NewUnit(component)
+	uf, err = NewUnit(component, c.templatePaths)
 	if err != nil {
 		return
 	}

deisctl/backend/fleet/create_test.go

@@ -0,0 +1,73 @@
+package fleet
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path"
+	"sync"
+	"testing"
+
+	"github.com/coreos/fleet/schema"
+)
+
+func TestCreate(t *testing.T) {
+
+	unitFiles := []string{"deis-controller.service", "deis-builder.service",
+		"deis-router.service"}
+
+	unitContents := []byte("[Unit]")
+
+	name, err := ioutil.TempDir("", "deisctl-fleetctl")
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, unit := range unitFiles {
+		ioutil.WriteFile(path.Join(name, unit), unitContents, 777)
+	}
+
+	testFleetClient := stubFleetClient{testUnits: []*schema.Unit{}, unitsMutex: &sync.Mutex{},
+		unitStatesMutex: &sync.Mutex{}}
+
+	c := &FleetClient{templatePaths: []string{name}, Fleet: &testFleetClient}
+
+	var errOutput string
+	outchan := make(chan string)
+	errchan := make(chan error)
+	var wg sync.WaitGroup
+
+	logMutex := sync.Mutex{}
+
+	go logState(outchan, errchan, &errOutput, &logMutex)
+
+	c.Create([]string{"controller", "builder", "router@1"}, &wg, outchan, errchan)
+
+	wg.Wait()
+	close(errchan)
+	close(outchan)
+
+	logMutex.Lock()
+	if errOutput != "" {
+		t.Fatal(errOutput)
+	}
+	logMutex.Unlock()
+
+	expectedUnits := []string{"deis-controller.service", "deis-builder.service",
+		"deis-router@1.service"}
+
+	for _, expectedUnit := range expectedUnits {
+		found := false
+
+		for _, unit := range testFleetClient.testUnits {
+			if unit.Name == expectedUnit {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			t.Error(fmt.Errorf("Expected Unit %s not found in Unit States", expectedUnit))
+		}
+	}
+}

deisctl/backend/fleet/destroy.go

@@ -10,7 +10,7 @@ import (
 // Destroy units for a given target
 func (c *FleetClient) Destroy(targets []string, wg *sync.WaitGroup, outchan chan string, errchan chan error) {
 	// expand @* targets
-	expandedTargets, err := expandTargets(c, targets)
+	expandedTargets, err := c.expandTargets(targets)
 	if err != nil {
 		errchan <- err
 		return

deisctl/backend/fleet/destroy_test.go

@@ -0,0 +1,52 @@
+package fleet
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/coreos/fleet/schema"
+)
+
+func TestDestroy(t *testing.T) {
+	testUnits := []*schema.Unit{
+		&schema.Unit{
+			Name: "deis-registry.service",
+		},
+		&schema.Unit{
+			Name: "deis-builder.service",
+		},
+		&schema.Unit{
+			Name: "deis-router@1.service",
+		},
+	}
+
+	testFleetClient := stubFleetClient{testUnits: testUnits, testUnitStates: []*schema.UnitState{}, unitsMutex: &sync.Mutex{}, unitStatesMutex: &sync.Mutex{}}
+
+	c := &FleetClient{Fleet: &testFleetClient}
+
+	var errOutput string
+	outchan := make(chan string)
+	errchan := make(chan error)
+	var wg sync.WaitGroup
+
+	logMutex := sync.Mutex{}
+
+	go logState(outchan, errchan, &errOutput, &logMutex)
+
+	c.Destroy([]string{"controller", "registry", "router@1"}, &wg, outchan, errchan)
+
+	wg.Wait()
+	close(errchan)
+	close(outchan)
+
+	logMutex.Lock()
+	if errOutput != "" {
+		t.Fatal(errOutput)
+	}
+	logMutex.Unlock()
+
+	if len(testFleetClient.testUnits) != 1 || testFleetClient.testUnits[0].Name != "deis-builder.service" {
+		t.Error(fmt.Errorf("Got %d Units (want 1), first unit %s (want builder)", len(testFleetClient.testUnits), testFleetClient.testUnits[0].Name))
+	}
+}

deisctl/backend/fleet/fleet.go

@@ -1,6 +1,11 @@
 package fleet
 
 import (
+	"io"
+	"os"
+	"path"
+	"text/tabwriter"
+
 	"github.com/coreos/fleet/client"
 	"github.com/coreos/fleet/machine"
 )
@@ -11,6 +16,11 @@ type FleetClient struct {
 
 	// used to cache MachineStates
 	machineStates map[string]*machine.MachineState
+
+	templatePaths []string
+	runner        commandRunner
+	out           *tabwriter.Writer
+	errWriter     io.Writer
 }
 
 // NewClient returns a client used to communicate with Fleet
@@ -20,5 +30,17 @@ func NewClient() (*FleetClient, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &FleetClient{Fleet: client}, nil
+
+	// path hierarchy for finding systemd service templates
+	templatePaths := []string{
+		os.Getenv("DEISCTL_UNITS"),
+		path.Join(os.Getenv("HOME"), ".deis", "units"),
+		"/var/lib/deis/units",
+	}
+
+	out := new(tabwriter.Writer)
+	out.Init(os.Stdout, 0, 8, 1, '\t', 0)
+
+	return &FleetClient{Fleet: client, templatePaths: templatePaths, runner: sshCommandRunner{},
+		out: out, errWriter: os.Stderr}, nil
 }

deisctl/backend/fleet/fleet_test.go

@@ -1,6 +1,130 @@
 package fleet
 
-import "testing"
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	"github.com/coreos/fleet/machine"
+	"github.com/coreos/fleet/schema"
+)
+
+type stubFleetClient struct {
+	testUnits         []*schema.Unit
+	testUnitStates    []*schema.UnitState
+	testMachineStates []machine.MachineState
+	unitStatesMutex   *sync.Mutex
+	unitsMutex        *sync.Mutex
+}
+
+func (c *stubFleetClient) Machines() ([]machine.MachineState, error) {
+	return c.testMachineStates, nil
+}
+func (c *stubFleetClient) Unit(name string) (*schema.Unit, error) {
+	c.unitsMutex.Lock()
+	defer c.unitsMutex.Unlock()
+
+	for _, unit := range c.testUnits {
+		if unit.Name == name {
+			return unit, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Unit %s not found", name)
+}
+func (c *stubFleetClient) Units() ([]*schema.Unit, error) {
+	c.unitsMutex.Lock()
+	defer c.unitsMutex.Unlock()
+
+	return c.testUnits, nil
+}
+func (c *stubFleetClient) UnitStates() ([]*schema.UnitState, error) {
+	c.unitStatesMutex.Lock()
+	defer c.unitStatesMutex.Unlock()
+
+	return c.testUnitStates, nil
+}
+func (c *stubFleetClient) SetUnitTargetState(name, target string) error {
+
+	var activeState string
+	var subState string
+
+	if target == "loaded" {
+		activeState = "inactive"
+		subState = "dead"
+	} else if target == "launched" {
+		activeState = "active"
+		subState = "running"
+	}
+
+	unit, err := c.Unit(name)
+
+	if err != nil {
+		return err
+	}
+
+	c.unitsMutex.Lock()
+	unit.DesiredState = target
+	c.unitsMutex.Unlock()
+
+	c.unitStatesMutex.Lock()
+	defer c.unitStatesMutex.Unlock()
+
+	for _, unitState := range c.testUnitStates {
+		if name == unitState.Name {
+			unitState.SystemdSubState = subState
+			unitState.SystemdActiveState = activeState
+			return nil
+		}
+	}
+
+	c.testUnitStates = append(c.testUnitStates, &schema.UnitState{Name: name, SystemdSubState: subState, SystemdActiveState: activeState})
+
+	return nil
+}
+
+func (c *stubFleetClient) CreateUnit(unit *schema.Unit) error {
+	c.unitsMutex.Lock()
+	c.testUnits = append(c.testUnits, unit)
+	c.unitsMutex.Unlock()
+
+	return nil
+}
+
+func (c *stubFleetClient) DestroyUnit(name string) error {
+	c.unitsMutex.Lock()
+	for i := len(c.testUnits) - 1; i >= 0; i-- {
+		if c.testUnits[i].Name == name {
+			c.testUnits = append(c.testUnits[:i], c.testUnits[i+1:]...)
+		}
+	}
+	c.unitsMutex.Unlock()
+
+	return nil
+}
+
+func logState(outchan chan string, errchan chan error, errOutput *string, mutex *sync.Mutex) {
+	for {
+		select {
+		case _, ok := <-outchan:
+			if !ok {
+				outchan = nil
+			}
+		case err, ok := <-errchan:
+			if !ok {
+				errchan = nil
+			}
+			if err != nil {
+				mutex.Lock()
+				*errOutput += fmt.Sprintf("%v\n", err)
+				mutex.Unlock()
+			}
+		}
+		if outchan == nil && errchan == nil {
+			break
+		}
+	}
+}
 
 func TestNewClient(t *testing.T) {
 	// set required flags

deisctl/backend/fleet/journal.go

@@ -11,19 +11,19 @@ func (c *FleetClient) Journal(target string) (err error) {
 		return
 	}
 	for _, unit := range units {
-		runJournal(c, unit)
+		c.runJournal(unit)
 	}
 	return
 }
 
 // runJournal tails the systemd journal for a given unit
-func runJournal(c *FleetClient, name string) (exit int) {
-	machineID, err := findUnit(c, name)
+func (c *FleetClient) runJournal(name string) (exit int) {
+	machineID, err := c.findUnit(name)
 
 	if err != nil {
 		return 1
 	}
 
 	command := fmt.Sprintf("journalctl --unit %s --no-pager -n 40 -f", name)
-	return runCommand(c, command, machineID)
+	return c.runCommand(command, machineID)
 }