foreman_omaha 0.0.3 → 1.0.0

data/test/functional/omaha_reports_controller_test.rb

@@ -2,52 +2,52 @@ require 'test_plugin_helper'
 
 class OmahaReportsControllerTest < ActionController::TestCase
   test '#index' do
-    FactoryGirl.create(:omaha_report)
-    get :index, {}, set_session_user
+    FactoryBot.create(:omaha_report)
+    get :index, session: set_session_user
     assert_response :success
     assert_not_nil assigns('omaha_reports')
     assert_template 'index'
   end
 
   test '#show' do
-    report = FactoryGirl.create(:omaha_report)
-    get :show, { :id => report.id }, set_session_user
+    report = FactoryBot.create(:omaha_report)
+    get :show, params: { :id => report.id }, session: set_session_user
     assert_template 'show'
   end
 
   test '404 on #show when id is blank' do
-    get :show, { :id => ' ' }, set_session_user
+    get :show, params: { :id => ' ' }, session: set_session_user
     assert_response :missing
     assert_template 'common/404'
   end
 
   test '#show last' do
-    FactoryGirl.create(:omaha_report)
-    get :show, { :id => 'last' }, set_session_user
+    FactoryBot.create(:omaha_report)
+    get :show, params: { :id => 'last' }, session: set_session_user
     assert_template 'show'
   end
 
   test '404 on #show last when no reports available' do
-    get :show, { :id => 'last', :host_id => FactoryGirl.create(:host) }, set_session_user
+    get :show, params: { :id => 'last', :host_id => FactoryBot.create(:host) }, session: set_session_user
     assert_response :missing
     assert_template 'common/404'
   end
 
   test '#show last report for host' do
-    report = FactoryGirl.create(:omaha_report)
-    get :show, { :id => 'last', :host_id => report.host.to_param }, set_session_user
+    report = FactoryBot.create(:omaha_report)
+    get :show, params: { :id => 'last', :host_id => report.host.to_param }, session: set_session_user
     assert_template 'show'
   end
 
   test 'render 404 when #show invalid report for a host is requested' do
-    get :show, { :id => 'last', :host_id => 'blalala.domain.com' }, set_session_user
+    get :show, params: { :id => 'last', :host_id => 'blalala.domain.com' }, session: set_session_user
     assert_response :missing
     assert_template 'common/404'
   end
 
   test '#destroy' do
-    report = FactoryGirl.create(:omaha_report)
-    delete :destroy, { :id => report }, set_session_user
+    report = FactoryBot.create(:omaha_report)
+    delete :destroy, params: { :id => report }, session: set_session_user
     assert_redirected_to omaha_reports_url
     assert !ConfigReport.exists?(report.id)
   end

data/test/test_plugin_helper.rb

@@ -2,9 +2,9 @@
 require 'test_helper'
 require 'database_cleaner'
 
-# Add plugin to FactoryGirl's paths
-FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
-FactoryGirl.reload
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload
 
 # Foreman's setup doesn't handle cleaning up for Minitest::Spec
 DatabaseCleaner.strategy = :transaction

data/test/unit/charts/oem_distribution_test.rb

@@ -0,0 +1,26 @@
+require 'test_plugin_helper'
+
+module ForemanOmaha
+  module Charts
+    class OemDistribitionTest < ActiveSupport::TestCase
+      setup do
+        User.current = FactoryBot.create(:user, :admin)
+      end
+
+      let(:oem_distribition_chart) { ForemanOmaha::Charts::OemDistribution.new }
+
+      context 'with hosts' do
+        setup do
+          FactoryBot.create_list(:host, 5, :with_omaha_facet)
+        end
+
+        test 'calculates the oem distribution' do
+          expected = [
+            { :label => 'rackspace', :data => 5 }
+          ]
+          assert_equal(expected, oem_distribition_chart.to_chart_data.sort_by { |e| e[:label] })
+        end
+      end
+    end
+  end
+end

data/test/unit/charts/status_distribution_test.rb

@@ -0,0 +1,28 @@
+require 'test_plugin_helper'
+
+module ForemanOmaha
+  module Charts
+    class StatusDistribitionTest < ActiveSupport::TestCase
+      setup do
+        User.current = FactoryBot.create(:user, :admin)
+      end
+
+      let(:status_distribition_chart) { ForemanOmaha::Charts::StatusDistribution.new }
+
+      context 'with hosts' do
+        setup do
+          FactoryBot.create_list(:host, 5, :with_omaha_facet)
+          FactoryBot.create_list(:host, 3, :with_omaha_facet, :omaha_status => 2)
+        end
+
+        test 'calculates the status distribution' do
+          expected = [
+            { :label => 'Complete', :data => 5, :color => '#89A54E' },
+            { :label => 'Downloading', :data => 3, :color => '#3D96AE' }
+          ]
+          assert_equal(expected, status_distribition_chart.to_chart_data.sort_by { |e| e[:label] })
+        end
+      end
+    end
+  end
+end

data/test/unit/charts/version_distribution_test.rb

@@ -0,0 +1,28 @@
+require 'test_plugin_helper'
+
+module ForemanOmaha
+  module Charts
+    class VersionDistribitionTest < ActiveSupport::TestCase
+      setup do
+        User.current = FactoryBot.create(:user, :admin)
+      end
+
+      let(:version_distribition_chart) { ForemanOmaha::Charts::VersionDistribution.new }
+
+      context 'with hosts' do
+        setup do
+          FactoryBot.create_list(:host, 5, :with_omaha_facet)
+          FactoryBot.create_list(:host, 7, :with_omaha_facet, :omaha_version => '1465.7.0')
+        end
+
+        test 'calculates the version distribution' do
+          expected = [
+            { :label => '1068.9.0', :data => 5 },
+            { :label => '1465.7.0', :data => 7 }
+          ]
+          assert_equal(expected, version_distribition_chart.to_chart_data.sort_by { |e| e[:label] })
+        end
+      end
+    end
+  end
+end

data/test/unit/group_version_breakdown_test.rb

@@ -0,0 +1,65 @@
+require 'test_plugin_helper'
+
+class CurrentVersionBreakdownTest < ActiveSupport::TestCase
+  setup do
+    User.current = FactoryBot.create(:user, :admin)
+  end
+
+  let(:stable_group) { FactoryBot.create(:omaha_group, :uuid => 'stable', :name => 'Stable') }
+  let(:beta_group) { FactoryBot.create(:omaha_group, :uuid => 'beta', :name => 'Beta') }
+  let(:group_version_breakdown) { ForemanOmaha::GroupVersionBreakdown.new(:omaha_group => stable_group) }
+  let(:stable_releases) { ['1520.6.0', '1520.5.0', '1465.8.0'] }
+  let(:beta_coreos) { create_coreos_os('1576.3.0', 'beta') }
+
+  context 'with hosts' do
+    setup do
+      oslist = stable_releases.map do |release|
+        create_coreos_os(release)
+      end
+      FactoryBot.create_list(
+        :host, 2, :managed, :with_omaha_facet,
+        :omaha_version => oslist.first.release,
+        :omaha_group => stable_group,
+        :operatingsystem => oslist.first
+      )
+      FactoryBot.create(
+        :host, :managed, :with_omaha_facet,
+        :omaha_version => oslist.last.release,
+        :omaha_group => stable_group,
+        :operatingsystem => oslist.last
+      )
+      FactoryBot.create(
+        :host, :managed, :with_omaha_facet,
+        :omaha_version => beta_coreos.release,
+        :omaha_group => beta_group,
+        :operatingsystem => beta_coreos
+      )
+    end
+
+    test 'counts host in stable group' do
+      assert_equal 3, group_version_breakdown.facets.count
+    end
+
+    test 'calculates a version breakdown' do
+      expected = [
+        { :version => '1520.6.0', :count => 2, :percentage => 66.67 },
+        { :version => '1465.8.0', :count => 1, :percentage => 33.33 }
+      ]
+      assert_equal expected, group_version_breakdown.version_breakdown
+    end
+  end
+
+  private
+
+  def create_coreos_os(version, channel = 'stable')
+    semver = Gem::Version.new(version)
+    FactoryBot.create(
+      :coreos,
+      :with_associations,
+      :major => semver.segments.first,
+      :minor => semver.segments.last(2).join('.'),
+      :release_name => channel,
+      :title => "CoreOS #{version}"
+    )
+  end
+end

data/test/unit/host_status/omaha_status_test.rb

@@ -0,0 +1,19 @@
+require 'test_plugin_helper'
+
+class OmahaStatusTest < ActiveSupport::TestCase
+  let(:host) { FactoryBot.build_stubbed(:host, :with_omaha_facet) }
+  let(:status) { HostStatus::OmahaStatus.new }
+
+  setup do
+    User.current = FactoryBot.create(:user, :admin)
+    status.host = host
+  end
+
+  test '#relevant? is only for hosts with an omaha facet' do
+    assert_equal true, status.relevant?
+
+    status.host = FactoryBot.build_stubbed(:host)
+
+    assert_equal false, status.relevant?
+  end
+end

data/test/unit/host_test.rb

@@ -0,0 +1,55 @@
+require 'test_plugin_helper'
+
+class HostTest < ActiveSupport::TestCase
+  setup do
+    User.current = FactoryBot.create(:user, :admin)
+  end
+
+  context 'scoped search' do
+    setup do
+      @host = FactoryBot.create(:host, :with_omaha_facet)
+    end
+
+    test 'search by last_report' do
+      hosts = Host.search_for('last_omaha_report = Today')
+      assert_includes hosts, @host
+    end
+
+    test 'search by machineid' do
+      hosts = Host.search_for("omaha_machineid = #{@host.omaha_facet.machineid}")
+      assert_includes hosts, @host
+    end
+
+    test 'search by version' do
+      hosts = Host.search_for("omaha_version = #{@host.omaha_facet.version}")
+      assert_includes hosts, @host
+    end
+
+    test 'search by oem' do
+      hosts = Host.search_for("omaha_oem = #{@host.omaha_facet.oem}")
+      assert_includes hosts, @host
+    end
+
+    test 'search by status' do
+      hosts = Host.search_for("omaha_status = #{@host.omaha_facet.status}")
+      assert_includes hosts, @host
+    end
+
+    test 'search by omaha_group' do
+      hosts = Host.search_for("omaha_group = \"#{@host.omaha_facet.omaha_group.name}\"")
+      assert_includes hosts, @host
+    end
+  end
+
+  context 'host rebuild' do
+    let(:host) { FactoryBot.create(:host, :managed, :with_omaha_facet) }
+
+    test 'clears the omaha facet' do
+      assert host.omaha_facet
+      host.build = true
+      assert_valid host
+      assert host.save
+      refute host.reload.omaha_facet
+    end
+  end
+end

data/test/unit/omaha_fact_parser_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class OmahaFactsParserTest < ActiveSupport::TestCase
+  setup do
+    User.current = users(:admin)
+  end
+
+  let(:facts) do
+    {
+      'appid' => 'e96281a6-d1af-4bde-9a0a-97b76e56dc57',
+      'version' => '1068.9.0',
+      'track' => 'stable',
+      'board' => 'amd64-usr',
+      'alephversion' => '1010.5.0',
+      'oemversion' => '',
+      'oem' => '',
+      'platform' => 'CoreOS',
+      'osmajor' => '1068',
+      'osminor' => '9.0',
+      'ipaddress' => '127.0.0.1',
+      'ipaddress6' => '',
+      'hostname' => 'client.example.com'
+    }
+  end
+  let(:importer) { ::ForemanOmaha::FactParser.new(facts) }
+
+  context '#architecture' do
+    let(:architecture) { importer.architecture }
+
+    test 'should return an Architecture' do
+      assert_kind_of Architecture, architecture
+      assert_equal Architecture.find_by(name: 'x86_64'), architecture
+    end
+  end
+
+  context '#operatingsystem' do
+    let(:os) { importer.operatingsystem }
+
+    test 'should return an OS with correct params' do
+      assert_kind_of Operatingsystem, os
+      assert_equal '1068', os.major
+      assert_equal '9.0', os.minor
+      assert_equal 'CoreOS', os.name
+      assert_equal 'CoreOS 1068.9.0', os.description
+      assert_equal 'stable', os.release_name
+      assert_empty os.ptables
+      assert_empty os.media
+      assert_empty os.os_default_templates
+    end
+
+    context 'with old versions' do
+      setup do
+        FactoryBot.create(:coreos,
+                          :with_associations,
+                          :with_os_defaults,
+                          :major => '899',
+                          :minor => '17.0',
+                          :title => 'CoreOS 899.17.0')
+        @previous = FactoryBot.create(:coreos,
+                                      :with_associations,
+                                      :with_os_defaults,
+                                      :major => '1010',
+                                      :minor => '5.0',
+                                      :title => 'CoreOS 1010.5.0')
+      end
+
+      test 'should copy attributes from previous os version' do
+        assert_equal '1068', os.major
+        assert_equal '9.0', os.minor
+        assert_equal @previous.ptables, os.ptables
+        assert_equal @previous.architectures, os.architectures
+        assert_equal @previous.media, os.media
+        assert_equal @previous.os_default_templates, os.os_default_templates
+      end
+    end
+  end
+end

data/test/unit/omaha_report_test.rb

@@ -2,11 +2,11 @@ require 'test_plugin_helper'
 
 class OmahaReportTest < ActiveSupport::TestCase
   setup do
-    User.current = FactoryGirl.create(:user, :admin)
+    User.current = FactoryBot.create(:user, :admin)
   end
 
   context 'status' do
-    let(:report) { FactoryGirl.build(:omaha_report) }
+    let(:report) { FactoryBot.build(:omaha_report) }
 
     test 'should be complete' do
       report.status = 'complete'
@@ -46,8 +46,8 @@ class OmahaReportTest < ActiveSupport::TestCase
   end
 
   context 'operatingsystem' do
-    let(:os) { FactoryGirl.create(:coreos, :major => '1068', :minor => '9.0') }
-    let(:report) { FactoryGirl.create(:omaha_report) }
+    let(:os) { FactoryBot.create(:coreos, :major => '1068', :minor => '9.0') }
+    let(:report) { FactoryBot.create(:omaha_report) }
 
     test 'should get operatingsystem' do
       assert_equal os, report.operatingsystem
@@ -60,30 +60,76 @@ class OmahaReportTest < ActiveSupport::TestCase
   end
 
   context '#import' do
-    test 'should import a report' do
-      host = FactoryGirl.create(:host)
-      report = {
+    let(:host) { FactoryBot.create(:host) }
+    let(:group) { FactoryBot.create(:omaha_group, :name => 'Stable', :uuid => 'stable') }
+    let(:report_data) do
+      {
         'host' => host.name,
         'status' => 'downloading',
-        'omaha_version' => '1068.9.0',
+        'omaha_version' => '494.5.0',
+        'omaha_group' => 'stable',
+        'machineid' => '8e9450f47a4c47adbfe48b946e201c84',
+        'oem' => 'rackspace',
         'reported_at' => Time.now.utc.to_s
       }
+    end
+
+    test 'should import a report' do
       assert_difference('ForemanOmaha::OmahaReport.count') do
-        ForemanOmaha::OmahaReport.import(report)
+        ForemanOmaha::OmahaReport.import(report_data)
       end
     end
 
     test 'should not import a report with invalid value' do
-      host = FactoryGirl.create(:host)
-      report = {
-        'host' => host.name,
-        'status' => 'invalid',
-        'omaha_version' => '1068.9.0',
-        'reported_at' => Time.now.utc.to_s
-      }
+      report_data['status'] = 'invalid'
       assert_raise ArgumentError do
-        ForemanOmaha::OmahaReport.import(report)
+        ForemanOmaha::OmahaReport.import(report_data)
       end
     end
+
+    test 'should create host omaha facet' do
+      assert_nil host.omaha_facet
+      assert_not_nil group
+      ForemanOmaha::OmahaReport.import(report_data)
+      facet = host.reload.omaha_facet
+      assert_not_nil facet
+      assert_equal host, facet.host
+      assert_equal report_data['reported_at'].to_date, facet.last_report.to_date
+      assert_equal report_data['status'], facet.status
+      assert_equal report_data['machineid'], facet.machineid
+      assert_equal report_data['oem'], facet.oem
+      assert_equal report_data['omaha_version'], facet.version
+      assert_equal group, facet.omaha_group
+    end
+
+    test 'should update host omaha facet' do
+      assert_not_nil group
+      ForemanOmaha::OmahaReport.import(report_data)
+      time = Time.now.advance(seconds: 10).utc.to_s
+      new_report = report_data.merge(
+        'status' => 'complete',
+        'reported_at' => time,
+        'omaha_version' => '1068.9.0'
+      ).except('host')
+      ForemanOmaha::OmahaReport.import(new_report)
+      facet = host.reload.omaha_facet
+      assert_not_nil facet
+      assert_equal host, facet.host
+      assert_equal time.to_date, facet.last_report.to_date
+      assert_equal 'complete', facet.status
+      assert_equal new_report['machineid'], facet.machineid
+      assert_equal 'rackspace', facet.oem
+      assert_equal '1068.9.0', facet.version
+      assert_equal group, facet.omaha_group
+    end
+
+    test 'should detect omaha group by os version' do
+      assert_not_nil group
+      FactoryBot.create(:coreos)
+      ForemanOmaha::OmahaReport.import(report_data.except('omaha_group'))
+      facet = host.reload.omaha_facet
+      assert_not_nil facet
+      assert_equal group, facet.omaha_group
+    end
   end
 end