houston-core 0.5.0.beta1 → 0.5.0

data/app/models/task.rb

@@ -1,96 +1,96 @@
 class Task < ActiveRecord::Base
-  
+
   versioned initial_version: true, only: [:description, :effort]
-  
+
   belongs_to :ticket
   belongs_to :project
   has_and_belongs_to_many :sprints, extend: UniqueAdd
   has_and_belongs_to_many :releases
   has_and_belongs_to_many :commits
-  
+
   validates :project_id, :ticket_id, :number, presence: true
   validate :description_must_be_present, :unless => :default_task?
-  
+
   before_validation :set_project_id, on: :create
   before_validation :assign_number, on: :create
   before_destroy :prevent_destroying_a_tickets_last_task
-  
+
   attr_readonly :number
-  
+
   default_scope { order(:number) }
-  
-  
-  
+
+
+
   class << self
     def open
       where completed_at: nil
     end
-    
+
     def numbered(*numbers)
       where number: numbers.flatten
     end
-    
+
     def lettered(*letters)
       numbered letters.flatten.map { |letter| to_number(letter) }
     end
-    
+
     def default
       where description: nil
     end
-    
+
     def uncommitted
       where first_commit_at: nil
     end
-    
+
     def committed
       where(arel_table[:first_commit_at].not_eq(nil))
     end
-    
+
     def unreleased
       where first_release_at: nil
     end
-    
+
     def released
       where(arel_table[:first_release_at].not_eq(nil))
     end
-    
+
     def completed
       where(arel_table[:completed_at].not_eq(nil))
     end
-    
+
     def completed_during(sprint)
       where(arel_table[:completed_at].in(sprint.range).or(arel_table[:first_commit_at].in(sprint.range)))
     end
-    
+
     def in_current_sprint
       joins(:sprint).where("sprints.end_date >= current_date")
     end
-    
+
     def checked_out_by(user)
       where(checked_out_by_id: user.id)
     end
-    
+
     def find_by_project_and_shorthand(project_slug, shorthand)
       with_shorthand(shorthand)
         .merge(Ticket.joins(:project)
           .where(Project.arel_table[:slug].eq(project_slug)))
         .first
     end
-    
+
     def with_shorthand(shorthand)
       _, ticket_number, letter = shorthand.split /(\d+)([a-z]+)/
       joins(:ticket)
         .where(Ticket.arel_table[:number].eq(ticket_number))
         .lettered(letter)
     end
-    
+
     def versions
       VestalVersions::Version.where(versioned_type: "Task", versioned_id: pluck(:id))
     end
   end
-  
-  
-  
+
+
+
   def letter
     bytes = []
     remaining = number
@@ -100,118 +100,118 @@ class Task < ActiveRecord::Base
     end
     bytes.pack "c*"
   end
-  
+
   def description
     super || ticket.summary
   end
-  
+
   def shorthand
     "#{ticket.number}#{letter}"
   end
-  
-  
-  
+
+
+
   def released!(release)
     self.releases << release unless releases.exists?(release.id)
     update_column :first_release_at, release.created_at unless released?
     Houston.observer.fire "task:released", self
   end
-  
+
   def released?
     first_release_at.present?
   end
-  
-  
-  
+
+
+
   def committed!(commit)
     update_column :first_commit_at, commit.authored_at unless committed?
     Houston.observer.fire "task:committed", self
   end
-  
+
   def committed?
     first_commit_at.present?
   end
-  
-  
-  
+
+
+
   def completed!
     return if completed?
     touch :completed_at
     Houston.observer.fire "task:completed", self
   end
   alias :complete! :completed!
-  
+
   def completed?
     completed_at.present?
   end
-  
+
   def manually_completed?
     completed? && !committed? && !released?
   end
-  
+
   def completed_during?(sprint)
     return false unless completed?
     completed_at < sprint.ends_at
   end
-  
-  
-  
+
+
+
   def reopen!
     return unless manually_completed?
     update_column :completed_at, nil
     Houston.observer.fire "task:reopened", self
   end
-  
+
   def open?
     !completed?
   end
-  
-  
-  
+
+
+
   def checked_out?(sprint)
     SprintTask.where(sprint_id: sprint.id, task_id: id).checked_out.exists?
   end
-  
+
   def checked_out_by_me?(sprint, user)
     SprintTask.where(sprint_id: sprint.id, task_id: id).checked_out_by(user).exists?
   end
-  
+
   def check_out!(sprint, user)
     SprintTask.where(sprint_id: sprint.id, task_id: id).check_out!(user)
   end
-  
+
   def check_in!(sprint)
     SprintTask.where(sprint_id: sprint.id, task_id: id).check_in!
   end
-  
-  
-  
+
+
+
   def default_task?
     number == 1 && read_attribute(:description).nil?
   end
-  
-  
-  
+
+
+
 private
-  
+
   def set_project_id
     self.project_id = ticket.project_id if ticket
   end
-  
+
   def assign_number
     self.number = (Task.where(ticket_id: ticket_id).maximum(:number) || 0) + 1
   end
-  
+
   def description_must_be_present
     errors.add :description, "can't be blank" if read_attribute(:description).blank?
   end
-  
+
   def prevent_destroying_a_tickets_last_task
     return false if ticket.tasks.pluck(:id) == [id]
   end
-  
+
   def self.to_number(letter)
     letter.bytes.reverse.each_with_index.map { |byte, i| (byte - 96) * (26 ** i) }.sum
   end
-  
+
 end

data/app/models/test_error.rb

@@ -1,8 +1,8 @@
 class TestError < ActiveRecord::Base
-  
+
   def output=(value)
     super value
     self.sha = Digest::SHA1.hexdigest(value)
   end
-  
+
 end

data/app/models/test_result.rb

@@ -7,4 +7,11 @@ class TestResult < ActiveRecord::Base
   validates :test_id, :test_run_id, presence: true
   validates :status, inclusion: {in: %w{fail skip pass}}
 
+  def self.insert_many(attributes)
+    return if attributes.none?
+    columns = attributes.first.keys
+    values = attributes.map(&:values)
+    import columns, values
+  end
+
 end

data/app/models/test_run.rb

@@ -1,6 +1,6 @@
 class TestRun < ActiveRecord::Base
   include BelongsToCommit
-  
+
   belongs_to :project
   belongs_to :user
   has_many :test_results do
@@ -9,53 +9,49 @@ class TestRun < ActiveRecord::Base
       joins(:test).where("tests.suite" => suite, "tests.name" => name).first
     end
   end
-  
+
   validates_presence_of :project_id, :sha
   validates :results_url, :presence => true, :if => :completed?
   validates :result, inclusion: {in: %w{aborted pass fail error}, allow_nil: true, message: "\"%{value}\" is unknown. It must be pass, fail, error, or aborted"}
   validates_associated :test_results
-  
+
   default_scope { order("completed_at DESC") }
-  
+
   after_save :save_tests_and_results, if: :tests_changed?
   before_save :identify_user
-  
+
   serialize :tests
   serialize :coverage
-  
-  
-  
+
+
+
   class << self
     def find_by_sha(sha)
       return nil if sha.blank?
       where(["sha LIKE ?", "#{sha}%"]).limit(1).first
     end
-    
+
     def excluding(*test_runs_or_ids)
       ids = test_runs_or_ids.flatten.map { |test_run_or_id| test_run_or_id.respond_to?(:id) ? test_run_or_id.id : test_run_or_id }
       where arel_table[:id].not_in(ids)
     end
-    
+
     def completed
       where arel_table[:completed_at].not_eq(nil)
     end
-    
-    def pending
-      where(completed_at: nil)
-    end
-    
+
     def passed
       where(result: "pass")
     end
-    
+
     def failed
       where(result: "fail")
     end
-    
+
     def errored
       where(result: "error")
     end
-    
+
     def most_recent
       joins <<-SQL
         INNER JOIN (
@@ -68,47 +64,47 @@ class TestRun < ActiveRecord::Base
       SQL
     end
   end
-  
-  
-  
+
+
+
   def failed?
     result.to_s == "fail"
   end
-  
+
   def failed_or_errored?
     %w{fail error}.member?(result.to_s)
   end
-  
+
   def passed?
     result.to_s == "pass"
   end
-  
+
   def aborted?
     result.to_s == "aborted"
   end
-  
+
   def completed_without_running_tests?
     %w{aborted error}.member?(result.to_s)
   end
-  
+
   def broken?
     return false unless failed_or_errored?
-    
+
     last_tested_ancestor = commits_since_last_test_run.last
     return false if last_tested_ancestor.nil?
-    
+
     project.test_runs.find_by_sha(last_tested_ancestor.sha).passed?
   end
-  
+
   def fixed?
     return false unless passed?
-    
+
     last_tested_ancestor = commits_since_last_test_run.last
     return false if last_tested_ancestor.nil?
-    
+
     project.test_runs.find_by_sha(last_tested_ancestor.sha).failed_or_errored?
   end
-  
+
   def short_description(with_duration: false)
     passes = "#{pass_count} #{pass_count == 1 ? "test" : "tests"} passed"
     fails = "#{fail_count} #{fail_count == 1 ? "test" : "tests"} failed"
@@ -126,24 +122,24 @@ class TestRun < ActiveRecord::Base
       "#{project.ci_server_name} was not able to run the tests"
     end
   end
-  
-  
-  
+
+
+
   def url
     "https://#{Houston.config.host}/projects/#{project.slug}/test_runs/#{sha}"
   end
-  
-  
-  
+
+
+
   def coverage_detail
     @coverage_detail ||= (Array(coverage).map do |file|
       file = file.with_indifferent_access
       SourceFileCoverage.new(project, sha, file[:filename], file[:coverage])
     end).select { |file| file.src.any? }
   end
-  
-  
-  
+
+
+
   def commits_since_last_test_run
     shas_of_tested_commits = project.test_runs.excluding(self).pluck(:sha)
     project.repo.ancestors_until(sha, including_self: true) { |ancestor|
@@ -151,7 +147,7 @@ class TestRun < ActiveRecord::Base
   rescue Houston::Adapters::VersionControl::CommitNotFound
     []
   end
-  
+
   def commits_since_last_passing_test_run
     shas_of_passing_commits = project.test_runs.passed.pluck(:sha)
     project.repo.ancestors_until(sha, including_self: true) { |ancestor|
@@ -160,13 +156,13 @@ class TestRun < ActiveRecord::Base
     []
   end
   alias :blamable_commits :commits_since_last_passing_test_run
-  
-  
-  
+
+
+
   def retry!
     trigger_build!
   end
-  
+
   def start!
     # Let's _not_ trigger the build if this Test Run is not going
     # to be saved. Let's also run BelongsToCommit#identify_commit
@@ -176,54 +172,54 @@ class TestRun < ActiveRecord::Base
     trigger_build!
     save!
   end
-  
+
   def short_commit
     sha[0...7]
   end
-  
+
   def completed?
     completed_at.present?
   end
-  
+
   def has_results?
     result.present? and !aborted?
   end
-  
+
   def trigger_build!
     project.ci_server.build!(sha)
     Houston.observer.fire "test_run:start", self
   end
-  
+
   def completed!(results_url)
     self.completed_at = Time.now unless completed?
     self.results_url = results_url
     save!
     fetch_results!
-    
+
     if has_results?
       compare_results!
       fire_complete!
     end
   end
-  
+
   def fetch_results!
     update_attributes! project.ci_server.fetch_results!(results_url)
   rescue Houston::Adapters::CIServer::Error
     update_column :result, "error"
     Rails.logger.error "#{$!.message}\n  #{$!.backtrace.join("\n  ")}"
   end
-  
+
   def fire_complete!
     Houston.observer.fire "test_run:complete", self
   end
-  
-  
-  
+
+
+
   def tests=(value)
     @tests = nil
     write_attribute :tests, value
   end
-  
+
   def tests
     @tests ||= test_results.includes(:error).joins(:test).select("test_results.*", "tests.suite", "tests.name").map do |test_result|
       message, backtrace = test_result.error.output.split("\n\n") if test_result.error
@@ -232,31 +228,31 @@ class TestRun < ActiveRecord::Base
         status: test_result.status,
         duration: test_result.duration,
         error_message: message,
-        error_backtrace: backtrace.to_s.split("\n") } 
+        error_backtrace: backtrace.to_s.split("\n") }
     end
   end
-  
-  
-  
+
+
+
   def real_fail_count
     fail_count + regression_count
   end
-  
-  
-  
+
+
+
   def identify_user
     email = Mail::Address.new(agent_email)
     self.user = User.find_by_email_address(email.address)
   end
-  
+
   def save_tests_and_results
     create_tests_and_results read_attribute(:tests)
   end
-  
+
   def create_tests_and_results(tests)
     tests = Array(tests)
     return if tests.empty?
-    
+
     tests_map = Hash.new do |hash, (suite, name)|
       begin
         test = Test.create!(suite: suite, name: name, project_id: project_id)
@@ -265,13 +261,13 @@ class TestRun < ActiveRecord::Base
       end
       hash[[suite, name]] = test.id
     end
-    
+
     Test.where(project_id: project_id).pluck(:suite, :name, :id).each do |suite, name, id|
       tests_map[[suite, name]] = id
     end
-    
+
     errors_map = Hash[TestError.pluck(:sha, :id)]
-    
+
     test_results = Houston.benchmark("Processing #{tests.count} test results") do
       tests.map do |test_attributes|
         suite = test_attributes.fetch :suite
@@ -308,16 +304,16 @@ class TestRun < ActiveRecord::Base
       TestResult.insert_many(test_results)
     end
   end
-  
-  
-  
+
+
+
   def compare_results!
     return if completed_without_running_tests?
     return unless commit
     compare_to_parent!
     compare_to_children!
   end
-  
+
   def compare_to_parent!
     return if compared?
     return unless parent = commit.parent
@@ -349,18 +345,18 @@ class TestRun < ActiveRecord::Base
       end
     end
   end
-  
+
   def compare_to_children!
     commit.children.each do |commit|
       commit.test_run.compare_results! if commit.test_run
     end
   end
-  
+
 private
-  
+
   # This is defined in Rails 4.2 but absent in previous versions
   def validate!
     raise ActiveRecord::RecordInvalid.new(self) unless valid?
   end
-  
+
 end