func (as *assertsSuite) TestEncoderSingleDecodeOK(c *C) {
encoded := []byte("type: test-only\n" +
"authority-id: auth-id2\n" +
"primary-key: abc\n" +
"revision: 5\n" +
"header1: value1\n" +
"header2: value2\n" +
"body-length: 8\n\n" +
"THE-BODY" +
"\n\n" +
"openpgp c2ln")
a0, err := asserts.Decode(encoded)
c.Assert(err, IsNil)
cont0, _ := a0.Signature()
stream := new(bytes.Buffer)
enc := asserts.NewEncoder(stream)
enc.Encode(a0)
a1, err := asserts.Decode(stream.Bytes())
c.Assert(err, IsNil)
cont1, _ := a1.Signature()
c.Check(cont1, DeepEquals, cont0)
}
func (as *assertsSuite) TestEncoderDecoderHappy(c *C) {
stream := new(bytes.Buffer)
enc := asserts.NewEncoder(stream)
asserts.EncoderAppend(enc, []byte(exampleEmptyBody2NlNl))
asserts.EncoderAppend(enc, []byte(exampleBodyAndExtraHeaders))
asserts.EncoderAppend(enc, []byte(exampleEmptyBodyAllDefaults))
decoder := asserts.NewDecoder(stream)
a, err := decoder.Decode()
c.Assert(err, IsNil)
c.Check(a.Type(), Equals, asserts.TestOnlyType)
_, ok := a.(*asserts.TestOnly)
c.Check(ok, Equals, true)
checkContent(c, a, exampleEmptyBody2NlNl)
a, err = decoder.Decode()
c.Assert(err, IsNil)
checkContent(c, a, exampleBodyAndExtraHeaders)
a, err = decoder.Decode()
c.Assert(err, IsNil)
checkContent(c, a, exampleEmptyBodyAllDefaults)
a, err = decoder.Decode()
c.Assert(err, Equals, io.EOF)
}
func (ar assertResponse) ServeHTTP(w http.ResponseWriter, r *http.Request) {
t := asserts.MediaType
if ar.bundle {
t = mime.FormatMediaType(t, map[string]string{"bundle": "y"})
}
w.Header().Set("Content-Type", t)
w.Header().Set("X-Ubuntu-Assertions-Count", strconv.Itoa(len(ar.assertions)))
enc := asserts.NewEncoder(w)
for _, a := range ar.assertions {
err := enc.Encode(a)
if err != nil {
logger.Noticef("unable to write encoded assertion into response: %v", err)
break
}
}
}
func (x *cmdKnown) Execute(args []string) error {
// TODO: share this kind of parsing once it's clearer how often is used in snap
headers := map[string]string{}
for _, headerFilter := range x.KnownOptions.HeaderFilters {
parts := strings.SplitN(headerFilter, "=", 2)
if len(parts) != 2 {
return fmt.Errorf("invalid header filter: %q (want key=value)", headerFilter)
}
headers[parts[0]] = parts[1]
}
assertions, err := Client().Known(x.KnownOptions.AssertTypeName, headers)
if err != nil {
return err
}
enc := asserts.NewEncoder(Stdout)
for _, a := range assertions {
enc.Encode(a)
}
return nil
}