ddr-models 2.7.6 → 2.8.0.rc1

data/lib/ddr/models/language.rb

@@ -0,0 +1,31 @@
+require "active_resource"
+
+module Ddr::Models
+  class Language < ActiveResource::Base
+
+    self.site = ENV["DDR_AUX_API_URL"]
+
+    def self.call(obj)
+      obj.language.map do |lang|
+        find_by_code(lang)
+      end
+    rescue ActiveResource::ResourceNotFound => e
+      raise Ddr::Models::NotFoundError, e
+    end
+
+    def self.find_by_code(code)
+      return unless code
+      new get(:find, code: code)
+    end
+
+    def self.codes
+      all.map(&:code)
+    end
+
+    def to_s
+      label
+    end
+
+  end
+end
+

data/lib/ddr/models/media_type.rb

@@ -0,0 +1,22 @@
+module Ddr::Models
+  class MediaType
+
+    def self.call(file_or_path)
+      path = file_or_path.respond_to?(:path) ? file_or_path.path : file_or_path
+      # Use preferred media type, if available
+      media_type = Ddr::Models.preferred_media_types[File.extname(path)]
+      if !media_type
+        if file_or_path.respond_to?(:content_type)
+          # Rails ActionDispatch::Http::UploadedFile
+          media_type = file_or_path.content_type
+        else
+          # Fall back to first MIME type or default
+          mime_types = MIME::Types.of(path)
+          media_type = mime_types.empty? ? Ddr::Models.default_mime_type : mime_types.first.content_type
+        end
+      end
+      media_type
+    end
+
+  end
+end

data/lib/ddr/models/{licenses/license.rb → rights_statement.rb}

@@ -1,17 +1,13 @@
 require "active_resource"
 
 module Ddr::Models
-  class License < ActiveResource::Base
+  class RightsStatement < ActiveResource::Base
 
     self.site = ENV["DDR_AUX_API_URL"]
 
-    attr_accessor :pid
-
     def self.call(obj)
-      if obj.license
-        license = new get(:find, url: obj.license)
-        license.pid = obj.pid
-        license
+      if obj.rights.present?
+        new get(:find, url: obj.rights.first)
       end
     rescue ActiveResource::ResourceNotFound => e
       raise Ddr::Models::NotFoundError, e

data/lib/ddr/models/solr_document.rb

@@ -3,6 +3,9 @@ require 'json'
 module Ddr::Models
   module SolrDocument
     extend ActiveSupport::Concern
+    extend Deprecation
+
+    self.deprecation_horizon = 'ddr-models v3.0'
 
     included do
       alias_method :pid, :id
@@ -176,9 +179,11 @@ module Ddr::Models
       active_fedora_model.tableize
     end
 
-    def effective_license
-      @effective_license ||= EffectiveLicense.call(self)
+    def rights_statement
+      @rights_statement ||= RightsStatement.call(self)
     end
+    alias_method :effective_license, :rights_statement
+    deprecation_deprecate :effective_license
 
     def roles
       @roles ||= Ddr::Auth::Roles::DetachedRoleSet.from_json(access_role)
@@ -228,6 +233,21 @@ module Ddr::Models
       end
     end
 
+    def streamable?
+      has_datastream?(Ddr::Datastreams::STREAMABLE_MEDIA)
+    end
+
+    def streamable_media_path
+      if streamable?
+        Ddr::Utils.path_from_uri(datastreams[Ddr::Datastreams::STREAMABLE_MEDIA]["dsLocation"])
+      end
+    end
+
+    # FIXME - Probably need a more general solution mapping object reader methods to index field names.
+    def rights
+      self["rights_tesim"]
+    end
+
     private
 
     def targets_query

data/lib/ddr/models/streamable.rb

@@ -0,0 +1,22 @@
+module Ddr::Models
+  module Streamable
+    extend ActiveSupport::Concern
+
+    included do
+      has_file_datastream name: Ddr::Datastreams::STREAMABLE_MEDIA,
+                          type: Ddr::Datastreams::StreamableMediaDatastream,
+                          versionable: true,
+                          label: "Streamable media file for this object",
+                          control_group: "E"
+    end
+
+    def streamable_media_type
+      datastreams[Ddr::Datastreams::STREAMABLE_MEDIA].mimeType
+    end
+
+    def streamable_media_path
+      datastreams[Ddr::Datastreams::STREAMABLE_MEDIA].file_path
+    end
+
+  end
+end

data/lib/ddr/models/version.rb

@@ -1,5 +1,5 @@
 module Ddr
   module Models
-    VERSION = "2.7.6"
+    VERSION = "2.8.0.rc1"
   end
 end

data/lib/ddr/utils.rb

@@ -1,6 +1,7 @@
 require 'openssl'
 
 module Ddr::Utils
+  extend Deprecation
 
   def self.digest content, algorithm
     raise TypeError, "Algorithm must be a string: #{algorithm.inspect}" unless algorithm.is_a?(String)
@@ -14,10 +15,9 @@ module Ddr::Utils
   # file can be a File object or file path (String)
   # @return [String] the mime type or default
   def self.mime_type_for(file, file_name=nil)
-    return file.content_type if file.respond_to?(:content_type) # E.g., Rails uploaded file
-    path = file_name || file_path(file) rescue nil
-    mime_types = MIME::Types.of(path) rescue []                 # MIME::Types.of blows up on nil
-    mime_types.empty? ? Ddr::Models.default_mime_type : mime_types.first.content_type
+    Deprecation.warn(self, "`Ddr::Utils.mime_type_for` is deprecated and will be removed in ddr-models 3.0." \
+                           " Use `Ddr::Models::MediaType.call(file)` instead. (called from #{caller.first})")
+    Ddr::Models::MediaType.call(file_name || file)
   end
 
   def self.file_or_path?(file)

data/lib/ddr/vocab/asset.rb

@@ -35,5 +35,13 @@ module Ddr::Vocab
              label: "Rights Note",
              comment: "Free-text statement about the rights status of the resource."
 
+    property "alephId",
+             label: "Aleph ID",
+             comment: "The Aleph identifier for a catalog record corresponding to the object."
+
+    property "affiliation",
+             label: "Affiliation",
+             comment: "An organizational entity associated with the object content."
+
   end
 end

data/spec/factories/collection_factories.rb

@@ -2,6 +2,7 @@ FactoryGirl.define do
 
   factory :collection do
     title [ "Test Collection" ]
+    admin_set "foo"
     sequence(:identifier) { |n| [ "coll%05d" % n ] }
   end
 

data/spec/index/fields_spec.rb

@@ -141,6 +141,18 @@ module Ddr::Index
         its(:heading) { is_expected.to eq "interviewer_name_facet" }
       end
 
+      describe "LANGUAGE_FACET" do
+        subject { Fields::LANGUAGE_FACET }
+        its(:label) { is_expected.to eq "Language Facet" }
+        its(:heading) { is_expected.to eq "language_facet" }
+      end
+
+      describe "LANGUAGE_NAME" do
+        subject { Fields::LANGUAGE_NAME }
+        its(:label) { is_expected.to eq "Language Name" }
+        its(:heading) { is_expected.to eq "language_name" }
+      end
+
       describe "LITHOGRAPHER_FACET" do
         subject { Fields::LITHOGRAPHER_FACET }
         its(:label) { is_expected.to eq "Lithographer Facet" }
@@ -225,6 +237,12 @@ module Ddr::Index
         its(:heading) { is_expected.to eq "setting_facet" }
       end
 
+      describe "STREAMABLE_MEDIA_TYPE" do
+        subject { Fields::STREAMABLE_MEDIA_TYPE }
+        its(:label) { is_expected.to eq "Streamable Media Type" }
+        its(:heading) { is_expected.to eq "streamable_media_type" }
+      end
+
       describe "SUBSERIES_FACET" do
         subject { Fields::SUBSERIES_FACET }
         its(:label) { is_expected.to eq "Subseries Facet" }

data/spec/managers/derivatives_manager_spec.rb

@@ -101,15 +101,12 @@ module Ddr::Managers
           object.reload
         end
         it "uses the intermediate file as the derivative source" do
-          expect(object.intermediateFile).to receive(:content).and_call_original
-          expect(object.content).to_not receive(:content)
-          object.derivatives.generate_derivative! Ddr::Derivatives::DERIVATIVES[:multires_image]
+          expect(object.derivatives.source_datastream).to equal(object.datastreams[Ddr::Datastreams::INTERMEDIATE_FILE])
         end
       end
       describe "object does not have intermediate file" do
         it "uses the content file as the derivative source" do
-          expect(object.content).to receive(:content).and_call_original
-          object.derivatives.generate_derivative! Ddr::Derivatives::DERIVATIVES[:multires_image]
+          expect(object.derivatives.source_datastream).to equal(object.datastreams[Ddr::Datastreams::CONTENT])
         end
       end
     end

data/spec/models/active_fedora_base_spec.rb

@@ -24,4 +24,7 @@ RSpec.describe ActiveFedora::Base do
     end
   end
 
+  its(:can_be_streamable?) { is_expected.to be false }
+  it { is_expected.not_to be_streamable }
+
 end

data/spec/models/admin_set_spec.rb

@@ -1,5 +1,5 @@
 module Ddr::Models
-  RSpec.describe AdminSet, ddr_aux: true do
+  RSpec.describe AdminSet, ddr_aux: true, admin_set: true do
 
     describe ".call" do
       let(:obj) { Item.new }
@@ -30,6 +30,7 @@ module Ddr::Models
 
       describe "when the object does not have an admin set" do
         it "returns nil" do
+          expect(described_class).to receive(:find_by_code).and_call_original
           expect(described_class.call(obj)).to be_nil
         end
       end

data/spec/models/attachment_spec.rb

@@ -5,5 +5,6 @@ RSpec.describe Attachment, type: :model, attachments: true do
   it_behaves_like "it has an association", :belongs_to, :attached_to, :is_attached_to, "ActiveFedora::Base"
   it_behaves_like "a non-collection model"
   it_behaves_like "an unpublishable object"
+  it_behaves_like "an object that cannot be streamable"
 
 end

data/spec/models/collection_spec.rb

@@ -1,22 +1,19 @@
-require 'spec_helper'
-
 RSpec.describe Collection, type: :model do
 
-  subject { described_class.new(title: ["Test Collection"]) }
+  subject { described_class.new(title: ["Test Collection"], admin_set: "foo") }
 
   it_behaves_like "a DDR model"
   it_behaves_like "it has an association", :has_many, :children, :is_member_of_collection, "Item"
   it_behaves_like "it has an association", :has_many, :targets, :is_external_target_for, "Target"
   it_behaves_like "a publishable object"
+  it_behaves_like "an object that cannot be streamable"
 
   describe "admin set" do
-    let(:admin_set) { Ddr::Models::AdminSet.new(code: "foobar", title: "FooBar") }
     before do
-      allow(Ddr::Models::AdminSet).to receive(:find_by_code).with("foobar") { admin_set }
-      subject.admin_set = "foobar"
+      subject.admin_set = "foo"
     end
     it "indexes the admin set title" do
-      expect(subject.to_solr[Ddr::Index::Fields::ADMIN_SET_TITLE]).to eq("FooBar")
+      expect(subject.to_solr[Ddr::Index::Fields::ADMIN_SET_TITLE]).to eq("Foo Admin Set")
     end
   end
 

data/spec/models/component_spec.rb

@@ -7,6 +7,7 @@ RSpec.describe Component, type: :model, components: true do
   it_behaves_like "a non-collection model"
   it_behaves_like "a potentially publishable object"
   it_behaves_like "an object that can have an intermediate file"
+  it_behaves_like "an object that can be streamable"
 
   describe "indexing" do
     subject { FactoryGirl.build(:component) }
@@ -50,18 +51,32 @@ RSpec.describe Component, type: :model, components: true do
         end
       end
       describe "service file" do
-        describe "with multires image" do
+        let(:service_files) { struct.uses[Ddr::Models::Structure::USE_SERVICE_FILE].map(&:href) }
+        describe "with multires image but not streamable media" do
+          before { allow(subject).to receive(:has_multires_image?) { true } }
+          it "has the correct structure file" do
+            expect(service_files).to contain_exactly(Ddr::Datastreams::MULTIRES_IMAGE)
+          end
+        end
+        describe "with streamable media but not multires image" do
+          before { allow(subject).to receive(:streamable?) { true } }
+          it "has the correct structure file" do
+            expect(service_files).to contain_exactly(Ddr::Datastreams::STREAMABLE_MEDIA)
+          end
+        end
+        describe "with both multires image and streamable media" do
           before do
             allow(subject).to receive(:has_multires_image?) { true }
+            allow(subject).to receive(:streamable?) { true }
           end
           it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_SERVICE_FILE].first.href)
-                                                                            .to eq(Ddr::Datastreams::MULTIRES_IMAGE)
+            expect(service_files).to contain_exactly(Ddr::Datastreams::MULTIRES_IMAGE,
+                                                     Ddr::Datastreams::STREAMABLE_MEDIA)
           end
         end
-        describe "without multires image" do
+        describe "with neither multires image nor streamable media" do
           it "has the correct structure file" do
-            expect(struct.uses[Ddr::Models::Structure::USE_SERVICE_FILE].first.href).to eq(Ddr::Datastreams::CONTENT)
+            expect(service_files).to contain_exactly(Ddr::Datastreams::CONTENT)
           end
         end
       end

data/spec/models/has_struct_metadata_spec.rb

@@ -33,7 +33,6 @@ module Ddr::Models
       end
       it "should index the JSON representation of the structures" do
         indexing = item.to_solr
-        expect(indexing[Ddr::Index::Fields::STRUCT]).to eq(expected_json)
         expect(indexing[Ddr::Index::Fields::STRUCTURE]).to eq(expected_json)
       end
       describe "structure source" do

data/spec/models/indexing_spec.rb

@@ -13,6 +13,8 @@ module Ddr::Models
 
       before do
         obj.adminMetadata.doi << "http://doi.org/10.1000/182"
+        obj.affiliation << "Talk to me in the back alley."
+        obj.aleph_id = "lkheajklfwbsef"
         obj.aspace_id = "aspace_dccea43034e1b8261e14cf999e86449d"
         obj.display_format = "Image"
         obj.ingested_by = "foo@bar.com"
@@ -52,47 +54,53 @@ module Ddr::Models
         obj.set_desc_metadata_values(:volume, "100")
       end
 
-      its([Indexing::ACCESS_ROLE]) { is_expected.to eq(obj.roles.to_json) }
-      its([Indexing::ARRANGER_FACET]) { is_expected.to eq(["Arranger Value"]) }
-      its([Indexing::ASPACE_ID]) { is_expected.to eq("aspace_dccea43034e1b8261e14cf999e86449d") }
-      its([Indexing::CATEGORY_FACET]) { is_expected.to eq(["Category Value"]) }
-      its([Indexing::COMPANY_FACET]) { is_expected.to eq(["Company Value"]) }
-      its([Indexing::COMPOSER_FACET]) { is_expected.to eq(["Composer Value"]) }
-      its([Indexing::DC_IS_PART_OF]) { is_expected.to eq(["RL10059CS1010"])}
-      its([Indexing::DISPLAY_FORMAT]) { is_expected.to eq("Image") }
-      its([Indexing::DOI]) { is_expected.to eq(["http://doi.org/10.1000/182"]) }
-      its([Indexing::ENGRAVER_FACET]) { is_expected.to eq(["Engraver Value"]) }
-      its([Indexing::FOLDER_FACET]) { is_expected.to eq(["Folder Value"]) }
-      its([Indexing::GENRE_FACET]) { is_expected.to eq(["Genre Value"]) }
-      its([Indexing::ILLUSTRATED_FACET]) { is_expected.to eq(["Illustrated Value"]) }
-      its([Indexing::ILLUSTRATOR_FACET]) { is_expected.to eq(["Illustrator Value"]) }
-      its([Indexing::INGESTED_BY]) { is_expected.to eq("foo@bar.com") }
-      its([Indexing::INGESTION_DATE]) { is_expected.to eq("2017-01-13T18:55:29Z") }
-      its([Indexing::INSTRUMENTATION_FACET]) { is_expected.to eq(["Instrumentation Value"]) }
-      its([Indexing::INTERVIEWER_NAME_FACET]) { is_expected.to eq(["Interviewer Name Value"]) }
-      its([Indexing::IS_FORMAT_OF]) { is_expected.to eq(["ark:/99999/fk4aaa"]) }
-      its([Indexing::LICENSE]) { is_expected.to eq("cc-by-nc-nd-40") }
-      its([Indexing::LITHOGRAPHER_FACET]) { is_expected.to eq(["Lithographer Value"]) }
-      its([Indexing::LOCAL_ID]) { is_expected.to eq("foo") }
-      its([Indexing::LYRICIST_FACET]) { is_expected.to eq(["Lyricist Value"]) }
-      its([Indexing::MEDIUM_FACET]) { is_expected.to eq(["Medium Value"]) }
-      its([Indexing::PERFORMER_FACET]) { is_expected.to eq(["Performer Value"]) }
-      its([Indexing::PERMANENT_ID]) { is_expected.to eq("ark:/99999/fk4zzz") }
-      its([Indexing::PERMANENT_URL]) { is_expected.to eq("http://id.library.duke.edu/ark:/99999/fk4zzz") }
-      its([Indexing::PLACEMENT_COMPANY_FACET]) { is_expected.to eq(["Placement Company Value"]) }
-      its([Indexing::POLICY_ROLE]) { is_expected.to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first) }
-      its([Indexing::PRODUCER_FACET]) { is_expected.to eq(["Producer Value"]) }
-      its([Indexing::PRODUCT_FACET]) { is_expected.to eq(["Product Value"]) }
-      its([Indexing::PUBLICATION_FACET]) { is_expected.to eq(["Publication Value"]) }
-      its([Indexing::RESOURCE_ROLE]) { is_expected.to contain_exactly(role1.agent.first) }
-      its([Indexing::RIGHTS_NOTE]) { is_expected.to eq(["Public domain"]) }
-      its([Indexing::ROLL_NUMBER_FACET]) { is_expected.to eq(["10"]) }
-      its([Indexing::SETTING_FACET]) { is_expected.to eq(["Setting Value"]) }
-      its([Indexing::SUBSERIES_FACET]) { is_expected.to eq(["Subseries Value"]) }
-      its([Indexing::TEMPORAL_FACET]) { is_expected.to eq(["Temporal Value"]) }
-      its([Indexing::TONE_FACET]) { is_expected.to eq(["Tone Value"]) }
-      its([Indexing::VOLUME_FACET]) { is_expected.to eq(["100"]) }
-
+      specify {
+        expect(subject[Indexing::ACCESS_ROLE]).to eq(obj.roles.to_json)
+        expect(subject[Indexing::ADMIN_SET_TITLE]).to be_nil
+        expect(subject[Indexing::AFFILIATION]).to eq(["Talk to me in the back alley."])
+        expect(subject[Indexing::AFFILIATION_FACET]).to eq(["Talk to me in the back alley."])
+        expect(subject[Indexing::ALEPH_ID]).to eq "lkheajklfwbsef"
+        expect(subject[Indexing::ARRANGER_FACET]).to eq(["Arranger Value"])
+        expect(subject[Indexing::ASPACE_ID]).to eq("aspace_dccea43034e1b8261e14cf999e86449d")
+        expect(subject[Indexing::CATEGORY_FACET]).to eq(["Category Value"])
+        expect(subject[Indexing::COMPANY_FACET]).to eq(["Company Value"])
+        expect(subject[Indexing::COMPOSER_FACET]).to eq(["Composer Value"])
+        expect(subject[Indexing::DC_IS_PART_OF]).to eq(["RL10059CS1010"])
+        expect(subject[Indexing::DISPLAY_FORMAT]).to eq("Image")
+        expect(subject[Indexing::DOI]).to eq(["http://doi.org/10.1000/182"])
+        expect(subject[Indexing::ENGRAVER_FACET]).to eq(["Engraver Value"])
+        expect(subject[Indexing::FOLDER_FACET]).to eq(["Folder Value"])
+        expect(subject[Indexing::GENRE_FACET]).to eq(["Genre Value"])
+        expect(subject[Indexing::ILLUSTRATED_FACET]).to eq(["Illustrated Value"])
+        expect(subject[Indexing::ILLUSTRATOR_FACET]).to eq(["Illustrator Value"])
+        expect(subject[Indexing::INGESTED_BY]).to eq("foo@bar.com")
+        expect(subject[Indexing::INGESTION_DATE]).to eq("2017-01-13T18:55:29Z")
+        expect(subject[Indexing::INSTRUMENTATION_FACET]).to eq(["Instrumentation Value"])
+        expect(subject[Indexing::INTERVIEWER_NAME_FACET]).to eq(["Interviewer Name Value"])
+        expect(subject[Indexing::IS_FORMAT_OF]).to eq(["ark:/99999/fk4aaa"])
+        expect(subject[Indexing::LICENSE]).to eq("cc-by-nc-nd-40")
+        expect(subject[Indexing::LITHOGRAPHER_FACET]).to eq(["Lithographer Value"])
+        expect(subject[Indexing::LOCAL_ID]).to eq("foo")
+        expect(subject[Indexing::LYRICIST_FACET]).to eq(["Lyricist Value"])
+        expect(subject[Indexing::MEDIUM_FACET]).to eq(["Medium Value"])
+        expect(subject[Indexing::PERFORMER_FACET]).to eq(["Performer Value"])
+        expect(subject[Indexing::PERMANENT_ID]).to eq("ark:/99999/fk4zzz")
+        expect(subject[Indexing::PERMANENT_URL]).to eq("http://id.library.duke.edu/ark:/99999/fk4zzz")
+        expect(subject[Indexing::PLACEMENT_COMPANY_FACET]).to eq(["Placement Company Value"])
+        expect(subject[Indexing::POLICY_ROLE]).to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first)
+        expect(subject[Indexing::PRODUCER_FACET]).to eq(["Producer Value"])
+        expect(subject[Indexing::PRODUCT_FACET]).to eq(["Product Value"])
+        expect(subject[Indexing::PUBLICATION_FACET]).to eq(["Publication Value"])
+        expect(subject[Indexing::RESOURCE_ROLE]).to contain_exactly(role1.agent.first)
+        expect(subject[Indexing::RIGHTS_NOTE]).to eq(["Public domain"])
+        expect(subject[Indexing::ROLL_NUMBER_FACET]).to eq(["10"])
+        expect(subject[Indexing::SETTING_FACET]).to eq(["Setting Value"])
+        expect(subject[Indexing::STREAMABLE_MEDIA_TYPE]).to be_nil
+        expect(subject[Indexing::SUBSERIES_FACET]).to eq(["Subseries Value"])
+        expect(subject[Indexing::TEMPORAL_FACET]).to eq(["Temporal Value"])
+        expect(subject[Indexing::TONE_FACET]).to eq(["Tone Value"])
+        expect(subject[Indexing::VOLUME_FACET]).to eq(["100"])
+      }
     end
 
     describe "content-bearing object indexing" do
@@ -102,9 +110,48 @@ module Ddr::Models
         allow(obj.content).to receive(:createDate) { create_date }
       }
 
-      its([Indexing::CONTENT_CREATE_DATE]) { is_expected.to eq "2016-01-22T21:50:33Z" }
-      its([Indexing::ATTACHED_FILES_HAVING_CONTENT]) {
-        is_expected.to contain_exactly("content", "RELS-EXT", "descMetadata", "adminMetadata")
+      specify {
+        expect(subject[Indexing::CONTENT_CREATE_DATE]).to eq "2016-01-22T21:50:33Z"
+        expect(subject[Indexing::ATTACHED_FILES_HAVING_CONTENT]).to contain_exactly("content", "RELS-EXT", "descMetadata", "adminMetadata")
+        expect(subject[Indexing::CONTENT_SIZE]).to eq 230714
+        expect(subject[Indexing::CONTENT_SIZE_HUMAN]).to eq "225 KB"
+        expect(subject[Indexing::MEDIA_TYPE]).to eq "image/tiff"
+        expect(subject[Indexing::MEDIA_MAJOR_TYPE]).to eq "image"
+        expect(subject[Indexing::MEDIA_SUB_TYPE]).to eq "tiff"
+      }
+
+      describe "streamable object indexing" do
+        before {
+          obj.add_file(fixture_file_upload('bird.jpg', 'image/jpeg'), 'streamableMedia')
+          obj.save!
+        }
+        specify {
+          expect(subject[Indexing::STREAMABLE_MEDIA_TYPE]).to eq "image/jpeg"
+        }
+      end
+    end
+
+    describe "admin set title" do
+      subject { FactoryGirl.build(:item) }
+      let(:coll) { FactoryGirl.create(:collection) }
+      before do
+        subject.parent = coll
+        subject.admin_policy = coll
+      end
+      specify {
+        expect(subject.index_fields[Indexing::ADMIN_SET_TITLE]).to eq "Foo Admin Set"
+      }
+    end
+
+    describe "language name" do
+      subject { FactoryGirl.build(:item) }
+      before do
+        subject.language = ["cym", "Not a Code"]
+        subject.save!
+      end
+      specify {
+        expect(subject.index_fields[Indexing::LANGUAGE_FACET]).to eq ["Welsh", "Not a Code"]
+        expect(subject.index_fields[Indexing::LANGUAGE_NAME]).to eq ["Welsh", "Not a Code"]
       }
     end