func (as *authSuite) TestNewUserAddsToExistent(c *C) {
as.state.Lock()
firstUser, err := auth.NewUser(as.state, "username", "macaroon", []string{"discharge"})
as.state.Unlock()
c.Check(err, IsNil)
// adding a new one
as.state.Lock()
user, err := auth.NewUser(as.state, "new_username", "new_macaroon", []string{"new_discharge"})
as.state.Unlock()
expected := &auth.UserState{
ID: 2,
Username: "******",
Macaroon: "new_macaroon",
Discharges: []string{"new_discharge"},
StoreMacaroon: "new_macaroon",
StoreDischarges: []string{"new_discharge"},
}
c.Check(err, IsNil)
c.Check(user, DeepEquals, expected)
as.state.Lock()
userFromState, err := auth.User(as.state, 2)
as.state.Unlock()
c.Check(err, IsNil)
c.Check(userFromState, DeepEquals, expected)
// first user is still in the state
as.state.Lock()
userFromState, err = auth.User(as.state, 1)
as.state.Unlock()
c.Check(err, IsNil)
c.Check(userFromState, DeepEquals, firstUser)
}
func (as *authSuite) TestRemove(c *C) {
as.state.Lock()
user, err := auth.NewUser(as.state, "username", "macaroon", []string{"discharge"})
as.state.Unlock()
c.Check(err, IsNil)
as.state.Lock()
_, err = auth.User(as.state, user.ID)
as.state.Unlock()
c.Check(err, IsNil)
as.state.Lock()
err = auth.RemoveUser(as.state, user.ID)
as.state.Unlock()
c.Assert(err, IsNil)
as.state.Lock()
_, err = auth.User(as.state, user.ID)
as.state.Unlock()
c.Check(err, ErrorMatches, "invalid user")
as.state.Lock()
err = auth.RemoveUser(as.state, user.ID)
as.state.Unlock()
c.Assert(err, ErrorMatches, "invalid user")
}
func (as *authSuite) TestUserForNoAuthInState(c *C) {
as.state.Lock()
userFromState, err := auth.User(as.state, 42)
as.state.Unlock()
c.Check(err, NotNil)
c.Check(userFromState, IsNil)
}
func (as *authSuite) TestUserForNonExistent(c *C) {
as.state.Lock()
_, err := auth.NewUser(as.state, "username", "macaroon", []string{"discharge"})
as.state.Unlock()
c.Check(err, IsNil)
as.state.Lock()
userFromState, err := auth.User(as.state, 42)
c.Check(err, ErrorMatches, "invalid user")
c.Check(userFromState, IsNil)
}
func (as *authSuite) TestUser(c *C) {
as.state.Lock()
user, err := auth.NewUser(as.state, "username", "macaroon", []string{"discharge"})
as.state.Unlock()
c.Check(err, IsNil)
as.state.Lock()
userFromState, err := auth.User(as.state, 1)
as.state.Unlock()
c.Check(err, IsNil)
c.Check(userFromState, DeepEquals, user)
}
func (m *SnapManager) doDownloadSnap(t *state.Task, _ *tomb.Tomb) error {
st := t.State()
st.Lock()
ss, snapst, err := snapSetupAndState(t)
st.Unlock()
if err != nil {
return err
}
checker := func(info *snap.Info) error {
return checkRevisionIsNew(ss.Name, snapst, info.Revision)
}
pb := &TaskProgressAdapter{task: t}
var auther store.Authenticator
if ss.UserID > 0 {
st.Lock()
user, err := auth.User(st, ss.UserID)
st.Unlock()
if err != nil {
return err
}
auther = user.Authenticator()
}
storeInfo, downloadedSnapFile, err := m.backend.Download(ss.Name, ss.Channel, checker, pb, auther)
if err != nil {
return err
}
ss.SnapPath = downloadedSnapFile
ss.Revision = storeInfo.Revision
// update the snap setup and state for the follow up tasks
st.Lock()
t.Set("snap-setup", ss)
snapst.Candidate = &storeInfo.SideInfo
Set(st, ss.Name, snapst)
st.Unlock()
return nil
}
func (as *authSuite) TestNewUserSortsDischarges(c *C) {
as.state.Lock()
user, err := auth.NewUser(as.state, "username", "macaroon", []string{"discharge2", "discharge1"})
as.state.Unlock()
expected := &auth.UserState{
ID: 1,
Username: "******",
Macaroon: "macaroon",
Discharges: []string{"discharge1", "discharge2"},
StoreMacaroon: "macaroon",
StoreDischarges: []string{"discharge1", "discharge2"},
}
c.Check(err, IsNil)
c.Check(user, DeepEquals, expected)
as.state.Lock()
userFromState, err := auth.User(as.state, 1)
as.state.Unlock()
c.Check(err, IsNil)
c.Check(userFromState, DeepEquals, expected)
}