JustAnotherArchivist
/
transfer.sh
forkato da kiska/transfer.sh
1
0
Forka 1
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
243 Commit
17 Rami (Branch)
34 MiB
 
 
 
Albero (Tree): 84643d1dc1
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da '84643d1dc1'
${ noResults }
transfer.sh/vendor/github.com/goamz/goamz/iam/iam_test.go

451 righe
17 KiB
Originale Blame Cronologia 

  1. package iam_test

  2. 

  3. import (

  4. 	"strings"

  5. 	"testing"

  6. 	"time"

  7. 

  8. 	"github.com/goamz/goamz/aws"

  9. 	"github.com/goamz/goamz/iam"

  10. 	"github.com/goamz/goamz/testutil"

  11. 	. "gopkg.in/check.v1"

  12. )

  13. 

  14. func Test(t *testing.T) {

  15. 	TestingT(t)

  16. }

  17. 

  18. type S struct {

  19. 	iam *iam.IAM

  20. }

  21. 

  22. var _ = Suite(&S{})

  23. 

  24. var testServer = testutil.NewHTTPServer()

  25. 

  26. func (s *S) SetUpSuite(c *C) {

  27. 	testServer.Start()

  28. 	auth := aws.Auth{AccessKey: "abc", SecretKey: "123"}

  29. 	s.iam = iam.NewWithClient(auth, aws.Region{IAMEndpoint: testServer.URL}, testutil.DefaultClient)

  30. }

  31. 

  32. func (s *S) TearDownTest(c *C) {

  33. 	testServer.Flush()

  34. }

  35. 

  36. func (s *S) TestCreateUser(c *C) {

  37. 	testServer.Response(200, nil, CreateUserExample)

  38. 	resp, err := s.iam.CreateUser("Bob", "/division_abc/subdivision_xyz/")

  39. 	values := testServer.WaitRequest().URL.Query()

  40. 	c.Assert(values.Get("Action"), Equals, "CreateUser")

  41. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  42. 	c.Assert(values.Get("Path"), Equals, "/division_abc/subdivision_xyz/")

  43. 	c.Assert(err, IsNil)

  44. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  45. 	expected := iam.User{

  46. 		Path: "/division_abc/subdivision_xyz/",

  47. 		Name: "Bob",

  48. 		Id:   "AIDACKCEVSQ6C2EXAMPLE",

  49. 		Arn:  "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob",

  50. 	}

  51. 	c.Assert(resp.User, DeepEquals, expected)

  52. }

  53. 

  54. func (s *S) TestCreateUserConflict(c *C) {

  55. 	testServer.Response(409, nil, DuplicateUserExample)

  56. 	resp, err := s.iam.CreateUser("Bob", "/division_abc/subdivision_xyz/")

  57. 	testServer.WaitRequest()

  58. 	c.Assert(resp, IsNil)

  59. 	c.Assert(err, NotNil)

  60. 	e, ok := err.(*iam.Error)

  61. 	c.Assert(ok, Equals, true)

  62. 	c.Assert(e.Message, Equals, "User with name Bob already exists.")

  63. 	c.Assert(e.Code, Equals, "EntityAlreadyExists")

  64. }

  65. 

  66. func (s *S) TestGetUser(c *C) {

  67. 	testServer.Response(200, nil, GetUserExample)

  68. 	resp, err := s.iam.GetUser("Bob")

  69. 	values := testServer.WaitRequest().URL.Query()

  70. 	c.Assert(values.Get("Action"), Equals, "GetUser")

  71. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  72. 	c.Assert(err, IsNil)

  73. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  74. 	expected := iam.User{

  75. 		Path: "/division_abc/subdivision_xyz/",

  76. 		Name: "Bob",

  77. 		Id:   "AIDACKCEVSQ6C2EXAMPLE",

  78. 		Arn:  "arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob",

  79. 	}

  80. 	c.Assert(resp.User, DeepEquals, expected)

  81. }

  82. 

  83. func (s *S) TestDeleteUser(c *C) {

  84. 	testServer.Response(200, nil, RequestIdExample)

  85. 	resp, err := s.iam.DeleteUser("Bob")

  86. 	values := testServer.WaitRequest().URL.Query()

  87. 	c.Assert(values.Get("Action"), Equals, "DeleteUser")

  88. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  89. 	c.Assert(err, IsNil)

  90. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  91. }

  92. 

  93. func (s *S) TestCreateGroup(c *C) {

  94. 	testServer.Response(200, nil, CreateGroupExample)

  95. 	resp, err := s.iam.CreateGroup("Admins", "/admins/")

  96. 	values := testServer.WaitRequest().URL.Query()

  97. 	c.Assert(values.Get("Action"), Equals, "CreateGroup")

  98. 	c.Assert(values.Get("GroupName"), Equals, "Admins")

  99. 	c.Assert(values.Get("Path"), Equals, "/admins/")

  100. 	c.Assert(err, IsNil)

  101. 	c.Assert(resp.Group.Path, Equals, "/admins/")

  102. 	c.Assert(resp.Group.Name, Equals, "Admins")

  103. 	c.Assert(resp.Group.Id, Equals, "AGPACKCEVSQ6C2EXAMPLE")

  104. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  105. }

  106. 

  107. func (s *S) TestCreateGroupWithoutPath(c *C) {

  108. 	testServer.Response(200, nil, CreateGroupExample)

  109. 	_, err := s.iam.CreateGroup("Managers", "")

  110. 	values := testServer.WaitRequest().URL.Query()

  111. 	c.Assert(values.Get("Action"), Equals, "CreateGroup")

  112. 	c.Assert(err, IsNil)

  113. 	_, ok := map[string][]string(values)["Path"]

  114. 	c.Assert(ok, Equals, false)

  115. }

  116. 

  117. func (s *S) TestDeleteGroup(c *C) {

  118. 	testServer.Response(200, nil, RequestIdExample)

  119. 	resp, err := s.iam.DeleteGroup("Admins")

  120. 	values := testServer.WaitRequest().URL.Query()

  121. 	c.Assert(values.Get("Action"), Equals, "DeleteGroup")

  122. 	c.Assert(values.Get("GroupName"), Equals, "Admins")

  123. 	c.Assert(err, IsNil)

  124. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  125. }

  126. 

  127. func (s *S) TestListGroups(c *C) {

  128. 	testServer.Response(200, nil, ListGroupsExample)

  129. 	resp, err := s.iam.Groups("/division_abc/")

  130. 	values := testServer.WaitRequest().URL.Query()

  131. 	c.Assert(values.Get("Action"), Equals, "ListGroups")

  132. 	c.Assert(values.Get("PathPrefix"), Equals, "/division_abc/")

  133. 	c.Assert(err, IsNil)

  134. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  135. 	expected := []iam.Group{

  136. 		{

  137. 			Path: "/division_abc/subdivision_xyz/",

  138. 			Name: "Admins",

  139. 			Id:   "AGPACKCEVSQ6C2EXAMPLE",

  140. 			Arn:  "arn:aws:iam::123456789012:group/Admins",

  141. 		},

  142. 		{

  143. 			Path: "/division_abc/subdivision_xyz/product_1234/engineering/",

  144. 			Name: "Test",

  145. 			Id:   "AGP2MAB8DPLSRHEXAMPLE",

  146. 			Arn:  "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test",

  147. 		},

  148. 		{

  149. 			Path: "/division_abc/subdivision_xyz/product_1234/",

  150. 			Name: "Managers",

  151. 			Id:   "AGPIODR4TAW7CSEXAMPLE",

  152. 			Arn:  "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers",

  153. 		},

  154. 	}

  155. 	c.Assert(resp.Groups, DeepEquals, expected)

  156. }

  157. 

  158. func (s *S) TestListGroupsWithoutPathPrefix(c *C) {

  159. 	testServer.Response(200, nil, ListGroupsExample)

  160. 	_, err := s.iam.Groups("")

  161. 	values := testServer.WaitRequest().URL.Query()

  162. 	c.Assert(values.Get("Action"), Equals, "ListGroups")

  163. 	c.Assert(err, IsNil)

  164. 	_, ok := map[string][]string(values)["PathPrefix"]

  165. 	c.Assert(ok, Equals, false)

  166. }

  167. 

  168. func (s *S) TestCreateAccessKey(c *C) {

  169. 	testServer.Response(200, nil, CreateAccessKeyExample)

  170. 	resp, err := s.iam.CreateAccessKey("Bob")

  171. 	values := testServer.WaitRequest().URL.Query()

  172. 	c.Assert(values.Get("Action"), Equals, "CreateAccessKey")

  173. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  174. 	c.Assert(err, IsNil)

  175. 	c.Assert(resp.AccessKey.UserName, Equals, "Bob")

  176. 	c.Assert(resp.AccessKey.Id, Equals, "AKIAIOSFODNN7EXAMPLE")

  177. 	c.Assert(resp.AccessKey.Secret, Equals, "wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY")

  178. 	c.Assert(resp.AccessKey.Status, Equals, "Active")

  179. }

  180. 

  181. func (s *S) TestDeleteAccessKey(c *C) {

  182. 	testServer.Response(200, nil, RequestIdExample)

  183. 	resp, err := s.iam.DeleteAccessKey("ysa8hasdhasdsi", "Bob")

  184. 	values := testServer.WaitRequest().URL.Query()

  185. 	c.Assert(values.Get("Action"), Equals, "DeleteAccessKey")

  186. 	c.Assert(values.Get("AccessKeyId"), Equals, "ysa8hasdhasdsi")

  187. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  188. 	c.Assert(err, IsNil)

  189. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  190. }

  191. 

  192. func (s *S) TestDeleteAccessKeyBlankUserName(c *C) {

  193. 	testServer.Response(200, nil, RequestIdExample)

  194. 	_, err := s.iam.DeleteAccessKey("ysa8hasdhasdsi", "")

  195. 	c.Assert(err, IsNil)

  196. 	values := testServer.WaitRequest().URL.Query()

  197. 	c.Assert(values.Get("Action"), Equals, "DeleteAccessKey")

  198. 	c.Assert(values.Get("AccessKeyId"), Equals, "ysa8hasdhasdsi")

  199. 	_, ok := map[string][]string(values)["UserName"]

  200. 	c.Assert(ok, Equals, false)

  201. }

  202. 

  203. func (s *S) TestAccessKeys(c *C) {

  204. 	testServer.Response(200, nil, ListAccessKeyExample)

  205. 	resp, err := s.iam.AccessKeys("Bob")

  206. 	values := testServer.WaitRequest().URL.Query()

  207. 	c.Assert(values.Get("Action"), Equals, "ListAccessKeys")

  208. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  209. 	c.Assert(err, IsNil)

  210. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  211. 	c.Assert(resp.AccessKeys, HasLen, 2)

  212. 	c.Assert(resp.AccessKeys[0].Id, Equals, "AKIAIOSFODNN7EXAMPLE")

  213. 	c.Assert(resp.AccessKeys[0].UserName, Equals, "Bob")

  214. 	c.Assert(resp.AccessKeys[0].Status, Equals, "Active")

  215. 	c.Assert(resp.AccessKeys[1].Id, Equals, "AKIAI44QH8DHBEXAMPLE")

  216. 	c.Assert(resp.AccessKeys[1].UserName, Equals, "Bob")

  217. 	c.Assert(resp.AccessKeys[1].Status, Equals, "Inactive")

  218. }

  219. 

  220. func (s *S) TestAccessKeysBlankUserName(c *C) {

  221. 	testServer.Response(200, nil, ListAccessKeyExample)

  222. 	_, err := s.iam.AccessKeys("")

  223. 	c.Assert(err, IsNil)

  224. 	values := testServer.WaitRequest().URL.Query()

  225. 	c.Assert(values.Get("Action"), Equals, "ListAccessKeys")

  226. 	_, ok := map[string][]string(values)["UserName"]

  227. 	c.Assert(ok, Equals, false)

  228. }

  229. 

  230. func (s *S) TestGetUserPolicy(c *C) {

  231. 	testServer.Response(200, nil, GetUserPolicyExample)

  232. 	resp, err := s.iam.GetUserPolicy("Bob", "AllAccessPolicy")

  233. 	values := testServer.WaitRequest().URL.Query()

  234. 	c.Assert(values.Get("Action"), Equals, "GetUserPolicy")

  235. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  236. 	c.Assert(values.Get("PolicyName"), Equals, "AllAccessPolicy")

  237. 	c.Assert(err, IsNil)

  238. 	c.Assert(resp.Policy.UserName, Equals, "Bob")

  239. 	c.Assert(resp.Policy.Name, Equals, "AllAccessPolicy")

  240. 	c.Assert(strings.TrimSpace(resp.Policy.Document), Equals, `{"Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]}`)

  241. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  242. }

  243. 

  244. func (s *S) TestPutUserPolicy(c *C) {

  245. 	document := `{

  246. 		"Statement": [

  247. 		{

  248. 			"Action": [

  249. 				"s3:*"

  250. 			],

  251. 			"Effect": "Allow",

  252. 			"Resource": [

  253. 				"arn:aws:s3:::8shsns19s90ajahadsj/*",

  254. 				"arn:aws:s3:::8shsns19s90ajahadsj"

  255. 			]

  256. 		}]

  257. 	}`

  258. 	testServer.Response(200, nil, RequestIdExample)

  259. 	resp, err := s.iam.PutUserPolicy("Bob", "AllAccessPolicy", document)

  260. 	req := testServer.WaitRequest()

  261. 	c.Assert(req.Method, Equals, "POST")

  262. 	c.Assert(req.FormValue("Action"), Equals, "PutUserPolicy")

  263. 	c.Assert(req.FormValue("PolicyName"), Equals, "AllAccessPolicy")

  264. 	c.Assert(req.FormValue("UserName"), Equals, "Bob")

  265. 	c.Assert(req.FormValue("PolicyDocument"), Equals, document)

  266. 	c.Assert(req.FormValue("Version"), Equals, "2010-05-08")

  267. 	c.Assert(err, IsNil)

  268. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  269. }

  270. 

  271. func (s *S) TestDeleteUserPolicy(c *C) {

  272. 	testServer.Response(200, nil, RequestIdExample)

  273. 	resp, err := s.iam.DeleteUserPolicy("Bob", "AllAccessPolicy")

  274. 	values := testServer.WaitRequest().URL.Query()

  275. 	c.Assert(values.Get("Action"), Equals, "DeleteUserPolicy")

  276. 	c.Assert(values.Get("PolicyName"), Equals, "AllAccessPolicy")

  277. 	c.Assert(values.Get("UserName"), Equals, "Bob")

  278. 	c.Assert(err, IsNil)

  279. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  280. }

  281. 

  282. func (s *S) TestAddUserToGroup(c *C) {

  283. 	testServer.Response(200, nil, AddUserToGroupExample)

  284. 	resp, err := s.iam.AddUserToGroup("admin1", "Admins")

  285. 	values := testServer.WaitRequest().URL.Query()

  286. 	c.Assert(values.Get("Action"), Equals, "AddUserToGroup")

  287. 	c.Assert(values.Get("GroupName"), Equals, "Admins")

  288. 	c.Assert(values.Get("UserName"), Equals, "admin1")

  289. 	c.Assert(err, IsNil)

  290. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  291. }

  292. 

  293. func (s *S) TestListAccountAliases(c *C) {

  294. 	testServer.Response(200, nil, ListAccountAliasesExample)

  295. 	resp, err := s.iam.ListAccountAliases()

  296. 	values := testServer.WaitRequest().URL.Query()

  297. 	c.Assert(values.Get("Action"), Equals, "ListAccountAliases")

  298. 	c.Assert(err, IsNil)

  299. 	c.Assert(resp.AccountAliases[0], Equals, "foocorporation")

  300. 	c.Assert(resp.RequestId, Equals, "c5a076e9-f1b0-11df-8fbe-45274EXAMPLE")

  301. }

  302. 

  303. func (s *S) TestCreateAccountAlias(c *C) {

  304. 	testServer.Response(200, nil, CreateAccountAliasExample)

  305. 	resp, err := s.iam.CreateAccountAlias("foobaz")

  306. 	values := testServer.WaitRequest().URL.Query()

  307. 	c.Assert(values.Get("Action"), Equals, "CreateAccountAlias")

  308. 	c.Assert(values.Get("AccountAlias"), Equals, "foobaz")

  309. 	c.Assert(err, IsNil)

  310. 	c.Assert(resp.RequestId, Equals, "36b5db08-f1b0-11df-8fbe-45274EXAMPLE")

  311. }

  312. 

  313. func (s *S) TestDeleteAccountAlias(c *C) {

  314. 	testServer.Response(200, nil, DeleteAccountAliasExample)

  315. 	resp, err := s.iam.DeleteAccountAlias("foobaz")

  316. 	values := testServer.WaitRequest().URL.Query()

  317. 	c.Assert(values.Get("Action"), Equals, "DeleteAccountAlias")

  318. 	c.Assert(values.Get("AccountAlias"), Equals, "foobaz")

  319. 	c.Assert(err, IsNil)

  320. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  321. }

  322. 

  323. func (s *S) TestUploadServerCertificate(c *C) {

  324. 	testServer.Response(200, nil, UploadServerCertificateExample)

  325. 

  326. 	certificateBody := `

  327. -----BEGIN CERTIFICATE-----

  328. MIICdzCCAeCgAwIBAgIGANc+Ha2wMA0GCSqGSIb3DQEBBQUAMFMxCzAJBgNVBAYT

  329. AlVTMRMwEQYDVQQKEwpBbWF6b24uY29tMQwwCgYDVQQLEwNBV1MxITAfBgNVBAMT

  330. GEFXUyBMaW1pdGVkLUFzc3VyYW5jZSBDQTAeFw0wOTAyMDQxNzE5MjdaFw0xMDAy

  331. MDQxNzE5MjdaMFIxCzAJBgNVBAYTAlVTMRMwEQYDVQQKEwpBbWF6b24uY29tMRcw

  332. FQYDVQQLEw5BV1MtRGV2ZWxvcGVyczEVMBMGA1UEAxMMNTdxNDl0c3ZwYjRtMIGf

  333. MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCpB/vsOwmT/O0td1RqzKjttSBaPjbr

  334. dqwNe9BrOyB08fw2+Ch5oonZYXfGUrT6mkYXH5fQot9HvASrzAKHO596FdJA6DmL

  335. ywdWe1Oggk7zFSXO1Xv+3vPrJtaYxYo3eRIp7w80PMkiOv6M0XK8ubcTouODeJbf

  336. suDqcLnLDxwsvwIDAQABo1cwVTAOBgNVHQ8BAf8EBAMCBaAwFgYDVR0lAQH/BAww

  337. CgYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQULGNaBphBumaKbDRK

  338. CAi0mH8B3mowDQYJKoZIhvcNAQEFBQADgYEAuKxhkXaCLGcqDuweKtO/AEw9ZePH

  339. wr0XqsaIK2HZboqruebXEGsojK4Ks0WzwgrEynuHJwTn760xe39rSqXWIOGrOBaX

  340. wFpWHVjTFMKk+tSDG1lssLHyYWWdFFU4AnejRGORJYNaRHgVTKjHphc5jEhHm0BX

  341. AEaHzTpmEXAMPLE=

  342. -----END CERTIFICATE-----

  343. `

  344. 	privateKey := `

  345. -----BEGIN DSA PRIVATE KEY-----

  346. MIIBugIBTTKBgQD33xToSXPJ6hr37L3+KNi3/7DgywlBcvlFPPSHIw3ORuO/22mT

  347. 8Cy5fT89WwNvZ3BPKWU6OZ38TQv3eWjNc/3U3+oqVNG2poX5nCPOtO1b96HYX2mR

  348. 3FTdH6FRKbQEhpDzZ6tRrjTHjMX6sT3JRWkBd2c4bGu+HUHO1H7QvrCTeQIVTKMs

  349. TCKCyrLiGhUWuUGNJUMU6y6zToGTHl84Tz7TPwDGDXuy/Dk5s4jTVr+xibROC/gS

  350. Qrs4Dzz3T1ze6lvU8S1KT9UsOB5FUJNTTPCPey+Lo4mmK6b23XdTyCIT8e2fsm2j

  351. jHHC1pIPiTkdLS3j6ZYjF8LY6TENFng+LDY/xwPOl7TJVoD3J/WXC2J9CEYq9o34

  352. kq6WWn3CgYTuo54nXUgnoCb3xdG8COFrg+oTbIkHTSzs3w5o/GGgKK7TDF3UlJjq

  353. vHNyJQ6kWBrQRR1Xp5KYQ4c/Dm5kef+62mH53HpcCELguWVcffuVQpmq3EWL9Zp9

  354. jobTJQ2VHjb5IVxiO6HRSd27di3njyrzUuJCyHSDTqwLJmTThpd6OTIUTL3Tc4m2

  355. 62TITdw53KWJEXAMPLE=

  356. -----END DSA PRIVATE KEY-----

  357. `

  358. 	params := &iam.UploadServerCertificateParams{

  359. 		ServerCertificateName: "ProdServerCert",

  360. 		Path:            "/company/servercerts/",

  361. 		PrivateKey:      privateKey,

  362. 		CertificateBody: certificateBody,

  363. 	}

  364. 

  365. 	resp, err := s.iam.UploadServerCertificate(params)

  366. 	req := testServer.WaitRequest()

  367. 	c.Assert(req.Method, Equals, "POST")

  368. 	c.Assert(req.FormValue("Action"), Equals, "UploadServerCertificate")

  369. 	c.Assert(req.FormValue("CertificateBody"), Equals, certificateBody)

  370. 	c.Assert(req.FormValue("PrivateKey"), Equals, privateKey)

  371. 	c.Assert(req.FormValue("ServerCertificateName"), Equals, "ProdServerCert")

  372. 	c.Assert(req.FormValue("CertificateChain"), Equals, "")

  373. 	c.Assert(req.FormValue("Path"), Equals, "/company/servercerts/")

  374. 	c.Assert(req.FormValue("Version"), Equals, "2010-05-08")

  375. 	c.Assert(err, IsNil)

  376. 

  377. 	ud, _ := time.Parse(time.RFC3339, "2010-05-08T01:02:03.004Z")

  378. 	exp, _ := time.Parse(time.RFC3339, "2012-05-08T01:02:03.004Z")

  379. 	expected := iam.ServerCertificateMetadata{

  380. 		Arn: "arn:aws:iam::123456789012:server-certificate/company/servercerts/ProdServerCert",

  381. 		ServerCertificateName: "ProdServerCert",

  382. 		ServerCertificateId:   "ASCACKCEVSQ6C2EXAMPLE",

  383. 		Path:                  "/company/servercerts/",

  384. 		UploadDate:            ud,

  385. 		Expiration:            exp,

  386. 	}

  387. 	c.Assert(resp.ServerCertificateMetadata, DeepEquals, expected)

  388. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  389. }

  390. 

  391. func (s *S) TestListServerCertificates(c *C) {

  392. 	testServer.Response(200, nil, ListServerCertificatesExample)

  393. 	params := &iam.ListServerCertificatesParams{

  394. 		Marker:     "my-fake-marker",

  395. 		PathPrefix: "/some/fake/path",

  396. 	}

  397. 

  398. 	resp, err := s.iam.ListServerCertificates(params)

  399. 	req := testServer.WaitRequest()

  400. 

  401. 	c.Assert(err, IsNil)

  402. 	c.Assert(req.Method, Equals, "GET")

  403. 	c.Assert(req.FormValue("Action"), Equals, "ListServerCertificates")

  404. 	c.Assert(req.FormValue("Marker"), Equals, "my-fake-marker")

  405. 	c.Assert(req.FormValue("PathPrefix"), Equals, "/some/fake/path")

  406. 	c.Assert(req.FormValue("Version"), Equals, "2010-05-08")

  407. 

  408. 	uploadDate, _ := time.Parse(time.RFC3339, "2010-05-08T01:02:03.004Z")

  409. 	expirationDate, _ := time.Parse(time.RFC3339, "2012-05-08T01:02:03.004Z")

  410. 	expected := []iam.ServerCertificateMetadata{

  411. 		{

  412. 			Arn: "arn:aws:iam::123456789012:server-certificate/company/servercerts/ProdServerCert",

  413. 			ServerCertificateName: "ProdServerCert",

  414. 			ServerCertificateId:   "ASCACKCEVSQ6C2EXAMPLE1",

  415. 			Path:                  "/some/fake/path",

  416. 			UploadDate:            uploadDate,

  417. 			Expiration:            expirationDate,

  418. 		},

  419. 		{

  420. 			Arn: "arn:aws:iam::123456789012:server-certificate/company/servercerts/BetaServerCert",

  421. 			ServerCertificateName: "BetaServerCert",

  422. 			ServerCertificateId:   "ASCACKCEVSQ6C2EXAMPLE2",

  423. 			Path:                  "/some/fake/path",

  424. 			UploadDate:            uploadDate,

  425. 			Expiration:            expirationDate,

  426. 		},

  427. 		{

  428. 			Arn: "arn:aws:iam::123456789012:server-certificate/company/servercerts/TestServerCert",

  429. 			ServerCertificateName: "TestServerCert",

  430. 			ServerCertificateId:   "ASCACKCEVSQ6C2EXAMPLE3",

  431. 			Path:                  "/some/fake/path",

  432. 			UploadDate:            uploadDate,

  433. 			Expiration:            expirationDate,

  434. 		},

  435. 	}

  436. 

  437. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eTHISDIFFERENTTEST")

  438. 	c.Assert(resp.IsTruncated, Equals, false)

  439. 	c.Assert(resp.ServerCertificates, DeepEquals, expected)

  440. }

  441. 

  442. func (s *S) TestDeleteServerCertificate(c *C) {

  443. 	testServer.Response(200, nil, DeleteServerCertificateExample)

  444. 	resp, err := s.iam.DeleteServerCertificate("ProdServerCert")

  445. 	req := testServer.WaitRequest()

  446. 	c.Assert(req.FormValue("Action"), Equals, "DeleteServerCertificate")

  447. 	c.Assert(req.FormValue("ServerCertificateName"), Equals, "ProdServerCert")

  448. 	c.Assert(err, IsNil)

  449. 	c.Assert(resp.RequestId, Equals, "7a62c49f-347e-4fc4-9331-6e8eEXAMPLE")

  450. }