attributor 5.4 → 6.0

data/spec/attribute_resolver_spec.rb

@@ -1,237 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper.rb')
-
-describe Attributor::AttributeResolver do
-  let(:value) { /\w+/.gen }
-
-  context 'registering and querying simple values' do
-    let(:name) { 'string_value' }
-    before { subject.register(name, value) }
-
-    it 'works' do
-      expect(subject.query(name)).to be value
-    end
-  end
-
-  context 'querying and registering nested values' do
-    let(:one) { double(two: value) }
-    let(:key) { 'one.two' }
-    before { subject.register('one', one) }
-
-    it 'works' do
-      expect(subject.query(key)).to be value
-    end
-  end
-
-  context 'querying nested values from models' do
-    let(:instance) { double('instance', ssh_key: ssh_key) }
-    let(:ssh_key) { double('ssh_key', name: value) }
-    let(:key) { 'instance.ssh_key.name' }
-
-    before { subject.register('instance', instance) }
-
-    it 'works' do
-      expect(subject.query('instance')).to be instance
-      expect(subject.query('instance.ssh_key')).to be ssh_key
-      expect(subject.query(key)).to be value
-    end
-
-    context 'with a prefix' do
-      let(:key) { 'name' }
-      let(:prefix) { '$.instance.ssh_key' }
-      let(:value) { 'some_name' }
-      it 'works' do
-        expect(subject.query(key, prefix)).to be(value)
-      end
-    end
-  end
-
-  context 'querying values that do not exist' do
-    context 'for a straight key' do
-      let(:key) { 'missing' }
-      it 'returns nil' do
-        expect(subject.query(key)).to be_nil
-      end
-    end
-    context 'for a nested key' do
-      let(:key) { 'nested.missing' }
-      it 'returns nil' do
-        expect(subject.query(key)).to be_nil
-      end
-    end
-  end
-
-  context 'querying collection indices from models' do
-    let(:instances) { [instance1, instance2] }
-    let(:instance1) { double('instance1', ssh_key: ssh_key1) }
-    let(:instance2) { double('instance2', ssh_key: ssh_key2) }
-    let(:ssh_key1) { double('ssh_key', name: value) }
-    let(:ssh_key2) { double('ssh_key', name: 'second') }
-    let(:args) { [path, prefix].compact }
-
-    before { subject.register('instances', instances) }
-
-    it 'resolves the index to the correct member of the collection' do
-      expect(subject.query('instances')).to be instances
-      expect(subject.query('instances.at(1).ssh_key')).to be ssh_key2
-      expect(subject.query('instances.at(0).ssh_key.name')).to be value
-    end
-
-    it 'returns nil for index out of range' do
-      expect(subject.query('instances.at(2)')).to be(nil)
-      expect(subject.query('instances.at(-1)')).to be(nil)
-    end
-
-    context 'with a prefix' do
-      let(:key) { 'name' }
-      let(:prefix) { '$.instances.at(0).ssh_key' }
-      let(:value) { 'some_name' }
-
-      it 'resolves the index to the correct member of the collection' do
-        expect(subject.query(key, prefix)).to be(value)
-      end
-    end
-  end
-
-  context 'checking attribute conditions' do
-    let(:key) { 'instance.ssh_key.name' }
-    let(:ssh_key) { double('ssh_key', name: value) }
-    let(:instance_id) { 123 }
-    let(:instance) { double('instance', ssh_key: ssh_key, id: instance_id) }
-
-    let(:context) { '$' }
-
-    before { subject.register('instance', instance) }
-
-    let(:present_key) { key }
-    let(:missing_key) { 'instance.ssh_key.something_else' }
-
-    context 'with no condition' do
-      let(:condition) { nil }
-      before { expect(ssh_key).to receive(:something_else).and_return(nil) }
-      it 'works' do
-        expect(subject.check(context, present_key, condition)).to be true
-        expect(subject.check(context, missing_key, condition)).to be false
-      end
-    end
-
-    context 'with a string condition' do
-      let(:passing_condition) { value }
-      let(:failing_condition) { /\w+/.gen }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    context 'with a regex condition' do
-      let(:passing_condition) { /\w+/ }
-      let(:failing_condition) { /\d+/ }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    context 'with an integer condition' do
-      let(:key) { 'instance.id' }
-      let(:passing_condition) { instance_id }
-      let(:failing_condition) { /\w+/.gen }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to be true
-        expect(subject.check(context, key, failing_condition)).to be false
-      end
-    end
-
-    skip 'with a hash condition' do
-    end
-
-    context 'with a proc condition' do
-      let(:passing_condition) { proc { |test_value| test_value == value } }
-      let(:failing_condition) { proc { |test_value| test_value != value } }
-
-      it 'works' do
-        expect(subject.check(context, key, passing_condition)).to eq(true)
-        expect(subject.check(context, key, failing_condition)).to eq(false)
-      end
-    end
-
-    context 'with an unsupported condition type' do
-      let(:condition) { double('weird condition type') }
-      it 'raises an error' do
-        expect { subject.check(context, present_key, condition) }.to raise_error(Attributor::AttributorException)
-      end
-    end
-
-    context 'with a condition that asserts something IS nil' do
-      let(:ssh_key) { double('ssh_key', name: nil) }
-      it 'can be done using the almighty Proc' do
-        cond = proc { |value| !value.nil? }
-        expect(subject.check(context, key, cond)).to be false
-      end
-    end
-
-    context 'with a relative path' do
-      let(:context) { '$.instance.ssh_key' }
-      let(:key) { 'name' }
-
-      it 'works' do
-        expect(subject.check(context, key, value)).to be true
-      end
-    end
-  end
-
-  # context 'with context stuff...' do
-
-  #   let(:ssh_key) { double("ssh_key", name:value) }
-  #   let(:instance) { double("instance", ssh_key:ssh_key) }
-
-  #   let(:key) { "ssh_key.name" }
-  #   let(:key) { "$.payload" }
-  #   let(:key) { "ssh_key.name" } # no $ == current object
-  #   let(:key) { "@.ssh_key" }    # @ is current object
-
-  #   before { subject.register('instance', instance) }
-
-  #   it 'works?' do
-  #     # check dependency for 'instance'
-  #     resolver.with 'instance' do |res|
-  #       res.check(key)
-  #       '$.payload'
-  #     end
-
-  #   end
-
-  # end
-
-  # context 'integration with attributes that have sub-attributes' do
-  # when you start to parse... do you set the root in the resolver?
-  # end
-  #
-  #  context 'actually using the thing' do
-
-  #   # we'll always want to add... right? never really remove?
-  #   # at least not remove for the duration of a given resolver...
-  #   # which will last for one request.
-  #   #
-  #   # could the resolver be an identity-map of sorts for the request?
-  #   # how much overlap is there in there?
-  #   #
-  #   #
-
-  #   it 'is really actually quite useful' do
-  #     #attribute = Attributor::Attribute.new ::String, required_if: { "instance.ssh_key.name" : Proc.new { |value| value.nil? } }
-
-  #     resolver = Attributor::AttributeResolver.new
-
-  #     resolver.register '$.parsed_params', parsed_params
-  #     resolver.register '$.payload', payload
-
-  #     resolver.query '$.parsed_params.account_id'
-
-  #   end
-
-  # end
-end