github.com/rakutentech/cli@v6.12.5-0.20151006231303-24468b65536e+incompatible/cf/commands/space/space_test.go (about)

     1  package space_test
     2  
     3  import (
     4  	"github.com/cloudfoundry/cli/cf/api/space_quotas/fakes"
     5  	"github.com/cloudfoundry/cli/cf/command_registry"
     6  	"github.com/cloudfoundry/cli/cf/configuration/core_config"
     7  	"github.com/cloudfoundry/cli/cf/models"
     8  	"github.com/cloudfoundry/cli/plugin/models"
     9  	testcmd "github.com/cloudfoundry/cli/testhelpers/commands"
    10  	testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
    11  	testreq "github.com/cloudfoundry/cli/testhelpers/requirements"
    12  	testterm "github.com/cloudfoundry/cli/testhelpers/terminal"
    13  	. "github.com/onsi/ginkgo"
    14  	. "github.com/onsi/gomega"
    15  
    16  	. "github.com/cloudfoundry/cli/testhelpers/matchers"
    17  )
    18  
    19  var _ = Describe("space command", func() {
    20  	var (
    21  		ui                  *testterm.FakeUI
    22  		requirementsFactory *testreq.FakeReqFactory
    23  		quotaRepo           *fakes.FakeSpaceQuotaRepository
    24  		configRepo          core_config.Repository
    25  		deps                command_registry.Dependency
    26  	)
    27  
    28  	updateCommandDependency := func(pluginCall bool) {
    29  		deps.Ui = ui
    30  		deps.Config = configRepo
    31  		deps.RepoLocator = deps.RepoLocator.SetSpaceQuotaRepository(quotaRepo)
    32  		command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("space").SetDependency(deps, pluginCall))
    33  	}
    34  
    35  	BeforeEach(func() {
    36  		configRepo = testconfig.NewRepositoryWithDefaults()
    37  		quotaRepo = &fakes.FakeSpaceQuotaRepository{}
    38  		ui = &testterm.FakeUI{}
    39  		requirementsFactory = &testreq.FakeReqFactory{}
    40  
    41  		deps = command_registry.NewDependency()
    42  	})
    43  
    44  	runCommand := func(args ...string) bool {
    45  		return testcmd.RunCliCommand("space", args, requirementsFactory, updateCommandDependency, false)
    46  	}
    47  
    48  	Describe("requirements", func() {
    49  		It("fails when not logged in", func() {
    50  			requirementsFactory.TargetedOrgSuccess = true
    51  
    52  			Expect(runCommand("some-space")).To(BeFalse())
    53  		})
    54  
    55  		It("fails when an org is not targeted", func() {
    56  			requirementsFactory.LoginSuccess = true
    57  
    58  			Expect(runCommand("some-space")).To(BeFalse())
    59  		})
    60  
    61  		It("Shows usage when called incorrectly", func() {
    62  			requirementsFactory.LoginSuccess = true
    63  
    64  			runCommand("some-space", "much")
    65  			Expect(ui.Outputs).To(ContainSubstrings(
    66  				[]string{"Incorrect Usage", "Requires an argument"},
    67  			))
    68  		})
    69  	})
    70  
    71  	Context("when logged in and an org is targeted", func() {
    72  		BeforeEach(func() {
    73  			org := models.OrganizationFields{}
    74  			org.Name = "my-org"
    75  			org.Guid = "my-org-guid"
    76  
    77  			app := models.ApplicationFields{}
    78  			app.Name = "app1"
    79  			app.Guid = "app1-guid"
    80  			apps := []models.ApplicationFields{app}
    81  
    82  			domain := models.DomainFields{}
    83  			domain.Name = "domain1"
    84  			domain.Guid = "domain1-guid"
    85  			domains := []models.DomainFields{domain}
    86  
    87  			serviceInstance := models.ServiceInstanceFields{}
    88  			serviceInstance.Name = "service1"
    89  			serviceInstance.Guid = "service1-guid"
    90  			services := []models.ServiceInstanceFields{serviceInstance}
    91  
    92  			securityGroup1 := models.SecurityGroupFields{Name: "Nacho Security", Rules: []map[string]interface{}{
    93  				{"protocol": "all", "destination": "0.0.0.0-9.255.255.255", "log": true, "IntTest": 1000},
    94  			}}
    95  			securityGroup2 := models.SecurityGroupFields{Name: "Nacho Prime", Rules: []map[string]interface{}{
    96  				{"protocol": "udp", "ports": "8080-9090", "destination": "198.41.191.47/1"},
    97  			}}
    98  			securityGroups := []models.SecurityGroupFields{securityGroup1, securityGroup2}
    99  
   100  			space := models.Space{}
   101  			space.Name = "whose-space-is-it-anyway"
   102  			space.Guid = "whose-space-is-it-anyway-guid"
   103  			space.Organization = org
   104  			space.Applications = apps
   105  			space.Domains = domains
   106  			space.ServiceInstances = services
   107  			space.SecurityGroups = securityGroups
   108  			space.SpaceQuotaGuid = "runaway-guid"
   109  
   110  			quota := models.SpaceQuota{}
   111  			quota.Guid = "runaway-guid"
   112  			quota.Name = "runaway"
   113  			quota.MemoryLimit = 102400
   114  			quota.InstanceMemoryLimit = -1
   115  			quota.RoutesLimit = 111
   116  			quota.ServicesLimit = 222
   117  			quota.NonBasicServicesAllowed = false
   118  
   119  			requirementsFactory.LoginSuccess = true
   120  			requirementsFactory.TargetedOrgSuccess = true
   121  			requirementsFactory.Space = space
   122  
   123  			quotaRepo.FindByGuidReturns(quota, nil)
   124  		})
   125  
   126  		Context("when the guid flag is passed", func() {
   127  			It("shows only the space guid", func() {
   128  				runCommand("--guid", "whose-space-is-it-anyway")
   129  
   130  				Expect(ui.Outputs).To(ContainSubstrings(
   131  					[]string{"whose-space-is-it-anyway-guid"},
   132  				))
   133  
   134  				Expect(ui.Outputs).ToNot(ContainSubstrings(
   135  					[]string{"Getting info for space", "whose-space-is-it-anyway", "my-org", "my-user"},
   136  				))
   137  			})
   138  		})
   139  
   140  		Context("when the security-group-rules flag is passed", func() {
   141  			It("it shows space information and security group rules", func() {
   142  				runCommand("--security-group-rules", "whose-space-is-it-anyway")
   143  
   144  				Expect(ui.Outputs).To(ContainSubstrings(
   145  					[]string{"Getting rules for the security group", "Nacho Security"},
   146  					[]string{"protocol", "all"},
   147  					[]string{"destination", "0.0.0.0-9.255.255.255"},
   148  					[]string{"Getting rules for the security group", "Nacho Prime"},
   149  					[]string{"protocol", "udp"},
   150  					[]string{"log", "true"},
   151  					[]string{"IntTest", "1000"},
   152  					[]string{"ports", "8080-9090"},
   153  					[]string{"destination", "198.41.191.47/1"},
   154  				))
   155  			})
   156  		})
   157  
   158  		Context("when the space has a space quota", func() {
   159  			It("shows information about the given space", func() {
   160  				runCommand("whose-space-is-it-anyway")
   161  				Expect(ui.Outputs).To(ContainSubstrings(
   162  					[]string{"Getting info for space", "whose-space-is-it-anyway", "my-org", "my-user"},
   163  					[]string{"OK"},
   164  					[]string{"whose-space-is-it-anyway"},
   165  					[]string{"Org", "my-org"},
   166  					[]string{"Apps", "app1"},
   167  					[]string{"Domains", "domain1"},
   168  					[]string{"Services", "service1"},
   169  					[]string{"Security Groups", "Nacho Security", "Nacho Prime"},
   170  					[]string{"Space Quota", "runaway (100G memory limit, -1 instance memory limit, 111 routes, 222 services, paid services disallowed)"},
   171  				))
   172  			})
   173  
   174  		})
   175  
   176  		Context("when the space does not have a space quota", func() {
   177  			It("shows information without a space quota", func() {
   178  				requirementsFactory.Space.SpaceQuotaGuid = ""
   179  				runCommand("whose-space-is-it-anyway")
   180  				Expect(quotaRepo.FindByGuidCallCount()).To(Equal(0))
   181  				Expect(ui.Outputs).To(ContainSubstrings(
   182  					[]string{"Getting info for space", "whose-space-is-it-anyway", "my-org", "my-user"},
   183  					[]string{"OK"},
   184  					[]string{"whose-space-is-it-anyway"},
   185  					[]string{"Org", "my-org"},
   186  					[]string{"Apps", "app1"},
   187  					[]string{"Domains", "domain1"},
   188  					[]string{"Services", "service1"},
   189  					[]string{"Security Groups", "Nacho Security", "Nacho Prime"},
   190  					[]string{"Space Quota"},
   191  				))
   192  			})
   193  		})
   194  
   195  		Context("When called as a plugin", func() {
   196  			var (
   197  				pluginModel plugin_models.GetSpace_Model
   198  			)
   199  			BeforeEach(func() {
   200  				pluginModel = plugin_models.GetSpace_Model{}
   201  				deps.PluginModels.Space = &pluginModel
   202  			})
   203  
   204  			It("Fills in the PluginModel", func() {
   205  				testcmd.RunCliCommand("space", []string{"whose-space-is-it-anyway"}, requirementsFactory, updateCommandDependency, true)
   206  				Ω(pluginModel.Name).To(Equal("whose-space-is-it-anyway"))
   207  				Ω(pluginModel.Guid).To(Equal("whose-space-is-it-anyway-guid"))
   208  
   209  				Ω(pluginModel.Organization.Name).To(Equal("my-org"))
   210  				Ω(pluginModel.Organization.Guid).To(Equal("my-org-guid"))
   211  
   212  				Ω(pluginModel.Applications).To(HaveLen(1))
   213  				Ω(pluginModel.Applications[0].Name).To(Equal("app1"))
   214  				Ω(pluginModel.Applications[0].Guid).To(Equal("app1-guid"))
   215  
   216  				Ω(pluginModel.Domains).To(HaveLen(1))
   217  				Ω(pluginModel.Domains[0].Name).To(Equal("domain1"))
   218  				Ω(pluginModel.Domains[0].Guid).To(Equal("domain1-guid"))
   219  
   220  				Ω(pluginModel.ServiceInstances).To(HaveLen(1))
   221  				Ω(pluginModel.ServiceInstances[0].Name).To(Equal("service1"))
   222  				Ω(pluginModel.ServiceInstances[0].Guid).To(Equal("service1-guid"))
   223  
   224  				Ω(pluginModel.SecurityGroups).To(HaveLen(2))
   225  				Ω(pluginModel.SecurityGroups[0].Name).To(Equal("Nacho Security"))
   226  				Ω(pluginModel.SecurityGroups[0].Rules).To(HaveLen(1))
   227  				Ω(pluginModel.SecurityGroups[0].Rules[0]).To(HaveLen(4))
   228  				val := pluginModel.SecurityGroups[0].Rules[0]["protocol"]
   229  				Ω(val).To(Equal("all"))
   230  				val = pluginModel.SecurityGroups[0].Rules[0]["destination"]
   231  				Ω(val).To(Equal("0.0.0.0-9.255.255.255"))
   232  
   233  				Ω(pluginModel.SecurityGroups[1].Name).To(Equal("Nacho Prime"))
   234  				Ω(pluginModel.SecurityGroups[1].Rules).To(HaveLen(1))
   235  				Ω(pluginModel.SecurityGroups[1].Rules[0]).To(HaveLen(3))
   236  				val = pluginModel.SecurityGroups[1].Rules[0]["protocol"]
   237  				Ω(val).To(Equal("udp"))
   238  				val = pluginModel.SecurityGroups[1].Rules[0]["destination"]
   239  				Ω(val).To(Equal("198.41.191.47/1"))
   240  				val = pluginModel.SecurityGroups[1].Rules[0]["ports"]
   241  				Ω(val).To(Equal("8080-9090"))
   242  
   243  				Ω(pluginModel.SpaceQuota.Name).To(Equal("runaway"))
   244  				Ω(pluginModel.SpaceQuota.Guid).To(Equal("runaway-guid"))
   245  				Ω(pluginModel.SpaceQuota.MemoryLimit).To(Equal(int64(102400)))
   246  				Ω(pluginModel.SpaceQuota.InstanceMemoryLimit).To(Equal(int64(-1)))
   247  				Ω(pluginModel.SpaceQuota.RoutesLimit).To(Equal(111))
   248  				Ω(pluginModel.SpaceQuota.ServicesLimit).To(Equal(222))
   249  				Ω(pluginModel.SpaceQuota.NonBasicServicesAllowed).To(BeFalse())
   250  			})
   251  		})
   252  	})
   253  
   254  })