← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charm.v6-unstable/meta_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/juju/charm.v6-unstable/meta_test.go
13
13
        "strings"
14
14
 
15
15
        jc "github.com/juju/testing/checkers"
 
16
        "github.com/juju/version"
16
17
        gc "gopkg.in/check.v1"
17
18
        "gopkg.in/yaml.v1"
 
19
        yamlv2 "gopkg.in/yaml.v2"
18
20
 
19
21
        "gopkg.in/juju/charm.v6-unstable"
20
22
        "gopkg.in/juju/charm.v6-unstable/resource"
220
222
        c.Assert(meta.Peers, gc.IsNil)
221
223
}
222
224
 
 
225
func (s *MetaSuite) TestCombinedRelations(c *gc.C) {
 
226
        meta, err := charm.ReadMeta(repoMeta(c, "riak"))
 
227
        c.Assert(err, gc.IsNil)
 
228
        combinedRelations := meta.CombinedRelations()
 
229
        expectedLength := len(meta.Provides) + len(meta.Requires) + len(meta.Peers)
 
230
        c.Assert(combinedRelations, gc.HasLen, expectedLength)
 
231
        c.Assert(combinedRelations, jc.DeepEquals, map[string]charm.Relation{
 
232
                "endpoint": {
 
233
                        Name:      "endpoint",
 
234
                        Role:      charm.RoleProvider,
 
235
                        Interface: "http",
 
236
                        Scope:     charm.ScopeGlobal,
 
237
                },
 
238
                "admin": {
 
239
                        Name:      "admin",
 
240
                        Role:      charm.RoleProvider,
 
241
                        Interface: "http",
 
242
                        Scope:     charm.ScopeGlobal,
 
243
                },
 
244
                "ring": {
 
245
                        Name:      "ring",
 
246
                        Role:      charm.RolePeer,
 
247
                        Interface: "riak",
 
248
                        Limit:     1,
 
249
                        Scope:     charm.ScopeGlobal,
 
250
                },
 
251
        })
 
252
}
 
253
 
223
254
var relationsConstraintsTests = []struct {
224
255
        rels string
225
256
        err  string
301
332
// for testing valid and invalid series.
302
333
const dummyMetadata = "name: a\nsummary: b\ndescription: c"
303
334
 
304
 
// TestSeries ensures that valid series values are parsed correctly when specified
305
 
// in the charm metadata.
306
335
func (s *MetaSuite) TestSeries(c *gc.C) {
307
336
        // series not specified
308
337
        meta, err := charm.ReadMeta(strings.NewReader(dummyMetadata))
317
346
        c.Assert(meta.Series, gc.DeepEquals, []string{"precise", "trusty", "plan9"})
318
347
}
319
348
 
320
 
// TestInvalidSeries ensures that invalid series values cause a parse error
321
 
// when specified in the charm metadata.
322
349
func (s *MetaSuite) TestInvalidSeries(c *gc.C) {
323
350
        for _, seriesName := range []string{"pre-c1se", "pre^cise", "cp/m", "OpenVMS"} {
324
351
                _, err := charm.ReadMeta(strings.NewReader(
328
355
        }
329
356
}
330
357
 
 
358
func (s *MetaSuite) TestMinJujuVersion(c *gc.C) {
 
359
        // series not specified
 
360
        meta, err := charm.ReadMeta(strings.NewReader(dummyMetadata))
 
361
        c.Assert(err, gc.IsNil)
 
362
        c.Check(meta.Series, gc.HasLen, 0)
 
363
        charmMeta := fmt.Sprintf("%s\nmin-juju-version: ", dummyMetadata)
 
364
        vals := []version.Number{
 
365
                {Major: 1, Minor: 25},
 
366
                {Major: 1, Minor: 25, Tag: "alpha1"},
 
367
                {Major: 1, Minor: 25, Patch: 1},
 
368
        }
 
369
        for _, ver := range vals {
 
370
                val := charmMeta + ver.String()
 
371
                meta, err = charm.ReadMeta(strings.NewReader(val))
 
372
                c.Assert(err, gc.IsNil)
 
373
                c.Assert(meta.MinJujuVersion, gc.Equals, ver)
 
374
        }
 
375
}
 
376
 
 
377
func (s *MetaSuite) TestInvalidMinJujuVersion(c *gc.C) {
 
378
        _, err := charm.ReadMeta(strings.NewReader(dummyMetadata + "\nmin-juju-version: invalid-version"))
 
379
 
 
380
        c.Check(err, gc.ErrorMatches, `invalid min-juju-version: invalid version "invalid-version"`)
 
381
}
 
382
 
 
383
func (s *MetaSuite) TestNoMinJujuVersion(c *gc.C) {
 
384
        meta, err := charm.ReadMeta(strings.NewReader(dummyMetadata))
 
385
        c.Assert(err, jc.ErrorIsNil)
 
386
        c.Check(meta.MinJujuVersion, gc.Equals, version.Zero)
 
387
}
 
388
 
331
389
func (s *MetaSuite) TestCheckMismatchedRelationName(c *gc.C) {
332
390
        // This  Check case cannot be covered by the above
333
391
        // TestRelationsConstraints tests.
365
423
        c.Assert(err, gc.ErrorMatches, `charm "foo" has mismatched relation name ""; expected "foo"`)
366
424
}
367
425
 
 
426
func (s *MetaSuite) TestCheckMismatchedExtraBindingName(c *gc.C) {
 
427
        meta := charm.Meta{
 
428
                Name: "foo",
 
429
                ExtraBindings: map[string]charm.ExtraBinding{
 
430
                        "foo": {Name: "bar"},
 
431
                },
 
432
        }
 
433
        err := meta.Check()
 
434
        c.Assert(err, gc.ErrorMatches, `charm "foo" has invalid extra bindings: mismatched extra binding name: got "bar", expected "foo"`)
 
435
}
 
436
 
 
437
func (s *MetaSuite) TestCheckEmptyNameKeyOrEmptyExtraBindingName(c *gc.C) {
 
438
        meta := charm.Meta{
 
439
                Name:          "foo",
 
440
                ExtraBindings: map[string]charm.ExtraBinding{"": {Name: "bar"}},
 
441
        }
 
442
        err := meta.Check()
 
443
        expectedError := `charm "foo" has invalid extra bindings: missing binding name`
 
444
        c.Assert(err, gc.ErrorMatches, expectedError)
 
445
 
 
446
        meta.ExtraBindings = map[string]charm.ExtraBinding{"bar": {Name: ""}}
 
447
        err = meta.Check()
 
448
        c.Assert(err, gc.ErrorMatches, expectedError)
 
449
}
 
450
 
368
451
// Test rewriting of a given interface specification into long form.
369
452
//
370
453
// InterfaceExpander uses `coerce` to do one of two things:
498
581
                                Scope:     "quxxx",
499
582
                        },
500
583
                },
 
584
                ExtraBindings: map[string]charm.ExtraBinding{
 
585
                        "foo": {Name: "foo"},
 
586
                        "qux": {Name: "qux"},
 
587
                },
501
588
                Categories:  []string{"quxxxx", "quxxxxx"},
502
589
                Tags:        []string{"openstack", "storage"},
503
590
                Format:      10,
604
691
    peerLessSimple:
605
692
        interface: peery
606
693
        optional: true
 
694
extra-bindings:
 
695
    extraBar:
 
696
    extraFoo1:
607
697
categories: [c1, c1]
608
698
tags: [t1, t2]
609
699
series:
624
714
        }
625
715
}
626
716
 
627
 
func (s *MetaSuite) TestYAMLMarshalSimpleRelation(c *gc.C) {
628
 
        // Check that a simple relation gets marshaled as a string.
 
717
func (s *MetaSuite) TestYAMLMarshalV2(c *gc.C) {
 
718
        for i, test := range metaYAMLMarshalTests {
 
719
                c.Logf("test %d: %s", i, test.about)
 
720
                ch, err := charm.ReadMeta(strings.NewReader(test.yaml))
 
721
                c.Assert(err, gc.IsNil)
 
722
                gotYAML, err := yamlv2.Marshal(ch)
 
723
                c.Assert(err, gc.IsNil)
 
724
                gotCh, err := charm.ReadMeta(bytes.NewReader(gotYAML))
 
725
                c.Assert(err, gc.IsNil)
 
726
                c.Assert(gotCh, jc.DeepEquals, ch)
 
727
        }
 
728
}
 
729
 
 
730
func (s *MetaSuite) TestYAMLMarshalSimpleRelationOrExtraBinding(c *gc.C) {
 
731
        // Check that a simple relation / extra-binding gets marshaled as a string.
629
732
        chYAML := `
630
733
name: minimal
631
734
description: d
636
739
    client: http
637
740
peers:
638
741
     me: http
 
742
extra-bindings:
 
743
     foo:
639
744
`
640
745
        ch, err := charm.ReadMeta(strings.NewReader(chYAML))
641
746
        c.Assert(err, gc.IsNil)
658
763
                "peers": map[interface{}]interface{}{
659
764
                        "me": "http",
660
765
                },
 
766
                "extra-bindings": map[interface{}]interface{}{
 
767
                        "foo": nil,
 
768
                },
661
769
        })
662
770
}
663
771
 
827
935
        c.Assert(store.Properties, jc.SameContents, []string{"transient"})
828
936
}
829
937
 
 
938
func (s *MetaSuite) TestExtraBindings(c *gc.C) {
 
939
        meta, err := charm.ReadMeta(strings.NewReader(`
 
940
name: a
 
941
summary: b
 
942
description: c
 
943
extra-bindings:
 
944
    endpoint-1:
 
945
    foo:
 
946
    bar-42:
 
947
`))
 
948
        c.Assert(err, gc.IsNil)
 
949
        c.Assert(meta.ExtraBindings, gc.DeepEquals, map[string]charm.ExtraBinding{
 
950
                "endpoint-1": {
 
951
                        Name: "endpoint-1",
 
952
                },
 
953
                "foo": {
 
954
                        Name: "foo",
 
955
                },
 
956
                "bar-42": {
 
957
                        Name: "bar-42",
 
958
                },
 
959
        })
 
960
}
 
961
 
 
962
func (s *MetaSuite) TestExtraBindingsEmptyMapError(c *gc.C) {
 
963
        meta, err := charm.ReadMeta(strings.NewReader(`
 
964
name: a
 
965
summary: b
 
966
description: c
 
967
extra-bindings:
 
968
`))
 
969
        c.Assert(err, gc.ErrorMatches, "metadata: extra-bindings: expected map, got nothing")
 
970
        c.Assert(meta, gc.IsNil)
 
971
}
 
972
 
 
973
func (s *MetaSuite) TestExtraBindingsNonEmptyValueError(c *gc.C) {
 
974
        meta, err := charm.ReadMeta(strings.NewReader(`
 
975
name: a
 
976
summary: b
 
977
description: c
 
978
extra-bindings:
 
979
    foo: 42
 
980
`))
 
981
        c.Assert(err, gc.ErrorMatches, `metadata: extra-bindings.foo: expected empty value, got int\(42\)`)
 
982
        c.Assert(meta, gc.IsNil)
 
983
}
 
984
 
 
985
func (s *MetaSuite) TestExtraBindingsEmptyNameError(c *gc.C) {
 
986
        meta, err := charm.ReadMeta(strings.NewReader(`
 
987
name: a
 
988
summary: b
 
989
description: c
 
990
extra-bindings:
 
991
    "":
 
992
`))
 
993
        c.Assert(err, gc.ErrorMatches, `metadata: extra-bindings: expected non-empty binding name, got string\(""\)`)
 
994
        c.Assert(meta, gc.IsNil)
 
995
}
 
996
 
830
997
func (s *MetaSuite) TestPayloadClasses(c *gc.C) {
831
998
        meta, err := charm.ReadMeta(strings.NewReader(`
832
999
name: a