debian-mirror-gitlab/spec/graphql/resolvers/paginated_tree_resolver_spec.rb
2021-10-27 15:23:28 +05:30

102 lines
2.8 KiB
Ruby

# frozen_string_literal: true
require 'spec_helper'
RSpec.describe Resolvers::PaginatedTreeResolver do
include GraphqlHelpers
let_it_be(:project) { create(:project, :repository) }
let_it_be(:repository) { project.repository }
specify do
expect(described_class).to have_nullable_graphql_type(Types::Tree::TreeType.connection_type)
end
describe '#resolve', :aggregate_failures do
subject { resolve_repository(args, opts) }
let(:args) { { ref: 'master' } }
let(:opts) { {} }
let(:start_cursor) { subject.start_cursor }
let(:end_cursor) { subject.end_cursor }
let(:items) { subject.items }
let(:entries) { items.first.entries }
it 'resolves to a collection with a tree object' do
expect(items.first).to be_an_instance_of(Tree)
expect(start_cursor).to be_nil
expect(end_cursor).to be_blank
expect(entries.count).to eq(repository.tree.entries.count)
end
context 'with recursive option' do
let(:args) { super().merge(recursive: true) }
it 'resolve to a recursive tree' do
expect(entries[4].path).to eq('files/html')
end
end
context 'with limited max_page_size' do
let(:opts) { { max_page_size: 5 } }
it 'resolves to a pagination collection with a tree object' do
expect(items.first).to be_an_instance_of(Tree)
expect(start_cursor).to be_nil
expect(end_cursor).to be_present
expect(entries.count).to eq(5)
end
end
context 'when repository does not exist' do
before do
allow(repository).to receive(:exists?).and_return(false)
end
it 'returns nil' do
is_expected.to be(nil)
end
end
describe 'Cursor pagination' do
context 'when cursor is invalid' do
let(:args) { super().merge(after: 'invalid') }
it { expect { subject }.to raise_error(Gitlab::Graphql::Errors::ArgumentError) }
end
it 'returns all tree entries during cursor pagination' do
cursor = nil
expected_entries = repository.tree.entries.map(&:path)
collected_entries = []
loop do
result = resolve_repository(args.merge(after: cursor), max_page_size: 10)
collected_entries += result.items.first.entries.map(&:path)
expect(result.start_cursor).to eq(cursor)
cursor = result.end_cursor
break if cursor.blank?
end
expect(collected_entries).to match_array(expected_entries)
end
end
end
def resolve_repository(args, opts = {})
field_options = described_class.field_options.merge(
owner: resolver_parent,
name: 'field_value'
).merge(opts)
field = ::Types::BaseField.new(**field_options)
resolve_field(field, repository, args: args, object_type: resolver_parent)
end
end