func (cs *clientSuite) TestSnapClientIntegration(c *check.C) {
c.Assert(os.MkdirAll(filepath.Dir(dirs.SnapSocket), 0755), check.IsNil)
l, err := net.Listen("unix", dirs.SnapSocket)
if err != nil {
c.Fatalf("unable to listen on %q: %v", dirs.SnapSocket, err)
}
f := func(w http.ResponseWriter, r *http.Request) {
c.Check(r.URL.Path, check.Equals, "/v2/snapctl")
c.Check(r.URL.RawQuery, check.Equals, "")
fmt.Fprintln(w, `{"type":"sync", "result":{"stdout":"test stdout","stderr":"test stderr"}}`)
}
srv := &httptest.Server{
Listener: l,
Config: &http.Server{Handler: http.HandlerFunc(f)},
}
srv.Start()
defer srv.Close()
cli := client.New(nil)
options := &client.SnapCtlOptions{
ContextID: "foo",
Args: []string{"bar", "--baz"},
}
stdout, stderr, err := cli.RunSnapctl(options)
c.Check(err, check.IsNil)
c.Check(string(stdout), check.Equals, "test stdout")
c.Check(string(stderr), check.Equals, "test stderr")
}
func (cs *clientSuite) TestSnapdClientIntegration(c *check.C) {
c.Assert(os.MkdirAll(filepath.Dir(dirs.SnapdSocket), 0755), check.IsNil)
l, err := net.Listen("unix", dirs.SnapdSocket)
if err != nil {
c.Fatalf("unable to listen on %q: %v", dirs.SnapdSocket, err)
}
f := func(w http.ResponseWriter, r *http.Request) {
c.Check(r.URL.Path, check.Equals, "/v2/system-info")
c.Check(r.URL.RawQuery, check.Equals, "")
fmt.Fprintln(w, `{"type":"sync", "result":{"series":"42"}}`)
}
srv := &httptest.Server{
Listener: l,
Config: &http.Server{Handler: http.HandlerFunc(f)},
}
srv.Start()
defer srv.Close()
cli := client.New(nil)
si, err := cli.SysInfo()
c.Check(err, check.IsNil)
c.Check(si.Series, check.Equals, "42")
}
func run() (stdout, stderr []byte, err error) {
cli := client.New(&clientConfig)
return cli.RunSnapctl(&client.SnapCtlOptions{
ContextID: os.Getenv("SNAP_CONTEXT"),
Args: os.Args[1:],
})
}
func MakeFakeRefreshForSnaps(snaps []string, blobDir string) error {
storePrivKey, _ := assertstest.ReadPrivKey(systestkeys.TestStorePrivKey)
db, err := asserts.OpenDatabase(&asserts.DatabaseConfig{
KeypairManager: asserts.NewMemoryKeypairManager(),
Backstore: asserts.NewMemoryBackstore(),
Trusted: sysdb.Trusted(),
})
if err != nil {
return err
}
// for signing
db.ImportKey(storePrivKey)
var cliConfig client.Config
cli := client.New(&cliConfig)
retrieve := func(ref *asserts.Ref) (asserts.Assertion, error) {
headers := make(map[string]string)
for i, k := range ref.Type.PrimaryKey {
headers[k] = ref.PrimaryKey[i]
}
as, err := cli.Known(ref.Type.Name, headers)
if err != nil {
return nil, err
}
switch len(as) {
case 1:
return as[0], nil
case 0:
return nil, asserts.ErrNotFound
default:
panic(fmt.Sprintf("multiple assertions when retrieving by primary key: %v", ref))
}
}
save := func(a asserts.Assertion) error {
err := db.Add(a)
if err != nil {
if _, ok := err.(*asserts.RevisionError); !ok {
return err
}
}
return writeAssert(a, blobDir)
}
f := asserts.NewFetcher(db, retrieve, save)
for _, snap := range snaps {
if err := makeFakeRefreshForSnap(snap, blobDir, db, f); err != nil {
return err
}
}
return nil
}
func (cs *clientSuite) SetUpTest(c *check.C) {
os.Setenv(client.TestAuthFileEnvKey, filepath.Join(c.MkDir(), "auth.json"))
cs.cli = client.New(nil)
cs.cli.SetDoer(cs)
cs.err = nil
cs.rsp = ""
cs.req = nil
cs.header = nil
cs.status = http.StatusOK
cs.doCalls = 0
dirs.SetRootDir(c.MkDir())
}
func (cs *clientSuite) TestNewPanics(c *check.C) {
c.Assert(func() {
client.New(&client.Config{BaseURL: ":"})
}, check.PanicMatches, `cannot parse server base URL: ":" \(parse :: missing protocol scheme\)`)
}
// Client returns a new client using ClientConfig as configuration.
func Client() *client.Client {
return client.New(&ClientConfig)
}
