katello-foreman-engine 0.0.1 → 0.0.2

data/katello-foreman-engine.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "katello-foreman-engine"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.authors = ["Katello"]
   s.date = "2013-04-19"
@@ -11,7 +11,6 @@ Gem::Specification.new do |s|
   s.licenses = ["GPL-2"]
   s.require_paths = ["lib"]
   s.add_dependency "foreman_api"
-  s.add_dependency "deface", "~> 0.7.2"
   s.add_dependency "dynflow"
   s.summary = "Foreman specific parts of Katello"
 end

data/lib/katello-foreman-engine.rb

@@ -1,2 +1 @@
-require 'deface'
 require 'katello_foreman_engine'

data/lib/katello_foreman_engine/actions/changeset_promote.rb

@@ -0,0 +1,31 @@
+#
+# Copyright 2013 Red Hat, Inc.
+#
+# This software is licensed to you under the GNU General Public
+# License as published by the Free Software Foundation; either version
+# 2 of the License (GPLv2) or (at your option) any later version.
+# There is NO WARRANTY for this software, express or implied,
+# including the implied warranties of MERCHANTABILITY,
+# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+# have received a copy of GPLv2 along with this software; if not, see
+# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+
+module KatelloForemanEngine
+  module Actions
+
+    class ChangesetPromote < Dynflow::Action
+
+      def self.subscribe
+        Katello::Actions::ChangesetPromote
+      end
+
+      def plan(changeset)
+        changeset.affected_repos.each do |repo|
+          repo = repo.get_clone(changeset.environment)
+          plan_action(RepositoryChange, repo)
+        end
+      end
+
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/content_view_promote.rb

@@ -6,10 +6,13 @@ module KatelloForemanEngine
         Katello::Actions::ContentViewPromote
       end
 
-      def plan(*args)
+      def plan(content_view, from_env, to_env)
         unless Bindings.environment_find(input['organization_label'], input['to_env_label'], input['label'])
           plan_self input
         end
+        content_view.repos(to_env) do |repo|
+          plan_action(RepositoryChange, repo)
+        end
       end
 
       input_format do

data/lib/katello_foreman_engine/actions/distribution_publish.rb

@@ -0,0 +1,104 @@
+module KatelloForemanEngine
+  module Actions
+    class DistributionPublish < Dynflow::Action
+
+      input_format do
+        param :family, String,  "Example: Red Hat Enterprise Linux"
+        param :variant, String, "Example: Server"
+        param :arch, String,    "Example: x86_64"
+        param :version, String, "Example: 6.3"
+        param :repo, Hash do
+          param :pulp_id
+          param :uri, String, "Example: https://example.com/pulp/repos/org/env/pr/os/"
+          param :label
+          param :product_label
+          param :content_view_label
+          param :environment_label
+          param :organization_label
+        end
+      end
+
+      def run
+        medium_name = construct_medium_name
+        medium_path = Helpers.installation_media_path(input['repo']['uri'])
+        return if Bindings.medium_find(medium_path)
+
+        arch = find_or_create_arch
+        os = find_or_create_operating_system
+        assign_arch_to_os(os, arch)
+        medium = Bindings.medium_create(medium_name, medium_path)
+        assign_medium_to_os(os, medium)
+      end
+
+      private
+
+      def find_or_create_arch
+        arch = Bindings.architecture_find(input['arch']) ||
+          Bindings.architecture_create(input['arch'])
+        return arch
+      end
+
+      def find_or_create_operating_system
+        os_name = construct_operating_system_name
+        major, minor = input['version'].split('.')
+
+        os = Bindings.operating_system_find(os_name, major, minor)
+        unless os
+          os = Bindings.operating_system_create(os_name, major, minor)
+        end
+
+        return os
+      end
+
+      def assign_arch_to_os(os, arch)
+        if os['architectures']
+          arch_ids = os['architectures'].map { |a| a['architecture']['id'] }
+        else
+          arch_ids = []
+        end
+        unless arch_ids.include?(arch['id'])
+          arch_ids << arch['id']
+          data = {'architecture_ids' => arch_ids}
+          Bindings.operating_system_update(os['id'], data)
+        end
+      end
+
+      def assign_medium_to_os(os, medium)
+        if os['media']
+          medium_ids = os['media'].map { |a| a['medium']['id'] }
+        else
+          medium_ids = []
+        end
+        unless medium_ids.include?(medium['id'])
+          medium_ids << medium['id']
+          data = {'medium_ids' => medium_ids}
+          Bindings.operating_system_update(os['id'], data)
+        end
+      end
+
+
+      def construct_medium_name
+        parts = []
+        parts << [
+                  input['repo']['organization_label'],
+                  input['repo']['environment_label'],
+                  input['repo']['content_view_label']
+                 ].compact.join('/')
+        parts << input['family']
+        parts << input['variant']
+        parts << input['version']
+        parts << input['arch']
+        name = parts.join(' ')
+        # we need to make the name a bit shorter to get under 50
+        # charatcers for medium name
+        name.sub!('Red Hat Enterprise Linux','RHEL')
+        return name
+      end
+
+      def construct_operating_system_name
+        [input['family'], input['variant']].join(' ').gsub(' ', '_')
+      end
+
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/distribution_unpublish.rb

@@ -0,0 +1,26 @@
+module KatelloForemanEngine
+  module Actions
+    class DistributionUnpublish < Dynflow::Action
+
+      def self.subscribe
+        Katello::Actions::RepositoryDestroy
+      end
+
+      input_format do
+        param :medium_id, String
+      end
+
+      def plan(repo)
+        path = Helpers.installation_media_path(repo.uri)
+        if medium = Bindings.medium_find(path)
+          plan_self('medium_id' => medium['id'])
+        end
+      end
+
+      def run
+        Bindings.medium_destroy(input['medium_id'])
+      end
+
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/repository_change.rb

@@ -0,0 +1,50 @@
+#
+# Copyright 2013 Red Hat, Inc.
+#
+# This software is licensed to you under the GNU General Public
+# License as published by the Free Software Foundation; either version
+# 2 of the License (GPLv2) or (at your option) any later version.
+# There is NO WARRANTY for this software, express or implied,
+# including the implied warranties of MERCHANTABILITY,
+# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+# have received a copy of GPLv2 along with this software; if not, see
+# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+
+module KatelloForemanEngine
+  module Actions
+
+    class RepositoryChange < Dynflow::Action
+
+      def plan(repo)
+        if repo.distributions.empty?
+          # no distributions, no instalation media
+          plan_action(DistributionUnpublish, repo)
+        elsif(repo.unprotected)
+          repo_info = {
+            'pulp_id' => repo.pulp_id,
+            'uri' => repo.uri,
+            'label'   => repo.label,
+            'product_label'   => repo.product.label,
+            'environment_label'   => repo.environment.label,
+            'organization_label'   => repo.organization.label
+          }
+
+          if repo.content_view && !repo.content_view.default?
+            repo_info['content_view_label'] = repo.content_view.label
+          end
+
+          # Foreman's installation media don't distinguish between
+          # different variants. Using just a first one.
+          distribution = repo.distributions.first
+          plan_action(DistributionPublish,
+                      { 'repo' => repo_info,
+                        'family' => distribution.family,
+                        'variant' => distribution.variant,
+                        'arch' => distribution.arch,
+                        'version' => distribution.version })
+        end
+      end
+
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/user_destroy.rb

@@ -8,7 +8,7 @@ module KatelloForemanEngine
 
       def plan(user)
         if foreman_user = Bindings.user_find(input['username'])
-          plan_self 'foreman_user_id' => foreman_user['user']['id']
+          plan_self 'foreman_user_id' => foreman_user['id']
         end
       end
 

data/lib/katello_foreman_engine/bindings.rb

@@ -24,6 +24,26 @@ module KatelloForemanEngine
         resource(ForemanApi::Resources::Environment)
       end
 
+      def architecture
+        resource(ForemanApi::Resources::Architecture)
+      end
+
+      def ptable
+        resource(ForemanApi::Resources::Ptable)
+      end
+
+      def operating_system
+        resource(ForemanApi::Resources::OperatingSystem)
+      end
+
+      def config_template
+        resource(ForemanApi::Resources::ConfigTemplate)
+      end
+
+      def medium
+        resource(ForemanApi::Resources::Medium)
+      end
+
       def user(username = nil)
         user_resource = resource(ForemanApi::Resources::User)
         if username && User.current.username == username
@@ -34,12 +54,6 @@ module KatelloForemanEngine
         return user_resource
       end
 
-      def resource(resource_class)
-        client = resource_class.new(client_config)
-        client.client.options[:headers][:foreman_user] = User.current.username
-        return client
-      end
-
       def organization_find(name)
         orgs, _ = base.http_call('get', '/api/organizations', 'search' => "name = #{name}")
         return orgs.first
@@ -77,8 +91,7 @@ module KatelloForemanEngine
       end
 
       def user_find(username)
-        users, _ = user(username).index('search' => "login = #{username}")
-        return users.first
+        find_resource(user(username), "login = #{username}")
       end
 
       def user_create(username, email)
@@ -93,6 +106,121 @@ module KatelloForemanEngine
         user.destroy('id' => id)
       end
 
+      def architecture_find(name)
+        find_resource(architecture, "name = #{name}")
+      end
+
+      def architecture_create(name)
+        without_root_key { architecture.create('architecture' => {'name' => name}) }
+      end
+
+      def operating_system_find(name, major, minor)
+        find_resource(operating_system, "name = #{name} AND major = #{major} AND minor = #{minor}")
+      end
+
+      def operating_system_create(name, major, minor)
+        data = {
+          'name' => name,
+          'major' => major.to_s,
+          'minor' => minor.to_s,
+          'family' => Settings['foreman_os_family']
+        }
+        templates_to_add = [template_find(Settings['foreman_os_provisioning_template']),
+                            template_find(Settings['foreman_os_pxe_template'])].compact
+        data['os_default_templates_attributes'] = templates_to_add.map do |template|
+          {
+            "config_template_id" => template["id"],
+            "template_kind_id" => template["template_kind"]["id"],
+          }
+        end
+
+        if ptable = ptable_find(Settings['foreman_os_ptable'])
+          data['ptable_ids'] = [ptable['id']]
+        end
+
+        os = without_root_key { operating_system.create('operatingsystem' => data) }
+
+        oss, _ = operating_system.index
+        os_ids = oss.map { |o| o['operatingsystem']['id'] }
+        templates_to_add.each do |template|
+          # Because of http://projects.theforeman.org/issues/2500 we
+          # have not way to add only the created os to the template.
+          # As a workaround, we add all os to the template for now.
+          config_template.update("id" => template['id'],
+                                 'config_template' => {
+                                   "operatingsystem_ids" => os_ids
+                                 })
+        end
+        return os
+      end
+
+      def operating_system_update(id, data)
+        without_root_key do
+          operating_system.update('id' => id, 'operatingsystem' => data)
+        end
+      end
+
+      def template_find(name)
+        find_resource(config_template, %{name = "#{name}"})
+      end
+
+      def medium_find(path)
+        find_resource(medium, %{path = "#{path}"})
+      end
+
+      def medium_create(name, path)
+        without_root_key do
+          self.medium.create('medium' => {
+                               'name' => name,
+                               'path' => path,
+                               'os_family' => Settings['foreman_os_family']})
+        end
+      end
+
+      def medium_destroy(id)
+        self.medium.destroy('id' => id)
+      end
+
+      def ptable_find(name)
+        find_resource(ptable, %{name = "#{name}"})
+      end
+
+      private
+
+      # configure resource client to be used to call Foreman.
+      # We need to do this for every resoruce right now.
+      # We might improve this on foreman_api side later.
+      def resource(resource_class)
+        client = resource_class.new(client_config)
+        client.client.options[:headers][:foreman_user] = User.current.username
+        return client
+      end
+
+      # From Foreman, the resource comes in form:
+      #
+      #   { 'resource' => { 'attr1' => 'val1', 'attr2' => 'val2' } }
+      #
+      # this method returns only the body, i.e.:
+      #
+      #   { 'attr1' => 'val1', 'attr2' => 'val2' }
+      #
+      # If block given, it expects the call to foreman_api from that
+      #
+      # We might improve this on foreman_api side later
+      def without_root_key(resource_hash = nil, &block)
+        if block
+          resource_hash, _ = yield
+        end
+        if resource_hash
+          resource_hash.values.first
+        end
+      end
+
+      def find_resource(resource, search_query)
+        results, _ =  resource.index('search' => search_query)
+        return without_root_key(results.first)
+      end
+
     end
   end
 

data/lib/katello_foreman_engine/engine.rb

@@ -4,6 +4,7 @@ module KatelloForemanEngine
   class Engine < ::Rails::Engine
 
     config.after_initialize do
+      require 'katello_foreman_engine/helpers'
       require 'katello_foreman_engine/settings'
       Settings.initialize_settings
       require 'katello_foreman_engine/bindings'

data/lib/katello_foreman_engine/helpers.rb

@@ -0,0 +1,15 @@
+module KatelloForemanEngine
+  module Helpers
+    class << self
+
+      # takes repo uri from Katello and makes installation media url
+      # suitable for provisioning from it
+      def installation_media_path(repo_uri)
+        path = repo_uri.sub(/\Ahttps/, 'http')
+        path << "/" unless path.end_with?('/')
+        return path
+      end
+    end
+
+  end
+end

data/lib/katello_foreman_engine/settings.rb

@@ -5,7 +5,12 @@ module KatelloForemanEngine
       @settings = {
         'foreman_url' => Katello.config.foreman.url.sub(/\/+\Z/,''),
         'oauth_consumer_key' => Katello.config.foreman.oauth_key,
-        'oauth_consumer_secret' => Katello.config.foreman.oauth_secret
+        'oauth_consumer_secret' => Katello.config.foreman.oauth_secret,
+        # TODO: make the following options configurable:
+        'foreman_os_family' => 'Redhat',
+        'foreman_os_provisioning_template' => 'Katello Kickstart Default',
+        'foreman_os_pxe_template' => 'Kickstart default PXElinux',
+        'foreman_os_ptable' => 'RedHat default',
       }
     end
 

data/test/lib/actions/distribution_publish_test.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class DistributionPublishTest < ActiveSupport::TestCase
+
+      def setup
+        @input = {
+          'family' => 'Red Hat Enterprise Linux',
+          'variant' => 'Server',
+          'arch' => 'x86_64',
+          'version' => '6.3',
+          'repo' => {
+            'pulp_id' => 'Org-Env-Prod-Repo',
+            'uri' => 'http://example.com/pulp/repos/os/',
+            'label' => 'Repo',
+            'product_label' => 'Prod',
+            'environment_label' => 'Env',
+            'organization_label' => 'Org'
+          }
+        }
+
+        @arch = 'x86_64'
+        @os_name = 'Red_Hat_Enterprise_Linux_Server'
+        @os_major = '6'
+        @os_minor = '3'
+
+        @medium_name = 'Org/Env Red Hat Enterprise Linux Server 6.3 x86_64'
+        @medium_path = 'http://example.com/pulp/repos/os/'
+
+        @arch_output = {'architecture' => { 'id' => 1, 'name' => @arch }}
+        @ptable_output = {'ptable' => { 'id' => 1, 'name' => 'RedHat default' }}
+        @os_output = {
+          'operatingsystem' => {
+            'id' => 1,
+            'name' => @os_name,
+            'major' => @os_major,
+            'minor' => @os_minor,
+            'family' => 'RedHat',
+            'architectures' => [@arch_output],
+            'media' => [],
+            'ptables' => [@ptable_output],
+          }
+        }
+        @medium_output = {
+          'medium' => {
+            'id' => 1,
+            'name' => @medium_name,
+            'path' => @medium_path
+          }
+        }
+
+        stub_foreman_search(:architecture, "name = #{@arch}", @arch_output)
+        stub_foreman_search(:ptable, %{name = "RedHat default"}, @ptable_output)
+        stub_foreman_call(:medium, :index, nil, [])
+        stub_foreman_call(:medium, :create, nil, @medium_output)
+        stub_foreman_call(:operating_system, :index, nil, [])
+        stub_foreman_call(:operating_system, :create, nil, @os_output)
+        stub_foreman_call(:operating_system, :update)
+        stub_foreman_search(:config_template, %{name = "Katello Kickstart Default"}, nil)
+        stub_foreman_search(:config_template, %{name = "Kickstart default PXElinux"}, nil)
+        stub_foreman_search(:ptable, %{name = "RedHat default"}, nil)
+        stub_foreman_call(:operating_system, :index, nil, [])
+      end
+
+      def run_action
+        action = DistributionPublish.new(@input)
+        action.run
+        return action
+      end
+
+      test "creates architecture in foreman if not created yet" do
+        stub_foreman_search(:architecture, "name = #{@arch}", nil)
+        expect_foreman_call(:architecture, :create, {'name' => @arch}, @arch_output)
+        run_action
+      end
+
+      test "creates operating system in foreman if not created yet" do
+        stub_foreman_search(:operating_system, "name = #{@os_name} AND major = #{@os_major} AND minor = #{@os_minor}", nil)
+        os_data = {
+          'name' => @os_name,
+          'major' => @os_major.to_s,
+          'minor' => @os_minor.to_s,
+          'family' => 'Redhat',
+          'os_default_templates_attributes' => [],
+        }
+        expect_foreman_call(:operating_system, :create, os_data, @os_output)
+        run_action
+      end
+
+      test "creates sets minor version empty if missing" do
+        stub_foreman_search(:operating_system, "name = #{@os_name} AND major = #{@os_major} AND minor = ", nil)
+        os_data = {
+          'name' => @os_name,
+          'major' => @os_major.to_s,
+          'minor' => '',
+          'family' => 'Redhat',
+          'os_default_templates_attributes' => [],
+        }
+        expect_foreman_call(:operating_system, :create, os_data, @os_output)
+        @input['version'] = '6'
+        run_action
+      end
+
+      test "assigns architecture to operating system if not assigned yet" do
+        os_without_arch = {
+          'operatingsystem' => @os_output['operatingsystem'].merge('architectures' => [])
+        }
+        stub_foreman_search(:operating_system, "name = #{@os_name} AND major = #{@os_major} AND minor = #{@os_minor}", os_without_arch)
+        expected_data = {'id' => 1, 'architecture_ids' => [@arch_output['architecture']['id']]}
+        expect_foreman_call(:operating_system, :update,  expected_data)
+        run_action
+      end
+
+      test "creates medium and assigns it to the os in not created yet" do
+        expect_foreman_call(:medium, :create, {'name' => @medium_name, 'path' => @medium_path, 'os_family' => 'Redhat'}, @medium_output)
+        expected_data = {'id' => 1, 'medium_ids' => [@medium_output['medium']['id']]}
+        expect_foreman_call(:operating_system, :update,  expected_data)
+        run_action
+      end
+
+    end
+  end
+end

data/test/lib/actions/distribution_unpublish_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class DistributionUnpublishTest < ActiveSupport::TestCase
+
+      def setup
+        @https_path = "https://example.com/my/repo"
+        @http_path = "http://example.com/my/repo/"
+        @medium_output = {'medium' => {'id' => '123'}}
+        @repo = stub(:uri => @https_path)
+      end
+
+      test "deletes the instalation media using the repo" do
+        stub_foreman_search(:medium, %{path = "#{@http_path}"}, @medium_output)
+        step = run_steps(DistributionUnpublish, {}, @repo).first
+        assert_equal DistributionUnpublish, step.action_class
+        assert_equal({'medium_id' => '123'}, step.input)
+      end
+
+      test "does nothing if the installation media is not present" do
+        stub_foreman_search(:medium, %{path = "#{@http_path}"}, [])
+        assert_equal [], run_steps(DistributionUnpublish, {}, @repo)
+      end
+
+      test 'calls bindings to destroy environment' do
+        expect_foreman_call(:medium, :destroy, {'id' => '123'})
+        DistributionUnpublish.new('medium_id' => '123').run
+      end
+
+    end
+  end
+end

data/test/lib/actions/{env_create.rb → env_create_test.rb}

@@ -10,21 +10,19 @@ module KatelloForemanEngine
         env.organization = org
 
         env.library = false
-        plan = prepare_plan(EnvCreate, {}, env)
-        step = plan.run_steps.first
-        assert_equal EnvCreate, step.action_class
-        assert_equal step.input['org_label'], 'org'
-        assert_equal step.input['label'], 'dev'
-        assert_equal step.input['cv_id'], 'env'
+        step = run_steps(EnvironmentCreate, {}, env).first
+        assert_equal EnvironmentCreate, step.action_class
+        assert_equal 'org', step.input['org_label']
+        assert_equal 'dev', step.input['label']
+        assert_equal 'env', step.input['content_view_id']
 
         env.library = true
-        plan = prepare_plan(EnvCreate, {}, env)
-        assert_equal [], plan.run_steps
+        assert_equal [], run_steps(EnvironmentCreate, {}, env)
       end
 
       test 'calls bindings to create environment' do
         Bindings.expects(:environment_create).with('env', 'org', 'dev')
-        EnvCreate.new('org_label' => 'org', 'label' => 'dev', 'cv_id' => 'env').run
+        EnvironmentCreate.new('org_label' => 'org', 'label' => 'dev', 'content_view_id' => 'env').run
       end
 
     end

data/test/lib/actions/{env_destroy.rb → env_destroy_test.rb}

@@ -13,24 +13,21 @@ module KatelloForemanEngine
         Bindings.expects(:environment_find).with('org', 'dev').returns(foreman_env)
 
         env.library = false
-        plan = prepare_plan(EnvDestroy,{}, env)
-        step = plan.run_steps.first
-        assert_equal EnvDestroy, step.action_class
+        step = run_steps(EnvironmentDestroy,{}, env).first
+        assert_equal EnvironmentDestroy, step.action_class
         assert_equal step.input['foreman_id'], '123'
 
         env.library = true
-        plan = prepare_plan(EnvDestroy, {}, env)
-        assert_equal [], plan.run_steps
+        assert_equal [], run_steps(EnvironmentDestroy,{}, env)
 
         env.library = false
         Bindings.expects(:environment_find).returns(nil)
-        plan = prepare_plan(EnvDestroy, {}, env)
-        assert_equal [], plan.run_steps
+        assert_equal [], run_steps(EnvironmentDestroy,{}, env)
       end
 
       test 'calls bindings to destroy environment' do
         Bindings.expects(:environment_destroy).with('123')
-        EnvDestroy.new('foreman_id' => '123').run
+        EnvironmentDestroy.new('foreman_id' => '123').run
       end
 
     end

data/test/lib/actions/{org_destroy.rb → org_destroy_test.rb}

@@ -7,14 +7,12 @@ module KatelloForemanEngine
       test "runs only when the org is present in Foreman" do
         foreman_org = { 'organization' => { 'id' => '123' } }
         Bindings.expects(:organization_find).with('KT-[test]').returns(foreman_org)
-        plan = prepare_plan(OrgDestroy, {'label' => 'test'}, nil)
-        step = plan.run_steps.first
+        step = run_steps(OrgDestroy, {'label' => 'test'}, nil).first
         assert_equal OrgDestroy, step.action_class
         assert_equal step.input['foreman_id'], '123'
 
         Bindings.expects(:organization_find).returns(nil)
-        plan = prepare_plan(OrgDestroy, {'label' => 'test'}, nil)
-        assert_equal [], plan.run_steps
+        assert_equal [], run_steps(OrgDestroy, {'label' => 'test'}, nil)
       end
 
       test 'calls bindings to destroy organization' do

data/test/lib/actions/repository_change_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class RepositoryChangeTest < ActiveSupport::TestCase
+
+      def setup
+        @repo_with_distros = stub(:unprotected => true,
+                                  :distributions => [stub('family'  => 'Family',
+                                                          'variant' => 'Variant',
+                                                          'arch'    => 'Arch',
+                                                          'version' => 'Version')],
+                                  :pulp_id => 'pulp_id',
+                                  :uri     => 'https://example.com/repo/uri',
+                                  :label   => 'label',
+                                  :product => stub(:label => 'product_label'),
+                                  :content_view => stub(:default? => true, :label => 'cv'),
+                                  :environment => stub(:label => 'environment_label'),
+                                  :organization => stub(:label => 'organization_label'))
+
+        @expected_publish_input = {
+          "repo"=>
+          {
+            "pulp_id"=>"pulp_id",
+            "uri"=>"https://example.com/repo/uri",
+            "label"=>"label",
+            "product_label"=>"product_label",
+            "environment_label"=>"environment_label",
+            "organization_label"=>"organization_label"
+          },
+          "family"=>"Family",
+          "variant"=>"Variant",
+          "arch"=>"Arch",
+          "version"=>"Version"
+        }
+      end
+
+      test "plans repository unpublish if no distros found for the repo" do
+        repo = stub(:distributions => [])
+        action_class, arg = planned_actions(RepositoryChange, {}, repo).first
+        assert_equal DistributionUnpublish, action_class
+        assert_equal repo, arg
+      end
+
+      test "plans distribution publish if repo is unprotected and has distirbutions" do
+        action_class, input = planned_actions(RepositoryChange, {}, @repo_with_distros).first
+        assert_equal DistributionPublish, action_class
+        assert_equal @expected_publish_input, input
+      end
+
+      test "passes the content view label unless repo in default content view" do
+        @repo_with_distros.content_view.stubs(:default? => false)
+        action_class, input = planned_actions(RepositoryChange, {}, @repo_with_distros).first
+        assert_equal DistributionPublish, action_class
+        @expected_publish_input['repo']['content_view_label'] = 'cv'
+        assert_equal input, @expected_publish_input
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -11,10 +11,67 @@ require 'mocha/setup'
 
 Rails.backtrace_cleaner.remove_silencers!
 
-# returns the execution plan for given action, given
+# returns the subactions being planned from the plan method of
+# +action_class+. It prevents calling plan methods on the subactions,
+# letting to test only the action_class in isolation.
+def planned_actions(action_class, input, *args)
+  planned_actions = []
+  action = action_class.new(input)
+  action.stubs(:plan_action).with do |*args|
+    planned_actions << args
+  end
+  action.plan(*args)
+  return planned_actions
+end
+
+# returns the run steps planned for given action, given
 # input from parent action and *args for plan method
-def prepare_plan(action_class, input, *args)
+def run_steps(action_class, input, *args)
   action = action_class.new(input)
   action.plan(*args)
-  return action.execution_plan
+  return action.execution_plan.run_steps
+end
+
+def expect_foreman_search(*args)
+  args = args + [true]
+  stub_foreman_search(*args)
+end
+
+def stub_foreman_search(resource, search, response, expect = false)
+  response = case response
+             when nil
+               []
+             when Array
+               response
+             else
+               [response]
+             end
+  stub_foreman_call(resource, :index, {'search' => search}, response, expect)
+end
+
+def expect_foreman_call(*args)
+  args = args + [true]
+  stub_foreman_call(*args)
+end
+
+def stub_foreman_call(resource, action, request = nil, response = nil, expect = false)
+  setup_user
+  resource_key = resource.to_s
+  # difference between class name and resource key in the API
+  resource_key.gsub!('_','') if resource_key == 'operating_system'
+  if request && [:create, :update].include?(action) && !request.has_key?(resource_key)
+    request = {resource_key => request}
+  end
+  resource_class ="ForemanApi::Resources::#{resource.to_s.camelize}".constantize
+  stub = resource_class.any_instance.stubs(action)
+  if request
+    stub.with(request)
+  end
+  if response
+    stub.returns([response, response.to_json])
+  end
+end
+
+def setup_user
+  User.current ||= User.new(:username => 'admin')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: katello-foreman-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -27,22 +27,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: deface
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.7.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: dynflow
   requirement: !ruby/object:Gem::Requirement
@@ -72,22 +56,30 @@ files:
 - katello-foreman-engine.gemspec
 - lib/katello-foreman-engine.rb
 - lib/katello_foreman_engine.rb
+- lib/katello_foreman_engine/actions/changeset_promote.rb
 - lib/katello_foreman_engine/actions/content_view_demote.rb
 - lib/katello_foreman_engine/actions/content_view_promote.rb
+- lib/katello_foreman_engine/actions/distribution_publish.rb
+- lib/katello_foreman_engine/actions/distribution_unpublish.rb
 - lib/katello_foreman_engine/actions/environment_create.rb
 - lib/katello_foreman_engine/actions/environment_destroy.rb
 - lib/katello_foreman_engine/actions/org_create.rb
 - lib/katello_foreman_engine/actions/org_destroy.rb
+- lib/katello_foreman_engine/actions/repository_change.rb
 - lib/katello_foreman_engine/actions/user_create.rb
 - lib/katello_foreman_engine/actions/user_destroy.rb
 - lib/katello_foreman_engine/bindings.rb
 - lib/katello_foreman_engine/engine.rb
+- lib/katello_foreman_engine/helpers.rb
 - lib/katello_foreman_engine/settings.rb
 - script/rails
-- test/lib/actions/env_create.rb
-- test/lib/actions/env_destroy.rb
-- test/lib/actions/org_create.rb
-- test/lib/actions/org_destroy.rb
+- test/lib/actions/distribution_publish_test.rb
+- test/lib/actions/distribution_unpublish_test.rb
+- test/lib/actions/env_create_test.rb
+- test/lib/actions/env_destroy_test.rb
+- test/lib/actions/org_create_test.rb
+- test/lib/actions/org_destroy_test.rb
+- test/lib/actions/repository_change_test.rb
 - test/lib/bindings_test.rb
 - test/lib/settings_test.rb
 - test/test_helper.rb