foreman_opentofu 0.0.1

data/lib/foreman_opentofu/provider_types/nutanix.rb

@@ -0,0 +1,6 @@
+# FIXME: should not be necessary due to autoloading :-(
+require "#{ForemanOpentofu::Engine.root}/app/services/foreman_opentofu/provider_type_manager"
+require "#{ForemanOpentofu::Engine.root}/app/services/foreman_opentofu/provider_type"
+
+ForemanOpentofu::ProviderTypeManager.register('nutanix') do
+end

data/lib/foreman_opentofu/provider_types/ovirt.rb

@@ -0,0 +1,2 @@
+ForemanOpentofu::ProviderTypeManager.register('ovirt') do
+end

data/lib/foreman_opentofu/provider_types.rb

@@ -0,0 +1,3 @@
+Dir["#{File.expand_path('provider_types', __dir__)}/*.rb"].each do |file|
+  load file
+end

data/lib/foreman_opentofu/version.rb

@@ -0,0 +1,3 @@
+module ForemanOpentofu
+  VERSION = '0.0.1'.freeze
+end

data/lib/foreman_opentofu.rb

@@ -0,0 +1,6 @@
+require 'deface'
+
+module ForemanOpentofu
+  require 'foreman_opentofu/version'
+  require 'foreman_opentofu/engine'
+end

data/lib/tasks/foreman_opentofu_tasks.rake

@@ -0,0 +1,30 @@
+require 'rake/testtask'
+
+# Tasks
+namespace :foreman_opentofu do
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    # details are handled in .rubocop.yml
+    task.patterns = [ForemanOpentofu::Engine.root.to_s]
+  end
+rescue LoadError => e
+  raise e unless Rails.env.production?
+end
+
+# Tests
+namespace :test do
+  desc 'Test ForemanOpentofu'
+  Rake::TestTask.new(:foreman_opentofu) do |t|
+    test_dir = File.expand_path('../../test', __dir__)
+    t.libs << 'test'
+    t.libs << test_dir
+    t.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+    t.warning = false
+  end
+end
+
+Rake::Task[:test].enhance ['test:foreman_opentofu']
+
+load 'tasks/jenkins.rake'
+Rake::Task['jenkins:unit'].enhance ['test:foreman_opentofu', 'foreman_opentofu:rubocop'] if Rake::Task.task_defined?(:'jenkins:unit')

data/locale/Makefile

@@ -0,0 +1,73 @@
+#
+# Makefile for PO merging and MO generation. More info in the README.
+#
+# make all-mo (default) - generate MO files
+# make check - check translations using translate-tool
+# make tx-update - download and merge translations from Transifex
+# make clean - clean everything
+#
+DOMAIN = $(shell ruby -rrubygems -e 'puts Gem::Specification::load(Dir.glob("../*.gemspec")[0]).name')
+VERSION = $(shell ruby -rrubygems -e 'puts Gem::Specification::load(Dir.glob("../*.gemspec")[0]).version')
+POTFILE = $(DOMAIN).pot
+MOFILE = $(DOMAIN).mo
+POFILES = $(shell find . -name '$(DOMAIN).po')
+MOFILES = $(patsubst %.po,%.mo,$(POFILES))
+POXFILES = $(patsubst %.po,%.pox,$(POFILES))
+EDITFILES = $(patsubst %.po,%.edit.po,$(POFILES))
+JSFILES = $(shell find ../app/assets/javascripts/*/locale -name '$(DOMAIN).js')
+
+%.mo: %.po
+	mkdir -p $(shell dirname $@)/LC_MESSAGES
+	msgfmt -o $(shell dirname $@)/LC_MESSAGES/$(MOFILE) $<
+
+# Generate MO files from PO files
+all-mo: $(MOFILES)
+
+# Check for malformed strings
+%.pox: %.po
+	msgfmt -c $<
+	pofilter --nofuzzy -t variables -t blank -t urls -t emails -t long -t newlines \
+		-t endwhitespace -t endpunc -t puncspacing -t options -t printf -t validchars --gnome $< > $@
+	cat $@
+	! grep -q msgid $@
+
+%.edit.po: %.po.time_stamp
+	touch $@
+
+# gettext will trash the .edit.po file if the time stamp doesn't exist or is older than the po file
+%.po.time_stamp: %.po
+	touch --reference $< $@
+
+# Prevent make from treating this as an intermediate file to be cleaned up
+.PRECIOUS: %.po.time_stamp
+
+check: $(POXFILES)
+
+# Unify duplicate translations
+uniq-po:
+	for f in $(shell find ./ -name "*.po") ; do \
+		msguniq $$f -o $$f ; \
+	done
+
+tx-pull: $(EDITFILES)
+	# Initialize new languages
+	cd .. && tx pull -f --all --minimum-perc 50
+	# Force update all existing languages
+	cd .. && tx pull -f --minimum-perc 0
+	for f in $(EDITFILES) ; do \
+		sed -i 's/^\("Project-Id-Version: \).*$$/\1$(DOMAIN) $(VERSION)\\n"/' $$f; \
+	done
+
+tx-update: tx-pull
+	@echo
+	@echo Run rake plugin:gettext[$(DOMAIN)] from the Foreman installation
+	@echo then run rake plugin:po_to_json[$(DOMAIN)] from the Foreman installation
+	@echo then run make -C locale mo-files to finish
+	@echo
+
+mo-files: $(MOFILES)
+	git add $(POFILES) $(POTFILE) $(JSFILES) ../locale/*/LC_MESSAGES
+	git commit -m "i18n - pulling from tx"
+	@echo
+	@echo Changes commited!
+	@echo

data/locale/en/foreman_opentofu.po

@@ -0,0 +1,19 @@
+# foreman_opentofu
+#
+# This file is distributed under the same license as foreman_opentofu.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: version 0.0.1\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-08-20 08:46+0100\n"
+"PO-Revision-Date: 2014-08-20 08:54+0100\n"
+"Last-Translator: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language-Team: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+

data/locale/foreman_opentofu.pot

@@ -0,0 +1,19 @@
+# foreman_opentofu
+#
+# This file is distributed under the same license as foreman_opentofu.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: version 0.0.1\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2014-08-20 08:46+0100\n"
+"PO-Revision-Date: 2014-08-20 08:46+0100\n"
+"Last-Translator: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language-Team: Foreman Team <foreman-dev@googlegroups.com>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
+

data/locale/gemspec.rb

@@ -0,0 +1,2 @@
+# Matches foreman_opentofu.gemspec
+_('TODO: Description of ForemanPluginTemplate.')

data/test/controllers/api/v2/tf_states_controller_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Api
+  module V2
+    class TfStatesControllerTest < ActionController::TestCase
+      setup do
+        @tf_one = FactoryBot.create(:tf_state)
+        @tf_two = FactoryBot.create(:tf_state)
+      end
+
+      test 'should show tf_state when present' do
+        get :show, params: { name: @tf_one.name }
+
+        assert_response :success
+        assert_equal 'application/json; charset=utf-8', @response.content_type
+
+        body = ActiveSupport::JSON.decode(@response.body)
+        assert_equal 'bar', body['foo']
+      end
+
+      test 'should return 404 when tf_state is missing' do
+        get :show, params: { name: 'missing-vm' }
+
+        assert_response :not_found
+        assert_equal '', @response.body
+      end
+
+      test 'should create tf_state with valid json body' do
+        attrs = { hello: 'world' }
+        assert_difference('ForemanOpentofu::TfState.count', 1) do
+          @request.env['CONTENT_TYPE'] = 'application/json'
+          post :create, params: { name: 'new-vm' }, body: attrs.to_json
+        end
+
+        assert_response :success
+
+        tf_state = ForemanOpentofu::TfState.find_by(name: 'new-vm')
+        assert_not_nil tf_state
+        assert_equal 'world', ActiveSupport::JSON.decode(tf_state.state)['hello']
+      end
+
+      test 'should update tf_state when already exists' do
+        post :create, params: { name: @tf_one.name }, body: { updated: true }.to_json
+
+        assert_response :success
+
+        assert ActiveSupport::JSON.decode(@tf_one.reload.state)['updated']
+      end
+
+      test 'should destroy tf_state when present' do
+        assert_difference('ForemanOpentofu::TfState.count', -1) do
+          delete :destroy, params: { name: @tf_two.name }
+        end
+
+        assert_response :success
+      end
+
+      test 'should return ok when destroying missing tf_state' do
+        assert_no_difference('ForemanOpentofu::TfState.count') do
+          delete :destroy, params: { name: 'missing-vm' }
+        end
+
+        assert_response :success
+      end
+    end
+  end
+end

data/test/factories/compute_resources.rb

@@ -0,0 +1,26 @@
+FactoryBot.modify do
+  factory :compute_resource do
+    provider { 'Tofu' }
+
+    trait :opentofu_nutanix do
+      opentofu_provider { :nutanix }
+      user { 'nuser' }
+      password { 'npassword' }
+      sequence(:url) { |n| "#{n}.example.com" }
+      # uuid { 'vdatacenter' } # alias for datacenter
+      # after(:build) { |cr| cr.stubs(:update_public_key) }
+    end
+
+    trait :opentofu_ovirt do
+      opentofu_provider { :ovirt }
+      user { 'ovuser' }
+      password { 'ovpassword' }
+      sequence(:url) { |n| "#{n}.example.com" }
+    end
+  end
+end
+
+FactoryBot.define do
+  factory :opentofu_nutanix_cr, parent: :compute_resource, class: ForemanOpentofu::Tofu, traits: [:opentofu_nutanix]
+  factory :opentofu_ovirt_cr, parent: :compute_resource, class: ForemanOpentofu::Tofu, traits: [:opentofu_ovirt]
+end

data/test/factories/foreman_opentofu_factories.rb

@@ -0,0 +1,7 @@
+FactoryBot.modify do
+  factory :host do
+    trait :foreman_opentofu do
+      name { 'foreman_opentofu' }
+    end
+  end
+end

data/test/factories/tf_state_factories.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :tf_state, class: 'ForemanOpentofu::TfState' do
+    sequence(:name) { |n| "vm-#{n}" }
+    sequence(:uuid) { |n| "uuid-#{n}" }
+    state { '{"foo":"bar"}' }
+  end
+end

data/test/models/foreman_opentofu/opentofu_vm_commands_test.rb

@@ -0,0 +1,147 @@
+require 'test_helper'
+
+module ForemanOpentofu
+  class OpentofuVMCommandsTest < ActiveSupport::TestCase
+    setup do
+      @nutanix_cr = FactoryBot.build_stubbed(:opentofu_nutanix_cr)
+      @executor = mock('OpentofuExecuter')
+      @nutanix_cr.stubs(:client).returns(@executor)
+    end
+
+    test '#find_vm_by_uuid returns ComputeVM' do
+      FactoryBot.create(:tf_state)
+      @executor.stubs(:run).with('output').returns({ 'id' => 'vm-1' })
+      vm = @nutanix_cr.find_vm_by_uuid('uuid-1')
+      assert_instance_of ComputeVM, vm
+    end
+
+    test '#find_vm_by_uuid wraps exceptions' do
+      @executor.stubs(:run).raises(StandardError.new('boom'))
+
+      assert_raises(Foreman::WrappedException) do
+        @nutanix_cr.find_vm_by_uuid('uuid-1')
+      end
+    end
+
+    test '#new_vm returns OpenStruct with attributes' do
+      @executor.stubs(:run).with('new').returns(
+        'resource_changes' => [
+          { 'change' => { 'after' => { 'name' => 'vm1' } } },
+        ]
+      )
+
+      vm = @nutanix_cr.new_vm('name' => 'vm1')
+
+      assert_instance_of OpenStruct, vm
+      assert_equal 'vm1', vm.name
+    end
+
+    test '#create_vm returns ComputeVM' do
+      @executor.stubs(:run).with('create').returns({ 'id' => 'vm1' })
+
+      vm = @nutanix_cr.create_vm('name' => 'vm1')
+
+      assert_instance_of ComputeVM, vm
+    end
+
+    test '#create_vm wraps exceptions' do
+      @executor.stubs(:run).raises(StandardError.new('boom'))
+
+      assert_raises(Foreman::WrappedException) do
+        @nutanix_cr.create_vm('name' => 'vm1')
+      end
+    end
+
+    test '#destroy_vm deletes tf_state' do
+      tf_state = FactoryBot.create(:tf_state)
+
+      @executor.stubs(:run).with('destroy')
+      assert_difference('ForemanOpentofu::TfState.count', -1) do
+        @nutanix_cr.destroy_vm(tf_state.uuid)
+      end
+    end
+
+    test '#destroy_vm does nothing when tf_state missing' do
+      @executor.stubs(:run).with('destroy')
+
+      assert_nothing_raised do
+        @nutanix_cr.destroy_vm('missing')
+      end
+    end
+
+    test '#start_vm returns true when powered on' do
+      @executor.stubs(:run).with('create').returns(
+        'vm' => { 'power_state' => 'on' }
+      )
+
+      assert @nutanix_cr.start_vm('vm1')
+    end
+
+    test '#stop_vm returns true when powered off' do
+      @executor.stubs(:run).with('create').returns(
+        'vm' => { 'power_state' => 'off' }
+      )
+
+      assert @nutanix_cr.stop_vm('vm1')
+    end
+
+    test '#save_vm updates existing vm and returns ComputeVM without creating new TfState' do
+      tf_state = FactoryBot.create(:tf_state, uuid: 'uuid1', name: 'existing-vm')
+
+      @executor.stubs(:run).with('create').returns({ 'id' => tf_state.uuid })
+
+      assert_no_difference('ForemanOpentofu::TfState.count') do
+        vm = @nutanix_cr.save_vm('uuid1', [{ 'cpu' => 4 }])
+        assert_instance_of ComputeVM, vm
+      end
+    end
+
+    test '#save_vm updates vm with no attributes without creating new TfState' do
+      tf_state = FactoryBot.create(:tf_state, uuid: 'uuid1', name: 'existing-vm')
+
+      @executor.stubs(:run).with('create').returns({ 'id' => tf_state.uuid })
+
+      assert_no_difference('ForemanOpentofu::TfState.count') do
+        vm = @nutanix_cr.save_vm('uuid1', [])
+        assert_instance_of ComputeVM, vm
+      end
+    end
+
+    test '#save_vm wraps exceptions and does not create new TfState' do
+      FactoryBot.create(:tf_state, uuid: 'uuid1', name: 'existing-vm')
+
+      @executor.stubs(:run).raises(StandardError.new('update failed'))
+
+      assert_no_difference('ForemanOpentofu::TfState.count') do
+        assert_raises(Foreman::WrappedException) do
+          @nutanix_cr.save_vm('uuid1', [{ 'cpu' => 8 }])
+        end
+      end
+    end
+
+    test '#save_vm fails when TfState is missing' do
+      assert_no_difference('ForemanOpentofu::TfState.count') do
+        ex = assert_raises(StandardError) do
+          @nutanix_cr.save_vm('missing', [{ 'cpu' => 4 }])
+        end
+        assert_match(/VM with UUID missing does not exist/, ex.message)
+      end
+    end
+
+    test '#test_connection runs tofu test_connection' do
+      @executor.stubs(:run).with('test_connection')
+
+      @nutanix_cr.test_connection
+
+      assert_empty @nutanix_cr.errors
+    end
+
+    test '#test_connection adds error on failure' do
+      @executor.stubs(:run).raises(StandardError.new('fail'))
+
+      @nutanix_cr.test_connection
+
+      assert @nutanix_cr.errors.any?
+    end
+  end
+end

data/test/models/foreman_opentofu_test.rb

@@ -0,0 +1,43 @@
+require 'test_plugin_helper'
+# require 'models/compute_resources/compute_resource_test_helpers'
+
+module ForemanOpentofu
+  class NutanixTest < ActiveSupport::TestCase
+    # include ComputeResourceTestHelpers
+
+    let(:subject) { FactoryBot.build_stubbed(:opentofu_nutanix_cr) }
+
+    should validate_presence_of(:url)
+    should validate_presence_of(:user)
+    should validate_presence_of(:password)
+    # should validate_presence_of(:datacenter)
+    # should allow_values('vcenter.example.com', 'vcenter').for(:server)
+
+    test 'valid nutanix resource' do
+      assert subject.valid?
+    end
+
+    # FIXME: some of the following might be redundant
+    test 'invalid without URL' do
+      subject.url = nil
+      assert_not subject.valid?
+      assert_includes subject.errors[:url], "can't be blank"
+    end
+
+    test 'invalid without username' do
+      subject.user = nil
+      assert_not subject.valid?
+      assert_includes subject.errors[:user], "can't be blank"
+    end
+
+    test 'invalid without password' do
+      subject.password = nil
+      assert_not subject.valid?
+      assert_includes subject.errors[:password], "can't be blank"
+    end
+
+    test 'provided attributes includes mac' do
+      assert_includes subject.provided_attributes.keys, :mac
+    end
+  end
+end

data/test/services/app_wrapper_test.rb

@@ -0,0 +1,31 @@
+require 'test_plugin_helper'
+
+module ForemanOpentofu
+  class AppWrapperTest < ActiveSupport::TestCase
+    let(:app_wrapper) { AppWrapper.new('/tmp') }
+
+    test 'params parsed' do
+      params = app_wrapper.send(:parse_params, ['tofu', 'init', '--json'])
+      assert_kind_of(Array, params)
+      assert_equal(3, params.length)
+      params = app_wrapper.send(:parse_params, '--json')
+      assert_kind_of(Array, params)
+      assert_equal(1, params.length)
+    end
+
+    test 'command is assembled' do
+      cmdline = app_wrapper.send(:command, ['tofu', 'init', '--json'])
+      assert_kind_of(String, cmdline)
+      assert_equal("'tofu' 'init' '--json' 2>&1", cmdline)
+    end
+
+    test 'tofu_execute() adds default_params' do
+      def_p = ['--always', '--added']
+      base_c = 'none'
+      app_wrapper.expects(:base_command).returns(base_c)
+      app_wrapper.expects(:default_params).returns(def_p)
+      app_wrapper.expects(:execute).with([base_c, 'noop'] + def_p)
+      app_wrapper.send(:tofu_execute, 'noop')
+    end
+  end
+end

data/test/services/opentofu_executer_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module ForemanOpentofu
+  class OpentofuExecuterTest < ActiveSupport::TestCase
+    setup do
+      @compute_resource = FactoryBot.build_stubbed(:opentofu_nutanix_cr)
+      @cr_attrs = { 'name' => 'vm-1' }
+      @executor = OpentofuExecuter.new(@compute_resource, @cr_attrs)
+
+      @template = FactoryBot.create(:provisioning_template, name: Setting[:provision_nutanix_host_template])
+      @executor.stubs(:provision_template).returns(@template)
+
+      @app_mock = mock('AppWrapper')
+      AppWrapper.stubs(:new).returns(@app_mock)
+      @app_mock.stubs(:main_configuration=)
+      @app_mock.stubs(:init)
+      @app_mock.stubs(:plan)
+      @app_mock.stubs(:show_plan)
+      @app_mock.stubs(:apply)
+      @app_mock.stubs(:destroy).returns { ForemanOpentofu::TfState.find_by(uuid: 'uuid-1')&.destroy }
+      @app_mock.stubs(:output).with('vm_attrs').returns('identity' => 'uuid-1')
+    end
+
+    test '#run create updates tf_state and returns attrs' do
+      tf_state = FactoryBot.create(:tf_state, name: 'vm-1')
+      result = @executor.run('create')
+      tf_state.reload
+      assert_equal tf_state.uuid, result['identity']
+      assert_not_nil tf_state.uuid, 'tf_state UUID should be set'
+    end
+
+    test '#run output returns vm_attrs' do
+      result = @executor.run('output')
+      assert_equal 'uuid-1', result['identity']
+    end
+
+    test '#run destroy calls destroy' do
+      @executor.run('destroy')
+      assert_nil ForemanOpentofu::TfState.find_by(uuid: 'uuid-1')
+    end
+
+    test '#run new calls plan and show_plan' do
+      @app_mock.expects(:plan)
+      @app_mock.expects(:show_plan)
+      @executor.run('new')
+    end
+
+    test '#run test_connection only plans' do
+      @app_mock.expects(:plan)
+      @executor.run('test_connection')
+    end
+
+    test '#run with invalid mode raises RuntimeError' do
+      assert_raises(RuntimeError) { @executor.run('invalid_mode') }
+    end
+
+    test '#render_template raises exception if nil returned' do
+      Foreman::Renderer::UnsafeModeRenderer.stubs(:render).returns(nil)
+      assert_raises(Foreman::Exception) { @executor.send(:render_template) }
+    end
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,6 @@
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload