wcc-contentful 1.0.6 → 1.1.1

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('.')
@@ -108,7 +128,7 @@ module WCC::Contentful::Store
       includes = row.try(:includes) || row.try(:[], 1)
       return entry unless entry && depth && depth > 0
 
-      WCC::Contentful::LinkVisitor.new(entry, :Link, :Asset,
+      WCC::Contentful::LinkVisitor.new(entry, :Link,
         # Walk all the links except for the leaf nodes
         depth: depth - 1).map! do |val|
         resolve_link(val, includes)
@@ -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

@@ -130,24 +130,6 @@ RSpec.shared_examples 'basic store' do
     JSON
   end
 
-  before do
-    allow(WCC::Contentful).to receive(:types)
-      .and_return({
-        'root' => double(fields: {
-          'name' => double(name: 'name', type: :String, array: false),
-          'link' => double(name: 'link', type: :Link, array: false),
-          'links' => double(name: 'links', type: :Link, array: true)
-        }),
-        'shallow' => double(fields: {
-          'name' => double(name: 'name', type: :String, array: false)
-        }),
-        'deep' => double(fields: {
-          'name' => double(name: 'name', type: :String, array: false),
-          'subLink' => double(name: 'subLink', type: :Link, array: false)
-        })
-      })
-  end
-
   describe '#set/#find' do
     describe 'ensures that the stored value is of type Hash' do
       it 'should not raise an error if value is a Hash' do
@@ -546,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
@@ -652,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/sync_engine.rb

@@ -49,7 +49,6 @@ module WCC::Contentful
         end
 
         @store = store
-        @state = read_state if should_sync?
       end
       if state
         @state = token_wrapper_factory(state)

data/lib/wcc/contentful/test/attributes.rb

@@ -31,10 +31,6 @@ module WCC::Contentful::Test::Attributes
     ##
     # Get a hash of default values for all attributes unique to the given Contentful model.
     def defaults(const)
-      unless const < WCC::Contentful::Model
-        raise ArgumentError, "#{const} is not a subclass of WCC::Contentful::Model"
-      end
-
       const.content_type_definition.fields.each_with_object({}) do |(name, f), h|
         h[name.to_sym] = h[name.underscore.to_sym] = default_value(f)
       end

data/lib/wcc/contentful/test/double.rb

@@ -7,8 +7,10 @@ module WCC::Contentful::Test::Double
   # Builds a rspec double of the Contentful model for the given content_type.
   # All attributes that are known to be required fields on the content type
   # will return a default value based on the field type.
-  def contentful_double(content_type, **attrs)
-    const = WCC::Contentful::Model.resolve_constant(content_type)
+  def contentful_double(const, **attrs)
+    unless const.respond_to?(:content_type_definition)
+      const = WCC::Contentful::Model.resolve_constant(const.to_s)
+    end
     attrs.symbolize_keys!
 
     bad_attrs = attrs.reject { |a| const.instance_methods.include?(a) }

data/lib/wcc/contentful/test/factory.rb

@@ -7,8 +7,10 @@ module WCC::Contentful::Test::Factory
   # Builds a in-memory instance of the Contentful model for the given content_type.
   # All attributes that are known to be required fields on the content type
   # will return a default value based on the field type.
-  def contentful_create(content_type, context = nil, **attrs)
-    const = WCC::Contentful::Model.resolve_constant(content_type.to_s)
+  def contentful_create(const, context = nil, **attrs)
+    unless const.respond_to?(:content_type_definition)
+      const = WCC::Contentful::Model.resolve_constant(const.to_s)
+    end
     attrs = attrs.transform_keys { |a| a.to_s.camelize(:lower) }
 
     id = attrs.delete('id')

data/lib/wcc/contentful/version.rb

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