praxis 2.0.pre.10 → 2.0.pre.15

data/spec/praxis/extensions/attribute_filtering/filter_tree_node_spec.rb

@@ -4,14 +4,15 @@ require 'praxis/extensions/attribute_filtering'
 
 describe Praxis::Extensions::AttributeFiltering::FilterTreeNode do
 
+  let(:dummy_object) { double("Fake NodeObject")}
   let(:filters) do
     [
-      {name: 'one', specs: { op: '>', value: 1}},
-      {name: 'one', specs: { op: '<', value: 10}},
-      {name: 'rel1.a1', specs: { op: '=', value: 1}},
-      {name: 'rel1.a2', specs: { op: '=', value: 2}},
-      {name: 'rel1.rel2.b1', specs: { op: '=', value: 11}},
-      {name: 'rel1.rel2.b2', specs: { op: '=', value: 12}}
+      {name: 'one', op: '>', value: 1, node_object: dummy_object},
+      {name: 'one', op: '<', value: 10},
+      {name: 'rel1.a1', op: '=', value: 1},
+      {name: 'rel1.a2', op: '=', value: 2},
+      {name: 'rel1.rel2.b1', op: '=', value: 11},
+      {name: 'rel1.rel2.b2', op: '=', value: 12, node_object: dummy_object}
     ]
   end
   context 'initialization' do
@@ -19,20 +20,38 @@ describe Praxis::Extensions::AttributeFiltering::FilterTreeNode do
     it 'holds the top conditions and the child in a TreeNode' do
       expect(subject.path).to eq([])
       expect(subject.conditions.size).to eq(2)
+      expect(subject.conditions.map{|i| i.slice(:name,:op,:value)}).to eq([
+        {name: 'one', op: '>', value: 1},
+        {name: 'one', op: '<', value: 10},
+      ])
       expect(subject.children.keys).to eq(['rel1'])
       expect(subject.children['rel1']).to be_kind_of(described_class)
     end
 
+    it 'passes on any node_object value at any level' do
+      expect(subject.conditions.first[:node_object]).to be(dummy_object)
+      expect(subject.conditions[1]).to_not have_key(:node_object)
+      expect(subject.children['rel1'].children['rel2'].conditions[1][:node_object]).to be(dummy_object)
+    end
+
     it 'recursively holds the conditions and the children of their children in a TreeNode' do
       rel1 = subject.children['rel1']
       expect(rel1.path).to eq(['rel1'])
       expect(rel1.conditions.size).to eq(2)
+      expect(rel1.conditions.map{|i| i.slice(:name,:op,:value)}).to eq([
+        {name: 'a1', op: '=', value: 1},
+        {name: 'a2', op: '=', value: 2},
+      ])
       expect(rel1.children.keys).to eq(['rel2'])
       expect(rel1.children['rel2']).to be_kind_of(described_class)
 
       rel1rel2 = rel1.children['rel2']
       expect(rel1rel2.path).to eq(['rel1','rel2'])
       expect(rel1rel2.conditions.size).to eq(2)
+      expect(rel1rel2.conditions.map{|i| i.slice(:name,:op,:value)}).to eq([
+        {name: 'b1', op: '=', value: 11},
+        {name: 'b2', op: '=', value: 12}  
+      ])      
       expect(rel1rel2.children.keys).to be_empty
     end
   end

data/spec/praxis/extensions/attribute_filtering/filtering_params_spec.rb

@@ -6,46 +6,131 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
 
   context '.load' do
     subject { described_class.load(filters_string) }
+
+    context 'unescapes the URL encoded values' do
+      it 'for single values' do
+          str = "one=#{CGI.escape('*')}&two>#{CGI.escape('^%$#!st_uff')}|three<normal"
+          parsed = [
+            { name: :one, op: '=', value: '*'},
+            { name: :two, op: '>', value: '^%$#!st_uff'},
+            { name: :three, op: '<', value: 'normal'},
+          ]
+          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+      end
+      it 'each of the multi-values' do
+        escaped_one = [
+          CGI.escape('fun!'),
+          CGI.escape('Times'),
+          CGI.escape('~!@#$%^&*()_+-={}|[]\:";\'<>?,./`')
+        ].join(',')
+        str = "one=#{escaped_one}&two>normal"
+        parsed = [
+          { name: :one, op: '=', value: ['fun!','Times','~!@#$%^&*()_+-={}|[]\:";\'<>?,./`']},
+          { name: :two, op: '>', value: 'normal'},
+        ]
+        expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+      end
+      it 'does not handle badly escaped values that contain reserved chars ()|&,' do
+        badly_escaped = 'val('
+        str = "one=#{badly_escaped}&(two>normal|three!)"
+        expect{
+          described_class.load(str)
+        }.to raise_error(Parslet::ParseFailed)
+      end
+    end
     context 'parses for operator' do
-      described_class::AVAILABLE_OPERATORS.each do |op|
+      described_class::VALUE_OPERATORS.each do |op|
         it "#{op}" do
           str = "thename#{op}thevalue"
           parsed = [{ name: :thename, op: op, value: 'thevalue'}]
-          expect(described_class.load(str).parsed_array).to eq(parsed)
+          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
         end
       end
+      described_class::NOVALUE_OPERATORS.each do |op|
+        it "#{op}" do
+          str = "thename#{op}"
+          parsed = [{ name: :thename, op: op, value: nil}]
+          expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+        end
+      end
+      it 'can parse multiple values for filter' do
+        str="filtername=1,2,3"
+        parsed = [{ name: :filtername, op: '=', value: ["1","2","3"]}]
+        expect(described_class.load(str).parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq(parsed)
+      end
     end
-    context 'with all operators at once' do
-      let(:filters_string) { 'one=1&two!=2&three>=3&four<=4&five<5&six>6&seven!&eight!!'}
+    context 'with all value operators at once for the same AND group' do
+      let(:filters_string) { 'one=11&two!=22&three>=33&four<=4&five<5&six>6&seven!&eight!!'}
       it do
-        expect(subject.parsed_array).to eq([
-          { name: :one, op: '=', value: '1'},
-          { name: :two, op: '!=', value: '2'},
-          { name: :three, op: '>=', value: '3'},
+        expect(subject.parsed_array.map{|i| i.slice(:name,:op,:value)}).to eq([
+          { name: :one, op: '=', value: '11'},
+          { name: :two, op: '!=', value: '22'},
+          { name: :three, op: '>=', value: '33'},
           { name: :four, op: '<=', value: '4'},
           { name: :five, op: '<', value: '5'},
           { name: :six, op: '>', value: '6'},
           { name: :seven, op: '!', value: nil},
           { name: :eight, op: '!!', value: nil},          
         ])
+        # And all have the same parent, which is an AND group
+        parent = subject.parsed_array.map{|i|i[:node_object].parent_group}.uniq
+        expect(parent.size).to eq(1)
+        expect(parent.first.type).to eq(:and)
+        expect(parent.first.parent_group).to be_nil
+      end
+    end
+
+    context 'with with nested precedence groups' do
+      let(:filters_string) { '(one=11)&(two!=22|three!!)&four<=4&five>5|six!'}
+      it do
+        parsed = subject.parsed_array
+        expect(parsed.map{|i| i.slice(:name,:op,:value)}).to eq([
+          { name: :one, op: '=', value: '11'},
+          { name: :two, op: '!=', value: '22'},
+          { name: :three, op: '!!', value: nil},
+          { name: :four, op: '<=', value: '4'},
+          { name: :five, op: '>', value: '5'},
+          { name: :six, op: '!', value: nil},
+        ])
+        # Grouped appropriately
+        parent_of = parsed.each_with_object({}) do |item, hash|
+          hash[item[:name]] = item[:node_object].parent_group
+        end
+        # This is the expected tree grouping result
+        # OR -- six
+        #  |--- AND --five
+        #        |--- four
+        #        |--- OR -- three
+        #        |     |--- two
+        #        |--- one
+        # two and 3 are grouped together by an OR
+        expect(parent_of[:two]).to be(parent_of[:three])
+        expect(parent_of[:two].type).to eq(:or)
+        
+        # one, two, four and the or from two/three are grouped together by an AND
+        expect([parent_of[:one],parent_of[:two].parent_group,parent_of[:four],parent_of[:five]]).to all(be(parent_of[:one]))
+        expect(parent_of[:one].type).to eq(:and)
+
+        # six and the whole group above are grouped together with an OR
+        expect(parent_of[:six]).to be(parent_of[:one].parent_group)
+        expect(parent_of[:six].type).to eq(:or)
       end
     end
 
-    context 'with an associated MediaType' do
-      let(:params_for_post_media_type) do
+    context 'value coercing when associated to a MediaType' do
+      let(:parsed) do
         # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
         # construct it propertly by applying the block. Seems easier than creating the type alone, and 
         # then manually apply the block
         Attributor::Attribute.new(described_class.for(Post)) do
           filter 'id', using: ['=', '!=', '!']
-        end.type
+        end.type.load(str).parsed_array
       end
 
       context 'with a single value' do
         let(:str) { 'id=1' }
         it 'coerces its value to the associated mediatype attribute type' do
-          parsed = params_for_post_media_type.load(str).parsed_array
-          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>1)
+          expect(parsed.first[:value]).to eq(1)
           expect(Post.attributes[:id].type.valid_type?(parsed.first[:value])).to be_truthy
         end
       end
@@ -53,8 +138,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       context 'with multimatch' do
         let(:str) { 'id=1,2,3' }
         it 'coerces ALL csv values to the associated mediatype attribute type' do
-          parsed = params_for_post_media_type.load(str).parsed_array
-          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>[1, 2, 3])
+          expect(parsed.first[:value]).to eq([1, 2, 3])
           parsed.first[:value].each do |val|
             expect(Post.attributes[:id].type.valid_type?(val)).to be_truthy
           end
@@ -64,8 +148,7 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       context 'with a single value that is null' do
         let(:str) { 'id!' }
         it 'properly loads it as null' do
-          parsed = params_for_post_media_type.load(str).parsed_array
-          expect(parsed.first).to eq(:name=>:id, :op=>"!", :value=>nil)
+          expect(parsed.first[:value]).to be_nil
         end
       end
     end

data/spec/praxis/extensions/attribute_filtering/filters_parser_spec.rb

@@ -0,0 +1,148 @@
+require 'praxis/extensions/attribute_filtering/filters_parser'
+
+describe Praxis::Extensions::AttributeFiltering::FilteringParams::Condition do
+end 
+
+describe Praxis::Extensions::AttributeFiltering::FilteringParams::ConditionGroup do
+end 
+
+describe Praxis::Extensions::AttributeFiltering::FilteringParams::Parser do
+
+  context 'testing' do
+    let(:expectations) do
+      { 
+        'one=11|two=22' => "( one=11 OR two=22 )"
+      }
+    end
+    it 'parses and loads the parsed result into the tree objects' do
+      expectations.each do |filters, dump_result|
+
+        parsed = described_class.new.parse(filters)
+        tree = Praxis::Extensions::AttributeFiltering::FilteringParams::ConditionGroup.load(parsed)
+
+        expect(tree.dump).to eq(dump_result)
+      end
+    end
+  end
+   context 'parses the grammar' do
+
+    # Takes a hash with keys containing literal filters string, and values being the "dump format for Condition/Group"
+    shared_examples 'round-trip-properly' do |expectations|
+      it description do
+        expectations.each do |filters, dump_result|
+          parsed = Praxis::Extensions::AttributeFiltering::FilteringParams::Parser.new.parse(filters)
+          tree = Praxis::Extensions::AttributeFiltering::FilteringParams::ConditionGroup.load(parsed)
+          expect(tree.dump).to eq(dump_result)
+        end
+      end
+    end
+
+    context 'single expression' do
+      it_behaves_like 'round-trip-properly', { 
+        'one=11' => 'one=11',
+        '(one=11)' => 'one=11',
+        'one!' => "one!",
+      }
+    end
+    context 'same expression operator' do
+      it_behaves_like 'round-trip-properly', { 
+        'one=11&two=22' => '( one=11 AND two=22 )',
+        'one=11&two=22&three=3' => '( one=11 AND two=22 AND three=3 )',
+        'one=1,2,3&two=4,5' => '( one=[1,2,3] AND two=[4,5] )',
+        'one=11|two=22' => '( one=11 OR two=22 )',
+        'one=11|two=22|three=3' => '( one=11 OR two=22 OR three=3 )',
+      }
+    end
+
+    context 'respects and/or precedence and parenthesis grouping' do
+      it_behaves_like 'round-trip-properly', { 
+        'a=1&b=2&z=9|c=3' => '( ( a=1 AND b=2 AND z=9 ) OR c=3 )',
+        'a=1|b=2&c=3' => '( a=1 OR ( b=2 AND c=3 ) )',
+        'a=1|b=2&c=3&d=4' => '( a=1 OR ( b=2 AND c=3 AND d=4 ) )',
+        '(a=1|b=2)&c=3&d=4' => '( ( a=1 OR b=2 ) AND c=3 AND d=4 )',
+        'a=1|a.b.c_c=1&b=2' => '( a=1 OR ( a.b.c_c=1 AND b=2 ) )',
+        'a=1,2,3|b=4,5&c=one,two' => '( a=[1,2,3] OR ( b=[4,5] AND c=[one,two] ) )',
+        'one=11&two=2|three=3' => '( ( one=11 AND two=2 ) OR three=3 )', # AND has higer precedence
+        'one=11|two=2&three=3' => '( one=11 OR ( two=2 AND three=3 ) )', # AND has higer precedence
+        'one=11&two=2|three=3&four=4' => '( ( one=11 AND two=2 ) OR ( three=3 AND four=4 ) )',
+        '(one=11)&(two!=2|three=3)&four=4&five=5|six=6' => 
+            '( ( one=11 AND ( two!=2 OR three=3 ) AND four=4 AND five=5 ) OR six=6 )',
+        '(one=11)&three=3' => '( one=11 AND three=3 )',
+        '(one=11|two=2)&(three=3|four=4)' => '( ( one=11 OR two=2 ) AND ( three=3 OR four=4 ) )',
+        '(category_uuid=deadbeef1|category_uuid=deadbeef2)&(name=Book1|name=Book2)' =>
+            '( ( category_uuid=deadbeef1 OR category_uuid=deadbeef2 ) AND ( name=Book1 OR name=Book2 ) )',
+        '(category_uuid=deadbeef1&name=Book1)|(category_uuid=deadbeef2&name=Book2)' =>
+            '( ( category_uuid=deadbeef1 AND name=Book1 ) OR ( category_uuid=deadbeef2 AND name=Book2 ) )',
+      }
+    end
+
+    context 'empty values get converted to empty strings' do
+      it_behaves_like 'round-trip-properly', { 
+        'one=' => 'one=""',
+        'one=&two=2' => '( one="" AND two=2 )',
+      }
+    end
+
+    context 'no value operands' do
+      it_behaves_like 'round-trip-properly', { 
+        'one!' => "one!",
+        'one!!' => "one!!"
+      }
+
+      it 'fails if passing a value' do
+        expect {
+          described_class.new.parse('one!val')
+        }.to raise_error(Parslet::ParseFailed)
+        expect {
+          described_class.new.parse('one!!val')
+        }.to raise_error(Parslet::ParseFailed)
+      end 
+    end
+
+    context 'csv values result in multiple values for the operation' do
+      it_behaves_like 'round-trip-properly', { 
+        'multi=1,2' => "multi=[1,2]",
+        'multi=1,2,valuehere' => "multi=[1,2,valuehere]"
+      }
+    end
+
+    context 'supports [a-zA-Z0-9_\.] for filter names' do
+      it_behaves_like 'round-trip-properly', { 
+        'normal=1'      => 'normal=1',
+        'cOmBo=1'       => 'cOmBo=1',
+        '1=2'           => '1=2',
+        'aFew42Things=1' => 'aFew42Things=1',
+        'under_scores=1' => 'under_scores=1',
+        'several.dots.in.here=1' => 'several.dots.in.here=1',
+        'cOrN.00copia.of_thinGs.42_here=1' => 'cOrN.00copia.of_thinGs.42_here=1',
+      }
+    end
+    context 'supports everything (except &|(),) for values (even without encoding..not allowed, but just to ensure the parser does not bomb)' do
+      it_behaves_like 'round-trip-properly', {
+        'v=1123' => 'v=1123',
+        'v=*foo*' => 'v={*}foo{*}',
+        'v=*^%$#@!foo' => 'v={*}^%$#@!foo',
+        'v=_-=\{}"?:><' => 'v=_-=\{}"?:><',
+        'v=_-=\{}"?:><,another_value!' => 'v=[_-=\{}"?:><,another_value!]',
+      }
+    end
+    context 'properly detects and handles fuzzy matching encoded as {*} in the dump' do
+      it_behaves_like 'round-trip-properly', {
+        'v=*foo' => 'v={*}foo',
+        'v=*foo*' => 'v={*}foo{*}',
+        'v=foo*' => 'v=foo{*}',
+        'v=*start,end*,*both*' => 'v=[{*}start,end{*},{*}both{*}]',
+        "v=*#{CGI.escape('***')},#{CGI.escape('*')}" => 'v=[{*}***,*]', # Simple exact match on 2nd
+      }
+    end
+    context 'properly handles url-encoded values' do
+      it_behaves_like 'round-trip-properly', {
+        "v=#{CGI.escape('1123')}" => 'v=1123',
+        "v=*#{CGI.escape('foo')}*" => 'v={*}foo{*}',
+        "v=*#{CGI.escape('^%$#@!foo')}" => 'v={*}^%$#@!foo',
+        "v=#{CGI.escape('~!@#$%^&*()_+-={}|[]\:";\'<>?,./`')}" => 'v=~!@#$%^&*()_+-={}|[]\:";\'<>?,./`',
+        "v=#{CGI.escape('_-+=\{}"?:><')},#{CGI.escape('another_value!')}" => 'v=[_-+=\{}"?:><,another_value!]',
+      }
+    end 
+  end
+end

data/spec/praxis/extensions/field_selection/active_record_query_selector_spec.rb

@@ -29,7 +29,7 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       :id # We always load the primary keys
     ]
   end
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields)  }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields).selectors  }
   let(:debug){ false }
 
   subject(:selector) {described_class.new(query: query, selectors: selector_node, debug: debug) }

data/spec/praxis/extensions/field_selection/sequel_query_selector_spec.rb

@@ -64,7 +64,7 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
     ]
   end
 
-  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields)  }
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields).selectors  }
   subject {described_class.new(query: query, selectors: selector_node, debug: debug) }
 
   context 'generate' do

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -103,7 +103,7 @@ class ActiveBookResource < ActiveBaseResource
 
   filters_mapping(
     id: :id,
-    category_uuid: :category_uuid,
+    # category_uuid: :category_uuid  #NOTE: we do not need to define same-name-mappings if they exist
     'fake_nested.name': 'simple_name',
     'name': 'simple_name',
     'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -8,7 +8,7 @@ describe Praxis::Mapper::SelectorGenerator do
   context '#add' do
     let(:resource) { SimpleResource }
     shared_examples 'a proper selector' do
-      it { expect(generator.add(resource, fields).dump).to be_deep_equal selectors }
+      it { expect(generator.add(resource, fields).selectors.dump).to be_deep_equal selectors }
     end
     
     context 'basic combos' do

data/spec/praxis/media_type_identifier_spec.rb

@@ -218,7 +218,21 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'replaces suffix and parameters and adds new ones' do
       expect(complex_subject + 'json; nuts=false; cherry=true').to \
-      eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+        eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+    end
+
+    context 'does not add json for an already json identifier' do
+      it 'non-parameterized mediatypes simply ignore adding the suffix' do
+        plain_application_json = described_class.new('application/json')
+
+        expect(plain_application_json + 'json').to \
+          eq(plain_application_json)
+      end
+      it 'parameterized mediatypes still keeps them' do
+        parameterized_application_json = described_class.new('application/json; cherry=true; nuts=false')
+        expect(parameterized_application_json + 'json').to \
+          eq(parameterized_application_json)
+      end
     end
   end
 end

data/spec/praxis/response_definition_spec.rb

@@ -8,7 +8,8 @@ describe Praxis::ResponseDefinition do
     Proc.new do
       status 200
       description 'test description'
-      headers({ "X-Header" => "value", "Content-Type" => "application/some-type" })
+      header( "X-Header", "value", description: 'Very nais header')
+      header( "Content-Type", "application/some-type" )
     end
   end
 
@@ -17,7 +18,7 @@ describe Praxis::ResponseDefinition do
   its(:parts) { should be(nil) }
   let(:response_status) { 200 }
   let(:response_content_type) { "application/some-type" }
-  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type} }
+  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type, "Location" => '/somewhere/over/the/rainbow'} }
 
   let(:response) { instance_double("Praxis::Response", status: response_status , headers: response_headers, content_type: response_content_type ) }
 
@@ -105,29 +106,6 @@ describe Praxis::ResponseDefinition do
     end
   end
 
-  context '#headers' do
-    it 'accepts a Hash' do
-      response_definition.headers Hash["X-Header" => "value", "Content-Type" => "application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-    end
-
-    it 'accepts an Array' do
-      response_definition.headers ["X-Header: value", "Content-Type: application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value", "Content-Type: application/some-type")
-    end
-
-    it 'accepts a String' do
-      response_definition.headers "X-Header: value"
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value")
-    end
-
-    it 'should return an error when headers are not a Hash, Array or String object' do
-      expect{ response_definition.headers Object.new }. to raise_error(Praxis::Exceptions::InvalidConfiguration)
-    end
-  end
-
   context '#parts' do
     context 'with a :like argument (and no block)' do
       before do
@@ -242,7 +220,6 @@ describe Praxis::ResponseDefinition do
 
       it "calls all the validation sub-functions" do
         expect(response_definition).to receive(:validate_status!).once
-        expect(response_definition).to receive(:validate_location!).once
         expect(response_definition).to receive(:validate_headers!).once
         expect(response_definition).to receive(:validate_content_type!).once
         response_definition.validate(response)
@@ -272,112 +249,39 @@ describe Praxis::ResponseDefinition do
 
       end
 
-      describe "#validate_location!" do
-        let(:block) { proc { status 200 } }
-
-        context 'checking location mismatches' do
-          before { response_definition.location(location) }
-
-          context 'for Regexp' do
-            let(:location) { /no_match/ }
-
-            it 'should raise an error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
-          end
-
-          context 'for String' do
-            let(:location) { "no_match" }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+      describe "#validate_headers!" do
+        context 'when there are missing headers' do
+          it 'should raise error' do
+            response_definition.header('X-Unknown', 'test')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
-
         end
-      end
-
-      describe "#validate_headers!" do
-        before { response_definition.headers(headers) }
-        context 'checking headers are set' do
-          context 'when there are missing headers' do
-            let (:headers) { { 'X-some' => 'test' } }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_headers!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+        context 'when headers with same names are returned' do
+          it 'a simply required header should not raise error just by being there' do
+            response_definition.header('X-Header', nil)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when headers specs are name strings" do
-            context "and is missing" do
-              let (:headers) { [ "X-Just-Key" ] }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) { [ "X-Header" ] }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'an exact string header should not raise error if it fully matches' do
+            response_definition.header('X-Header', 'value')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are hashes" do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Just-Key" => "notfoodbar" } ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" } ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should not raise error if it matches the regexp' do
+            response_definition.header('X-Header', /value/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are of mixed type " do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "not-gonna-find-me" ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "Content-Type" ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should raise error if it does not match the regexp' do
+            response_definition.header('X-Header', /anotherthing/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
         end
       end
@@ -478,7 +382,10 @@ describe Praxis::ResponseDefinition do
       if parts || parts_block
         parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
       end
-      response.headers(headers) if headers
+
+      headers&.each do |(name, value)|
+        response.header(name, value)
+      end
     end
 
     context 'for a definition with a media type' do
@@ -520,8 +427,9 @@ describe Praxis::ResponseDefinition do
       its([:location]){ should == {value: location.inspect ,type: :regexp} }
 
       it 'should have a header defined with value and type keys' do
-        expect( output[:headers] ).to have(1).keys
+        expect( output[:headers] ).to have(2).keys
         expect( output[:headers]['Header1'] ).to eq({value: 'Value1' ,type: :string })
+        expect( output[:headers]['Location'] ).to eq({value: "/\\/my\\/url\\//" ,type: :regexp })        
       end
     end