gestart-admino 1.0.0

data/spec/admino/query/base_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Base do
+      subject(:query) { Base.new(params, context, config) }
+      let(:params) { {} }
+      let(:context) { {} }
+      let(:config) { nil }
+
+      it 'takes a request params' do
+        expect(query.params).to eq params
+      end
+
+      context 'with an explicit config' do
+        let(:config) { Configuration.new }
+
+        it 'uses it' do
+          expect(query.config).to eq config
+        end
+      end
+
+      context 'with a declared search_field' do
+        let(:config) { Configuration.new }
+        let(:search_field_config) { config.add_search_field(:search_field) }
+
+        before do
+          search_field_config
+        end
+
+        it 'returns a configured SearchField' do
+          search_field = query.search_field_by_name(:search_field)
+          expect(search_field.config).to eq search_field_config
+          expect(search_field.params).to eq params
+        end
+      end
+
+      context 'with a declared filter_group' do
+        let(:config) { Configuration.new }
+        let(:filter_group_config) { config.add_filter_group(:filter_group, [:one, :two]) }
+
+        before do
+          filter_group_config
+        end
+
+        it 'returns a configured FilterGroup' do
+          filter_group = query.filter_group_by_name(:filter_group)
+          expect(filter_group.config).to eq filter_group_config
+          expect(filter_group.params).to eq params
+          expect(filter_group.i18n_key).to eq :filter_group
+        end
+      end
+
+      context 'with a declared sorting' do
+        let(:config) { Configuration.new }
+        let(:sorting_config) do
+          config.add_sorting_scopes([:by_title, :by_date])
+        end
+
+        before do
+          sorting_config
+        end
+
+        it 'returns a configured Sorting' do
+          sorting = query.sorting
+          expect(sorting.config).to eq sorting_config
+          expect(sorting.params).to eq params
+        end
+      end
+
+      describe '#scope' do
+        let(:config) { Configuration.new }
+        let(:result) { query.scope(starting_scope) }
+        let(:starting_scope) { ScopeMock.new('explicit') }
+
+        describe 'starting scope' do
+          context 'with an explicit scope' do
+            it 'uses it' do
+              expect(result.name).to eq 'explicit'
+            end
+          end
+
+          context 'with no explicit scope, but a default one configured' do
+            let(:result) { query.scope }
+
+            before do
+              config.starting_scope_callable = Proc.new { |query|
+                ScopeMock.new('configured').foo(query)
+              }
+            end
+
+            before do
+              result
+            end
+
+            it 'calls it with self and uses it' do
+              expect(result.name).to eq 'configured'
+              expect(result.chain).to eq [:foo, [query]]
+            end
+          end
+
+          context 'with no scope' do
+            let(:result) { query.scope }
+
+            it 'raises a ArgumentError' do
+              expect { result }.to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        context 'with a set of search_fields, filter_groups and sortings' do
+          let(:search_field_config) { config.add_search_field(:search_field) }
+          let(:filter_group_config) { config.add_filter_group(:filter_group, [:one, :two]) }
+          let(:sorting_config) { config.add_sorting_scopes([:title, :year]) }
+
+          let(:params) do
+            {
+              query: {
+                search_field: "foo",
+                filter_group: "one",
+              },
+              sorting: "title",
+              sort_order: "desc"
+            }
+          end
+
+          before do
+            search_field_config
+            filter_group_config
+            sorting_config
+            query
+          end
+
+          context 'if query object does not respond to scopes' do
+            it 'chains from starting scope' do
+              expect(result.chain).to eq [
+                :search_field, ["foo"],
+                :one, [],
+                :title, [:desc]
+              ]
+            end
+          end
+
+          context 'else' do
+            let(:query_klass) do
+              Class.new(Base) do
+                def self.model_name
+                  ActiveModel::Name.new(self, nil, "temp")
+                end
+
+                def search_field_scope(scope, foo)
+                  scope.my_search_field(foo)
+                end
+
+                def one_scope(scope)
+                  scope.my_one
+                end
+
+                def title_scope(scope, order)
+                  scope.my_title(order)
+                end
+              end
+            end
+
+            subject(:query) do
+              query_klass.new(params, context, config)
+            end
+
+            it 'chains from starting scope calling query object methods' do
+              expect(result.chain).to eq [
+                :my_search_field, ["foo"],
+                :my_one, [],
+                :my_title, [:desc]
+              ]
+            end
+          end
+        end
+
+        context 'with a configured ending scope' do
+          before do
+            config.ending_scope_callable = Proc.new { |query| bar(query) }
+          end
+
+          it 'calls it with self at the end of the chain' do
+            expect(result.chain).to eq [:bar, [query]]
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/dsl_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Dsl do
+      let(:config) { TestQuery.config }
+      let(:instance) { TestQuery.new }
+
+      it 'allows #search_field declaration' do
+        search_field = config.search_fields.last
+        expect(search_field.name).to eq :starting_from
+      end
+
+      it 'allows #filter_by declaration' do
+        filter_group = config.filter_groups.first
+        expect(filter_group.name).to eq :bar
+        expect(filter_group.scopes).to eq [:one, :two]
+        expect(filter_group.include_empty_scope?).to be_truthy
+      end
+
+      it 'allows #sortings declaration' do
+        sorting = config.sorting
+        expect(sorting.scopes).to eq [:by_title, :by_date]
+        expect(sorting.default_scope).to eq :by_title
+        expect(sorting.default_direction).to eq :desc
+      end
+
+      it 'allows #starting_scope block declaration' do
+        expect(config.starting_scope_callable.call).to eq 'start'
+      end
+
+      it 'allows #ending_scope block declaration' do
+        expect(config.ending_scope_callable.call).to eq 'end'
+      end
+
+      context 'with a search_field' do
+        let(:search_field) { double('SearchField', value: 'value') }
+
+        before do
+          allow(instance).to receive(:search_field_by_name).
+            with(:foo).
+            and_return(search_field)
+        end
+
+        it 'it generates a getter' do
+          expect(instance.foo).to eq 'value'
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/filter_group_presenter_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'active_support/hash_with_indifferent_access'
+
+module Admino
+  module Query
+    describe FilterGroupPresenter do
+      subject(:presenter) { FilterGroupPresenter.new(filter_group, view) }
+      let(:view) { RailsViewContext.new }
+      let(:filter_group) do
+        double(
+          'FilterGroup',
+          query_i18n_key: :query_name,
+          i18n_key: :filter_group,
+          param_name: :filter_group
+        )
+      end
+      let(:request_object) do
+        double(
+          'ActionDispatch::Request',
+          query_parameters: ActiveSupport::HashWithIndifferentAccess.new(
+            params
+          ),
+          path: '/'
+        )
+      end
+      let(:params) do
+        { 'query' => { 'field' => 'value', 'filter_group' => 'bar' } }
+      end
+
+      before do
+        allow(view).to receive(:request).and_return(request_object)
+      end
+
+      describe '#scope_link' do
+        subject { presenter.scope_link(:foo) }
+        let(:scope_active) { false }
+
+        before do
+          allow(filter_group).to receive(:is_scope_active?).
+            with(:foo).and_return(scope_active)
+        end
+
+        context 'active CSS class' do
+          let(:scope_active) { true }
+
+          it 'adds an is-active class' do
+            is_expected.to have_tag(:a, with: { class: 'is-active' })
+          end
+
+          context 'if an :active_class option is specified' do
+            subject { presenter.scope_link(:foo, active_class: 'active') }
+
+            it 'adds it' do
+              is_expected.to have_tag(:a, with: { class: 'active' })
+            end
+          end
+        end
+
+        context 'else' do
+          it 'does not add it' do
+            is_expected.not_to have_tag(:a, with: { class: 'is-active' })
+          end
+        end
+
+        context 'label' do
+          before do
+            allow(presenter).to receive(:scope_name).with(:foo).and_return('scope_name')
+          end
+
+          it 'uses #scope_name method' do
+            is_expected.to have_tag(:a, text: 'scope_name')
+          end
+
+          context 'if a second parameter is supplied' do
+            subject { presenter.scope_link(:foo, 'test', active_class: 'active') }
+
+            it 'uses it' do
+              is_expected.to have_tag(:a, text: 'test')
+            end
+          end
+        end
+
+        context 'URL' do
+          before do
+            allow(presenter).to receive(:scope_path).with(:foo).and_return('URL')
+          end
+
+          it 'uses #scope_path method' do
+            is_expected.to have_tag(:a, href: 'URL')
+          end
+        end
+      end
+
+      describe '#scope_params' do
+        let(:scope_active) { false }
+        subject { presenter.scope_params(:foo) }
+
+        before do
+          allow(filter_group).to receive(:is_scope_active?).with(:foo).and_return(scope_active)
+        end
+
+        context 'if scope is active' do
+          let(:scope_active) { true }
+
+          it 'deletes the filter_group param' do
+            expect(subject[:query]).not_to have_key 'filter_group'
+          end
+
+          it 'keeps the request parameters intact' do
+            presenter.scope_params(:foo)
+            expect(request_object.query_parameters[:query][:filter_group]).to be_present
+          end
+
+          context 'the resulting query hash becomes empty' do
+            let(:params) do
+              { 'query' => { 'filter_group' => 'bar' } }
+            end
+
+            it 'removes the param altoghether' do
+              expect(subject).not_to have_key 'query'
+            end
+          end
+        end
+
+        context 'else' do
+          let(:scope_active) { false }
+
+          it 'is set as filter group value' do
+            expect(subject[:query][:filter_group]).to eq 'foo'
+          end
+        end
+
+        it 'preserves the other params' do
+          expect(subject[:query][:field]).to eq 'value'
+        end
+      end
+
+      describe '#name' do
+        context do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              query: { filter_groups: { query_name: { filter_group: { name: 'NAME' } } } }
+            )
+          end
+
+          it 'returns a I18n translatable name for the filter_group' do
+            expect(presenter.name).to eq 'NAME'
+          end
+        end
+
+        context 'if no translation is available' do
+          it 'falls back to a titleized version of the filter_group name' do
+            expect(presenter.name).to eq 'Filter group'
+          end
+        end
+      end
+
+      describe '#scope_name' do
+        context do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              query: { filter_groups: { query_name: { filter_group: { scopes: { bar: 'NAME' } } } } }
+            )
+          end
+
+          it 'returns a I18n translatable name for the scope' do
+            expect(presenter.scope_name(:bar)).to eq 'NAME'
+          end
+        end
+
+        context 'if no translation is available' do
+          it 'falls back to a titleized version of the scope name' do
+            expect(presenter.scope_name(:bar)).to eq 'Bar'
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/filter_group_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe FilterGroup do
+      subject(:filter_group) { FilterGroup.new(config, params) }
+      let(:config) do
+        Configuration::FilterGroup.new(:foo, [:bar, :other], options)
+      end
+      let(:options) { {} }
+      let(:params) { {} }
+
+      describe '#active_scope' do
+        context 'with no param' do
+          let(:params) { {} }
+
+          it 'returns nil' do
+            expect(filter_group.active_scope).to be_nil
+          end
+
+          context 'if include_empty_scope is true' do
+            let(:options) { { include_empty_scope: true } }
+
+            it 'returns the :empty scope' do
+              expect(filter_group.active_scope).to eq :empty
+            end
+
+            context 'if default scope is set' do
+              let(:config) do
+                Configuration::FilterGroup.new(
+                  :foo,
+                  [:bar],
+                  include_empty_scope: true,
+                  default: :bar
+                )
+              end
+
+              it 'returns it' do
+                expect(filter_group.active_scope).to eq :bar
+              end
+            end
+          end
+        end
+
+        context 'with "empty" param' do
+          let(:params) { { 'query' => { 'foo' => 'empty' } } }
+
+          context 'if include_empty_scope is true' do
+            let(:options) { { include_empty_scope: true, default: :bar } }
+
+            it 'returns the :empty scope' do
+              expect(filter_group.active_scope).to eq :empty
+            end
+          end
+        end
+
+        context 'with an invalid value' do
+          let(:params) { { 'query' => { 'foo' => 'qux' } } }
+
+          it 'returns nil' do
+            expect(filter_group.active_scope).to be_nil
+          end
+
+          context 'if include_empty_scope is true' do
+            let(:options) { { include_empty_scope: true, default: :bar } }
+
+            it 'returns nil' do
+              expect(filter_group.active_scope).to be_nil
+            end
+          end
+        end
+
+        context 'with a valid value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the scope name' do
+            expect(filter_group.active_scope).to eq :bar
+          end
+        end
+      end
+
+      describe '#augment_scope' do
+        let(:result) { filter_group.augment_scope(scope) }
+        let(:scope) { ScopeMock.new('original') }
+
+        context 'if the search_field has a value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the original scope chained with the filter_group scope' do
+            expect(result.chain).to eq [:bar, []]
+          end
+        end
+
+        context 'else' do
+          it 'returns the original scope' do
+            expect(result).to eq scope
+          end
+
+          context 'if include_empty_scope is true' do
+            let(:options) { { include_empty_scope: true } }
+
+            it 'returns the original scope' do
+              expect(result).to eq scope
+            end
+          end
+        end
+      end
+
+      describe '#is_scope_active?' do
+        let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+        it 'returns true if the provided scope is the one currently active' do
+          expect(filter_group.is_scope_active?('bar')).to be_truthy
+        end
+      end
+
+      describe '#scopes' do
+        subject { filter_group.scopes }
+
+        context 'if include_empty_scope is true' do
+          let(:options) { { include_empty_scope: true } }
+
+          it { is_expected.to eq [:empty, :bar, :other] }
+        end
+
+        context 'else' do
+          it { is_expected.to eq [:bar, :other] }
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/search_field_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe SearchField do
+      subject(:search_field) { SearchField.new(config, params) }
+      let(:config) { Configuration::SearchField.new(:foo) }
+      let(:params) { {} }
+
+      describe '#value' do
+        context 'with a value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the param value for the search_field' do
+            expect(search_field.value).to eq 'bar'
+          end
+        end
+
+        context 'else' do
+          it 'returns nil' do
+            expect(search_field.value).to be_nil
+          end
+
+          context 'with a default value' do
+            let(:config) {
+              Configuration::SearchField.new(:foo, default: 'foo')
+            }
+
+            it 'returns it' do
+              expect(search_field.value).to eq 'foo'
+            end
+          end
+        end
+
+        context 'with a date-shaped value' do
+          let(:params) { { 'query' => { 'foo' => '2014-10-05' } } }
+
+          it 'returns it untouched, as a String' do
+            expect(search_field.value).to eq '2014-10-05'
+            expect(search_field.value).to be_a String
+          end
+        end
+      end
+
+      describe '#augment_scope' do
+        let(:result) { search_field.augment_scope(scope) }
+        let(:scope) { ScopeMock.new('original') }
+
+        context 'if the search_field has a value' do
+          let(:params) { { 'query' => { 'foo' => 'bar' } } }
+
+          it 'returns the original scope chained with the search_field scope' do
+            expect(result.chain).to eq [:foo, ['bar']]
+          end
+        end
+
+        context 'else' do
+          it 'returns the original scope' do
+            expect(result).to eq scope
+          end
+        end
+      end
+    end
+  end
+end
+