github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/api/sshclient/facade_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package sshclient_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	jujutesting "github.com/juju/testing"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/names.v2"
    12  
    13  	apitesting "github.com/juju/juju/api/base/testing"
    14  	"github.com/juju/juju/api/sshclient"
    15  	"github.com/juju/juju/apiserver/common"
    16  	"github.com/juju/juju/apiserver/params"
    17  )
    18  
    19  type FacadeSuite struct {
    20  	jujutesting.IsolationSuite
    21  }
    22  
    23  var _ = gc.Suite(&FacadeSuite{})
    24  
    25  func (s *FacadeSuite) TestAddress(c *gc.C) {
    26  	var stub jujutesting.Stub
    27  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    28  		stub.AddCall(objType+"."+request, arg)
    29  		c.Check(id, gc.Equals, "")
    30  		*result.(*params.SSHAddressResults) = params.SSHAddressResults{
    31  			Results: []params.SSHAddressResult{{Address: "1.1.1.1"}},
    32  		}
    33  		return nil
    34  	})
    35  	facade := sshclient.NewFacade(apiCaller)
    36  	expectedArg := []interface{}{params.Entities{[]params.Entity{{
    37  		names.NewUnitTag("foo/0").String(),
    38  	}}}}
    39  
    40  	public, err := facade.PublicAddress("foo/0")
    41  	c.Assert(err, jc.ErrorIsNil)
    42  	c.Check(public, gc.Equals, "1.1.1.1")
    43  	stub.CheckCalls(c, []jujutesting.StubCall{{"SSHClient.PublicAddress", expectedArg}})
    44  	stub.ResetCalls()
    45  
    46  	private, err := facade.PrivateAddress("foo/0")
    47  	c.Assert(err, jc.ErrorIsNil)
    48  	c.Check(private, gc.Equals, "1.1.1.1")
    49  	stub.CheckCalls(c, []jujutesting.StubCall{{"SSHClient.PrivateAddress", expectedArg}})
    50  }
    51  
    52  func (s *FacadeSuite) TestAddressError(c *gc.C) {
    53  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    54  		return errors.New("boom")
    55  	})
    56  	facade := sshclient.NewFacade(apiCaller)
    57  
    58  	public, err := facade.PublicAddress("foo/0")
    59  	c.Check(public, gc.Equals, "")
    60  	c.Check(err, gc.ErrorMatches, "boom")
    61  
    62  	private, err := facade.PrivateAddress("foo/0")
    63  	c.Check(private, gc.Equals, "")
    64  	c.Check(err, gc.ErrorMatches, "boom")
    65  }
    66  
    67  func (s *FacadeSuite) TestAddressTargetError(c *gc.C) {
    68  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    69  		*result.(*params.SSHAddressResults) = params.SSHAddressResults{
    70  			Results: []params.SSHAddressResult{{Error: common.ServerError(errors.New("boom"))}},
    71  		}
    72  		return nil
    73  	})
    74  	facade := sshclient.NewFacade(apiCaller)
    75  
    76  	public, err := facade.PublicAddress("foo/0")
    77  	c.Check(public, gc.Equals, "")
    78  	c.Check(err, gc.ErrorMatches, "boom")
    79  
    80  	private, err := facade.PrivateAddress("foo/0")
    81  	c.Check(private, gc.Equals, "")
    82  	c.Check(err, gc.ErrorMatches, "boom")
    83  }
    84  
    85  func (s *FacadeSuite) TestAddressMissingResults(c *gc.C) {
    86  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    87  		return nil
    88  	})
    89  	facade := sshclient.NewFacade(apiCaller)
    90  	expectedErr := "expected 1 result, got 0"
    91  
    92  	public, err := facade.PublicAddress("foo/0")
    93  	c.Check(public, gc.Equals, "")
    94  	c.Check(err, gc.ErrorMatches, expectedErr)
    95  
    96  	private, err := facade.PrivateAddress("foo/0")
    97  	c.Check(private, gc.Equals, "")
    98  	c.Check(err, gc.ErrorMatches, expectedErr)
    99  }
   100  
   101  func (s *FacadeSuite) TestAddressExtraResults(c *gc.C) {
   102  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   103  		*result.(*params.SSHAddressResults) = params.SSHAddressResults{
   104  			Results: []params.SSHAddressResult{
   105  				{Address: "1.1.1.1"},
   106  				{Address: "2.2.2.2"},
   107  			},
   108  		}
   109  		return nil
   110  	})
   111  	facade := sshclient.NewFacade(apiCaller)
   112  	expectedErr := "expected 1 result, got 2"
   113  
   114  	public, err := facade.PublicAddress("foo/0")
   115  	c.Check(public, gc.Equals, "")
   116  	c.Check(err, gc.ErrorMatches, expectedErr)
   117  
   118  	private, err := facade.PrivateAddress("foo/0")
   119  	c.Check(private, gc.Equals, "")
   120  	c.Check(err, gc.ErrorMatches, expectedErr)
   121  }
   122  
   123  func (s *FacadeSuite) TestPublicKeys(c *gc.C) {
   124  	var stub jujutesting.Stub
   125  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   126  		stub.AddCall(objType+"."+request, arg)
   127  		c.Check(id, gc.Equals, "")
   128  		*result.(*params.SSHPublicKeysResults) = params.SSHPublicKeysResults{
   129  			Results: []params.SSHPublicKeysResult{{PublicKeys: []string{"rsa", "dsa"}}},
   130  		}
   131  		return nil
   132  	})
   133  	facade := sshclient.NewFacade(apiCaller)
   134  	keys, err := facade.PublicKeys("foo/0")
   135  	c.Assert(err, jc.ErrorIsNil)
   136  	c.Check(keys, gc.DeepEquals, []string{"rsa", "dsa"})
   137  	stub.CheckCalls(c, []jujutesting.StubCall{{
   138  		"SSHClient.PublicKeys",
   139  		[]interface{}{params.Entities{[]params.Entity{{
   140  			Tag: names.NewUnitTag("foo/0").String(),
   141  		}}}},
   142  	}})
   143  }
   144  
   145  func (s *FacadeSuite) TestPublicKeysError(c *gc.C) {
   146  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   147  		return errors.New("boom")
   148  	})
   149  	facade := sshclient.NewFacade(apiCaller)
   150  	keys, err := facade.PublicKeys("foo/0")
   151  	c.Check(keys, gc.IsNil)
   152  	c.Check(err, gc.ErrorMatches, "boom")
   153  }
   154  
   155  func (s *FacadeSuite) TestPublicKeysTargetError(c *gc.C) {
   156  	var stub jujutesting.Stub
   157  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   158  		stub.AddCall(objType+"."+request, arg)
   159  		c.Check(id, gc.Equals, "")
   160  		*result.(*params.SSHPublicKeysResults) = params.SSHPublicKeysResults{
   161  			Results: []params.SSHPublicKeysResult{{Error: common.ServerError(errors.New("boom"))}},
   162  		}
   163  		return nil
   164  	})
   165  	facade := sshclient.NewFacade(apiCaller)
   166  	keys, err := facade.PublicKeys("foo/0")
   167  	c.Check(keys, gc.IsNil)
   168  	c.Check(err, gc.ErrorMatches, "boom")
   169  }
   170  
   171  func (s *FacadeSuite) TestPublicKeysMissingResults(c *gc.C) {
   172  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   173  		return nil
   174  	})
   175  	facade := sshclient.NewFacade(apiCaller)
   176  	keys, err := facade.PublicKeys("foo/0")
   177  	c.Check(keys, gc.IsNil)
   178  	c.Check(err, gc.ErrorMatches, "expected 1 result, got 0")
   179  }
   180  
   181  func (s *FacadeSuite) TestPublicKeysExtraResults(c *gc.C) {
   182  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   183  		*result.(*params.SSHPublicKeysResults) = params.SSHPublicKeysResults{
   184  			Results: []params.SSHPublicKeysResult{
   185  				{PublicKeys: []string{"rsa"}},
   186  				{PublicKeys: []string{"rsa"}},
   187  			},
   188  		}
   189  		return nil
   190  	})
   191  	facade := sshclient.NewFacade(apiCaller)
   192  	keys, err := facade.PublicKeys("foo/0")
   193  	c.Check(keys, gc.IsNil)
   194  	c.Check(err, gc.ErrorMatches, "expected 1 result, got 2")
   195  }
   196  
   197  func (s *FacadeSuite) TestProxy(c *gc.C) {
   198  	checkProxy(c, true)
   199  	checkProxy(c, false)
   200  }
   201  
   202  func checkProxy(c *gc.C, useProxy bool) {
   203  	var stub jujutesting.Stub
   204  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   205  		stub.AddCall(objType+"."+request, arg)
   206  		*result.(*params.SSHProxyResult) = params.SSHProxyResult{
   207  			UseProxy: useProxy,
   208  		}
   209  		return nil
   210  	})
   211  	facade := sshclient.NewFacade(apiCaller)
   212  	result, err := facade.Proxy()
   213  	c.Check(err, jc.ErrorIsNil)
   214  	c.Check(result, gc.Equals, useProxy)
   215  	stub.CheckCalls(c, []jujutesting.StubCall{{"SSHClient.Proxy", []interface{}{nil}}})
   216  }
   217  
   218  func (s *FacadeSuite) TestProxyError(c *gc.C) {
   219  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   220  		return errors.New("boom")
   221  	})
   222  	facade := sshclient.NewFacade(apiCaller)
   223  	_, err := facade.Proxy()
   224  	c.Check(err, gc.ErrorMatches, "boom")
   225  }