teamcity 1.3.1

data/lib/teamcity/client/build_types.rb

@@ -0,0 +1,305 @@
+module TeamCity
+  class Client
+    # Defines methods related to build types (or build configurations)
+    module BuildTypes
+      # HTTP GET
+
+      # List of build types
+      #
+      # @return [Array<Hashie::Mash>, nil] of buildtypes or nil if no buildtypes exist
+      def buildtypes
+        response = get('buildTypes')
+        response['buildType']
+      end
+
+      # Get build configuration details
+      #
+      # @param options [Hash] option keys, :id => buildtype_id
+      # @return [Hashie::Mash] of build configuration details
+      def buildtype(options={})
+        assert_options(options)
+        get("buildTypes/#{locator(options)}")
+      end
+
+      # Create a Build Configuration
+      #
+      # @param project_id [String] id of the project you are adding the build configuration
+      # @param name [String] name of the buildtype you wish to create
+      # @return [Hashie::Mash] of build configuration details
+      def create_buildtype(project_id, name)
+        post("projects/#{project_id}/buildTypes", :content_type => :text) do |req|
+          req.body = name
+        end
+      end
+
+      # Get a listing of vcs branches
+      #
+      # @param buildtype_id [String]
+      # @return [Array<Hashie::Mash>]
+      def buildtype_branches(buildtype_id)
+        path = "buildTypes/#{buildtype_id}/branches"
+        response = get(path, :accept => :json, :content_type => :json)
+        response.branch
+      end
+
+      # Get whether the build is paused or not
+      #
+      # @param options [Hash] option keys, :id => buildtype_id
+      # @return [String] 'true' or 'false' on whether the build is paused
+      def buildtype_state(options={})
+        assert_options(options)
+        path = "buildTypes/#{locator(options)}/paused"
+        get(path, :accept => :text, :content_type => :text)
+      end
+
+      # Get build configuration settings
+      #
+      # @param (see #buildtype)
+      # @return [Array<Hashie::Mash>] of build configuration settings
+      def buildtype_settings(options={})
+        assert_options(options)
+        response = get("buildTypes/#{locator(options)}/settings")
+        response['property']
+      end
+
+      # Get build configuration parameters
+      #
+      # @param (see #buildtype)
+      # @return [Array<Hashie::Mash>] of build configuration parameters
+      def buildtype_parameters(options={})
+        assert_options(options)
+        response = get("buildTypes/#{locator(options)}/parameters")
+        response['property']
+      end
+
+      # Get investigation info for build configuration
+      #
+      # @param buildtype_id [String] the buildtype id
+      # @return [Array<Hashie::Mash>] of build investigation info
+      def buildtype_investigations(buildtype_id)
+        response = get("buildTypes/#{buildtype_id}/investigations")
+        response['investigation']
+      end
+
+      # Get template associated with build configuration
+      #
+      # @param (see #buildtype)
+      # @return [Hashie::Mash, nil] of build configuration parameters or nil if
+      def buildtype_template(options={})
+        assert_options(options)
+        begin
+          get("buildTypes/#{locator(options)}/template")
+        rescue StandardError => e
+          /No template associated/.match(e.to_s) ? nil : raise
+        end
+      end
+
+      # @macro [attach] build configuration settings
+      #   @method buildtype_$1(options = {})
+      #   Get build configuration $1
+      #   @param options [Hash] option keys, :id => buildtype_id
+      #   @return [Array<Hashie::Mash>] of build configuration $1
+      def self.make_method(name)
+        define_method("buildtype_#{name}".to_sym) do |options|
+          name_has_dashes = name.to_s.gsub('_', '-')
+          assert_options(options)
+          response = get("buildTypes/#{locator(options)}/#{name_has_dashes}", accept: :json)
+          response[response.keys.first]
+        end
+      end
+
+      private_class_method :make_method
+
+      make_method :features
+      make_method :triggers
+      make_method :steps
+      make_method :agent_requirements
+      make_method :artifact_dependencies
+      make_method :snapshot_dependencies
+      make_method :vcs_root_entries
+
+      # Attach a vcs root to a build type (build configuration_)
+      #
+      #
+      # @param buildtype_id [String] the buildtype id
+      # @param vcs_root_id [String, Numeric] id of vcs root
+      # @return [Hashie::Mash] vcs root object that was attached
+      def attach_vcs_root(buildtype_id, vcs_root_id)
+        payload = { 'vcs-root' => { :id => vcs_root_id } }
+
+        post("buildTypes/#{buildtype_id}/vcs-root-entries", :content_type => :json) do |req|
+          req.body = payload.to_json
+        end
+      end
+
+      # Set a buildtype parameter (Create or Update)
+      #
+      #
+      # @param buildtype_id [String] the buildtype id
+      # @param parameter_name [String] name of the parameter to set
+      # @param parameter_value [String] value of the parameter
+      # @return parameter_value [String] that was set
+      def set_buildtype_parameter(buildtype_id, parameter_name, parameter_value)
+        path = "buildTypes/#{buildtype_id}/parameters/#{parameter_name}"
+        put(path, :accept => :text, :content_type => :text) do |req|
+          req.body = parameter_value
+        end
+      end
+
+      # Delete a buildtype parameter
+      #
+      # @param buildtype_id [String] the buildtype id
+      # @param parameter_name [String] name of the parameter to delete
+      # @return [nil]
+      def delete_buildtype_parameter(buildtype_id, parameter_name)
+        path = "buildTypes/#{buildtype_id}/parameters/#{parameter_name}"
+        delete(path, :accept => :text, :content_type => :text)
+        return nil
+      end
+
+      # Create a buildtype agent requirement (Create)
+      #
+      # @param buildtype_id [String] the buildtype id
+      # @param parameter_name [String] name of the parameter to set
+      # @param parameter_value [String] value of the parameter
+      # @param condition [String] the condition for which to check against
+      # @return [Hashie::Mash]
+      #
+      # @example Create a condition where a system property equals something
+      #    TeamCity.create_agent_requirement('bt1', 'system.os.name', 'Linux', 'equals')
+      #
+      # @note Check the TeamCity UI for supported conditions
+      def create_agent_requirement(buildtype_id, parameter_name, parameter_value, condition)
+        builder = TeamCity::ElementBuilder.new(:id => parameter_name, :type => condition) do |properties|
+          properties['property-name']  = parameter_name
+          properties['property-value'] = parameter_value
+        end
+
+        path = "buildTypes/#{buildtype_id}/agent-requirements"
+        post(path, :accept => :json, :content_type => :json) do |req|
+          req.body = builder.to_request_body
+        end
+      end
+
+      # Delete an agent requirement for a buildtype
+      #
+      # @param buildtype_id [String] the buildtype_id
+      # @param parameter_name [String] name of the requirement to delete
+      # @return [nil]
+      def delete_agent_requirement(buildtype_id, parameter_name)
+        delete("buildTypes/#{buildtype_id}/agent-requirements/#{parameter_name}")
+      end
+
+      # Set a buildtype field
+      #
+      # @example Change buildtype name
+      #   TeamCity.set_buildtype_field('bt3', 'name', 'new-name')
+      # @example Set buildtype description
+      #   TeamCity.set_buildtype_field('bt3', 'description', 'new-description')
+      # @example Pause/Unpause a buildtype
+      #   Teamcity.set_buildtype_field('buildtype', 'paused', 'true|false')
+      #
+      # @param buidltype_id [String] the buildtype id
+      # @param field_name [String] the field name
+      # @param field_value [String] the value to set the field to
+      # @return field_value [String] value that was set
+      def set_buildtype_field(buildtype_id, field_name, field_value)
+        path = "buildTypes/#{buildtype_id}/#{field_name}"
+        put(path, :accept => :text, :content_type => :text) do |req|
+          req.body = field_value
+        end
+      end
+
+      # Set buildtype settings
+      #
+      # @example Cleaning all files between the builds
+      #   TeamCity.set_buildtype_setting('bt3', 'cleanBuild', 'true')
+      # @example Checkout on the server
+      #   TeamCity.set_buildtype_setting('bt3', 'checkoutMode', 'ON_SERVER')
+      # @example Fail the build after 10 Minutes
+      #   Teamcity.set_buildtype_setting('bt3', 'executionTimeoutMin', '10')
+      #
+      # @param buidltype_id [String] the buildtype id
+      # @param setting_name [String] the settings name
+      # @param setting_value [String] the value to set the settings to
+      # @return setting_value [String] value that was set
+      def set_buildtype_setting(buildtype_id, setting_name, setting_value)
+        set_buildtype_field(buildtype_id, "settings/#{setting_name}", setting_value)
+      end
+
+      # Delete buildtype (build configuration)
+      #
+      # @param buildtype_id [String] the id of the buildtype
+      # @return [nil]
+      def delete_buildtype(buildtype_id)
+        delete("buildTypes/#{buildtype_id}")
+      end
+
+      # Set build step field
+      #
+      # @param buildtype_id [String] the id of the buildtype
+      # @param step_id [String] the id of the build step
+      # @param field_name [String] the name of the field to set
+      # @param field_value [String] the value to set the field name to
+      # @return [nil]
+      def set_build_step_field(buildtype_id, step_id, field_name, field_value)
+        path = "buildTypes/#{buildtype_id}/steps/#{step_id}/#{field_name}"
+        put(path, :accept => :text, :content_type => :text) do |req|
+          req.body = field_value
+        end
+      end
+
+      # Create Build Step
+      #
+      # @param buildtype_id [String] :buildtype_id to create the step under
+      # @option options [String] :name for the step definition (optional)
+      # @option options [String] :type Type of Build Step: 'Maven', 'Ant', etc
+      # @yield [Hash] properties to set on the step, view the official documentation for supported properties
+      # @return [Hashie::Mash] step object that was created
+      #
+      # @example Create a Maven2 step that executes the target verify
+      #   TeamCity.create_build_step(:buildtype_id => 'my-build-type-id', :type => 'Maven', name: 'Unit Tests') do |properties|
+      #     properties['goals'] = 'verify'
+      #     properties['mavenSelection'] = 'mavenSelection:default'
+      #     properties['pomLocation'] = 'pom.xml'
+      #   end
+      def create_build_step(buildtype_id, options = {}, &block)
+        attributes = {
+          :type => options.fetch(:type),
+          :name => options.fetch(:name) { nil }
+        }
+
+        builder = TeamCity::ElementBuilder.new(attributes, &block)
+
+        post("buildTypes/#{buildtype_id}/steps", :content_type => :json) do |req|
+          req.body = builder.to_request_body
+        end
+      end
+
+      # Create Build Trigger
+      #
+      # @param buildtype_id [String] :buildtype_id to create the trigger under
+      # @option options [String] :type Type of Build Trigger: 'vcsTrigger', 'schedulingTrigger', etc
+      # @yield [Hash] properties to set on the trigger, view the official documentation for supported properties
+      # @return [Hashie::Mash] trigger object that was created
+      #
+      # @example Create a a VCS build trigger for checkins
+      #   TeamCity.create_build_step(:buildtype_id => 'my-build-type-id', :type => 'vcsTrigger', name: 'Every Checkin') do |properties|
+      #     properties['groupCheckkinsByCommitter'] = 'true'
+      #     properties['perCheckinTriggering'] = 'true'
+      #     properties['quietPeriodMode'] = 'DO_NOT_USE'
+      #   end
+      def create_build_trigger(buildtype_id, options = {}, &block)
+        attributes = {
+          :type => options.fetch(:type),
+        }
+
+        builder = TeamCity::ElementBuilder.new(attributes, &block)
+
+        post("buildTypes/#{buildtype_id}/triggers", :content_type => :json) do |req|
+          req.body = builder.to_request_body
+        end
+      end
+    end
+  end
+end

data/lib/teamcity/client/builds.rb

@@ -0,0 +1,92 @@
+module TeamCity
+  class Client
+    # Defines methods related to builds
+    module Builds
+
+      # HTTP GET
+
+      # List of builds
+      #
+      # @param options [Hash] list of build locators to filter build results on
+      # @return [Array<Hashie::Mash>] of builds (empty array if no builds exist)
+      def builds(options={})
+        url_params = options.empty? ? '' : "?locator=#{locator(options)}"
+        response = get("builds#{url_params}")
+        response.build
+      end
+
+      # Get build details
+      #
+      # @param options [Hash] option keys, :id => build_id
+      # @return [Hashie::Mash] of build details
+      def build(options={})
+        assert_options(options)
+        get("builds/#{locator(options)}")
+      end
+
+      # Get the build tags
+      #
+      # @param options [Hash] option keys, :id => build_id
+      # @return [Array<Hashie::Mash>] or empty array if no tags exist
+      def build_tags(options={})
+        assert_options(options)
+        response = get("builds/#{locator(options)}/tags")
+        response.fetch(:tag)
+      end
+
+      # Get build statistics
+      #
+      # @param build_id [String]
+      # @return [Array<Hashie::Mash>]
+      def build_statistics(build_id)
+        response = get("builds/#{build_id}/statistics")
+        response['property']
+      end
+
+      # Tells you whether or not a build is pinned
+      #
+      # @param id [String] build to check if it is pinned
+      # @return [Boolean] whether the build is pinned or not
+      def build_pinned?(id)
+        path = "builds/#{id}/pin"
+        response = get(path, :accept => :text, :content_type => :text)
+        response == 'true'
+      end
+
+      # Get build artifacts
+      #
+      # @param build_id [String]
+      # @return [Array<Hashie::Mash>]
+      def build_artifacts(build_id)
+        response = get("builds/#{build_id}/artifacts")
+        response['files']
+      end
+      
+      # HTTP PUT
+
+      # Pin a build
+      #
+      # @param id [String] build to pin
+      # @param comment [String] provide a comment to the pin
+      # @return [nil]
+      def pin_build(id, comment='')
+        path = "builds/#{id}/pin"
+        put(path, :accept => :text, :content_type => :text) do |req|
+          req.body = comment
+        end
+        return nil
+      end
+
+      # HTTP DELETE
+
+      # Unpin a build
+      #
+      # @param id [String] build to unpin
+      # @return [nil]
+      def unpin_build(id)
+        path = "builds/#{id}/pin"
+        delete(path, :content_type => :text)
+      end
+    end
+  end
+end

data/lib/teamcity/client/common.rb

@@ -0,0 +1,23 @@
+module TeamCity
+  class Client
+    # Defines some common methods shared across the other
+    # teamcity api modules
+    module Common
+
+      private
+
+      def assert_options(options)
+        !options[:id] and raise ArgumentError, "Must provide an id", caller
+      end
+
+      # Take a list of locators to search on multiple criterias
+      #
+      def locator(options={})
+        options.inject([]) do |locators, locator|
+          key, value = locator
+          locators << "#{key}:#{value}"
+        end.join(',')
+      end
+    end
+  end
+end

data/lib/teamcity/client/projects.rb

@@ -0,0 +1,159 @@
+module TeamCity
+  class Client
+    # Defines methods related to projects
+    module Projects
+
+      # List of projects
+      #
+      # @return [Array<Hashie::Mash>, nil] of projects or nil if no projects exist
+      def projects
+        response = get('projects')
+        response['project']
+      end
+
+      # Get project details
+      #
+      # @param options [Hash] The options hash,
+      # @option options [String] :id the project id
+      # @return [Hashie::Mash] of project details
+      def project(options={})
+        assert_options(options)
+        get("projects/#{locator(options)}")
+      end
+
+      # List of Build Configurations of a project
+      #
+      # @param (see #project)
+      # @return [Array<Hashie::Mash> of build types (an empty array will be returne if none exist)
+      def project_buildtypes(options={})
+        assert_options(options)
+        response = get("projects/#{locator(options)}/buildTypes")
+        response['buildType']
+      end
+
+      # List of parameters defined on a project
+      #
+      # @param (see #project)
+      # @return [Array<Hashie::Mash>] of parameters (empty if none are defined)
+      def project_parameters(options={})
+        assert_options(options)
+        response = get("projects/#{locator(options)}/parameters")
+        response['property']
+      end
+
+      # Get parent project
+      #
+      # @param (see #project)
+      # @return [Hashie::Mash] of the parent project details
+      # @rest_api_version >= 8.0
+      def parent_project(options={})
+        assert_options(options)
+        response = get("projects/#{locator(options)}/parentProject")
+        return nil if response['id'] == '_Root'
+        response
+      end
+
+      # Create an empty project
+      #
+      # @param name [String] Name of the project
+      # @return [Hashie::Mash] project details
+      def create_project(name)
+        post("projects", :content_type => :text) do |req|
+          req.body = name
+        end
+      end
+
+      # Copy another project
+      #
+      # @param source_project_id [String] id of the project you wish to copy
+      # @param target_project_name [String] name of the project you want to create
+      # @param options [Hash] copy project options
+      # @option options [Boolean] :copyAllAssociatedSettings copy all associated settings
+      # @options options [String] :parentProject used to define the parent project to create this project under (root will be use by default)
+      # @options options [String] :id to use for the new project
+      # @return [Hashie::Mash] project details
+      def copy_project(source_project_id, target_project_name, options={})
+        attributes = {
+          :name => target_project_name
+        }
+
+        payload = { 'sourceProject' => { locator: source_project_id } }.merge(attributes)
+
+        post("projects", :content_type => :json, :accept => :json) do |req|
+          req.body = payload.to_json
+        end
+      end
+
+      # Delete a project
+      #
+      # @param project_id [String] the id of the project
+      # @return [nil]
+      def delete_project(project_id)
+        delete("projects/#{project_id}")
+      end
+
+      # Delete a project parameter
+      #
+      # @param project_id [String] the project id
+      # @param parameter_name [String] name of the parameter to delete
+      # @return [nil]
+      def delete_project_parameter(project_id, parameter_name)
+        path = "projects/#{project_id}/parameters/#{parameter_name}"
+        delete(path, :accept => :text)
+        return nil
+      end
+
+      # Set a project parameter (Create or Update)
+      #
+      #
+      # @param project_id [String] the project id
+      # @param parameter_name [String] name of the parameter to set
+      # @param parameter_value [String] value of the parameter
+      # @return [String] parameter_value that was set
+      def set_project_parameter(project_id, parameter_name, parameter_value)
+        path = "projects/#{project_id}/parameters/#{parameter_name}"
+        put(path, :content_type => :text, :accept => :text) do |req|
+          req.body = parameter_value
+        end
+      end
+
+      # Set a project field
+      #
+      # @example Set a projects name
+      #   TeamCity.set_project_field('project1', 'name', 'new-name')
+      # @example Set a projects description
+      #   TeamCity.set_project_field('project1', 'description', 'new-description')
+      # @example Archive/Unarchive a project
+      #   Teamcity.set_project_field('project1', 'archived', 'true|false')
+      #
+      # @param project_id [String] the project id
+      # @param field_name [String] the field name: 'name', 'description', 'archived'
+      # @param field_value [String] the value to set the field to
+      # @return [String] project_field_value that was set
+      def set_project_field(project_id, field_name, field_value)
+        path = "projects/#{project_id}/#{field_name}"
+        put(path, :content_type => :text, :accept => :text) do |req|
+          req.body = field_value
+        end
+      end
+
+      # Set a parent for a given project
+      #
+      # @example Set project1 as parent for project2
+      #   TeamCity.set_parent_project('project2', 'project1')
+      #
+      # @param project_id [String] the project id
+      # @param parent_project_id [String] the parent project id
+      # @return [Hashie::Mash] of child project details
+      # @rest_api_version >= 8.0
+      def set_parent_project(project_id, parent_project_id)
+        path = "projects/#{project_id}/parentProject"
+        payload = { :id => parent_project_id }
+
+        put(path, :content_type => :json, :accept => :json) do |req|
+          req.body = payload.to_json
+        end
+      end
+    end
+  end
+end