wcc-contentful 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f99e076627c9facfff117f6d9df87dcf593d8a07bb6d3351b159172207aff81a
-  data.tar.gz: 463c6b34cbf4a5718736e04365a9705795fd1f3435167cc1028d5c217596fb34
+  metadata.gz: 964aa9bb9b781c8ca90803f8117130daf1aac1ea88324ab64237b0e2a6a6c328
+  data.tar.gz: 834dd56d5e39fdad058efa794f1e5022b92d9122463c827d91d85ffcd9dbe291
 SHA512:
-  metadata.gz: 4be52c0f698f59b61f91d547ae7a2588b07bc9d184cd09a78730f7a09b290d005770b4f1ab3306d7e9cbc9ca0e5a20c7dc3c63fa39417a7c3219bf4c28ecd8a8
-  data.tar.gz: a1e93027a2a81655f9dbe82ee54c4f77061ef757c2dee9e3fe12369ce9f8d698fd01a7ab9a2510244273f567dbbdb05084eeb3b333abcafce9ccb05c6e62c4bc
+  metadata.gz: ff532ebd5b3750554a63786877d846c724e5edb28796f964977b7bc03064eada4ea3c608d0b0809a4306306c5bb75dfedc0ed5fa670ef7fb2b224b39ebcaafcc
+  data.tar.gz: '0886f5a8caad820a963af4d37a07fb319ae5cfc8735f400f41eb22131df9f90477b966d91f3e2f26e40bffc1579bcbc9bba2dd351cb677a28df90dea87368eef'

data/app/jobs/wcc/contentful/webhook_enable_job.rb

@@ -13,18 +13,17 @@ module WCC::Contentful
       client = WCC::Contentful::SimpleClient::Management.new(
         args
       )
-      enable_webhook(client, args.slice(:app_url, :webhook_username, :webhook_password))
+      enable_webhook(client, args.slice(:receive_url, :webhook_username, :webhook_password))
     end
 
-    def enable_webhook(client, app_url:, webhook_username: nil, webhook_password: nil)
-      expected_url = URI.join(app_url, 'webhook/receive').to_s
-      webhook = client.webhook_definitions.items.find { |w| w['url'] == expected_url }
+    def enable_webhook(client, receive_url:, webhook_username: nil, webhook_password: nil)
+      webhook = client.webhook_definitions.items.find { |w| w['url'] == receive_url }
       logger.debug "existing webhook: #{webhook.inspect}" if webhook
       return if webhook
 
       body = {
         'name' => 'WCC::Contentful webhook',
-        'url' => expected_url,
+        'url' => receive_url,
         'topics' => [
           '*.publish',
           '*.unpublish'
@@ -50,13 +49,14 @@ module WCC::Contentful
 
       {
         management_token: config.management_token,
-        app_url: config.app_url,
         space: config.space,
         environment: config.environment,
         default_locale: config.default_locale,
         connection: config.connection,
         webhook_username: config.webhook_username,
-        webhook_password: config.webhook_password
+        webhook_password: config.webhook_password,
+
+        receive_url: URI.join(config.app_url, 'webhook/receive').to_s
       }
     end
 

data/lib/wcc/contentful/store/cdn_adapter.rb

@@ -105,6 +105,11 @@ module WCC::Contentful::Store
 
       def apply_operator(operator, field, expected, context = nil)
         op = operator == :eq ? nil : operator
+        if expected.is_a?(Array)
+          expected = expected.join(',')
+          op = :in if op.nil?
+        end
+
         param = parameter(field, operator: op, context: context, locale: true)
 
         self.class.new(

data/lib/wcc/contentful/store/memory_store.rb

@@ -38,7 +38,13 @@ module WCC::Contentful::Store
       end
     end
 
+    SUPPORTED_OPS = %i[eq ne in nin].freeze
+
     def execute(query)
+      (query.conditions.map(&:op) - SUPPORTED_OPS).each do |op|
+        raise ArgumentError, "Operator :#{op} not supported"
+      end
+
       relation = mutex.with_read_lock { @hash.values }
 
       # relation is an enumerable that we apply conditions to in the form of
@@ -56,21 +62,49 @@ module WCC::Contentful::Store
       # For each condition, we apply a new Enumerable#select with a block that
       # enforces the condition.
       query.conditions.reduce(relation) do |memo, condition|
-        memo.select do |entry|
-          # Our naiive implementation only supports equality operator
-          raise ArgumentError, "Operator #{condition.op} not supported" unless condition.op == :eq
+        __send__("apply_#{condition.op}", memo, condition)
+      end
+    end
 
-          # The condition's path tells us where to find the value in the JSON object
-          val = entry.dig(*condition.path)
+    private
 
-          # For arrays, equality is defined as does the array include the expected value.
-          # See https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/array-equality-inequality
-          if val.is_a? Array
-            val.include?(condition.expected)
-          else
-            val == condition.expected
-          end
-        end
+    def apply_eq(memo, condition)
+      memo.select { |entry| eq?(entry, condition) }
+    end
+
+    def apply_ne(memo, condition)
+      memo.reject { |entry| eq?(entry, condition) }
+    end
+
+    def eq?(entry, condition)
+      # The condition's path tells us where to find the value in the JSON object
+      val = entry.dig(*condition.path)
+
+      # For arrays, equality is defined as does the array include the expected value.
+      # See https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/array-equality-inequality
+      if val.is_a? Array
+        val.include?(condition.expected)
+      else
+        val == condition.expected
+      end
+    end
+
+    def apply_in(memo, condition)
+      memo.select { |entry| in?(entry, condition) }
+    end
+
+    def apply_nin(memo, condition)
+      memo.reject { |entry| in?(entry, condition) }
+    end
+
+    def in?(entry, condition)
+      val = entry.dig(*condition.path)
+
+      if val.is_a? Array
+        # TODO: detect if in ruby 3.1 and use val.intersect?(condition.expected)
+        val.any? { |item| condition.expected.include?(item) }
+      else
+        condition.expected.include?(val)
       end
     end
   end

data/lib/wcc/contentful/store/query.rb

@@ -34,6 +34,17 @@ module WCC::Contentful::Store
       @extra = extra
     end
 
+    FALSE_VALUES = [
+      false, 0,
+      '0', :"0",
+      'f', :f,
+      'F', :F,
+      'false', :false, # rubocop:disable Lint/BooleanSymbol
+      'FALSE', :FALSE,
+      'off', :off,
+      'OFF', :OFF
+    ].to_set.freeze
+
     # Returns a new chained Query that has a new condition.  The new condition
     # represents the WHERE comparison being applied here.  The underlying store
     # implementation translates this condition statement into an appropriate
@@ -50,7 +61,16 @@ module WCC::Contentful::Store
     # @expected The expected value to compare the field's value against.
     # @context A context object optionally containing `context[:locale]`
     def apply_operator(operator, field, expected, context = nil)
+      operator ||= expected.is_a?(Array) ? :in : :eq
       raise ArgumentError, "Operator #{operator} not supported" unless respond_to?(operator)
+      raise ArgumentError, 'value cannot be nil (try using exists: false)' if expected.nil?
+
+      case operator
+      when :in, :nin, :all
+        expected = Array(expected)
+      when :exists
+        expected = !FALSE_VALUES.include?(expected)
+      end
 
       field = field.to_s if field.is_a? Symbol
       path = field.is_a?(Array) ? field : field.split('.')
@@ -151,7 +171,7 @@ module WCC::Contentful::Store
           elsif op?(k)
             { path: path, op: k.to_sym, expected: v }
           else
-            { path: path + [k], op: :eq, expected: v }
+            { path: path + [k], op: nil, expected: v }
           end
         end
       end

data/lib/wcc/contentful/store/rspec_examples/basic_store.rb

@@ -528,68 +528,6 @@ RSpec.shared_examples 'basic store' do
       expect(found.dig('sys', 'id')).to eq('idTwo')
       expect(found.dig('fields', 'system', 'en-US')).to eq('Two')
     end
-
-    [
-      [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
-      [Float, proc { rand }]
-    ].each do |(type, generator)|
-      context "by #{type} equality" do
-        it 'can apply filter object' do
-          data =
-            1.upto(10).map do |i|
-              {
-                'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-                'fields' => { type.to_s => { 'en-US' => generator.call } }
-              }
-            end
-
-          desired_value = generator.call
-          desired = {
-            'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-            'fields' => { type.to_s => { 'en-US' => desired_value } }
-          }
-
-          data << desired
-          data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-          # act
-          found = subject.find_by(content_type: 'test1', filter: { type.to_s => desired_value })
-
-          # assert
-          expect(found).to_not be_nil
-          expect(found).to eq(desired)
-        end
-
-        it 'filter object can find value in array' do
-          data =
-            1.upto(10).map do |i|
-              {
-                'sys' => {
-                  'id' => "k#{i}",
-                  'contentType' => { 'sys' => { 'id' => 'test1' } }
-                },
-                'fields' => { 'name' => { 'en-US' => [generator.call, generator.call] } }
-              }
-            end
-
-          desired_value = generator.call
-          desired = {
-            'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
-            'fields' => { type.to_s => { 'en-US' => [generator.call, desired_value].shuffle } }
-          }
-
-          data << desired
-          data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-          # act
-          found = subject.find_by(content_type: 'test1', filter: { type.to_s => { eq: desired_value } })
-
-          # assert
-          expect(found).to_not be_nil
-          expect(found).to eq(desired)
-        end
-      end
-    end
   end
 
   describe '#find_all' do
@@ -634,29 +572,6 @@ RSpec.shared_examples 'basic store' do
         %w[k1 k5 k9]
       )
     end
-
-    it 'filter query eq can find value in array' do
-      content_types = %w[test1 test2 test3 test4]
-      data =
-        1.upto(10).map do |i|
-          {
-            'sys' => {
-              'id' => "k#{i}",
-              'contentType' => { 'sys' => { 'id' => content_types[i % content_types.length] } }
-            },
-            'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
-          }
-        end
-      data.each { |d| subject.set(d.dig('sys', 'id'), d) }
-
-      # act
-      found = subject.find_all(content_type: 'test2')
-        .apply('name' => { eq: 'test_2_5' })
-
-      # assert
-      expect(found.count).to eq(1)
-      expect(found.first.dig('sys', 'id')).to eq('k5')
-    end
   end
 
   def make_link_to(id, link_type = 'Entry')

data/lib/wcc/contentful/store/rspec_examples/operators/eq.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :eq operator' do
+  [
+    [String, proc { "test#{rand(1..10_000)}" }],
+    [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
+    [Float, proc { rand }]
+  ].each do |(type, generator)|
+    context "with #{type} value" do
+      let(:desired_value) {
+        generator.call
+      }
+
+      let(:data) {
+        1.upto(3).map do |i|
+          {
+            'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+            'fields' => { type.to_s => { 'en-US' => generator.call } }
+          }
+        end
+      }
+
+      let(:desired) {
+        {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => desired_value } }
+        }
+      }
+
+      it 'find_by can apply filter object' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => desired_value })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_by can find value in array' do
+        data =
+          1.upto(3).map do |i|
+            {
+              'sys' => {
+                'id' => "k#{i}",
+                'contentType' => { 'sys' => { 'id' => 'test1' } }
+              },
+              'fields' => { 'name' => { 'en-US' => [generator.call, generator.call] } }
+            }
+          end
+
+        desired_value = generator.call
+        desired = {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => [generator.call, desired_value].shuffle } }
+        }
+
+        data << desired
+        data.shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { eq: desired_value } })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_all can apply operator' do
+        desired =
+          4.upto(5).map do |i|
+            {
+              'sys' => { 'id' => "k#{i}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+              'fields' => { type.to_s => { 'en-US' => desired_value } }
+            }
+          end
+
+        [*data, *desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_all(content_type: 'test1')
+          .eq(type.to_s, desired_value)
+
+        # assert
+        expect(found.count).to eq(2)
+        sorted = found.to_a.sort_by { |item| item.dig('sys', 'id') }
+        expect(sorted).to eq(desired)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/in.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :in operator' do
+  it 'find_all with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.shuffle.take(2)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .in('name', to_find.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(2)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      to_find.map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_all with array on array field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find1, to_find2 = ids.shuffle
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .in('name', ["test#{to_find1}", "test_2_#{to_find2}"])
+
+    expect(found.count).to eq(2)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      ["k#{to_find1}", "k#{to_find2}"].sort
+    )
+  end
+
+  it 'find_all defaults to :in when given an array' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.shuffle.take(3)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .apply('name' => to_find.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(3)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      to_find.map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_by with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.sample
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: { in: ['asdf', "test#{to_find}"] } }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_find}")
+  end
+
+  it 'find_by defaults to :in when given an array' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_find = ids.sample
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: ['asdf', "test#{to_find}"] }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_find}")
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/ne.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :ne operator' do
+  [
+    [String, proc { "test#{rand(1..100_000)}" }],
+    [Integer, proc { rand(-4_611_686_018_427_387_903..4_611_686_018_427_387_903) }],
+    [Float, proc { rand }]
+  ].each do |(type, generator)|
+    context "with #{type} value" do
+      let(:specified_value) {
+        generator.call
+      }
+
+      let(:desired) {
+        # desired entry doesn't have the specified_value
+        {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => 1.upto(rand(2..5)).map { generator.call } } }
+        }
+      }
+
+      let(:data) {
+        1.upto(3).map do |i|
+          random_values = 1.upto(rand(2..5)).map { generator.call }
+
+          # remaining data does include the specified_value
+          {
+            'sys' => {
+              'id' => "k#{i}",
+              'contentType' => { 'sys' => { 'id' => 'test1' } }
+            },
+            'fields' => { type.to_s => { 'en-US' => [*random_values, specified_value].shuffle } }
+          }
+        end
+      }
+
+      it 'find_by can apply filter object' do
+        specified_value = generator.call
+        data = {
+          'sys' => { 'id' => "k#{rand}", 'contentType' => { 'sys' => { 'id' => 'test1' } } },
+          'fields' => { type.to_s => { 'en-US' => specified_value } }
+        }
+
+        subject.set(data.dig('sys', 'id'), data)
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { ne: specified_value } })
+
+        # assert
+        expect(found).to be_nil
+      end
+
+      it 'find_by can find value in array' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'test1', filter: { type.to_s => { ne: specified_value } })
+
+        # assert
+        expect(found).to_not be_nil
+        expect(found).to eq(desired)
+      end
+
+      it 'find_all can apply operator' do
+        [*data, desired].shuffle.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_all(content_type: 'test1')
+          .ne(type.to_s, specified_value)
+
+        # assert
+        expect(found.count).to eq(1)
+        expect(found.first).to eq(desired)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators/nin.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports :nin operator' do
+  it 'find_all with array on string field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude = ids.shuffle.take(2)
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .nin('name', to_exclude.map { |i| "test#{i}" })
+
+    expect(found.count).to eq(8)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      (ids - to_exclude).map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_all with array on array field' do
+    ids = 1.upto(10).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => ["test#{i}", "test_2_#{i}"] } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude1, to_exclude2 = ids.shuffle
+
+    # act
+    found = subject.find_all(content_type: 'test')
+      .nin('name', ["test#{to_exclude1}", "test_2_#{to_exclude2}"])
+
+    expect(found.count).to eq(8)
+    expect(found.map { |item| item.dig('sys', 'id') }.sort).to eq(
+      (ids - [to_exclude1, to_exclude2]).map { |i| "k#{i}" }.sort
+    )
+  end
+
+  it 'find_by with array on string field' do
+    ids = 1.upto(2).to_a
+    data =
+      ids.map do |i|
+        {
+          'sys' => {
+            'id' => "k#{i}",
+            'contentType' => { 'sys' => { 'id' => 'test' } }
+          },
+          'fields' => { 'name' => { 'en-US' => "test#{i}" } }
+        }
+      end
+    data.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+    to_exclude, to_expect = ids.shuffle
+
+    # act
+    found = subject.find_by(
+      content_type: 'test',
+      filter: { name: { nin: ['asdf', "test#{to_exclude}"] } }
+    )
+
+    expect(found.dig('sys', 'id')).to eq("k#{to_expect}")
+  end
+end

data/lib/wcc/contentful/store/rspec_examples/operators.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative './operators/eq'
+require_relative './operators/ne'
+require_relative './operators/in'
+require_relative './operators/nin'
+
+(WCC::Contentful::Store::Query::Interface::OPERATORS -
+  %i[eq ne in nin]).each do |op|
+    RSpec.shared_examples "supports :#{op} operator" do
+      it 'TODO'
+    end
+  end
+
+RSpec.shared_examples 'operators' do |feature_set|
+  supported_operators =
+    if feature_set.nil?
+      WCC::Contentful::Store::Query::Interface::OPERATORS
+        .each_with_object({}) { |k, h| h[k] = 'pending' }
+    elsif feature_set.is_a?(Array)
+      WCC::Contentful::Store::Query::Interface::OPERATORS
+        .each_with_object({}) { |k, h| h[k] = feature_set.include?(k.to_sym) }
+    elsif feature_s.is_a?(Hash)
+      feature_set
+    else
+      raise ArgumentError, 'Please provide a hash or array of operators to test'
+    end
+
+  supported_operators.each do |op, value|
+    next if value
+
+    it "does not support :#{op}" do
+      expect {
+        subject.find_all(content_type: 'test')
+          .apply('name' => { op => 'test' })
+          .to_a
+      }.to raise_error do |ex|
+        expect(ex.to_s).to match(/not supported/)
+      end
+    end
+  end
+
+  supported_operators.each do |op, value|
+    next unless value
+
+    it_behaves_like "supports :#{op} operator" do
+      before { pending(":#{op} operator to be implemented") } if value == 'pending'
+    end
+  end
+end

data/lib/wcc/contentful/store/rspec_examples.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './rspec_examples/basic_store'
+require_relative './rspec_examples/operators'
 require_relative './rspec_examples/nested_queries'
 require_relative './rspec_examples/include_param'
 
@@ -41,6 +42,7 @@ RSpec.shared_examples 'contentful store' do |feature_set|
   }.merge(feature_set&.symbolize_keys || {})
 
   include_examples 'basic store'
+  include_examples 'operators', feature_set[:operators]
   include_examples 'supports nested queries', feature_set[:nested_queries]
   include_examples 'supports include param', feature_set[:include_param]
 end

data/lib/wcc/contentful/version.rb

@@ -2,6 +2,6 @@
 
 module WCC
   module Contentful
-    VERSION = '1.1.0'
+    VERSION = '1.1.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wcc-contentful
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Watermark Dev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-02 00:00:00.000000000 Z
+date: 2022-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -484,6 +484,11 @@ files:
 - lib/wcc/contentful/store/rspec_examples/basic_store.rb
 - lib/wcc/contentful/store/rspec_examples/include_param.rb
 - lib/wcc/contentful/store/rspec_examples/nested_queries.rb
+- lib/wcc/contentful/store/rspec_examples/operators.rb
+- lib/wcc/contentful/store/rspec_examples/operators/eq.rb
+- lib/wcc/contentful/store/rspec_examples/operators/in.rb
+- lib/wcc/contentful/store/rspec_examples/operators/ne.rb
+- lib/wcc/contentful/store/rspec_examples/operators/nin.rb
 - lib/wcc/contentful/sync_engine.rb
 - lib/wcc/contentful/sys.rb
 - lib/wcc/contentful/test.rb