14 |
15 | <% @targets.each do |t| %>
16 |
17 |
29 |
30 |
--------------------------------------------------------------------------------
/config/environments/development.rb:
--------------------------------------------------------------------------------
1 | Testmine::Application.configure do
2 | # Settings specified here will take precedence over those in config/application.rb.
3 |
4 | # In the development environment your application's code is reloaded on
5 | # every request. This slows down response time but is perfect for development
6 | # since you don't have to restart the web server when you make code changes.
7 | config.cache_classes = false
8 |
9 | # Do not eager load code on boot.
10 | config.eager_load = false
11 |
12 | # Show full error reports and disable caching.
13 | config.consider_all_requests_local = true
14 | config.action_controller.perform_caching = false
15 |
16 | # Don't care if the mailer can't send.
17 | config.action_mailer.raise_delivery_errors = false
18 |
19 | # Print deprecation notices to the Rails logger.
20 | config.active_support.deprecation = :log
21 |
22 | # Raise an error on page load if there are pending migrations
23 | config.active_record.migration_error = :page_load
24 |
25 | # Debug mode disables concatenation and preprocessing of assets.
26 | # This option may cause significant delays in view rendering with a large
27 | # number of complex assets.
28 | config.assets.debug = true
29 |
30 | config.assets.paths << "#{Rails.root}/app/assets/fonts"
31 | end
32 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM centos:7
2 |
3 | RUN yum -y update
4 | RUN yum -y groupinstall 'Development Tools'
5 | RUN yum -y install wget libxslt-devel libyaml-devel libxml2-devel gdbm-devel libffi-devel zlib-devel openssl-devel libyaml-devel readline-devel curl-devel openssl-devel pcre-devel git memcached-devel valgrind-devel mysql-devel ImageMagick-devel ImageMagick
6 | RUN yum -y install mariadb-server
7 |
8 | RUN curl -sL https://rpm.nodesource.com/setup_8.x | bash -
9 | RUN yum install -y nodejs
10 |
11 | RUN cd /tmp
12 | RUN wget http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
13 | RUN rpm -Uvh epel-release-latest-7.noarch.rpm
14 |
15 | # ruby 2.5.1
16 | RUN cd /usr/local/src
17 | RUN wget "https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.1.tar.gz"
18 | RUN tar -zxvf "ruby-2.5.1.tar.gz"
19 | RUN cd ruby-2.5.1 \
20 | && ./configure \
21 | && make \
22 | && make install
23 |
24 | # ruby-gems
25 | RUN cd ..
26 | RUN wget "https://rubygems.org/rubygems/rubygems-2.7.7.tgz"
27 | RUN tar -zxvf "rubygems-2.7.7.tgz"
28 | RUN cd rubygems-2.7.7 \
29 | && /usr/local/bin/ruby setup.rb
30 |
31 | ENV app /app
32 |
33 | RUN mkdir $app
34 | WORKDIR $app
35 | ADD . $app
36 |
37 | RUN cd $app
38 | RUN bundle update
39 | RUN bundle install
40 |
41 | RUN rake acts_as_taggable_on_engine:install:migrations
42 |
43 | EXPOSE 3002
--------------------------------------------------------------------------------
/app/assets/stylesheets/application.scss:
--------------------------------------------------------------------------------
1 | /*
2 | * This is a manifest file that'll be compiled into application.css, which will include all the files
3 | * listed below.
4 | *
5 | * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
6 | * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
7 | *
8 | * You're free to add application-wide styles to this file and they'll appear at the top of the
9 | * compiled file, but it's generally better to create a new file per style scope.
10 | *
11 | */
12 |
13 | // "bootstrap-sprockets" must be imported before "bootstrap" and "bootstrap/variables"
14 | @import "bootstrap-sprockets";
15 | @import "bootstrap";
16 | @import "font-awesome-sprockets";
17 | @import "font-awesome";
18 | @import "result_badges";
19 | @import "tags";
20 | @import "world_effects";
21 | @import "result_tables";
22 |
23 | .navbar-image {
24 | float: left;
25 | padding: 5px 20px 5px 5px;
26 | }
27 |
28 | .reliability table {
29 | border-collapse: collapse;
30 | width: 100%;
31 | }
32 |
33 | .reliability th, .reliability td {
34 | text-align: left;
35 | padding: 8px;
36 | }
37 |
38 | .reliability tr:nth-child(even){
39 | background-color: #f2f2f2
40 | }
41 |
42 | .reliability th {
43 | background-color: #4CAF50;
44 | color: white;
45 | }
46 |
--------------------------------------------------------------------------------
/app/models/flaky_result_report.rb:
--------------------------------------------------------------------------------
1 | class FlakyResultReport
2 |
3 | def self.populate( args )
4 |
5 | primary_world_id = args[:world_id] or raise "Need to provide a primary world id"
6 | primary_world = World.find(primary_world_id)
7 | target = args[:target]
8 |
9 | tags = args[:tags]
10 |
11 | primary_results_by_test = Result.unscoped
12 | .includes(:test_definition => :tags,
13 | :children => [
14 | :children => [:test_definition => :tags],
15 | :test_definition => :tags ])
16 | .joins(:run)
17 | .where(:parent_id => nil, :runs => {:target => target, :world_id => primary_world_id})
18 | .last(500)
19 | .group_by { |r| r.test_definition }
20 |
21 | tests = primary_results_by_test.keys
22 |
23 | aggregates = tests.map do |test|
24 | primary_results = primary_results_by_test[test] || []
25 | AggregateResult.new( test, primary_world, primary_results, target, tags )
26 | end
27 |
28 | AggregateResultGroup.new( :results => aggregates, :world => primary_world, :target => target )
29 | end
30 |
31 | end
32 |
--------------------------------------------------------------------------------
/app/assets/javascripts/lazy_loading.js:
--------------------------------------------------------------------------------
1 | function loadComparisonGroups(tag) {
2 |
3 | var elements = $('.comparison-loader')
4 | for ( var i=0; i < elements.length; i++ ) {
5 | loadComparisonGroup(elements[i].id, tag)
6 | }
7 | }
8 |
9 | function loadComparisonGroup(id, tag)
10 | {
11 | var elems = id.split("-");
12 | elems.shift();
13 | var primary_id = elems.shift();
14 | var reference_id = elems.shift();
15 | var target = elems.join('-');
16 |
17 | $.ajax({ url: '/comparison/'+primary_id+'/'+reference_id+'?target='+target+'&tag='+tag,
18 | type: 'GET',
19 | success: function( data ) {
20 | $('[id="' + id + '"]').replaceWith(data);
21 | }
22 | })
23 | }
24 |
25 | function loadAggregateGroups(tag) {
26 |
27 | var elements = $('.aggregate-group-loader')
28 | for ( var i=0; i < elements.length; i++ ) {
29 | loadAggregateGroup(elements[i].id, tag)
30 | }
31 | }
32 |
33 | function loadAggregateGroup(id, tag)
34 | {
35 | var elems = id.split("-");
36 | elems.shift();
37 | var world_id = elems.shift();
38 | var target = elems.join('-');
39 |
40 | $.ajax({ url: '/aggregate/'+world_id+'?target='+target+'&tag='+tag,
41 | type: 'GET',
42 | success: function( data ) {
43 | $('[id="' + id + '"]').replaceWith(data);
44 | }
45 | })
46 | }
--------------------------------------------------------------------------------
/app/views/suites/show.html.erb:
--------------------------------------------------------------------------------
1 |
18 |
26 | <% end %>
27 |
28 |
19 |
24 |
25 | 20 | <%=t-%> 21 | (loading...) 22 |
23 |
2 |
7 |
8 | <%= ( @suite.name ? @suite.name : "Unnamed suite (##{@suite.id})" )-%>
3 |<%= @suite.description -%>
4 |<%= link_to @suite.url, @suite.url if @suite.url -%>
5 |<%= link_to @suite.repo, @suite.repo if @suite.url-%>
6 |
9 |
10 |
11 |
16 |
17 |
18 |
19 | | ID | <%= @suite.id -%> |
|---|---|
| Project | <%= @suite.project -%> |
| Runner | <%= @suite.runner -%> |
| Created | <%= simple_time(@suite.created_at) -%> |
20 | <%= @suite.documentation -%>
21 |
22 |
23 |
24 |
27 |
28 |
29 |
47 |
48 |
49 |
--------------------------------------------------------------------------------
/public/500.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Latest test worlds
25 | 26 || ID | 30 |World | 31 |Flaky Test Report | 32 |Version | 33 |Runs | 34 | 35 | <% @worlds.each do |w| %> 36 | 37 |
|---|---|---|---|---|
| <%= w.id -%> | 39 |<%= link_to w.name, "/worlds/#{w.id}" -%> | 40 |<%= link_to "View", "/flaky-test-report/#{w.id}?" if w.runs.count > 1 -%> | 41 |<%= w.version -%> | 42 |<%= w.runs.count -%> | 43 |
53 |
55 | We're sorry, but something went wrong.
54 |If you are the application owner check the logs for more information.
56 | 57 | 58 | -------------------------------------------------------------------------------- /public/422.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
53 |
56 | The change you wanted was rejected.
54 |Maybe you tried to change something you didn't have access to.
55 |If you are the application owner check the logs for more information.
57 | 58 | 59 | -------------------------------------------------------------------------------- /public/404.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
53 |
56 | The page you were looking for doesn't exist.
54 |You may have mistyped the address or the page may have moved.
55 |If you are the application owner check the logs for more information.
57 | 58 | 59 | -------------------------------------------------------------------------------- /spec/models/world_spec.rb: -------------------------------------------------------------------------------- 1 | require 'spec_helper' 2 | 3 | describe World do 4 | 5 | describe World::SingleComponent do 6 | 7 | describe "#find_or_create" do 8 | 9 | it "creates a new world with a world id" do 10 | world = World::SingleComponent.find_or_create( 11 | :component => "TestMite", 12 | :project => "Hive", 13 | :version => "1.2.3" ) 14 | 15 | world.should be_a World::SingleComponent 16 | world.id.should be_a Fixnum 17 | world.component.should be_a String 18 | world.project.should be_a String 19 | world.version.should be_a String 20 | world.name.should be_a String 21 | end 22 | 23 | it "creates and retrieves a world just created" do 24 | args = { 25 | :project => "Hive", 26 | :component => "TestMite", 27 | :version => "1.2.3" } 28 | 29 | world1 = World::SingleComponent.find_or_create( args ) 30 | world2 = World::SingleComponent.find_or_create( args ) 31 | 32 | world1.id.should == world2.id 33 | end 34 | 35 | it "retrieves two runs for a world" do 36 | world = World::SingleComponent.find_or_create( 37 | :component => "TestMite", 38 | :project => "Hive", 39 | :version => "1.2.3" ) 40 | 41 | r1 = Run.create( world: world, target: 'x86_64' ) 42 | r2 = Run.create( world: world, target: 'x86_64' ) 43 | 44 | world.runs.count.should == 2 45 | 46 | end 47 | 48 | end 49 | 50 | end 51 | 52 | end 53 | -------------------------------------------------------------------------------- /app/views/layouts/_favicons.html.erb: -------------------------------------------------------------------------------- 1 | <%= favicon_link_tag( 'apple-touch-icon-57x57.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '57x57' ) -%> 2 | <%= favicon_link_tag( 'apple-touch-icon-60x60.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '60x60' ) -%> 3 | <%= favicon_link_tag( 'apple-touch-icon-72x72.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '72x72' ) -%> 4 | <%= favicon_link_tag( 'apple-touch-icon-76x76.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '76x76' ) -%> 5 | <%= favicon_link_tag( 'apple-touch-icon-114x114.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '114x114' ) -%> 6 | <%= favicon_link_tag( 'apple-touch-icon-120x120.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '120x120' ) -%> 7 | <%= favicon_link_tag( 'apple-touch-icon-144x144.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '144x144' ) -%> 8 | <%= favicon_link_tag( 'apple-touch-icon-152x152.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '152x152' ) -%> 9 | <%= favicon_link_tag( 'apple-touch-icon-180x180.png', rel: "apple-touch-icon", :type => 'image/png', :sizes => '180x180' ) -%> 10 | 11 | <%= favicon_link_tag( 'favicon-32x32.png', rel: "icon", :type => 'image/png', :sizes => '32x32' ) -%> 12 | <%= favicon_link_tag( 'favicon-194x194.png', rel: "icon", :type => 'image/png', :sizes => '194x194' ) -%> 13 | <%= favicon_link_tag( 'favicon-96x96.png', rel: "icon", :type => 'image/png', :sizes => '96x96' ) -%> 14 | <%= favicon_link_tag( 'favicon-192x192.png', rel: "icon", :type => 'image/png', :sizes => '192x192' ) -%> 15 | <%= favicon_link_tag( 'favicon-16x16.png', rel: "icon", :type => 'image/png', :sizes => '16x16' ) -%> -------------------------------------------------------------------------------- /config/environments/test.rb: -------------------------------------------------------------------------------- 1 | Testmine::Application.configure do 2 | # Settings specified here will take precedence over those in config/application.rb. 3 | 4 | # The test environment is used exclusively to run your application's 5 | # test suite. You never need to work with it otherwise. Remember that 6 | # your test database is "scratch space" for the test suite and is wiped 7 | # and recreated between test runs. Don't rely on the data there! 8 | config.cache_classes = true 9 | 10 | # Do not eager load code on boot. This avoids loading your whole application 11 | # just for the purpose of running a single test. If you are using a tool that 12 | # preloads Rails for running tests, you may have to set it to true. 13 | config.eager_load = false 14 | 15 | # Configure static asset server for tests with Cache-Control for performance. 16 | config.serve_static_assets = true 17 | config.static_cache_control = "public, max-age=3600" 18 | 19 | # Show full error reports and disable caching. 20 | config.consider_all_requests_local = true 21 | config.action_controller.perform_caching = false 22 | 23 | # Raise exceptions instead of rendering exception templates. 24 | config.action_dispatch.show_exceptions = false 25 | 26 | # Disable request forgery protection in test environment. 27 | config.action_controller.allow_forgery_protection = false 28 | 29 | # Tell Action Mailer not to deliver emails to the real world. 30 | # The :test delivery method accumulates sent emails in the 31 | # ActionMailer::Base.deliveries array. 32 | config.action_mailer.delivery_method = :test 33 | 34 | # Print deprecation notices to the stderr. 35 | config.active_support.deprecation = :stderr 36 | 37 | config.assets.paths << "#{Rails.root}/app/assets/fonts" 38 | end 39 | -------------------------------------------------------------------------------- /spec/spec_helper.rb: -------------------------------------------------------------------------------- 1 | # This file is copied to spec/ when you run 'rails generate rspec:install' 2 | ENV["RAILS_ENV"] ||= 'test' 3 | require File.expand_path("../../config/environment", __FILE__) 4 | require 'rspec/rails' 5 | require 'rspec/autorun' 6 | 7 | # Requires supporting ruby files with custom matchers and macros, etc, 8 | # in spec/support/ and its subdirectories. 9 | Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f } 10 | 11 | # Checks for pending migrations before tests are run. 12 | # If you are not using ActiveRecord, you can remove this line. 13 | ActiveRecord::Migration.check_pending! if defined?(ActiveRecord::Migration) 14 | 15 | RSpec.configure do |config| 16 | # ## Mock Framework 17 | # 18 | # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line: 19 | # 20 | # config.mock_with :mocha 21 | # config.mock_with :flexmock 22 | # config.mock_with :rr 23 | 24 | # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures 25 | config.fixture_path = "#{::Rails.root}/spec/fixtures" 26 | 27 | # If you're not using ActiveRecord, or you'd prefer not to run each of your 28 | # examples within a transaction, remove the following line or assign false 29 | # instead of true. 30 | config.use_transactional_fixtures = true 31 | 32 | # If true, the base class of anonymous controllers will be inferred 33 | # automatically. This will be the default behavior in future versions of 34 | # rspec-rails. 35 | config.infer_base_class_for_anonymous_controllers = false 36 | 37 | # Run specs in random order to surface order dependencies. If you find an 38 | # order dependency and want to debug it, you can fix the order by providing 39 | # the seed, which is printed after each run. 40 | # --seed 1234 41 | config.order = "random" 42 | end 43 | -------------------------------------------------------------------------------- /app/models/test_definition.rb: -------------------------------------------------------------------------------- 1 | class TestDefinition < ActiveRecord::Base 2 | 3 | belongs_to :suite 4 | belongs_to :parent, :foreign_key => "parent_id", :class_name => 'TestDefinition' 5 | has_many :children, :foreign_key => "parent_id", :class_name => 'TestDefinition', :dependent => :destroy 6 | has_many :results 7 | acts_as_taggable 8 | default_scope { includes( :tags) } 9 | 10 | 11 | def self.find_or_create(args) 12 | TestDefinition.where( 13 | name: args[:name], 14 | suite_id: args[:suite_id], 15 | file: args[:file], 16 | parent_id: args[:parent_id] 17 | ).first_or_create do |test| 18 | test.name = args[:name] 19 | test.node_type = args[:node_type] 20 | test.description = args[:description] 21 | test.file = args[:file] 22 | test.line = args[:line] 23 | test.parent_id = args[:parent_id] 24 | test.tag_list = args[:tags] 25 | end 26 | end 27 | 28 | def specific_tags 29 | if ! @specific_tags 30 | @specific_tags = self.tags.collect { |t| t.name } 31 | end 32 | @specific_tags 33 | end 34 | 35 | def inherited_tags 36 | if ! @inherited_tags 37 | all = self.tags.collect { |t| t.name } 38 | if self.parent 39 | all += self.parent.inherited_tags 40 | end 41 | all.uniq 42 | @inherited_tags = all.uniq 43 | end 44 | @inherited_tags 45 | end 46 | 47 | def add_test_definition(args) 48 | args[:suite_id] = self.suite_id 49 | args[:parent_id] = self.id 50 | args[:file] = self.file if !args[:file] 51 | TestDefinition.find_or_create(args) 52 | end 53 | 54 | def file_name( modifier = :short ) 55 | file_name = file 56 | if modifier == :short 57 | file =~ /.*features\/(.*.feature)/ 58 | file_name = $1 if $1 59 | end 60 | file_name 61 | end 62 | 63 | def confidence 64 | end 65 | end 66 | -------------------------------------------------------------------------------- /app/views/flaky_test/show.erb: -------------------------------------------------------------------------------- 1 | <% @has_flaky = false %> 2 |Flaky Test Report
3 |4 |
5 |
6 | <% if !@tags.empty? %>
7 | <% @tags.each do |t| %>
8 |
14 | <% end %>
15 | <% end %>
16 |
17 |
61 | <% if !@has_flaky %>
62 |
18 |
22 |
23 | 19 | <%=@target-%> 20 |
21 |
24 |
25 | <% if !@results.results.empty? %>
26 |
27 |
28 |
55 |
56 | <% end %>
57 |
58 |
59 |
60 | | Suite | 30 |Test Name | 31 |Pass | 32 |Fail | 33 |Flaky (%) | 34 |
|---|---|---|---|---|
| <%= r.test_definition.name %> | 43 | 44 |45 | <%= link_to( pretty_truncate(h(s.test_definition.name), 80, 'em'), "/tests/#{s.test_definition.id}?target=#{@target}&detail=true") -%> | 46 |<%= s.statuses.count("pass") %> | 47 |<%= s.statuses.count("fail") %> | 48 |<%= s.flakyPercentage %> | 49 |
There are no flaky tests in this world.
63 | <% end %> 64 | -------------------------------------------------------------------------------- /spec/extras/ingest_cucumber_run_spec.rb: -------------------------------------------------------------------------------- 1 | require 'spec_helper' 2 | require 'json' 3 | 4 | describe IrIngestor do 5 | describe "ingesting a simple result" do 6 | 7 | before(:all) do 8 | @ir = { 9 | type: "ruby cucumber", 10 | started: Time.now-20, 11 | finished: Time.now.to_s, 12 | target: 'x86_32', 13 | project: 'hive', 14 | world: { 15 | component: 'web_app', 16 | version: '0.2.2' 17 | }, 18 | project: "hive", 19 | suite: "cucumber", 20 | results: [ 21 | { 22 | "file" => "features/simple_feature.feature", 23 | "line" => 2, 24 | "type" =>"Cucumber::Feature", 25 | "name" =>"Background steps", 26 | "description" => "As a user\nI want results!", 27 | "children" => [ 28 | { 29 | "file" => "features/simple_feature.feature", 30 | "line" => 14, 31 | "type" => "Cucumber::Scenario", 32 | "name" => "Deleted scenario", 33 | "children" =>[ 34 | { 35 | "type" => "Cucumber::Step", 36 | "name" => "Given something", 37 | "status" => "pass" 38 | }, 39 | { 40 | "type" => "Cucumber::Step", 41 | "name" => "When something happens", 42 | "status" => "pass" 43 | }, 44 | { 45 | "type" => "Cucumber::Step", 46 | "name" => "Then something else happens", 47 | "status" => "fail" 48 | } 49 | ] 50 | }] 51 | } 52 | ] 53 | }.to_json 54 | 55 | end 56 | 57 | it "imports under a single result object" do 58 | 59 | run = IrIngestor.parse_ir(@ir) 60 | 61 | run.results.count.should == 5 62 | run.top_level_results.count.should == 1 63 | 64 | run.top_level_results.first.status.should be_nil 65 | run.top_level_results.first.children.first.status.should be_nil 66 | 67 | run.top_level_results.first.children.first.children.first.status.should == "pass" 68 | end 69 | end 70 | 71 | end -------------------------------------------------------------------------------- /app/controllers/reliability_controller.rb: -------------------------------------------------------------------------------- 1 | class ReliabilityController < ApplicationController 2 | 3 | def show 4 | suite_id = params[:suite] 5 | @suite_name = get_suite_name(suite_id) 6 | @fail_last_day = fail_last_day(suite_id) 7 | @fail_last_week = fail_last_week(suite_id) 8 | @fail_last_month = fail_last_month(suite_id) 9 | @pass_last_day = pass_last_day(suite_id) 10 | @pass_last_week = pass_last_week(suite_id) 11 | @pass_last_month = pass_last_month(suite_id) 12 | @reliability_last_day = get_reliability(@fail_last_day,@pass_last_day) 13 | @reliability_last_week = get_reliability(@fail_last_week,@pass_last_week) 14 | @reliability_last_month = get_reliability(@fail_last_month,@pass_last_month) 15 | end 16 | 17 | def get_suite_name(suite_id) 18 | suite_name = Suite.find_by_sql("SELECT suites.name from suites where suites.id = " + suite_id.to_s) 19 | suite_name[0].name || "" 20 | end 21 | 22 | def get_reliability(fails,passes) 23 | fails = fails.to_f 24 | passes = passes.to_f 25 | 26 | 100.0 - (fails/passes * 100/1) 27 | end 28 | 29 | def fail_last_day(suite_id) 30 | fail_count(suite_id,2) 31 | end 32 | 33 | def fail_last_week(suite_id) 34 | fail_count(suite_id,7) 35 | end 36 | 37 | def fail_last_month(suite_id) 38 | fail_count(suite_id,30) 39 | end 40 | 41 | def pass_last_day(suite_id) 42 | pass_count(suite_id,2) 43 | end 44 | 45 | def pass_last_week(suite_id) 46 | pass_count(suite_id,7) 47 | end 48 | 49 | def pass_last_month(suite_id) 50 | pass_count(suite_id,30) 51 | end 52 | 53 | def fail_count(suite_id, numberofdays) 54 | TestDefinition.find_by_sql("SELECT test_definitions.id,test_definitions.name,results.status,runs.id,runs.finished_at from results, test_definitions, runs where results.test_definition_id = test_definitions.id and results.run_id = runs.id and test_definitions.suite_id = " + suite_id.to_s + " and results.status = 'fail' AND runs.finished_at >= NOW() - INTERVAL "+numberofdays.to_s+" DAY").count 55 | end 56 | 57 | def pass_count(suite_id, numberofdays) 58 | TestDefinition.find_by_sql("SELECT test_definitions.id,test_definitions.name,results.status,runs.id,runs.finished_at from results, test_definitions, runs where results.test_definition_id = test_definitions.id and results.run_id = runs.id and test_definitions.suite_id = " + suite_id.to_s + " and results.status = 'pass' AND runs.finished_at >= NOW() - INTERVAL " + numberofdays.to_s + " DAY").count 59 | end 60 | 61 | end 62 | -------------------------------------------------------------------------------- /app/models/result.rb: -------------------------------------------------------------------------------- 1 | class Result < ActiveRecord::Base 2 | belongs_to :test_definition 3 | belongs_to :run 4 | belongs_to :parent, :foreign_key => "parent_id", :class_name => 'Result' 5 | has_many :children, :foreign_key => "parent_id", :class_name => 'Result', :dependent => :destroy 6 | alias_attribute :test, :test_definition 7 | acts_as_taggable 8 | 9 | after_initialize :init 10 | 11 | def init 12 | @count = {} 13 | end 14 | 15 | STATUS_SCORES = 16 | { "pass" => 5, 17 | "fail" => 4, 18 | "error" => 3, 19 | "timeout" => 2, 20 | "notrun" => 1 } 21 | 22 | #default_scope { includes(:children, :test_definition) } 23 | 24 | before_save do |result| 25 | result.status = Result.normalize_result(result.status) 26 | end 27 | 28 | def self.normalize_result(status) 29 | { "passed" => "pass", 30 | "failed" => "fail", 31 | "errored" => "error", 32 | "undefined" => "notrun", 33 | "skipped" => "notrun" }[status] || status 34 | end 35 | 36 | # Count the status results of children 37 | # result.count(:pass) 38 | def count (status) 39 | # Note the use of collect and count here, rather than just a simple 40 | # count. This is because children is some kind of ActiveRecord array 41 | # and count doesn't work quite as expected on it 42 | if !@count[status] 43 | @count[status] = self.children.collect { |c| c.calculated_status == status.to_s }.count(true) 44 | end 45 | @count[status] 46 | end 47 | 48 | # returns an integer that represents the test result status 49 | # Useful for sorting results based on status 50 | def status_score 51 | STATUS_SCORES[calculated_status] || 0 52 | end 53 | 54 | def calculated_status 55 | if !@calculated_status 56 | @calculated_status = 57 | if status 58 | status 59 | else 60 | Result.summary_status(children.collect { |c| c.calculated_status }) 61 | end 62 | end 63 | @calculated_status 64 | end 65 | 66 | # Given a collection of result objects, return a summary of the 67 | # the result 68 | # i.e. pass, pass, fail => fail 69 | # pass, error, notrun => notrun 70 | def self.summary_status(statuses) 71 | 72 | resulting_status = "error" 73 | resulting_status = "pass" if statuses.count("pass") > 0 74 | resulting_status = "notrun" if statuses.count("notrun") > 0 75 | resulting_status = "fail" if statuses.count("fail") > 0 76 | 77 | resulting_status 78 | end 79 | 80 | def world 81 | run.world 82 | end 83 | end 84 | -------------------------------------------------------------------------------- /app/views/layouts/application.html.erb: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 |
60 |
61 | <%= yield %>
62 |
63 |
64 |
65 |
66 |
--------------------------------------------------------------------------------
/spec/models/result_history_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe ResultHistory do
4 | describe "Complex result sets" do
5 |
6 | before(:all) do
7 | @world = World::SingleComponent.find_or_create(
8 | :component => "TestMite",
9 | :project => "Titan",
10 | :version => "1.2.3" )
11 |
12 | @historic_runs = [
13 | Run.create( world: @world, target: 'x86_64' ),
14 | Run.create( world: @world, target: 'x86_64' ),
15 | Run.create( world: @world, target: 'x86_64' )
16 | ]
17 |
18 | @historic_parent = TestDefinition.find_or_create( name: 'Top' )
19 | @historic_test_definitions = [
20 | TestDefinition.find_or_create( name: 'Child1', parent_id: @historic_parent.id ),
21 | TestDefinition.find_or_create( name: 'Child2', parent_id: @historic_parent.id ),
22 | TestDefinition.find_or_create( name: 'Child3', parent_id: @historic_parent.id )
23 | ]
24 |
25 | @historic_runs.each do |r|
26 |
27 | parent = Result.create( test_definition_id: @historic_parent.id, status: "pass", run_id: r.id )
28 | @historic_test_definitions.each do |t|
29 | Result.create( test_definition_id: t.id, status: "pass", run_id: r.id, parent_id: parent.id )
30 | end
31 | end
32 |
33 | @result_history = ResultHistory.find( :test_definition_id => @historic_parent.id, :target => 'x86_64' )
34 |
35 | end
36 |
37 | it "has a test_defintion" do
38 | expect(@result_history.test_definition).to eq @historic_parent
39 | end
40 |
41 | it "has a primary result" do
42 | expect( @result_history.primary_result ).to be_a Result
43 | end
44 |
45 | it "has a primary result that is the latest result" do
46 | expect( @result_history.primary_result ).to eq Result.where(:parent_id => nil).last
47 | end
48 |
49 | it "has reference results" do
50 | expect( @result_history.reference_results.count ).to be >= 2
51 | expect( @result_history.reference_results.first ).to be_a Result
52 | end
53 |
54 | it "has child test definitions that correspond to the primary result" do
55 | expect( @result_history.child_test_definitions ).to be_a Array
56 | expect( @result_history.child_test_definitions.first ).to be_a TestDefinition
57 | end
58 |
59 | it "has a child result for the first test defintion" do
60 | test_definition = @result_history.child_test_definitions[0]
61 | expect( @result_history.primary_child(test_definition)).to eq @result_history.primary_children[0]
62 | end
63 |
64 | end
65 |
66 |
67 |
68 | end
69 |
--------------------------------------------------------------------------------
/app/models/aggregate_result_comparison.rb:
--------------------------------------------------------------------------------
1 | class AggregateResultComparison
2 | attr_accessor :primary, :reference, :test_definition, :target, :tags
3 |
4 | def initialize( primary_world, reference_world, test_def, target, primary_aggregate_result, reference_aggregate_result, tags )
5 | @primary = primary_aggregate_result
6 | @reference = reference_aggregate_result
7 | @test_definition = test_def
8 | @target = target
9 | @primary_world = primary_world
10 | @reference_world = reference_world
11 | @tags = tags
12 |
13 | if !@primary
14 | @primary = AggregateResult.new( @test_definition, primary_world, [], target, tags )
15 | end
16 |
17 | if !@reference
18 | @reference = AggregateResult.new( @test_definition, reference_world, [], target, tags )
19 | end
20 | end
21 |
22 | # Return the comparison status for the primary world
23 | def status
24 | if !@status
25 | status = @primary.status
26 | if @primary.status == "pass" and @reference.status != "pass"
27 | status = "newpass"
28 | elsif @reference.status == "pass" and @primary.status == "fail"
29 | status = "regres"
30 | end
31 |
32 | if status.match("pass") && @primary.children.count < @reference.children.count
33 | status = "notrun"
34 | end
35 |
36 | if status == "pass" && @primary.children.count > @reference.children.count
37 | status = "newpass"
38 | end
39 |
40 | @status = status
41 | end
42 | @status
43 | end
44 |
45 | # Do primary and reference results differ
46 | def diff
47 | @primary.status != @reference.status || @primary.children.count != @reference.children.count
48 | end
49 |
50 |
51 | def children
52 | if !@children
53 |
54 | primary_child_results_by_test = primary.children.group_by { |r| r.test_definition }
55 | reference_child_results_by_test = reference.children.group_by { |r| r.test_definition }
56 |
57 | tests = primary_child_results_by_test.keys.concat( reference_child_results_by_test.keys ).uniq
58 |
59 | if !primary_child_results_by_test && ! reference_child_results_by_test
60 | @children = []
61 | else
62 | @children = tests.collect do |test|
63 | primary_aggregate = primary_child_results_by_test[test].pop if primary_child_results_by_test[test]
64 | reference_aggregate = reference_child_results_by_test[test].pop if reference_child_results_by_test[test]
65 |
66 | AggregateResultComparison.new( primary, reference, test, target, primary_aggregate, reference_aggregate, tags )
67 | end
68 | end
69 |
70 | end
71 | @children
72 | end
73 |
74 |
75 | end
--------------------------------------------------------------------------------
/spec/models/test_definition_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe TestDefinition do
4 | describe "find_or_create" do
5 |
6 | it "creates a test definition" do
7 |
8 | test_definition = TestDefinition.find_or_create(
9 | name: 'Scanning item',
10 | node_type: 'Cucumber::Feature',
11 | description: 'Scanning an item',
12 | file: 'items.feature',
13 | line: 1
14 | )
15 |
16 | test_definition.name.should be_a String
17 | test_definition.node_type.should be_a String
18 | test_definition.description.should be_a String
19 | test_definition.file.should be_a String
20 | test_definition.line.should be_a Fixnum
21 | end
22 |
23 | it "creates 2 definitions for a suite" do
24 |
25 | suite = Suite.find_or_create(
26 | project: 'Titan',
27 | name: 'Cucumber features',
28 | runner: 'Ruby Cucumber',
29 | description: 'Feature files for the Titan project',
30 | documentation: "Long description of what's going on",
31 | url: 'https://www.github.com/bbc-test',
32 | repo: 'https://www.github.com/bbc-test/titan'
33 | )
34 |
35 | suite.add_test_definition(
36 | name: 'Scanning item',
37 | node_type: 'Cucumber::Feature',
38 | description: 'Scanning an item',
39 | file: 'items.feature',
40 | line: 1
41 | )
42 |
43 | suite.add_test_definition(
44 | name: 'Showing total',
45 | node_type: 'Cucumber::Feature',
46 | description: 'Showing cart total',
47 | file: 'items.feature',
48 | line: 7
49 | )
50 |
51 | suite.tests.count.should == 2
52 |
53 | end
54 |
55 | it "creates definition and sub-definition for a suite" do
56 |
57 | suite = Suite.find_or_create(
58 | project: 'Titan',
59 | name: 'Cucumber features',
60 | runner: 'Ruby Cucumber',
61 | )
62 |
63 | test = suite.add_test_definition(
64 | name: 'Scanning things',
65 | node_type: 'Cucumber::Scenario',
66 | )
67 |
68 | test.suite.name.should == "Cucumber features"
69 |
70 | subtest = test.add_test_definition(
71 | name: 'Given something',
72 | node_type: 'Cucumber::Step',
73 | )
74 |
75 | subtest = test.add_test_definition(
76 | name: 'Then something',
77 | node_type: 'Cucumber::Step',
78 | )
79 |
80 | subtest.parent.name.should == "Scanning things"
81 |
82 | suite.tests.count.should == 1
83 | suite.tests.first.children.count.should == 2
84 | end
85 |
86 |
87 |
88 | end
89 |
90 | end
91 |
--------------------------------------------------------------------------------
/app/models/aggregate_result_group.rb:
--------------------------------------------------------------------------------
1 | # world_id, parent_result_id, test_definition_id, target
2 | # best_result_id, status, pass_count, fail_count, error_count, notrun_count
3 |
4 | class AggregateResultGroup
5 | attr_accessor :results, :target, :world
6 |
7 | #
8 | # Create an AggregateResultGroup
9 | # Requires: world_id
10 | # target
11 | # Construncts a result-like object that contains a whole bunch of results
12 | #
13 | def self.populate( args )
14 | world_id = args[:world_id] or raise "Need to provide a world_id"
15 |
16 | world = World.find(world_id)
17 | target = args[:target] or raise "Need to provide a target"
18 |
19 | tags = args[:tags]
20 |
21 | results_by_test_id = Result.unscoped.includes(:test_definition => :tags,
22 | :children => [
23 | :children => [:test_definition => :tags],
24 | :test_definition => :tags ]).joins(:run)
25 | .where(:parent_id => nil,
26 | :runs => {:target => target, :world_id => world_id})
27 | .last(500)
28 | .group_by { |r| r.test_definition_id }
29 |
30 | aggregates = results_by_test_id.values.collect do |results|
31 | AggregateResult.new( results[0].test_definition, world, results, target, tags )
32 | end
33 |
34 | if tags && !tags.empty?
35 | aggregates = aggregates.select { |ar| ar.tags.any? { |t| tags.include?(t) } }
36 | end
37 |
38 | AggregateResultGroup.new( :results => aggregates, :world => world, :target => target )
39 | end
40 |
41 | #
42 | # Construct the object
43 | #
44 | def initialize( args )
45 | @world = args[:world]
46 | @results = args[:results]
47 | @target = args[:target]
48 | @count = {}
49 | end
50 |
51 | # Get a list of tags that all the test_definitions in this aggregate are tagged with
52 | def tags
53 | if !@tags
54 | @tags = results.collect { |r| r.tags }.flatten.uniq
55 | end
56 | @tags
57 | end
58 |
59 | #
60 | # Return the overall status of the target
61 | #
62 | def status
63 | if !@status
64 | @status =
65 | if results.empty?
66 | 'notrun'
67 | else
68 | Result.summary_status(results.collect { |r| r.status } )
69 | end
70 | end
71 | @status
72 | end
73 |
74 | def confidence
75 | end
76 |
77 | #
78 | # Counts the statuses of all the child elements
79 | #
80 | def count (status)
81 | if !@count[status]
82 | @count[status] = self.results.collect { |c| c.status == status.to_s }.count(true)
83 | end
84 | @count[status]
85 | end
86 |
87 | end
88 |
--------------------------------------------------------------------------------
/spec/models/aggregate_result_comparison_group_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe AggregateResultComparisonGroup do
4 | describe "adding a result" do
5 |
6 | before(:each) do
7 |
8 | @test = TestDefinition.find_or_create(
9 | name: 'Scanning item',
10 | node_type: 'Cucumber::Feature'
11 | )
12 |
13 | @world1 = World::SingleComponent.find_or_create(
14 | :component => "TestMite",
15 | :project => "Titan",
16 | :version => "1.2.3" )
17 |
18 | @world2 = World::SingleComponent.find_or_create(
19 | :component => "TestMite",
20 | :project => "Titan",
21 | :version => "1.2.4" )
22 |
23 | @run1 = Run.create( world: @world1, target: 'ubuntu' )
24 | @run2 = Run.create( world: @world1, target: 'osx' )
25 | @run3 = Run.create( world: @world2, target: 'ubuntu' )
26 | @run4 = Run.create( world: @world2, target: 'osx' )
27 | @run5 = Run.create( world: @world2, target: 'osx' )
28 |
29 | @result1 = Result.create(
30 | :test_definition_id => @test.id,
31 | :status => "pass",
32 | :run_id => @run1.id
33 | )
34 |
35 | @result2 = Result.create(
36 | :test_definition_id => @test.id,
37 | :status => "fail",
38 | :run_id => @run2.id
39 | )
40 | @result3 = Result.create(
41 | :test_definition_id => @test.id,
42 | :status => "fail",
43 | :run_id => @run3.id
44 | )
45 | @result4 = Result.create(
46 | :test_definition_id => @test.id,
47 | :status => "fail",
48 | :run_id => @run4.id
49 | )
50 | @result5 = Result.create(
51 | :test_definition_id => @test.id,
52 | :status => "pass",
53 | :run_id => @run5.id
54 | )
55 | end
56 |
57 | it "produces 1 comparison set from results from 2 worlds" do
58 | comparison = AggregateResultComparisonGroup.populate( :reference_world_id => @world1.id, :primary_world_id => @world2.id, :target => 'osx' )
59 | expect( comparison.results.count ).to eq 1
60 | expect( comparison.results.first ).to be_a AggregateResultComparison
61 | expect( comparison.status ).to eq "newpass"
62 | end
63 |
64 | it "contains aggregates from two different worlds" do
65 | comparison = AggregateResultComparisonGroup.populate( :reference_world_id => @world1.id, :primary_world_id => @world2.id, :target => 'osx' )
66 |
67 | expect(comparison.results.first.status).to eq "newpass"
68 | expect(comparison.results.first.reference.world.id).not_to eq comparison.results.first.primary.world.id
69 |
70 | expect(comparison.results.first.reference.status).not_to eq comparison.results.first.primary.status
71 | end
72 |
73 | end
74 |
75 | end
76 |
--------------------------------------------------------------------------------
/config/routes.rb:
--------------------------------------------------------------------------------
1 | Testmine::Application.routes.draw do
2 |
3 | root 'suites#index'
4 | get "suites" => 'suites#index'
5 | get "suites/:id" => 'suites#show'
6 |
7 | get "runs/show"
8 | get "worlds/show"
9 | get "worlds/index"
10 | get "worlds/search" => 'worlds#search'
11 | # The priority is based upon order of creation: first created -> highest priority.
12 | # See how all your routes lay out with "rake routes".
13 |
14 | get 'worlds' => 'worlds#index'
15 | get 'worlds/:id' => 'worlds#show'
16 | get 'worlds/:primary/:reference' => 'worlds#compare'
17 |
18 | get 'flaky-test-report/:world_id' => 'flaky_test#show'
19 |
20 | get 'aggregate/:world_id' => 'worlds#aggregate_group_element'
21 | get 'comparison/:primary/:reference' => 'worlds#comparison_group_element'
22 |
23 | get 'runs/:id' => 'runs#show'
24 | get 'reliability/:suite' => 'reliability#show'
25 |
26 | get 'oldtests/:id' => 'tests#show'
27 | get 'tests/:id' => 'tests#history'
28 |
29 |
30 | get '/status' => 'api/v1/status#show'
31 |
32 | namespace :api, defaults: { format: :json } do
33 | namespace :v1 do
34 | post 'submit' => 'results#ingest_ir'
35 | end
36 | end
37 |
38 | # You can have the root of your site routed with "root"
39 | # root 'welcome#index'
40 |
41 | # Example of regular route:
42 | # get 'products/:id' => 'catalog#view'
43 |
44 | # Example of named route that can be invoked with purchase_url(id: product.id)
45 | # get 'products/:id/purchase' => 'catalog#purchase', as: :purchase
46 |
47 | # Example resource route (maps HTTP verbs to controller actions automatically):
48 | # resources :products
49 |
50 | # Example resource route with options:
51 | # resources :products do
52 | # member do
53 | # get 'short'
54 | # post 'toggle'
55 | # end
56 | #
57 | # collection do
58 | # get 'sold'
59 | # end
60 | # end
61 |
62 | # Example resource route with sub-resources:
63 | # resources :products do
64 | # resources :comments, :sales
65 | # resource :seller
66 | # end
67 |
68 | # Example resource route with more complex sub-resources:
69 | # resources :products do
70 | # resources :comments
71 | # resources :sales do
72 | # get 'recent', on: :collection
73 | # end
74 | # end
75 |
76 | # Example resource route with concerns:
77 | # concern :toggleable do
78 | # post 'toggle'
79 | # end
80 | # resources :posts, concerns: :toggleable
81 | # resources :photos, concerns: :toggleable
82 |
83 | # Example resource route within a namespace:
84 | # namespace :admin do
85 | # # Directs /admin/products/* to Admin::ProductsController
86 | # # (app/controllers/admin/products_controller.rb)
87 | # resources :products
88 | # end
89 | end
90 |
--------------------------------------------------------------------------------
/app/assets/stylesheets/result_badges.scss:
--------------------------------------------------------------------------------
1 |
2 | // Derived from Bootstrap 2 badges
3 |
4 | // Bootstrap 2 is licensed under apache 2. Take a look at
5 | // the licence information in this directory.
6 |
7 |
8 | .version-label {
9 | color: #000000;
10 | }
11 |
12 | .badge-result {
13 | display: inline-block;
14 | padding: 2px 4px;
15 | font-size: 11.844px;
16 | font-weight: bold;
17 | line-height: 14px;
18 | color: #ffffff;
19 | text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
20 | white-space: nowrap;
21 | vertical-align: baseline;
22 | background-color: #999999;
23 | width: 30px;
24 | display: inline-block;
25 | text-align: center;
26 | padding-right: 9px;
27 | padding-left: 9px;
28 | -webkit-border-radius: 9px;
29 | -moz-border-radius: 9px;
30 | border-radius: 9px;
31 | }
32 |
33 | .badge-count-0 {
34 | opacity: 0.2;
35 | }
36 |
37 | .panel-heading .badge.badge-fail,
38 | .badge-fail {
39 | background-color: #b94a48;
40 | }
41 |
42 | .badge-fail[href] {
43 | background-color: #953b39;
44 | }
45 |
46 | .panel-heading .badge.badge-notrun,
47 | .badge-notrun {
48 | background-color: #f89406;
49 | }
50 |
51 | .badge-notrun[href] {
52 | background-color: #c67605;
53 | }
54 |
55 | .panel-heading .badge.badge-pass,
56 | .badge-pass {
57 | background-color: #468847;
58 | }
59 |
60 | .badge-pass[href] {
61 | background-color: #356635;
62 | }
63 |
64 | .badge-info {
65 | background-color: #3a87ad;
66 | }
67 |
68 | .badge-info[href] {
69 | background-color: #2d6987;
70 | }
71 |
72 | .panel-heading .badge.badge-error,
73 | .badge-error {
74 | background-color: #333333;
75 | }
76 |
77 | .badge-parent {
78 | }
79 |
80 |
81 | .result {
82 | width: 60px;
83 | display: inline-block;
84 | text-align: center;
85 | font-size: 10.998px;
86 | font-weight: bold;
87 | line-height: 14px;
88 | font-family: monospace;
89 | color: #ffffff;
90 | text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
91 | white-space: nowrap;
92 | vertical-align: baseline;
93 | background-color: #999999;
94 | padding: 1px 4px 2px;
95 | -webkit-border-radius: 3px;
96 | -moz-border-radius: 3px;
97 | border-radius: 3px;
98 | }
99 |
100 | .result-fail, .result-regression, .result-regres {
101 | background-color: #b94a48;
102 | }
103 |
104 | .result-notrun {
105 | background-color: #f89406;
106 | }
107 |
108 | .result-pass, .result-newpass {
109 | background-color: #468847;
110 | }
111 |
112 | .result-error {
113 | background-color: #333333;
114 | }
115 |
116 | .result-nodiff {
117 | opacity: 0.2;
118 | }
119 |
120 | .table th.world-right-aligned {
121 | text-align: right;
122 | }
123 |
124 | .table-element-center {
125 | text-align: center;
126 | }
127 |
128 | .table-element-left {
129 | text-align: left;
130 | }
131 |
132 | .table-element-right {
133 | text-align: right;
134 | }
135 |
--------------------------------------------------------------------------------
/app/views/tests/show.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
3 |
88 |
89 |
--------------------------------------------------------------------------------
/spec/models/aggregate_result_group_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | describe AggregateResultGroup do
4 | describe "adding a result" do
5 |
6 | before(:each) do
7 |
8 | @test = TestDefinition.find_or_create(
9 | name: 'Scanning item',
10 | node_type: 'Cucumber::Feature'
11 | )
12 |
13 | @test2 = TestDefinition.find_or_create(
14 | name: 'Some other thing',
15 | node_type: 'Cucumber::Feature'
16 | )
17 |
18 | @world = World::SingleComponent.find_or_create(
19 | :component => "TestMite",
20 | :project => "Titan",
21 | :version => "1.2.3" )
22 |
23 | @run1 = Run.create( world: @world, target: 'osx' )
24 | @run2 = Run.create( world: @world, target: 'osx' )
25 | @run3 = Run.create( world: @world, target: 'ubuntu' )
26 |
27 | @result1 = Result.create(
28 | :test_definition_id => @test.id,
29 | :status => "fail",
30 | :run_id => @run1.id
31 | )
32 | @result2 = Result.create(
33 | :test_definition_id => @test.id,
34 | :status => "pass",
35 | :run_id => @run2.id
36 | )
37 | @result3 = Result.create(
38 | :test_definition_id => @test.id,
39 | :status => "pass",
40 | :run_id => @run3.id
41 | )
42 | @result4 = Result.create(
43 | :test_definition_id => @test2.id,
44 | :status => "fail",
45 | :run_id => @run3.id
46 | )
47 |
48 |
49 | end
50 |
51 | it "aggregates results for a world and target" do
52 | aggregate_group_1 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'osx' )
53 | expect(aggregate_group_1.results.count).to eq 1
54 |
55 | aggregate_group_2 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'ubuntu' )
56 | expect(aggregate_group_2.results.count).to eq 2
57 | end
58 |
59 | it "produces summary counts of child results" do
60 | aggregate_results_1 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'osx' )
61 | aggregate_results_2 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'ubuntu' )
62 |
63 | expect(aggregate_results_1.count('pass')).to eq 1
64 | expect(aggregate_results_1.count('fail')).to eq 0
65 | expect(aggregate_results_1.count('error')).to eq 0
66 |
67 | expect(aggregate_results_2.count('pass')).to eq 1
68 | expect(aggregate_results_2.count('fail')).to eq 1
69 | expect(aggregate_results_2.count('error')).to eq 0
70 |
71 | end
72 |
73 | it "produces a summery status for child results" do
74 | aggregate_results_1 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'osx' )
75 | aggregate_results_2 = AggregateResultGroup.populate( :world_id => @world.id, :target => 'ubuntu' )
76 |
77 | expect(aggregate_results_1.status).to eq 'pass'
78 | expect(aggregate_results_2.status).to eq 'fail'
79 |
80 | end
81 |
82 |
83 | end
84 |
85 | end
86 |
--------------------------------------------------------------------------------
/app/controllers/worlds_controller.rb:
--------------------------------------------------------------------------------
1 | class WorldsController < ApplicationController
2 | def index
3 | @worlds = World.last(100).reverse
4 | end
5 |
6 |
7 | # worlds/search?hive_job_id=3000
8 | def search
9 |
10 | @search_params = {}
11 |
12 | if params[:hive_job_id]
13 | @search_params[:hive_job_id] = params[:hive_job_id]
14 | runs = Run.where( @search_params )
15 |
16 | if runs && !runs.empty?
17 | world = runs.first.world
18 | redirect_to "/worlds/#{world.id}"
19 | end
20 |
21 | elsif params[:version]
22 |
23 | @search_params[:project] = params[:project] if params[:project]
24 | @search_params[:component] = params[:component] if params[:component]
25 | @search_params[:version] = params[:version]
26 |
27 | world = World.where( @search_params ).last
28 |
29 | if world
30 | redirect_to "/worlds/#{world.id}"
31 | end
32 |
33 |
34 | end
35 | end
36 |
37 | def show
38 | @world = World.includes(:runs).find(params[:id].to_i)
39 |
40 | @runs = @world.runs.reverse
41 |
42 | @tag = params[:tag] if (params[:tag] && params[:tag].length > 0)
43 |
44 | @targets = Run.where( :world_id => @world.id ).pluck('DISTINCT target')
45 |
46 | @comparison_worlds = World.similar(@world).includes(:runs)
47 | end
48 |
49 | def aggregate_group_element
50 |
51 | @target = params[:target]
52 | @world_id = params[:world_id].to_i
53 | @tag = params[:tag] if (params[:tag] && params[:tag].length > 0)
54 | tags = []
55 | tags.push @tag if @tag
56 |
57 | @results = AggregateResultGroup.populate( :world_id => @world_id,
58 | :target => @target,
59 | :tags => tags )
60 |
61 | @tags = @results.tags
62 |
63 | render layout: false
64 | end
65 |
66 |
67 | def compare
68 | reference_world_id = params[:reference].to_i
69 | primary_world_id = params[:primary].to_i
70 | @reference_world = World.find(reference_world_id)
71 | @primary_world = World.find(primary_world_id)
72 |
73 | @targets = Run.where( :world_id => [reference_world_id, primary_world_id] ).pluck('DISTINCT target')
74 | end
75 |
76 | def comparison_group_element
77 | @target = params[:target]
78 | @primary_world_id = params[:primary].to_i
79 | @reference_world_id = params[:reference].to_i
80 | @reference_world = World.find(params[:reference].to_i)
81 | @primary_world = World.find(params[:primary].to_i)
82 | @tag = params[:tag] if (params[:tag] && params[:tag].length > 0)
83 | tags = []
84 | tags.push @tag if @tag
85 |
86 | @results = AggregateResultComparisonGroup.populate( :primary_world_id => @primary_world_id,
87 | :reference_world_id => @reference_world_id,
88 | :target => @target,
89 | :tags => tags )
90 | render layout: false
91 | end
92 |
93 |
94 | end
95 |
--------------------------------------------------------------------------------
/app/helpers/application_helper.rb:
--------------------------------------------------------------------------------
1 | module ApplicationHelper
2 |
3 | def job_count_badge( status, count )
4 | badge = status_bootstrap_mappings(status)
5 | "#{count}".html_safe
6 | end
7 |
8 | def status_badge( status )
9 | "#{status.to_s}".html_safe
10 | end
11 |
12 | def filter_status_badge(status, type, batch_id=nil)
13 | link_path = ( type == :batches ) ? filter_batches_path(status) : batch_filter_path(batch_id, status)
14 | link_to "#{status.to_s}".html_safe, link_path
15 | end
16 |
17 | def status_bootstrap_mappings(status)
18 | {
19 | "pass" => 'success',
20 | "fail" => 'important',
21 | "error" => 'inverse',
22 | "notrun" => 'default'
23 | }[status]
24 | end
25 |
26 | # Outputs a time from, realtive to the current time
27 | def pretty_time(time)
28 | if time
29 | time.strftime("%Y-%m-%d %H:%M:%S")
30 | else
31 | "~"
32 | end
33 | end
34 |
35 | # Outputs different time formats relative to the current time
36 | def simple_time(time)
37 |
38 | if !time
39 | "~"
40 | else
41 |
42 | now = Time.now
43 |
44 | format = "%Y-%m-%d %H:%M:%S"
45 |
46 | if time.year == now.year
47 | if time.yday == now.yday
48 | format = "%H:%M:%S"
49 | else
50 | format = "%d-%m %H:%M:%S"
51 | end
52 | end
53 |
54 | time.strftime(format)
55 | end
56 | end
57 |
58 | def pretty_truncate(string, length, emphasis, additional = nil)
59 |
60 | visible_text = string
61 | popup_text = ''
62 |
63 | if string.length > length
64 | popup_text = string
65 | end
66 |
67 | if additional
68 | popup_text = %{#{popup_text} #{additional}}
69 | end
70 |
71 | if popup_text.length > 0
72 | html = %{<#{emphasis}>#{string.truncate(length)}}
73 | html += %{}
74 | else
75 | html = "<#{emphasis}>#{string}"
76 | end
77 |
78 | html.html_safe
79 | end
80 |
81 | def pretty_node( result )
82 | short_result = result.test_definition.node_type.split('::').last
83 | "<%= @test.node_type -%>
4 |<%= @test.name -%>
5 |<%= @test.description -%>
6 | 7 | 8 | 16 | 17 | 18 |
19 |
20 | <% counter = 0 %>
21 | <% @results_hash.each do |t, a| %>
22 |
23 | <% tab_class='active' if params[:target] == t %>
24 |
86 |
87 |
25 | <% counter += 1 %>
26 |
27 |
28 |
29 |
30 |
82 |
83 |
84 | <% end %>
85 | | 32 | <% (0..14).each do |i| %> 33 | <% r =a[i] %> 34 | <% if r %> 35 | | " class="label label-primary" data-toggle="tooltip" data-placement="top" title="<%= r.world.component -%>: <%= r.world.version -%>"><%= r.world.version -%> | 36 | 37 | <% else %> 38 |39 | <% end %> 40 | 41 | <% end %> 42 | |
|---|---|---|
| 48 | <% (0..14).each do |i| %> 49 | <% r = a[i] %> 50 | <% if r %> 51 | | <%= r.status.capitalize[0] -%> | 52 | <% else %> 53 |54 | <% end %> 55 | <% end %> 56 | |
| <%= link_to(t.name, "/tests/#{t.id}?target=#{a[0].run.target}") -%> | 66 | 67 | <% (0..14).each do |i| %> 68 | <% r = a[i] %> 69 | <% if r %> 70 | <% status = ( r.children[j] ? r.children[j].status : 'notrun' ) %> 71 |<%= status.capitalize[0] -%> | 72 | <% else %> 73 |74 | <% end %> 75 | <% end %> 76 | |
#{short_result}".html_safe
84 | end
85 |
86 | def hive_url(args = {})
87 | if ENV['HIVE_URL']
88 | base = ENV['HIVE_URL']
89 | if args[:job]
90 | "#{base}/jobs/#{args[:job].to_s}"
91 | else
92 | base
93 | end
94 | else
95 | nil
96 | end
97 | end
98 |
99 | def hive_job_link( run )
100 | if hive_url && run.hive_job_id
101 | "
".html_safe
102 | else
103 | ""
104 | end
105 | end
106 |
107 | end
108 |
--------------------------------------------------------------------------------
/app/models/result_history.rb:
--------------------------------------------------------------------------------
1 | class ResultHistory
2 |
3 | attr_accessor :test_definition
4 | attr_accessor :primary_result
5 | attr_accessor :reference_results #array of reference
6 |
7 | def self.find(args)
8 |
9 | # First identify the test_definition
10 | test_definition_id = args[:test_definition_id] or raise "Need to provide a test definition id"
11 | target = args[:target] or raise "Need to provide a target"
12 |
13 | test_definition = TestDefinition.find( test_definition_id )
14 |
15 | results = Result.joins(:run).where( :test_definition_id => test_definition_id, :runs => { :target => target } ).reverse
16 | ResultHistory.new( test_definition, results.shift, results )
17 | end
18 |
19 | def self.find_for_all_targets(args)
20 |
21 | # First identify the test_definition
22 | test_definition_id = args[:test_definition_id] or raise "Need to provide a test definition id"
23 | target = args[:target]
24 |
25 | # Next derive recent targets...
26 | targets = Run.joins(:results => :test_definition).where( :results => {:test_definition_id => test_definition_id} ).order('runs.id DESC').pluck('DISTINCT runs.target' )
27 | targets.push(target).uniq! if target
28 |
29 | # Finally find the results
30 | targets.reduce({}) { |h, t| h[t] = ResultHistory.find( args.merge({:target=>t}) ); h }
31 | end
32 |
33 | def self.find_for_recent_targets(args)
34 |
35 | # First identify the test_definition
36 | test_definition_id = args[:test_definition_id] or raise "Need to provide a test definition id"
37 | target = args[:target]
38 |
39 | # Next derive recent targets...
40 | targets = Run.joins(:results => :test_definition).where( :results => {:test_definition_id => test_definition_id} ).limit(200).order('runs.id DESC').pluck('DISTINCT runs.target' )
41 | targets.push(target).uniq! if target
42 |
43 | # Finally find the results
44 | targets.reduce({}) { |h, t| h[t] = ResultHistory.find( args.merge({:target=>t}) ); h }
45 | end
46 |
47 | def self.group_by_commit (histories)
48 | grouped_results = Hash.new
49 |
50 | histories.each do |target, results|
51 | results.reference_results.each do |r|
52 |
53 | commit = r.world.version
54 | status = r.calculated_status
55 | date = r.updated_at
56 |
57 | if !grouped_results.has_key? commit
58 | grouped_results[commit] = Hash.new
59 | end
60 |
61 | grouped_results[commit][:date] = date
62 |
63 | if !grouped_results[commit].has_key? status
64 | grouped_results[commit][status] = 1
65 | else
66 | grouped_results[commit][status] = grouped_results[commit][status] + 1
67 | end
68 | end
69 | end
70 |
71 | return grouped_results
72 | end
73 |
74 | def initialize(test_definition, primary, reference)
75 | @test_definition = test_definition
76 | @primary_result = primary
77 | @reference_results = reference
78 | end
79 |
80 | def primary_children
81 | @primary_result.children
82 | end
83 |
84 | def child_test_definitions
85 | self.primary_children.collect { |c| c.test_definition }
86 | end
87 |
88 | def primary_child(test_definition)
89 | self.primary_children.detect { |c| c.test_definition.id == test_definition.id }
90 | end
91 |
92 | def reference_child(test_definition, i)
93 | if reference_results[i]
94 | reference_results[i].children.detect { |r| r.test_definition.id == test_definition.id }
95 | end
96 | end
97 |
98 | end
--------------------------------------------------------------------------------
/config/environments/production.rb:
--------------------------------------------------------------------------------
1 | Testmine::Application.configure do
2 | # Settings specified here will take precedence over those in config/application.rb.
3 |
4 | # Code is not reloaded between requests.
5 | config.cache_classes = true
6 |
7 | # Eager load code on boot. This eager loads most of Rails and
8 | # your application in memory, allowing both thread web servers
9 | # and those relying on copy on write to perform better.
10 | # Rake tasks automatically ignore this option for performance.
11 | config.eager_load = true
12 |
13 | # Full error reports are disabled and caching is turned on.
14 | config.consider_all_requests_local = false
15 | config.action_controller.perform_caching = true
16 |
17 | # Enable Rack::Cache to put a simple HTTP cache in front of your application
18 | # Add `rack-cache` to your Gemfile before enabling this.
19 | # For large-scale production use, consider using a caching reverse proxy like nginx, varnish or squid.
20 | # config.action_dispatch.rack_cache = true
21 |
22 | # Disable Rails's static asset server (Apache or nginx will already do this).
23 | config.serve_static_assets = true
24 |
25 | # Compress JavaScripts and CSS.
26 | config.assets.js_compressor = :uglifier
27 | # config.assets.css_compressor = :sass
28 |
29 | # Do not fallback to assets pipeline if a precompiled asset is missed.
30 | config.assets.compile = true
31 |
32 | # Generate digests for assets URLs.
33 | config.assets.digest = true
34 |
35 | # Version of your assets, change this if you want to expire all your assets.
36 | config.assets.version = '1.0'
37 |
38 | # Specifies the header that your server uses for sending files.
39 | # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
40 | # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
41 |
42 | # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
43 | config.force_ssl = true
44 |
45 | # Set to :debug to see everything in the log.
46 | config.log_level = :info
47 |
48 | # Prepend all log lines with the following tags.
49 | # config.log_tags = [ :subdomain, :uuid ]
50 |
51 | # Use a different logger for distributed setups.
52 | # config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)
53 |
54 | # Use a different cache store in production.
55 | # config.cache_store = :mem_cache_store
56 |
57 | # Enable serving of images, stylesheets, and JavaScripts from an asset server.
58 | # config.action_controller.asset_host = "http://assets.example.com"
59 |
60 | # Precompile additional assets.
61 | # application.js, application.css, and all non-JS/CSS in app/assets folder are already added.
62 | # config.assets.precompile += %w( search.js )
63 |
64 | # Ignore bad email addresses and do not raise email delivery errors.
65 | # Set this to true and configure the email server for immediate delivery to raise delivery errors.
66 | # config.action_mailer.raise_delivery_errors = false
67 |
68 | # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
69 | # the I18n.default_locale when a translation can not be found).
70 | config.i18n.fallbacks = true
71 |
72 | # Send deprecation notices to registered listeners.
73 | config.active_support.deprecation = :notify
74 |
75 | # Disable automatic flushing of the log to improve performance.
76 | # config.autoflush_log = false
77 |
78 | # Use default logging formatter so that PID and timestamp are not suppressed.
79 | config.log_formatter = ::Logger::Formatter.new
80 |
81 | config.assets.paths << "#{Rails.root}/app/assets/fonts"
82 | config.assets.precompile += %w(.svg .eot .woff .ttf)
83 |
84 | end
85 |
--------------------------------------------------------------------------------
/app/views/tests/history.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
3 |
100 |
--------------------------------------------------------------------------------
/app/extras/ir_ingestor.rb:
--------------------------------------------------------------------------------
1 | require 'json'
2 | class IrIngestor
3 |
4 |
5 | def self.parse_ir( json )
6 |
7 | ir = JSON.parse(json)
8 |
9 | type = ir["type"] || "ruby cucumber"
10 | started = ir["started"]
11 | finished = ir["finished"]
12 | target = ir["target"]
13 | project = ir["project"] || ir["world"]["project"]
14 | component= ir["component"] || ir["world"]["component"]
15 | version = ir["version"] || ir["world"]["version"]
16 | results = ir["results"] || ir["tests"]
17 | suite = ir["suite"]
18 | hive_job_id = ir["hive_job_id"] || ir["hive_job"]
19 |
20 | #
21 | # 1) Process the world under test
22 | #
23 |
24 | world = process_world( project, component, version) or raise "Couldn't derive a world"
25 |
26 |
27 | #
28 | # 2) Process the run information
29 | # (Need the world to create a run)
30 | #
31 |
32 | run = Run.create( :started_at => started,
33 | :finished_at => finished,
34 | :target => target,
35 | :hive_job_id => hive_job_id,
36 | :world_id => world.id ) or raise "Couldn't create a new run"
37 | #
38 | # 3) Process the suite
39 | #
40 | suite = Suite.find_or_create(
41 | project: project,
42 | name: suite,
43 | runner: type,
44 | )
45 |
46 | #
47 | # 4) Process the test results
48 | # (Need the run to associate with results)
49 | #
50 |
51 | results = process_results( run, suite, results, suite ) or raise "Couldn't process results"
52 |
53 | run.status = Result.summary_status( results.collect { |r| r.status } )
54 | run.save
55 | run
56 | end
57 |
58 |
59 | def self.process_world( project, component, version )
60 | World::SingleComponent.find_or_create(
61 | :component => component,
62 | :project => project,
63 | :version => version )
64 | end
65 |
66 | # Recursively process results structure
67 | def self.process_results(run, suite, results_array, parent_definiton, parent_result = nil)
68 |
69 | results = []
70 | if results_array.respond_to?(:each)
71 | results_array.each do |r|
72 | file = r["file"]
73 | line = r["line"]
74 | type = r["type"]
75 | name = r["name"]
76 | description = r["description"]
77 | children = r["children"]
78 | status = r["status"]
79 | started = r["started"]
80 | finished = r["finished"]
81 | tags = r["tags"]
82 |
83 |
84 | test_definition = parent_definiton.add_test_definition(
85 | name: name,
86 | node_type: type,
87 | file: file,
88 | line: line,
89 | description: description,
90 | tag_list: tags
91 | )
92 |
93 | # Replace tags with the latest
94 | test_definition.tag_list = tags
95 | test_definition.save
96 |
97 | parent_id = parent_result.id if parent_result
98 | result = Result.create(
99 | :test_definition_id => test_definition.id,
100 | :status => status,
101 | :parent_id => parent_id,
102 | :run_id => run.id,
103 | :started_at => started,
104 | :finished_at => finished,
105 | :tag_list => tags
106 | )
107 |
108 | if children
109 | child_results = process_results(run, suite, children, test_definition, result)
110 |
111 | if !status
112 | result.status = Result.summary_status( child_results.collect {|c| c.status} )
113 | # Note: don't save the result
114 | end
115 | end
116 | results.push result
117 | end
118 | else
119 | puts results_array.inspect
120 | end
121 |
122 | results
123 | end
124 |
125 | end
126 |
--------------------------------------------------------------------------------
/app/models/aggregate_result_comparison_group.rb:
--------------------------------------------------------------------------------
1 | class AggregateResultComparisonGroup
2 | attr_accessor :primary_world, :reference_world, :results, :target, :tags
3 |
4 |
5 |
6 | def self.populate( args )
7 |
8 | primary_world_id = args[:primary_world_id] or raise "Need to provide a primary world id"
9 | reference_world_id = args[:reference_world_id] or raise "Need to provide a reference world id"
10 | primary_world = World.find(primary_world_id)
11 | reference_world = World.find(reference_world_id)
12 | target = args[:target]
13 |
14 | tags = args[:tags]
15 |
16 | primary_results_by_test = Result.unscoped
17 | .includes(:test_definition => :tags,
18 | :children => [
19 | :children => [:test_definition => :tags],
20 | :test_definition => :tags ])
21 | .joins(:run)
22 | .where(:parent_id => nil, :runs => {:target => target, :world_id => primary_world_id})
23 | .last(500)
24 | .group_by { |r| r.test_definition }
25 |
26 | reference_results_by_test = Result.unscoped
27 | .includes(:test_definition => :tags,
28 | :children => [
29 | :children => [:test_definition => :tags],
30 | :test_definition => :tags ])
31 | .joins(:run)
32 | .where(:parent_id => nil, :runs => {:target => target, :world_id => reference_world_id})
33 | .last(500)
34 | .group_by { |r| r.test_definition }
35 |
36 | tests = primary_results_by_test.keys.concat(reference_results_by_test.keys).uniq
37 |
38 | aggregates = []
39 | tests.each do |test|
40 | primary_results = primary_results_by_test[test] || []
41 | reference_results = reference_results_by_test[test] || []
42 |
43 | primary_aggregate = AggregateResult.new( test, primary_world, primary_results, target, tags )
44 | reference_aggregate = AggregateResult.new( test, reference_world, reference_results, target, tags )
45 |
46 | aggregates.push(AggregateResultComparison.new( primary_world, reference_world, test, target,
47 | primary_aggregate, reference_aggregate, tags) )
48 | end
49 |
50 | AggregateResultComparisonGroup.new( :primary_world => primary_world,
51 | :reference_world => reference_world,
52 | :target => target,
53 | :results => aggregates,
54 | :tags => tags )
55 | end
56 |
57 | def initialize( args )
58 | @primary_world = args[:primary_world]
59 | @reference_world = args[:reference_world]
60 | @results = args[:results]
61 | @target = args[:target]
62 | @tags = args[:tags]
63 | @count = {}
64 | end
65 |
66 | #
67 | # Return the overall status of the target
68 | #
69 | def status
70 | AggregateResultComparisonGroup.summary_status(results.collect {|r| r.status} )
71 | end
72 |
73 | def diff
74 | results.collect { |r| r.diff }.any? { |v| v == true }
75 | end
76 |
77 |
78 | def self.summary_status(statuses)
79 |
80 | resulting_status = "error"
81 | resulting_status = "pass" if statuses.count("pass") > 0
82 | resulting_status = "newpass" if statuses.count("newpass") > 0
83 | resulting_status = "notrun" if statuses.count("notrun") > 0
84 | resulting_status = "fail" if statuses.count("fail") > 0
85 | resulting_status = "regres" if statuses.count("regres") > 0
86 |
87 | resulting_status
88 | end
89 |
90 | end
91 |
--------------------------------------------------------------------------------
/app/models/aggregate_result.rb:
--------------------------------------------------------------------------------
1 | # world_id, parent_result_id, test_definition_id, target
2 | # best_result_id, status, pass_count, fail_count, error_count, notrun_count
3 |
4 | class AggregateResult
5 | attr_accessor :results, :target, :world, :test_definition, :filter_tags
6 |
7 | # Returns an array of AggregateResult children
8 | def children
9 | if !@children
10 | child_result_set = @results.map { |r| r.children }
11 | @children = AggregateResult.process_children(child_result_set.flatten, world, target, self.inherited_tags, filter_tags)
12 | end
13 | @children
14 | end
15 |
16 | def self.process_children( results, world, target, tags, filter_tags )
17 | results_by_test = results.group_by { |r| r.test_definition }
18 |
19 | filter_tags = [] if !tags.empty? && tags.any? { |t| filter_tags.include?(t) }
20 |
21 | aggregates = results_by_test.collect { |test, result| AggregateResult.new( test, world, result, target, filter_tags ) }
22 |
23 | if filter_tags && !filter_tags.empty?
24 | aggregates = aggregates.select { |ar| ar.tags.any? { |t| filter_tags.include?(t) } }
25 | end
26 | aggregates
27 | end
28 |
29 | def best
30 | if !@best
31 | if !results || results.empty?
32 | @best = Result.new(:status => "notrun")
33 | else
34 | if results.last.status =='pass'
35 | @best = results.last
36 | else
37 | sorted_results = results.sort { |a, b| a.status_score <=> b.status_score }
38 | @best = sorted_results.last
39 | end
40 | end
41 | end
42 | @best
43 | end
44 |
45 | def stability
46 | (results.collect { |r| r.status_score }.sum / best.status_score ) * ( 100 / results.count )
47 | end
48 |
49 | def confidence
50 | test_definition.confidence
51 | end
52 |
53 | #
54 | # Given a Result, or an array of Results, creates an AggregateResult
55 | # object.
56 | #
57 | def initialize( _test_definition, _world, _result, _target, _filter_tags )
58 | @test_definition = _test_definition
59 | @world = _world
60 | @results = _result
61 | @filter_tags = _filter_tags
62 | if @results && @results.count > 0 && @results.first.class != Result
63 | raise "Not an array of Results #{caller}"
64 | end
65 |
66 | @target = _target
67 | @count = {}
68 | end
69 |
70 | #
71 | # Methods to make this look more like a Result object
72 | #
73 | def statuses
74 | statuses = results.collect {|r| r.status}
75 | end
76 |
77 | def flaky?
78 | self.statuses.uniq.count > 1
79 | end
80 |
81 | def flakyPercentage
82 | ((self.statuses.count("fail").to_f / self.statuses.count.to_f) * 100).round(2)
83 | end
84 |
85 | def status
86 | if !@status
87 | if self.best.status
88 | @status = self.best.status
89 | # If a status hasn't been set, need to work it out
90 | else
91 | @status = Result.summary_status(children.collect {|r| r.status})
92 | end
93 | end
94 | @status
95 | end
96 |
97 | # Counts the statuses of all the child elements
98 | def count(status)
99 | if !@count[status.to_sym]
100 | self.children.each { |c| @count[c.status.to_sym] = @count[c.status.to_sym].to_i + 1 }
101 | @count.default = 0
102 | end
103 | @count[status.to_sym]
104 | end
105 |
106 | def inherited_tags
107 | if !@inherited_tags
108 | @inherited_tags = self.test_definition.specific_tags
109 | end
110 | @inherited_tags
111 | end
112 |
113 | def tags
114 | if !@tags
115 | all = self.test_definition.specific_tags
116 | if !self.is_a_test?
117 | all += self.children.collect { |c| c.tags }
118 | end
119 | @tags = all.flatten.uniq
120 | end
121 | @tags
122 | end
123 |
124 | # Is this an actual test node -- i.e. does it have a status
125 | # TODO Create new step class to make optimisations easier
126 | def is_a_test?
127 | self.best.status
128 | end
129 |
130 | end
131 |
--------------------------------------------------------------------------------
/app/views/worlds/show.html.erb:
--------------------------------------------------------------------------------
1 | <%= @test.node_type-%>
4 |<%= @test.name -%>
5 |<%= @test.description -%>
6 | 7 | 8 | 16 | 17 | 18 |
19 |
20 | <% counter = 0 %>
21 |
22 |
23 |
24 | <% if params[:detail] %>
25 |
26 |
27 |
47 |
48 | ← Back
49 | <% else %>
50 | <% @histories.each do |target, results| %>
51 |
52 | <% tab_class='active' if params[:target] == target %>
53 |
98 |
99 | | Updated At | 29 |Commits | 30 |Passes | 31 |Fails | 32 |Status | 33 |Flaky (%) | 34 |
|---|---|---|---|---|---|
| <%= values[:date] %> | 39 |<%= commit %> | 40 |<%= values["pass"] %> | 41 |<%= values["fail"] %> | 42 |<%= "Flaky" if values["pass"] && values["fail"] %> | 43 |<%= (values["fail"].to_f / (values["pass"].to_f + values["fail"].to_f) * 100).round(2) if values["pass"] && values["fail"] %> | 44 |
54 | <% counter += 1 %>
55 |
56 |
57 |
58 |
93 |
94 |
95 | <% end %>
96 | <% end %>
97 | | 60 | <% (-14..0).each do |i| %> 61 | <% r = results.reference_results[i.abs] %> 62 | <% if r %> 63 | | <%= r.calculated_status.capitalize[0] -%> | 64 | <% else %> 65 |66 | <% end %> 67 | <% end %> 68 | | <%= results.primary_result.calculated_status.capitalize[0] -%> | 69 |
|---|---|---|---|
| <%= link_to(t.name, "/tests/#{t.id}?target=#{target}&test_suite=#{@test_definition_id}&detail=true") -%> | 77 | <% (-14..0).each do |i| %> 78 | <% r = results.reference_child(t,i.abs) %> 79 | <% if r %> 80 | <% status = ( r ? r.calculated_status : 'notrun' ) %> 81 |<%= status.capitalize[0] if status -%> | 82 | <% else %> 83 |84 | <% end %> 85 | <% end %> 86 | | <%= results.primary_child(t).calculated_status.capitalize[0] -%> | 87 |
2 |
11 |
12 | 3 | <% if @world.project.eql? @world.component %> 4 | <%= @world.project -%> 5 | <% else %> 6 | <%= @world.project + ": " + @world.component -%> 7 | <% end %> 8 |
9 |<%= @world.name -%>
10 |
13 |
14 |
15 |
20 |
21 |
22 |
23 | | ID | <%= @world.id -%> |
|---|---|
| Component | <%= @world.component -%> |
| Version | <%= @world.version -%> |
| Runs | <%= @world.runs.count -%> |
24 |
32 |
33 |
34 | 25 |
30 | 31 |
35 |
36 |
37 |
43 |
44 |
45 |
46 |
10 |
14 |
15 | This would mean every build has its results captured in a different bucket. Testmine uses the project and component names to allow you to compare worlds under test. So you could compare a new feature branch build, '1.1-new-feature' against the results for your last know release candidate: '1.0-rc'
16 |
17 | ### Runs
18 |
19 | Runs are the individual executions of your test suites. A run may comprise multiple test results for a particular world and target. A target represents the platform you are testing against. So for our Android app, it might be a particular device or OS build. You can view individual run results in testmine by clicking on a run id. While it can be useful to look at specific run results, the aggregated world views give an overview of your testing for a particular world.
20 |
21 | ### Aggregate Results
22 |
23 | Testmine aggregates all the runs for a world into a single-page aggregated view of the results. Results are organised by target. It's important to note that the aggregated view takes the best results from across your test runs. So if you have two different runs, and a test passed in first run, but failed in the second run, the second result is discarded. This behaviour means that testmine filters out failed results where test behaviour is inconsistent.
24 |
25 | ### Comparison Results
26 |
27 | Testmine can present a side-by-side view of aggregate results for two worlds. Testmine compares the results to provide a comparason status. They have the following meanings:
28 | * **PASS** Results passed consistently in line with the reference world
29 | * **NEWPASS** Tests that previously failed are now passing
30 | * **REGRESS** Tests that previously passed are now failing
31 | * **FAIL** Tests that failed previously are still failing
32 | * **ERROR** Tests failed to execute correctly
33 | * **NOTRUN** The tests have not been run
34 |
35 | In addition, the comparison result will be faded if the results between the two worlds exactly match.
36 |
37 | ## Running testmine
38 |
39 | Testmine is a straightforward Rails application. You can deploy a local copy easily by checking it out and running:
40 |
41 |
42 | ### Method # 1: Run directly on Host Machine
43 |
44 | bundle install --local --without development test
45 | bundle exec rake db:migrate
46 | bundle exec rails s
47 |
48 | You should get a testmine instance on port 3002 with an sqlite database.
49 |
50 | ### Method # 2: Run it on Docker
51 |
52 | #### Prerequiste for Docker
53 | 1. Download and install docker https://docs.docker.com/docker-for-mac/install/
54 | 2. Install virtualbox on your machine.
55 | ```
56 | $ brew cask install virtualbox
57 | ```
58 | 3. Create a default docker machine
59 | ```
60 | $ docker-machine create default
61 | ```
62 | 4. Ensure your docker machine is running
63 | ```
64 | $ docker-machine status
65 | ```
66 | It should say "Running".
67 |
68 | 5. Get the ip address of your docker machine
69 | ```
70 | $ docker-machine env default
71 | ...
72 | export DOCKER_HOST="tcp://192.168.99.100:2376"
73 | ...
74 | ```
75 | The ip address is 192.168.99.100 in this case.
76 | 6. Run the following command to configure your shell
77 | ```
78 | eval $(docker-machine env default)
79 | ```
80 |
81 | #### Run testmine on Docker
82 |
83 | Run the following to startup a docker machine for testmine.
84 |
85 | ```
86 | docker-compose build
87 | docker-compose up
88 | ```
89 |
90 | Visit the browser http://192.168.99.100:3002 to see the output.
91 |
92 |
93 |
94 | ## Submitting results
95 |
96 | In order to submit your results to testmine, you will need to format your test results as Res IR
97 | (see our [res](https://github.com/bbc/res) repo for more information). Res provides a number of formatters for sumbitting from popular test runner such as cucumber and rspec.
98 |
99 | Alternatively you can hand-craft your own res output, and submit it against the endpoint: /api/v1/submit
100 |
101 | ## License
102 |
103 | Testmine is available to everyone under the terms of the MIT open source licence.
104 | Take a look at the LICENSE file in the code.
105 |
106 | Copyright (c) 2016 BBC
107 |
--------------------------------------------------------------------------------
/app/views/worlds/aggregate_group_element.html.erb:
--------------------------------------------------------------------------------
1 |
3 | <%= pretty_node(c) -%>
4 |
5 | <%= link_to( pretty_truncate(h(c.test_definition.name), 80, 'strong', h(c.test_definition.file_name(:short))), "/tests/#{c.test_definition.id}?target=#{@target}") -%>
6 |
7 | <%= c.reference.results.count -%>
8 |
9 | "><%= c.reference.count("pass") %>
10 | "><%= c.reference.count("fail") or 0 %>
11 | "><%= c.reference.count("notrun") %>
12 | "><%= c.reference.count("error") -%>
13 |
14 |
16 | <%= c.reference.status -%>
17 |
18 |
19 | <%= c.primary.status -%>
20 |
21 |
23 | "><%= c.primary.count("pass") %>
24 | "><%= c.primary.count("fail") or 0 %>
25 | "><%= c.primary.count("notrun") %>
26 | "><%= c.primary.count("error") -%>
27 |
28 | <%= c.primary.results.count %>
29 |
30 |
31 | <%= c.status -%>
32 |
33 |
34 |
35 |
36 | <% c.children.each do |s| %>
37 |
38 | <%= pretty_node(s) -%>
39 | <%= link_to( pretty_truncate(h(s.test_definition.name), 80, 'em'), "/tests/#{s.test_definition.id}?target=#{@target}") -%>
40 |
41 | <%= s.reference.results.count -%>
42 |
43 | "><%= s.reference.count("pass") %>
44 | "><%= s.reference.count("fail") or 0 %>
45 | "><%= s.reference.count("notrun") %>
46 | "><%= s.reference.count("error") -%>
47 |
48 |
49 | <%= hive_job_link(s.reference.best.run) if s.reference.best && s.reference.best.run -%>
50 |
51 |
52 | <%= s.reference.status -%>
53 |
54 |
55 | <%= s.primary.status -%>
56 |
57 |
58 | <%= hive_job_link(s.primary.best.run) if s.primary.best && s.primary.best.run -%>
59 |
60 |
61 | "><%= s.primary.count("pass") %>
62 | "><%= s.primary.count("fail") or 0 %>
63 | "><%= s.primary.count("notrun") %>
64 | "><%= s.primary.count("error") -%>
65 |
66 | <%= s.primary.results.count -%>
67 |
68 |
69 | <%= s.status -%>
70 |
71 |
72 |
73 |
74 | <% end %>
75 |
76 |
77 |
--------------------------------------------------------------------------------
/app/views/worlds/comparison_group_element.html.erb:
--------------------------------------------------------------------------------
1 |
47 |
48 |
145 |
146 |
147 |
154 |
--------------------------------------------------------------------------------
/app/views/runs/show.html.erb:
--------------------------------------------------------------------------------
1 |
49 |
50 |
51 | 52 |
76 |
77 |
78 |
79 | 51 | 52 |
53 |
54 | <% @targets.each do |t| %>
55 |
56 |
74 |
75 |
57 |
72 | <% end %>
73 |
58 |
69 | 59 | <%=t-%> 60 | 61 | ???? 62 | ? 63 | ? 64 | ? 65 | ? 66 | 67 |
68 |
70 |
71 |
80 |
81 |
82 | 83 |
84 |
85 |
111 |
112 |
113 |
114 |
115 | 82 | 83 |
| Run ID | 87 |Target | 88 |Status | 89 |Started | 90 |Duration | 91 |
|---|---|---|---|---|
| <%= link_to r.id, "/runs/#{r.id}" -%> | 100 |<%= r.target -%> | 101 |<%= status_badge(r.status) -%> 102 | <%= hive_job_link(r) -%> 103 | | 104 |<%= r.started_at ? r.started_at.to_s(:short) : '-' -%> | 105 |<%= r.duration -%> | 106 |
116 |
117 |
118 | 119 |
143 |
144 | 118 | 119 |
Compare results against...
120 |-
121 |
122 | <% if @comparison_worlds.empty? %>
123 |
124 |
Couldn't find any comparison worlds
125 | 126 | <% end %> 127 | 128 |
129 |
130 |
131 | <% @comparison_worlds.each do |w| %>
132 |
139 |
140 |
141 |
142 | | <%= link_to w.version, "/worlds/#{@world.id}/#{w.id}" -%> | 134 |<%= w.runs.count -%> | 135 |<%= time_ago_in_words w.created_at -%> ago | 136 |
2 |
8 |
9 | Run <%= @run.id -%>
3 |Target: <%= @run.target -%>
4 |World: <%= link_to "#{@run.world.component}: #{@run.world.version}", "/worlds/#{@run.world.id}" -%>
5 |<%= @run.status -%> 6 |
7 |10 |
11 |
12 |
89 |
90 |
91 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Testmine
2 |
3 | Testmine is test results tool for storing and analysing result data. Testmine takes result output for a test run, and stores it in a result bucket for historic analysis.
4 |
5 | ## Concepts
6 |
7 | ### Worlds
8 |
9 | Testmine stores test results in buckets called worlds. A world is identified by the project, component, and version strings submitted along with the test results. So, for example, if you're testing a mobile application like iPlayer, you might submit against:
10 |
11 | project: 'iPlayer',
12 | component: 'android'
13 | version: | 14 | | 15 | | 16 | P 17 | F 18 | N 19 | E 20 | | 21 |22 | | |||
|---|---|---|---|---|---|---|
| <%= pretty_node(r) -%> | 28 |<%= link_to( pretty_truncate("#{h r.test_definition.name}", 80, 'strong', r.test_definition.file_name(:short) ), "/tests/#{r.test_definition.id}?target=#{@run.target}") -%> | 29 | 30 |31 | <%= r.calculated_status -%> 32 | | 33 |34 | <%= r.count(:pass) %> 35 | <%= r.count(:fail) or 0 %> 36 | <%= r.count(:notrun) %> 37 | <%= r.count(:error) -%> 38 | | <%= simple_time(r.finished_at) %> | 39 |||
| <%= pretty_node(s) -%> | 45 |<%= link_to( pretty_truncate(h(s.test.name), 80, 'em'), "/tests/#{s.test.id}?target=#{@run.target}&test_suite=#{@test_definition_id}&detail=true") -%> | 46 | 47 |48 | <%= s.calculated_status -%> 49 | | 50 | 51 |52 | <%= s.count(:pass) %> 53 | <%= s.count(:fail) or 0 %> 54 | <%= s.count(:notrun) %> 55 | <%= s.count(:error) -%> 56 | | <%= simple_time(r.finished_at) %> | 57 |||
| <%= pretty_node(s) -%> | 63 |<%= pretty_truncate(h(s.test.name), 80, 'em') -%> | 64 | 65 |66 | <%= s.calculated_status -%> 67 | | 68 | 69 |70 | <% if s.children.count > 0 %> 71 | <%= s.count(:pass) %> 72 | <%= s.count(:fail) or 0 %> 73 | <%= s.count(:notrun) %> 74 | <%= s.count(:error) -%> 75 | <% end %> 76 | | <%= simple_time(r.finished_at) %> | 77 |||
90 |
2 | <% if !@tags.empty? %>
3 | <% @tags.each do |t| %>
4 |
10 | <% end %>
11 | <% end %>
12 |
13 |
27 |
28 |
108 |
--------------------------------------------------------------------------------
/db/schema.rb:
--------------------------------------------------------------------------------
1 | # This file is auto-generated from the current state of the database. Instead
2 | # of editing this file, please use the migrations feature of Active Record to
3 | # incrementally modify your database, and then regenerate this schema definition.
4 | #
5 | # Note that this schema.rb definition is the authoritative source for your
6 | # database schema. If you need to create the application database on another
7 | # system, you should be using db:schema:load, not running all the migrations
8 | # from scratch. The latter is a flawed and unsustainable approach (the more migrations
9 | # you'll amass, the slower it'll run and the greater likelihood for issues).
10 | #
11 | # It's strongly recommended that you check this file into your version control system.
12 |
13 | ActiveRecord::Schema.define(version: 20160216102230) do
14 |
15 | create_table "results", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
16 | t.integer "test_definition_id"
17 | t.integer "run_id"
18 | t.integer "parent_id"
19 | t.integer "value"
20 | t.string "status"
21 | t.text "output", limit: 65535
22 | t.datetime "started_at"
23 | t.datetime "finished_at"
24 | t.datetime "created_at"
25 | t.datetime "updated_at"
26 | t.index ["parent_id"], name: "index_results_on_parent_id", using: :btree
27 | t.index ["run_id", "test_definition_id"], name: "index_results_on_run_id_and_test_definition_id", using: :btree
28 | t.index ["run_id"], name: "index_results_on_run_id", using: :btree
29 | t.index ["test_definition_id"], name: "index_results_on_test_definition_id", using: :btree
30 | end
31 |
32 | create_table "runs", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
33 | t.integer "world_id"
34 | t.string "owner"
35 | t.integer "hive_job_id"
36 | t.string "target"
37 | t.string "status"
38 | t.datetime "started_at"
39 | t.datetime "finished_at"
40 | t.datetime "created_at"
41 | t.datetime "updated_at"
42 | t.index ["world_id"], name: "index_runs_on_world_id", using: :btree
43 | end
44 |
45 | create_table "suites", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
46 | t.string "project"
47 | t.string "name"
48 | t.string "runner"
49 | t.string "description"
50 | t.text "documentation", limit: 65535
51 | t.string "url"
52 | t.string "repo"
53 | t.datetime "created_at"
54 | t.datetime "updated_at"
55 | t.index ["project", "name"], name: "index_suites_on_project_and_name", using: :btree
56 | end
57 |
58 | create_table "taggings", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
59 | t.integer "tag_id"
60 | t.integer "taggable_id"
61 | t.string "taggable_type"
62 | t.integer "tagger_id"
63 | t.string "tagger_type"
64 | t.string "context", limit: 128
65 | t.datetime "created_at"
66 | t.index ["tag_id", "taggable_id", "taggable_type", "context", "tagger_id", "tagger_type"], name: "taggings_idx", unique: true, using: :btree
67 | t.index ["taggable_id", "taggable_type", "context"], name: "index_taggings_on_taggable_id_and_taggable_type_and_context", using: :btree
68 | end
69 |
70 | create_table "tags", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
71 | t.string "name"
72 | t.integer "taggings_count", default: 0
73 | t.index ["name"], name: "index_tags_on_name", unique: true, using: :btree
74 | end
75 |
76 | create_table "test_definitions", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
77 | t.string "name"
78 | t.string "node_type"
79 | t.text "description", limit: 65535
80 | t.string "file"
81 | t.integer "line"
82 | t.integer "parent_id"
83 | t.integer "suite_id"
84 | t.datetime "created_at"
85 | t.datetime "updated_at"
86 | t.index ["name", "suite_id", "file", "parent_id"], name: "lookup", using: :btree
87 | t.index ["suite_id"], name: "index_test_definitions_on_suite_id", using: :btree
88 | end
89 |
90 | create_table "worlds", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci" do |t|
91 | t.string "type"
92 | t.string "name"
93 | t.text "description", limit: 65535
94 | t.string "project"
95 | t.string "component"
96 | t.string "version"
97 | t.datetime "created_at"
98 | t.datetime "updated_at"
99 | t.index ["project", "component", "version"], name: "index_worlds_on_project_and_component_and_version", using: :btree
100 | t.index ["project", "component"], name: "index_worlds_on_project_and_component", using: :btree
101 | end
102 |
103 | end
104 |
--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
1 | GEM
2 | remote: https://rubygems.org/
3 | specs:
4 | actioncable (5.0.7.1)
5 | actionpack (= 5.0.7.1)
6 | nio4r (>= 1.2, < 3.0)
7 | websocket-driver (~> 0.6.1)
8 | actionmailer (5.0.7.1)
9 | actionpack (= 5.0.7.1)
10 | actionview (= 5.0.7.1)
11 | activejob (= 5.0.7.1)
12 | mail (~> 2.5, >= 2.5.4)
13 | rails-dom-testing (~> 2.0)
14 | actionpack (5.0.7.1)
15 | actionview (= 5.0.7.1)
16 | activesupport (= 5.0.7.1)
17 | rack (~> 2.0)
18 | rack-test (~> 0.6.3)
19 | rails-dom-testing (~> 2.0)
20 | rails-html-sanitizer (~> 1.0, >= 1.0.2)
21 | actionview (5.0.7.1)
22 | activesupport (= 5.0.7.1)
23 | builder (~> 3.1)
24 | erubis (~> 2.7.0)
25 | rails-dom-testing (~> 2.0)
26 | rails-html-sanitizer (~> 1.0, >= 1.0.3)
27 | activejob (5.0.7.1)
28 | activesupport (= 5.0.7.1)
29 | globalid (>= 0.3.6)
30 | activemodel (5.0.7.1)
31 | activesupport (= 5.0.7.1)
32 | activerecord (5.0.7.1)
33 | activemodel (= 5.0.7.1)
34 | activesupport (= 5.0.7.1)
35 | arel (~> 7.0)
36 | activesupport (5.0.7.1)
37 | concurrent-ruby (~> 1.0, >= 1.0.2)
38 | i18n (>= 0.7, < 2)
39 | minitest (~> 5.1)
40 | tzinfo (~> 1.1)
41 | acts-as-taggable-on (6.0.0)
42 | activerecord (~> 5.0)
43 | arel (7.1.4)
44 | autoprefixer-rails (9.4.2)
45 | execjs
46 | backports (3.11.4)
47 | bootstrap-sass (3.3.7)
48 | autoprefixer-rails (>= 5.2.1)
49 | sass (>= 3.3.4)
50 | builder (3.2.3)
51 | concurrent-ruby (1.1.3)
52 | crass (1.0.4)
53 | daemons (1.2.6)
54 | erubis (2.7.0)
55 | eventmachine (1.2.7)
56 | execjs (2.7.0)
57 | ffi (1.9.25)
58 | font-awesome-sass (5.5.0.1)
59 | sassc (>= 1.11)
60 | globalid (0.4.1)
61 | activesupport (>= 4.2.0)
62 | i18n (1.1.1)
63 | concurrent-ruby (~> 1.0)
64 | jbuilder (2.8.0)
65 | activesupport (>= 4.2.0)
66 | multi_json (>= 1.2)
67 | jquery-rails (4.3.3)
68 | rails-dom-testing (>= 1, < 3)
69 | railties (>= 4.2.0)
70 | thor (>= 0.14, < 2.0)
71 | loofah (2.2.3)
72 | crass (~> 1.0.2)
73 | nokogiri (>= 1.5.9)
74 | mail (2.7.1)
75 | mini_mime (>= 0.1.1)
76 | method_source (0.9.2)
77 | mini_mime (1.0.1)
78 | mini_portile2 (2.3.0)
79 | minitest (5.11.3)
80 | multi_json (1.13.1)
81 | mysql2 (0.5.2)
82 | nio4r (2.3.1)
83 | nokogiri (1.8.5)
84 | mini_portile2 (~> 2.3.0)
85 | rack (2.0.6)
86 | rack-test (0.6.3)
87 | rack (>= 1.0)
88 | rails (5.0.7.1)
89 | actioncable (= 5.0.7.1)
90 | actionmailer (= 5.0.7.1)
91 | actionpack (= 5.0.7.1)
92 | actionview (= 5.0.7.1)
93 | activejob (= 5.0.7.1)
94 | activemodel (= 5.0.7.1)
95 | activerecord (= 5.0.7.1)
96 | activesupport (= 5.0.7.1)
97 | bundler (>= 1.3.0)
98 | railties (= 5.0.7.1)
99 | sprockets-rails (>= 2.0.0)
100 | rails-dom-testing (2.0.3)
101 | activesupport (>= 4.2.0)
102 | nokogiri (>= 1.6)
103 | rails-html-sanitizer (1.0.4)
104 | loofah (~> 2.2, >= 2.2.2)
105 | railties (5.0.7.1)
106 | actionpack (= 5.0.7.1)
107 | activesupport (= 5.0.7.1)
108 | method_source
109 | rake (>= 0.8.7)
110 | thor (>= 0.18.1, < 2.0)
111 | rake (12.3.2)
112 | rb-fsevent (0.10.3)
113 | rb-inotify (0.9.10)
114 | ffi (>= 0.5.0, < 2)
115 | sass (3.7.2)
116 | sass-listen (~> 4.0.0)
117 | sass-listen (4.0.0)
118 | rb-fsevent (~> 0.9, >= 0.9.4)
119 | rb-inotify (~> 0.9, >= 0.9.7)
120 | sass-rails (5.0.7)
121 | railties (>= 4.0.0, < 6)
122 | sass (~> 3.1)
123 | sprockets (>= 2.8, < 4.0)
124 | sprockets-rails (>= 2.0, < 4.0)
125 | tilt (>= 1.1, < 3)
126 | sassc (2.0.0)
127 | ffi (~> 1.9.6)
128 | rake
129 | sprockets (3.7.2)
130 | concurrent-ruby (~> 1.0)
131 | rack (> 1, < 3)
132 | sprockets-rails (3.2.1)
133 | actionpack (>= 4.0)
134 | activesupport (>= 4.0)
135 | sprockets (>= 3.0.0)
136 | thin (1.7.2)
137 | daemons (~> 1.0, >= 1.0.9)
138 | eventmachine (~> 1.0, >= 1.0.4)
139 | rack (>= 1, < 3)
140 | thor (0.20.3)
141 | thread_safe (0.3.6)
142 | tilt (2.0.9)
143 | token_phrase (1.0.6)
144 | backports
145 | tzinfo (1.2.5)
146 | thread_safe (~> 0.1)
147 | uglifier (4.1.20)
148 | execjs (>= 0.3.0, < 3)
149 | websocket-driver (0.6.5)
150 | websocket-extensions (>= 0.1.0)
151 | websocket-extensions (0.1.3)
152 |
153 | PLATFORMS
154 | ruby
155 |
156 | DEPENDENCIES
157 | acts-as-taggable-on (= 6.0.0)
158 | bootstrap-sass (= 3.3.7)
159 | font-awesome-sass (= 5.5.0.1)
160 | jbuilder (= 2.8.0)
161 | jquery-rails (= 4.3.3)
162 | mysql2 (= 0.5.2)
163 | nokogiri (= 1.8.5)
164 | rails (= 5.0.7.1)
165 | sass-rails (= 5.0.7)
166 | thin (= 1.7.2)
167 | token_phrase (= 1.0.6)
168 | uglifier (= 4.1.20)
169 |
170 | BUNDLED WITH
171 | 1.16.1
172 |
--------------------------------------------------------------------------------
/app/views/worlds/comparison_element.html.erb:
--------------------------------------------------------------------------------
1 | <% c = @comparison %>
2 |
29 |
30 | <% if !@results.results.empty? %>
31 |
32 |
33 |
103 |
104 | <% end %>
105 |
106 |
107 | | 35 | 36 | | S | 37 |n | 38 |Result | 39 |40 | P 41 | F 42 | N 43 | E 44 | | 45 |||
|---|---|---|---|---|---|---|
| <%= pretty_node(r) -%> | 50 | 51 |52 | <%= link_to( pretty_truncate(h(r.test_definition.name), 80, 'strong', h(r.test_definition.file_name(:short))), "/tests/#{r.test_definition.id}?target=#{@target}") -%> 53 | | 54 | 55 |56 | <%= r.stability -%> 57 | <%= r.confidence -%> 58 | | 59 | 60 |<%= r.results.count %> | 61 |62 | <%= r.status -%> 63 | | 64 | 65 |66 | <%= r.count(:pass) %> 67 | <%= r.count(:fail) or 0 %> 68 | <%= r.count(:notrun) %> 69 | <%= r.count(:error) -%> 70 | | 71 ||
| <%= pretty_node(s) -%> | 77 |<%= link_to( pretty_truncate(h(s.test_definition.name), 80, 'em'), "/tests/#{s.test_definition.id}?target=#{@target}&detail=true") -%> | 78 | 79 |80 | <%= s.stability -%> 81 | <%= s.confidence -%> 82 | | 83 | 84 |<%= s.results.count %> | 85 |86 | <%= s.status -%> 87 | <%= hive_job_link(s.best.run) if s.best -%> 88 | | 89 | 90 |91 | <%= s.best.count(:pass) %> 92 | <%= s.best.count(:fail) or 0 %> 93 | <%= s.best.count(:notrun) %> 94 | <%= s.best.count(:error) -%> 95 | | 96 | 97 ||
2 |
3 |
10 |
11 | 4 | <%=@target-%> 5 | 6 | <%= @results.status -%> 7 | 8 |
9 |
12 |
13 |
14 |
| 16 | | 17 | | <%= @reference_world.version -%> |
18 | <%= @primary_world.version -%> |
19 | 20 | | |||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| 24 | | 25 | | 26 | | 27 | P 28 | F 29 | N 30 | E 31 | | 32 |33 | | 34 | | 35 | | 36 | | 37 | P 38 | F 39 | N 40 | E 41 | | 42 |43 | 44 | | Diff | 45 ||
| <%= pretty_node(c) -%> | 51 |52 | <%= link_to( pretty_truncate(h(c.test_definition.name), 80, 'strong', h(c.test_definition.file_name(:short))), "/tests/#{c.test_definition.id}?target=#{@target}") -%> | 53 |<%= c.reference.results.count -%> | 54 |55 | "><%= c.reference.count("pass") %> 56 | "><%= c.reference.count("fail") or 0 %> 57 | "><%= c.reference.count("notrun") %> 58 | "><%= c.reference.count("error") -%> 59 | | 60 |61 | | 62 | <%= c.reference.status -%> 63 | | 64 |65 | <%= c.primary.status -%> 66 | | 67 |68 | | 69 | "><%= c.primary.count("pass") %> 70 | "><%= c.primary.count("fail") or 0 %> 71 | "><%= c.primary.count("notrun") %> 72 | "><%= c.primary.count("error") -%> 73 | | 74 |<%= c.primary.results.count %> | 75 | 76 |77 | <%= c.status -%> 78 | | 79 | 80 ||
| <%= pretty_node(s) -%> | 85 |<%= link_to( pretty_truncate(h(s.test_definition.name), 80, 'em'), "/tests/#{s.test_definition.id}?target=#{@target}") -%> | 86 | 87 |<%= s.reference.results.count -%> | 88 |89 | "><%= s.reference.count("pass") %> 90 | "><%= s.reference.count("fail") or 0 %> 91 | "><%= s.reference.count("notrun") %> 92 | "><%= s.reference.count("error") -%> 93 | | 94 |95 | <%= hive_job_link(s.reference.best.run) if s.reference.best && s.reference.best.run -%> 96 | | 97 |98 | <%= s.reference.status -%> 99 | | 100 |101 | <%= s.primary.status -%> 102 | | 103 |104 | <%= hive_job_link(s.primary.best.run) if s.primary.best && s.primary.best.run -%> 105 | | 106 |107 | "><%= s.primary.count("pass") %> 108 | "><%= s.primary.count("fail") or 0 %> 109 | "><%= s.primary.count("notrun") %> 110 | "><%= s.primary.count("error") -%> 111 | | 112 |<%= s.primary.results.count -%> | 113 | 114 |115 | <%= s.status -%> 116 | | 117 | 118 ||