← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/names.v2/relation_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/juju/names.v2/relation_test.go
 
1
// Copyright 2013 Canonical Ltd.
 
2
// Licensed under the LGPLv3, see LICENCE file for details.
 
3
 
 
4
package names_test
 
5
 
 
6
import (
 
7
        gc "gopkg.in/check.v1"
 
8
 
 
9
        "gopkg.in/juju/names.v2"
 
10
)
 
11
 
 
12
type relationSuite struct{}
 
13
 
 
14
var _ = gc.Suite(&relationSuite{})
 
15
 
 
16
var relationNameTests = []struct {
 
17
        pattern string
 
18
        valid   bool
 
19
}{
 
20
        {pattern: "", valid: false},
 
21
        {pattern: "0foo", valid: false},
 
22
        {pattern: "foo", valid: true},
 
23
        {pattern: "f1-boo", valid: true},
 
24
        {pattern: "f-o-o", valid: true},
 
25
        {pattern: "-foo", valid: false},
 
26
        {pattern: "fo#o", valid: false},
 
27
        {pattern: "foo-42", valid: true},
 
28
        {pattern: "FooBar", valid: false},
 
29
        {pattern: "foo42-bar1", valid: true},
 
30
        {pattern: "42", valid: false},
 
31
        {pattern: "0", valid: false},
 
32
        {pattern: "%not", valid: false},
 
33
        {pattern: "42also-not", valid: false},
 
34
        {pattern: "042", valid: false},
 
35
        {pattern: "0x42", valid: false},
 
36
        {pattern: "foo_42", valid: true},
 
37
        {pattern: "_foo", valid: false},
 
38
        {pattern: "!foo", valid: false},
 
39
        {pattern: "foo_bar-baz_boo", valid: true},
 
40
        {pattern: "foo bar", valid: false},
 
41
        {pattern: "foo-_", valid: false},
 
42
        {pattern: "foo-", valid: false},
 
43
        {pattern: "foo_-a", valid: false},
 
44
        {pattern: "foo_", valid: false},
 
45
}
 
46
 
 
47
func (s *relationSuite) TestRelationKeyFormats(c *gc.C) {
 
48
        // In order to test all possible combinations, we need
 
49
        // to use the relationNameTests and applicationNameTests
 
50
        // twice to construct all possible keys.
 
51
        for i, testRel := range relationNameTests {
 
52
                for j, testSvc := range applicationNameTests {
 
53
                        peerKey := testSvc.pattern + ":" + testRel.pattern
 
54
                        key := peerKey + " " + peerKey
 
55
                        isValid := testSvc.valid && testRel.valid
 
56
                        c.Logf("test %d: %q -> valid: %v", i*len(applicationNameTests)+j, key, isValid)
 
57
                        c.Assert(names.IsValidRelation(key), gc.Equals, isValid)
 
58
                        c.Assert(names.IsValidRelation(peerKey), gc.Equals, isValid)
 
59
                }
 
60
        }
 
61
}
 
62
 
 
63
var parseRelationTagTests = []struct {
 
64
        tag      string
 
65
        expected names.Tag
 
66
        err      error
 
67
}{{
 
68
        tag: "",
 
69
        err: names.InvalidTagError("", ""),
 
70
}, {
 
71
        tag:      "relation-wordpress:db mysql:db",
 
72
        expected: names.NewRelationTag("wordpress:db mysql:db"),
 
73
}, {
 
74
        tag:      "relation-wordpress:mysql",
 
75
        expected: names.NewRelationTag("wordpress:mysql"),
 
76
}, {
 
77
        tag: "dave",
 
78
        err: names.InvalidTagError("dave", ""),
 
79
}, {
 
80
        tag: "application-dave",
 
81
        err: names.InvalidTagError("application-dave", names.RelationTagKind),
 
82
}}
 
83
 
 
84
func (s *relationSuite) TestParseRelationTag(c *gc.C) {
 
85
        for i, t := range parseRelationTagTests {
 
86
                c.Logf("test %d: %s", i, t.tag)
 
87
                got, err := names.ParseRelationTag(t.tag)
 
88
                if err != nil || t.err != nil {
 
89
                        c.Check(err, gc.DeepEquals, t.err)
 
90
                        continue
 
91
                }
 
92
                c.Check(got, gc.FitsTypeOf, t.expected)
 
93
                c.Check(got, gc.Equals, t.expected)
 
94
        }
 
95
}