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 }