func (s *BuySnapSuite) TestBuyInvalidCharacters(c *check.C) { _, err := snap.Parser().ParseArgs([]string{"buy", "a:b"}) c.Assert(err, check.NotNil) c.Check(err.Error(), check.Equals, "cannot buy snap: invalid characters in name") c.Check(s.Stdout(), check.Equals, "") c.Check(s.Stderr(), check.Equals, "") _, err = snap.Parser().ParseArgs([]string{"buy", "c*d"}) c.Assert(err, check.NotNil) c.Check(err.Error(), check.Equals, "cannot buy snap: invalid characters in name") c.Check(s.Stdout(), check.Equals, "") c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapSuite) TestSnapRunHookUnsetRevisionIntegration(c *check.C) { // mock installed snap dirs.SetRootDir(c.MkDir()) defer func() { dirs.SetRootDir("/") }() si := snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{ Revision: snap.R(42), }) err := os.Symlink(si.MountDir(), filepath.Join(si.MountDir(), "../current")) c.Assert(err, check.IsNil) // redirect exec execArg0 := "" execArgs := []string{} execEnv := []string{} restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error { execArg0 = arg0 execArgs = args execEnv = envv return nil }) defer restorer() // Specifically pass "unset" which would use the active version. _, err = snaprun.Parser().ParseArgs([]string{"run", "--hook=configure", "-r=unset", "snapname"}) c.Assert(err, check.IsNil) c.Check(execArg0, check.Equals, filepath.Join(dirs.LibExecDir, "snap-confine")) c.Check(execArgs, check.DeepEquals, []string{ filepath.Join(dirs.LibExecDir, "snap-confine"), "snap.snapname.hook.configure", filepath.Join(dirs.LibExecDir, "snap-exec"), "--hook=configure", "snapname"}) c.Check(execEnv, testutil.Contains, "SNAP_REVISION=42") }
func (s *SnapSuite) TestCreateKeyInvalidCharacters(c *C) { _, err := snap.Parser().ParseArgs([]string{"create-key", "a b"}) c.Assert(err, NotNil) c.Check(err.Error(), Equals, "key name \"a b\" is not valid; only ASCII letters, digits, and hyphens are allowed") c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *SnapSuite) TestLoginAskEmail(c *C) { if err := archWithBrokenDevPtmx(); err != nil { c.Skip(err.Error()) } n := 0 s.RedirectClientToTestServer(makeLoginTestServer(c, &n)) // send the email fmt.Fprint(s.stdin, "[email protected]\n") // send the password fmt.Fprint(s.term, "some-password\n") rest, err := snap.Parser().ParseArgs([]string{"login"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) // test slightly ugly, on a real system STDOUT will be: // Email address: [email protected]\n // because the input to stdin is echoed c.Check(s.Stdout(), Equals, `Email address: Password of "*****@*****.**": Login successful `) c.Check(s.Stderr(), Equals, "") c.Check(n, Equals, 1) }
func (s *SnapSuite) TestSnapRunAppIntegration(c *check.C) { // mock installed snap dirs.SetRootDir(c.MkDir()) defer func() { dirs.SetRootDir("/") }() si := snaptest.MockSnap(c, string(mockYaml), &snap.SideInfo{ Revision: snap.R("x2"), }) err := os.Symlink(si.MountDir(), filepath.Join(si.MountDir(), "../current")) c.Assert(err, check.IsNil) // redirect exec execArg0 := "" execArgs := []string{} execEnv := []string{} restorer := snaprun.MockSyscallExec(func(arg0 string, args []string, envv []string) error { execArg0 = arg0 execArgs = args execEnv = envv return nil }) defer restorer() // and run it! rest, err := snaprun.Parser().ParseArgs([]string{"run", "snapname.app", "--arg1", "arg2"}) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{"snapname.app", "--arg1", "arg2"}) c.Check(execArg0, check.Equals, filepath.Join(dirs.LibExecDir, "snap-confine")) c.Check(execArgs, check.DeepEquals, []string{ filepath.Join(dirs.LibExecDir, "snap-confine"), "snap.snapname.app", filepath.Join(dirs.LibExecDir, "snap-exec"), "snapname.app", "--arg1", "arg2"}) c.Check(execEnv, testutil.Contains, "SNAP_REVISION=x2") }
func (s *SnapSuite) TestAutoImportAssertsHappyNotOnClassic(c *C) { restore := release.MockOnClassic(true) defer restore() fakeAssertData := []byte("my-assertion") s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { c.Errorf("auto-import on classic is disabled, but something tried to do a %q with %s", r.Method, r.URL.Path) }) fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert") err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644) c.Assert(err, IsNil) mockMountInfoFmt := ` 24 0 8:18 / %s rw,relatime shared:1 - ext4 /dev/sdb2 rw,errors=remount-ro,data=ordered` content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn)) restore = snap.MockMountInfoPath(makeMockMountInfo(c, content)) defer restore() rest, err := snap.Parser().ParseArgs([]string{"auto-import"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "auto-import is disabled on classic\n") }
func (s *SnapSuite) TestFindNothingFails(c *check.C) { s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { c.Fatalf("it reached the server") }) _, err := snap.Parser().ParseArgs([]string{"find"}) c.Assert(err, check.ErrorMatches, `you need to specify a query. Try.*`) }
func (s *SnapSuite) TestFindHello(c *check.C) { n := 0 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, check.Equals, "GET") c.Check(r.URL.Path, check.Equals, "/v2/find") q := r.URL.Query() c.Check(q.Get("q"), check.Equals, "hello") fmt.Fprintln(w, findHelloJSON) default: c.Fatalf("expected to get 1 requests, now on %d", n+1) } n++ }) rest, err := snap.Parser().ParseArgs([]string{"find", "hello"}) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Matches, `Name +Version +Developer +Notes +Summary hello +2.10 +canonical +- +GNU Hello, the "hello world" snap hello-huge +1.0 +noise +- +a really big snap `) c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapSuite) TestListWithNotes(c *check.C) { n := 0 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, check.Equals, "GET") c.Check(r.URL.Path, check.Equals, "/v2/snaps") fmt.Fprintln(w, `{"type": "sync", "result": [ {"name": "foo", "status": "active", "version": "4.2", "developer": "bar", "revision":17, "trymode": true} ,{"name": "dm1", "status": "active", "version": "5", "revision":1, "devmode": true, "confinement": "devmode"} ,{"name": "dm2", "status": "active", "version": "5", "revision":1, "devmode": true, "confinement": "strict"} ,{"name": "cf1", "status": "active", "version": "6", "revision":2, "confinement": "devmode"} ]}`) default: c.Fatalf("expected to get 1 requests, now on %d", n+1) } n++ }) rest, err := snap.Parser().ParseArgs([]string{"list"}) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Matches, `(?ms)^Name +Version +Rev +Developer +Notes$`) c.Check(s.Stdout(), check.Matches, `(?ms).*^foo +4.2 +17 +bar +try$`) c.Check(s.Stdout(), check.Matches, `(?ms).*^dm1 +.* +devmode$`) c.Check(s.Stdout(), check.Matches, `(?ms).*^dm2 +.* +devmode$`) c.Check(s.Stdout(), check.Matches, `(?ms).*^cf1 +.* +jailmode$`) c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapKeysSuite) TestDeleteKeyRequiresName(c *C) { _, err := snap.Parser().ParseArgs([]string{"delete-key"}) c.Assert(err, NotNil) c.Check(err.Error(), Equals, "the required argument `<key-name>` was not provided") c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *BuySnapSuite) TestBuyHelp(c *check.C) { _, err := snap.Parser().ParseArgs([]string{"buy"}) c.Assert(err, check.NotNil) c.Check(err.Error(), check.Equals, "the required argument `<snap>` was not provided") c.Check(s.Stdout(), check.Equals, "") c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapSignBuildSuite) TestSignBuildWorksDevelGrade(c *C) { snapFilename := "foo_1_amd64.snap" snapContent := []byte("sample") _err := ioutil.WriteFile(snapFilename, snapContent, 0644) c.Assert(_err, IsNil) defer os.Remove(snapFilename) tempdir := c.MkDir() for _, fileName := range []string{"pubring.gpg", "secring.gpg", "trustdb.gpg"} { data, err := ioutil.ReadFile(filepath.Join("test-data", fileName)) c.Assert(err, IsNil) err = ioutil.WriteFile(filepath.Join(tempdir, fileName), data, 0644) c.Assert(err, IsNil) } os.Setenv("SNAP_GNUPG_HOME", tempdir) defer os.Unsetenv("SNAP_GNUPG_HOME") _, err := snap.Parser().ParseArgs([]string{"sign-build", snapFilename, "--developer-id", "dev-id1", "--snap-id", "snap-id-1", "--grade", "devel"}) c.Assert(err, IsNil) assertion, err := asserts.Decode([]byte(s.Stdout())) c.Assert(err, IsNil) c.Check(assertion.Type(), Equals, asserts.SnapBuildType) c.Check(assertion.HeaderString("grade"), Equals, "devel") // check for valid signature ?! c.Check(s.Stderr(), Equals, "") }
func (s *SnapOpSuite) runTryTest(c *check.C, devmode bool) { // pass relative path to cmd tryDir := "some-dir" s.srv.checker = func(r *http.Request) { // ensure the client always sends the absolute path fullTryDir, err := filepath.Abs(tryDir) c.Assert(err, check.IsNil) c.Check(r.URL.Path, check.Equals, "/v2/snaps") postData, err := ioutil.ReadAll(r.Body) c.Assert(err, check.IsNil) c.Assert(string(postData), check.Matches, "(?s).*Content-Disposition: form-data; name=\"action\"\r\n\r\ntry\r\n.*") c.Assert(string(postData), check.Matches, fmt.Sprintf("(?s).*Content-Disposition: form-data; name=\"snap-path\"\r\n\r\n%s\r\n.*", regexp.QuoteMeta(fullTryDir))) c.Assert(string(postData), check.Matches, fmt.Sprintf("(?s).*Content-Disposition: form-data; name=\"devmode\"\r\n\r\n%s\r\n.*", strconv.FormatBool(devmode))) } s.RedirectClientToTestServer(s.srv.handle) cmd := []string{"try", tryDir} if devmode { cmd = append(cmd, "--devmode") } rest, err := snap.Parser().ParseArgs(cmd) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Matches, fmt.Sprintf(`(?sm).*foo 1.0 mounted from .*%s`, tryDir)) c.Check(s.Stderr(), check.Equals, "") // ensure that the fake server api was actually hit c.Check(s.srv.n, check.Equals, s.srv.total) }
func (s *SnapSuite) TestAutoImportAssertsNotImportedFromLoop(c *C) { restore := release.MockOnClassic(false) defer restore() fakeAssertData := []byte("bad-assertion") s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { // assertion is ignored, nothing is posted to this endpoint panic("not reached") }) fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert") err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644) c.Assert(err, IsNil) mockMountInfoFmtWithLoop := ` 24 0 8:18 / %s rw,relatime shared:1 - squashfs /dev/loop1 rw,errors=remount-ro,data=ordered` content := fmt.Sprintf(mockMountInfoFmtWithLoop, filepath.Dir(fakeAssertsFn)) restore = snap.MockMountInfoPath(makeMockMountInfo(c, content)) defer restore() rest, err := snap.Parser().ParseArgs([]string{"auto-import"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *SnapKeysSuite) TestExportKeyAccount(c *C) { rootPrivKey, _ := assertstest.GenerateKey(1024) storePrivKey, _ := assertstest.GenerateKey(752) storeSigning := assertstest.NewStoreStack("canonical", rootPrivKey, storePrivKey) manager := asserts.NewGPGKeypairManager() assertstest.NewAccount(storeSigning, "developer1", nil, "") rest, err := snap.Parser().ParseArgs([]string{"export-key", "another", "--account=developer1"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) assertion, err := asserts.Decode(s.stdout.Bytes()) c.Assert(err, IsNil) c.Check(assertion.Type(), Equals, asserts.AccountKeyRequestType) c.Check(assertion.Revision(), Equals, 0) c.Check(assertion.HeaderString("account-id"), Equals, "developer1") c.Check(assertion.HeaderString("name"), Equals, "another") c.Check(assertion.HeaderString("public-key-sha3-384"), Equals, "DVQf1U4mIsuzlQqAebjjTPYtYJ-GEhJy0REuj3zvpQYTZ7EJj7adBxIXLJ7Vmk3L") since, err := time.Parse(time.RFC3339, assertion.HeaderString("since")) c.Assert(err, IsNil) zone, offset := since.Zone() c.Check(zone, Equals, "UTC") c.Check(offset, Equals, 0) c.Check(s.Stderr(), Equals, "") privKey, err := manager.Get(assertion.HeaderString("public-key-sha3-384")) c.Assert(err, IsNil) err = asserts.SignatureCheck(assertion, privKey.PublicKey()) c.Assert(err, IsNil) }
func (s *SnapSuite) TestKnownRemote(c *check.C) { var server *httptest.Server restorer := snap.MockStoreNew(func(cfg *store.Config, auth auth.AuthContext) *store.Store { if cfg == nil { cfg = store.DefaultConfig() } serverURL, err := url.Parse(server.URL + "/assertions/") c.Assert(err, check.IsNil) cfg.AssertionsURI = serverURL return store.New(cfg, auth) }) defer restorer() n := 0 server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, check.Equals, "GET") c.Check(r.URL.Path, check.Equals, "/assertions/model/16/canonical/pi99") fmt.Fprintln(w, mockModelAssertion) default: c.Fatalf("expected to get 1 requests, now on %d", n+1) } n++ })) rest, err := snap.Parser().ParseArgs([]string{"known", "--remote", "model", "series=16", "brand-id=canonical", "model=pi99"}) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Equals, mockModelAssertion) c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapKeysSuite) TestExportKeyNonexistent(c *C) { _, err := snap.Parser().ParseArgs([]string{"export-key", "nonexistent"}) c.Assert(err, NotNil) c.Check(err.Error(), Equals, "cannot find key named \"nonexistent\" in GPG keyring") c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *SnapSuite) TestAutoImportIntoSpoolUnhappyTooBig(c *C) { restore := release.MockOnClassic(false) defer restore() dirs.SetRootDir(c.MkDir()) defer dirs.SetRootDir("") l, err := logger.NewConsoleLog(s.stderr, 0) c.Assert(err, IsNil) logger.SetLogger(l) // fake data is bigger than the default assertion limit fakeAssertData := make([]byte, 641*1024) // ensure we can not connect snap.ClientConfig.BaseURL = "can-not-connect-to-this-url" fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert") err = ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644) c.Assert(err, IsNil) mockMountInfoFmt := ` 24 0 8:18 / %s rw,relatime shared:1 - squashfs /dev/sc1 rw,errors=remount-ro,data=ordered` content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn)) restore = snap.MockMountInfoPath(makeMockMountInfo(c, content)) defer restore() _, err = snap.Parser().ParseArgs([]string{"auto-import"}) c.Assert(err, ErrorMatches, "cannot queue .*, file size too big: 656384") }
func (s *SnapSignBuildSuite) TestSignBuildMissingSnap(c *C) { _, err := snap.Parser().ParseArgs([]string{"sign-build", "foo_1_amd64.snap", "--developer-id", "dev-id1", "--snap-id", "snap-id-1"}) c.Assert(err, NotNil) c.Check(err.Error(), Equals, "cannot compute snap \"foo_1_amd64.snap\" digest: open foo_1_amd64.snap: no such file or directory") c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *SnapSignBuildSuite) TestSignBuildWorks(c *C) { snapFilename := "foo_1_amd64.snap" snapContent := []byte("sample") _err := ioutil.WriteFile(snapFilename, snapContent, 0644) c.Assert(_err, IsNil) defer os.Remove(snapFilename) tempdir := c.MkDir() for _, fileName := range []string{"pubring.gpg", "secring.gpg", "trustdb.gpg"} { data, err := ioutil.ReadFile(filepath.Join("test-data", fileName)) c.Assert(err, IsNil) err = ioutil.WriteFile(filepath.Join(tempdir, fileName), data, 0644) c.Assert(err, IsNil) } os.Setenv("SNAP_GNUPG_HOME", tempdir) defer os.Unsetenv("SNAP_GNUPG_HOME") _, err := snap.Parser().ParseArgs([]string{"sign-build", snapFilename, "--developer-id", "dev-id1", "--snap-id", "snap-id-1"}) c.Assert(err, IsNil) assertion, err := asserts.Decode([]byte(s.Stdout())) c.Assert(err, IsNil) c.Check(assertion.Type(), Equals, asserts.SnapBuildType) c.Check(assertion.Revision(), Equals, 0) c.Check(assertion.HeaderString("authority-id"), Equals, "dev-id1") c.Check(assertion.HeaderString("developer-id"), Equals, "dev-id1") c.Check(assertion.HeaderString("grade"), Equals, "stable") c.Check(assertion.HeaderString("snap-id"), Equals, "snap-id-1") c.Check(assertion.HeaderString("snap-size"), Equals, fmt.Sprintf("%d", len(snapContent))) c.Check(assertion.HeaderString("snap-sha3-384"), Equals, "jyP7dUgb8HiRNd1SdYPp_il-YNrl6P6PgNAe-j6_7WytjKslENhMD3Of5XBU5bQK") // check for valid signature ?! c.Check(s.Stderr(), Equals, "") }
func (s *SnapSignBuildSuite) TestSignBuildMandatoryFlags(c *C) { _, err := snap.Parser().ParseArgs([]string{"sign-build", "foo_1_amd64.snap"}) c.Assert(err, NotNil) c.Check(err.Error(), Equals, "the required flags `--developer-id' and `--snap-id' were not specified") c.Check(s.Stdout(), Equals, "") c.Check(s.Stderr(), Equals, "") }
func (s *BuySnapSuite) TestBuySnapFailsOutOfRangeMethodID(c *check.C) { mockServer := &buyTestMockSnapServer{ ExpectedMethods: expectedMethods{ "GET": &expectedMethod{ "/v2/find": buySnapFindURL(c), "/v2/buy/methods": &expectedURL{ Body: buyMethodsSelectPaymentMethodJson, }, }, }, Checker: c, } defer mockServer.checkCounts() s.RedirectClientToTestServer(mockServer.serveHttp) // Payment method selection out of range fmt.Fprint(s.stdin, "5\n") rest, err := snap.Parser().ParseArgs([]string{"buy", "hello"}) c.Assert(err, check.NotNil) c.Check(err.Error(), check.Equals, `cannot buy snap "hello": unknown payment method selection 5`) c.Check(rest, check.DeepEquals, []string{"hello"}) c.Check(s.Stdout(), check.Equals, ` Selection Description 1 **** **** **** 1111 (exp 23/2020) 2 **** **** **** 2222 (exp 23/2025) 3 **** **** **** 3333 (exp 30/2027) Type a number to select payment method: `) c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapSuite) TestRefreshList(c *check.C) { n := 0 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, check.Equals, "GET") c.Check(r.URL.Path, check.Equals, "/v2/find") c.Check(r.URL.Query().Get("select"), check.Equals, "refresh") fmt.Fprintln(w, `{"type": "sync", "result": [{"name": "foo", "status": "active", "version": "4.2update1", "developer": "bar", "revision":17,"summary":"some summary"}]}`) default: c.Fatalf("expected to get 1 requests, now on %d", n+1) } n++ }) rest, err := snap.Parser().ParseArgs([]string{"refresh", "--list"}) c.Assert(err, check.IsNil) c.Assert(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Matches, `Name +Version +Rev +Developer +Notes foo +4.2update1 +17 +bar +-.* `) c.Check(s.Stderr(), check.Equals, "") // ensure that the fake server api was actually hit c.Check(n, check.Equals, 1) }
func (s *SnapSuite) TestInvalidParameters(c *check.C) { invalidParameters := []string{"run", "--hook=apply-config", "--command=command-name", "snap-name"} _, err := snaprun.Parser().ParseArgs(invalidParameters) c.Check(err, check.ErrorMatches, ".*cannot use --hook and --command together.*") invalidParameters = []string{"run", "-r=1", "--command=command-name", "snap-name"} _, err = snaprun.Parser().ParseArgs(invalidParameters) c.Check(err, check.ErrorMatches, ".*-r can only be used with --hook.*") invalidParameters = []string{"run", "-r=1", "snap-name"} _, err = snaprun.Parser().ParseArgs(invalidParameters) c.Check(err, check.ErrorMatches, ".*-r can only be used with --hook.*") invalidParameters = []string{"run", "--hook=apply-config", "foo", "bar", "snap-name"} _, err = snaprun.Parser().ParseArgs(invalidParameters) c.Check(err, check.ErrorMatches, ".*too many arguments for hook \"apply-config\": bar.*") }
func (s *SnapSuite) TestCreateUser(c *check.C) { n := 0 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0, 1: c.Check(r.Method, check.Equals, "POST") c.Check(r.URL.Path, check.Equals, "/v2/create-user") var body map[string]interface{} dec := json.NewDecoder(r.Body) err := dec.Decode(&body) c.Assert(err, check.IsNil) c.Check(body, check.DeepEquals, map[string]interface{}{ "email": "*****@*****.**", "sudoer": false, }) fmt.Fprintln(w, `{"type": "sync", "result": {"username": "******", "ssh-key-count": 1}}`) default: c.Fatalf("expected to get 2 requests, now on %d", n+1) } n++ }) rest, err := snap.Parser().ParseArgs([]string{"create-user", "*****@*****.**"}) c.Assert(err, check.IsNil) c.Check(rest, check.DeepEquals, []string{}) c.Check(n, check.Equals, 1) c.Assert(s.Stdout(), check.Equals, `Created user "karl" and imported SSH keys.`+"\n") c.Assert(s.Stderr(), check.Equals, "") s.stdout.Reset() expectedResponse := &client.CreateUserResult{ Username: "******", SSHKeyCount: 1, } actualResponse := &client.CreateUserResult{} rest, err = snap.Parser().ParseArgs([]string{"create-user", "--json", "*****@*****.**"}) c.Assert(err, check.IsNil) c.Check(rest, check.DeepEquals, []string{}) c.Check(n, check.Equals, 2) json.Unmarshal(s.stdout.Bytes(), actualResponse) c.Assert(actualResponse, check.DeepEquals, expectedResponse) c.Assert(s.Stderr(), check.Equals, "") }
func (s *SnapSuite) TestAutoImportFromSpoolHappy(c *C) { restore := release.MockOnClassic(false) defer restore() fakeAssertData := []byte("my-assertion") n := 0 total := 2 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, Equals, "POST") c.Check(r.URL.Path, Equals, "/v2/assertions") postData, err := ioutil.ReadAll(r.Body) c.Assert(err, IsNil) c.Check(postData, DeepEquals, fakeAssertData) fmt.Fprintln(w, `{"type": "sync", "result": {"ready": true, "status": "Done"}}`) n++ case 1: c.Check(r.Method, Equals, "POST") c.Check(r.URL.Path, Equals, "/v2/create-user") postData, err := ioutil.ReadAll(r.Body) c.Assert(err, IsNil) c.Check(string(postData), Equals, `{"sudoer":true,"known":true}`) fmt.Fprintln(w, `{"type": "sync", "result": [{"username": "******"}]}`) n++ default: c.Fatalf("unexpected request: %v (expected %d got %d)", r, total, n) } }) dirs.SetRootDir(c.MkDir()) defer dirs.SetRootDir("") fakeAssertsFn := filepath.Join(dirs.SnapAssertsSpoolDir, "1234343") err := os.MkdirAll(filepath.Dir(fakeAssertsFn), 0755) c.Assert(err, IsNil) err = ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644) c.Assert(err, IsNil) l, err := logger.NewConsoleLog(s.stderr, 0) c.Assert(err, IsNil) logger.SetLogger(l) rest, err := snap.Parser().ParseArgs([]string{"auto-import"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) c.Check(s.Stdout(), Equals, `created user "foo"`+"\n") // matches because we may get a: // "WARNING: cannot create syslog logger\n" // in the output c.Check(s.Stderr(), Matches, fmt.Sprintf("(?ms).*imported %s\n", fakeAssertsFn)) c.Check(n, Equals, total) c.Check(osutil.FileExists(fakeAssertsFn), Equals, false) }
func (s *BuySnapSuite) TestBuySnapSelectPaymentMethodWithDefault(c *check.C) { mockServer := &buyTestMockSnapServer{ ExpectedMethods: expectedMethods{ "GET": &expectedMethod{ "/v2/find": buySnapFindURL(c), "/v2/buy/methods": &expectedURL{ Body: buyMethodsSelectPaymentMethodWithDefaultJson, }, }, "POST": &expectedMethod{ "/v2/buy": &expectedURL{ Body: buySnapJson, Checker: func(r *http.Request) { var postData struct { SnapID string `json:"snap-id"` SnapName string `json:"snap-name"` Price float64 `json:"price"` Currency string `json:"currency"` MethodID int `json:"method-id"` BackendID string `json:"backend-id"` } decoder := json.NewDecoder(r.Body) err := decoder.Decode(&postData) c.Assert(err, check.IsNil) c.Check(postData.SnapID, check.Equals, "mVyGrEwiqSi5PugCwyH7WgpoQLemtTd6") c.Check(postData.SnapName, check.Equals, "hello") c.Check(postData.Price, check.Equals, 2.99) c.Check(postData.Currency, check.Equals, "GBP") // Confirm the correct details for card #1 c.Check(postData.MethodID, check.Equals, 123) c.Check(postData.BackendID, check.Equals, "credit_card") }, }, }, }, Checker: c, } defer mockServer.checkCounts() s.RedirectClientToTestServer(mockServer.serveHttp) // Select the default card fmt.Fprint(s.stdin, "\n") // Confirm "yes" to the purchase fmt.Fprint(s.stdin, "\n") rest, err := snap.Parser().ParseArgs([]string{"buy", "hello"}) c.Check(err, check.IsNil) c.Check(rest, check.DeepEquals, []string{}) c.Check(s.Stdout(), check.Equals, ` Selection Description * 1 **** **** **** 1111 (exp 23/2020) 2 **** **** **** 2222 (exp 23/2025) 3 **** **** **** 3333 (exp 30/2027) Press <enter> to use your default[*], or type a number to select payment method: Do you want to buy "hello" from "canonical" for 2.99GBP? (Y/n): hello bought `) c.Check(s.Stderr(), check.Equals, "") }
func (s *SnapSuite) TestAutoImportAssertsHappy(c *C) { restore := release.MockOnClassic(false) defer restore() fakeAssertData := []byte("my-assertion") n := 0 total := 2 s.RedirectClientToTestServer(func(w http.ResponseWriter, r *http.Request) { switch n { case 0: c.Check(r.Method, Equals, "POST") c.Check(r.URL.Path, Equals, "/v2/assertions") postData, err := ioutil.ReadAll(r.Body) c.Assert(err, IsNil) c.Check(postData, DeepEquals, fakeAssertData) fmt.Fprintln(w, `{"type": "sync", "result": {"ready": true, "status": "Done"}}`) n++ case 1: c.Check(r.Method, Equals, "POST") c.Check(r.URL.Path, Equals, "/v2/create-user") postData, err := ioutil.ReadAll(r.Body) c.Assert(err, IsNil) c.Check(string(postData), Equals, `{"sudoer":true,"known":true}`) fmt.Fprintln(w, `{"type": "sync", "result": [{"username": "******"}]}`) n++ default: c.Fatalf("unexpected request: %v (expected %d got %d)", r, total, n) } }) fakeAssertsFn := filepath.Join(c.MkDir(), "auto-import.assert") err := ioutil.WriteFile(fakeAssertsFn, fakeAssertData, 0644) c.Assert(err, IsNil) mockMountInfoFmt := ` 24 0 8:18 / %s rw,relatime shared:1 - ext4 /dev/sdb2 rw,errors=remount-ro,data=ordered` content := fmt.Sprintf(mockMountInfoFmt, filepath.Dir(fakeAssertsFn)) restore = snap.MockMountInfoPath(makeMockMountInfo(c, content)) defer restore() l, err := logger.NewConsoleLog(s.stderr, 0) c.Assert(err, IsNil) logger.SetLogger(l) rest, err := snap.Parser().ParseArgs([]string{"auto-import"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) c.Check(s.Stdout(), Equals, `created user "foo"`+"\n") // matches because we may get a: // "WARNING: cannot create syslog logger\n" // in the output c.Check(s.Stderr(), Matches, fmt.Sprintf("(?ms).*imported %s\n", fakeAssertsFn)) c.Check(n, Equals, total) }
func (s *SnapKeysSuite) TestKeysJSONEmpty(c *C) { err := os.RemoveAll(os.Getenv("SNAP_GNUPG_HOME")) c.Assert(err, IsNil) rest, err := snap.Parser().ParseArgs([]string{"keys", "--json"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) c.Check(s.Stdout(), Equals, "[]\n") c.Check(s.Stderr(), Equals, "") }
func (s *SnapKeysSuite) TestExportKeyNonDefault(c *C) { rest, err := snap.Parser().ParseArgs([]string{"export-key", "another"}) c.Assert(err, IsNil) c.Assert(rest, DeepEquals, []string{}) pubKey, err := asserts.DecodePublicKey(s.stdout.Bytes()) c.Assert(err, IsNil) c.Check(pubKey.ID(), Equals, "DVQf1U4mIsuzlQqAebjjTPYtYJ-GEhJy0REuj3zvpQYTZ7EJj7adBxIXLJ7Vmk3L") c.Check(s.Stderr(), Equals, "") }