ddr-models 1.2.0

data/spec/models/user_spec.rb~

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe User, :type => :model do
+
+  subject { FactoryGirl.build(:user) }
+
+  describe "#member_of?" do
+    it "should return true if the user is a member of the group" do
+      allow(subject).to receive(:groups).and_return(["foo", "bar"])
+      expect(subject).to be_member_of("foo")
+    end
+    it "should return false if the user is not a member of the group" do
+      allow(subject).to receive(:groups).and_return(["foo", "bar"])
+      expect(subject).not_to be_member_of("baz")
+    end
+  end
+
+  describe "#authorized_to_act_as_superuser?" do
+    it "should return false if the superuser group is not defined (nil)" do
+      DulHydra.superuser_group = nil
+      expect(subject).not_to be_authorized_to_act_as_superuser
+    end
+    it "should return false if the user is not a member of the superuser group" do
+      DulHydra.superuser_group = "superusers"
+      allow(subject).to receive(:groups).and_return(["normal"])
+      expect(subject).not_to be_authorized_to_act_as_superuser
+    end
+    it "should return true if the user is a member of the superuser group" do
+      DulHydra.superuser_group = "superusers"
+      allow(subject).to receive(:groups).and_return(["superusers"])
+      expect(subject).to be_authorized_to_act_as_superuser
+    end
+  end
+
+  describe "#principal_name" do
+    it "should return the principal name for the user" do
+      expect(subject.principal_name).to eq subject.user_key
+    end
+  end
+
+  describe "#principals" do
+    it "should be a list of the user's groups + the user's principal_name" do
+      allow(subject).to receive(:groups) { ["foo", "bar"] }
+      expect(subject.principals).to match_array ["foo", "bar", subject.principal_name]
+    end
+  end
+
+  describe "#has_role?" do
+    let(:obj) { double }
+    it "should send :principal_has_role? to the object with the user's principals" do
+      expect(obj).to receive(:principal_has_role?).with(subject.principals, :administrator)
+      subject.has_role?(obj, :administrator)
+    end
+  end
+
+end

data/spec/services/group_service_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Ddr
+  module Auth
+    RSpec.describe GroupService do  
+      subject { described_class.new }
+      
+      describe "#groups" do
+        describe "at minimum" do
+          it "should include the 'public' and 'registered' groups" do
+            expect(subject.groups).to include("public", "registered")
+          end
+        end
+        describe "using #append_groups hook" do
+          before { allow(subject).to receive(:append_groups).and_return(["spam:eggs", "fish:water"]) }
+          it "should add the groups to the list" do
+            expect(subject.groups).to include("spam:eggs", "fish:water")
+          end
+        end
+        describe "when RoleMapper config file is present and not empty" do
+          before do
+            allow(described_class).to receive(:include_role_mapper_groups).and_return(true)
+            allow(RoleMapper).to receive(:role_names).and_return(["foo", "bar"])
+          end
+          it "should include the role mapper groups" do
+            expect(subject.groups).to include("foo", "bar")
+          end
+        end
+        describe "when RoleMapper config file is missing or empty" do
+          before { allow(described_class).to receive(:include_role_mapper_groups).and_return(false) }
+          it "should only include the default minimum groups" do
+            expect(subject.groups).to match_array(["public", "registered"])
+          end
+        end
+      end
+      
+      describe "#user_groups(user)" do
+        describe "when user is not persisted" do
+          let(:user) { FactoryGirl.build(:user) }
+          it "should return only 'public' group" do
+            expect(subject.user_groups(user)).to eq(["public"])
+          end
+        end
+        describe "when the user is persisted" do
+          let(:user) { FactoryGirl.create(:user) }
+          it "should include the 'public' and 'registered' groups" do
+            expect(subject.user_groups(user)).to include("public", "registered")
+          end
+          describe "using #append_user_groups(user) hook" do
+            before { allow(subject).to receive(:append_user_groups).with(user).and_return(["spam:eggs", "fish:water"]) }
+            it "should add the groups to the list" do
+              expect(subject.user_groups(user)).to include("spam:eggs", "fish:water")
+            end
+          end
+          describe "when the RoleMapper config file is present and not empty" do
+            before do
+              allow(described_class).to receive(:include_role_mapper_groups).and_return(true)
+              allow(RoleMapper).to receive(:roles).with(user).and_return(["foo", "bar"])
+            end
+            it "should add the user's roles to the list" do
+              expect(subject.user_groups(user)).to include("foo", "bar")
+            end
+          end
+          describe "when RoleMapper config file is missing or empty" do
+            before { allow(described_class).to receive(:include_role_mapper_groups).and_return(false) }
+            it "should only include the default minimum groups" do
+              expect(subject.groups).to match_array(["public", "registered"])
+            end
+          end
+        end
+      end
+    end
+  end
+end
+    

data/spec/services/group_service_spec.rb~

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe DulHydra::Services::GroupService do  
+  subject { described_class.new }
+  
+  describe "#groups" do
+    describe "at minimum" do
+      it "should include the 'public' and 'registered' groups" do
+        expect(subject.groups).to include("public", "registered")
+      end
+    end
+    describe "using #append_groups hook" do
+      before { allow(subject).to receive(:append_groups).and_return(["spam:eggs", "fish:water"]) }
+      it "should add the groups to the list" do
+        expect(subject.groups).to include("spam:eggs", "fish:water")
+      end
+    end
+    describe "when RoleMapper config file is present and not empty" do
+      before do
+        allow(described_class).to receive(:include_role_mapper_groups).and_return(true)
+        allow(RoleMapper).to receive(:role_names).and_return(["foo", "bar"])
+      end
+      it "should include the role mapper groups" do
+        expect(subject.groups).to include("foo", "bar")
+      end
+    end
+    describe "when RoleMapper config file is missing or empty" do
+      before { allow(described_class).to receive(:include_role_mapper_groups).and_return(false) }
+      it "should only include the default minimum groups" do
+        expect(subject.groups).to match_array(["public", "registered"])
+      end
+    end
+  end
+  
+  describe "#user_groups(user)" do
+    describe "when user is not persisted" do
+      let(:user) { FactoryGirl.build(:user) }
+      it "should return only 'public' group" do
+        expect(subject.user_groups(user)).to eq(["public"])
+      end
+    end
+    describe "when the user is persisted" do
+      let(:user) { FactoryGirl.create(:user) }
+      it "should include the 'public' and 'registered' groups" do
+        expect(subject.user_groups(user)).to include("public", "registered")
+      end
+      describe "using #append_user_groups(user) hook" do
+        before { allow(subject).to receive(:append_user_groups).with(user).and_return(["spam:eggs", "fish:water"]) }
+        it "should add the groups to the list" do
+          expect(subject.user_groups(user)).to include("spam:eggs", "fish:water")
+        end
+      end
+      describe "when the RoleMapper config file is present and not empty" do
+        before do
+          allow(described_class).to receive(:include_role_mapper_groups).and_return(true)
+          allow(RoleMapper).to receive(:roles).with(user).and_return(["foo", "bar"])
+        end
+        it "should add the user's roles to the list" do
+          expect(subject.user_groups(user)).to include("foo", "bar")
+        end
+      end
+      describe "when RoleMapper config file is missing or empty" do
+        before { allow(described_class).to receive(:include_role_mapper_groups).and_return(false) }
+        it "should only include the default minimum groups" do
+          expect(subject.groups).to match_array(["public", "registered"])
+        end
+      end
+    end
+  end
+end
+

data/spec/services/id_service_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe Ddr::Services::IdService do
+
+  before { FileUtils.rm(Ddr::Models.minter_statefile) if File.exists?(Ddr::Models.minter_statefile)}
+  after { FileUtils.rm(Ddr::Models.minter_statefile) }
+  
+  context "identifier format" do
+    before { allow(Ddr::Services::IdService).to receive(:noid_template).and_return("x.rddeeddeek") }
+    it "should mint identifiers of the appropriate format" do
+      expect(Ddr::Services::IdService.mint).to match(/x\d\d\w\w\d\d\w\w\w/)
+    end
+  end
+  
+  context "duplicate identifiers" do
+    before do
+      allow(Ddr::Services::IdService).to receive(:noid_template).and_return(".rd")
+      Ddr::Models::MintedId.create(minted_id: '0')
+      Ddr::Models::MintedId.create(minted_id: '1')
+      Ddr::Models::MintedId.create(minted_id: '2')
+      Ddr::Models::MintedId.create(minted_id: '3')
+      Ddr::Models::MintedId.create(minted_id: '4')
+      Ddr::Models::MintedId.create(minted_id: '6')
+      Ddr::Models::MintedId.create(minted_id: '7')
+      Ddr::Models::MintedId.create(minted_id: '8')
+      Ddr::Models::MintedId.create(minted_id: '9')
+    end
+    it "should not mint an already existing identifier" do
+      expect(Ddr::Services::IdService.mint).to eq('5') 
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,125 @@
+ENV['RAILS_ENV'] ||= "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+
+require "ddr-models"
+require "rails"
+require "rspec/rails"
+require "factory_girl_rails"
+require "database_cleaner"
+
+Dir[File.join(File.dirname(__FILE__), "support", "*.rb")].each { |f| require f }
+
+DatabaseCleaner.strategy = :truncation
+
+require "ddr-antivirus"
+Ddr::Antivirus.scanner_adapter = :null
+
+require "logger"
+Ddr::Antivirus.logger = Logger.new(File::NULL)
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+
+  config.include ActionDispatch::TestProcess
+  config.fixture_path = File.join(Ddr::Models::Engine.root, "spec", "fixtures")
+  config.use_transactional_fixtures = true  
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  #config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  #config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.before(:suite) do
+    DatabaseCleaner.clean
+    ActiveFedora::Base.destroy_all
+    Ddr::Models.external_file_store = Dir.mktmpdir
+  end
+
+  config.after(:suite) do
+    FileUtils.remove_entry_secure Ddr::Models.external_file_store
+  end
+
+  config.after(:each) do
+    ActiveFedora::Base.destroy_all
+  end
+
+end

data/spec/support/shared_examples_for_access_controllables.rb

@@ -0,0 +1,6 @@
+RSpec.shared_examples "an access controllable object" do
+  it "should have a rightsMetadata datastream" do
+    expect(subject.datastreams.keys).to include("rightsMetadata")
+    expect(subject.datastreams["rightsMetadata"]).to be_kind_of(Hydra::Datastream::RightsMetadata)
+  end
+end

data/spec/support/shared_examples_for_associations.rb

@@ -0,0 +1,8 @@
+RSpec.shared_examples "it has an association" do |macro, association, property, class_name|
+  it "via a certain property" do
+    expect(described_class.reflect_on_association(association).options[:property]).to eq property
+  end
+  it "targeting a certain class name" do
+    expect(described_class.reflect_on_association(association).options[:class_name]).to eq class_name
+  end
+end

data/spec/support/shared_examples_for_ddr_models.rb

@@ -0,0 +1,7 @@
+RSpec.shared_examples "a DDR model" do
+  it_behaves_like "a describable object"
+  it_behaves_like "a governable object"
+  it_behaves_like "an access controllable object"
+  it_behaves_like "an object that has properties"
+  it_behaves_like "an object that has a display title"
+end

data/spec/support/shared_examples_for_describables.rb

@@ -0,0 +1,63 @@
+RSpec.shared_examples "a describable object" do
+  let(:object) { described_class.new }
+  context "having an identifier" do
+    before do
+      object.identifier = ["id001"]
+      object.save(validate: false)
+    end
+    it "should be findable by identifier" do
+      expect(described_class.find_by_identifier('id001')).to include object
+    end
+  end
+  describe "#desc_metadata_terms" do
+    it "should have a default value" do
+      expect(object.desc_metadata_terms).to eq Ddr::Datastreams::DescriptiveMetadataDatastream.term_names
+    end
+    describe "arguments" do
+      it "with fixed results" do
+        expect(object.desc_metadata_terms(:dcterms)).to eq(Ddr::Metadata::Vocabulary.term_names(RDF::DC11) + (Ddr::Metadata::Vocabulary.term_names(RDF::DC) - Ddr::Metadata::Vocabulary.term_names(RDF::DC11)))
+        expect(object.desc_metadata_terms(:dcterms)).to match_array Ddr::Metadata::Vocabulary.term_names(RDF::DC)
+        expect(object.desc_metadata_terms(:duke)).to eq Ddr::Metadata::Vocabulary.term_names(Ddr::Metadata::DukeTerms)
+        expect(object.desc_metadata_terms(:dcterms_elements11)).to eq Ddr::Metadata::Vocabulary.term_names(RDF::DC11)
+        expect(object.desc_metadata_terms(:defined_attributes)).to match_array Ddr::Metadata::Vocabulary.term_names(RDF::DC11)
+      end
+      context "with variable results" do
+        before do
+          object.descMetadata.title = ["Object Title"]
+          object.descMetadata.creator = ["Duke University Libraries"]
+          object.descMetadata.identifier = ["id001"]
+          object.save
+        end
+        it "should accept an :empty argument" do
+          expect(object.desc_metadata_terms(:empty)).to eq(object.desc_metadata_terms - [:title, :creator, :identifier])
+        end
+        it "should accept a :present argument" do
+          expect(object.desc_metadata_terms(:present)).to match_array [:title, :creator, :identifier]
+        end
+      end
+    end
+  end
+  describe "#set_desc_metadata" do
+    let(:term_values_hash) { object.desc_metadata_terms.each_with_object({}) {|t, memo| memo[t] = ["Value"]} }
+    it "should set the descMetadata terms to the values of the matching keys in the hash" do
+      object.desc_metadata_terms.each do |t|
+        expect(object).to receive(:set_desc_metadata_values).with(t, ["Value"])
+      end
+      object.set_desc_metadata(term_values_hash)
+    end
+  end
+  describe "#set_desc_metadata_values" do
+    context "when values == nil" do
+      it "should set the term to an empty value" do
+        object.set_desc_metadata_values(:title, nil)
+        expect(object.descMetadata.title).to be_empty
+      end
+    end
+    context "when values is an array" do
+      it "should reject empty values from the array" do
+        object.set_desc_metadata_values(:title, ["Object Title", nil, "Alternative Title", ""])
+        expect(object.descMetadata.title).to eq ["Object Title", "Alternative Title"]
+      end
+    end
+  end
+end