func setupDependencies() (deps *cliDependencies) {
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
deps = new(cliDependencies)
deps.termUI = terminal.NewUI(os.Stdin)
deps.manifestRepo = manifest.NewManifestDiskRepository()
deps.configRepo = configuration.NewRepositoryFromFilepath(configuration.DefaultFilePath(), func(err error) {
if err != nil {
deps.termUI.Failed(fmt.Sprintf("Config error: %s", err))
}
})
deps.apiRepoLocator = api.NewRepositoryLocator(deps.configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(deps.configRepo),
"cloud-controller": net.NewCloudControllerGateway(deps.configRepo),
"uaa": net.NewUAAGateway(deps.configRepo),
})
return
}
func main() {
fileutils.SetTmpPathPrefix("cf")
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
termUI := terminal.NewUI()
assignTemplates()
configRepo := configuration.NewConfigurationDiskRepository()
config := loadConfig(termUI, configRepo)
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(termUI, config, configRepo, repoLocator)
reqFactory := requirements.NewFactory(termUI, config, repoLocator)
cmdRunner := commands.NewRunner(cmdFactory, reqFactory)
app, err := app.NewApp(cmdRunner)
if err != nil {
return
}
app.Run(os.Args)
}
func main() {
defer func() {
maybeSomething := recover()
if maybeSomething != nil {
displayCrashDialog()
}
}()
fileutils.SetTmpPathPrefix("cf")
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
termUI := terminal.NewUI()
configRepo := configuration.NewConfigurationDiskRepository()
config := loadConfig(termUI, configRepo)
manifestRepo := manifest.NewManifestDiskRepository()
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(termUI, config, configRepo, manifestRepo, repoLocator)
reqFactory := requirements.NewFactory(termUI, config, repoLocator)
cmdRunner := commands.NewRunner(cmdFactory, reqFactory)
app, err := app.NewApp(cmdRunner)
if err != nil {
return
}
app.Run(os.Args)
}
func createCommandFactory() command_factory.Factory {
fakeUI := &testterm.FakeUI{}
configRepo := testconfig.NewRepository()
manifestRepo := manifest.NewManifestDiskRepository()
apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(configRepo),
"cloud-controller": net.NewCloudControllerGateway(configRepo),
"uaa": net.NewUAAGateway(configRepo),
})
return command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator)
}
func createUsersRepo(t *testing.T, ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewTLSServer(t, ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewTLSServer(t, uaaReqs)
uaaTarget = uaa.URL
}
org := cf.OrganizationFields{}
org.Guid = "some-org-guid"
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ccTarget,
OrganizationFields: org,
}
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.Endpoint = uaaTarget
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway, endpointRepo)
return
}
func createUsersRepo(t *testing.T, ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewTLSServer(t, ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewTLSServer(t, uaaReqs)
uaaTarget = uaa.URL
}
config := &configuration.Configuration{
AccessToken: "BEARER my_access_token",
Target: ccTarget,
Organization: cf.Organization{Guid: "some-org-guid"},
}
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{GetEndpointEndpoints: map[cf.EndpointType]string{
cf.UaaEndpointKey: uaaTarget,
}}
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway, endpointRepo)
return
}
func setupAuthDependencies(request testnet.TestRequest) (deps authDependencies) {
deps.ts, deps.handler = testnet.NewTLSServer([]testnet.TestRequest{request})
deps.config = testconfig.NewRepository()
deps.config.SetAuthorizationEndpoint(deps.ts.URL)
deps.gateway = net.NewUAAGateway()
return
}
func TestCommands(t *testing.T) {
for _, cmdName := range availableCmdNames() {
ui := &testterm.FakeUI{}
config := &configuration.Configuration{}
configRepo := testconfig.FakeConfigRepository{}
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(ui, config, configRepo, repoLocator)
cmdRunner := &FakeRunner{cmdFactory: cmdFactory, t: t}
app, _ := NewApp(cmdRunner)
app.Run([]string{"", cmdName})
assert.Equal(t, cmdRunner.cmdName, cmdName)
}
}
func findCommand(cmdName string) (cmd cli.Command) {
fakeUI := &testterm.FakeUI{}
configRepo := testconfig.NewRepository()
manifestRepo := manifest.NewManifestDiskRepository()
apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(configRepo),
"cloud-controller": net.NewCloudControllerGateway(configRepo),
"uaa": net.NewUAAGateway(configRepo),
})
cmdFactory := command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator)
requirementsFactory := &testreq.FakeReqFactory{}
cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory)
myApp := app.NewApp(cmdRunner, cmdFactory.CommandMetadatas()...)
for _, cmd := range myApp.Commands {
if cmd.Name == cmdName {
return cmd
}
}
panic(fmt.Sprintf("command %s does not exist", cmdName))
return
}
func setupAuthWithEndpoint(t *testing.T, request testnet.TestRequest) (ts *httptest.Server, handler *testnet.TestHandler, auth UAAAuthenticationRepository) {
ts, handler = testnet.NewTLSServer(t, []testnet.TestRequest{request})
configRepo := testconfig.FakeConfigRepository{}
configRepo.Delete()
config, err := configRepo.Get()
assert.NoError(t, err)
config.AuthorizationEndpoint = ts.URL
config.AccessToken = ""
gateway := net.NewUAAGateway()
auth = NewUAAAuthenticationRepository(gateway, configRepo)
return
}
func createUsersRepo(ccReqs []testnet.TestRequest, uaaReqs []testnet.TestRequest) (cc *httptest.Server,
ccHandler *testnet.TestHandler, uaa *httptest.Server, uaaHandler *testnet.TestHandler, repo UserRepository) {
ccTarget := ""
uaaTarget := ""
if len(ccReqs) > 0 {
cc, ccHandler = testnet.NewServer(ccReqs)
ccTarget = cc.URL
}
if len(uaaReqs) > 0 {
uaa, uaaHandler = testnet.NewServer(uaaReqs)
uaaTarget = uaa.URL
}
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ccTarget)
ccGateway := net.NewCloudControllerGateway(configRepo)
uaaGateway := net.NewUAAGateway(configRepo)
configRepo.SetUaaEndpoint(uaaTarget)
repo = NewCloudControllerUserRepository(configRepo, uaaGateway, ccGateway)
return
}
func NewRepositoryLocator(config *configuration.Configuration) (loc RepositoryLocator) {
loc.config = config
loc.configurationRepo = configuration.NewConfigurationDiskRepository()
authGateway := net.NewUAAAuthGateway()
loc.authenticator = NewUAAAuthenticator(authGateway, loc.configurationRepo)
loc.cloudControllerGateway = net.NewCloudControllerGateway(loc.authenticator)
loc.uaaGateway = net.NewUAAGateway(loc.authenticator)
loc.organizationRepo = NewCloudControllerOrganizationRepository(config, loc.cloudControllerGateway)
loc.spaceRepo = NewCloudControllerSpaceRepository(config, loc.cloudControllerGateway)
loc.appRepo = NewCloudControllerApplicationRepository(config, loc.cloudControllerGateway)
loc.appSummaryRepo = NewCloudControllerAppSummaryRepository(config, loc.cloudControllerGateway, loc.appRepo)
loc.appFilesRepo = NewCloudControllerAppFilesRepository(config, loc.cloudControllerGateway)
loc.domainRepo = NewCloudControllerDomainRepository(config, loc.cloudControllerGateway)
loc.routeRepo = NewCloudControllerRouteRepository(config, loc.cloudControllerGateway)
loc.stackRepo = NewCloudControllerStackRepository(config, loc.cloudControllerGateway)
loc.serviceRepo = NewCloudControllerServiceRepository(config, loc.cloudControllerGateway)
loc.passwordRepo = NewCloudControllerPasswordRepository(config, loc.uaaGateway)
loc.logsRepo = NewLoggregatorLogsRepository(config, loc.cloudControllerGateway, LoggregatorHost)
return
}
"org-users", "orgs", "passwd", "purge-service-offering", "push", "quotas", "rename", "rename-org",
"rename-service", "rename-service-broker", "rename-space", "restart", "routes", "scale",
"service", "service-auth-tokens", "service-brokers", "services", "set-env", "set-org-role", "set-quota",
"set-space-role", "create-shared-domain", "space", "space-users", "spaces", "stacks", "start", "stop",
"target", "unbind-service", "unmap-route", "unset-env", "unset-org-role", "unset-space-role",
"update-buildpack", "update-service-broker", "update-service-auth-token", "update-user-provided-service",
}
var _ = Describe("App", func() {
It("#NewApp", func() {
ui := &testterm.FakeUI{}
config := testconfig.NewRepository()
manifestRepo := &testmanifest.FakeManifestRepository{}
repoLocator := api.NewRepositoryLocator(config, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(ui, config, manifestRepo, repoLocator)
cmdRunner := &FakeRunner{cmdFactory: cmdFactory}
for _, cmdName := range expectedCommandNames {
output := bytes.NewBuffer(make([]byte, 1024))
trace.SetStdout(output)
trace.EnableTrace()
app, err := NewApp(cmdRunner)
Expect(err).NotTo(HaveOccurred())
"net/http"
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("AuthenticationRepository", func() {
var (
gateway net.Gateway
ts *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
)
BeforeEach(func() {
gateway = net.NewUAAGateway()
})
AfterEach(func() {
ts.Close()
})
It("logs in", func() {
ts, handler, config = setupAuthDependencies(successfulLoginRequest)
auth := NewUAAAuthenticationRepository(gateway, config)
apiResponse := auth.Authenticate(map[string]string{
"username": "******",
"password": "******",
})
"net/http/httptest"
testconfig "testhelpers/configuration"
testnet "testhelpers/net"
)
var _ = Describe("AuthenticationRepository", func() {
var (
gateway net.Gateway
testServer *httptest.Server
handler *testnet.TestHandler
config configuration.ReadWriter
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
gateway = net.NewUAAGateway(config)
})
AfterEach(func() {
testServer.Close()
})
It("logs in", func() {
testServer, handler, config = setupAuthDependencies(successfulLoginRequest)
auth := NewUAAAuthenticationRepository(gateway, config)
apiErr := auth.Authenticate(map[string]string{
"username": "******",
"password": "******",
})
_, apiResponse := repo.ListUsersInOrgForRole("my-org-guid", models.ORG_MANAGER)
Expect(ccHandler.AllRequestsCalled()).To(BeTrue())
Expect(apiResponse.StatusCode).To(Equal(http.StatusGatewayTimeout))
})
It("returns an error when the UAA endpoint cannot be determined", func() {
ccReqs, _ := createUsersByRoleEndpoints("/v2/organizations/my-org-guid/managers")
ts, _ := testnet.NewTLSServer(ccReqs)
defer ts.Close()
configRepo := testconfig.NewRepositoryWithDefaults()
configRepo.SetApiEndpoint(ts.URL)
ccGateway := net.NewCloudControllerGateway()
uaaGateway := net.NewUAAGateway()
endpointRepo := &testapi.FakeEndpointRepo{}
endpointRepo.UAAEndpointReturns.ApiResponse = net.NewApiResponseWithError("Failed to get endpoint!", errors.New("Failed!"))
repo := NewCloudControllerUserRepository(configRepo, uaaGateway, ccGateway, endpointRepo)
_, apiResponse := repo.ListUsersInOrgForRole("my-org-guid", models.ORG_MANAGER)
Expect(apiResponse).To(Equal(endpointRepo.UAAEndpointReturns.ApiResponse))
})
})
It("TestFindByUsername", func() {
usersResponse := `{ "resources": [{ "id": "my-guid", "userName": "******" }]}`
uaaReq := testapi.NewCloudControllerTestRequest(testnet.TestRequest{
Method: "GET",
)
var _ = Describe("User Repository", func() {
var (
ccServer *httptest.Server
ccHandler *testnet.TestHandler
uaaServer *httptest.Server
uaaHandler *testnet.TestHandler
repo UserRepository
config configuration.ReadWriter
)
BeforeEach(func() {
config = testconfig.NewRepositoryWithDefaults()
ccGateway := net.NewCloudControllerGateway(config)
uaaGateway := net.NewUAAGateway(config)
repo = NewCloudControllerUserRepository(config, uaaGateway, ccGateway)
})
AfterEach(func() {
if uaaServer != nil {
uaaServer.Close()
}
if ccServer != nil {
ccServer.Close()
}
})
setupCCServer := func(requests ...testnet.TestRequest) {
ccServer, ccHandler = testnet.NewServer(requests)
config.SetApiEndpoint(ccServer.URL)
"rename-service", "rename-service-broker", "rename-space", "restart", "routes", "scale",
"service", "service-auth-tokens", "service-brokers", "services", "set-env", "set-org-role",
"set-space-role", "create-shared-domain", "space", "space-users", "spaces", "stacks", "start", "stop",
"target", "unbind-service", "unmap-route", "unset-env", "unset-org-role", "unset-space-role",
"update-buildpack", "update-service-broker", "update-service-auth-token", "update-user-provided-service",
"quotas", "create-quota", "delete-quota", "quota", "set-quota",
}
var _ = Describe("App", func() {
It("#NewApp", func() {
ui := &testterm.FakeUI{}
config := testconfig.NewRepository()
manifestRepo := &testmanifest.FakeManifestRepository{}
repoLocator := api.NewRepositoryLocator(config, map[string]net.Gateway{
"auth": net.NewUAAGateway(config),
"cloud-controller": net.NewCloudControllerGateway(config),
"uaa": net.NewUAAGateway(config),
})
cmdFactory := command_factory.NewFactory(ui, config, manifestRepo, repoLocator)
metadatas := []command_metadata.CommandMetadata{}
for _, cmdName := range expectedCommandNames {
metadatas = append(metadatas, command_metadata.CommandMetadata{Name: cmdName})
}
for _, cmdName := range expectedCommandNames {
cmdRunner := &FakeRunner{cmdFactory: cmdFactory}
output := bytes.NewBuffer(make([]byte, 1024))
trace.SetStdout(output)