github.com/technosophos/deis@v1.7.1-0.20150915173815-f9005256004b/deisctl/backend/fleet/ssh_test.go (about)

     1  package fleet
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"reflect"
     7  	"sync"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/coreos/fleet/machine"
    12  	"github.com/coreos/fleet/schema"
    13  )
    14  
    15  type mockCommandRunner struct{}
    16  
    17  func (mockCommandRunner) LocalCommand(string) (int, error) {
    18  	return 0, nil
    19  }
    20  
    21  func (mockCommandRunner) RemoteCommand(cmd string, addr string, timeout time.Duration) (int, error) {
    22  	if cmd != "true" || addr != "1.1.1.1" || timeout != 0 {
    23  		return -1, fmt.Errorf("Got %s %s %d, which is unexpected", cmd, addr, timeout)
    24  	}
    25  	return 0, nil
    26  }
    27  
    28  func TestRunCommand(t *testing.T) {
    29  	t.Parallel()
    30  
    31  	expected := machine.MachineState{
    32  		ID:       "test-1",
    33  		PublicIP: "1.1.1.1",
    34  		Metadata: nil,
    35  		Version:  "",
    36  	}
    37  
    38  	testMachines := []machine.MachineState{
    39  		expected,
    40  	}
    41  
    42  	testWriter := bytes.Buffer{}
    43  
    44  	c := &FleetClient{Fleet: &stubFleetClient{testMachineStates: testMachines},
    45  		runner: mockCommandRunner{}, errWriter: &testWriter}
    46  
    47  	code := c.runCommand("true", "test-1")
    48  
    49  	err := testWriter.String()
    50  	if err != "" || code != 0 {
    51  		t.Errorf("Error: %v, Returned %d", err, code)
    52  	}
    53  }
    54  
    55  func TestFindUnit(t *testing.T) {
    56  	t.Parallel()
    57  
    58  	expectedID := "testing"
    59  
    60  	testUnits := []*schema.Unit{
    61  		&schema.Unit{
    62  			Name:         "deis-router@1.service",
    63  			CurrentState: "loaded",
    64  			MachineID:    expectedID,
    65  		},
    66  		&schema.Unit{
    67  			Name: "deis-router@2.service",
    68  		},
    69  	}
    70  	c := &FleetClient{Fleet: &stubFleetClient{testUnits: testUnits, unitsMutex: &sync.Mutex{}}}
    71  
    72  	expectedErr := "Error retrieving Unit foo: Unit foo not found"
    73  
    74  	_, err := c.findUnit("foo")
    75  
    76  	actualErr := err.Error()
    77  
    78  	if actualErr != expectedErr {
    79  		t.Errorf("Expected '%s', Got '%s'", expectedErr, actualErr)
    80  	}
    81  
    82  	expectedErr = "Unit deis-router@2.service does not appear to be running.\n"
    83  
    84  	_, err = c.findUnit("deis-router@2.service")
    85  
    86  	actualErr = err.Error()
    87  
    88  	if actualErr != expectedErr {
    89  		t.Errorf("Expected '%s', Got '%s'", expectedErr, actualErr)
    90  	}
    91  
    92  	result, err := c.findUnit("deis-router@1.service")
    93  
    94  	if err != nil {
    95  		t.Error(err)
    96  	}
    97  
    98  	if result != expectedID {
    99  		t.Errorf("Expected %s, Got %s", expectedID, result)
   100  	}
   101  }
   102  
   103  func TestMachineState(t *testing.T) {
   104  	t.Parallel()
   105  
   106  	expected := machine.MachineState{
   107  		ID:       "test-1",
   108  		PublicIP: "1.1.1.1",
   109  		Metadata: nil,
   110  		Version:  "",
   111  	}
   112  
   113  	testMachines := []machine.MachineState{
   114  		expected,
   115  		machine.MachineState{
   116  			ID:       "test-2",
   117  			PublicIP: "2.2.2.2",
   118  			Metadata: nil,
   119  			Version:  "",
   120  		},
   121  	}
   122  	c := &FleetClient{Fleet: &stubFleetClient{testMachineStates: testMachines}}
   123  
   124  	result, err := c.machineState(expected.ID)
   125  
   126  	if err != nil {
   127  		t.Fatal(err)
   128  	}
   129  
   130  	if !reflect.DeepEqual(*result, expected) {
   131  		t.Errorf("Expected %v, Got %v", expected, *result)
   132  	}
   133  }