← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/application/application_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/application/application_test.go
7
7
        "fmt"
8
8
        "io"
9
9
        "regexp"
10
 
        "runtime"
11
10
        "sync"
12
11
        "time"
13
12
 
24
23
        "gopkg.in/mgo.v2"
25
24
 
26
25
        "github.com/juju/juju/apiserver/application"
 
26
        "github.com/juju/juju/apiserver/common"
27
27
        commontesting "github.com/juju/juju/apiserver/common/testing"
28
28
        "github.com/juju/juju/apiserver/params"
29
29
        apiservertesting "github.com/juju/juju/apiserver/testing"
51
51
 
52
52
var _ = gc.Suite(&serviceSuite{})
53
53
 
54
 
var _ application.Application = (*application.API)(nil)
55
 
 
56
54
func (s *serviceSuite) SetUpSuite(c *gc.C) {
57
55
        s.CharmStoreSuite.SetUpSuite(c)
58
56
        s.JujuConnSuite.SetUpSuite(c)
76
74
                Tag: s.AdminUserTag(c),
77
75
        }
78
76
        var err error
79
 
        s.applicationAPI, err = application.NewAPI(s.State, nil, s.authorizer)
 
77
        backend := application.NewStateBackend(s.State)
 
78
        blockChecker := common.NewBlockChecker(s.State)
 
79
        s.applicationAPI, err = application.NewAPI(
 
80
                backend, s.authorizer, blockChecker,
 
81
                application.CharmToStateCharm,
 
82
        )
80
83
        c.Assert(err, jc.ErrorIsNil)
81
84
}
82
85
 
170
173
                "title":    "foobar",
171
174
                "username": "",
172
175
        }
173
 
        settings, err := application.ParseSettingsCompatible(ch, options)
 
176
        settings, err := application.ParseSettingsCompatible(ch.Config(), options)
174
177
        c.Assert(err, jc.ErrorIsNil)
175
178
        c.Assert(settings, gc.DeepEquals, charm.Settings{
176
179
                "title":    "foobar",
181
184
        options = map[string]string{
182
185
                "yummy": "didgeridoo",
183
186
        }
184
 
        _, err = application.ParseSettingsCompatible(ch, options)
 
187
        _, err = application.ParseSettingsCompatible(ch.Config(), options)
185
188
        c.Assert(err, gc.ErrorMatches, `unknown option "yummy"`)
186
189
}
187
190
 
503
506
}
504
507
 
505
508
func (s *serviceSuite) TestAddCharmConcurrently(c *gc.C) {
506
 
        if runtime.GOOS == "windows" {
507
 
                c.Skip("bug 1596960: Skipping this on windows for now")
508
 
        }
 
509
        c.Skip("see lp:1596960 -- bad test for bad code")
 
510
 
509
511
        var putBarrier sync.WaitGroup
510
512
        var blobs blobs
511
513
        s.PatchValue(application.NewStateStorage, func(uuid string, session *mgo.Session) statestorage.Storage {
795
797
                CharmUrl:        curl.String(),
796
798
                ForceSeries:     true,
797
799
        })
798
 
        c.Assert(err, gc.ErrorMatches, "cannot change a service's series")
 
800
        c.Assert(err, gc.ErrorMatches, `cannot upgrade application "application" to charm "cs:~who/trusty/dummy-1": cannot change an application's series`)
799
801
}
800
802
 
801
803
func (s *serviceSuite) TestServiceSetCharmUnsupportedSeries(c *gc.C) {
823
825
                ApplicationName: "application",
824
826
                CharmUrl:        curl.String(),
825
827
        })
826
 
        c.Assert(err, gc.ErrorMatches, "cannot upgrade charm, only these series are supported: trusty, wily")
 
828
        c.Assert(err, gc.ErrorMatches, `cannot upgrade application "application" to charm "cs:~who/multi-series-1": only these series are supported: trusty, wily`)
827
829
}
828
830
 
829
831
func (s *serviceSuite) assertServiceSetCharmSeries(c *gc.C, upgradeCharm, series string) {
899
901
                CharmUrl:        curl.String(),
900
902
                ForceSeries:     true,
901
903
        })
902
 
        c.Assert(err, gc.ErrorMatches, `cannot upgrade charm, OS "Ubuntu" not supported by charm`)
 
904
        c.Assert(err, gc.ErrorMatches, `cannot upgrade application "application" to charm "cs:~who/multi-series-windows-0": OS "Ubuntu" not supported by charm`)
903
905
}
904
906
 
905
907
type testModeCharmRepo struct {
1356
1358
        application := s.AddTestingService(c, "dummy", s.AddTestingCharm(c, "dummy"))
1357
1359
 
1358
1360
        // Update constraints for the application.
1359
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
1361
        cons, err := constraints.Parse("mem=4096", "cores=2")
1360
1362
        c.Assert(err, jc.ErrorIsNil)
1361
1363
        args := params.ApplicationUpdate{
1362
1364
                ApplicationName: "dummy",
1381
1383
 
1382
1384
        // Update all the service attributes.
1383
1385
        minUnits := 3
1384
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
1386
        cons, err := constraints.Parse("mem=4096", "cores=2")
1385
1387
        c.Assert(err, jc.ErrorIsNil)
1386
1388
        args := params.ApplicationUpdate{
1387
1389
                ApplicationName: "application",
2073
2075
                c.Assert(err, jc.ErrorIsNil)
2074
2076
                now := time.Now()
2075
2077
                sInfo := status.StatusInfo{
2076
 
                        Status:  status.StatusIdle,
 
2078
                        Status:  status.Idle,
2077
2079
                        Message: "",
2078
2080
                        Since:   &now,
2079
2081
                }
2156
2158
                c.Assert(err, jc.ErrorIsNil)
2157
2159
                now := time.Now()
2158
2160
                sInfo := status.StatusInfo{
2159
 
                        Status:  status.StatusIdle,
 
2161
                        Status:  status.Idle,
2160
2162
                        Message: "",
2161
2163
                        Since:   &now,
2162
2164
                }
2325
2327
        application := s.AddTestingService(c, "dummy", s.AddTestingCharm(c, "dummy"))
2326
2328
 
2327
2329
        // Update constraints for the application.
2328
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
2330
        cons, err := constraints.Parse("mem=4096", "cores=2")
2329
2331
        c.Assert(err, jc.ErrorIsNil)
2330
2332
        err = s.applicationAPI.SetConstraints(params.SetConstraints{ApplicationName: "dummy", Constraints: cons})
2331
2333
        c.Assert(err, jc.ErrorIsNil)
2339
2341
func (s *serviceSuite) setupSetServiceConstraints(c *gc.C) (*state.Application, constraints.Value) {
2340
2342
        application := s.AddTestingService(c, "dummy", s.AddTestingCharm(c, "dummy"))
2341
2343
        // Update constraints for the application.
2342
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
2344
        cons, err := constraints.Parse("mem=4096", "cores=2")
2343
2345
        c.Assert(err, jc.ErrorIsNil)
2344
2346
        return application, cons
2345
2347
}
2380
2382
        application := s.AddTestingService(c, "dummy", s.AddTestingCharm(c, "dummy"))
2381
2383
 
2382
2384
        // Set constraints for the application.
2383
 
        cons, err := constraints.Parse("mem=4096", "cpu-cores=2")
 
2385
        cons, err := constraints.Parse("mem=4096", "cores=2")
2384
2386
        c.Assert(err, jc.ErrorIsNil)
2385
2387
        err = application.SetConstraints(cons)
2386
2388
        c.Assert(err, jc.ErrorIsNil)