praxis 2.0.pre.8 → 2.0.pre.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa1ee705af72674f99b3b697fe5199636d6268a55696e1bcdf4a892b11b7acf3
-  data.tar.gz: e3cc19834e9640b0ee252240013367b7e444623d19e3acb9cb3eff8c83d71223
+  metadata.gz: f2a11ec74ee5a52178fe7aae10c503eb61407c739c40c262386e855e1abd40ee
+  data.tar.gz: 71b397991329ea9726b366938de75768bedf812324e4b2d768ac7dae3f25e33e
 SHA512:
-  metadata.gz: 958b4bf7d5684477bfb371e970f8f05871c1699a4980dc508367d5d659dc013ce049b3336d55ca1b4ca1cf617ec5b10924e92e41f18102680087ebf015fe6ce7
-  data.tar.gz: 2bbde613a765af9769b9dba0a13860b4dc520148e4263c5b4b52acf55960f8ba0aa63870f3f31c1ef73a047c33b7ffce30477d789380617f336c0893dedf31a6
+  metadata.gz: 21fbd6dbb60486cea3ec5cdd18a1b4178873ff6343182f2b44a11d71cbdac1664bec005760b77511de342fc92a63abe7864c85f10ffc1c3953734a1069f2520d
+  data.tar.gz: 7c0f8a5c417ad9ecd76fd67e08f1f219cc274c3bbd30ec88d7ae669e0a10d4ec5585c365ad7c3a38163b3d4f367897e7129bbbda66664947e82c37dc90213f08

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## next
 
+## 2.0.pre.9
+
+- Refined OpenAPI doc generation to output only non-null attributes in the InfoObject.
+- Fixed filtering params validation to properly allow null values for the "!" and "!!" operators
+
 ## 2.0.pre.6
 
 - Removed the explicit `links` helpers from a `MediaType`. There was too much magic and assumptions built into it. Things can still be built in a custom basis (or through a plugin) if necessary.

data/lib/praxis/docs/openapi/info_object.rb

@@ -10,20 +10,28 @@ module Praxis
         end
 
         def dump
-          data ={
-            title: info.title,
-            description: info.description,
-            termsOfService: info.termsOfService,
-            contact: info.contact,
-            license: info.license,
-            version: version,
-            :'x-name' => info.name,
-            :'x-logo' => {
+          data = { version: version }
+          [
+            :title,
+            :description,
+            :termsOfService,
+            :contact,
+            :license
+          ].each do |attr|
+            val = info.send(attr)
+            data[attr] = val if val
+          end
+
+          # Special attributes
+          data[:'x-name'] = info.name
+          if info.logo_url
+            data[:'x-logo'] = {
               url: info.logo_url,
               backgroundColor: "#FFFFFF",
               altText: info.title
             }
-          }
+          end
+          data
         end
       end
     end

data/lib/praxis/extensions/attribute_filtering/filtering_params.rb

@@ -166,7 +166,6 @@ module Praxis
             end
   
             attr_name = match[:attribute].to_sym
-            # TODO: we should coerce values if there's a mediatype defined?
             coerced = if media_type
               filter_components = attr_name.to_s.split('.').map(&:to_sym)
               attr, _enclosing_type = find_filter_attribute(filter_components, media_type)
@@ -217,21 +216,9 @@ module Praxis
               errors << "Operator #{item[:op]} not allowed for filter #{attr_name}"
             end
             value_type = attr_filters[:value_type]
-            value = item[:value]
-            if value_type && !value_type.valid_type?(value)
-              # Allow a collection of values of the right type for multimatch (if operators are = or !=)
-              if ['=','!='].include?(item[:op])
-                coll_type = Attributor::Collection.of(value_type)
-                if !coll_type.valid_type?(value)
-                  errors << "Invalid type in filter/s value for #{attr_name} " +\
-                            "(one or more of the multiple matches in #{value} are not  a #{value_type.name.split('::').last})"
-                end
-              else
-                errors << "Invalid type in filter value for #{attr_name} (#{value} using '#{item[:op]}' is not a #{value_type.name.split('::').last})"
-              end
-            end
-  
             next unless value_type == Attributor::String
+
+            value = item[:value]
             unless value.empty?
               fuzzy_match = attr_filters[:fuzzy_match]
               if (value[-1] == '*' || value[0] == '*') && !fuzzy_match

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.8'
+  VERSION = '2.0.pre.9'
 end

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

@@ -30,5 +30,111 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         ])
       end
     end
+
+    context 'with an associated MediaType' do
+      let(:params_for_post_media_type) 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
+
+      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(Post.attributes[:id].type.valid_type?(parsed.first[:value])).to be_truthy
+        end
+      end
+
+      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])
+          parsed.first[:value].each do |val|
+            expect(Post.attributes[:id].type.valid_type?(val)).to be_truthy
+          end
+        end
+      end
+
+      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)
+        end
+      end
+    end
+
+  end
+
+  context '.validate' do
+    let(:filtering_params_type) 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: ['=', '!=']
+        filter 'title', using: ['=', '!='], fuzzy: true
+        filter 'content', using: ['=', '!=']
+      end.type
+    end
+    let(:loaded_params) { filtering_params_type.load(filters_string) }
+    subject { loaded_params.validate(filters_string) }
+
+    context 'errors' do
+      context 'given attributes that do not exist in the type' do
+        let(:filters_string) { 'NotAnExistingAttribute=Foobar*'}
+        it 'raises an error' do
+          expect{subject}.to raise_error(/NotAnExistingAttribute.*does not exist/)
+        end
+      end
+
+      context 'given unallowed attributes' do
+        let(:filters_string) { 'href=Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          matches_error = subject.any? {|err| err =~ /Filtering by href is not allowed/}
+          expect(matches_error).to be_truthy
+        end
+      end
+
+      context 'given unallowed operator' do
+        let(:filters_string) { 'title>Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          expect(subject.first).to match(/Operator > not allowed for filter title/)
+        end
+      end
+    end
+    context 'fuzzy matches' do
+      context 'when allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'title=IAmAString*'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+      context 'when NOT allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'content=IAmAString*'}
+          it 'errors out' do
+            expect(subject).to_not be_empty
+            expect(subject.first).to match(/Fuzzy matching for content is not allowed/)
+          end
+        end
+        context 'given a non-fuzzy string' do
+          let(:filters_string) { 'content=IAmAString'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.8
+  version: 2.0.pre.9
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -758,7 +758,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: Building APIs the way you want it.