go_api_client 0.5.4 → 1.0.0

data/lib/go_api_client/parsers/material_parser.rb

@@ -0,0 +1,29 @@
+require 'time'
+
+module GoApiClient
+  module Parsers
+    class Material
+      class << self
+
+        def parse(root)
+          url = root.attributes['url'].value if root.attributes['url']
+          branch = root.attributes['url'].value if root.attributes['branch']
+          pipeline_name = root.attributes['pipelineName'].value if root.attributes['pipelineName']
+          stage_name = root.attributes['stageName'].value if root.attributes['stageName']
+          GoApiClient::Domain::Material.new(
+              {
+                  :uri => root.attributes['materialUri'].value,
+                  :type => root.attributes['type'].value,
+                  :url => url,
+                  :branch => branch,
+                  :pipeline_name => pipeline_name,
+                  :stage_name => stage_name,
+                  :parsed_changesets => root.xpath('./modifications/changeset').collect do |element|
+                    GoApiClient::Parsers::Changeset.parse(element)
+                  end
+              })
+        end
+      end
+    end
+  end
+end

data/lib/go_api_client/parsers/parser_helper.rb

@@ -0,0 +1,11 @@
+module GoApiClient
+  module Parsers
+    class Helper
+      class << self
+        def href_from(xml)
+          xml.first.attribute('href').value unless xml.empty?
+        end
+      end
+    end
+  end
+end

data/lib/go_api_client/parsers/pipeline_parser.rb

@@ -0,0 +1,30 @@
+require 'time'
+
+module GoApiClient
+  module Parsers
+    class Pipeline < GoApiClient::Parsers::Helper
+      class << self
+        def parse(root)
+          GoApiClient::Domain::Pipeline.new(
+              {
+                  :name => root.attributes['name'].value,
+                  :label => root.attributes['label'].value,
+                  :counter => root.attributes['counter'].value.to_i,
+                  :self_uri => href_from(root.xpath("./link[@rel='self']")),
+                  :inserted_after_uri => href_from(root.xpath("./link[@rel='insertedAfter']")),
+                  :id => root.xpath('./id').first.content,
+                  :schedule_time => Time.parse(root.xpath('./scheduleTime').first.content).utc,
+                  :approved_by => root.xpath('./approvedBy').first.content,
+                  :stages => root.xpath('./stages/stage').collect do |element|
+                    element.attributes['href'].value
+                  end,
+                  :parsed_materials => root.xpath('./materials/material').collect do |element|
+                    GoApiClient::Parsers::Material.parse(element)
+                  end
+              })
+        end
+
+      end
+    end
+  end
+end

data/lib/go_api_client/parsers/project_parser.rb

@@ -0,0 +1,26 @@
+require 'time'
+
+module GoApiClient
+  module Parsers
+    class Project < GoApiClient::Parsers::Helper
+      class << self
+        def parse(root)
+          messages = root.xpath('./messages/message').collect do |element|
+            {:text => element.attributes['text'].value, :kind => element.attributes['kind'].value}
+          end if root.xpath('./messages/message')
+          GoApiClient::Domain::Project.new(
+              {
+                  :name => root.attributes['name'].value,
+                  :activity => root.attributes['activity'].value,
+                  :last_build_status => root.attributes['lastBuildStatus'].value,
+                  :last_build_label => root.attributes['lastBuildLabel'].value,
+                  :last_build_time => Time.parse(root.attributes['lastBuildTime'].value).utc,
+                  :web_uri => root.attributes['webUrl'].value,
+                  :parsed_messages => messages
+              })
+        end
+
+      end
+    end
+  end
+end

data/lib/go_api_client/parsers/scheduled_job_parser.rb

@@ -0,0 +1,28 @@
+module GoApiClient
+  module Parsers
+    class ScheduledJob < GoApiClient::Parsers::Helper
+
+      class << self
+        def parse(root)
+          environment = root.xpath('./environment').first.content if root.xpath('./environment').first
+          resources = root.xpath('./resources/resource').collect do |element|
+            element.content
+          end if root.xpath('./resources/resource')
+          environment_variables = root.xpath('./environmentVariables/variable').collect do |element|
+            {:name => element.attributes['name'].value, :value => element.content}
+          end if root.xpath('./environmentVariables/variable')
+          GoApiClient::Domain::ScheduledJob.new(
+              {
+                  :name => root.attributes['name'].value,
+                  :id => root.attributes['id'].value.to_i,
+                  :self_uri => href_from(root.xpath("./link[@rel='self']")),
+                  :build_locator => root.xpath('./buildLocator').first.content,
+                  :environment => environment,
+                  :resources => resources,
+                  :environment_variables => environment_variables
+              })
+        end
+      end
+    end
+  end
+end

data/lib/go_api_client/parsers/stage_parser.rb

@@ -0,0 +1,31 @@
+require 'time'
+
+module GoApiClient
+  module Parsers
+    class Stage < GoApiClient::Parsers::Helper
+      class << self
+        def parse(root)
+          GoApiClient::Domain::Stage.new(
+              {
+                  :name => root.attributes['name'].value,
+                  :counter => root.attributes['counter'].value.to_i,
+                  :id => root.xpath('./id').first.content,
+                  :self_uri => href_from(root.xpath("./link[@rel='self']")),
+                  :result => root.xpath('./result').first.content,
+                  :updated => Time.parse(root.xpath('./updated').first.content).utc,
+                  :state => root.xpath('./state').first.content,
+                  :approved_by => root.xpath('./approvedBy').first.content,
+                  :jobs => root.xpath('./jobs/job').collect do |element|
+                    element.attributes['href'].value
+                  end,
+                  :pipeline_name => root.xpath('./pipeline').first.attributes['name'].value,
+                  :pipeline_counter => root.xpath('./pipeline').first.attributes['counter'].value,
+                  :pipeline_label => root.xpath('./pipeline').first.attributes['label'].value,
+                  :pipeline_uri => root.xpath('./pipeline').first.attributes['href'].value
+              })
+        end
+      end
+    end
+  end
+end
+

data/lib/go_api_client/parsers/user_parser.rb

@@ -0,0 +1,12 @@
+module GoApiClient
+  module Parsers
+    class User
+      class << self
+        def parse(root)
+          _, name, email = *root.content.match(/(.*) <(.+?)>/)
+          GoApiClient::Domain::User.new(name, email)
+        end
+      end
+    end
+  end
+end

data/lib/go_api_client/version.rb

@@ -1,9 +1,9 @@
 module GoApiClient
   module Version
-    MAJOR = 0
-    MINOR = 5
-    PATCH = 4
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
     RELEASE = ENV['GO_PIPELINE_COUNTER']
     VERSION = [MAJOR, MINOR, PATCH, RELEASE].compact.join('.')
   end
-end
+end

data/lib/go_api_client.rb

@@ -1,119 +1,65 @@
-require 'nokogiri'
-
-require 'net/http'
-
-require 'go_api_client/version'
-require 'go_api_client/helpers'
-require 'go_api_client/http_fetcher'
-
-require 'go_api_client/atom'
-require 'go_api_client/pipeline'
-require 'go_api_client/stage'
-require 'go_api_client/job'
-require 'go_api_client/artifact'
-require 'go_api_client/commit'
-require 'go_api_client/user'
 require 'go_api_client/logger'
-require 'go_api_client/engine' if defined?(::Rails)
+require 'go_api_client/version'
 
 module GoApiClient
-
-  # A wrapper that contains the last run information of scraping the go atom feed
-  class LastRun
-    # A list of pipelines
-    # @return [Array<Pipeline>]
-    # @see GoApiClient.runs
-    attr_reader :pipelines
-
-    # The most recent atom entry when the feed was last fetched
-    attr_reader :latest_atom_entry_id
-
-    def initialize(pipelines, latest_atom_entry_id)
-      @pipelines            = pipelines
-      @latest_atom_entry_id = latest_atom_entry_id
-    end
+  autoload :Client, 'go_api_client/client'
+  autoload :HttpFetcher, 'go_api_client/http_fetcher'
+  autoload :Engine, 'go_api_client/engine' if defined?(::Rails)
+  autoload :AttributeHelper, 'go_api_client/attribute_helper'
+
+  module Api
+    autoload :AbstractApi, 'go_api_client/api/abstract_api'
+    autoload :Cctray, 'go_api_client/api/cctray'
+    autoload :Config, 'go_api_client/api/config'
+    autoload :Pipeline, 'go_api_client/api/pipeline'
+    autoload :Properties, 'go_api_client/api/properties'
+    autoload :Feed, 'go_api_client/api/feed'
+    autoload :Job, 'go_api_client/api/job'
+    autoload :Stage, 'go_api_client/api/stage'
   end
 
-  class << self
-    # Connects to the a go server via the "Atom Feed API":http://www.thoughtworks-studios.com/docs/go/current/help/Feeds_API.html
-    # and fetches entire the pipeline history for that pipeline. Since this this is a wrapper around an atom feed,
-    # it is important to remember the last atom feed entry that was seen in order to prevent crawling the entire atom feed
-    # over and over again and slow the process down.
-    #
-    # @return [LastRun] an object containing a list of all pipelines ordered by their counter along with the last stage that ran in the pipeline
-    # @param [Hash] options the connection options
-    # @option options [String]  :host ("localhost") Host to connect to.
-    # @option options [Ingeger] :port (8153) Port to connect to.
-    # @option options [Boolean] :ssl  (false) If connection should be made over ssl.
-    # @option options [String]  :username (nil) The username to be used if server or the pipeline requires authorization.
-    # @option options [String]  :password (nil) The password to be used if server or the pipeline requires authorization.
-    # @option options [String]  :pipeline_name The name of the pipeline that should be fetched.
-    # @option options [String]  :latest_atom_entry_id (nil) The id of the last atom feed entry
-    def runs(options={})
-      options = ({:ssl => false, :host => 'localhost', :port => 8153, :username => nil, :password => nil, :latest_atom_entry_id => nil}).merge(options)
-
-      http_fetcher = GoApiClient::HttpFetcher.new(:username => options[:username], :password => options[:password])
-
-      pipeline_name = options[:pipeline_name] || "defaultPipeline"
-      feed_url = "#{options[:ssl] ? 'https' : 'http'}://#{options[:host]}:#{options[:port]}/go/api/pipelines/#{pipeline_name}/stages.xml"
-      feed = GoApiClient::Atom::Feed.new(feed_url, options[:latest_atom_entry_id])
-      feed.fetch!(http_fetcher)
-      return construct_last_run(feed, http_fetcher, options[:latest_atom_entry_id])
-    end
-
-    def all_runs(options={})
-      options = ({:ssl => false, :host => 'localhost', :port => 8153, :username => nil, :password => nil}).merge(options)
-      http_fetcher = GoApiClient::HttpFetcher.new(:username => options[:username], :password => options[:password])
-      feed_url = "#{options[:ssl] ? 'https' : 'http'}://#{options[:host]}:#{options[:port]}/go/api/pipelines.xml"
-      feed = GoApiClient::Atom::Feed.new(feed_url, nil)
-      feed = feed.fetch_all!(http_fetcher)
-      feed.inject({}) do |memo, (href, entries)|
-        memo[href] = construct_last_run(entries, http_fetcher, nil)
-        memo
-      end
-    end
-
-    # Answers if a build is in progress. For the list of supported connection options see {GoApiClient.runs #runs}
-    # @see .build_finished?
-    def build_in_progress?(options={})
-      raise ArgumentError("Hostname is mandatory") unless options[:host]
-      options = ({:ssl => false, :port => 8153, :username => nil, :password => nil, :pipeline_name => 'defaultPipeline'}).merge(options)
-      http_fetcher = GoApiClient::HttpFetcher.new(:username => options[:username], :password => options[:password])
-      url = "#{options[:ssl] ? 'https' : 'http'}://#{options[:host]}:#{options[:port]}/go/cctray.xml"
-      doc = Nokogiri::XML(http_fetcher.get!(url))
-      doc.css("Project[activity='Building'][name^='#{options[:pipeline_name]} ::']").count > 0
-    end
-
-    # Answers if a build is in completed. For the list of supported connection options see {GoApiClient.runs #runs}
-    # @see .build_in_progress?
-    def build_finished?(options)
-      !build_in_progress?(options)
-    end
-
-    # Schedule a particular pipeline with the latest available materials.
-    def schedule_pipeline(options)
-      raise ArgumentError("Hostname is mandatory") unless options[:host]
-      options = ({:ssl => false, :port => 8153, :username => nil, :password => nil, :pipeline_name => 'defaultPipeline'}).merge(options)
-
-      uri = "#{options[:ssl] ? 'https' : 'http'}://#{options[:host]}:#{options[:port]}/go/api/pipelines/#{options[:pipeline_name]}/schedule"
-      GoApiClient::HttpFetcher.new.post!(uri)
+  module Domain
+    autoload :Author, 'go_api_client/domain/author'
+    autoload :Artifact, 'go_api_client/domain/artifact'
+    autoload :Changeset, 'go_api_client/domain/changeset'
+    autoload :Entry, 'go_api_client/domain/entry'
+    autoload :Feed, 'go_api_client/domain/feed'
+    autoload :InternalCache, 'go_api_client/domain/internal_cache'
+    autoload :Job, 'go_api_client/domain/job'
+    autoload :ScheduledJob, 'go_api_client/domain/scheduled_job'
+    autoload :Pipeline, 'go_api_client/domain/pipeline'
+    autoload :Stage, 'go_api_client/domain/stage'
+    autoload :Material, 'go_api_client/domain/material'
+    autoload :Project, 'go_api_client/domain/project'
+    autoload :User, 'go_api_client/domain/user'
+
+    module Config
+      autoload :Pipeline, 'go_api_client/domain/config/pipeline'
+      autoload :Stage, 'go_api_client/domain/config/stage'
+      autoload :Job, 'go_api_client/domain/config/job'
     end
+  end
 
-    private
-
-    def construct_last_run(feed, http_fetcher, last_atom_entry_id)
-      pipelines = {}
-      stages = feed.entries.collect do |entry|
-        Stage.from(entry.stage_href, :authors => entry.authors, :pipeline_cache => pipelines, :http_fetcher => http_fetcher)
-      end
-
-      pipelines.values.each do |p|
-        p.stages = p.stages.sort_by {|s| s.completed_at }
-      end
-
-      pipelines = pipelines.values.sort_by {|p| p.counter}
-      latest_atom_entry_id = stages.empty? ? last_atom_entry_id : feed.entries.first.id
-      return LastRun.new(pipelines, latest_atom_entry_id)
+  module Parsers
+    autoload :Author, 'go_api_client/parsers/author_parser'
+    autoload :Artifact, 'go_api_client/parsers/artifact_parser'
+    autoload :Changeset, 'go_api_client/parsers/changeset'
+    autoload :Material, 'go_api_client/parsers/material_parser'
+    autoload :Job, 'go_api_client/parsers/job_parser'
+    autoload :ScheduledJob, 'go_api_client/parsers/scheduled_job_parser'
+    autoload :Helper, 'go_api_client/parsers/parser_helper'
+    autoload :Pipeline, 'go_api_client/parsers/pipeline_parser'
+    autoload :Stage, 'go_api_client/parsers/stage_parser'
+    autoload :Author, 'go_api_client/parsers/author_parser'
+    autoload :Entry, 'go_api_client/parsers/entry_parser'
+    autoload :Feed, 'go_api_client/parsers/feed_parser'
+    autoload :Project, 'go_api_client/parsers/project_parser'
+    autoload :User, 'go_api_client/parsers/user_parser'
+
+    module Config
+      autoload :Pipeline, 'go_api_client/parsers/config/pipeline_parser'
+      autoload :Stage, 'go_api_client/parsers/config/stage_parser'
+      autoload :Job, 'go_api_client/parsers/config/job_parser'
     end
   end
-end
+end

data/test/go_api_client/artifact_test.rb

@@ -1,15 +1,15 @@
-require "test_helper"
+require 'test_helper'
 
 module GoApiClient
   class ArtifactTest < Test::Unit::TestCase
-    test "should construct the artifacts from the job xml" do
-      stub_request(:get, "http://localhost:8153/go/api/jobs/3.xml").to_return(:body => file_contents("jobs_3.xml"))
+    test 'should construct the artifacts from the job xml' do
+      link = 'http://localhost:8153/go/api/jobs/3.xml'
+      stub_request(:get, link).to_return(:body => file_contents('jobs_3.xml'))
 
-      link = "http://localhost:8153/go/api/jobs/3.xml"
-      job = GoApiClient::Job.from(link)
-      assert_equal 2, job.artifacts.count
-      assert_equal "https://ci.snap-ci.com/go/files/Go-SaaS-Rails/898/Dist/1/rpm/tmp.zip", job.artifacts.first.as_zip_file_url
-      assert_equal "https://ci.snap-ci.com/go/files/Go-SaaS-Rails/898/Dist/1/rpm/log.zip", job.artifacts.last.as_zip_file_url
+      job = GoApiClient::Client.new.api(:job).job({:job_uri => link})
+      assert_equal 2, job.parsed_artifacts.count
+      assert_equal 'https://ci.snap-ci.com/go/files/Go-SaaS-Rails/898/Dist/1/rpm/tmp.zip', job.parsed_artifacts.first.as_zip_file_url
+      assert_equal 'https://ci.snap-ci.com/go/files/Go-SaaS-Rails/898/Dist/1/rpm/log.zip', job.parsed_artifacts.last.as_zip_file_url
     end
   end
 end

data/test/go_api_client/author_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module GoApiClient
+  module Atom
+    class AuthorTest < Test::Unit::TestCase
+
+      test 'should be able to parse author:s info' do
+        doc = Nokogiri::XML('<author xmlns="http://www.w3.org/2005/Atom"><name><![CDATA[oogabooga <twgosaas@gmail.com>]]></name><uri>http://oogabooga.example.com<uri></author>')
+        author = GoApiClient::Parsers::Author.parse(doc.root)
+        assert_equal GoApiClient::Domain::Author.new({:name => 'oogabooga', :email => 'twgosaas@gmail.com', :uri => 'http://oogabooga.example.com'}), author
+      end
+
+      test 'should be able to parse author xml with no email and uri' do
+        doc = Nokogiri::XML('<author xmlns="http://www.w3.org/2005/Atom"><name><![CDATA[oogabooga]]></name></author>')
+        author = GoApiClient::Parsers::Author.parse(doc.root)
+        assert_equal GoApiClient::Domain::Author.new({:name => 'oogabooga'}), author
+      end
+
+      test 'should be able to parse author xml with email specified in the name tag' do
+        doc = Nokogiri::XML('<author xmlns="http://www.w3.org/2005/Atom"><name><![CDATA[oogabooga <twgosaas@gmail.com>]]></name></author>')
+        author = GoApiClient::Parsers::Author.parse(doc.root)
+        assert_equal GoApiClient::Domain::Author.new({:name => 'oogabooga', :email => 'twgosaas@gmail.com'}), author
+      end
+
+    end
+  end
+end

data/test/go_api_client/building_test.rb

@@ -1,10 +1,10 @@
-require "test_helper"
+require 'test_helper'
 
 module GoApiClient
   class BuildingTest < Test::Unit::TestCase
 
-    test "should report that Go is building if atleast 1 stage in specified pipeline is building" do
-      feed = %Q{
+    test 'should report that Go is building if atleast 1 stage in specified pipeline is building' do
+      feed = '
               <?xml version="1.0" encoding="utf-8"?>
               <Projects>
                 <Project name="defaultPipeline :: RailsTests" activity="Building" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
@@ -13,15 +13,16 @@ module GoApiClient
                 <Project name="anotherPipeline :: RailsTests" activity="Sleeping" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
                 <Project name="anotherPipeline :: SmokeTests" activity="Sleeping" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
               </Projects>
-           }
-      stub_request(:get, "http://go-server.2.project:8153/go/cctray.xml").
-        to_return(:body => feed)
-      assert       GoApiClient.build_in_progress?(:host => 'go-server.2.project', :pipeline_name => 'defaultPipeline')
-      assert_false GoApiClient.build_in_progress?(:host => 'go-server.2.project', :pipeline_name => 'anotherPipeline')
+           '
+      stub_request(:get, 'http://go-server.2.project:8153/go/cctray.xml').to_return(:body => feed)
+
+      cctray_api = GoApiClient::Client.new({:host => 'go-server.2.project'}).api(:cctray)
+      assert_false cctray_api.projects({:pipeline_name => 'defaultPipeline', :activity => 'Building'}).empty?
+      assert       cctray_api.projects({:pipeline_name => 'anotherPipeline', :activity => 'Building'}).empty?
     end
 
-    test "should report that Go is sleeping if all stages in specified pipeline are sleeping" do
-      feed = %Q{
+    test 'should report that Go is sleeping if all stages in specified pipeline are sleeping' do
+      feed = '
               <?xml version="1.0" encoding="utf-8"?>
               <Projects>
                 <Project name="defaultPipeline :: RailsTests" activity="Sleeping" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
@@ -30,17 +31,18 @@ module GoApiClient
                 <Project name="anotherPipeline :: RailsTests" activity="Building" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
                 <Project name="anotherPipeline :: SmokeTests" activity="Sleeping" lastBuildStatus="Success" lastBuildLabel="4" lastBuildTime="2012-07-19T10:03:04" webUrl="http://go-server.2.project:8153/go/pipelines/defaultPipeline/5/RailsTests/1" />
               </Projects>
-           }
-      stub_request(:get, "http://go-server.2.project:8153/go/cctray.xml").
-        to_return(:body => feed)
-      assert        GoApiClient.build_finished?(:host => 'go-server.2.project', :pipeline_name => 'defaultPipeline')
-      assert_false  GoApiClient.build_finished?(:host => 'go-server.2.project', :pipeline_name => 'anotherPipeline')
+           '
+      stub_request(:get, 'http://go-server.2.project:8153/go/cctray.xml').to_return(:body => feed)
+
+      cctray_api = GoApiClient::Client.new({:host => 'go-server.2.project'}).api(:cctray)
+      assert_false cctray_api.projects({:pipeline_name => 'anotherPipeline', :activity => 'Building'}).empty?
+      assert       cctray_api.projects({:pipeline_name => 'defaultPipeline', :activity => 'Building'}).empty?
     end
 
-    test "should handle empty feeds" do
-      stub_request(:get, "http://go-server.2.project:8153/go/cctray.xml").
-        to_return(:body => nil)
-      assert_false GoApiClient.build_in_progress?(:host => 'go-server.2.project')
+    test 'should handle empty feeds' do
+      stub_request(:get, 'http://go-server.2.project:8153/go/cctray.xml').to_return(:body => nil)
+      cctray_api = GoApiClient::Client.new({:host => 'go-server.2.project'}).api(:cctray)
+      assert       cctray_api.projects({:pipeline_name => 'defaultPipeline', :activity => 'Building'}).empty?
     end
 
   end