func (s *agentSuite) TestAgentLogin(c *gc.C) {
u, err := url.Parse(s.discharger.URL)
c.Assert(err, gc.IsNil)
for i, test := range agentLoginTests {
c.Logf("%d. %s", i, test.about)
s.discharger.LoginHandler = test.loginHandler
client := httpbakery.NewClient()
client.Key, err = bakery.GenerateKey()
c.Assert(err, gc.IsNil)
err = agent.SetUpAuth(client, u, "test-user")
c.Assert(err, gc.IsNil)
m, err := s.bakery.NewMacaroon("", nil, []checkers.Caveat{{
Location: s.discharger.URL,
Condition: "test condition",
}})
c.Assert(err, gc.IsNil)
ms, err := client.DischargeAll(m)
if test.expectError != "" {
c.Assert(err, gc.ErrorMatches, test.expectError)
continue
}
c.Assert(err, gc.IsNil)
err = s.bakery.Check(ms, bakery.FirstPartyCheckerFunc(
func(caveat string) error {
return nil
},
))
c.Assert(err, gc.IsNil)
}
}
func (s *agentSuite) TestLoginCookie(c *gc.C) {
key, err := bakery.GenerateKey()
c.Assert(err, gc.IsNil)
tests := []struct {
about string
setCookie func(*httpbakery.Client, *url.URL)
expectUser string
expectKey *bakery.PublicKey
expectError string
expectCause error
}{{
about: "success",
setCookie: func(client *httpbakery.Client, u *url.URL) {
agent.SetUpAuth(client, u, "bob")
},
expectUser: "******",
expectKey: &key.Public,
}, {
about: "no cookie",
setCookie: func(client *httpbakery.Client, u *url.URL) {},
expectError: "no agent-login cookie found",
expectCause: agent.ErrNoAgentLoginCookie,
}, {
about: "invalid base64 encoding",
setCookie: func(client *httpbakery.Client, u *url.URL) {
client.Jar.SetCookies(u, []*http.Cookie{{
Name: "agent-login",
Value: "x",
}})
},
expectError: "cannot decode cookie value: illegal base64 data at input byte 0",
}, {
about: "invalid JSON",
setCookie: func(client *httpbakery.Client, u *url.URL) {
client.Jar.SetCookies(u, []*http.Cookie{{
Name: "agent-login",
Value: base64.StdEncoding.EncodeToString([]byte("}")),
}})
},
expectError: "cannot unmarshal agent login: invalid character '}' looking for beginning of value",
}, {
about: "no username",
setCookie: func(client *httpbakery.Client, u *url.URL) {
agent.SetCookie(client.Jar, u, "", &key.Public)
},
expectError: "agent login has no user name",
}, {
about: "no public key",
setCookie: func(client *httpbakery.Client, u *url.URL) {
agent.SetCookie(client.Jar, u, "hello", nil)
},
expectError: "agent login has no public key",
}}
var (
foundUser string
foundKey *bakery.PublicKey
foundErr error
)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
foundUser, foundKey, foundErr = agent.LoginCookie(req)
}))
defer srv.Close()
srvURL, err := url.Parse(srv.URL)
c.Assert(err, gc.IsNil)
for i, test := range tests {
c.Logf("test %d: %s", i, test.about)
client := httpbakery.NewClient()
client.Key = key
test.setCookie(client, srvURL)
req, err := http.NewRequest("GET", srv.URL, nil)
c.Assert(err, gc.IsNil)
resp, err := client.Do(req)
c.Assert(err, gc.IsNil)
c.Assert(resp.StatusCode, gc.Equals, http.StatusOK)
if test.expectError != "" {
c.Assert(foundErr, gc.ErrorMatches, test.expectError)
if test.expectCause != nil {
c.Assert(errgo.Cause(foundErr), gc.Equals, test.expectCause)
}
continue
}
c.Assert(foundUser, gc.Equals, test.expectUser)
c.Assert(foundKey, gc.DeepEquals, test.expectKey)
}
}
func (s *agentSuite) TestSetUpAuthError(c *gc.C) {
client := httpbakery.NewClient()
err := agent.SetUpAuth(client, nil, "test-user")
c.Assert(err, gc.ErrorMatches, "cannot set-up authentication: client key not configured")
}