wcc-contentful 0.4.0.pre.beta → 1.0.0

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

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'supports include param' do |feature_set|
+  describe 'supports options: { include: >0 }' do
+    before { skip('include_param feature not supported') } if feature_set == false
+    before { pending('include_param feature not yet implemented') } if feature_set&.to_s == 'pending'
+
+    let(:root) do
+      {
+        'sys' => {
+          'id' => 'root',
+          'type' => 'Entry',
+          'contentType' => { 'sys' => { 'id' => 'root' } }
+        },
+        'fields' => {
+          'name' => { 'en-US' => 'root' },
+          'link' => { 'en-US' => make_link_to('deep1') },
+          'links' => { 'en-US' => [
+            make_link_to('shallow3'),
+            make_link_to('deep2')
+          ] }
+        }
+      }
+    end
+
+    def shallow(id = nil) # rubocop:disable Naming/UncommunicativeMethodParamName
+      {
+        'sys' => {
+          'id' => "shallow#{id}",
+          'type' => 'Entry',
+          'contentType' => { 'sys' => { 'id' => 'shallow' } }
+        },
+        'fields' => { 'name' => { 'en-US' => "shallow#{id}" } }
+      }
+    end
+
+    def deep(id, link = nil) # rubocop:disable Naming/UncommunicativeMethodParamName
+      {
+        'sys' => {
+          'id' => "deep#{id}",
+          'type' => 'Entry',
+          'contentType' => { 'sys' => { 'id' => 'deep' } }
+        },
+        'fields' => {
+          'name' => { 'en-US' => "deep#{id}" },
+          'subLink' => { 'en-US' => link || make_link_to("shallow#{id}") }
+        }
+      }
+    end
+
+    describe '#find_by' do
+      it 'recursively resolves links if include > 0' do
+        [
+          root,
+          *1.upto(3).map { |i| shallow(i) },
+          *1.upto(2).map { |i| deep(i) }
+        ].each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'root', filter: { name: 'root' }, options: {
+          include: 2
+        })
+
+        # assert
+        expect(found.dig('sys', 'id')).to eq('root')
+
+        # depth 1
+        link = found.dig('fields', 'link', 'en-US')
+        expect(link.dig('fields', 'name', 'en-US')).to eq('deep1')
+        links = found.dig('fields', 'links', 'en-US')
+        expect(links[0].dig('fields', 'name', 'en-US')).to eq('shallow3')
+
+        # depth 2
+        expect(link.dig('fields', 'subLink', 'en-US', 'fields', 'name', 'en-US'))
+          .to eq('shallow1')
+        expect(links[1].dig('fields', 'subLink', 'en-US', 'fields', 'name', 'en-US'))
+          .to eq('shallow2')
+      end
+
+      it 'stops resolving links at include depth' do
+        [
+          root,
+          *1.upto(3).map { |i| shallow(i) },
+          *1.upto(2).map { |i| deep(i) }
+        ].each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        found = subject.find_by(content_type: 'root', filter: { name: 'root' }, options: {
+          include: 1
+        })
+
+        # assert
+        expect(found.dig('sys', 'id')).to eq('root')
+
+        # depth 1
+        link = found.dig('fields', 'link', 'en-US')
+        expect(link.dig('fields', 'name', 'en-US')).to eq('deep1')
+        links = found.dig('fields', 'links', 'en-US')
+        expect(links[0].dig('fields', 'name', 'en-US')).to eq('shallow3')
+
+        # depth 2
+        expect(link.dig('fields', 'subLink', 'en-US', 'sys', 'type'))
+          .to eq('Link')
+        expect(links[1].dig('fields', 'subLink', 'en-US', 'sys', 'type'))
+          .to eq('Link')
+      end
+
+      1.upto(5).each do |depth|
+        it "does not call into #find in order to resolve include: #{depth}" do
+          skip("supported up to #{feature_set}") if feature_set.is_a?(Integer) && feature_set < depth
+
+          items = [root]
+          # 1..N
+          1.upto(depth).map do |n|
+            items << deep(n, make_link_to("deep#{n + 1}"))
+          end
+          items.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+          # Expect
+          expect(subject).to_not receive(:find)
+
+          # act
+          found = subject.find_by(content_type: 'root', filter: { name: 'root' }, options: {
+            include: depth
+          })
+
+          link = found.dig('fields', 'link', 'en-US')
+          1.upto(depth).each do |_n|
+            expect(link.dig('sys', 'type')).to eq('Entry')
+            link = link.dig('fields', 'subLink', 'en-US')
+          end
+          expect(link.dig('sys', 'type')).to eq('Link')
+        end
+      end
+
+      it 'handles recursion' do
+        items = [
+          deep(0, make_link_to('deep1')),
+          deep(1, make_link_to('deep0'))
+        ]
+        items.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        r0 = subject.find_by(content_type: 'deep', filter: { id: 'deep0' }, options: {
+          include: 4
+        })
+
+        link = r0.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep1')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep0')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep1')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep0')
+      end
+    end
+
+    describe '#find_all' do
+      it 'recursively resolves links if include > 0' do
+        [
+          root,
+          *1.upto(3).map { |i| shallow(i) },
+          *1.upto(2).map { |i| deep(i) }
+        ].each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        result = subject.find_all(content_type: 'root', options: {
+          include: 2
+        }).to_a
+
+        # assert
+        found = result.first
+        expect(found.dig('sys', 'id')).to eq('root')
+
+        # depth 1
+        link = found.dig('fields', 'link', 'en-US')
+        expect(link.dig('fields', 'name', 'en-US')).to eq('deep1')
+        links = found.dig('fields', 'links', 'en-US')
+        expect(links[0].dig('fields', 'name', 'en-US')).to eq('shallow3')
+
+        # depth 2
+        expect(link.dig('fields', 'subLink', 'en-US', 'fields', 'name', 'en-US'))
+          .to eq('shallow1')
+        expect(links[1].dig('fields', 'subLink', 'en-US', 'fields', 'name', 'en-US'))
+          .to eq('shallow2')
+      end
+
+      it 'stops resolving links at include depth' do
+        [
+          root,
+          *1.upto(3).map { |i| shallow(i) },
+          *1.upto(2).map { |i| deep(i) }
+        ].each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        result = subject.find_all(content_type: 'root', options: {
+          include: 1
+        }).to_a
+
+        # assert
+        found = result.first
+        expect(found.dig('sys', 'id')).to eq('root')
+
+        # depth 1
+        link = found.dig('fields', 'link', 'en-US')
+        expect(link.dig('fields', 'name', 'en-US')).to eq('deep1')
+        links = found.dig('fields', 'links', 'en-US')
+        expect(links[0].dig('fields', 'name', 'en-US')).to eq('shallow3')
+
+        # depth 2
+        expect(link.dig('fields', 'subLink', 'en-US', 'sys', 'type'))
+          .to eq('Link')
+        expect(links[1].dig('fields', 'subLink', 'en-US', 'sys', 'type'))
+          .to eq('Link')
+      end
+
+      1.upto(5).each do |depth|
+        it "does not call into #find in order to resolve include: #{depth}" do
+          skip("supported up to #{feature_set}") if feature_set.is_a?(Integer) && feature_set < depth
+
+          # 1..N
+          items =
+            0.upto(depth).map do |n|
+              deep(n, make_link_to("deep#{n + 1}"))
+            end
+          items.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+          # Expect
+          expect(subject).to_not receive(:find)
+
+          # act
+          results = subject.find_all(content_type: 'deep', options: {
+            include: depth
+          }).to_a
+
+          results.sort_by { |entry| entry.dig('sys', 'id') }.each_with_index do |found, n|
+            link = found.dig('fields', 'subLink', 'en-US')
+            1.upto(depth - n).each do |_n|
+              expect(link.dig('sys', 'type')).to eq('Entry')
+              link = link.dig('fields', 'subLink', 'en-US')
+            end
+            expect(link.dig('sys', 'type')).to eq('Link')
+          end
+          expect(results.length).to eq(items.length)
+        end
+      end
+
+      it 'handles recursion' do
+        items = [
+          deep(0, make_link_to('deep1')),
+          deep(1, make_link_to('deep0'))
+        ]
+        items.each { |d| subject.set(d.dig('sys', 'id'), d) }
+
+        # act
+        results = subject.find_all(content_type: 'deep', options: {
+          include: 4
+        }).to_a
+
+        results = results.sort_by { |entry| entry.dig('sys', 'id') }
+
+        r0 = results[0]
+        link = r0.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep1')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep0')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep1')
+        link = link.dig('fields', 'subLink', 'en-US')
+        expect(link.dig('sys', 'type')).to eq('Entry')
+        expect(link.dig('sys', 'id')).to eq('deep0')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/BlockDelimiters
+
+RSpec.shared_examples 'supports nested queries' do |feature_set|
+  describe 'nested (join) queries' do
+    before { skip('nested_queries feature not supported') } if feature_set == false
+    before { pending('nested_queries feature to be implemented') } if feature_set&.to_s == 'pending'
+
+    let(:team) {
+      JSON.parse(<<~JSON)
+        {
+          "sys": {
+            "space": {
+              "sys": {
+                "type": "Link",
+                "linkType": "Space",
+                "id": "hw5pse7y1ojx"
+              }
+            },
+            "id": "Team-1234",
+            "type": "Entry",
+            "createdAt": "2018-03-09T23:39:27.737Z",
+            "updatedAt": "2018-03-09T23:39:27.737Z",
+            "revision": 1,
+            "contentType": {
+              "sys": {
+                "type": "Link",
+                "linkType": "ContentType",
+                "id": "team"
+              }
+            }
+          },
+          "fields": {
+            "name": {
+              "en-US": "Dallas Cowboys"
+            },
+            "members": {
+              "en-US": [
+                {
+                  "sys": {
+                    "type": "Link",
+                    "linkType": "Entry",
+                    "id": "Member-1"
+                  }
+                },
+                {
+                  "sys": {
+                    "type": "Link",
+                    "linkType": "Entry",
+                    "id": "Member-2"
+                  }
+                }
+              ]
+            },
+            "owner": {
+              "en-US": {
+                "sys": {
+                  "type": "Link",
+                  "linkType": "Entry",
+                  "id": "Owner-1"
+                }
+              }
+            }
+          }
+        }
+      JSON
+    }
+
+    let(:member1) {
+      JSON.parse(<<~JSON)
+        {
+          "sys": {
+            "space": {
+              "sys": {
+                "type": "Link",
+                "linkType": "Space",
+                "id": "hw5pse7y1ojx"
+              }
+            },
+            "id": "Member-1",
+            "type": "Entry",
+            "createdAt": "2019-09-16T19:49:57.879Z",
+            "updatedAt": "2019-09-16T19:49:57.879Z",
+            "revision": 1,
+            "contentType": {
+              "sys": {
+                "type": "Link",
+                "linkType": "ContentType",
+                "id": "person"
+              }
+            }
+          },
+          "fields": {
+            "firstName": {
+              "en-US": "Ezekiel "
+            },
+            "lastName": {
+              "en-US": "Elliot"
+            },
+            "position": {
+              "en-US": "Running Back"
+            },
+            "profileImage": {
+              "en-US": {
+                "sys": {
+                  "type": "Link",
+                  "linkType": "Asset",
+                  "id": "3pWma8spR62aegAWAWacyA"
+                }
+              }
+            }
+          }
+        }
+      JSON
+    }
+
+    let(:member2) {
+      JSON.parse(<<~JSON)
+        {
+          "sys": {
+            "space": {
+              "sys": {
+                "type": "Link",
+                "linkType": "Space",
+                "id": "hw5pse7y1ojx"
+              }
+            },
+            "id": "Member-2",
+            "type": "Entry",
+            "createdAt": "2019-09-16T19:49:57.879Z",
+            "updatedAt": "2019-09-16T19:49:57.879Z",
+            "revision": 1,
+            "contentType": {
+              "sys": {
+                "type": "Link",
+                "linkType": "ContentType",
+                "id": "person"
+              }
+            }
+          },
+          "fields": {
+            "firstName": {
+              "en-US": "Dak"
+            },
+            "lastName": {
+              "en-US": "Prescot"
+            },
+            "position": {
+              "en-US": "Quarterback"
+            },
+            "profileImage": null
+          }
+        }
+      JSON
+    }
+
+    let(:owner) {
+      JSON.parse(<<~JSON)
+        {
+          "sys": {
+            "space": {
+              "sys": {
+                "type": "Link",
+                "linkType": "Space",
+                "id": "hw5pse7y1ojx"
+              }
+            },
+            "id": "Owner-1",
+            "type": "Entry",
+            "createdAt": "2019-09-16T19:49:57.879Z",
+            "updatedAt": "2019-09-16T19:49:57.879Z",
+            "revision": 1,
+            "contentType": {
+              "sys": {
+                "type": "Link",
+                "linkType": "ContentType",
+                "id": "person"
+              }
+            }
+          },
+          "fields": {
+            "firstName": {
+              "en-US": "Jerry"
+            },
+            "lastName": {
+              "en-US": "Jones"
+            },
+            "position": {
+              "en-US": "owner"
+            }
+          }
+        }
+      JSON
+    }
+
+    describe '#find_by' do
+      context 'singular reference' do
+        before do
+          # add a dummy redirect that we ought to pass over
+          redirect2 = entry.deep_dup
+          redirect2['sys']['id'] = 'wrong_one'
+          redirect2['fields'].delete('page')
+          subject.set('wrong_one', redirect2)
+
+          [entry, page, asset].each { |d| subject.set(d.dig('sys', 'id'), d) }
+        end
+
+        it 'allows filtering by a reference field' do
+          # act
+          found = subject.find_by(
+            content_type: 'redirect',
+            filter: {
+              page: {
+                slug: { eq: 'some-page' }
+              }
+            }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('1qLdW7i7g4Ycq6i4Cckg44')
+          expect(found.dig('sys', 'contentType', 'sys', 'id')).to eq('redirect')
+        end
+
+        it 'allows filtering by reference id' do
+          # act
+          found = subject.find_by(
+            content_type: 'redirect',
+            filter: { 'page' => { id: '2zKTmej544IakmIqoEu0y8' } }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('1qLdW7i7g4Ycq6i4Cckg44')
+        end
+
+        it 'handles explicitly specified sys attr' do
+          # act
+          found = subject.find_by(
+            content_type: 'redirect',
+            filter: {
+              page: {
+                'sys.contentType.sys.id' => 'page'
+              }
+            }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('1qLdW7i7g4Ycq6i4Cckg44')
+        end
+      end
+
+      context 'array reference' do
+        before do
+          # add a second team
+          team2 = team.deep_dup
+          team2['sys']['id'] = 'wrong_one'
+          team2['fields'].delete('members')
+          subject.set('wrong_one', team2)
+
+          [team, member1, member2, owner].each { |d| subject.set(d.dig('sys', 'id'), d) }
+        end
+
+        it 'filters by array reference field' do
+          # act
+          found = subject.find_by(
+            content_type: 'team',
+            filter: {
+              members: {
+                firstName: { eq: 'Dak' }
+              }
+            }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('Team-1234')
+        end
+
+        # The PostgresStore uses a 'links' column to do a join expression,
+        # this checks errors related to that case.
+        it 'does not include a link in another field' do
+          # act
+          found = subject.find_by(
+            content_type: 'team',
+            filter: {
+              members: {
+                lastName: { eq: 'Jones' }
+              }
+            }
+          )
+
+          expect(found).to be_nil
+
+          found2 = subject.find_by(
+            content_type: 'team',
+            filter: {
+              owner: {
+                lastName: { eq: 'Jones' }
+              }
+            }
+          )
+          expect(found2).to_not be_nil
+        end
+
+        it 'filters by array reference ID' do
+          # act
+          found = subject.find_by(
+            content_type: 'team',
+            filter: {
+              members: { id: 'Member-1' }
+            }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('Team-1234')
+        end
+
+        it 'handles explicitly specified sys attr' do
+          # act
+          found = subject.find_by(
+            content_type: 'team',
+            filter: {
+              members: {
+                'sys.contentType.sys.id' => 'person'
+              }
+            }
+          )
+
+          # assert
+          expect(found).to_not be_nil
+          expect(found.dig('sys', 'id')).to eq('Team-1234')
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/BlockDelimiters