foreman-tasks 4.0.0 → 5.0.0

data/test/core/unit/task_launcher_test.rb

@@ -1,56 +0,0 @@
-require 'foreman_tasks_core_test_helper'
-require 'foreman_tasks/test_helpers'
-
-module ForemanTasksCore
-  module TaskLauncher
-    class TaskLauncherTest < ActiveSupport::TestCase
-      include ForemanTasks::TestHelpers::WithInThreadExecutor
-
-      describe ForemanTasksCore::TaskLauncher do
-        let(:launcher) { launcher_class.new ForemanTasks.dynflow.world, {} }
-        let(:launcher_input) { { 'action_class' => Support::DummyDynflowAction.to_s, 'action_input' => input } }
-        let(:input) { { :do => :something } }
-        let(:expected_result) { input.merge(:callback_host => {}) }
-
-        describe ForemanTasksCore::TaskLauncher::Single do
-          let(:launcher_class) { Single }
-
-          it 'triggers an action' do
-            Support::DummyDynflowAction.any_instance.expects(:plan).with do |arg|
-              _(arg).must_equal(expected_result)
-            end
-            launcher.launch!(launcher_input)
-          end
-
-          it 'provides results' do
-            plan = launcher.launch!(launcher_input).finished.value!
-            _(launcher.results[:result]).must_equal 'success'
-            _(plan.result).must_equal :success
-          end
-        end
-
-        describe ForemanTasksCore::TaskLauncher::Batch do
-          let(:launcher_class) { Batch }
-
-          it 'triggers the actions' do
-            Support::DummyDynflowAction.any_instance.expects(:plan).with { |arg| arg == expected_result }.twice
-            parent = launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
-            plan = parent.finished.value!
-            _(plan.result).must_equal :success
-            _(plan.sub_plans.count).must_equal 2
-          end
-
-          it 'provides results' do
-            launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
-            _(launcher.results.keys).must_equal %w[foo bar]
-            launcher.results.values.each do |result|
-              plan = ForemanTasks.dynflow.world.persistence.load_execution_plan(result[:task_id])
-              _(result[:result]).must_equal 'success'
-              _(plan.result).must_equal :success
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/test/foreman_tasks_core_test_helper.rb

@@ -1,4 +0,0 @@
-require 'foreman_tasks_test_helper'
-require 'foreman_tasks_core'
-
-ForemanTasksCore.dynflow_setup ForemanTasks.dynflow.world

data/test/unit/otp_manager_test.rb

@@ -1,77 +0,0 @@
-require 'foreman_tasks_test_helper'
-require 'foreman_tasks_core/otp_manager'
-
-module ForemanTasksCore
-  class OtpManagerTest < ActiveSupport::TestCase
-    class TestOtpManager < OtpManager
-      def self.reset!
-        @passwords = nil
-      end
-    end
-
-    def try_to_authenticate(username, password)
-      TestOtpManager.authenticate(OtpManager.tokenize(username, password))
-    end
-
-    before do
-      TestOtpManager.reset!
-    end
-
-    let(:username) { 'myuser' }
-    let(:password) { '123456789' }
-    let(:base64)   { 'bXl1c2VyOjEyMzQ1Njc4OQ==' }
-
-    it 'it doesn\'t raise when no passwords were generated yet' do
-      assert_not try_to_authenticate('missing', 'password')
-    end
-
-    it 'generates OTPs using SecureRandom.hex and converts them to strings' do
-      otp = 4
-      SecureRandom.stubs(:hex).returns(otp)
-      _(TestOtpManager.generate_otp(username)).must_equal otp.to_s
-    end
-
-    it 'provides #drop_otp method that removes OTP only when correct username and password is provided' do
-      otp = TestOtpManager.generate_otp(username)
-      assert_not TestOtpManager.drop_otp('wrong_username', 'wrong_password')
-      assert_not TestOtpManager.drop_otp(username, 'wrong_password')
-      assert_not TestOtpManager.drop_otp('wrong_username', otp)
-      assert TestOtpManager.drop_otp(username, otp)
-    end
-
-    it 'authenticate removes OTP only when correct username and password is provided' do
-      otp = TestOtpManager.generate_otp(username)
-      assert_not try_to_authenticate('wrong_username', 'wrong_password')
-      assert_not try_to_authenticate(username, 'wrong_password')
-      assert_not try_to_authenticate(username, 'wrong_password')
-      assert_not try_to_authenticate('wrong_username', otp)
-      assert try_to_authenticate(username, otp)
-    end
-
-    it 'authenticates correctly' do
-      SecureRandom.stubs(:hex).returns(password)
-      TestOtpManager.generate_otp(username)
-
-      assert TestOtpManager.authenticate(base64)
-    end
-
-    it 'OTPs can be used only once' do
-      SecureRandom.stubs(:hex).returns(password)
-      TestOtpManager.generate_otp(username)
-
-      assert TestOtpManager.authenticate(base64)
-      assert_not TestOtpManager.authenticate(base64)
-    end
-
-    it 'creates token from username and password correctly' do
-      _(TestOtpManager.tokenize(username, password)).must_equal base64
-    end
-
-    it 'overwrites old OTP when generating a new one for the same username' do
-      old = TestOtpManager.generate_otp(username)
-      new = TestOtpManager.generate_otp(username)
-      assert_not try_to_authenticate(username, old)
-      assert try_to_authenticate(username, new)
-    end
-  end
-end