foreman_dlm 1.0.0 → 1.1.0

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

@@ -24,12 +24,12 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
 
     context '#create' do
       test 'should create dlmlock' do
-        assert_difference('Dlmlock.unscoped.count') do
+        assert_difference('ForemanDlm::Dlmlock.unscoped.count') do
           post :create, params: valid_attrs_with_root
         end
         assert_response :success
         body = ActiveSupport::JSON.decode(@response.body)
-        dlmlock = Dlmlock.find(body['id'])
+        dlmlock = ForemanDlm::Dlmlock.find(body['id'])
         assert dlmlock
         assert_equal valid_attrs['name'], dlmlock.name
         assert_equal valid_attrs['type'], dlmlock.type
@@ -99,11 +99,11 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
     context '#destroy' do
       test 'should destroy dlmlock' do
         dlmlock = FactoryBot.create(:dlmlock)
-        assert_difference('Dlmlock.unscoped.count', -1) do
+        assert_difference('ForemanDlm::Dlmlock.unscoped.count', -1) do
           delete :destroy, params: { :id => dlmlock.to_param }
         end
         assert_response :success
-        assert_equal 0, Dlmlock.where(:id => dlmlock.id).count
+        assert_equal 0, ForemanDlm::Dlmlock.where(:id => dlmlock.id).count
       end
     end
 
@@ -168,7 +168,7 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
         dlmlock = as_admin { FactoryBot.create(:dlmlock) }
         delete :destroy, params: { :id => dlmlock.to_param }
         assert_response :unauthorized
-        assert_equal 1, as_admin { Dlmlock.where(:id => dlmlock.id).count }
+        assert_equal 1, as_admin { ForemanDlm::Dlmlock.where(:id => dlmlock.id).count }
       end
     end
 
@@ -217,6 +217,13 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
         assert_equal host2.name, host['name']
         assert_equal false, host['self']
       end
+
+      test 'should update checkin time' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        refute as_admin { host1.dlm_facet }
+        put :show, params: { :id => dlmlock.to_param }
+        assert as_admin { host1.reload.dlm_facet.last_checkin_at }
+      end
     end
 
     context '#acquire' do
@@ -243,13 +250,20 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
 
       test 'should transparently create non-existing dlmlock' do
         lockname = 'Test Lock'
-        assert_equal 0, as_admin { Dlmlock.where(:name => lockname).count }
+        assert_equal 0, as_admin { ForemanDlm::Dlmlock.where(:name => lockname).count }
         put :acquire, params: { :id => lockname }
         assert_response :success
-        dlmlock = as_admin { Dlmlock.find_by(:name => lockname) }
+        dlmlock = as_admin { ForemanDlm::Dlmlock.find_by(:name => lockname) }
         assert_equal lockname, dlmlock.name
         assert_equal host1, dlmlock.host
       end
+
+      test 'should update checkin time' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        refute as_admin { host1.dlm_facet }
+        put :acquire, params: { :id => dlmlock.to_param }
+        assert as_admin { host1.reload.dlm_facet.last_checkin_at }
+      end
     end
 
     context '#release' do
@@ -276,13 +290,20 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
 
       test 'should transparently create non-existing dlmlock' do
         lockname = 'Test Lock'
-        assert_equal 0, as_admin { Dlmlock.where(:name => lockname).count }
+        assert_equal 0, as_admin { ForemanDlm::Dlmlock.where(:name => lockname).count }
         delete :release, params: { :id => lockname }
         assert_response :success
-        dlmlock = as_admin { Dlmlock.find_by(:name => lockname) }
+        dlmlock = as_admin { ForemanDlm::Dlmlock.find_by(:name => lockname) }
         assert_equal lockname, dlmlock.name
         assert_nil dlmlock.host
       end
+
+      test 'should update checkin time' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        refute as_admin { host1.dlm_facet }
+        put :release, params: { :id => dlmlock.to_param }
+        assert as_admin { host1.reload.dlm_facet.last_checkin_at }
+      end
     end
   end
 
@@ -329,7 +350,7 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
         dlmlock = as_admin { FactoryBot.create(:dlmlock) }
         delete :destroy, params: { :id => dlmlock.to_param }
         assert_response :unauthorized
-        assert_equal 1, as_admin { Dlmlock.where(:id => dlmlock.id).count }
+        assert_equal 1, as_admin { ForemanDlm::Dlmlock.where(:id => dlmlock.id).count }
       end
     end
 
@@ -357,7 +378,7 @@ class Api::V2::DlmlocksControllerTest < ActionController::TestCase
   def valid_attrs
     {
       'name' => 'testlock',
-      'type' => 'Dlmlock::Update'
+      'type' => 'ForemanDlm::Dlmlock::Update'
     }
   end
 

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

@@ -0,0 +1,81 @@
+require 'test_plugin_helper'
+
+class Api::V2::DlmlockEventsControllerTest < ActionController::TestCase
+  let(:host) { as_admin { FactoryBot.create(:host, :managed) } }
+
+  context 'with user authentication' do
+    context '#index' do
+      test 'should return the dlmlock_events for a given dlm_lock' do
+        # A random dlmlock with events, that should not be in the response.
+        dlmlock1 = FactoryBot.create(:dlmlock, host: host)
+        FactoryBot.create_list(:dlmlock_event, 2, dlmlock: dlmlock1)
+
+        dlmlock = FactoryBot.create(:dlmlock, host: host)
+        FactoryBot.create_list(:dlmlock_event, 3, dlmlock: dlmlock)
+
+        expected_size = dlmlock.dlmlock_events.count
+        expected_ids = dlmlock.dlmlock_events.pluck(:id).sort
+        expected_keys = ['id', 'event_type', 'created_at', 'updated_at']
+
+        get :index, params: { dlmlock_id: dlmlock.id }
+        assert_response :success
+
+        body = ActiveSupport::JSON.decode(@response.body)
+        assert_equal expected_size, body['total']
+        assert_equal expected_keys, body['results'].first.keys
+        assert_equal expected_ids, body['results'].map { |event| event['id'] }.sort
+      end
+    end
+  end
+
+  context 'as user with required permissions' do
+    let(:permissions) { Permission.where(name: ['view_dlmlocks', 'view_dlmlock_events']) }
+    let(:role) { FactoryBot.create(:role, permissions: permissions) }
+    let(:user) { FactoryBot.create(:user, roles: [role]) }
+
+    setup do
+      User.current = user
+      reset_api_credentials
+    end
+
+    context '#index' do
+      test 'should allow access' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        get :index, params: { dlmlock_id: dlmlock.id }
+        assert_response :success
+      end
+    end
+  end
+
+  context 'as user without required permissions' do
+    let(:user) { FactoryBot.create(:user, roles: []) }
+
+    setup do
+      User.current = user
+      reset_api_credentials
+    end
+
+    context '#index' do
+      test 'should deny access' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        get :index, params: { dlmlock_id: dlmlock.id }
+        assert_response :forbidden
+      end
+    end
+  end
+
+  context 'without any credentials' do
+    setup do
+      User.current = nil
+      reset_api_credentials
+    end
+
+    context '#index' do
+      test 'should deny access' do
+        dlmlock = as_admin { FactoryBot.create(:dlmlock) }
+        get :index, params: { dlmlock_id: dlmlock.id }
+        assert_response :unauthorized
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'test_plugin_helper'
+
+class Api::V2::HostsControllerTest < ActionController::TestCase
+  let(:host) { FactoryBot.create(:host, :managed, :with_dlm_facet) }
+
+  test 'should get index with dlm_facet attributes' do
+    host
+    get :index
+    assert_response :success
+    results = ActiveSupport::JSON.decode(@response.body)
+    hosts = results['results']
+    assert_not_empty hosts
+    host_with_facet = hosts.detect { |h| h['dlm_facet_attributes'].present? }
+    assert_not_nil host_with_facet
+    assert_equal host.dlm_facet.id, host_with_facet['dlm_facet_attributes']['id']
+    assert_equal host.dlm_facet.last_checkin_at.to_s, host_with_facet['dlm_facet_attributes']['last_checkin_at']
+  end
+
+  test 'should show individual record with dlm_facet attributes' do
+    get :show, params: { :id => host.to_param }
+    assert_response :success
+    show_response = ActiveSupport::JSON.decode(@response.body)
+    assert_not_empty show_response
+    assert_includes show_response.keys, 'dlm_facet_attributes'
+    assert_equal host.dlm_facet.id, show_response['dlm_facet_attributes']['id']
+    assert_equal host.dlm_facet.last_checkin_at.to_s, show_response['dlm_facet_attributes']['last_checkin_at']
+  end
+end

data/test/controllers/foreman_dlm/dlmlocks_test.rb

@@ -0,0 +1,55 @@
+require 'test_plugin_helper'
+
+module ForemanDlm
+  class DlmlocksControllerTest < ActionController::TestCase
+    test '#index' do
+      FactoryBot.create(:dlmlock)
+      get :index, session: set_session_user
+      assert_response :success
+      assert_not_nil assigns('dlmlocks')
+      assert_template 'index'
+    end
+
+    test '#index with no lock shows welcome page' do
+      get :index, session: set_session_user
+      assert_response :success
+      assert_template 'welcome'
+    end
+
+    test '#show' do
+      dlmlock = FactoryBot.create(:dlmlock)
+      get :show, params: { :id => dlmlock.id }, session: set_session_user
+      assert_response :success
+      assert_template 'show'
+    end
+
+    test '#destroy' do
+      dlmlock = FactoryBot.create(:dlmlock)
+      delete :destroy, params: { :id => dlmlock.id }, session: set_session_user
+      assert_redirected_to foreman_dlm_dlmlocks_url
+      refute Dlmlock.exists?(dlmlock.id)
+    end
+
+    test '#enable' do
+      dlmlock = FactoryBot.create(:dlmlock, enabled: false)
+      put :enable, params: { :id => dlmlock.id }, session: set_session_user
+      assert_redirected_to foreman_dlm_dlmlocks_url
+      assert dlmlock.reload.enabled?
+    end
+
+    test '#disable' do
+      dlmlock = FactoryBot.create(:dlmlock, enabled: true)
+      put :disable, params: { :id => dlmlock.id }, session: set_session_user
+      assert_redirected_to foreman_dlm_dlmlocks_url
+      assert dlmlock.reload.disabled?
+    end
+
+    test '#release' do
+      host = FactoryBot.create(:host)
+      dlmlock = FactoryBot.create(:dlmlock, host: host)
+      put :release, params: { :id => dlmlock.id }, session: set_session_user
+      assert_redirected_to foreman_dlm_dlmlocks_url
+      refute dlmlock.reload.taken?
+    end
+  end
+end

data/test/controllers/hosts_controller_test.rb

@@ -0,0 +1,12 @@
+require 'test_plugin_helper'
+
+class HostsControllerTest < ActionController::TestCase
+  let(:host) { FactoryBot.create(:host, :with_dlm_facet) }
+
+  test '#show shows dlm locks of that host' do
+    FactoryBot.create_list(:dlmlock, 2, host: host)
+    get :show, params: { :id => host.to_param }, session: set_session_user
+    assert_response :success
+    assert @response.body.match(/id='pagelet-id-locks'/)
+  end
+end

data/test/factories/dlm_facets.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :dlm_facet, class: 'ForemanDlm::DlmFacet' do
+    sequence(:last_checkin_at) { |n| n.minutes.ago }
+    host
+  end
+end

data/test/factories/dlmlock.rb

@@ -1,6 +1,10 @@
 FactoryBot.define do
-  factory :dlmlock do
+  factory :dlmlock, class: ::ForemanDlm::Dlmlock::Update do
     sequence(:name) { |n| "Lock #{n}" }
-    type 'Dlmlock::Update'
+    type 'ForemanDlm::Dlmlock::Update'
+
+    trait :locked do
+      host
+    end
   end
 end

data/test/factories/dlmlock_events.rb

@@ -0,0 +1,13 @@
+FactoryBot.define do
+  factory :dlmlock_event, class: ::ForemanDlm::DlmlockEvent do
+    dlmlock
+    event_type 'release'
+    host
+
+    trait :old_event do
+      after(:build) do |event|
+        event.created_at = 2.weeks.ago
+      end
+    end
+  end
+end

data/test/factories/host.rb

@@ -0,0 +1,7 @@
+FactoryBot.modify do
+  factory :host do
+    trait :with_dlm_facet do
+      association :dlm_facet, :factory => :dlm_facet, :strategy => :build
+    end
+  end
+end

data/test/jobs/refresh_dlmlock_status_test.rb

@@ -0,0 +1,10 @@
+require 'test_plugin_helper'
+
+class RefreshDlmlockStatusTest < ActiveJob::TestCase
+  let(:host) { FactoryBot.create(:host, :managed) }
+
+  test 'should refresh dlmlock status' do
+    Host::Managed.any_instance.expects(:refresh_dlmlock_status).once
+    perform_enqueued_jobs { ForemanDlm::RefreshDlmlockStatus.perform_later(host.id) }
+  end
+end

data/test/models/foreman_dlm/dlm_facet_test.rb

@@ -0,0 +1,13 @@
+require 'test_plugin_helper'
+
+module ForemanDlm
+  class DlmFacetTest < ActiveSupport::TestCase
+    setup do
+      User.current = users(:admin)
+    end
+
+    subject { FactoryBot.create(:dlm_facet) }
+    should belong_to(:host)
+    should validate_presence_of(:host)
+  end
+end

data/test/models/foreman_dlm/dlmlock_event_test.rb

@@ -0,0 +1,19 @@
+require 'test_plugin_helper'
+
+module ForemanDlm
+  class DlmlockEventTest < ActiveSupport::TestCase
+    should belong_to(:dlmlock)
+    should belong_to(:host)
+    should belong_to(:user)
+
+    test 'should expire lock events' do
+      event_count = 5
+      FactoryBot.create_list(:dlmlock_event, event_count)
+      FactoryBot.create_list(:dlmlock_event, event_count, :old_event)
+      assert_difference(-> { ForemanDlm::DlmlockEvent.count }, -1 * event_count) do
+        ForemanDlm::DlmlockEvent.expire(created_before: 7.days, batch_size: 2, sleep_time: 0.0001)
+      end
+      assert_equal event_count, ForemanDlm::DlmlockEvent.count
+    end
+  end
+end

data/test/models/foreman_dlm/dlmlock_test.rb

@@ -0,0 +1,299 @@
+require 'test_plugin_helper'
+
+module ForemanDlm
+  class DlmlockTest < ActiveSupport::TestCase
+    setup do
+      User.current = users(:admin)
+    end
+
+    should belong_to(:host)
+    should have_many(:dlmlock_events)
+
+    subject { FactoryBot.create(:dlmlock) }
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name)
+
+    let(:host1) { FactoryBot.create(:host, :managed) }
+    let(:host2) { FactoryBot.create(:host, :managed) }
+
+    class HostWithCallbacks < ::Host::Managed
+      attr_accessor :callbacks
+
+      def initialize(*attributes, &block)
+        super
+        @callbacks = []
+      end
+
+      after_lock :callback1
+      after_unlock :callback2
+
+      def callback1
+        Rails.logger.debug "callback1 executed for #{self} (#{self.class})"
+        callbacks << 'callback1'
+      end
+
+      def callback2
+        Rails.logger.debug "callback2 executed for #{self} (#{self.class})"
+        callbacks << 'callback2'
+      end
+    end
+
+    let(:host1_with_callbacks) { HostWithCallbacks.create(:name => 'test1.example.com') }
+    let(:host2_with_callbacks) { HostWithCallbacks.create(:name => 'test2.example.com') }
+
+    context 'a free and enabled DLM lock' do
+      let(:dlmlock) { FactoryBot.create(:dlmlock) }
+
+      test 'should be enabled and unlocked' do
+        assert_equal true, dlmlock.enabled?
+        assert_equal false, dlmlock.disabled?
+        assert_equal false, dlmlock.locked?
+        assert_equal false, dlmlock.taken?
+      end
+
+      test 'can be acquired' do
+        assert_nil dlmlock.host
+        assert dlmlock.acquire!(host1)
+        assert_equal host1, dlmlock.reload.host
+      end
+
+      test 'can be released' do
+        assert_nil dlmlock.host
+        assert dlmlock.release!(host1)
+        assert_nil dlmlock.reload.host
+      end
+
+      test 'creates a dlmlock_event on acquisition by owner' do
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          assert dlmlock.acquire!(host1)
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'acquire', event.event_type
+        assert_equal host1.id, event.host_id
+        assert_equal users(:admin).id, event.user_id
+        assert_equal dlmlock.id, event.dlmlock_id
+      end
+
+      test 'triggers after_lock callback' do
+        host = HostWithCallbacks.new
+        host.name = 'test.example.com'
+        host.save
+        assert dlmlock.acquire!(host)
+        assert_equal ['callback1'], host.callbacks
+      end
+    end
+
+    context 'a free and disabled DLM lock' do
+      let(:dlmlock) { FactoryBot.create(:dlmlock, :enabled => false) }
+
+      test 'should be disabled and unlocked' do
+        assert_equal false, dlmlock.enabled?
+        assert_equal true, dlmlock.disabled?
+        assert_equal false, dlmlock.locked?
+        assert_equal false, dlmlock.taken?
+      end
+
+      test 'can not be acquired' do
+        assert_nil dlmlock.host
+        assert_equal false, dlmlock.acquire!(host1)
+        assert_nil dlmlock.reload.host
+      end
+
+      test 'can not be released' do
+        assert_nil dlmlock.host
+        assert_equal false, dlmlock.release!(host1)
+        assert_nil dlmlock.reload.host
+      end
+
+      test 'triggers no callbacks' do
+        host = HostWithCallbacks.new
+        host.name = 'test.example.com'
+        host.save
+        assert_equal false, dlmlock.release!(host)
+        assert_equal [], host.callbacks
+      end
+    end
+
+    context 'an acquired DLM lock' do
+      let(:dlmlock) { FactoryBot.create(:dlmlock, :host => host1) }
+
+      test 'should be enabled and locked' do
+        assert_equal true, dlmlock.enabled?
+        assert_equal false, dlmlock.disabled?
+        assert_equal true, dlmlock.locked?
+        assert_equal true, dlmlock.taken?
+        assert_equal true, dlmlock.locked_by?(host1)
+        assert_equal true, dlmlock.acquired_by?(host1)
+      end
+
+      test 'can be acquired by owner' do
+        assert_equal host1, dlmlock.host
+        assert dlmlock.acquire!(host1)
+        assert_equal host1, dlmlock.reload.host
+      end
+
+      test 'can not be acquired by other host' do
+        assert_equal host1, dlmlock.host
+        assert_equal false, dlmlock.acquire!(host2)
+        assert_equal host1, dlmlock.reload.host
+      end
+
+      test 'can be released by owner' do
+        assert_equal host1, dlmlock.host
+        assert dlmlock.release!(host1)
+        assert_nil dlmlock.reload.host
+      end
+
+      test 'can not be released by other host' do
+        assert_equal host1, dlmlock.host
+        assert_equal false, dlmlock.release!(host2)
+        assert_equal host1, dlmlock.reload.host
+      end
+
+      test 'records audit change on release by owner' do
+        dlmlock
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          assert dlmlock.release!(host1)
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'release', event.event_type
+        assert_equal host1.id, event.host_id
+        assert_equal users(:admin).id, event.user_id
+        assert_equal dlmlock.id, event.dlmlock_id
+      end
+
+      test 'records no audit change on acquisition by owner' do
+        assert_no_difference "Audit.where(auditable_type: 'ForemanDlm::Dlmlock', action: 'update').count" do
+          assert dlmlock.acquire!(host1)
+        end
+      end
+
+      test 'triggers after_unlock callback on release by owner' do
+        host = HostWithCallbacks.new
+        host.name = 'test.example.com'
+        host.save
+        dlmlock.host = host
+        dlmlock.save
+        assert dlmlock.release!(host)
+        assert_equal ['callback2'], host.callbacks
+      end
+
+      test 'triggers no callbacks on release attempt by other host' do
+        assert host1_with_callbacks
+        assert host2_with_callbacks
+        dlmlock.update(:host => host1_with_callbacks)
+        assert_equal false, dlmlock.release!(host2_with_callbacks)
+        assert_equal [], host1_with_callbacks.callbacks
+        assert_equal [], host2_with_callbacks.callbacks
+      end
+
+      test 'triggers no callbacks on acquiry attempt by owner' do
+        assert host1_with_callbacks
+        dlmlock.update(:host => host1_with_callbacks)
+        assert dlmlock.acquire!(host1_with_callbacks)
+        assert_equal [], host1_with_callbacks.callbacks
+      end
+    end
+
+    context 'scoped search' do
+      test 'can be searched by name' do
+        dlmlock = FactoryBot.create(:dlmlock)
+        assert_equal Dlmlock::Update.find(dlmlock.id), Dlmlock.search_for("name ~ #{dlmlock.name}").first
+      end
+    end
+
+    describe '#locked' do
+      subject { Dlmlock.locked }
+
+      it 'includes only Distributed Locks that are locked' do
+        locked = FactoryBot.create(:dlmlock, :locked)
+        not_locked = FactoryBot.create(:dlmlock)
+
+        assert_includes subject, locked
+        refute_includes subject, not_locked
+      end
+    end
+
+    describe '#stale' do
+      setup do
+        FactoryBot.create(:setting, category: Setting::General, name: 'dlm_stale_time', value: 4)
+      end
+
+      subject { Dlmlock.stale }
+
+      it 'includes only Distributed Locks that are stale' do
+        now = Time.now.utc
+
+        travel_to now do
+          stale = FactoryBot.create(:dlmlock, :locked, updated_at: now - 5.hours)
+          not_stale = FactoryBot.create(:dlmlock, :locked, updated_at: now)
+          not_locked = FactoryBot.create(:dlmlock)
+
+          assert_includes subject, stale
+          refute_includes subject, not_stale
+          refute_includes subject, not_locked
+        end
+      end
+    end
+
+    context '#log_events' do
+      let(:dlmlock) { FactoryBot.create(:dlmlock) }
+
+      test 'logs acquire event' do
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          dlmlock.acquire!(host1)
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'acquire', event.event_type
+        assert_equal host1, event.host
+      end
+
+      test 'logs disable event' do
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          dlmlock.disable!
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'disable', event.event_type
+      end
+
+      test 'logs enable event' do
+        dlmlock.update(enabled: false)
+
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          dlmlock.enable!
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'enable', event.event_type
+      end
+
+      test 'logs failed event' do
+        dlmlock.acquire!(host1)
+
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          dlmlock.acquire!(host2)
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'fail', event.event_type
+        assert_equal host1, event.host
+      end
+
+      test 'logs release event' do
+        dlmlock.acquire!(host1)
+
+        assert_difference -> { DlmlockEvent.count }, 1 do
+          assert dlmlock.release!(host1)
+        end
+
+        event = DlmlockEvent.last
+        assert_equal 'release', event.event_type
+        assert_equal host1, event.host
+      end
+    end
+  end
+end