triannon-client 0.4.2 → 0.5.0

data/spec/lib/triannon-client/triannon_client_auth_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.shared_examples "authenticate" do |auth_required|
+
+  let(:tc) {
+    if auth_required
+      triannon_config_auth
+    else
+      triannon_config_no_auth
+    end
+    TriannonClient::TriannonClient.new
+  }
+
+  def check_header
+    headers = tc.site.headers
+    expect(headers).to include(:Authorization)
+    expect(headers[:Authorization]).to match(/Bearer/)
+  end
+
+  it "- #authenticate returns #{auth_required}" do
+    if auth_required
+      expect(tc.authenticate).to be_truthy
+      check_header
+    else
+      expect(tc.authenticate).to be false
+    end
+  end
+
+  it "- #authenticate! returns #{auth_required}" do
+    # Authenticate and then test that authenticate!
+    # will reset and renew the authentication.
+    auth1 = tc.authenticate
+    check_header if auth_required
+    expect(tc.site.headers).to receive(:delete)
+    if auth_required
+      # renew the authentication
+      expect(tc.authenticate!).to be_truthy
+      check_header
+      auth2 = tc.site.headers[:Authorization]
+      expect(auth1).not_to eql(auth2)
+    else
+      expect(tc.authenticate!).to be false
+    end
+  end
+
+end
+
+
+describe 'TriannonClientAUTH', :vcr do
+
+  context 'without authentication' do
+    auth_required = false # it's not required
+    it_behaves_like 'authenticate', auth_required
+  end
+
+  context 'with authentication' do
+    auth_required = true  # it must succeed
+    it_behaves_like 'authenticate', auth_required
+  end
+
+end

data/spec/lib/triannon-client/triannon_client_class_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+# ::TriannonClient::TriannonClient class specs
+
+describe 'TriannonClientClass' do
+
+  let(:tc) {
+    triannon_config_no_auth # spec_helper
+    TriannonClient::TriannonClient.new
+  }
+
+  describe 'has constants:' do
+    it 'CONTENT_TYPES' do
+      const = TriannonClient::TriannonClient::CONTENT_TYPES
+      expect(const).to be_instance_of Array
+      expect(const).to include('application/ld+json')
+    end
+    it 'PROFILE_TYPE_IIIF' do
+      const = TriannonClient::TriannonClient::PROFILE_IIIF
+      expect(const).to be_instance_of String
+      expect(const).to include('http://iiif.io/api/presentation/2/context.json')
+    end
+    it 'PROFILE_TYPE_OA' do
+      const = TriannonClient::TriannonClient::PROFILE_OA
+      expect(const).to be_instance_of String
+      expect(const).to include('http://www.w3.org/ns/oa-context-20130208.json')
+    end
+    it 'CONTENT_TYPE_IIIF' do
+      const = TriannonClient::TriannonClient::CONTENT_TYPE_IIIF
+      expect(const).to be_instance_of String
+      expect(const).to include('application/ld+json')
+      expect(const).to include('http://iiif.io/api/presentation/2/context.json')
+    end
+    it 'CONTENT_TYPE_OA' do
+      const = TriannonClient::TriannonClient::CONTENT_TYPE_OA
+      expect(const).to be_instance_of String
+      expect(const).to include('application/ld+json')
+      expect(const).to include('http://www.w3.org/ns/oa-context-20130208.json')
+    end
+    it 'JSONLD_TYPE' do
+      const = TriannonClient::TriannonClient::JSONLD_TYPE
+      expect(const).to be_instance_of String
+      expect(const).to eql('application/ld+json')
+    end
+  end
+
+  describe 'public attributes:' do
+    # attribute accessors
+    it 'config' do
+      expect(tc).to respond_to(:config)
+    end
+    it 'site' do
+      expect(tc).to respond_to(:site)
+    end
+    it 'auth' do
+      expect(tc).to respond_to(:auth)
+    end
+    it 'container' do
+      expect(tc).to respond_to(:container)
+    end
+  end
+
+  describe 'public methods:' do
+    # methods
+    it 'authenticate' do
+      expect(tc).to respond_to(:authenticate)
+    end
+    it 'delete_annotation' do
+      expect(tc).to respond_to(:delete_annotation)
+    end
+    it 'get_annotations' do
+      expect(tc).to respond_to(:get_annotations)
+    end
+    it 'get_annotation' do
+      expect(tc).to respond_to(:get_annotation)
+    end
+    it 'get_iiif_annotation' do
+      expect(tc).to respond_to(:get_iiif_annotation)
+    end
+    it 'get_oa_annotation' do
+      expect(tc).to respond_to(:get_oa_annotation)
+    end
+    # utilities
+    it 'response2graph' do
+      expect(tc).to respond_to(:response2graph)
+    end
+    it 'annotation_id' do
+      expect(tc).to respond_to(:annotation_id)
+    end
+    it 'annotation_uris' do
+      expect(tc).to respond_to(:annotation_uris)
+    end
+  end
+
+  describe 'private:' do
+    it 'check_id' do
+      expect(tc).not_to respond_to(:check_id)
+    end
+    it 'check_content_type' do
+      expect(tc).not_to respond_to(:check_content_type)
+    end
+  end
+
+end

data/spec/lib/triannon-client/triannon_client_create_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+RSpec.shared_examples "create annotations" do |auth_required|
+
+  let(:tc) {
+    if auth_required
+      triannon_config_auth
+    else
+      triannon_config_no_auth
+    end
+    TriannonClient::TriannonClient.new
+  }
+
+  def check_authentication(required)
+    auth = tc.authenticate
+    if required
+      expect(auth).to be_truthy
+    else
+      expect(auth).to be false
+    end
+  end
+
+  let(:exception_data) { 'post_exception' }
+  let(:exception_post) {
+    {
+      "commit"=>"Create Annotation",
+      "annotation"=>{"data"=>exception_data}
+    }
+  }
+  let(:exception_msg)  { 'create_exception' }
+
+  def raise_restclient_exception(status)
+    response = double
+    allow(response).to receive(:is_a?).and_return(RestClient::Response)
+    allow(response).to receive(:headers).and_return(jsonld_content)
+    allow(response).to receive(:body).and_return(exception_msg)
+    allow(response).to receive(:code).and_return(status)
+    exception = RestClient::Exception.new(response)
+    allow_any_instance_of(RestClient::Resource).to receive(:post).with(exception_post).and_raise(exception)
+    if status == 401
+      expect(tc).to receive(:authenticate).once # retry triggers authentication
+    else
+      expect(tc).not_to receive(:authenticate)  # no retry
+    end
+  end
+
+  it 'does not raise an error when submitting a valid open annotation' do
+    check_authentication(auth_required)
+    response = nil
+    expect do
+      response = tc.post_annotation(jsonld_oa)
+    end.not_to raise_error
+    # Double check the POST by deleting the annotation.
+    # If the POST was successful, the DELETE should work too.
+    graph = tc.response2graph(response)
+    uri = tc.annotation_uris(graph).first
+    id = tc.annotation_id(uri)
+    expect(tc.delete_annotation(id)).to be true
+  end
+  it 'returns a RestClient::Response object' do
+    # The response behaves primarily as a String, so it can not be tested
+    # as an instance of RestClient::Response, but it can be tested to respond
+    # to RestClient::Response methods.
+    check_authentication(auth_required)
+    anno = create_annotation
+    r = anno[:response]
+    expect(r.is_a? RestClient::Response).to be true
+    expect(r).to respond_to(:code)
+    expect(r).to respond_to(:body)
+    expect(r).to respond_to(:headers)
+  end
+  it 'POST 401 response retries and logs RestClient::Exception message' do
+    check_authentication(auth_required)
+    raise_restclient_exception(401)
+    expect(TriannonClient.configuration.logger).to receive(:error).with(/#{exception_msg}/)
+    tc.post_annotation(exception_data)
+  end
+  it 'POST 403 response does not retry and logs RestClient::Exception message' do
+    check_authentication(auth_required)
+    raise_restclient_exception(403)
+    expect(TriannonClient.configuration.logger).to receive(:error).with(/#{exception_msg}/)
+    tc.post_annotation(exception_data)
+  end
+  it 'POST 500 response does not retry and logs RestClient::Exception message' do
+    check_authentication(auth_required)
+    raise_restclient_exception(500)
+    expect(TriannonClient.configuration.logger).to receive(:error).with(/#{exception_msg}/)
+    tc.post_annotation(exception_data)
+  end
+  it 'logs RuntimeError message' do
+    check_authentication(auth_required)
+    exception = RuntimeError.new(exception_msg)
+    allow_any_instance_of(RestClient::Resource).to receive(:post).with(exception_post).and_raise(exception)
+    expect(TriannonClient.configuration.logger).to receive(:error).with(/#{exception_msg}/)
+    tc.post_annotation(exception_data)
+  end
+end
+
+
+describe 'TriannonClientCREATE', :vcr do
+
+  after :all do
+    clear_annotations('TriannonClientCREATE/clear_annotations')
+  end
+
+  describe "#post_annotation" do
+
+    context 'without authentication' do
+      auth_required = false # it's not required
+      it_behaves_like 'create annotations', auth_required
+    end
+
+    context 'with authentication' do
+      auth_required = true  # it must succeed
+      it_behaves_like 'create annotations', auth_required
+    end
+  end
+
+end

data/spec/lib/triannon-client/triannon_client_delete_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+RSpec.shared_examples "delete annotations" do |auth_required|
+
+  let(:tc) {
+    if auth_required
+      triannon_config_auth
+    else
+      triannon_config_no_auth
+    end
+    TriannonClient::TriannonClient.new
+  }
+
+  def test_delete_for_response_code(anno_id, status, result)
+    response = double
+    allow(response).to receive(:is_a?).and_return(RestClient::Response)
+    allow(response).to receive(:headers).and_return(jsonld_content)
+    allow(response).to receive(:body).and_return('delete_annotation')
+    allow(response).to receive(:code).and_return(status)
+    exception = RestClient::Exception.new(response)
+    if [401, 404, 410, 500].include? status
+      allow_any_instance_of(RestClient::Resource).to receive(:delete).and_raise(exception)
+      if status == 401
+        expect(tc).to receive(:authenticate).once # retry triggers auth
+      else
+        expect(tc).not_to receive(:authenticate)  # no retry
+      end
+    else
+      allow_any_instance_of(RestClient::Resource).to receive(:delete).and_return(response)
+      expect(tc).not_to receive(:authenticate)  # no retry
+    end
+    expect(tc.delete_annotation(anno_id)).to be result
+  end
+  it "DELETE 200 response returns true" do
+    test_delete_for_response_code('200_is_true', 200, true)
+  end
+  it "DELETE 202 response returns true" do
+    test_delete_for_response_code('202_is_true', 202, true)
+  end
+  it "DELETE 204 response returns true" do
+    test_delete_for_response_code('204_is_true', 204, true)
+  end
+  it "DELETE 401 response initiates a retry with authentication" do
+    test_delete_for_response_code('401_is_retry', 401, false)
+  end
+  it "DELETE 404 response returns true" do
+    test_delete_for_response_code('404_is_true', 404, true)
+  end
+  it "DELETE 410 response returns true" do
+    test_delete_for_response_code('410_is_true', 410, true)
+  end
+  it "DELETE 500 response returns false" do
+    test_delete_for_response_code('500_is_false', 500, false)
+  end
+  it 'DELETE 404|410 does not log exceptions' do
+    expect(tc.config.logger).not_to receive(:error)
+    test_delete_for_response_code('404_is_true', 404, true)
+    test_delete_for_response_code('410_is_true', 410, true)
+  end
+  it 'DELETE 500 logs exceptions' do
+    expect(tc.config.logger).to receive(:error)
+    test_delete_for_response_code('500_is_false', 500, false)
+  end
+  it 'validates the annotation ID' do
+    expect(tc).to receive(:check_id)
+    tc.delete_annotation('checking_anno_id')
+  end
+  it 'raises ArgumentError for an invalid annotation ID' do
+    expect_any_instance_of(RestClient::Resource).not_to receive(:delete)
+    expect { tc.delete_annotation('')  }.to raise_error(ArgumentError)
+    expect { tc.delete_annotation(nil) }.to raise_error(ArgumentError)
+  end
+  it 'uses RestClient::Resource.delete to DELETE a valid annotation ID' do
+    expect_any_instance_of(RestClient::Resource).to receive(:delete)
+    tc.delete_annotation(SecureRandom.uuid)
+  end
+  it 'returns TRUE when deleting an annotation that exists' do
+    anno = create_annotation
+    expect( tc.delete_annotation(anno[:id]) ).to be true
+    graph = tc.get_annotation(anno[:id])
+    graph_is_empty(graph)
+  end
+  it 'returns TRUE when deleting an annotation that does NOT exist' do
+    id = 'anno_does_not_exist'
+    graph = tc.get_annotation(id)
+    graph_is_empty(graph)
+    expect( tc.delete_annotation(id) ).to be true
+  end
+
+end
+
+
+describe 'TriannonClientDELETE', :vcr do
+
+  # before :all do
+  #   # create a new annotation and call all the response processing utils.
+  #   @anno = create_annotation('TriannonClientDELETE/create_annotation')
+  # end
+
+  after :all do
+    clear_annotations('TriannonClientDELETE/clear_annotations')
+  end
+
+  describe "#delete_annotation" do
+
+    context 'without authentication' do
+      auth_required = false # it's not required
+      it_behaves_like 'delete annotations', auth_required
+    end
+
+    context 'with authentication' do
+      auth_required = true  # it must succeed
+      it_behaves_like 'delete annotations', auth_required
+    end
+  end
+
+end

data/spec/lib/triannon-client/triannon_client_read_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+# ::TriannonClient::TriannonClient GET specs
+# The GET requests do not require authentication.
+
+describe 'TriannonClientREAD', :vcr do
+
+  before :all do
+    # create a new annotation and call all the response processing utils.
+    @anno = create_annotation('TriannonClientREAD/create_annotation')
+  end
+
+  after :all do
+    clear_annotations('TriannonClientREAD/clear_annotations')
+  end
+
+  let(:tc) {
+    # triannon_config_auth
+    TriannonClient::TriannonClient.new
+  }
+
+  def request_anno_with_content_type(content_type)
+    expect_any_instance_of(RestClient::Resource).to receive(:get).with(hash_including(:accept => content_type) )
+    tc.get_annotation(@anno[:id], content_type)
+  end
+
+  def gets_anno_with_content_type(content_type)
+    graph = tc.get_annotation(@anno[:id], content_type)
+    graph_contains_open_annotation(graph, @anno[:uris])
+  end
+
+  def cannot_get_anno_with_content_type(content_type)
+    graph = tc.get_annotation(@anno[:id], content_type)
+    graph_is_empty(graph)
+  end
+
+
+  let(:exception_msg) { 'get_exception' }
+  def raise_restclient_exception(status)
+    response = double
+    allow(response).to receive(:is_a?).and_return(RestClient::Response)
+    allow(response).to receive(:headers).and_return(jsonld_content)
+    allow(response).to receive(:body).and_return(exception_msg)
+    allow(response).to receive(:code).and_return(status)
+    exception = RestClient::Exception.new(response)
+    allow_any_instance_of(RestClient::Resource).to receive(:get).with(jsonld_accept).and_raise(exception)
+  end
+
+  context 'GET' do
+
+    describe "#get_annotations" do
+      it 'returns an RDF::Graph' do
+        graph = tc.get_annotations
+        graph_contains_statements(graph)
+      end
+      it 'returns an RDF::Graph that contains an AnnotationList' do
+        graph = tc.get_annotations
+        anno_list_uri = RDF::URI.parse('http://iiif.io/api/presentation/2#AnnotationList')
+        result = graph.query([nil, nil, anno_list_uri])
+        expect(result.size).to eql(1)
+      end
+      it 'returns an annotation list with an annotation created by a prior POST' do
+        graph = tc.get_annotations
+        graph_contains_open_annotation(graph, @anno[:uris])
+      end
+      it '404 response logs exceptions for RestClient::Exception' do
+        raise_restclient_exception(404)
+        expect(tc.config.logger).to receive(:error).with(/404/)
+        tc.get_annotations
+      end
+      it '500 response returns an EMPTY RDF graph' do
+        raise_restclient_exception(500)
+        graph = tc.get_annotations
+        graph_is_empty(graph)
+      end
+      it '500 response logs exceptions for RestClient::Exception' do
+        raise_restclient_exception(500)
+        expect(tc.config.logger).to receive(:error).with(/#{exception_msg}/)
+        tc.get_annotations
+      end
+      it 'logs exceptions for RuntimeError' do
+        exception = RuntimeError.new('get_exception')
+        allow_any_instance_of(RestClient::Resource).to receive(:get).with(jsonld_accept).and_raise(exception)
+        expect(tc.config.logger).to receive(:error).with(/get_exception/)
+        tc.get_annotations
+      end
+    end
+
+    describe "#get_iiif_annotation" do
+      # the mime type is fixed for this method
+      it 'requests an open annotation by ID, using a IIIF profile' do
+        graph_contains_open_annotation(@anno[:graph], @anno[:uris])
+        content_type = TriannonClient::TriannonClient::CONTENT_TYPE_IIIF
+        expect(tc).to receive(:get_annotation).with(@anno[:id], content_type)
+        tc.get_iiif_annotation(@anno[:id])
+      end
+      it 'returns an RDF::Graph of an open annotation' do
+        graph = tc.get_iiif_annotation(@anno[:id])
+        graph_contains_statements(graph)
+        graph_contains_open_annotation(graph, @anno[:uris])
+      end
+    end
+
+    describe "#get_oa_annotation" do
+      # the mime type is fixed for this method
+      it 'requests an open annotation by ID, using an OA profile' do
+        graph_contains_open_annotation(@anno[:graph], @anno[:uris])
+        content_type = TriannonClient::TriannonClient::CONTENT_TYPE_OA
+        expect(tc).to receive(:get_annotation).with(@anno[:id], content_type)
+        tc.get_oa_annotation(@anno[:id])
+      end
+      it 'returns an RDF::Graph of an open annotation' do
+        graph = tc.get_oa_annotation(@anno[:id])
+        graph_contains_statements(graph)
+        graph_contains_open_annotation(graph, @anno[:uris])
+      end
+    end
+
+    describe '#response2graph' do
+      it 'accepts a RestClient::Response instance' do
+        r = @anno[:response]
+        expect{tc.response2graph(r)}.not_to raise_error
+      end
+      it 'returns an RDF::Graph' do
+        expect(@anno[:graph]).to be_instance_of RDF::Graph
+        graph_contains_statements(@anno[:graph])
+      end
+      it 'raises ArgumentError when given nil' do
+        expect{tc.response2graph(nil)}.to raise_error(ArgumentError)
+      end
+      it 'raises ArgumentError when given an empty String' do
+        expect{tc.response2graph('')}.to raise_error(ArgumentError)
+      end
+      it 'raises ArgumentError when response content-type is unacceptable' do
+        h = {content_type: 'unacceptable'}
+        r = double
+        allow(r).to receive(:is_a?).and_return(RestClient::Response)
+        allow(r).to receive(:headers).and_return(h)
+        expect{tc.response2graph('')}.to raise_error(ArgumentError)
+      end
+      it 'returns an empty RDF::Graph for failure to parse input' do
+        r = double
+        allow(r).to receive(:is_a?).and_return(RestClient::Response)
+        allow(r).to receive(:code).and_return(200)
+        allow(r).to receive(:headers).and_return(jsonld_content)
+        allow(r).to receive(:body).and_return('malformed json')
+        g = tc.response2graph(r)
+        expect(g).to be_instance_of RDF::Graph
+        expect(g).to be_empty
+        h = {content_type: 'application/rdf+xml'}
+        allow(r).to receive(:headers).and_return(h)
+        allow(r).to receive(:body).and_return('malformed rdf+xml')
+        g = tc.response2graph(r)
+        expect(g).to be_instance_of RDF::Graph
+        expect(g).to be_empty
+        # h = {content_type: 'application/turtle'}
+        # allow(r).to receive(:headers).and_return(h)
+        # allow(r).to receive(:body).and_return('malformed turtle')
+        # g = tc.response2graph(r)
+        # expect(g).to be_instance_of RDF::Graph
+        # expect(g).to be_empty
+      end
+      it 'logs exceptions and returns an empty RDF::Graph' do
+        r = double
+        allow(r).to receive(:is_a?).and_return(RestClient::Response)
+        allow(r).to receive(:headers).and_return(jsonld_content)
+        allow(r).to receive(:body).and_raise(RuntimeError, 'oops!')
+        expect(tc.config.logger).to receive(:error).with(/oops!/)
+        g = tc.response2graph(r)
+        expect(g).to be_instance_of RDF::Graph
+        expect(g).to be_empty
+      end
+
+
+    end
+
+    describe "#annotation_uris" do
+      it "returns an array of RDF::URI from an RDF::Graph of an annotation" do
+        expect(@anno[:graph]).to be_instance_of RDF::Graph
+        expect(@anno[:uris]).to be_instance_of Array
+        expect(@anno[:uris]).not_to be_empty
+        expect(@anno[:uris].first).to be_instance_of RDF::URI
+      end
+      it "returns an RDF::URI that is a valid URI" do
+        expect(@anno[:uris].first).to match(/\A#{URI::regexp}\z/)
+      end
+    end
+
+    describe "#annotation_id" do
+      it "returns a String ID from the RDF::URI of an annotation" do
+        expect(@anno[:uris].first).to be_instance_of RDF::URI
+        expect(@anno[:id]).to be_instance_of String
+      end
+      it "returns a String ID that is not empty" do
+        expect(@anno[:id]).to be_instance_of String
+        expect(@anno[:id]).not_to be_empty
+      end
+    end
+
+    describe "annotation by ID" do
+
+      context 'using default content type' do
+
+        it 'checks the annotation ID' do
+          expect(tc).to receive(:check_id)
+          graph = tc.get_annotation(@anno[:id])
+          graph_contains_statements(graph)
+        end
+        it 'raises an argument error with a nil ID' do
+          expect{tc.get_annotation(nil)}.to raise_error(ArgumentError)
+        end
+        it 'raises an argument error with an integer ID' do
+          expect{tc.get_annotation(0)}.to raise_error(ArgumentError)
+        end
+        it 'raises an argument error with an empty string ID' do
+          expect{tc.get_annotation('')}.to raise_error(ArgumentError)
+        end
+        it 'requests an open annotation by ID, using JSON-LD content' do
+          jsonld = TriannonClient::TriannonClient::JSONLD_TYPE
+          expect_any_instance_of(RestClient::Resource).to receive(:get).with(hash_including(:accept => jsonld) )
+          # does not work using expect(tc.container).to receive(:get) etc.
+          tc.get_annotation(@anno[:id])
+        end
+        it 'returns an RDF graph with a valid ID for an annotation on the server' do
+          graph = tc.get_annotation(@anno[:id])
+          graph_contains_open_annotation(graph, @anno[:uris])
+        end
+        it 'returns an EMPTY RDF graph with a valid ID for NO annotation on the server' do
+          id = SecureRandom.uuid
+          graph = tc.get_annotation(id)
+          graph_is_empty(graph)
+        end
+        it '404 response logs exceptions for RestClient::Exception' do
+          raise_restclient_exception(404)
+          expect(tc.config.logger).to receive(:error).with(/404/)
+          tc.get_annotation('raise_get_exception')
+        end
+        it '500 response returns an EMPTY RDF graph' do
+          raise_restclient_exception(500)
+          graph = tc.get_annotation(@anno[:id])
+          graph_is_empty(graph)
+        end
+        it '500 response logs exceptions for RestClient::Exception' do
+          raise_restclient_exception(500)
+          expect(tc.config.logger).to receive(:error).with(/#{exception_msg}/)
+          tc.get_annotation(@anno[:id])
+        end
+        it 'logs exceptions for RuntimeError' do
+          exception = RuntimeError.new('get_exception')
+          allow_any_instance_of(RestClient::Resource).to receive(:get).with(jsonld_accept).and_raise(exception)
+          expect(tc.config.logger).to receive(:error).with(/get_exception/)
+          tc.get_annotation(@anno[:id])
+        end
+      end # using default content type
+
+      context 'using custom content type' do
+        # Content types could be supported for RDF::Format.content_types.keys,
+        # but not all of them are supported.  The supported content types for
+        # triannon are defined in
+        # https://github.com/sul-dlss/triannon/blob/master/config/initializers/mime_types.rb
+        # https://github.com/sul-dlss/triannon/blob/master/app/controllers/triannon/annotations_controller.rb
+        # https://github.com/sul-dlss/triannon/blob/master/app/controllers/triannon/search_controller.rb
+        # The default content type is "application/ld+json" and, at the time of
+        # writing, triannon also supports:
+        # turtle as:  ["application/x-turtle", "text/turtle"]
+        # rdf+xml as: ["application/rdf+xml", "text/rdf+xml", "text/rdf"]
+        # json as:    ["application/json", "text/x-json", "application/jsonrequest"]
+        # xml as:     ["application/xml", "text/xml", "application/x-xml"]
+        # html
+
+        # The client supports any format in RDF::Format.content_types, so the
+        # following are not included (as of July 2015):
+        # "application/json"        => true,
+        # "application/jsonrequest" => true,
+        # "text/x-json"             => true,
+        # "text/rdf+xml"            => true,
+        # "text/rdf"                => true,
+        # "application/xml"         => true,
+        # "text/xml"                => true,
+        # "application/x-xml"       => true,
+
+        # html and xhtml are supported by RDF::Format, so they can be used,
+        # but they fail to return a proper RDF::Graph
+        # "text/html"=> true,
+        # "application/xhtml+xml"=> true,
+
+        # content types that work
+        content_types = {
+          "application/ld+json"=> true,
+          "application/rdf+xml"=> true,
+          "text/turtle"=> true,
+          "application/x-turtle"=> true,
+        }
+        # content types that fail
+        content_types.merge!({
+          "application/x-ld+json"=> false,
+          "application/rdf+json"=> false,
+          "text/rdf+turtle"=> false,
+          "application/turtle"=> false,
+          "application/n-triples"=> false,
+          "application/rdf+n3"=> false,
+          "text/n3"=> false,
+          "text/rdf+n3"=> false,
+          "text/plain"=> false,
+          "application/n-quads"=> false,
+          "text/x-nquads"=> false,
+          "application/trig"=> false,
+          "application/x-trig"=> false,
+          "application/trix"=> false,
+          "text/csv"=> false,
+          "text/tab-separated-values"=>false,
+          "application/csvm+json"=>false,
+          })
+        specs = content_types.map do |type,success|
+          request_spec = <<EOS
+it 'requests an open annotation by ID, with content type "#{type}"' do
+  request_anno_with_content_type('#{type}')
+end
+EOS
+          if success
+            get_spec = <<EOS
+it 'gets an open annotation by ID, with content type "#{type}"' do
+  gets_anno_with_content_type('#{type}')
+end
+EOS
+          else
+            get_spec = <<EOS
+it 'cannot get an open annotation by ID, with content type "#{type}"' do
+  cannot_get_anno_with_content_type('#{type}')
+end
+EOS
+          end
+          request_spec + get_spec
+        end
+        eval(specs.join)
+      end # using custom content type
+
+    end # annotation by ID
+  end # GET context
+
+end
+