Add test cases for job param (#232)

* Add test cases for job param

* Improve test for job create

* Add test cases for job log

* Add test cases for job log command

* Add more test cases

* Add more test cases for crumbissuer

app/cmd/config_list.go

 package cmd
 
 import (
+	"bytes"
 	"fmt"
-	"os"
 
 	"github.com/jenkins-zh/jenkins-cli/util"
 	"github.com/spf13/cobra"
@@ -16,10 +16,11 @@ var configListCmd = &cobra.Command{
 	Use:   "list",
 	Short: "List all Jenkins config items",
 	Long:  `List all Jenkins config items`,
-	Run: func(_ *cobra.Command, _ []string) {
+	Run: func(cmd *cobra.Command, _ []string) {
 		current := getCurrentJenkins()
 
-		table := util.CreateTable(os.Stdout)
+		buf := new(bytes.Buffer)
+		table := util.CreateTable(buf)
 		table.AddRow("number", "name", "url", "description")
 		for i, jenkins := range getConfig().JenkinsServers {
 			name := jenkins.Name
@@ -27,11 +28,11 @@ var configListCmd = &cobra.Command{
 				name = fmt.Sprintf("*%s", name)
 			}
 			if len(jenkins.Description) > 15 {
-				table.AddRow(fmt.Sprintf("%d", i), name, jenkins.URL, jenkins.Description[0:15])
-			} else {
-				table.AddRow(fmt.Sprintf("%d", i), name, jenkins.URL, jenkins.Description)
+				jenkins.Description = jenkins.Description[0:15]
 			}
+			table.AddRow(fmt.Sprintf("%d", i), name, jenkins.URL, jenkins.Description)
 		}
 		table.Render()
+		cmd.Print(string(buf.Bytes()))
 	},
 }

app/cmd/config_list_test.go

+package cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+
+	"gopkg.in/yaml.v2"
+
+	"github.com/golang/mock/gomock"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("config list command", func() {
+	var (
+		ctrl *gomock.Controller
+	)
+
+	BeforeEach(func() {
+		ctrl = gomock.NewController(GinkgoT())
+		rootCmd.SetArgs([]string{})
+		rootOptions.Jenkins = ""
+		rootOptions.ConfigFile = "test.yaml"
+	})
+
+	AfterEach(func() {
+		rootCmd.SetArgs([]string{})
+		os.Remove(rootOptions.ConfigFile)
+		rootOptions.ConfigFile = ""
+		ctrl.Finish()
+	})
+
+	Context("basic cases", func() {
+		It("should success", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			rootCmd.SetArgs([]string{"config", "list"})
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+			Expect(buf.String()).To(Equal(`number name        url                           description
+0      *yourServer http://localhost:8080/jenkins 
+`))
+		})
+
+		It("with long description", func() {
+			config := getSampleConfig()
+			config.JenkinsServers[0].Description = "01234567890123456789"
+			data, err := yaml.Marshal(&config)
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			rootCmd.SetArgs([]string{"config", "list"})
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+			Expect(buf.String()).To(Equal(`number name        url                           description
+0      *yourServer http://localhost:8080/jenkins 012345678901234
+`))
+		})
+	})
+})

app/cmd/crumbIssuer.go

 package cmd
 
 import (
-	"crypto/tls"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
 	"net/http"
-	"net/url"
+
+	"github.com/jenkins-zh/jenkins-cli/app/helper"
+
+	"github.com/jenkins-zh/jenkins-cli/client"
 
 	"github.com/spf13/cobra"
 )
 
 // CrumbIssuerOptions contains the command line options
 type CrumbIssuerOptions struct {
-	Upload bool
+	RoundTripper http.RoundTripper
 }
 
 func init() {
-	rootCmd.AddCommand(versionCmd)
+	rootCmd.AddCommand(crumbIssuerCmd)
 }
 
-var versionCmd = &cobra.Command{
+var crumbIssuerOptions CrumbIssuerOptions
+
+var crumbIssuerCmd = &cobra.Command{
 	Use:   "crumb",
 	Short: "Print crumbIssuer of Jenkins",
 	Long:  `Print crumbIssuer of Jenkins`,
-	Run: func(_ *cobra.Command, _ []string) {
-		crumb, _ := getCrumb()
-		fmt.Printf("%s=%s", crumb.CrumbRequestField, crumb.Crumb)
-	},
-}
-
-// CrumbIssuer represents Jenkins crumb
-type CrumbIssuer struct {
-	Crumb             string `json:"crumb"`
-	CrumbRequestField string `json:"crumbRequestField"`
-}
-
-func getCrumb() (CrumbIssuer, *JenkinsServer) {
-	config := getCurrentJenkins()
+	Run: func(cmd *cobra.Command, _ []string) {
+		jenkinsCore := &client.JenkinsCore{RoundTripper: crumbIssuerOptions.RoundTripper}
+		getCurrentJenkinsAndClient(jenkinsCore)
 
-	jenkinsRoot := config.URL
-	api := fmt.Sprintf("%s/crumbIssuer/api/json", jenkinsRoot)
-
-	req, err := http.NewRequest("GET", api, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-	req.SetBasicAuth(config.UserName, config.Token)
-
-	var crumbIssuer CrumbIssuer
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-
-	if config.ProxyAuth != "" {
-		basicAuth := "Basic " + base64.StdEncoding.EncodeToString([]byte(config.ProxyAuth))
-		req.Header.Add("Proxy-Authorization", basicAuth)
-
-		tr.ProxyConnectHeader = http.Header{}
-		tr.ProxyConnectHeader.Add("Proxy-Authorization", basicAuth)
-
-		if proxyURL, err := url.Parse(config.Proxy); err == nil {
-			tr.Proxy = http.ProxyURL(proxyURL)
-		}
-	}
-	client := &http.Client{Transport: tr}
-	if response, err := client.Do(req); err == nil {
-		if data, err := ioutil.ReadAll(response.Body); err == nil {
-			if response.StatusCode == 200 {
-				json.Unmarshal(data, &crumbIssuer)
-			} else {
-				fmt.Println("get curmb error")
-				log.Fatal(string(data))
-			}
-		} else {
-			log.Fatal(err)
+		crumb, err := jenkinsCore.GetCrumb()
+		if err == nil {
+			cmd.Printf("%s=%s\n", crumb.CrumbRequestField, crumb.Crumb)
 		}
-	} else {
-		log.Fatal(err)
-	}
-	return crumbIssuer, config
+		helper.CheckErr(cmd, err)
+	},
 }

app/cmd/crumbissuer_test.go

+package cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+
+	"github.com/jenkins-zh/jenkins-cli/client"
+
+	"github.com/golang/mock/gomock"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/jenkins-zh/jenkins-cli/mock/mhttp"
+)
+
+var _ = Describe("crumb command", func() {
+	var (
+		ctrl         *gomock.Controller
+		roundTripper *mhttp.MockRoundTripper
+		jenkinsRoot  string
+		username     string
+		token        string
+	)
+
+	BeforeEach(func() {
+		ctrl = gomock.NewController(GinkgoT())
+		roundTripper = mhttp.NewMockRoundTripper(ctrl)
+		crumbIssuerOptions.RoundTripper = roundTripper
+		rootCmd.SetArgs([]string{})
+		rootOptions.Jenkins = ""
+		rootOptions.ConfigFile = "test.yaml"
+
+		jenkinsRoot = "http://localhost:8080/jenkins"
+		username = "admin"
+		token = "111e3a2f0231198855dceaff96f20540a9"
+	})
+
+	AfterEach(func() {
+		rootCmd.SetArgs([]string{})
+		os.Remove(rootOptions.ConfigFile)
+		rootOptions.ConfigFile = ""
+		ctrl.Finish()
+	})
+
+	Context("basic cases", func() {
+		It("should success", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			client.PrepareForGetIssuer(roundTripper, jenkinsRoot, username, token)
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			rootCmd.SetArgs([]string{"crumb"})
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+			Expect(buf.String()).To(Equal("CrumbRequestField=Crumb\n"))
+		})
+	})
+})

app/cmd/job_create.go

@@ -42,21 +42,18 @@ var jobCreateCmd = &cobra.Command{
 
 		var createMode string
 		var err error
-		if createMode, err = jobCreateOption.getCreateMode(jclient); err != nil {
-			cmd.PrintErrln(err)
-			return
-		}
-
-		payload := client.CreateJobPayload{
-			Name: jobName,
-			Mode: createMode,
-			From: jobCreateOption.Copy,
-		}
+		if createMode, err = jobCreateOption.getCreateMode(jclient); err == nil {
+			payload := client.CreateJobPayload{
+				Name: jobName,
+				Mode: createMode,
+				From: jobCreateOption.Copy,
+			}
 
-		if jobCreateOption.Copy != "" {
-			payload.Mode = "copy"
+			if jobCreateOption.Copy != "" {
+				payload.Mode = "copy"
+			}
+			err = jclient.Create(payload)
 		}
-		err = jclient.Create(payload)
 		helper.CheckErr(cmd, err)
 	},
 }

app/cmd/job_log.go

 package cmd
 
 import (
-	"fmt"
-	"log"
+	"net/http"
 	"time"
 
 	"github.com/jenkins-zh/jenkins-cli/client"
@@ -17,6 +16,8 @@ type JobLogOption struct {
 	LogText      string
 	LastBuildID  int
 	LastBuildURL string
+
+	RoundTripper http.RoundTripper
 }
 
 var jobLogOption JobLogOption
@@ -29,35 +30,38 @@ func init() {
 }
 
 var jobLogCmd = &cobra.Command{
-	Use:   "log <jobName>",
-	Short: "Print the job of your Jenkins",
-	Long:  `Print the job of your Jenkins`,
-	Args:  cobra.MinimumNArgs(1),
+	Use:   "log <jobName> [buildID]",
+	Short: "Print the job's log of your Jenkins",
+	Long: `Print the job's log of your Jenkins
+It'll print the log text of the last build if you don't give the build id.`,
+	Args: cobra.MinimumNArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		name := args[0]
-		jenkins := getCurrentJenkinsFromOptionsOrDie()
-		jclient := &client.JobClient{}
-		jclient.URL = jenkins.URL
-		jclient.UserName = jenkins.UserName
-		jclient.Token = jenkins.Token
-		jclient.Proxy = jenkins.Proxy
-		jclient.ProxyAuth = jenkins.ProxyAuth
+
+		jclient := &client.JobClient{
+			JenkinsCore: client.JenkinsCore{
+				RoundTripper: jobLogOption.RoundTripper,
+			},
+		}
+		getCurrentJenkinsAndClient(&(jclient.JenkinsCore))
 
 		lastBuildID := -1
+		var jobBuild *client.JobBuild
+		var err error
 		for {
-			if build, err := jclient.GetBuild(name, -1); err == nil {
-				jobLogOption.LastBuildID = build.Number
-				jobLogOption.LastBuildURL = build.URL
+			if jobBuild, err = jclient.GetBuild(name, -1); err == nil {
+				jobLogOption.LastBuildID = jobBuild.Number
+				jobLogOption.LastBuildURL = jobBuild.URL
 			}
 			if lastBuildID != jobLogOption.LastBuildID {
 				lastBuildID = jobLogOption.LastBuildID
-				fmt.Println("Current build number:", jobLogOption.LastBuildID)
-				fmt.Println("Current build url:", jobLogOption.LastBuildURL)
+				cmd.Println("Current build number:", jobLogOption.LastBuildID)
+				cmd.Println("Current build url:", jobLogOption.LastBuildURL)
 
-				printLog(jclient, name, jobLogOption.History, 0)
+				err = printLog(jclient, cmd, name, jobLogOption.History, 0)
 			}
 
-			if !jobLogOption.Watch {
+			if err != nil || !jobLogOption.Watch {
 				break
 			}
 
@@ -66,12 +70,13 @@ var jobLogCmd = &cobra.Command{
 	},
 }
 
-func printLog(jclient *client.JobClient, jobName string, history int, start int64) {
-	if status, err := jclient.Log(jobName, history, start); err == nil {
+func printLog(jclient *client.JobClient, cmd *cobra.Command, jobName string, history int, start int64) (err error) {
+	var jobLog client.JobLog
+	if jobLog, err = jclient.Log(jobName, history, start); err == nil {
 		isNew := false
 
-		if jobLogOption.LogText != status.Text {
-			jobLogOption.LogText = status.Text
+		if jobLogOption.LogText != jobLog.Text {
+			jobLogOption.LogText = jobLog.Text
 			isNew = true
 		} else if history == -1 {
 			if build, err := jclient.GetBuild(jobName, -1); err == nil && jobLogOption.LastBuildID != build.Number {
@@ -82,13 +87,12 @@ func printLog(jclient *client.JobClient, jobName string, history int, start int6
 		}
 
 		if isNew {
-			fmt.Print(status.Text)
+			cmd.Print(jobLog.Text)
 		}
 
-		if status.HasMore {
-			printLog(jclient, jobName, history, status.NextStart)
+		if jobLog.HasMore {
+			err = printLog(jclient, cmd, jobName, history, jobLog.NextStart)
 		}
-	} else {
-		log.Fatal(err)
 	}
+	return
 }

app/cmd/job_log_test.go

+package cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+
+	"github.com/jenkins-zh/jenkins-cli/client"
+
+	"github.com/golang/mock/gomock"
+	"github.com/jenkins-zh/jenkins-cli/mock/mhttp"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("job log command", func() {
+	var (
+		ctrl         *gomock.Controller
+		roundTripper *mhttp.MockRoundTripper
+		rootURL      string
+		username     string
+		token        string
+	)
+
+	BeforeEach(func() {
+		ctrl = gomock.NewController(GinkgoT())
+		roundTripper = mhttp.NewMockRoundTripper(ctrl)
+		jobLogOption.RoundTripper = roundTripper
+		rootCmd.SetArgs([]string{})
+		rootOptions.Jenkins = ""
+		rootOptions.ConfigFile = "test.yaml"
+
+		rootURL = "http://localhost:8080/jenkins"
+		username = "admin"
+		token = "111e3a2f0231198855dceaff96f20540a9"
+	})
+
+	AfterEach(func() {
+		rootCmd.SetArgs([]string{})
+		os.Remove(rootOptions.ConfigFile)
+		rootOptions.ConfigFile = ""
+		ctrl.Finish()
+	})
+
+	Context("basic cases, need RoundTripper", func() {
+		It("output the last build log", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			jobName := "fake"
+			client.PrepareForGetBuild(roundTripper, rootURL, jobName, -1, username, token)
+			client.PrepareForJobLog(roundTripper, rootURL, jobName, -1, username, token)
+			rootCmd.SetArgs([]string{"job", "log", jobName})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal("Current build number: 0\nCurrent build url: \nfake log"))
+		})
+	})
+})

app/cmd/job_param.go

@@ -2,8 +2,9 @@ package cmd
 
 import (
 	"encoding/json"
-	"fmt"
-	"log"
+	"net/http"
+
+	"github.com/jenkins-zh/jenkins-cli/app/helper"
 
 	"github.com/jenkins-zh/jenkins-cli/client"
 	"github.com/spf13/cobra"
@@ -14,6 +15,8 @@ type JobParamOption struct {
 	OutputOption
 
 	Indent bool
+
+	RoundTripper http.RoundTripper
 }
 
 var jobParamOption JobParamOption
@@ -26,24 +29,22 @@ func init() {
 
 var jobParamCmd = &cobra.Command{
 	Use:   "param <jobName>",
-	Short: "Get param of the job of your Jenkins",
-	Long:  `Get param of the job of your Jenkins`,
+	Short: "Get parameters of the job of your Jenkins",
+	Long:  `Get parameters of the job of your Jenkins`,
 	Args:  cobra.MinimumNArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		name := args[0]
-		jenkins := getCurrentJenkinsFromOptionsOrDie()
-		jclient := &client.JobClient{}
-		jclient.URL = jenkins.URL
-		jclient.UserName = jenkins.UserName
-		jclient.Token = jenkins.Token
-		jclient.Proxy = jenkins.Proxy
-		jclient.ProxyAuth = jenkins.ProxyAuth
+		jclient := &client.JobClient{
+			JenkinsCore: client.JenkinsCore{
+				RoundTripper: jobParamOption.RoundTripper,
+			},
+		}
+		getCurrentJenkinsAndClient(&(jclient.JenkinsCore))
 
-		if job, err := jclient.GetJob(name); err == nil {
+		job, err := jclient.GetJob(name)
+		var data []byte
+		if err == nil {
 			proCount := len(job.Property)
-			if jobBuildOption.Debug {
-				fmt.Println("Found properties ", proCount)
-			}
 			if proCount != 0 {
 				for _, pro := range job.Property {
 					if len(pro.ParameterDefinitions) == 0 {
@@ -51,23 +52,17 @@ var jobParamCmd = &cobra.Command{
 					}
 
 					if jobParamOption.Indent {
-						if data, err := json.MarshalIndent(pro.ParameterDefinitions, "", " "); err == nil {
-							fmt.Println(string(data))
-						} else {
-							log.Fatal(err)
-						}
+						data, err = json.MarshalIndent(pro.ParameterDefinitions, "", " ")
 					} else {
-						if data, err := json.Marshal(pro.ParameterDefinitions); err == nil {
-							fmt.Println(string(data))
-						} else {
-							log.Fatal(err)
-						}
+						data, err = json.Marshal(pro.ParameterDefinitions)
 					}
 					break
 				}
 			}
-		} else {
-			log.Fatal(err)
 		}
+		if err == nil && len(data) > 0 {
+			cmd.Println(string(data))
+		}
+		helper.CheckErr(cmd, err)
 	},
 }

app/cmd/job_param_test.go

+package cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+
+	"github.com/jenkins-zh/jenkins-cli/client"
+
+	"github.com/golang/mock/gomock"
+	"github.com/jenkins-zh/jenkins-cli/mock/mhttp"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("job search command", func() {
+	var (
+		ctrl         *gomock.Controller
+		roundTripper *mhttp.MockRoundTripper
+		rootURL      string
+		username     string
+		token        string
+	)
+
+	BeforeEach(func() {
+		ctrl = gomock.NewController(GinkgoT())
+		roundTripper = mhttp.NewMockRoundTripper(ctrl)
+		jobParamOption.RoundTripper = roundTripper
+		rootCmd.SetArgs([]string{})
+		rootOptions.Jenkins = ""
+		rootOptions.ConfigFile = "test.yaml"
+
+		rootURL = "http://localhost:8080/jenkins"
+		username = "admin"
+		token = "111e3a2f0231198855dceaff96f20540a9"
+	})
+
+	AfterEach(func() {
+		rootCmd.SetArgs([]string{})
+		os.Remove(rootOptions.ConfigFile)
+		rootOptions.ConfigFile = ""
+		ctrl.Finish()
+	})
+
+	Context("basic cases, need RoundTripper", func() {
+		It("without parameters", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			jobName := "fake"
+			client.PrepareForGetJob(roundTripper, rootURL, jobName, username, token)
+			rootCmd.SetArgs([]string{"job", "param", jobName})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal(""))
+		})
+
+		It("with one parameter", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			jobName := "fake"
+			client.PrepareForGetJobWithParams(roundTripper, rootURL, jobName, username, token)
+			rootCmd.SetArgs([]string{"job", "param", jobName})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal("[{\"Description\":\"\",\"name\":\"name\",\"Type\":\"StringParameterDefinition\",\"value\":\"\",\"DefaultParameterValue\":{\"Description\":\"\",\"Value\":\"jake\"}}]\n"))
+		})
+
+		It("with one parameter, output with indent", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			jobName := "fake"
+			client.PrepareForGetJobWithParams(roundTripper, rootURL, jobName, username, token)
+			rootCmd.SetArgs([]string{"job", "param", jobName, "--indent=true"})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal("[\n {\n  \"Description\": \"\",\n  \"name\": \"name\",\n  \"Type\": \"StringParameterDefinition\",\n  \"value\": \"\",\n  \"DefaultParameterValue\": {\n   \"Description\": \"\",\n   \"Value\": \"jake\"\n  }\n }\n]\n"))
+		})
+	})
+})

app/cmd/plugin_install.go

@@ -2,55 +2,79 @@ package cmd
 
 import (
 	"fmt"
-	"log"
+	"github.com/jenkins-zh/jenkins-cli/app/helper"
+	"net/http"
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/jenkins-zh/jenkins-cli/client"
 	"github.com/spf13/cobra"
 )
 
+// PluginInstallOption is the option for plugin install
+type PluginInstallOption struct {
+	UseMirror    bool
+	ShowProgress bool
+
+	RoundTripper http.RoundTripper
+}
+
+var pluginInstallOption PluginInstallOption
+
 func init() {
 	pluginCmd.AddCommand(pluginInstallCmd)
+	pluginInstallCmd.Flags().BoolVarP(&pluginInstallOption.UseMirror, "use-mirror", "", true,
+		"If you want to download plugin from a mirror site")
+	pluginInstallCmd.Flags().BoolVarP(&pluginInstallOption.ShowProgress, "show-progress", "", true,
+		"If you want to show the progress of download a plugin")
 	pluginInstallCmd.Flags().StringVarP(&pluginOpt.Suite, "suite", "", "", "Suite of plugins")
 }
 
 var pluginInstallCmd = &cobra.Command{
 	Use:   "install [pluginName]",
 	Short: "Install the plugins",
-	Long:  `Install the plugins`,
-	Run: func(_ *cobra.Command, args []string) {
-		jenkins := getCurrentJenkinsFromOptionsOrDie()
-		jclient := &client.PluginManager{}
-		jclient.URL = jenkins.URL
-		jclient.UserName = jenkins.UserName
-		jclient.Token = jenkins.Token
-		jclient.Proxy = jenkins.Proxy
-		jclient.ProxyAuth = jenkins.ProxyAuth
+	Long: `Install the plugins
+Allow you to install a plugin with or without the version`,
+	Example: `jcli plugin install localization-zh-cn
+jcli plugin install localization-zh-cn@1.0.9
+`,
+	Run: func(cmd *cobra.Command, args []string) {
+		jclient := &client.PluginManager{
+			JenkinsCore: client.JenkinsCore{
+				RoundTripper: pluginInstallOption.RoundTripper,
+			},
+			ShowProgress: pluginInstallOption.ShowProgress,
+			UseMirror:    pluginInstallOption.UseMirror,
+			MirrorURL:    getDefaultMirror(),
+		}
+		getCurrentJenkinsAndClient(&(jclient.JenkinsCore))
+
 		plugins := make([]string, len(args))
 		plugins = append(plugins, args...)
 
+		var err error
 		if pluginOpt.Suite != "" {
 			if suite := findSuiteByName(pluginOpt.Suite); suite != nil {
 				plugins = append(plugins, suite.Plugins...)
 			} else {
-				log.Fatal("Cannot found suite", pluginOpt.Suite)
+				err = fmt.Errorf("cannot found suite %s", pluginOpt.Suite)
 			}
 		}
 
-		if len(plugins) == 0 {
+		if err == nil && len(plugins) == 0 {
 			for {
 				var keyword string
 				prompt := &survey.Input{Message: "Please input the keyword to search your plugin!"}
-				if err := survey.AskOne(prompt, &keyword); err != nil {
-					log.Fatal(err)
+				if err = survey.AskOne(prompt, &keyword); err != nil {
+					break
 				}
 
-				if availablePlugins, err := jclient.GetAvailablePlugins(); err == nil {
+				var availablePlugins *client.AvailablePluginList
+				if availablePlugins, err = jclient.GetAvailablePlugins(); err == nil {
 					matchedPlugins := searchPlugins(availablePlugins, keyword)
-					optinalPlugins := convertToArray(matchedPlugins)
+					optionalPlugins := convertToArray(matchedPlugins)
 
-					if len(optinalPlugins) == 0 {
-						fmt.Println("Cannot find any plugins by your keyword, or they already installed.")
+					if len(optionalPlugins) == 0 {
+						cmd.Println("Cannot find any plugins by your keyword, or they already installed.")
 						continue
 					}
 
@@ -59,26 +83,28 @@ var pluginInstallCmd = &cobra.Command{
 						Options: convertToArray(matchedPlugins),
 					}
 					selectedPlugins := []string{}
-					survey.AskOne(prompt, &selectedPlugins)
+					if err = survey.AskOne(prompt, &selectedPlugins); err != nil {
+						break
+					}
 					plugins = append(plugins, selectedPlugins...)
-
-					break
-				} else {
-					log.Fatal(err)
 				}
+				break
 			}
 
-			fmt.Println("Going to install", plugins)
+			cmd.Println("Going to install", plugins)
 		}
 
-		jclient.InstallPlugin(plugins)
+		if err == nil {
+			err = jclient.InstallPlugin(plugins)
+		}
+		helper.CheckErr(cmd, err)
 	},
 }
 
-func convertToArray(aviablePlugins []client.AvailablePlugin) (plugins []string) {
+func convertToArray(availablePlugins []client.AvailablePlugin) (plugins []string) {
 	plugins = make([]string, 0)
 
-	for _, plugin := range aviablePlugins {
+	for _, plugin := range availablePlugins {
 		if plugin.Installed {
 			continue
 		}

app/cmd/plugin_install_test.go

+package cmd
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+
+	"github.com/golang/mock/gomock"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/jenkins-zh/jenkins-cli/client"
+	"github.com/jenkins-zh/jenkins-cli/mock/mhttp"
+)
+
+var _ = Describe("plugin install command", func() {
+	var (
+		ctrl         *gomock.Controller
+		roundTripper *mhttp.MockRoundTripper
+		rootURL      string
+		username     string
+		token        string
+
+		pluginName string
+	)
+
+	BeforeEach(func() {
+		ctrl = gomock.NewController(GinkgoT())
+		roundTripper = mhttp.NewMockRoundTripper(ctrl)
+		pluginInstallOption.RoundTripper = roundTripper
+		rootCmd.SetArgs([]string{})
+		rootOptions.Jenkins = ""
+		rootOptions.ConfigFile = "test.yaml"
+
+		rootURL = "http://localhost:8080/jenkins"
+		username = "admin"
+		token = "111e3a2f0231198855dceaff96f20540a9"
+
+		pluginName = "fake"
+	})
+
+	AfterEach(func() {
+		rootCmd.SetArgs([]string{})
+		os.Remove(rootOptions.ConfigFile)
+		rootOptions.ConfigFile = ""
+		ctrl.Finish()
+	})
+
+	Context("basic cases", func() {
+		It("install one plugin", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			client.PrepareForInstallPlugin(roundTripper, rootURL, pluginName, username, token)
+
+			rootCmd.SetArgs([]string{"plugin", "install", pluginName})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal(""))
+		})
+
+		It("unknow suite", func() {
+			data, err := generateSampleConfig()
+			Expect(err).To(BeNil())
+			err = ioutil.WriteFile(rootOptions.ConfigFile, data, 0664)
+			Expect(err).To(BeNil())
+
+			rootCmd.SetArgs([]string{"plugin", "install", pluginName, "--suite", "fake"})
+
+			buf := new(bytes.Buffer)
+			rootCmd.SetOutput(buf)
+			_, err = rootCmd.ExecuteC()
+			Expect(err).To(BeNil())
+
+			Expect(buf.String()).To(Equal("cannot found suite fake\n"))
+		})
+	})
+
+	Context("convertToArray", func() {
+		It("empty plugins", func() {
+			plugins := make([]client.AvailablePlugin, 0)
+			result := convertToArray(plugins)
+			Expect(result).NotTo(BeNil())
+			Expect(len(result)).To(Equal(0))
+		})
+
+		It("all installed plugins", func() {
+			plugins := []client.AvailablePlugin{{
+				Installed: true,
+			}}
+			result := convertToArray(plugins)
+			Expect(result).NotTo(BeNil())
+			Expect(len(result)).To(Equal(0))
+		})
+
+		It("one no installed plugin", func() {
+			plugins := []client.AvailablePlugin{{
+				Installed: false,
+				Name:      "fake",
+			}}
+			result := convertToArray(plugins)
+			Expect(result).NotTo(BeNil())
+			Expect(len(result)).To(Equal(1))
+		})
+	})
+})

app/cmd/plugin_list.go

@@ -3,7 +3,7 @@ package cmd
 import (
 	"bytes"
 	"fmt"
-	"log"
+	"github.com/jenkins-zh/jenkins-cli/app/helper"
 	"net/http"
 	"strings"
 
@@ -71,7 +71,9 @@ var pluginListCmd = &cobra.Command{
 			}
 		}
 
-		if plugins, err := jclient.GetPlugins(); err == nil {
+		var err error
+		var plugins *client.InstalledPluginList
+		if plugins, err = jclient.GetPlugins(); err == nil {
 			filteredPlugins := make([]client.InstalledPlugin, 0)
 			for _, plugin := range plugins.Plugins {
 				if filter {
@@ -99,16 +101,12 @@ var pluginListCmd = &cobra.Command{
 				}
 			}
 
-			if data, err := pluginListOption.Output(filteredPlugins); err == nil {
-				if len(data) > 0 {
-					cmd.Print(string(data))
-				}
-			} else {
-				log.Fatal(err)
+			var data []byte
+			if data, err = pluginListOption.Output(filteredPlugins); err == nil && len(data) > 0 {
+				cmd.Print(string(data))
 			}
-		} else {
-			log.Fatal(err)
 		}
+		helper.CheckErr(cmd, err)
 	},
 }
 

app/cmd/plugin_upload.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"github.com/jenkins-zh/jenkins-cli/app/helper"
 	"io/ioutil"
 	"log"
 	"net/http"
@@ -117,6 +118,7 @@ jcli plugin upload sample.hpi --show-progress=false`,
 			defer os.Remove(pluginUploadOption.pluginFilePath)
 		}
 
-		jclient.Upload(pluginUploadOption.pluginFilePath)
+		err := jclient.Upload(pluginUploadOption.pluginFilePath)
+		helper.CheckErr(cmd, err)
 	},
 }

client/common_test.go

@@ -116,7 +116,7 @@ var _ = Describe("common test", func() {
 		})
 
 		It("with crumb setting", func() {
-			RequestCrumb(roundTripper, jenkinsCore.URL)
+			PrepareForGetIssuer(roundTripper, jenkinsCore.URL, "", "")
 
 			crumb, err := jenkinsCore.GetCrumb()
 			Expect(err).To(BeNil())
@@ -126,15 +126,16 @@ var _ = Describe("common test", func() {
 		})
 
 		It("with error from server", func() {
-			requestCrumb, _ := http.NewRequest("GET", fmt.Sprintf("%s%s", jenkinsCore.URL, "/crumbIssuer/api/json"), nil)
-			responseCrumb := &http.Response{
-				StatusCode: 500,
-				Proto:      "HTTP/1.1",
-				Request:    requestCrumb,
-				Body:       ioutil.NopCloser(bytes.NewBufferString("")),
-			}
-			roundTripper.EXPECT().
-				RoundTrip(requestCrumb).Return(responseCrumb, nil)
+			//requestCrumb, _ := http.NewRequest("GET", fmt.Sprintf("%s%s", jenkinsCore.URL, "/crumbIssuer/api/json"), nil)
+			//responseCrumb := &http.Response{
+			//	StatusCode: 500,
+			//	Proto:      "HTTP/1.1",
+			//	Request:    requestCrumb,
+			//	Body:       ioutil.NopCloser(bytes.NewBufferString("")),
+			//}
+			//roundTripper.EXPECT().
+			//	RoundTrip(requestCrumb).Return(responseCrumb, nil)
+			PrepareForGetIssuerWith500(roundTripper, jenkinsCore.URL, "", "")
 
 			_, err := jenkinsCore.GetCrumb()
 			Expect(err).To(HaveOccurred())

client/common_test_common.go

+package client
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/jenkins-zh/jenkins-cli/mock/mhttp"
+)
+
+// PrepareForGetIssuer only for test
+func PrepareForGetIssuer(roundTripper *mhttp.MockRoundTripper, rootURL, user, password string) (
+	request *http.Request, response *http.Response) {
+	request, _ = http.NewRequest("GET", fmt.Sprintf("%s%s", rootURL, "/crumbIssuer/api/json"), nil)
+	response = &http.Response{
+		StatusCode: 200,
+		Request:    request,
+		Body:       ioutil.NopCloser(bytes.NewBufferString(`{"CrumbRequestField":"CrumbRequestField","Crumb":"Crumb"}`)),
+	}
+	roundTripper.EXPECT().
+		RoundTrip(request).Return(response, nil)
+	if user != "" && password != "" {
+		request.SetBasicAuth(user, password)
+	}
+	return
+}
+
+// PrepareForGetIssuerWith500 only for test
+func PrepareForGetIssuerWith500(roundTripper *mhttp.MockRoundTripper, rootURL, user, password string) {
+	_, response := PrepareForGetIssuer(roundTripper, rootURL, user, password)
+	response.StatusCode = 500
+}

client/job.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"net/url"
 	"strconv"
@@ -102,9 +101,6 @@ func (q *JobClient) GetJobTypeCategories() (jobCategories []JobCategory, err err
 			jobCategories = result.Categories
 		} else {
 			err = fmt.Errorf("unexpected status code: %d", statusCode)
-			if q.Debug {
-				ioutil.WriteFile("debug.html", data, 0664)
-			}
 		}
 	}
 	return
@@ -153,9 +149,9 @@ func (q *JobClient) Log(jobName string, history int, start int64) (jobLog JobLog
 	path := parseJobPath(jobName)
 	var api string
 	if history == -1 {
-		api = fmt.Sprintf("%s/%s/lastBuild/logText/progressiveText?start=%d", q.URL, path, start)
+		api = fmt.Sprintf("%s%s/lastBuild/logText/progressiveText?start=%d", q.URL, path, start)
 	} else {
-		api = fmt.Sprintf("%s/%s/%d/logText/progressiveText?start=%d", q.URL, path, history, start)
+		api = fmt.Sprintf("%s%s/%d/logText/progressiveText?start=%d", q.URL, path, history, start)
 	}
 	var (
 		req      *http.Request
@@ -164,8 +160,9 @@ func (q *JobClient) Log(jobName string, history int, start int64) (jobLog JobLog
 
 	req, err = http.NewRequest("GET", api, nil)
 	if err == nil {
-		q.AuthHandle(req)
-	} else {
+		err = q.AuthHandle(req)
+	}
+	if err != nil {
 		return
 	}
 
@@ -186,11 +183,7 @@ func (q *JobClient) Log(jobName string, history int, start int64) (jobLog JobLog
 				jobLog.HasMore = strings.ToLower(response.Header.Get("X-More-Data")) == "true"
 				jobLog.NextStart, _ = strconv.ParseInt(response.Header.Get("X-Text-Size"), 10, 64)
 			}
-		} else {
-			log.Fatal(string(data))
 		}
-	} else {
-		log.Fatal(err)
 	}
 	return
 }
@@ -226,7 +219,6 @@ func (q *JobClient) Create(jobPayload CreateJobPayload) (err error) {
 func (q *JobClient) Delete(jobName string) (err error) {
 	var (
 		statusCode int
-		data       []byte
 	)
 
 	api := fmt.Sprintf("/job/%s/doDelete", jobName)
@@ -234,12 +226,9 @@ func (q *JobClient) Delete(jobName string) (err error) {
 		util.ContentType: util.ApplicationForm,
 	}
 
-	if statusCode, data, err = q.Request("POST", api, header, nil); err == nil {
+	if statusCode, _, err = q.Request("POST", api, header, nil); err == nil {
 		if statusCode != 200 && statusCode != 302 {
 			err = fmt.Errorf("unexpected status code: %d", statusCode)
-			if q.Debug {
-				ioutil.WriteFile("debug.html", data, 0664)
-			}
 		}
 	}
 	return

client/job_test.go

@@ -369,4 +369,26 @@ var _ = Describe("job test", func() {
 			Expect(len(builds)).To(Equal(2))
 		})
 	})
+
+	Context("Log", func() {
+		It("with a specific build number", func() {
+			jobName := "fakeJob"
+
+			PrepareForJobLog(roundTripper, jobClient.URL, jobName, 1, "", "")
+
+			log, err := jobClient.Log(jobName, 1, 0)
+			Expect(err).To(BeNil())
+			Expect(log.Text).To(Equal("fake log"))
+		})
+
+		It("get the last job's log", func() {
+			jobName := "fakeJob"
+
+			PrepareForJobLog(roundTripper, jobClient.URL, jobName, -1, "", "")
+
+			log, err := jobClient.Log(jobName, -1, 0)
+			Expect(err).To(BeNil())
+			Expect(log.Text).To(Equal("fake log"))
+		})
+	})
 })

client/job_test_common.go

@@ -74,9 +74,10 @@ func PrepareForBuildWithParams(roundTripper *mhttp.MockRoundTripper, rootURL, jo
 }
 
 // PrepareForGetJob only for test
-func PrepareForGetJob(roundTripper *mhttp.MockRoundTripper, rootURL, jobName, user, password string) {
+func PrepareForGetJob(roundTripper *mhttp.MockRoundTripper, rootURL, jobName, user, password string) (
+	response *http.Response) {
 	request, _ := http.NewRequest("GET", fmt.Sprintf("%s/job/%s/api/json", rootURL, jobName), nil)
-	response := &http.Response{
+	response = &http.Response{
 		StatusCode: 200,
 		Proto:      "HTTP/1.1",
 		Request:    request,
@@ -98,11 +99,53 @@ func PrepareForGetJob(roundTripper *mhttp.MockRoundTripper, rootURL, jobName, us
 	if user != "" && password != "" {
 		request.SetBasicAuth(user, password)
 	}
+	return
+}
+
+// PrepareForGetJobWithParams only for test
+func PrepareForGetJobWithParams(roundTripper *mhttp.MockRoundTripper, rootURL, jobName, user, password string) {
+	response := PrepareForGetJob(roundTripper, rootURL, jobName, user, password)
+	response.Body = ioutil.NopCloser(bytes.NewBufferString(fmt.Sprintf(`{
+  "name" : "%s",
+  "builds" : [
+    {
+      "number" : 1,
+      "url" : "http://localhost:8080/job/we/1/"
+    },
+    {
+      "number" : 2,
+      "url" : "http://localhost:8080/job/we/2/"
+    }],
+  "property" : [
+    {
+      "_class" : "io.alauda.jenkins.devops.sync.WorkflowJobProperty"
+    },
+    {
+      "parameterDefinitions" : [
+        {
+          "defaultParameterValue" : {
+            "name" : "name",
+            "value" : "jake"
+          },
+          "description" : "",
+          "name" : "name",
+          "type" : "StringParameterDefinition"
+        }
+      ]
+    }
+  ]
+}`, jobName)))
 }
 
 // PrepareForGetBuild only for test
 func PrepareForGetBuild(roundTripper *mhttp.MockRoundTripper, rootURL, jobName string, buildID int, user, password string) {
-	request, _ := http.NewRequest("GET", fmt.Sprintf("%s/job/%s/%d/api/json", rootURL, jobName, buildID), nil)
+	api := ""
+	if buildID == -1 {
+		api = fmt.Sprintf("%s/job/%s/lastBuild/api/json", rootURL, jobName)
+	} else {
+		api = fmt.Sprintf("%s/job/%s/%d/api/json", rootURL, jobName, buildID)
+	}
+	request, _ := http.NewRequest("GET", api, nil)
 	response := &http.Response{
 		StatusCode: 200,
 		Proto:      "HTTP/1.1",
@@ -117,3 +160,28 @@ func PrepareForGetBuild(roundTripper *mhttp.MockRoundTripper, rootURL, jobName s
 		request.SetBasicAuth(user, password)
 	}
 }
+
+// PrepareForJobLog only for test
+func PrepareForJobLog(roundTripper *mhttp.MockRoundTripper, rootURL, jobName string, buildID int, user, password string) {
+	var api string
+	if buildID == -1 {
+		api = fmt.Sprintf("%s/job/%s/lastBuild/logText/progressiveText?start=%d", rootURL, jobName, 0)
+	} else {
+		api = fmt.Sprintf("%s/job/%s/%d/logText/progressiveText?start=%d", rootURL, jobName, buildID, 0)
+	}
+	request, _ := http.NewRequest("GET", api, nil)
+	response := &http.Response{
+		StatusCode: 200,
+		Request:    request,
+		Header: map[string][]string{
+			"X-More-Data": []string{"false"},
+			"X-Text-Size": []string{"8"},
+		},
+		Body: ioutil.NopCloser(bytes.NewBufferString("fake log")),
+	}
+	roundTripper.EXPECT().
+		RoundTrip(request).Return(response, nil)
+	if user != "" && password != "" {
+		request.SetBasicAuth(user, password)
+	}
+}

client/pluginApi.go

@@ -154,18 +154,13 @@ func (d *PluginAPI) getPlugin(name string) (plugin *PluginInfo, err error) {
 	pluginAPI := fmt.Sprintf("https://plugins.jenkins.io/api/plugin/%s", name)
 	logger.Debug("fetch data from plugin API", zap.String("url", pluginAPI))
 
-	resp, err := cli.Get(pluginAPI)
-	if err != nil {
-		return plugin, err
-	}
-
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-
-	plugin = &PluginInfo{}
-	err = json.Unmarshal(body, plugin)
-	if err != nil {
-		log.Println("error when unmarshal:", string(body))
+	var resp *http.Response
+	if resp, err = cli.Get(pluginAPI); err == nil {
+		var body []byte
+		if body, err = ioutil.ReadAll(resp.Body); err == nil {
+			plugin = &PluginInfo{}
+			err = json.Unmarshal(body, plugin)
+		}
 	}
 	return
 }

client/pluginApi_test_common.go

@@ -56,17 +56,17 @@ func PrepareOnePluginWithOptionalDep(roundTripper *mhttp.MockRoundTripper, plugi
 }
 
 // PrepareDownloadPlugin only for test
-func PrepareDownloadPlugin(roundTripper *mhttp.MockRoundTripper) {
+func PrepareDownloadPlugin(roundTripper *mhttp.MockRoundTripper) (response *http.Response) {
 	request, _ := http.NewRequest("GET",
 		"http://updates.jenkins-ci.org/download/plugins/hugo/0.1.8/hugo.hpi", nil)
-	response := &http.Response{
+	response = &http.Response{
 		StatusCode: 200,
-		Proto:      "HTTP/1.1",
 		Request:    request,
 		Body:       ioutil.NopCloser(bytes.NewBufferString("")),
 	}
 	roundTripper.EXPECT().
 		RoundTrip(request).Return(response, nil)
+	return
 }
 
 // PrepareCheckUpdate only for test

client/pluginManager_test.go

@@ -141,24 +141,30 @@ var _ = Describe("PluginManager test", func() {
 			Expect(err).To(BeNil())
 		})
 
-		It("normal case with version, should success", func() {
-			PrepareForInstallPluginWithVersion(roundTripper, pluginMgr.URL, pluginName, "1.0", "", "")
+		It("upload a plugin with a specific version, should success", func() {
+			pluginName = "hugo"
+			version := "0.1.8"
+			PrepareDownloadPlugin(roundTripper)
+			PrepareForUploadPlugin(roundTripper, pluginMgr.URL)
 
-			err := pluginMgr.InstallPlugin([]string{pluginName + "@" + "1.0"})
+			err := pluginMgr.InstallPlugin([]string{pluginName + "@" + version})
 			Expect(err).To(BeNil())
 		})
 
-		It("with 400", func() {
-			PrepareForInstallPluginWithCode(roundTripper, 400, pluginMgr.URL, pluginName, "", "")
+		It("upload a not exists plugin", func() {
+			pluginName = "hugo"
+			version := "0.1.8"
+			response := PrepareDownloadPlugin(roundTripper)
+			response.StatusCode = 400
 
-			err := pluginMgr.InstallPlugin([]string{pluginName})
+			err := pluginMgr.InstallPlugin([]string{pluginName + "@" + version})
 			Expect(err).NotTo(BeNil())
 		})
 
-		It("with 400 & version", func() {
-			PrepareForInstallPluginWithCode(roundTripper, 400, pluginMgr.URL, pluginName + "@" + "1.0", "", "")
+		It("with 400", func() {
+			PrepareForInstallPluginWithCode(roundTripper, 400, pluginMgr.URL, pluginName, "", "")
 
-			err := pluginMgr.InstallPlugin([]string{pluginName + "@" + "1.0"})
+			err := pluginMgr.InstallPlugin([]string{pluginName})
 			Expect(err).NotTo(BeNil())
 		})
 

client/pluginManger.go

@@ -18,6 +18,8 @@ import (
 type PluginManager struct {
 	JenkinsCore
 
+	UseMirror    bool
+	MirrorURL    string
 	ShowProgress bool
 }
 
@@ -104,45 +106,69 @@ func (p *PluginManager) getPluginsInstallQuery(names []string) string {
 			pluginNames = append(pluginNames, fmt.Sprintf("plugin.%s=", name))
 		}
 	}
+	if len(pluginNames) == 0 {
+		return ""
+	}
 	return strings.Join(pluginNames, "&")
 }
 
-func (p *PluginManager) getVersionalPlugins(names []string) string {
+func (p *PluginManager) getVersionalPlugins(names []string) []string {
 	pluginNames := make([]string, 0)
 	for _, name := range names {
 		if strings.Contains(name, "@") {
-			if err := p.installPluginWithVersion(name); err != nil {
-				fmt.Println(err)
-			}
-			pluginNames = append(pluginNames, fmt.Sprintf("plugin.%s,", name))
+			pluginNames = append(pluginNames, name)
 		}
 	}
-	return strings.Join(pluginNames, "&")
+	return pluginNames
 }
 
 // InstallPlugin install a plugin by name
 func (p *PluginManager) InstallPlugin(names []string) (err error) {
-	api := fmt.Sprintf("/pluginManager/install?%s", p.getPluginsInstallQuery(names))
+	plugins := p.getPluginsInstallQuery(names)
 	versionalPlugins := p.getVersionalPlugins(names)
-	fmt.Println(versionalPlugins)
+	if plugins != "" {
+		err = p.installPluginsWithoutVersion(plugins)
+	}
 
+	if err == nil && len(versionalPlugins) > 0 {
+		err = p.installPluginsWithVersion(versionalPlugins)
+	}
+	return
+}
+
+func (p *PluginManager) installPluginsWithoutVersion(plugins string) (err error) {
+	api := fmt.Sprintf("/pluginManager/install?%s", plugins)
 	var response *http.Response
 	response, err = p.RequestWithResponse("POST", api, nil, nil)
-	if response.StatusCode == 400 {
+	if response != nil && response.StatusCode == 400 {
 		if errMsg, ok := response.Header["X-Error"]; ok {
 			for _, msg := range errMsg {
 				err = fmt.Errorf(msg)
 			}
 		} else {
-			err = fmt.Errorf("Cannot found plugins %v", names)
+			err = fmt.Errorf("cannot found plugins %s", plugins)
 		}
 	}
 	return
 }
 
-// InstallPluginWithVersion install a plugin by name & version
+func (p *PluginManager) installPluginsWithVersion(plugins []string) (err error) {
+	for _, plugin := range plugins {
+		if err = p.installPluginWithVersion(plugin); err != nil {
+			break
+		}
+	}
+	return
+}
+
+// installPluginWithVersion install a plugin by name & version
 func (p *PluginManager) installPluginWithVersion(name string) (err error) {
-	pluginAPI := PluginAPI{}
+	pluginAPI := PluginAPI{
+		RoundTripper: p.RoundTripper,
+		UseMirror:    p.UseMirror,
+		MirrorURL:    p.MirrorURL,
+		ShowProgress: p.ShowProgress,
+	}
 	pluginName := "%s.hpi"
 	pluginVersion := strings.Split(name, "@")
 
@@ -150,14 +176,11 @@ func (p *PluginManager) installPluginWithVersion(name string) (err error) {
 	url := fmt.Sprintf("http://updates.jenkins-ci.org/download/plugins/%s/%s/%s.hpi",
 		pluginVersion[0], pluginVersion[1], pluginVersion[0])
 
-	if err := pluginAPI.download(url, name); err != nil {
-		return err
-	}
-
-	if err = p.Upload(fmt.Sprintf(pluginName, name)); err != nil {
-		return err
+	url = pluginAPI.getMirrorURL(url)
+	if err = pluginAPI.download(url, name); err == nil {
+		err = p.Upload(fmt.Sprintf(pluginName, name))
 	}
-	return nil
+	return
 }
 
 // UninstallPlugin uninstall a plugin by name

client/test_methods.go

@@ -185,7 +185,7 @@ func PrepareForUploadPlugin(roundTripper *mhttp.MockRoundTripper, rootURL string
 		RoundTrip(NewRequestMatcher(request)).Return(response, nil)
 
 	// common crumb request
-	requestCrumb, responseCrumb = RequestCrumb(roundTripper, rootURL)
+	requestCrumb, responseCrumb = PrepareForGetIssuer(roundTripper, rootURL, "", "")
 	return
 }
 
@@ -203,7 +203,7 @@ func PrepareForUninstallPlugin(roundTripper *mhttp.MockRoundTripper, rootURL, pl
 		RoundTrip(NewRequestMatcher(request)).Return(response, nil)
 
 	// common crumb request
-	requestCrumb, responseCrumb = RequestCrumb(roundTripper, rootURL)
+	requestCrumb, responseCrumb = PrepareForGetIssuer(roundTripper, rootURL, "", "")
 	return
 }
 
@@ -227,11 +227,10 @@ func PrepareCancelQueue(roundTripper *mhttp.MockRoundTripper, rootURL, user, pas
 	}
 	roundTripper.EXPECT().
 		RoundTrip(request).Return(response, nil)
-	requestCrumb, _ := RequestCrumb(roundTripper, rootURL)
+	PrepareForGetIssuer(roundTripper, rootURL, user, passwd)
 
 	if user != "" && passwd != "" {
 		request.SetBasicAuth(user, passwd)
-		requestCrumb.SetBasicAuth(user, passwd)
 	}
 }
 
@@ -274,22 +273,6 @@ func PrepareGetQueue(roundTripper *mhttp.MockRoundTripper, rootURL, user, passwd
 	}
 }
 
-// RequestCrumb only for the test case
-func RequestCrumb(roundTripper *mhttp.MockRoundTripper, rootURL string) (
-	requestCrumb *http.Request, responseCrumb *http.Response) {
-	requestCrumb, _ = http.NewRequest("GET", fmt.Sprintf("%s%s", rootURL, "/crumbIssuer/api/json"), nil)
-	responseCrumb = &http.Response{
-		StatusCode: 200,
-		Request:    requestCrumb,
-		Body: ioutil.NopCloser(bytes.NewBufferString(`
-		{"CrumbRequestField":"CrumbRequestField","Crumb":"Crumb"}
-		`)),
-	}
-	roundTripper.EXPECT().
-		RoundTrip(requestCrumb).Return(responseCrumb, nil)
-	return
-}
-
 // PrepareForRequestUpdateCenter only for the test case
 func PrepareForRequestUpdateCenter(roundTripper *mhttp.MockRoundTripper, rootURL string) (
 	requestCenter *http.Request, responseCenter *http.Response) {
@@ -408,8 +391,8 @@ func PrepareForInstallPlugin(roundTripper *mhttp.MockRoundTripper, rootURL, plug
 }
 
 // PrepareForInstallPluginWithVersion only for test
-func PrepareForInstallPluginWithVersion(roundTripper *mhttp.MockRoundTripper, rootURL, pluginName, version, user, passwd string)  {
-	PrepareForInstallPluginWithCode(roundTripper, 200, rootURL, pluginName + "@" + version, user, passwd)
+func PrepareForInstallPluginWithVersion(roundTripper *mhttp.MockRoundTripper, rootURL, pluginName, version, user, passwd string) {
+	PrepareForInstallPluginWithCode(roundTripper, 200, rootURL, pluginName+"@"+version, user, passwd)
 }
 
 // PrepareForInstallPluginWithCode only for test
@@ -426,7 +409,7 @@ func PrepareForInstallPluginWithCode(roundTripper *mhttp.MockRoundTripper,
 		RoundTrip(NewRequestMatcher(request)).Return(response, nil)
 
 	// common crumb request
-	requestCrumb, _ := RequestCrumb(roundTripper, rootURL)
+	requestCrumb, _ := PrepareForGetIssuer(roundTripper, rootURL, user, passwd)
 
 	if user != "" && passwd != "" {
 		request.SetBasicAuth(user, passwd)
@@ -492,11 +475,9 @@ func PrepareCommonPost(request *http.Request, responseBody string, roundTripper
 		RoundTrip(NewVerboseRequestMatcher(request).WithBody().WithQuery()).Return(response, nil)
 
 	// common crumb request
-	requestCrumb, _ := RequestCrumb(roundTripper, rootURL)
-
+	PrepareForGetIssuer(roundTripper, rootURL, user, passwd)
 	if user != "" && passwd != "" {
 		request.SetBasicAuth(user, passwd)
-		requestCrumb.SetBasicAuth(user, passwd)
 	}
 	return
 }

util/http.go

@@ -94,7 +94,7 @@ func (h *HTTPDownloader) DownloadFile() error {
 				ioutil.WriteFile("debug-download.html", data, 0664)
 			}
 		}
-		return fmt.Errorf("Invalidate status code: %d", resp.StatusCode)
+		return fmt.Errorf("invalidate status code: %d", resp.StatusCode)
 	}
 
 	writer := &ProgressIndicator{