portainer/api/stacks/deployments/deploy_test.go

251 lines
7.8 KiB
Go

package deployments
import (
"errors"
"strings"
"testing"
"github.com/portainer/portainer/api/datastore"
portainer "github.com/portainer/portainer/api"
gittypes "github.com/portainer/portainer/api/git/types"
"github.com/stretchr/testify/assert"
)
type gitService struct {
cloneErr error
id string
}
func (g *gitService) CloneRepository(destination, repositoryURL, referenceName, username, password string) error {
return g.cloneErr
}
func (g *gitService) LatestCommitID(repositoryURL, referenceName, username, password string) (string, error) {
return g.id, nil
}
func (g *gitService) ListRefs(repositoryURL, username, password string, hardRefresh bool) ([]string, error) {
return nil, nil
}
func (g *gitService) ListFiles(repositoryURL, referenceName, username, password string, hardRefresh bool, includedExts []string) ([]string, error) {
return nil, nil
}
type noopDeployer struct{}
func (s *noopDeployer) DeploySwarmStack(stack *portainer.Stack, endpoint *portainer.Endpoint, registries []portainer.Registry, prune bool, pullImage bool) error {
return nil
}
func (s *noopDeployer) DeployComposeStack(stack *portainer.Stack, endpoint *portainer.Endpoint, registries []portainer.Registry, forcePullImage bool, forceRereate bool) error {
return nil
}
func (s *noopDeployer) DeployKubernetesStack(stack *portainer.Stack, endpoint *portainer.Endpoint, user *portainer.User) error {
return nil
}
func Test_redeployWhenChanged_FailsWhenCannotFindStack(t *testing.T) {
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
err := RedeployWhenChanged(1, nil, store, nil)
assert.Error(t, err)
assert.Truef(t, strings.HasPrefix(err.Error(), "failed to get the stack"), "it isn't an error we expected: %v", err.Error())
}
func Test_redeployWhenChanged_DoesNothingWhenNotAGitBasedStack(t *testing.T) {
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
admin := &portainer.User{ID: 1, Username: "admin"}
err := store.User().Create(admin)
assert.NoError(t, err, "error creating an admin")
err = store.Stack().Create(&portainer.Stack{ID: 1, CreatedBy: "admin"})
assert.NoError(t, err, "failed to create a test stack")
err = RedeployWhenChanged(1, nil, store, &gitService{nil, ""})
assert.NoError(t, err)
}
func Test_redeployWhenChanged_DoesNothingWhenNoGitChanges(t *testing.T) {
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
tmpDir := t.TempDir()
admin := &portainer.User{ID: 1, Username: "admin"}
err := store.User().Create(admin)
assert.NoError(t, err, "error creating an admin")
err = store.Stack().Create(&portainer.Stack{
ID: 1,
CreatedBy: "admin",
ProjectPath: tmpDir,
GitConfig: &gittypes.RepoConfig{
URL: "url",
ReferenceName: "ref",
ConfigHash: "oldHash",
}})
assert.NoError(t, err, "failed to create a test stack")
err = RedeployWhenChanged(1, nil, store, &gitService{nil, "oldHash"})
assert.NoError(t, err)
}
func Test_redeployWhenChanged_FailsWhenCannotClone(t *testing.T) {
cloneErr := errors.New("failed to clone")
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
admin := &portainer.User{ID: 1, Username: "admin"}
err := store.User().Create(admin)
assert.NoError(t, err, "error creating an admin")
err = store.Stack().Create(&portainer.Stack{
ID: 1,
CreatedBy: "admin",
GitConfig: &gittypes.RepoConfig{
URL: "url",
ReferenceName: "ref",
ConfigHash: "oldHash",
}})
assert.NoError(t, err, "failed to create a test stack")
err = RedeployWhenChanged(1, nil, store, &gitService{cloneErr, "newHash"})
assert.Error(t, err)
assert.ErrorIs(t, err, cloneErr, "should failed to clone but didn't, check test setup")
}
func Test_redeployWhenChanged(t *testing.T) {
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
tmpDir := t.TempDir()
err := store.Endpoint().Create(&portainer.Endpoint{ID: 1})
assert.NoError(t, err, "error creating environment")
username := "user"
err = store.User().Create(&portainer.User{Username: username, Role: portainer.AdministratorRole})
assert.NoError(t, err, "error creating a user")
stack := portainer.Stack{
ID: 1,
EndpointID: 1,
ProjectPath: tmpDir,
UpdatedBy: username,
GitConfig: &gittypes.RepoConfig{
URL: "url",
ReferenceName: "ref",
ConfigHash: "oldHash",
}}
err = store.Stack().Create(&stack)
assert.NoError(t, err, "failed to create a test stack")
t.Run("can deploy docker compose stack", func(t *testing.T) {
stack.Type = portainer.DockerComposeStack
store.Stack().UpdateStack(stack.ID, &stack)
err = RedeployWhenChanged(1, &noopDeployer{}, store, &gitService{nil, "newHash"})
assert.NoError(t, err)
})
t.Run("can deploy docker swarm stack", func(t *testing.T) {
stack.Type = portainer.DockerSwarmStack
store.Stack().UpdateStack(stack.ID, &stack)
err = RedeployWhenChanged(1, &noopDeployer{}, store, &gitService{nil, "newHash"})
assert.NoError(t, err)
})
t.Run("can deploy kube app", func(t *testing.T) {
stack.Type = portainer.KubernetesStack
store.Stack().UpdateStack(stack.ID, &stack)
err = RedeployWhenChanged(1, &noopDeployer{}, store, &gitService{nil, "newHash"})
assert.NoError(t, err)
})
}
func Test_getUserRegistries(t *testing.T) {
_, store, teardown := datastore.MustNewTestStore(t, true, true)
defer teardown()
endpointID := 123
admin := &portainer.User{ID: 1, Username: "admin", Role: portainer.AdministratorRole}
err := store.User().Create(admin)
assert.NoError(t, err, "error creating an admin")
user := &portainer.User{ID: 2, Username: "user", Role: portainer.StandardUserRole}
err = store.User().Create(user)
assert.NoError(t, err, "error creating a user")
team := portainer.Team{ID: 1, Name: "team"}
store.TeamMembership().Create(&portainer.TeamMembership{
ID: 1,
UserID: user.ID,
TeamID: team.ID,
Role: portainer.TeamMember,
})
registryReachableByUser := portainer.Registry{
ID: 1,
Name: "registryReachableByUser",
RegistryAccesses: portainer.RegistryAccesses{
portainer.EndpointID(endpointID): {
UserAccessPolicies: map[portainer.UserID]portainer.AccessPolicy{
user.ID: {RoleID: portainer.RoleID(portainer.StandardUserRole)},
},
},
},
}
err = store.Registry().Create(&registryReachableByUser)
assert.NoError(t, err, "couldn't create a registry")
registryReachableByTeam := portainer.Registry{
ID: 2,
Name: "registryReachableByTeam",
RegistryAccesses: portainer.RegistryAccesses{
portainer.EndpointID(endpointID): {
TeamAccessPolicies: map[portainer.TeamID]portainer.AccessPolicy{
team.ID: {RoleID: portainer.RoleID(portainer.StandardUserRole)},
},
},
},
}
err = store.Registry().Create(&registryReachableByTeam)
assert.NoError(t, err, "couldn't create a registry")
registryRestricted := portainer.Registry{
ID: 3,
Name: "registryRestricted",
RegistryAccesses: portainer.RegistryAccesses{
portainer.EndpointID(endpointID): {
UserAccessPolicies: map[portainer.UserID]portainer.AccessPolicy{
user.ID + 100: {RoleID: portainer.RoleID(portainer.StandardUserRole)},
},
},
},
}
err = store.Registry().Create(&registryRestricted)
assert.NoError(t, err, "couldn't create a registry")
t.Run("admin should has access to all registries", func(t *testing.T) {
registries, err := getUserRegistries(store, admin, portainer.EndpointID(endpointID))
assert.NoError(t, err)
assert.ElementsMatch(t, []portainer.Registry{registryReachableByUser, registryReachableByTeam, registryRestricted}, registries)
})
t.Run("regular user has access to registries allowed to him and/or his team", func(t *testing.T) {
registries, err := getUserRegistries(store, user, portainer.EndpointID(endpointID))
assert.NoError(t, err)
assert.ElementsMatch(t, []portainer.Registry{registryReachableByUser, registryReachableByTeam}, registries)
})
}