lita-jenkins-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3b68aa187c68b0eea7ff4043bbd7386c75b49b9
+  data.tar.gz: 705e15c1b4ffd07774add758d91a56497f565031
+SHA512:
+  metadata.gz: d616b316970f6b6f7505eee8c8c4138ac69a1985244267af2828c6102a9425542b69defa620c9546e6429f45277d96de45f2402e84a817890638c307cd236496
+  data.tar.gz: 88a010b6513b1428e428310f416c9766fe8119a94a3f1295167a679ea74641c11f77d1541ebccc530eaf5d7c7c5af583cc4bb0d34a2b88de875829800d70319d

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+spec/config.yml
+.byebug_history

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,43 @@
+# lita-jenkins-client
+
+Lita jenkins handler that use the [jenkins\_api\_client gem](https://github.com/arangamani/jenkins_api_client)
+
+## About
+Integrate Lita and jenkins api. I've implement some commands which is usable now.
+
+## Installation
+
+Add lita-jenkins-client to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-jenkins-client", github: 'joshua5201/lita-jenkins-client'
+```
+
+## Current Available Commands 
+
+see `@lita help jenkins` for more info
+
+```
+@lita jenkins version 
+@lita jenkins running?
+@lita jenkins cli [cmd]
+@lita jenkins version
+
+@lita jenkins job build [job name] [param_key:param_value]
+@lita jenkins job params [job name]
+@lita jenkins job status [job name]
+@lita jenkins job all
+@lita jenkins job list [filter]
+@lita jenkins job list_by_status [success/failure]
+```
+
+## Test
+1. `cp spec/config.yml.example spec/config.yml` and edit your configurations.
+2. Make sure you don't have project named after `test_with_param` and `test_without_param` 
+3. `rspec`
+
+## Contribute
+1. feature: I only implement some of api from [jenkins\_api\_client gem](https://github.com/arangamani/jenkins_api_client), you can follow the structure and implement more commands.
+2. bug: please report issues or just help me fix them. 
+3. please provide RSpec tests
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita/handlers/jenkins_client/action.rb

@@ -0,0 +1,55 @@
+require_relative 'command'
+require 'byebug'
+class Lita::Handlers::JenkinsClient < Lita::Handler  
+  class Action < Lita::Handlers::JenkinsClient
+    namespace "jenkins_client"
+
+    class << self
+      protected 
+
+      def route_prefix
+        ["jenkins"]
+      end
+      
+      def route_matcher(actions)
+        Regexp.new('^'+(route_prefix + [actions].flatten).join(' ').strip + '\b', 'i')
+      end
+
+      def name_prefix
+        route_prefix.join(' ')
+      end
+
+      def commands
+        {}
+      end 
+
+      def method_added(name)
+        if self == Lita::Handlers::JenkinsClient::Action
+          return
+        end
+        if cmd = commands[name]
+          route(route_matcher(cmd.matcher), name, :help => {
+            "#{name_prefix} #{cmd.name}" => "#{cmd.help} Usage: #{name_prefix} #{cmd.usage}"
+          })
+        end
+      end
+
+    end
+
+    protected
+
+    def api_exec(usage = nil) 
+      if block_given?
+        begin 
+          yield
+        rescue Exception => e
+          "Error: #{e.message}" + (usage ? " Usage: #{usage}" : '') 
+        end
+      end
+    end
+
+    def usage(name)
+      self.class.commands[name].usage
+    end
+  end
+end

data/lib/lita/handlers/jenkins_client/base_action.rb

@@ -0,0 +1,42 @@
+require_relative 'command'
+class Lita::Handlers::JenkinsClient < Lita::Handler  
+  class BaseAction < Lita::Handlers::JenkinsClient::Action
+    # 1. Method defined under JenkinsApi::Client
+    # 2. Convenience custom commands
+    # @lita jenkins [command]
+    
+    namespace 'jenkins_client'
+
+    def self.commands
+      super.merge ({
+        version: Command.new(name: 'version', matcher: 'version', help: 'get jenkins version.'),
+        cli: Command.new(name: 'cli', matcher: 'cli', help: 'executes the jenkins cli.', usage: 'cli [command]'),
+        running?: Command.new(name: 'running?', matcher: 'running', help: 'Show if jenkins is running.'),
+      })
+    end
+
+    def version(res)
+      res.reply api_exec { 
+        client.get_jenkins_version
+      }
+    end
+
+    def cli(res)
+      if res.args.length < 2
+        res.reply 'Please provide at least one command'
+        return 
+      end
+      res.reply api_exec(usage(:cli)) { 
+        client.exec_cli(res.args.slice(1...res.args.length).join(' '))
+      }
+    end
+
+    def running?(res)
+      res.reply api_exec { 
+        client.get_root.inspect
+        "Running"
+      }
+    end
+
+  end
+end

data/lib/lita/handlers/jenkins_client/build_param.rb

@@ -0,0 +1,65 @@
+class Lita::Handlers::JenkinsClient < Lita::Handler  
+  class BuildParam
+    attr_reader :type, :name, :description, :default, :choices, :value
+    def self.supported_types
+      ['boolean', 'string', 'choice'].freeze
+    end
+
+    def self.print_supported_types
+      "Currently available param types: #{self.supported_types.join(' ')}"
+    end
+
+    def initialize(type: , name: , description: , default: '', choices: [])
+      @type, @name, @description, @default, @choices = type, name, description, default, choices
+      if type == 'choice'
+        @default = choices[0] 
+      end
+
+      if wrong_type? 
+        raise ArgumentError, self.class.print_supported_types
+      end
+
+      self.value = @default 
+    end
+
+    def value=(v)
+      if v.nil?
+        @value = nil
+      end
+
+      unless v.is_a? (String)
+        return
+      end
+
+      case @type
+      when 'string'
+        @value = v
+      when 'boolean'
+        if v == 'true'
+          @value = true
+        elsif v == 'false'
+          @value = false
+        else
+          raise ArgumentError, "#{@name} should be true or false"
+        end
+      when 'choice'
+        if @choices.include? (v)
+          @value = v
+        else
+          raise ArgumentError, "#{@name} should be one of #{@choices.inspect}"
+        end
+      else
+        raise ArgumentError, self.class.print_supported_types 
+      end
+    end
+
+    def to_h
+      {@name => @value}
+    end
+
+    private
+    def wrong_type?
+      not self.class.supported_types.include? @type
+    end
+  end
+end

data/lib/lita/handlers/jenkins_client/command.rb

@@ -0,0 +1,9 @@
+class Lita::Handlers::JenkinsClient < Lita::Handler  
+  class Command
+    attr_reader :name, :matcher, :help, :usage
+    def initialize(name: , matcher: , help: , usage: nil)
+      @name, @matcher, @help = name, matcher, help
+      @usage = usage ? usage : name
+    end
+  end
+end

data/lib/lita/handlers/jenkins_client/job_action.rb

@@ -0,0 +1,146 @@
+require_relative 'command'
+require_relative 'build_param'
+class Lita::Handlers::JenkinsClient < Lita::Handler  
+  class JobAction < Lita::Handlers::JenkinsClient::Action
+    # Method defined under JenkinsApi::Client::Job
+    # @lita jenkins job [command]
+    
+    namespace "jenkins_client"
+
+    class << self
+      def route_prefix
+        super + ["job"]
+      end
+
+      def commands
+        super.merge({
+          all: Command.new(name: 'all', matcher: 'all', help: 'list all jobs.'),
+          list: Command.new(name: 'list', matcher: 'list', help: 'list jobs matching pattern.', usage: 'list [filter]'),
+          list_by_status: Command.new(name: 'list_by_status', matcher: 'list_by_status', help: 'list jobs with certain status.', usage: 'list_by_status [success/failure]'),
+          status: Command.new(name: 'status', matcher: 'status', help: 'print job status.', usage: 'status [job name]'),
+          build: Command.new(name: 'build', matcher: 'build', help: "build job, #{BuildParam.print_supported_types}", usage: 'build [job name] [param_key:param_value]'),
+          params: Command.new(name: 'params', matcher: 'params', help: 'obtain the build parameters of a job.', usage: 'params [job_name]'),
+          exists?: Command.new(name: 'exists?', matcher: 'exists', help: 'check if a job exists', usage: 'exists [job name]'),
+        })
+      end
+    end
+
+    def all(res)
+      res.reply api_exec {
+        client.job.list_all.inspect
+      }
+    end
+
+    def list(res)
+      if res.args.length < 3
+        res.reply 'please provide a search condition'
+        return
+      end
+
+      res.reply api_exec { client.job.list(res.args[2]) }
+    end
+
+    def list_by_status(res)
+      if res.args.length < 3
+        res.reply 'please provide a status ( SUCCESS, FAILURE )'
+        return
+      end
+      
+      res.reply api_exec { client.job.list_by_status(res.args[2]) }
+    end
+
+    def build(res)
+      if res.args.length < 3
+        res.reply 'please provide a job name'
+        return
+      end
+
+      job_name = res.args[2]
+      if client.job.exists?(job_name) == false
+        res.reply "job #{job_name} not exists" 
+        return 
+      end
+      hash_args = key_value_pair(res.args.slice(3...res.args.length))
+      if hash_args.empty? 
+        res.reply api_exec { 
+          print_build_status(client.job.build(job_name))
+        }
+        return 
+      end
+
+      begin
+        params = parse_build_params(hash_args, client.job.get_build_params(job_name))
+        res.reply api_exec { 
+          print_build_status(client.job.build(job_name, params))
+        }
+      rescue ArgumentError => e
+        res.reply "Error: #{e.message}"
+      end
+    end
+
+    def delete(res)
+      if res.args.length < 3 
+        res.reply 'please provide a job name'
+        return
+      end
+
+      res.reply api_exec { client.job.delete(res.args[2]).inspect }
+    end
+
+    def status(res)
+      if res.args.length < 3 
+        res.reply 'please provide a job name'
+        return
+      end
+
+      res.reply api_exec { client.job.get_current_build_status(res.args[2]).inspect }
+    end
+
+    def exists?(res)
+      if res.args.length < 3
+        res.reply 'please provide a job name'
+        return
+      end
+
+      res.reply api_exec { client.job.exists?(res.args[2]).inspect }
+    end
+
+    def params(res)
+      if res.args.length < 3 
+        res.reply 'please provide a job name'
+        return
+      end
+
+      res.reply api_exec { client.job.get_build_params(res.args[2]).inspect }
+    end
+
+    private
+    def parse_build_params(hash_args, build_params)
+      params = build_params.map do |param|
+        bp = BuildParam.new(param)
+        bp.value = hash_args[bp.name]
+        bp
+      end
+
+      return params.reduce({}) {|res, p| res.merge(p.to_h) }
+    end
+
+    def key_value_pair(args)
+      args.map { |arg|
+        if pair = /([\/\\,\.\w-]+):([\/\\,\.\w-]+)/.match(arg)&.captures
+          [pair[0], pair[1]]
+        else
+          nil
+        end
+      }.compact.to_h
+    end
+
+    def print_build_status(status)
+      if status == '201'
+        'Job created. (http status 201)'
+      else
+        "Something went wrong. (http status: #{status})"
+      end
+    end
+  end
+end

data/lib/lita/handlers/jenkins_client.rb

@@ -0,0 +1,57 @@
+require_relative 'jenkins_client/action'
+require_relative 'jenkins_client/base_action'
+require_relative 'jenkins_client/job_action'
+require_relative 'jenkins_client/command'
+
+module Lita
+  module Handlers
+    class JenkinsClient < Handler
+      namespace 'jenkins_client'
+
+      CONFIGS = { 
+        server_url: String,
+        server_ip: String,
+        server_port: String,
+        proxy_ip: String,
+        proxy_port: String,
+        jenkins_path: String,
+        username: String,
+        password: String,
+        password_base64: String,
+        log_location: String,
+        log_level: Fixnum,
+        timeout: Fixnum,
+        ssl: Object,
+        follow_redirects: Object,
+        identity_file: String,
+        cookies: String
+      }.freeze
+
+      CONFIGS.each do |config_name, config_type|
+        if config_type == Object
+          config config_name, type: config_type do 
+            validate do |value|
+              "#{config_name} must be true or false or nil" unless [true, false, nil].include? value
+            end
+          end
+        else
+        config config_name, type: config_type 
+        end
+      end
+
+      protected
+      def jenkins_params 
+        CONFIGS.keys.select{|key| config.respond_to?(key)}.map{|key| [key, config.send(key)] }.to_h
+      end
+
+      def client
+        @client ||= JenkinsApi::Client.new(jenkins_params)
+      end
+    end
+
+    Lita.register_handler(JenkinsClient)
+    Lita.register_handler(JenkinsClient::Action)
+    Lita.register_handler(JenkinsClient::BaseAction)
+    Lita.register_handler(JenkinsClient::JobAction)
+  end
+end

data/lib/lita-jenkins-client.rb

@@ -0,0 +1,13 @@
+require "lita"
+require "jenkins_api_client"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/handlers/jenkins_client"
+
+Lita::Handlers::JenkinsClient.template_root File.expand_path(
+  File.join("..", "..", "templates"),
+ __FILE__
+)

data/lita-jenkins-client.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-jenkins-client"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Tsung-en Hsiao"]
+  spec.email         = ["joshua841025@gmail.com"]
+  spec.summary = 'Lita jenkins handler that use the jenkins_api_client gem'
+  spec.description = 'Lita jenkins handler that use the jenkins_api_client gem'
+  spec.license       = "MIT"
+  spec.metadata      = { "lita_plugin_type" => "handler" }
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "lita", ">= 4.7"
+  spec.add_dependency "byebug"
+  spec.add_runtime_dependency "jenkins_api_client", '~> 1.4'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "simplecov"
+end

data/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  lita:
+    handlers:
+      jenkins_client:

data/spec/config.yml.example

@@ -0,0 +1,7 @@
+:server_url: "http://ci.example.com"
+:username: "yourusername"
+:password: "thepassword"
+:log_level: 2
+
+# pass cli tests if you use https and got 403 error 
+:cli_test: true

data/spec/fixtures/test_with_params.xml

@@ -0,0 +1,43 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <description></description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.BooleanParameterDefinition>
+          <name>bool</name>
+          <description></description>
+          <defaultValue>true</defaultValue>
+        </hudson.model.BooleanParameterDefinition>
+        <hudson.model.ChoiceParameterDefinition>
+          <name>choice</name>
+          <description></description>
+          <choices class="java.util.Arrays$ArrayList">
+            <a class="string-array">
+              <string>a</string>
+              <string>b</string>
+              <string>c</string>
+              <string>d</string>
+            </a>
+          </choices>
+        </hudson.model.ChoiceParameterDefinition>
+        <hudson.model.StringParameterDefinition>
+          <name>foo</name>
+          <description></description>
+          <defaultValue>bar</defaultValue>
+        </hudson.model.StringParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <canRoam>true</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers/>
+  <concurrentBuild>false</concurrentBuild>
+  <builders/>
+  <publishers/>
+  <buildWrappers/>
+</project>

data/spec/fixtures/test_without_params.xml

@@ -0,0 +1,16 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <description></description>
+  <keepDependencies>false</keepDependencies>
+  <properties/>
+  <scm class="hudson.scm.NullSCM"/>
+  <canRoam>true</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers/>
+  <concurrentBuild>false</concurrentBuild>
+  <builders/>
+  <publishers/>
+  <buildWrappers/>
+</project>

data/spec/lita/handlers/action_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient::Action, lita_handler: true, additional_lita_handlers: JenkinsClient do
+  let(:subject_class) { Lita::Handlers::JenkinsClient::Action }
+
+  describe 'class methods' do
+    describe '#route_matcher' do
+      it 'adds a prefix to action name' do
+        expect(subject_class.send(:route_matcher, "foo")).to eq(Regexp.new('^jenkins foo\b', 'i'))
+      end
+
+      it 'also accepts array as parameter' do
+        expect(subject_class.send(:route_matcher, ["foo", "bar"])).to eq(Regexp.new('^jenkins foo bar\b', 'i'))
+      end
+    end
+  end
+
+  describe '#api_exec' do
+    it 'returns block output' do
+      expect(subject.send(:api_exec) { 'output' }).to eq('output')
+    end
+
+    it 'returns error message when error raised' do
+      expect(subject.send(:api_exec) { raise Exception, 'test error.' }).to eq('Error: test error.')
+    end
+
+    it 'appends an usage message after error message if usage given' do
+      expect(subject.send(:api_exec, 'test usage') { 
+        raise Exception, 'test error.' 
+      }).to eq('Error: test error. Usage: test usage')
+    end
+  end
+
+end

data/spec/lita/handlers/base_action_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient::BaseAction, lita_handler: true, additional_lita_handlers: JenkinsClient do
+  it { is_expected.to route("jenkins version").to(:version) }
+  it { is_expected.to route("jenkins running?").to(:running?) }
+  it { is_expected.to route("jenkins cli").to(:cli) }
+
+  let! (:client) { JenkinsApi::Client.new(jenkins_config_hash) }
+
+  before do
+    registry.config.handlers.jenkins_client.tap do |config|
+      config.username = jenkins_config_hash[:username]
+      config.password = jenkins_config_hash[:password]
+      config.server_url = jenkins_config_hash[:server_url]
+      config.log_level = jenkins_config_hash[:log_level]
+    end
+  end
+
+  describe '#version' do
+    it 'replies jenkins version' do
+      send_message('jenkins version');
+      expect(replies.last).to eq(client.get_jenkins_version)
+    end
+  end
+
+  describe '#cli' do
+    it 'executes the Jenkins CLI', :cli_test => true do
+      send_message('jenkins cli list-plugins git') 
+      expect(replies.last).to eq(client.exec_cli('list-plugins git'))
+    end
+    it 'ends when no commands provides' do
+      send_message('jenkins cli ') 
+      expect(replies.last).to eq('Please provide at least one command')
+    end
+  end
+
+  describe '#running?' do
+    it 'returns Running when jenkins running' do
+      send_message('jenkins running?') 
+      expect(replies.last).to eq("Running")
+    end
+  end
+
+end

data/spec/lita/handlers/build_param_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient::BuildParam do
+  let (:boolean_param) { described_class.new(type: 'boolean', name: 'test', description: 'foobar', default: 'true') } 
+  let (:string_param) { described_class.new(type: 'string', name: 'test', description: 'foobar', default: 'testdefault') }
+  let (:choice_param) { described_class.new(type: 'choice', name: 'test', description: 'foobar', choices: ['a', 'b', 'c']) }
+  describe '#initialize' do
+    it 'initializes boolean type param' do
+      expect(boolean_param.type).to eq('boolean')
+      expect(boolean_param.name).to eq('test')
+      expect(boolean_param.default).to eq('true')
+      expect(boolean_param.description).to eq('foobar')
+    end
+
+    it 'initializes string type param' do
+      expect(string_param.type).to eq('string')
+    end
+
+    it 'sets value to default' do
+      expect(string_param.value).to eq('testdefault')
+    end
+
+    it 'initializes choice type param' do
+      expect(choice_param.type).to eq('choice')
+    end
+
+    it 'set default to first choice when type is choice' do
+      expect(choice_param.default).to eq('a')
+    end
+
+    it 'raises error when type is not supported' do
+      expect { 
+        described_class.new(type: 'wrong', name: 'test', description: 'foobar', choices: ['a', 'b', 'c'])
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#value=' do
+    it 'sets @value to nil if v nil' do
+      string_param.value = nil
+      expect(string_param.value).to be(nil)
+    end
+
+    it 'ends if input not a String' do
+      expect { string_param.value = 123 }.not_to change{string_param.value}
+    end
+
+    describe 'it sets @value according to type' do
+      it 'sets string' do
+        string_param.value = "new_string"
+        expect(string_param.value).to eq("new_string")
+      end
+
+      it 'sets boolean to true' do
+        boolean_param.value = "true"
+        expect(boolean_param.value).to be true
+      end
+
+      it 'sets boolean to false' do
+        boolean_param.value = "false"
+        expect(boolean_param.value).to be false
+      end
+
+      it 'raises error when not a boolean string' do
+        expect { boolean_param.value = "something wrong" }.to raise_error(ArgumentError)
+      end
+
+      it 'sets choice' do
+        choice_param.value = 'b'
+        expect(choice_param.value).to eq('b')
+      end
+
+      it 'raises error when not in choices' do
+        expect { choice_param.value = 'e' }.to raise_error(ArgumentError)
+      end
+
+      it 'raises error when type not supported' do
+        string_param.instance_variable_set(:@type, 'foo')
+        expect { string_param.value = 'raise' }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'converts BuildParam to Hash' do
+      expect(boolean_param.to_h).to eq({'test' => true})
+    end
+  end
+end

data/spec/lita/handlers/command_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient::Command do
+  describe '#initialize' do
+    it 'can be initialized with usage' do
+      command = described_class.new(name: 'testname', matcher: 'testmatcher', help: 'testhelp', usage: 'testusage')
+      expect(command).to be_a JenkinsClient::Command
+    end
+
+    it 'can be initialized without usage' do
+      command = described_class.new(name: 'testname', matcher: 'testmatcher', help: 'testhelp')
+      expect(command).to be_a JenkinsClient::Command
+    end
+
+    it 'has @usage equals to @name when no usage param provided' do
+      command = described_class.new(name: 'testname', matcher: 'testmatcher', help: 'testhelp')
+      expect(command.usage).to eq(command.name)
+    end
+  end
+end

data/spec/lita/handlers/jenkins_client_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient, lita_handler: true do
+  describe '#jenkins_params' do
+    before do
+      registry.config.handlers.jenkins_client.tap do |config|
+        config.username = jenkins_config_hash[:username]
+        config.password = jenkins_config_hash[:password]
+        config.server_url = jenkins_config_hash[:server_url]
+      end
+    end
+
+    it 'maps config to a hash param' do
+      expect(subject.send(:jenkins_params)[:username]).to eq(jenkins_config_hash[:username])
+      expect(subject.send(:jenkins_params)[:password]).to eq(jenkins_config_hash[:password])
+      expect(subject.send(:jenkins_params)[:server_url]).to eq(jenkins_config_hash[:server_url])
+    end
+
+    it 'validates boolean value if config_type is Object' do
+      expect {
+        registry.config.handlers.jenkins_client.tap do |config|
+          config.ssl = 123 
+        end
+      }.to raise_error(SystemExit)
+    end
+
+    describe '#client' do
+      it 'creates a client instance from the param hash' do
+        expect(subject.send(:client)).to be_a JenkinsApi::Client
+      end
+    end
+  end
+
+end

data/spec/lita/handlers/job_action_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+require "jenkins_api_client"
+
+include Lita::Handlers
+describe JenkinsClient::JobAction, lita_handler: true, additional_lita_handlers: JenkinsClient do
+  it { is_expected.to route('jenkins job all').to(:all) }
+  it { is_expected.to route('jenkins job list').to(:list) }
+  it { is_expected.to route('jenkins job status').to(:status) }
+  it { is_expected.to route('jenkins job build').to(:build) }
+  it { is_expected.to route('jenkins job exists?').to(:exists?) }
+  it { is_expected.to route('jenkins job params').to(:params) }
+  let! (:client) { JenkinsApi::Client.new(jenkins_config_hash) }
+
+  before do
+    registry.config.handlers.jenkins_client.tap do |config|
+      config.username = jenkins_config_hash[:username]
+      config.password = jenkins_config_hash[:password]
+      config.server_url = jenkins_config_hash[:server_url]
+      config.log_level = jenkins_config_hash[:log_level]
+    end
+  end
+
+  describe '#all' do
+    it 'returns list of jobs' do
+      send_message('jenkins job all')
+      expect(replies.last).to eq(client.job.list_all.inspect)
+    end
+  end
+
+
+  describe '#build' do
+    it 'ends when no input' do
+      send_message('jenkins job build')
+      expect(replies.last).to eq("please provide a job name")
+    end
+
+    it 'ends when job not exists' do
+      send_message('jenkins job build not_exist')
+      expect(replies.last).to eq("job not_exist not exists")
+    end
+
+    it 'builds job without parameters' do
+      send_message('jenkins job build test_without_params')
+      expect(replies.last).to eq("Job created. (http status 201)")
+    end
+
+    it 'builds job with parameters' do
+      send_message('jenkins job build test_with_params bool:true choice:c foo:foobar')
+      expect(replies.last).to eq("Job created. (http status 201)")
+    end
+
+    it 'reply error message when ArgumentError' do
+      send_message('jenkins job build test_with_params bool:abc choice:c foo:foobar')
+      expect(replies.last).to eq('Error: bool should be true or false')
+    end
+  end
+
+  describe '#parse_build_params' do
+    let(:build_params) { build_params = [{:type=>"boolean", :name=>"bool", :description=>"", :default=>"true"}, {:type=>"choice", :name=>"choice", :description=>"", :choices=>["a", "b", "c", "d"]}, {:type=>"string", :name=>"foo", :description=>"", :default=>"bar"}] }
+    let(:params) { {'bool' => true, 'choice' => 'c', 'foo' => 'foobar'} }
+
+    it 'parses valid args to valid build params' do
+      hash_args = {'bool' => 'true', 'choice' => 'c', 'foo' => 'foobar'}
+      expect(subject.send(:parse_build_params, hash_args, build_params)).to eq(params)
+    end
+  end
+
+  describe '#key_value_pair' do
+    it 'parses key:value string pairs to hash' do
+      input = ['foo:bar', 'test:true', 'ignored']
+      expect(subject.send(:key_value_pair, input)).to eq({'foo' => 'bar', 'test' => 'true'})
+    end
+  end
+
+  describe '#params' do
+    it 'obtains job info' do
+      send_message('jenkins job params test_with_params')
+      expect(replies.last).to eq(client.job.get_build_params('test_with_params').inspect)
+    end
+
+    it 'ends when no input' do
+      send_message('jenkins job params')
+      expect(replies.last).to eq('please provide a job name')
+    end
+  end
+
+  describe '#exists?' do
+    it 'shows if job exists' do
+      send_message('jenkins job exists? test_with_params')
+      expect(replies.last).to eq(client.job.exists?('test_with_params').inspect)
+    end
+
+    it 'ends when no input' do
+      send_message('jenkins job exists?')
+      expect(replies.last).to eq('please provide a job name')
+    end
+  end
+
+  describe '#status' do
+    it 'shows job status' do
+      send_message('jenkins job status test_with_params')
+      expect(replies.last).to eq(client.job.get_current_build_status('test_with_params').inspect)
+    end
+
+    it 'ends when no input' do
+      send_message('jenkins job exists?')
+      expect(replies.last).to eq('please provide a job name')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require "lita-jenkins-client"
+require "lita/rspec"
+require "psych"
+require "byebug"
+
+# A compatibility mode is provided for older plugins upgrading from Lita 3. Since this plugin
+# was generated with Lita 4, the compatibility mode should be left disabled.
+Lita.version_3_compatibility_mode = false
+
+def jenkins_config_hash
+  @config ||= Psych.load_file('spec/config.yml')
+end
+
+def set_test_jobs
+  client = JenkinsApi::Client.new(jenkins_config_hash)
+  client.job.create_or_update('test_with_params', File.read('spec/fixtures/test_with_params.xml'))
+  client.job.create_or_update('test_without_params', File.read('spec/fixtures/test_without_params.xml'))
+  client.job.create_or_update('test_without_params2', File.read('spec/fixtures/test_without_params.xml'))
+end
+
+def delete_test_jobs
+  client = JenkinsApi::Client.new(jenkins_config_hash)
+  client.job.delete('test_with_params')
+  client.job.delete('test_without_params')
+  client.job.delete('test_without_params2')
+end
+
+RSpec.configure do |config|
+  unless jenkins_config_hash[:cli_test]
+    config.filter_run_excluding :cli_test => true
+  end
+
+  config.before(:suite) do
+    set_test_jobs
+  end
+
+  config.after(:suite) do
+    delete_test_jobs
+  end
+end
+

metadata

@@ -0,0 +1,208 @@
+--- !ruby/object:Gem::Specification
+name: lita-jenkins-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tsung-en Hsiao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jenkins_api_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Lita jenkins handler that use the jenkins_api_client gem
+email:
+- joshua841025@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- lib/lita-jenkins-client.rb
+- lib/lita/handlers/jenkins_client.rb
+- lib/lita/handlers/jenkins_client/action.rb
+- lib/lita/handlers/jenkins_client/base_action.rb
+- lib/lita/handlers/jenkins_client/build_param.rb
+- lib/lita/handlers/jenkins_client/command.rb
+- lib/lita/handlers/jenkins_client/job_action.rb
+- lib/lita/handlers/jenkins_client/plugin_action.rb
+- lib/lita/handlers/jenkins_client/queue_action.rb
+- lib/lita/handlers/jenkins_client/system_action.rb
+- lita-jenkins-client.gemspec
+- locales/en.yml
+- spec/config.yml.example
+- spec/fixtures/test_with_params.xml
+- spec/fixtures/test_without_params.xml
+- spec/lita/handlers/action_spec.rb
+- spec/lita/handlers/base_action_spec.rb
+- spec/lita/handlers/build_param_spec.rb
+- spec/lita/handlers/command_spec.rb
+- spec/lita/handlers/jenkins_client_spec.rb
+- spec/lita/handlers/job_action_spec.rb
+- spec/spec_helper.rb
+- templates/.gitkeep
+homepage: 
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Lita jenkins handler that use the jenkins_api_client gem
+test_files:
+- spec/config.yml.example
+- spec/fixtures/test_with_params.xml
+- spec/fixtures/test_without_params.xml
+- spec/lita/handlers/action_spec.rb
+- spec/lita/handlers/base_action_spec.rb
+- spec/lita/handlers/build_param_spec.rb
+- spec/lita/handlers/command_spec.rb
+- spec/lita/handlers/jenkins_client_spec.rb
+- spec/lita/handlers/job_action_spec.rb
+- spec/spec_helper.rb