farscape 1.2.0

data/spec/lib/farscape/integration/resource_crud_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'json'
+require 'active_support/core_ext/string/filters'
+
+describe Farscape::RepresentorAgent do
+  let(:entry_point) { "http://localhost:#{RAILS_PORT}"}
+
+  let(:drds_link) { Farscape::Agent.new(entry_point).enter.transitions["drds"] }
+  let(:can_do_hash) { {conditions: 'can_do_anything'} }
+  let(:name) { 'Brave New DRD' }
+  let(:attrs) { {name: name, status: 'activated', old_status: 'activated'} }
+
+  context 'can do anything' do
+
+    it 'includes appropriate transitions' do
+      drds_resource = drds_link.invoke { |req| req.parameters = can_do_hash }
+      expect(drds_resource.transitions.keys).to include('create')
+    end
+
+    it 'can create a drd' do
+      name = 'Brave New DRD'
+      drds_resource = drds_link.invoke { |req| req.parameters = can_do_hash }
+      drd = drds_resource.transitions['create'].invoke do |req|
+        req.attributes = attrs
+        req.parameters = can_do_hash
+      end
+      expect(drd.transitions['self'].invoke.attributes['name']).to eq(name)
+      drd.transitions['delete'].invoke # Cleanup, failure here should imply failure in 'can delete a drd'
+    end
+
+    context 'an existing drd' do
+      before do
+        drds_resource = drds_link.invoke { |req| req.parameters = can_do_hash }
+        @drd = drds_resource.transitions['create'].invoke do |req|
+          req.attributes = attrs
+          req.parameters = can_do_hash
+        end
+      end
+
+
+      it 'can delete a drd' do
+        # NB We compare attributes as the self link will differ between the two calls
+        recall_drds = ->() { @drd.transitions['self'].invoke { |r| r.parameters = can_do_hash }.to_hash[:attributes] }
+        drd_attributes = @drd.to_hash[:attributes]
+        self_attributes = recall_drds.call
+        expect(self_attributes).to eq(drd_attributes)
+        @drd.transitions['delete'].invoke
+        expect { recall_drds.call }.to raise_error( Farscape::Exceptions::NotFound )
+      end
+
+      it 'returns proper errors' do
+        # NB We compare attributes as the self link will differ between the two calls
+        recall_drds = ->() { @drd.transitions['self'].invoke { |r| r.parameters = can_do_hash }.to_hash[:attributes] }
+        drd_attributes = @drd.to_hash[:attributes]
+        @drd.transitions['delete'].invoke
+        begin
+          recall_drds.call
+          raise Exception.new('Moya responded with a resource that\'s been deleted')
+        rescue Farscape::Exceptions::NotFound => e
+          expect(e.error_description).to eq('The server has not found anything matching the Request-URI.
+          No indication is given of whether the condition is temporary or permanent.
+          This status code is commonly used when the server does not wish to reveal exactly why the request has been refused, or when no other response is applicable.'.squish)
+          expect(e.representor.to_hash).to eq(e.message)
+        end
+      end
+
+      it 'can update a drd' do
+        new_kind = "sentinel"
+        begin
+          @drd.transitions['update'].invoke do |r|
+            r.attributes = {kind: new_kind}
+            r.parameters = can_do_hash
+          end
+        rescue
+          #TODO: Farscape handles redirects
+        end
+        kindof = @drd.transitions['self'].invoke.attributes['kind']
+        expect(kindof).to eq(new_kind)
+      end
+
+      it 'can toggle a drds activation state' do
+        status = @drd.attributes['status']
+        action = status == 'activated' ? 'deactivate' : 'activate'
+        @drd.transitions[action].invoke { |r| r.parameters = can_do_hash }
+        new_status = @drd.transitions['self'].invoke { |r| r.parameters = can_do_hash }.attributes['status']
+        expect(status).to_not eq(new_status)
+      end
+
+    end
+  end
+
+end

data/spec/lib/farscape/logger_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'farscape/logger'
+
+describe(Farscape) do
+
+  describe 'logger' do
+
+    after(:each) { Farscape.logger = nil }
+
+    it 'defaults to the built-in Ruby logger' do
+      Farscape.logger = nil
+      expect(Farscape.logger).to be_a(::Logger)
+    end
+
+    it 'can be set to any kind of logger' do
+      custom_logger = Object.new
+      Farscape.logger = custom_logger
+      expect(Farscape.logger).to eq(custom_logger)
+    end
+
+  end
+
+end

data/spec/lib/farscape/plugins_spec.rb

@@ -0,0 +1,344 @@
+require 'spec_helper'
+
+module TestMiddleware
+  class NoGetNoProblem
+    def initialize(app, config = {})
+      @app = app
+      @config = config
+    end
+    def call(env)
+      @app.call(env).on_complete do |env|
+        unless @config[:permissive]
+          raise StandardError, "Shazam!" if env[:method] == :get
+        end
+      end
+    end
+  end
+
+  class Saboteur
+    def initialize(app, *)
+      @app = app
+    end
+    def call(env)
+      env[:sabotaged] = true
+      @app.call(env)
+    end
+  end
+
+  class SabotageDetector
+    def initialize(app, *)
+      @app = app
+    end
+    def call(env)
+      raise 'Sabotage detected' if env[:sabotaged]
+      @app.call(env)
+    end
+  end
+
+end
+
+describe Farscape::Agent do
+
+  before(:each) do
+    Farscape.clear
+    detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector], default_state: :disabled}
+    saboteur_middleware = {class: TestMiddleware::Saboteur, before: :sebacean}
+    saboteur_plugin = {name: :Saboteur, type: :scarran, middleware: [saboteur_middleware]}
+    Farscape.register_plugin(detector_plugin)
+    Farscape.register_plugin(saboteur_plugin)
+  end
+
+  after(:all) { Farscape.clear }
+
+  let(:entry_point) { "http://localhost:#{RAILS_PORT}"}
+  let(:can_do_hash) { {conditions: 'can_do_anything'} }
+
+  it 'accepts a using directive that enables a plugin' do
+    expect { Farscape::Agent.new(entry_point).using(:Detector).enter }.to raise_error('Sabotage detected')
+  end
+
+  it 'accepts an omitting directive that disables a plugin' do
+    agent = Farscape::Agent.new(entry_point).using(:Detector)
+    agent = agent.omitting(:sebacean)
+    expect { agent.enter }.to_not raise_error
+  end
+
+  it 'allows showing the list of registered plugins' do
+    expect(Farscape::Agent.new(entry_point).plugins).to eq(Farscape.plugins)
+  end
+
+  it 'allows showing only those enabled for the agent' do
+    agent = Farscape::Agent.new(entry_point).using(:Detector)
+    expect(agent.enabled_plugins[:Detector]).to_not be_nil
+    expect(Farscape.disabled_plugins[:Detector]).to_not be_nil
+  end
+
+  it 'allows showing only those disabled for the agent' do
+    agent = Farscape::Agent.new(entry_point).using(:Detector)
+    agent = agent.omitting(:sebacean)
+    expect(agent.disabled_plugins.keys).to eq([:Detector])
+    expect(Farscape.enabled_plugins.keys).to eq([:Saboteur])
+  end
+
+  it 'allows using on TransitionAgent objects' do
+    transition = Farscape::Agent.new(entry_point).enter.transitions["drds"].using(:Detector)
+    expect { transition.invoke { |req| req.parameters = can_do_hash } }.to raise_error('Sabotage detected')
+    expect(transition.disabled_plugins).to eq({})
+  end
+
+  it 'allows using on RepresentorAgent objects' do
+    representor = Farscape::Agent.new(entry_point).enter.using(:Detector)
+    transition = representor.transitions["drds"]
+    expect { transition.invoke { |req| req.parameters = can_do_hash } }.to raise_error('Sabotage detected')
+    expect(representor.disabled_plugins).to eq({})
+  end
+
+end
+
+describe Farscape do
+  after(:all) { Farscape.clear }
+
+  context 'configuring plugins' do
+
+    before(:each) { Farscape.clear }
+
+    it 'can register a plugin' do
+      plugin = {name: :Peacekeeper, type: :sebacean}
+      expect(Farscape.register_plugin(plugin)).to be
+      expect(Farscape.plugins).to eq({Peacekeeper: plugin})
+    end
+
+    it 'can preemptively disable a plugin by name' do
+      Farscape.disable!(:Peacekeeper)
+      plugin = {name: :Peacekeeper, type: :sebacean}
+      Farscape.register_plugin(plugin)
+      expect(Farscape.enabled_plugins).to be_empty
+      expect(Farscape.disabled?(plugin)).to be true
+      expect(Farscape.enabled?(plugin)).to be false
+    end
+
+    it 'can preemptively disable a plugin by type' do
+      Farscape.disable!(:sebacean)
+      plugin = {name: :Peacekeeper, type: :sebacean}
+      Farscape.register_plugin(plugin)
+      expect(Farscape.enabled_plugins).to be_empty
+      expect(Farscape.disabled?(plugin)).to be true
+      expect(Farscape.enabled?(plugin)).to be false
+    end
+
+    it "can disable a plugin after it's added" do
+      Farscape.register_plugin(name: :Peacekeeper, type: :sebacean)
+      Farscape.register_plugin(name: :Imperium, type: :scarran)
+      Farscape.disable!(:sebacean)
+      expect(Farscape.enabled_plugins).to be_one
+    end
+
+    context 'adding middleware' do
+
+      before(:each) { Farscape.clear }
+      after(:all) { Farscape.clear }
+
+      it 'can add middleware' do
+        plugin = {name: :Peacekeeper, type: :sebacean, middleware: [TestMiddleware::NoGetNoProblem]}
+        Farscape.register_plugin(plugin)
+
+        expect(Farscape.middleware_stack.map{ |elt| elt[:class] } ).to eq([TestMiddleware::NoGetNoProblem])
+      end
+
+      it 'removes middleware when the source plugin is disabled' do
+        plugin = {name: :Peacekeeper, type: :sebacean, middleware: [TestMiddleware::NoGetNoProblem]}
+        Farscape.register_plugin(plugin)
+        Farscape.disable!( :sebacean )
+
+        expect(Farscape.middleware_stack).to be_none
+      end
+
+      it 'uses the middleware when making requests' do
+        plugin = {name: :Peacekeeper, type: :sebacean, middleware: [TestMiddleware::NoGetNoProblem]}
+        Farscape.register_plugin(plugin)
+
+        expect{Farscape::Agent.new("http://localhost:#{RAILS_PORT}").enter}.to raise_error('Shazam!')
+      end
+
+      it 'can configure middleware' do
+        plugin = {name: :Peacekeeper, type: :sebacean, middleware: [{class: TestMiddleware::NoGetNoProblem, config: {permissive: true}}]}
+        Farscape.register_plugin(plugin)
+
+        expect{Farscape::Agent.new("http://localhost:#{RAILS_PORT}").enter}.not_to raise_error
+      end
+
+      it 'adds middleware to disabled when disabled' do
+          plugin = {name: :Peacekeeper, default_state: :disabled, type: :sebacean, middleware: [{class: TestMiddleware::NoGetNoProblem, config: {permissive: true}}]}
+          Farscape.register_plugin(plugin)
+
+          expect(Farscape.enabled_plugins).to eq({})
+          expect(Farscape.disabled_plugins).to eq(plugin[:name] => plugin)
+      end
+
+      [:sebacean, TestMiddleware::SabotageDetector,'TestMiddleware::SabotageDetector',['TestMiddleware::SabotageDetector']].each do |form|
+        it "honors the before: option in middleware when given as #{form.inspect}" do
+          saboteur_middleware = {class: TestMiddleware::Saboteur, before: form}
+          saboteur_plugin = {name: :Saboteur, type: :scarran, middleware: [saboteur_middleware]}
+          detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector]}
+          [saboteur_plugin, detector_plugin].shuffle.each { |plugin| Farscape.register_plugin(plugin) }
+
+          expect(Farscape.middleware_stack.map{ |m| m[:class] }).to eq( [TestMiddleware::Saboteur, TestMiddleware::SabotageDetector] )
+          expect{Farscape::Agent.new("http://localhost:#{RAILS_PORT}").enter}.to raise_error('Sabotage detected')
+        end
+      end
+
+      [:sebacean, TestMiddleware::SabotageDetector,'TestMiddleware::SabotageDetector',['TestMiddleware::SabotageDetector']].each do |form|
+        it "honors the after: option in middleware when given as #{form.inspect}" do
+          saboteur_middleware = {class: TestMiddleware::Saboteur, after: form}
+          saboteur_plugin = {name: :Saboteur, type: :scarran, middleware: [saboteur_middleware]}
+          detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector]}
+          [saboteur_plugin, detector_plugin].shuffle.each { |plugin| Farscape.register_plugin(plugin) }
+
+          expect(Farscape.middleware_stack.map{ |m| m[:class] }).to eq( [TestMiddleware::SabotageDetector, TestMiddleware::Saboteur] )
+          expect{Farscape::Agent.new("http://localhost:#{RAILS_PORT}").enter}.not_to raise_error
+        end
+      end
+
+      it 'doesn\'t disable everything with one' do
+        detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector], default_state: :disabled}
+        saboteur_middleware = {class: TestMiddleware::Saboteur}
+        saboteur_plugin = {name: :Saboteur, type: :scarran, middleware: [saboteur_middleware]}
+        Farscape.register_plugin(detector_plugin)
+        Farscape.register_plugin(saboteur_plugin)
+
+        expect(Farscape.enabled_plugins.keys).to eq([:Saboteur])
+      end
+
+      it 'doesn\'t allow sneaky enabling' do
+        detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector], default_state: :disabled}
+        Farscape.register_plugin(detector_plugin)
+
+        expect(Farscape.disabled_plugins.keys).to eq([:Detector])
+
+        detector_plugin = {name: :Detector, type: :sebacean, middleware: [TestMiddleware::SabotageDetector], default_state: :enabled}
+        Farscape.register_plugin(detector_plugin)
+
+        expect(Farscape.disabled_plugins.keys).to eq([:Detector])
+      end
+
+    end
+
+    context 'extensions' do
+      before(:each) { Farscape.clear }
+      after(:all) { Farscape.clear }
+
+      let(:entry_point) { "http://localhost:#{RAILS_PORT}"}
+      let(:can_do_hash) { {conditions: 'can_do_anything'} }
+
+      it 'allows extensions' do
+        module Peacekeeper
+          def pacify!
+            raise 'none shall pass' unless enabled_plugins.include?(:Saboteur)
+          end
+        end
+        Farscape.register_plugin(name: :Peacekeeper, type: :security, extensions: {Agent: [Peacekeeper]})
+        expect { Farscape::Agent.new.pacify! }.to raise_error('none shall pass')
+      end
+
+      it 'allows extensions with altering existing methods' do
+        module Peacemaker
+          def self.extended(base)
+            base.instance_eval do
+              @original_transitions = method(:transitions)
+              def transitions
+                raise 'none shall pass' if @original_transitions.call.keys.include?("drds")
+                @original_transitions.call
+              end
+            end
+          end
+        end
+        Farscape.register_plugin(name: :Peacekeeper, type: :security, extensions: {RepresentorAgent: [Peacemaker]})
+        expect { Farscape::Agent.new.enter(entry_point).transitions.keys }.to raise_error('none shall pass')
+        expect(Farscape::Agent.new.enter(entry_point).omitting(:Peacekeeper).transitions.keys).to include("drds")
+      end
+
+      it 'allows discovery extensions' do
+        module ServiceCatalogue
+          def self.extended(base)
+            base.instance_eval do
+              @original_enter = method(:enter)
+              @dispatches = {
+                :moya => "http://localhost:#{RAILS_PORT}"
+              }
+              def enter(entry=nil)
+                @entry_point ||= entry
+                @entry_point = @dispatches[@entry_point] || @entry_point
+                @original_enter.call
+              end
+            end
+          end
+        end
+        Farscape.register_plugin(name: :Wormlet, type: :discovery, extensions: {Agent: [ServiceCatalogue]})
+        expect(Farscape::Agent.new(:moya).enter.transitions.keys).to include("drds")
+        expect(Farscape::Agent.new.enter(:moya).transitions.keys).to include("drds")
+        expect { Farscape::Agent.new.omitting(:discovery).enter(:moya).transitions.keys }.to raise_error(NoMethodError)
+      end
+
+    end
+
+    context 'workflow' do
+
+      before(:each) { Farscape.clear }
+
+      let(:entry_point) { "http://localhost:#{RAILS_PORT}"}
+      let(:can_do_hash) { {conditions: 'can_do_anything'} }
+
+      it 'manages enabling and disabling plugins' do
+        registration = [{name: :Peacekeeper, type: :sebacean, middleware: [TestMiddleware::NoGetNoProblem]}]
+        registration_keys = registration.map { |plugin| plugin[:name] }
+        Farscape.register_plugins(registration)
+
+        expect(Farscape.plugins.keys).to eq( registration_keys )
+        expect(Farscape.enabled_plugins.keys).to eq( registration_keys )
+        expect(Farscape.disabled_plugins.keys).to eq([])
+
+        Farscape.disable!(type: :sebacean)
+
+        expect(Farscape.enabled_plugins.keys).to eq([])
+        expect(Farscape.disabled_plugins.keys).to eq( registration_keys )
+
+        Farscape.enable!(name: :Peacekeeper)
+
+        expect(Farscape.enabled_plugins.keys).to eq( registration_keys )
+        expect(Farscape.disabled_plugins.keys).to eq([])
+      end
+
+      it 'managed complex enabling and disabling on instances' do
+        registration = [{name: :Peacekeeper, type: :sebacean, middleware: [TestMiddleware::NoGetNoProblem]}]
+        registration_keys = registration.map { |plugin| plugin[:name] }
+        Farscape.register_plugins(registration)
+        peacekeeper_plugin = {:Peacekeeper=>{:name=>:Peacekeeper, :type=>:sebacean, :middleware=>[TestMiddleware::NoGetNoProblem], :enabled=>true}}
+        disabled_plugin = {:Peacekeeper=>{:name=>:Peacekeeper, :type=>:sebacean, :middleware=>[TestMiddleware::NoGetNoProblem], :enabled=>false}}
+
+        expect(Farscape.enabled_plugins).to eq(peacekeeper_plugin)
+
+        agent = Farscape::Agent.new.omitting(name: :Peacekeeper)
+
+        expect(agent.plugins).to eq(disabled_plugin)
+        expect(agent.enabled_plugins).to eq({})
+        expect(agent.disabled_plugins).to eq(disabled_plugin)
+
+        resource = agent.enter(entry_point).transitions["drds"].invoke { |builder| builder.parameters = can_do_hash }
+        expect(resource.plugins).to eq(disabled_plugin)
+        expect(resource.enabled_plugins).to eq({})
+        expect(resource.plugins).to eq(disabled_plugin)
+
+        transition = resource.using(name: :Peacekeeper).transitions["items"]
+        details = resource.using(name: :Peacekeeper).embedded["items"].first
+
+        expect { transition.invoke }.to raise_error('Shazam!')
+        expect(details.plugins).to eq(peacekeeper_plugin)
+        expect(details.enabled_plugins).to eq(peacekeeper_plugin)
+        expect(details.disabled_plugins).to eq({})
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/farscape/transition_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Farscape::TransitionAgent do
+  let(:client) { double }
+  let(:agent) { double(media_type: :hale, client: client) }
+  let(:transition) { double(uri: 'com:mdsol', templated?: false) }
+  let(:arg) { { additional_fields: { key1: 'value1', key2: 'value2' } } }
+  let(:transition_agent) { described_class.new(transition, agent) }
+  let(:field_list) { double(name: 'additional_fields') }
+  let(:call_options) { { url: 'com:mdsol', headers: { Accept: 'application/vnd.hale+json' } } }
+
+  before do
+    allow(agent).to receive(:get_accept_header).and_return(Accept: 'application/vnd.hale+json')
+    allow(agent).to receive(:find_exception).and_return(nil)
+    allow(transition).to receive(:interface_method).and_return(http_method)
+    allow(transition).to receive(:parameters).and_return([ field_list ])
+    allow(transition).to receive(:attributes).and_return([])
+    allow_any_instance_of(described_class).to receive(:handle_extensions).and_return(nil)
+  end
+
+  context 'GET method' do
+    let(:http_method) { "get" }
+
+    it 'stores parameters in params' do
+      expect(client).to receive(:invoke).with(call_options.merge(method: http_method, params: arg))
+      transition_agent.invoke(arg)
+    end
+  end
+
+  context 'POST method' do
+    let(:http_method) { "post" }
+
+    it 'stores parameters in body' do
+      expect(client).to receive(:invoke).with(call_options.merge(method: http_method, body: arg))
+      transition_agent.invoke(arg)
+    end
+  end
+
+  # see https://tools.ietf.org/html/rfc6570#section-3.2.6
+  context "URL with a path segment" do
+    let(:transition) do
+      Representors::Transition.new(
+        templated: true,
+        rel: "find",
+        href: "https://example.com/api/v1/issues{/issue_uuid}"
+      )
+    end
+    let(:issue_uuid) { SecureRandom.uuid }
+
+    context "GET" do
+      let(:http_method) { "get" }
+
+      it "interpolates a templated URI" do
+        options = call_options.merge(
+          method: http_method,
+          url: "https://example.com/api/v1/issues/#{issue_uuid}",
+          params: arg
+        )
+        expect(client).to receive(:invoke).with(options)
+        transition_agent.invoke(arg.merge(issue_uuid: issue_uuid))
+      end
+    end
+
+    context "POST" do
+      let(:http_method) { "post" }
+
+      it "does not interpolate a templated URI" do
+        params = arg.merge(issue_uuid: issue_uuid)
+        options = call_options.merge(
+          method: http_method,
+          url: "https://example.com/api/v1/issues",
+          body: params
+        )
+        expect(client).to receive(:invoke).with(options)
+        transition_agent.invoke(params)
+      end
+    end
+  end
+end

data/spec/lib/helpers/partially_ordered_list_spec.rb

@@ -0,0 +1,125 @@
+require_relative '../../../lib/farscape/helpers/partially_ordered_list.rb'
+
+describe(PartiallyOrderedList) do
+
+  it 'sorts a list given a complete ordering' do
+    list = described_class.new { |a,b| a <=> b }
+    1.upto(10) { |i| list.add(i) }
+    expect(list.to_a).to eq([*1..10])
+  end
+
+  it 'sorts a shuffled list given a complete ordering' do
+    list = described_class.new { |a,b| a <=> b }
+    [*1..10].shuffle.each { |i| list.add(i) }
+    expect(list.to_a).to eq([*1..10])
+  end
+
+  it 'returns an arbitrary list when nothing is ordered' do
+    list = described_class.new {}
+    (1..20).each { |i| list.add(i) }
+    expect(list.count).to eq(20)
+  end
+
+
+  it 'finds an order for a list satisfying a disjoint ordering' do
+    list = described_class.new do |a,b|
+      if a % 2 == b % 2
+        a <=> b
+      end
+    end
+    [*1..20].shuffle.each { |i| list.add(i) }
+    expect(list.partition(&:odd?)).to eq([*1..20].partition(&:odd?))
+  end
+
+  it 'finds one possible transitive ordering' do
+    list = described_class.new do |a,b|
+      if a % 2 == b % 2
+        a <=> b
+      elsif [a,b] == [1,8]
+        1
+      elsif [a,b] == [8,1]
+        -1
+      end
+    end
+    [*1..20].shuffle.each { |i| list.add(i) }
+    expect(list.partition(&:odd?)).to eq([*1..20].partition(&:odd?))
+    expect(list.find_index(8)).to be < list.find_index(1)
+  end
+
+  it 'finds the only possible transitive ordering' do
+    list = described_class.new do |a,b|
+      if a % 2 == b % 2
+        a <=> b
+      elsif [a,b] == [1,20]
+        1
+      elsif [a,b] == [20,1]
+        -1
+      end
+    end
+    [*1..20].shuffle.each { |i| list.add(i) }
+    expect(list.to_a).to eq([2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])
+  end
+
+  it 'raises on circular ordering' do
+    list = described_class.new do |a,b|
+      if [a,b] == [1,10]
+        1
+      elsif [a,b] == [10,1]
+        -1
+      else
+        a <=> b
+      end
+    end
+    [*1..10].shuffle.each { |i| list.add(i) }
+    expect{ list.to_a }.to raise_error(PartiallyOrderedList::CircularOrderingError)
+  end
+
+  it 'deletes' do
+    list = described_class.new { |a,b| a <=> b }
+    [*1..10].shuffle.each { |i| list.add(i) }
+    list.delete(5)
+    expect(list.to_a).to eq( [1,2,3,4,6,7,8,9,10] )
+  end
+
+  it 'deletes when there is a cached ordering' do
+    list = described_class.new {}
+    list.add 1
+    list.add 2
+    list.to_a
+    list.delete 1
+    expect(list.to_a).to eq([2])
+  end
+
+  it 'invalidates cached ordering when a new item is added' do
+    list = described_class.new {}
+    1.upto(10) { |i| list.add(i) }
+    list.to_a
+    list.add(11)
+    expect(list.count).to eq(11)
+  end
+
+  it 'returns an enumerator when each is called without a block' do
+    expect(described_class.new{}.each).to be_a(Enumerator)
+  end
+
+  it 'raises if new is called without a block' do
+    expect{described_class.new}.to raise_error(ArgumentError)
+  end
+
+  it 're-sorts as needed' do
+    list = described_class.new do |a,b|
+      if a % 2 == b % 2
+        a <=> b
+      elsif [a,b] == [1,20]
+        1
+      elsif [a,b] == [20,1]
+        -1
+      end
+    end
+    [*1..19].shuffle.each { |i| list.add(i) }
+    list.to_a
+    list.add(20)
+    expect(list.to_a).to eq([2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])
+  end
+
+end