309 lines
9.8 KiB
Go
309 lines
9.8 KiB
Go
package org_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/influxdata/influx-cli/v2/api"
|
|
"github.com/influxdata/influx-cli/v2/clients"
|
|
"github.com/influxdata/influx-cli/v2/clients/org"
|
|
"github.com/influxdata/influx-cli/v2/internal/mock"
|
|
"github.com/influxdata/influx-cli/v2/internal/testutils"
|
|
"github.com/stretchr/testify/assert"
|
|
tmock "github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
var id = "1111111111111111"
|
|
|
|
func TestClient_Create(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
name string
|
|
params org.CreateParams
|
|
registerExpectations func(*testing.T, *mock.MockOrganizationsApi)
|
|
outLine string
|
|
}{
|
|
{
|
|
name: "name only",
|
|
params: org.CreateParams{
|
|
Name: "my-org",
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().PostOrgs(gomock.Any()).Return(api.ApiPostOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().PostOrgsExecute(tmock.MatchedBy(func(in api.ApiPostOrgsRequest) bool {
|
|
body := in.GetPostOrganizationRequest()
|
|
return assert.NotNil(t, body) &&
|
|
assert.Equal(t, "my-org", body.GetName()) &&
|
|
assert.Nil(t, body.Description)
|
|
})).Return(api.Organization{Name: "my-org", Id: api.PtrString("123")}, nil)
|
|
},
|
|
outLine: `123\s+my-org`,
|
|
},
|
|
{
|
|
name: "with description",
|
|
params: org.CreateParams{
|
|
Name: "my-org",
|
|
Description: "my cool new org",
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().PostOrgs(gomock.Any()).Return(api.ApiPostOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().PostOrgsExecute(tmock.MatchedBy(func(in api.ApiPostOrgsRequest) bool {
|
|
body := in.GetPostOrganizationRequest()
|
|
return assert.NotNil(t, body) &&
|
|
assert.Equal(t, "my-org", body.GetName()) &&
|
|
assert.Equal(t, "my cool new org", body.GetDescription())
|
|
})).Return(api.Organization{
|
|
Name: "my-org",
|
|
Id: api.PtrString("123"),
|
|
Description: api.PtrString("my cool new org"),
|
|
}, nil)
|
|
},
|
|
outLine: `123\s+my-org`,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctrl := gomock.NewController(t)
|
|
api := mock.NewMockOrganizationsApi(ctrl)
|
|
if tc.registerExpectations != nil {
|
|
tc.registerExpectations(t, api)
|
|
}
|
|
|
|
stdout := bytes.Buffer{}
|
|
stdio := mock.NewMockStdIO(ctrl)
|
|
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
|
|
|
|
cli := org.Client{CLI: clients.CLI{StdIO: stdio}, OrganizationsApi: api}
|
|
require.NoError(t, cli.Create(context.Background(), &tc.params))
|
|
testutils.MatchLines(t, []string{`ID\s+Name`, tc.outLine}, strings.Split(stdout.String(), "\n"))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClient_Delete(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
name string
|
|
notFound bool
|
|
}{
|
|
{
|
|
name: "delete existing",
|
|
},
|
|
{
|
|
name: "delete non-existing",
|
|
notFound: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctrl := gomock.NewController(t)
|
|
orgApi := mock.NewMockOrganizationsApi(ctrl)
|
|
|
|
stdout := bytes.Buffer{}
|
|
stdio := mock.NewMockStdIO(ctrl)
|
|
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
|
|
|
|
cli := org.Client{CLI: clients.CLI{StdIO: stdio}, OrganizationsApi: orgApi}
|
|
|
|
getReq := api.ApiGetOrgsIDRequest{ApiService: orgApi}.OrgID(id)
|
|
orgApi.EXPECT().GetOrgsID(gomock.Any(), gomock.Eq(id)).Return(getReq)
|
|
orgApi.EXPECT().GetOrgsIDExecute(gomock.Eq(getReq)).
|
|
DoAndReturn(func(request api.ApiGetOrgsIDRequest) (api.Organization, error) {
|
|
if tc.notFound {
|
|
return api.Organization{}, &api.Error{Code: api.ERRORCODE_NOT_FOUND}
|
|
}
|
|
return api.Organization{Id: api.PtrString(id), Name: "my-org"}, nil
|
|
})
|
|
|
|
if tc.notFound {
|
|
require.Error(t, cli.Delete(context.Background(), id))
|
|
require.Empty(t, stdout.String())
|
|
return
|
|
}
|
|
|
|
delReq := api.ApiDeleteOrgsIDRequest{ApiService: orgApi}.OrgID(id)
|
|
orgApi.EXPECT().DeleteOrgsID(gomock.Any(), gomock.Eq(id)).Return(delReq)
|
|
orgApi.EXPECT().DeleteOrgsIDExecute(gomock.Eq(delReq)).Return(nil)
|
|
|
|
require.NoError(t, cli.Delete(context.Background(), id))
|
|
testutils.MatchLines(t, []string{
|
|
`ID\s+Name\s+Deleted`,
|
|
`1111111111111111\s+my-org\s+true`,
|
|
}, strings.Split(stdout.String(), "\n"))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClient_List(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
name string
|
|
params org.ListParams
|
|
registerExpectations func(*testing.T, *mock.MockOrganizationsApi)
|
|
outLines []string
|
|
}{
|
|
{
|
|
name: "no results",
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().GetOrgs(gomock.Any()).Return(api.ApiGetOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().GetOrgsExecute(gomock.Any()).Return(api.Organizations{}, nil)
|
|
},
|
|
},
|
|
{
|
|
name: "many results",
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().GetOrgs(gomock.Any()).Return(api.ApiGetOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().GetOrgsExecute(gomock.Any()).Return(api.Organizations{
|
|
Orgs: &[]api.Organization{
|
|
{Id: api.PtrString("123"), Name: "org1"},
|
|
{Id: api.PtrString("456"), Name: "org2"},
|
|
},
|
|
}, nil)
|
|
},
|
|
outLines: []string{`123\s+org1`, `456\s+org2`},
|
|
},
|
|
{
|
|
name: "by name",
|
|
params: org.ListParams{
|
|
OrgParams: clients.OrgParams{OrgName: "org1"},
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().GetOrgs(gomock.Any()).Return(api.ApiGetOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().GetOrgsExecute(tmock.MatchedBy(func(in api.ApiGetOrgsRequest) bool {
|
|
return assert.Equal(t, "org1", *in.GetOrg()) && assert.Nil(t, in.GetOrgID())
|
|
})).Return(api.Organizations{
|
|
Orgs: &[]api.Organization{
|
|
{Id: api.PtrString("123"), Name: "org1"},
|
|
},
|
|
}, nil)
|
|
},
|
|
outLines: []string{`123\s+org1`},
|
|
},
|
|
{
|
|
name: "by ID",
|
|
params: org.ListParams{
|
|
OrgParams: clients.OrgParams{OrgID: id},
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().GetOrgs(gomock.Any()).Return(api.ApiGetOrgsRequest{ApiService: orgApi})
|
|
orgApi.EXPECT().GetOrgsExecute(tmock.MatchedBy(func(in api.ApiGetOrgsRequest) bool {
|
|
return assert.Nil(t, in.GetOrg()) && assert.Equal(t, id, *in.GetOrgID())
|
|
})).Return(api.Organizations{
|
|
Orgs: &[]api.Organization{
|
|
{Id: api.PtrString(id), Name: "org3"},
|
|
},
|
|
}, nil)
|
|
},
|
|
outLines: []string{fmt.Sprintf(`%s\s+org3`, id)},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctrl := gomock.NewController(t)
|
|
orgApi := mock.NewMockOrganizationsApi(ctrl)
|
|
if tc.registerExpectations != nil {
|
|
tc.registerExpectations(t, orgApi)
|
|
}
|
|
stdout := bytes.Buffer{}
|
|
stdio := mock.NewMockStdIO(ctrl)
|
|
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
|
|
|
|
cli := org.Client{CLI: clients.CLI{StdIO: stdio}, OrganizationsApi: orgApi}
|
|
require.NoError(t, cli.List(context.Background(), &tc.params))
|
|
testutils.MatchLines(t, append([]string{`ID\s+Name`}, tc.outLines...), strings.Split(stdout.String(), "\n"))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClient_Update(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
name string
|
|
params org.UpdateParams
|
|
registerExpectations func(*testing.T, *mock.MockOrganizationsApi)
|
|
outLine string
|
|
}{
|
|
{
|
|
name: "name",
|
|
params: org.UpdateParams{
|
|
OrgParams: clients.OrgParams{
|
|
OrgID: id,
|
|
OrgName: "my-org",
|
|
},
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().PatchOrgsID(gomock.Any(), gomock.Eq(id)).
|
|
Return(api.ApiPatchOrgsIDRequest{ApiService: orgApi}.OrgID(id))
|
|
orgApi.EXPECT().PatchOrgsIDExecute(tmock.MatchedBy(func(in api.ApiPatchOrgsIDRequest) bool {
|
|
body := in.GetPatchOrganizationRequest()
|
|
return assert.Equal(t, id, in.GetOrgID()) &&
|
|
assert.NotNil(t, body) &&
|
|
assert.Equal(t, "my-org", body.GetName()) &&
|
|
assert.Nil(t, body.Description)
|
|
})).Return(api.Organization{Id: api.PtrString(id), Name: "my-org"}, nil)
|
|
},
|
|
outLine: fmt.Sprintf(`%s\s+my-org`, id),
|
|
},
|
|
{
|
|
name: "description",
|
|
params: org.UpdateParams{
|
|
OrgParams: clients.OrgParams{OrgID: id},
|
|
Description: "my cool org",
|
|
},
|
|
registerExpectations: func(t *testing.T, orgApi *mock.MockOrganizationsApi) {
|
|
orgApi.EXPECT().PatchOrgsID(gomock.Any(), gomock.Eq(id)).
|
|
Return(api.ApiPatchOrgsIDRequest{ApiService: orgApi}.OrgID(id))
|
|
orgApi.EXPECT().PatchOrgsIDExecute(tmock.MatchedBy(func(in api.ApiPatchOrgsIDRequest) bool {
|
|
body := in.GetPatchOrganizationRequest()
|
|
return assert.Equal(t, id, in.GetOrgID()) &&
|
|
assert.NotNil(t, body) &&
|
|
assert.Nil(t, body.Name) &&
|
|
assert.Equal(t, "my cool org", body.GetDescription())
|
|
})).Return(api.Organization{Id: api.PtrString(id), Name: "my-org"}, nil)
|
|
},
|
|
outLine: fmt.Sprintf(`%s\s+my-org`, id),
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctrl := gomock.NewController(t)
|
|
orgApi := mock.NewMockOrganizationsApi(ctrl)
|
|
if tc.registerExpectations != nil {
|
|
tc.registerExpectations(t, orgApi)
|
|
}
|
|
stdout := bytes.Buffer{}
|
|
stdio := mock.NewMockStdIO(ctrl)
|
|
stdio.EXPECT().Write(gomock.Any()).DoAndReturn(stdout.Write).AnyTimes()
|
|
|
|
cli := org.Client{CLI: clients.CLI{StdIO: stdio}, OrganizationsApi: orgApi}
|
|
require.NoError(t, cli.Update(context.Background(), &tc.params))
|
|
testutils.MatchLines(t, []string{`ID\s+Name`, tc.outLine}, strings.Split(stdout.String(), "\n"))
|
|
})
|
|
}
|
|
}
|