func tearDownSnapd(fromBranch bool) error {
	if _, err := cli.ExecCommandErr("sudo", "systemctl", "stop",
		"snapd.service"); err != nil {
		return err
	}

	if _, err := cli.ExecCommandErr("sudo", "rm", "-rf", cfgDir); err != nil {
		return err
	}

	if fromBranch {
		if _, err := cli.ExecCommandErr("sudo", "umount", daemonBinaryPath); err != nil {
			return err
		}
	}

	if _, err := cli.ExecCommandErr("sudo", "systemctl", "daemon-reload"); err != nil {
		return err
	}

	if _, err := cli.ExecCommandErr("sudo", "systemctl", "start",
		"snapd.service"); err != nil {
		return err
	}

	return nil
}

func (s *purgeSuite) TestPurgeRemovesDataForDeactivatedNotRemovedPackage(c *check.C) {
	defer common.RemoveSnap(c, data.BasicSnapName)
	_, err := cli.ExecCommandErr("sudo", "snappy", "deactivate", snap)
	c.Assert(err, check.IsNil)

	_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap)
	c.Assert(err, check.IsNil)

	_, err = os.Stat(snapDataPath)
	c.Assert(os.IsNotExist(err), check.Equals, true)
}

func (s *purgeSuite) TestPurgeHonoursInstalledFlagForNotRemovedPackage(c *check.C) {
	defer common.RemoveSnap(c, data.BasicSnapName)

	dataFile := filepath.Join(snapDataPath, "data")
	_, err := cli.ExecCommandErr("sudo", "touch", dataFile)
	c.Assert(err, check.IsNil)

	_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap, "--installed")
	c.Assert(err, check.IsNil)

	_, err = os.Stat(dataFile)
	c.Assert(os.IsNotExist(err), check.Equals, true, check.Commentf("Error %v instead of os.IsNotExist", err))

	_, err = os.Stat(snapDataPath)
	c.Assert(err, check.IsNil)
}

// RemoveSnap executes the required command to remove the specified snap
func RemoveSnap(c *check.C, packageName string) string {
	cli.ExecCommand(c, "sudo", "snap", "remove", packageName)
	// XXX: right now "snap list" on freshly booted is empty
	// because u-d-f installed aren't in state
	out, _ := cli.ExecCommandErr("snap", "list")
	return out
}

func removeSnap(c *check.C, packageName string) string {
	cli.ExecCommand(c, "sudo", "snap", "remove", packageName)
	// FIXME: should `snap remove` shold show a list afterards?
	//        like `snappy install`?
	// right now "snap list" on freshly booted is empty
	// because u-d-f installed aren't in state
	out, _ := cli.ExecCommandErr("snap", "list")
	return out
}

func (s *classicDimensionSuite) TestDestroyUnexistingClassicMustPrintError(c *check.C) {
	output, err := cli.ExecCommandErr("sudo", "snap", "destroy-classic")

	c.Check(err, check.NotNil,
		check.Commentf("Trying to destroy unexisting classic dimension did not exit with an error"))
	c.Assert(string(output), check.Equals,
		"error: Classic dimension is not enabled.\n",
		check.Commentf("Wrong error message"))
}

func (s *purgeSuite) TestPurgeReturnsErrorForNotRemovedPackage(c *check.C) {
	defer common.RemoveSnap(c, data.BasicSnapName)

	_, err := cli.ExecCommandErr("sudo", "snappy", "purge", snap)
	c.Assert(err, check.NotNil)

	_, err = os.Stat(snapDataPath)
	c.Assert(err, check.IsNil)
}

func (s *installAppSuite) TestCallFailBinaryFromInstalledSnap(c *check.C) {
	snapPath, err := build.LocalSnap(c, data.BasicBinariesSnapName)
	defer os.Remove(snapPath)
	c.Assert(err, check.IsNil, check.Commentf("Error building local snap: %s", err))
	common.InstallSnap(c, snapPath)
	defer common.RemoveSnap(c, data.BasicBinariesSnapName)

	_, err = cli.ExecCommandErr("basic-binaries.fail")
	c.Assert(err, check.NotNil, check.Commentf("The binary did not fail"))
}

func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
	output, err := cli.ExecCommandErr("sudo", "snappy", "install", "unexisting.canonical")

	c.Check(err, check.NotNil,
		check.Commentf("Trying to install an unexisting snap did not exit with an error"))
	c.Assert(string(output), check.Equals,
		"Installing unexisting.canonical\n"+
			"unexisting.canonical failed to install: snappy package not found\n",
		check.Commentf("Wrong error message"))
}

func (s *installAppSuite) TestInstallUnexistingAppMustPrintError(c *check.C) {
	output, err := cli.ExecCommandErr("sudo", "snap", "install", "unexisting.canonical")

	c.Check(err, check.NotNil,
		check.Commentf("Trying to install an unexisting snap did not exit with an error"))
	c.Assert(string(output), testutil.Contains,
		"error: cannot perform the following tasks:\n"+
			"- Download snap \"unexisting.canonical\" from channel \"stable\" (snap not found)\n",
		check.Commentf("Wrong error message"))
}

func determinePayload(payload string) (string, error) {
	if _, err := os.Stat(payload); err == nil {
		// payload is a file, in order to make the snap file available to http we need to move it to its $SNAP_DATA path
		snapAppDataPath := filepath.Join("/var/lib/snaps", httpClientSnap, "current")
		if _, err := cli.ExecCommandErr("sudo", "cp", payload, snapAppDataPath); err != nil {
			return "", err
		}
		return "@" + filepath.Join(snapAppDataPath, filepath.Base(payload)), nil
	}
	// payload is a string
	return payload, nil
}

func (s *classicDimensionSuite) TestReEnableClassicMustPrintError(c *check.C) {
	c.Skip("Skipping until LP: #1563193 is fixed")
	s.enableClassic(c)
	defer s.destroyClassic(c)
	output, err := cli.ExecCommandErr("sudo", "snap", "enable-classic")

	c.Check(err, check.NotNil,
		check.Commentf("Trying to re-enable classic dimension did not exit with an error"))
	c.Assert(string(output), check.Equals,
		"Classic dimension is already enabled.\n",
		check.Commentf("Wrong error message"))
}

func (s *activateSuite) TestDeactivateRemovesBinary(c *check.C) {
	cli.ExecCommand(c, "sudo", "snappy", "deactivate", activateSnapName)
	defer cli.ExecCommand(c, "sudo", "snappy", "activate", activateSnapName)
	output, err := cli.ExecCommandErr(activateBinName)

	c.Assert(err, check.NotNil, check.Commentf("Deactivated snap binary did not exit with an error"))
	c.Assert(output, check.Not(check.Equals), activateEchoOutput,
		check.Commentf("Deactivated snap binary was not removed"))

	list := cli.ExecCommand(c, "snappy", "list", "-v")

	c.Assert(list, check.Matches, deActivatedPattern)
}

func setUpSnapd(c *check.C, fromBranch bool, extraEnv string) {
	cli.ExecCommand(c, "sudo", "systemctl", "stop",
		"snapd.service", "snapd.socket")

	if fromBranch {
		binPath, err := filepath.Abs("integration-tests/bin/snapd")
		c.Assert(err, check.IsNil)

		_, err = cli.ExecCommandErr("sudo", "mount", "-o", "bind",
			binPath, daemonBinaryPath)
		c.Assert(err, check.IsNil)
	}

	err := writeEnvConfig(extraEnv)
	c.Assert(err, check.IsNil)

	_, err = cli.ExecCommandErr("sudo", "systemctl", "daemon-reload")
	c.Assert(err, check.IsNil)

	_, err = cli.ExecCommandErr("sudo", "systemctl", "start", "snapd.service")
	c.Assert(err, check.IsNil)
}

func (s *purgeSuite) TestPurgeRemovesDataFromRemovedPackage(c *check.C) {
	common.RemoveSnap(c, data.BasicSnapName)

	versionSnapDataPath, err := getVersionSnapDataPath(snap)
	c.Assert(err, check.IsNil)

	_, err = os.Stat(versionSnapDataPath)
	c.Assert(err, check.IsNil)

	_, err = cli.ExecCommandErr("sudo", "snappy", "purge", snap)
	c.Assert(err, check.IsNil)

	_, err = os.Stat(versionSnapDataPath)
	c.Assert(os.IsNotExist(err), check.Equals, true)
}

func writeEnvConfig(extraEnv string) error {
	if _, err := cli.ExecCommandErr("sudo", "mkdir", "-p", cfgDir); err != nil {
		return err
	}

	cfgFile := filepath.Join(cfgDir, "env.conf")
	// FIXME: for now pass a test-only trusted key through an env var
	trustedKey, err := filepath.Abs("integration-tests/data/trusted.acckey")
	if err != nil {
		return err
	}

	cfgContent := []byte(fmt.Sprintf(`[Service]
Environment="SNAPPY_TRUSTED_ACCOUNT_KEY=%s" "%s"
`, trustedKey, extraEnv))
	if err = ioutil.WriteFile("/tmp/snapd.env.conf", cfgContent, os.ModeExclusive); err != nil {
		return err
	}

	if _, err = cli.ExecCommandErr("sudo", "mv", "/tmp/snapd.env.conf", cfgFile); err != nil {
		return err
	}
	return nil
}

// GetCurrentVersion returns the version of the installed and active package.
func GetCurrentVersion(c *check.C, packageName string) string {
	output, err := cli.ExecCommandErr("snap", "list")
	if err != nil {
		// XXX: right now "snap list" on freshly booted is empty
		// because u-d-f installed aren't in state
		return "verUnknown"
	}
	pattern := "(?mU)^" + packageName + " +(.*)$"
	re := regexp.MustCompile(pattern)
	match := re.FindStringSubmatch(string(output))
	c.Assert(match, check.NotNil, check.Commentf("Version of %s not found in %s", packageName, output))

	// match is like "ubuntu-core   2015-06-18 93        ubuntu"
	items := strings.Fields(match[0])
	return items[2]
}

func (s *grubSuite) TestGrubBootDirMustNotContainKernelFiles(c *check.C) {
	bootSystem, err := partition.BootSystem()
	c.Assert(err, check.IsNil, check.Commentf("Error getting boot system: %s", err))

	if bootSystem != "grub" {
		c.Skip("This test checks properties of grub based systems")
	}

	bootDir := partition.BootDir(bootSystem)
	for _, targetFile := range []string{"vmlinuz", "initrd.img"} {
		output, err := cli.ExecCommandErr("find", bootDir, "-name", fmt.Sprintf(`"%s"`, targetFile))

		c.Check(err, check.IsNil)
		c.Check(output, check.Equals, "")
	}
}

func (s *helloWorldExampleSuite) TestCallHelloWorldEvilMustPrintPermissionDeniedError(c *check.C) {
	common.InstallSnap(c, "hello-world/edge")
	s.AddCleanup(func() {
		common.RemoveSnap(c, "hello-world")
	})

	echoOutput, err := cli.ExecCommandErr("hello-world.evil")
	c.Assert(err, check.NotNil, check.Commentf("hello-world.evil did not fail"))

	expected := "" +
		"Hello Evil World!\n" +
		"This example demonstrates the app confinement\n" +
		"You should see a permission denied error next\n" +
		"/snaps/hello-world.canonical/.*/bin/evil: \\d+: " +
		"/snaps/hello-world.canonical/.*/bin/evil: " +
		"cannot create /var/tmp/myevil.txt: Permission denied\n"

	c.Assert(string(echoOutput), check.Matches, expected)
}

// makeRequest makes a request to the API according to the provided options.
func makeRequest(options *requestOptions) (body []byte, err error) {
	cmd := []string{"sudo", "http.do",
		"--pretty", "none",
		"--body",
		"--ignore-stdin",
		options.verb, options.resource}

	if options.payload != "" {
		payload, err := determinePayload(options.payload)
		if err != nil {
			return nil, err
		}
		if strings.HasPrefix(payload, "@") {
			defer os.Remove(payload[1:])
		}
		cmd = append(cmd, payload)
	}

	bodyString, err := cli.ExecCommandErr(append(cmd, "X-Allow-Unsigned:1")...)

	return []byte(bodyString), err
}