← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charmstore.v5-unstable/internal/v5/bench_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/charmstore.v5-unstable/internal/v5/bench_test.go
 
1
package v5_test
 
2
 
 
3
import (
 
4
        "net/http"
 
5
        "net/http/httptest"
 
6
 
 
7
        "github.com/juju/testing/httptesting"
 
8
        gc "gopkg.in/check.v1"
 
9
        "gopkg.in/juju/charm.v6-unstable"
 
10
        "gopkg.in/juju/charmrepo.v2-unstable/csclient/params"
 
11
 
 
12
        "gopkg.in/juju/charmstore.v5-unstable/internal/storetesting"
 
13
)
 
14
 
 
15
type BenchmarkSuite struct {
 
16
        commonSuite
 
17
}
 
18
 
 
19
var _ = gc.Suite(&BenchmarkSuite{})
 
20
 
 
21
func (s *BenchmarkSuite) TestBenchmarkMeta(c *gc.C) {
 
22
        s.addPublicCharmFromRepo(c, "wordpress", newResolvedURL("~charmers/precise/wordpress-23", 23))
 
23
        srv := httptest.NewServer(s.srv)
 
24
        defer srv.Close()
 
25
        url := srv.URL + storeURL("wordpress/meta/archive-size")
 
26
        c.Logf("benchmark start")
 
27
        resp, err := http.Get(url)
 
28
        if err != nil {
 
29
                c.Fatalf("get failed: %v", err)
 
30
        }
 
31
        resp.Body.Close()
 
32
        if resp.StatusCode != 200 {
 
33
                c.Fatalf("response failed with code %v", resp.Status)
 
34
        }
 
35
}
 
36
 
 
37
func (s *BenchmarkSuite) BenchmarkMeta(c *gc.C) {
 
38
        s.addPublicCharmFromRepo(c, "wordpress", newResolvedURL("~charmers/precise/wordpress-23", 23))
 
39
        srv := httptest.NewServer(s.srv)
 
40
        defer srv.Close()
 
41
        url := srv.URL + storeURL("wordpress/meta/archive-size")
 
42
        c.ResetTimer()
 
43
        for i := 0; i < c.N; i++ {
 
44
                resp, err := http.Get(url)
 
45
                if err != nil {
 
46
                        c.Fatalf("get failed: %v", err)
 
47
                }
 
48
                resp.Body.Close()
 
49
                if resp.StatusCode != 200 {
 
50
                        c.Fatalf("response failed with code %v", resp.Status)
 
51
                }
 
52
        }
 
53
}
 
54
 
 
55
var benchmarkCharmRelatedAddCharms = map[string]charm.Charm{
 
56
        "0 ~charmers/trusty/wordpress-0": storetesting.NewCharm(storetesting.RelationMeta(
 
57
                "requires cache memcache",
 
58
                "requires nfs mount",
 
59
        )),
 
60
        "1 ~charmers/utopic/memcached-1": storetesting.NewCharm(storetesting.RelationMeta(
 
61
                "provides cache memcache",
 
62
        )),
 
63
        "2 ~charmers/utopic/memcached-2": storetesting.NewCharm(storetesting.RelationMeta(
 
64
                "provides cache memcache",
 
65
        )),
 
66
        "90 ~charmers/utopic/redis-90": storetesting.NewCharm(storetesting.RelationMeta(
 
67
                "provides cache memcache",
 
68
        )),
 
69
        "47 ~charmers/trusty/nfs-47": storetesting.NewCharm(storetesting.RelationMeta(
 
70
                "provides nfs mount",
 
71
        )),
 
72
        "42 ~charmers/precise/nfs-42": storetesting.NewCharm(storetesting.RelationMeta(
 
73
                "provides nfs mount",
 
74
        )),
 
75
        "47 ~charmers/precise/nfs-47": storetesting.NewCharm(storetesting.RelationMeta(
 
76
                "provides nfs mount",
 
77
        )),
 
78
}
 
79
 
 
80
var benchmarkCharmRelatedExpectBody = params.RelatedResponse{
 
81
        Provides: map[string][]params.EntityResult{
 
82
                "memcache": {{
 
83
                        Id: charm.MustParseURL("utopic/memcached-1"),
 
84
                        Meta: map[string]interface{}{
 
85
                                "id-name": params.IdNameResponse{"memcached"},
 
86
                        },
 
87
                }, {
 
88
                        Id: charm.MustParseURL("utopic/memcached-2"),
 
89
                        Meta: map[string]interface{}{
 
90
                                "id-name": params.IdNameResponse{"memcached"},
 
91
                        },
 
92
                }, {
 
93
                        Id: charm.MustParseURL("utopic/redis-90"),
 
94
                        Meta: map[string]interface{}{
 
95
                                "id-name": params.IdNameResponse{"redis"},
 
96
                        },
 
97
                }},
 
98
                "mount": {{
 
99
                        Id: charm.MustParseURL("precise/nfs-42"),
 
100
                        Meta: map[string]interface{}{
 
101
                                "id-name": params.IdNameResponse{"nfs"},
 
102
                        },
 
103
                }, {
 
104
                        Id: charm.MustParseURL("precise/nfs-47"),
 
105
                        Meta: map[string]interface{}{
 
106
                                "id-name": params.IdNameResponse{"nfs"},
 
107
                        },
 
108
                }, {
 
109
                        Id: charm.MustParseURL("trusty/nfs-47"),
 
110
                        Meta: map[string]interface{}{
 
111
                                "id-name": params.IdNameResponse{"nfs"},
 
112
                        },
 
113
                }},
 
114
        },
 
115
}
 
116
 
 
117
func (s *BenchmarkSuite) BenchmarkCharmRelated(c *gc.C) {
 
118
        s.addCharms(c, benchmarkCharmRelatedAddCharms)
 
119
        expectBody := benchmarkCharmRelatedExpectBody
 
120
        srv := httptest.NewServer(s.srv)
 
121
        defer srv.Close()
 
122
        url := srv.URL + storeURL("trusty/wordpress-0/meta/charm-related?include=id-name")
 
123
        c.ResetTimer()
 
124
        for i := 0; i < c.N; i++ {
 
125
                httptesting.AssertJSONCall(c, httptesting.JSONCallParams{
 
126
                        Handler:      s.srv,
 
127
                        URL:          url,
 
128
                        ExpectStatus: http.StatusOK,
 
129
                        ExpectBody:   expectBody,
 
130
                })
 
131
        }
 
132
}
 
133
 
 
134
func (s *BenchmarkSuite) TestCharmRelated(c *gc.C) {
 
135
        s.addCharms(c, benchmarkCharmRelatedAddCharms)
 
136
        expectBody := benchmarkCharmRelatedExpectBody
 
137
        srv := httptest.NewServer(s.srv)
 
138
        defer srv.Close()
 
139
        url := srv.URL + storeURL("trusty/wordpress-0/meta/charm-related?include=id-name")
 
140
        httptesting.AssertJSONCall(c, httptesting.JSONCallParams{
 
141
                Handler:      s.srv,
 
142
                URL:          url,
 
143
                ExpectStatus: http.StatusOK,
 
144
                ExpectBody:   expectBody,
 
145
        })
 
146
}