hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/models/hyrax/user_usage_stats_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Hyrax::UserUsageStats do
+  subject { create(:user) }
+
+  describe 'with cached stats' do
+    let!(:stat_1_day_ago) { UserStat.create!(user_id: subject.id, date: 1.day.ago, file_views: 3, file_downloads: 2, work_views: 5) }
+    let!(:stat_2_days_ago) { UserStat.create!(user_id: subject.id, date: 2.days.ago, file_views: 2, file_downloads: 1, work_views: 7) }
+
+    let!(:someone_elses_user_id) { subject.id + 1 }
+    let!(:not_my_stat) { UserStat.create!(user_id: someone_elses_user_id, date: 2.days.ago, file_views: 10, file_downloads: 11) }
+
+    describe '#total_file_views' do
+      it 'returns the total file views for that user' do
+        expect(subject.total_file_views).to eq 5
+      end
+    end
+
+    describe '#total_file_downloads' do
+      it 'returns the total file downloads for that user' do
+        expect(subject.total_file_downloads).to eq 3
+      end
+    end
+
+    describe '#total_work_views' do
+      it 'returns the total work views for that user' do
+        expect(subject.total_work_views).to eq 12
+      end
+    end
+  end
+
+  describe 'with empty cache' do
+    describe '#total_file_views' do
+      it 'returns the total file views for that user' do
+        expect(subject.total_file_views).to eq 0
+      end
+    end
+
+    describe '#total_file_downloads' do
+      it 'returns the total file downloads for that user' do
+        expect(subject.total_file_downloads).to eq 0
+      end
+    end
+  end
+end

data/spec/models/hyrax/work_behavior_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe Hyrax::WorkBehavior do
+  before do
+    class EssentialWork < ActiveFedora::Base
+      include Hyrax::WorkBehavior
+    end
+  end
+  after do
+    Object.send(:remove_const, :EssentialWork)
+  end
+
+  subject { EssentialWork.new }
+
+  it 'mixes together some junk' do
+    expect(subject.class.ancestors).to include(::Hyrax::WithFileSets,
+                                               ::Hyrax::HumanReadableType,
+                                               Hyrax::Noid,
+                                               Hyrax::Serializers,
+                                               Hydra::WithDepositor,
+                                               Hydra::AccessControls::Embargoable,
+                                               Hyrax::Suppressible,
+                                               Hyrax::CollectionNesting)
+  end
+
+  describe '#to_s' do
+    it 'uses the provided titles' do
+      subject.title = %w[Hello World]
+      expect(subject.to_s).to include 'Hello'
+      expect(subject.to_s).to include 'World'
+    end
+  end
+
+  describe 'human_readable_type' do
+    it 'has a default' do
+      expect(subject.human_readable_type).to eq 'Essential Work'
+    end
+    it 'is settable (deprecated)' do
+      allow(Deprecation).to receive(:warn)
+      EssentialWork.human_readable_type = 'Custom Type'
+      expect(subject.human_readable_type).to eq 'Custom Type'
+    end
+  end
+
+  it 'inherits (and extends) to_solr behaviors from superclass' do
+    expect(subject.to_solr.keys).to include(:id)
+    expect(subject.to_solr.keys).to include('has_model_ssim')
+  end
+
+  describe 'indexer' do
+    let(:klass) { Class.new }
+
+    it 'is settable' do
+      EssentialWork.indexer = klass
+      expect(EssentialWork.indexer).to eq klass
+    end
+  end
+
+  describe '#update_nested_collection_relationship_indices', :with_nested_reindexing do
+    it 'will be called after save' do
+      expect(Samvera::NestingIndexer).to receive(:reindex_relationships).with(id: kind_of(String), extent: kind_of(String))
+      subject.save!
+    end
+  end
+end

data/spec/models/job_io_wrapper_spec.rb

@@ -0,0 +1,172 @@
+RSpec.describe JobIoWrapper, type: :model do
+  let(:user) { build(:user) }
+  let(:path) { fixture_path + '/world.png' }
+  let(:file_set_id) { 'bn999672v' }
+  let(:file_set) { instance_double(FileSet, id: file_set_id, uri: 'http://127.0.0.1/rest/fake/bn/99/96/72/bn999672v') }
+  let(:args) { { file_set_id: file_set_id, user: user, path: path } }
+
+  subject(:wrapper) { described_class.new(args) }
+
+  it 'requires attributes' do
+    expect { described_class.create! }.to raise_error ActiveRecord::RecordInvalid
+    expect { described_class.create!(file_set_id: file_set_id, path: path) }.to raise_error ActiveRecord::RecordInvalid
+    expect { described_class.create!(file_set_id: file_set_id, user: user) }.to raise_error ActiveRecord::RecordInvalid
+    expect { subject.save! }.not_to raise_error
+  end
+
+  describe '.create_with_wrapped_params!' do
+    let(:local_file) { File.open(path) }
+    let(:relation) { :remastered }
+
+    subject { described_class.create_with_varied_file_handling!(user: user, file_set: file_set, file: file, relation: relation) }
+
+    context 'with Rack::Test::UploadedFile' do
+      let(:file) { Rack::Test::UploadedFile.new(path, 'image/png') }
+
+      it 'creates a JobIoWrapper' do
+        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, path: file.path, original_name: 'world.png' }
+        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
+        subject
+      end
+    end
+
+    context 'with ::File' do
+      let(:file) { local_file }
+
+      it 'creates a JobIoWrapper' do
+        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, path: file.path }
+        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
+        subject
+      end
+    end
+
+    context 'with Hyrax::UploadedFile' do
+      let(:file) { Hyrax::UploadedFile.new(user: user, file_set_uri: file_set.uri, file: local_file) }
+
+      it 'creates a JobIoWrapper' do
+        expected_create_args = { user: user, relation: relation.to_s, file_set_id: file_set.id, uploaded_file: file, path: file.uploader.path }
+        expect(JobIoWrapper).to receive(:create!).with(expected_create_args)
+        subject
+      end
+    end
+  end
+
+  describe 'uploaded_file' do
+    let(:other_path) { fixture_path + '/image.jpg' }
+    let(:uploaded_file) { Hyrax::UploadedFile.new(user: user, file_set_uri: file_set.uri, file: File.new(other_path)) }
+
+    # context 'path only' is the rest of this file
+
+    context 'in leiu of path' do
+      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file } }
+
+      it 'validates and persists' do
+        expect { subject.save! }.not_to raise_error
+      end
+      it '#read routes to the uploaded_file' do
+        expect(subject).to receive(:file_from_uploaded_file!).and_call_original
+        subject.read
+      end
+      it '#mime_type and #original_name draw from the uploaded_file' do
+        expect(subject.mime_type).to eq('image/jpeg')
+        expect(subject.original_name).to eq('image.jpg')
+      end
+    end
+
+    context 'along with path (on shared filesystem)' do
+      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file, path: path } }
+
+      it 'validates and persists' do
+        expect { subject.save! }.not_to raise_error
+      end
+      it '#read routes to the path' do
+        expect(subject).not_to receive(:file_from_uploaded_file!)
+        subject.read
+      end
+      it '#mime_type and #original_name draw from the uploaded_file' do
+        expect(subject.mime_type).to eq('image/jpeg')
+        expect(subject.original_name).to eq('image.jpg')
+      end
+    end
+
+    context 'along with path (independent worker filesystems)' do
+      let(:deadpath) { fixture_path + '/some_file_that_does_not_exist.wav' }
+      let(:args) { { file_set_id: file_set_id, user: user, uploaded_file: uploaded_file, path: deadpath } }
+
+      it 'validates and persists' do
+        expect { subject.save! }.not_to raise_error
+      end
+      it '#read routes to the uploaded_file' do
+        expect(subject).to receive(:file_from_uploaded_file!).and_call_original
+        subject.read
+      end
+      it '#mime_type and #original_name draw from the uploaded_file' do
+        expect(subject.mime_type).to eq('image/jpeg')
+        expect(subject.original_name).to eq('image.jpg')
+      end
+    end
+  end
+
+  it 'has a #user' do
+    expect(subject.user).to eq(user)
+    expect(subject.user_id).to eq(user.id)
+  end
+
+  describe '#relation' do
+    it 'has default value' do
+      expect(subject.relation).to eq('original_file')
+    end
+    it 'accepts new value' do
+      subject.relation = 'remastered'
+      expect(subject.relation).to eq('remastered')
+    end
+  end
+
+  describe '#original_name' do
+    it 'extracts default value' do
+      expect(subject.original_name).to eq('world.png')
+    end
+    it 'accepts new value' do
+      subject.original_name = 'foobar'
+      expect(subject.original_name).to eq('foobar')
+    end
+  end
+
+  describe '#mime_type' do
+    it 'extracts default value' do
+      expect(subject.mime_type).to eq('image/png')
+    end
+    it 'accepts new value' do
+      subject.mime_type = 'text/plain'
+      expect(subject.mime_type).to eq('text/plain')
+    end
+    it 'uses original_name if set' do
+      subject.original_name = '汉字.jpg'
+      expect(subject.mime_type).to eq('image/jpeg')
+      subject.original_name = 'no_suffix'
+      expect(subject.mime_type).to eq('application/octet-stream')
+    end
+  end
+
+  describe '#file_actor' do
+    let(:file_actor) { Hyrax::Actors::FileActor.new(file_set, subject.relation, user) }
+
+    it 'produces an appropriate FileActor' do
+      allow(FileSet).to receive(:find).with(file_set_id).and_return(file_set)
+      expect(subject.file_actor).to eq(file_actor)
+    end
+  end
+
+  describe '#read' do
+    it 'delivers contents' do
+      expect(subject.read).to eq(File.open(path, 'rb').read)
+    end
+    context 'text file' do
+      let(:path) { fixture_path + '/png_fits.xml' }
+
+      it 'delivers contents' do
+        expect(subject.read).to eq(File.open(path, 'rb').read)
+      end
+    end
+  end
+end

data/spec/models/proxy_deposit_request_spec.rb

@@ -0,0 +1,170 @@
+RSpec.describe ProxyDepositRequest, type: :model do
+  include ActionView::Helpers::UrlHelper
+
+  let(:sender) { create(:user) }
+  let(:receiver) { create(:user) }
+  let(:receiver2) { create(:user) }
+  let(:work_id) { '123abc' }
+  let(:stubbed_work_query_service_class) { double(new: work_query_service) }
+  let(:work_query_service) { double(work: work) }
+  let(:work) { double('Work') }
+
+  subject do
+    described_class.new(work_id: work_id, sending_user: sender,
+                        receiving_user: receiver, sender_comment: "please take this")
+  end
+
+  # Injecting a different work_query_service_class to avoid hitting SOLR and Fedora; I need an
+  # instance variable as mocks are not allowed in the around blocks
+  # rubocop:disable RSpec/InstanceVariable
+  before do
+    @original_work_query_service_class = described_class.work_query_service_class
+    described_class.work_query_service_class = stubbed_work_query_service_class
+  end
+
+  after do
+    described_class.work_query_service_class = @original_work_query_service_class
+  end
+  # rubocop:enable RSpec/InstanceVariable
+
+  its(:status) { is_expected.to eq described_class::PENDING }
+  it { is_expected.to be_pending }
+  its(:fulfillment_date) { is_expected.to be_nil }
+  its(:sender_comment) { is_expected.to eq 'please take this' }
+
+  it { is_expected.to delegate_method(:to_s).to(:work_query_service) }
+  it { is_expected.to delegate_method(:work).to(:work_query_service) }
+  it { is_expected.to delegate_method(:deleted_work?).to(:work_query_service) }
+
+  context '.incoming_for' do
+    it 'returns non-deleted requests for the receiving_user' do
+      deleted_work_service = double(deleted_work?: true)
+      found_work_service = double(deleted_work?: false)
+
+      found = create(:proxy_deposit_request, work_id: 'abc', sending_user: sender, receiving_user: receiver)
+      allow(stubbed_work_query_service_class).to receive(:new).with(id: 'abc').and_return(found_work_service)
+
+      _deleted = create(:proxy_deposit_request, work_id: 'efg', sending_user: sender, receiving_user: receiver)
+      allow(stubbed_work_query_service_class).to receive(:new).with(id: 'efg').and_return(deleted_work_service)
+
+      _not_to_find = create(:proxy_deposit_request, work_id: 'hij', sending_user: receiver, receiving_user: sender)
+      expect(described_class.incoming_for(user: receiver)).to eq([found])
+    end
+  end
+
+  context '.outgoing_for' do
+    it 'returns only requests for the sending_user' do
+      found = create(:proxy_deposit_request, work_id: 'abc', sending_user: sender, receiving_user: receiver)
+      _not_to_find = create(:proxy_deposit_request, work_id: 'hij', sending_user: receiver, receiving_user: sender)
+      expect(described_class.outgoing_for(user: sender)).to eq([found])
+    end
+  end
+
+  context '#status' do
+    it 'is protected by enum enforcement' do
+      expect { described_class.new(status: 'not_valid') }.to raise_error(ArgumentError)
+    end
+
+    # Because the Rails documentation says "Declare an enum attribute where the values map to integers in the database, but can be queried by name." but appears to not be the case.
+    it 'is persisted as a string' do
+      subject.cancel!
+      values = described_class.connection.execute("SELECT * FROM #{described_class.quoted_table_name}")
+      expect(values.first.fetch('status')).to eq(described_class::CANCELED)
+    end
+  end
+
+  describe '#transfer!' do
+    it 'will change the status, fulfillment_date, and perform later the ContentDepositorChangeEventJob' do
+      allow(ContentDepositorChangeEventJob).to receive(:perform_later)
+      subject.transfer!
+      expect(subject.status).to eq(described_class::ACCEPTED)
+      expect(subject.fulfillment_date).to be_a(Time)
+      expect(subject).to be_accepted
+    end
+  end
+
+  describe '#cancel!' do
+    it 'will change the status, fulfillment_date' do
+      subject.cancel!
+      expect(subject.status).to eq(described_class::CANCELED)
+      expect(subject.fulfillment_date).to be_a(Time)
+      expect(subject).to be_canceled
+    end
+  end
+
+  describe '#reject!' do
+    it 'will change the status, fulfillment_date, and receiver comment' do
+      subject.reject!('a comment')
+      expect(subject.status).to eq(described_class::REJECTED)
+      expect(subject.fulfillment_date).to be_a(Time)
+      expect(subject.receiver_comment).to eq('a comment')
+      expect(subject).to be_rejected
+    end
+  end
+
+  describe 'transfer' do
+    context 'when the transfer_to user is not found' do
+      it 'raises an error' do
+        subject.transfer_to = 'dave'
+        expect(subject).not_to be_valid
+        expect(subject.errors[:transfer_to]).to eq(['must be an existing user'])
+      end
+    end
+
+    context 'when the transfer_to user is found' do
+      it 'creates a transfer_request' do
+        subject.transfer_to = receiver.user_key
+        expect { subject.save! }.to change { receiver.mailbox.inbox(unread: true).count }.from(0).to(1)
+        expect(receiver.mailbox.inbox.last.last_message.subject).to eq 'Ownership Change Request'
+        user_link = link_to(sender.name, Hyrax::Engine.routes.url_helpers.user_path(sender))
+        transfer_link = link_to('transfer requests', Hyrax::Engine.routes.url_helpers.transfers_path)
+        expect(receiver.mailbox.inbox.last.last_message.body).to eq user_link + ' wants to transfer a work to you. Review all ' + transfer_link
+        proxy_request = receiver.proxy_deposit_requests.first
+        expect(proxy_request.work_id).to eq(work_id)
+        expect(proxy_request.sending_user).to eq(sender)
+      end
+
+      it 'updates a transfer_request' do
+        subject.transfer_to = receiver.user_key
+        expect { subject.save! }.to change { receiver.mailbox.inbox(unread: true).count }.from(0).to(1)
+        subject.status = described_class::ACCEPTED
+        subject.save!
+        expect(sender.mailbox.inbox.last.last_message.subject).to eq 'Ownership Change ' + described_class::ACCEPTED
+        expect(sender.mailbox.inbox.last.last_message.body).to eq 'Your transfer request was ' + described_class::ACCEPTED + '.'
+      end
+    end
+
+    context 'when the receiving user is the sending user' do
+      it 'raises an error' do
+        subject.transfer_to = sender.user_key
+        expect(subject).not_to be_valid
+        expect(subject.errors[:transfer_to]).to eq(['specify a different user to receive the work'])
+      end
+    end
+
+    context 'when the work is already being transferred' do
+      let(:subject2) { described_class.new(work_id: work_id, sending_user: sender, receiving_user: receiver2, sender_comment: 'please take this') }
+
+      it 'raises an error' do
+        subject.save!
+        expect(subject2).not_to be_valid
+        expect(subject2.errors[:open_transfer]).to eq(['must close open transfer on the work before creating a new one'])
+      end
+
+      context 'when the first transfer is closed' do
+        before do
+          subject.status = described_class::ACCEPTED
+        end
+
+        it 'does not raise an error' do
+          expect { subject.save! }.to change { receiver.mailbox.inbox(unread: true).count }.from(0).to(1)
+          expect(subject2).to be_valid
+          expect(receiver.mailbox.inbox.last.last_message.subject).to eq 'Ownership Change Request'
+          user_link = link_to(sender.name, Hyrax::Engine.routes.url_helpers.user_path(sender))
+          transfer_link = link_to('transfer requests', Hyrax::Engine.routes.url_helpers.transfers_path)
+          expect(receiver.mailbox.inbox.last.last_message.body).to eq user_link + ' wants to transfer a work to you. Review all ' + transfer_link
+        end
+      end
+    end
+  end
+end

data/spec/models/single_use_link_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe SingleUseLink do
+  let(:file) { FileSet.new(id: 'abc123') }
+
+  describe "default attributes" do
+    let(:hash) { "sha2hash#{DateTime.current.to_f}" }
+    let(:path) { '/foo/file/99999' }
+
+    subject { described_class.new item_id: '99999', path: path }
+
+    it "creates link" do
+      expect(Digest::SHA2).to receive(:new).and_return(hash)
+      expect(subject.download_key).to eq hash
+      expect(subject.item_id).to eq '99999'
+      expect(subject.path).to eq path
+    end
+  end
+
+  describe "attribute aliases" do
+    let(:hash) { "sha2hash#{DateTime.current.to_f}" }
+    let(:path) { '/foo/file/99999' }
+
+    subject { described_class.new itemId: '99999', path: path }
+
+    it "creates link" do
+      expect(Digest::SHA2).to receive(:new).and_return(hash)
+      expect(subject.downloadKey).to eq hash
+      expect(subject.itemId).to eq '99999'
+      expect(subject.path).to eq path
+    end
+  end
+
+  describe "#expired?" do
+    let(:link) do
+      described_class.new(expires: expires)
+    end
+
+    subject { link.expired? }
+
+    context "when not expired" do
+      let(:expires) { DateTime.current.advance(hours: 1) }
+
+      it { is_expected.to be false }
+    end
+
+    context "when not expired" do
+      let(:expires) { DateTime.current.advance(hours: -1) }
+
+      it { is_expected.to be true }
+    end
+  end
+end

data/spec/models/sipity/agent_spec.rb

@@ -0,0 +1,8 @@
+module Sipity
+  RSpec.describe Agent, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include("proxy_for_id") }
+    its(:column_names) { is_expected.to include("proxy_for_type") }
+  end
+end

data/spec/models/sipity/comment_spec.rb

@@ -0,0 +1,24 @@
+module Sipity
+  RSpec.describe Comment, type: :model do
+    context 'database configuration' do
+      subject { described_class }
+
+      its(:column_names) { is_expected.to include('entity_id') }
+      its(:column_names) { is_expected.to include('agent_id') }
+      its(:column_names) { is_expected.to include('comment') }
+    end
+
+    describe '#name_of_commentor' do
+      let(:instance) { described_class.new }
+      let(:agent) { instance_double(Agent, proxy_for: user) }
+      let(:user) { instance_double(User, to_s: 'Hiya') }
+
+      subject { instance.name_of_commentor }
+
+      before do
+        allow(instance).to receive(:agent).and_return(agent)
+      end
+      it { is_expected.to eq('Hiya') }
+    end
+  end
+end

data/spec/models/sipity/entity_spec.rb

@@ -0,0 +1,27 @@
+module Sipity
+  RSpec.describe Entity, type: :model do
+    describe 'database configuration' do
+      subject { described_class }
+
+      its(:column_names) { is_expected.to include("proxy_for_global_id") }
+      its(:column_names) { is_expected.to include("workflow_id") }
+      its(:column_names) { is_expected.to include("workflow_state_id") }
+    end
+
+    subject { described_class.new }
+
+    describe 'delegations' do
+      it { is_expected.to delegate_method(:workflow_state_name).to(:workflow_state).as(:name) }
+      it { is_expected.to delegate_method(:workflow_name).to(:workflow).as(:name) }
+    end
+
+    describe '#proxy_for' do
+      let(:work) { create(:generic_work) }
+      let(:entity) { Sipity::Entity.new(proxy_for_global_id: work.to_global_id) }
+
+      it 'will retrieve based on a GlobalID of the object' do
+        expect(entity.proxy_for).to eq(work)
+      end
+    end
+  end
+end

data/spec/models/sipity/entity_specific_responsibility_spec.rb

@@ -0,0 +1,9 @@
+module Sipity
+  RSpec.describe EntitySpecificResponsibility, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include('workflow_role_id') }
+    its(:column_names) { is_expected.to include('entity_id') }
+    its(:column_names) { is_expected.to include('agent_id') }
+  end
+end

data/spec/models/sipity/notifiable_context_spec.rb

@@ -0,0 +1,7 @@
+module Sipity
+  RSpec.describe NotifiableContext, type: :model do
+    subject { described_class.new }
+
+    it "should have tests"
+  end
+end

data/spec/models/sipity/notification_recipient_spec.rb

@@ -0,0 +1,9 @@
+module Sipity
+  RSpec.describe NotificationRecipient, type: :model do
+    subject { described_class.new }
+
+    it 'will raise an ArgumentError if you provide an invalid recipient_strategy' do
+      expect { subject.recipient_strategy = '__incorrect_name__' }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/models/sipity/notification_spec.rb

@@ -0,0 +1,15 @@
+module Sipity
+  RSpec.describe Notification, type: :model do
+    subject { described_class.new }
+
+    it 'will raise an ArgumentError if you provide an invalid #notification_type' do
+      expect { subject.notification_type = '__incorrect_name__' }.to raise_error(ArgumentError)
+    end
+
+    describe '.valid_notification_types' do
+      subject { described_class.valid_notification_types }
+
+      it { is_expected.to eq([described_class::NOTIFICATION_TYPE_EMAIL]) }
+    end
+  end
+end

data/spec/models/sipity/role_spec.rb

@@ -0,0 +1,40 @@
+module Sipity
+  RSpec.describe Role, type: :model do
+    context 'class methods' do
+      subject { described_class }
+
+      its(:column_names) { is_expected.to include('name') }
+      its(:column_names) { is_expected.to include('description') }
+      context '.[]' do
+        let(:valid_name) { 'reviewing' }
+
+        it 'will find the named role' do
+          expected_object = described_class.create!(name: valid_name)
+          expect(described_class[valid_name]).to eq(expected_object)
+        end
+
+        it 'will created the named role' do
+          expect { described_class[valid_name].name }.to change { described_class.count }.by(1)
+        end
+      end
+    end
+
+    subject { described_class.new }
+
+    it 'will have a #to_s that is a name' do
+      subject.name = 'advising'
+      expect(subject.to_s).to eq(subject.name)
+    end
+
+    context '#destroy' do
+      it 'will not allow registered role names to be destroyed' do
+        role = Sipity::Role.create!(name: Hyrax::RoleRegistry::MANAGING)
+        expect { role.destroy! }.to raise_error(ActiveRecord::RecordNotDestroyed)
+      end
+      it 'will allow unregistered role names to be destroyed' do
+        role = Sipity::Role.create!(name: 'gong_farming')
+        expect { role.destroy! }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/models/sipity/workflow_action_spec.rb

@@ -0,0 +1,11 @@
+module Sipity
+  RSpec.describe WorkflowAction, type: :model do
+    context 'database configuration' do
+      subject { described_class }
+
+      its(:column_names) { is_expected.to include('workflow_id') }
+      its(:column_names) { is_expected.to include('resulting_workflow_state_id') }
+      its(:column_names) { is_expected.to include('name') }
+    end
+  end
+end

data/spec/models/sipity/workflow_responsibility_spec.rb

@@ -0,0 +1,8 @@
+module Sipity
+  RSpec.describe WorkflowResponsibility, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include('agent_id') }
+    its(:column_names) { is_expected.to include('workflow_role_id') }
+  end
+end

data/spec/models/sipity/workflow_role_spec.rb

@@ -0,0 +1,8 @@
+module Sipity
+  RSpec.describe WorkflowRole, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include('workflow_id') }
+    its(:column_names) { is_expected.to include('role_id') }
+  end
+end