gestart-admino 1.0.0

data/spec/admino/query/sorting_presenter_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+require 'active_support/hash_with_indifferent_access'
+
+module Admino
+  module Query
+    describe SortingPresenter do
+      subject(:presenter) { SortingPresenter.new(sorting, view) }
+      let(:view) { RailsViewContext.new }
+      let(:sorting) do
+        double(
+          'Sorting',
+          default_scope: 'by_name',
+          query_i18n_key: 'query_name'
+        )
+      end
+      let(:request_object) do
+        double(
+          'ActionDispatch::Request',
+          query_parameters: ActiveSupport::HashWithIndifferentAccess.new(
+            'sorting' => 'by_date', 'other' => 'value'
+          ),
+          path: '/'
+        )
+      end
+
+      before do
+        allow(view).to receive(:request).and_return(request_object)
+      end
+
+      describe '#scope_link' do
+        subject { presenter.scope_link(:by_title, 'Titolo') }
+
+        before do
+          allow(sorting).to receive(:is_scope_active?).with(:by_title).and_return(false)
+        end
+
+        context 'scope is active' do
+          before do
+            allow(sorting).to receive(:is_scope_active?).with(:by_title).and_return(true)
+          end
+
+          context 'ascending' do
+            before do
+              allow(sorting).to receive(:ascending?).and_return(true)
+            end
+
+            it 'adds an is-asc class' do
+              is_expected.to have_tag(:a, with: { class: 'is-asc' })
+            end
+
+            context 'if an :asc_class option is specified' do
+              subject { presenter.scope_link(:by_title, 'Titolo', asc_class: 'asc') }
+
+              it 'adds it' do
+                is_expected.to have_tag(:a, with: { class: 'asc' })
+              end
+            end
+          end
+
+          context 'descendent' do
+            before do
+              allow(sorting).to receive(:ascending?).and_return(false)
+            end
+
+            it 'adds an is-desc class' do
+              is_expected.to have_tag(:a, with: { class: 'is-desc' })
+            end
+
+            context 'if a :desc_class option is specified' do
+              subject { presenter.scope_link(:by_title, 'Titolo', desc_class: 'desc') }
+
+              it 'adds it' do
+                is_expected.to have_tag(:a, with: { class: 'desc' })
+              end
+            end
+          end
+        end
+
+        context 'else' do
+          it 'does not add it' do
+            is_expected.not_to have_tag(:a, with: { class: 'is-asc' })
+          end
+        end
+
+        context 'label' do
+          it 'uses the provided argument' do
+            is_expected.to have_tag(:a, text: 'Titolo')
+          end
+        end
+
+        context 'URL' do
+          before do
+            allow(presenter).to receive(:scope_path).with(:by_title).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
+        subject { presenter.scope_params(:by_title) }
+
+        before do
+          allow(sorting).to receive(:is_scope_active?).with(:by_title).and_return(false)
+        end
+
+        it 'preserves other params' do
+          expect(subject[:other]).to eq 'value'
+        end
+
+        it 'keeps the request parameters intact' do
+          subject
+          expect(request_object.query_parameters[:sorting]).to eq 'by_date'
+        end
+
+        it 'sets the sorting param as the scope' do
+          expect(subject[:sorting]).to eq 'by_title'
+        end
+
+        context 'scope is active' do
+          before do
+            allow(sorting).to receive(:is_scope_active?).with(:by_title).and_return(true)
+          end
+
+          context 'is currently ascending' do
+            before do
+              allow(sorting).to receive(:ascending?).and_return(true)
+            end
+
+            it 'sets the sorting order to descending' do
+              expect(subject[:sort_order]).to eq 'desc'
+            end
+          end
+
+          context 'is currently descending' do
+            before do
+              allow(sorting).to receive(:ascending?).and_return(false)
+            end
+
+            it 'sets the sorting order to ascending' do
+              expect(subject[:sort_order]).to eq 'asc'
+            end
+          end
+        end
+
+        context 'scope is the default one' do
+          let(:sorting) { double('Sorting', default_scope: :by_title) }
+
+          context 'default scope is ascending' do
+            before do
+              allow(sorting).to receive(:default_direction).and_return(:asc)
+            end
+
+            it 'sets the sorting order to ascending' do
+              expect(subject[:sort_order]).to eq 'asc'
+            end
+          end
+
+          context 'default scope is descending' do
+            before do
+              allow(sorting).to receive(:default_direction).and_return(:desc)
+            end
+
+            it 'sets the sorting order to descending' do
+              expect(subject[:sort_order]).to eq 'desc'
+            end
+          end
+        end
+
+        context 'else' do
+          before do
+            allow(sorting).to receive(:is_scope_active?).with(:by_title).and_return(false)
+          end
+
+          it 'sets the sorting order to ascending' do
+            expect(subject[:sort_order]).to eq 'asc'
+          end
+        end
+      end
+
+      describe '#scope_name' do
+        context do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              query: { sorting_scopes: { query_name: { by_name: 'Sort by name' } } }
+            )
+          end
+
+          it 'returns a I18n translatable name for the scope' do
+            expect(presenter.scope_name(:by_name)).to eq 'Sort by 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(:by_name)).to eq 'By name'
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/query/sorting_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+module Admino
+  module Query
+    describe Sorting do
+      subject(:sorting) { Sorting.new(config, params) }
+      let(:config) do
+        Configuration::Sorting.new(sorting_scopes, options)
+      end
+      let(:sorting_scopes) { [:by_title, :by_date] }
+      let(:options) { {} }
+      let(:params) { {} }
+
+      describe '#active_scope' do
+        context 'with no param' do
+          let(:params) { {} }
+
+          it 'returns false' do
+            expect(sorting.active_scope).to be_nil
+          end
+
+          context 'if a default scope is configured' do
+            let(:options) { { default_scope: :by_date } }
+
+            it 'returns it' do
+              expect(sorting.active_scope).to eq :by_date
+            end
+          end
+        end
+
+        context 'with an invalid value' do
+          let(:params) { { 'sorting' => 'foo' } }
+
+          it 'returns false' do
+            expect(sorting.active_scope).to be_nil
+          end
+        end
+
+        context 'with a valid value' do
+          let(:params) { { 'sorting' => 'by_title' } }
+
+          it 'returns the scope name' do
+            expect(sorting.active_scope).to eq :by_title
+          end
+        end
+      end
+
+      describe '#ascending?' do
+        context 'with no param' do
+          let(:params) { {} }
+
+          it 'returns true' do
+            expect(sorting).to be_ascending
+          end
+        end
+
+        context 'with invalid value' do
+          let(:params) { { 'sort_order' => 'foo' } }
+
+          it 'returns true' do
+            expect(sorting).to be_ascending
+          end
+        end
+
+        context 'with "asc" value' do
+          let(:params) { { 'sort_order' => 'asc' } }
+
+          it 'returns nil' do
+            expect(sorting).to be_ascending
+          end
+        end
+
+        context 'with "desc" value' do
+          let(:params) { { 'sort_order' => 'desc' } }
+
+          it 'returns the param value for the search_field' do
+            expect(sorting).not_to be_ascending
+          end
+        end
+
+        context 'if a default scope and direction are set and default scope is current' do
+          let(:options) { { default_scope: :by_date, default_direction: :desc } }
+          let(:params) { { 'sorting' => 'by_date', 'sort_order' => 'desc' } }
+
+          it 'returns it' do
+            expect(sorting).not_to be_ascending
+          end
+        end
+      end
+
+      describe '#augment_scope' do
+        let(:result) { sorting.augment_scope(scope) }
+        let(:scope) { ScopeMock.new('original') }
+
+        context 'if the search_field has a value' do
+          let(:params) { { 'sorting' => 'by_title', 'sort_order' => 'desc' } }
+
+          it 'returns the original scope chained with the current scope' do
+            expect(result.chain).to eq [:by_title, [:desc]]
+          end
+        end
+
+        context 'else' do
+          it 'returns the original scope' do
+            expect(result).to eq scope
+          end
+        end
+
+        context 'if a default scope is configured' do
+          let(:options) { { default_scope: :by_date } }
+          let(:params) { {} }
+
+          it 'returns the original scope chained with the default scope' do
+            expect(result.chain).to eq [:by_date, [:asc]]
+          end
+
+          context 'if a default direction is configured' do
+            let(:options) { { default_scope: :by_date, default_direction: :desc } }
+
+            it 'returns the original scope chained with the default scope and default direction' do
+              expect(result.chain).to eq [:by_date, [:desc]]
+            end
+          end
+        end
+      end
+
+      describe '#is_scope_active?' do
+        let(:params) { { 'sorting' => 'by_date' } }
+
+        it 'returns true if the provided scope is the one currently active' do
+          expect(sorting.is_scope_active?(:by_date)).to be_truthy
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/table/head_row_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+module Admino
+  module Table
+    describe HeadRow do
+      subject(:row) { HeadRow.new(klass, query, view) }
+      let(:klass) { Post }
+      let(:query) { nil }
+      let(:view) { RailsViewContext.new }
+
+      it 'takes a class and a view context' do
+        expect(row.resource_klass).to eq klass
+        expect(row.view_context).to eq view
+      end
+
+      describe '#column' do
+        subject { row.to_html }
+
+        context 'text' do
+          context 'with string label' do
+            before do
+              row.column(:title, 'This is a title')
+            end
+
+            it 'generates a label with it' do
+              is_expected.to have_tag(:th, text: 'This is a title')
+            end
+          end
+
+          context 'with symbol label and I18n set up' do
+            before do
+              I18n.backend.store_translations(
+                :en,
+                activemodel: { attributes: { post: { foo: 'This is foo' } } }
+              )
+            end
+
+            before do
+              row.column(:title, :foo)
+            end
+
+            it 'generates a label with the human attribute name' do
+              is_expected.to have_tag(:th, text: 'This is foo')
+            end
+          end
+
+          context 'with no label' do
+            before { row.column(:title) }
+
+            it 'generates a label with the titleized attribute name' do
+              is_expected.to have_tag(:th, text: 'Title')
+            end
+
+            context 'with I18n set up' do
+              before do
+                I18n.backend.store_translations(
+                  :en,
+                  activemodel: { attributes: { post: { title: 'Post title' } } }
+                )
+              end
+
+              before { row.column(:title) }
+
+              it 'generates a label with the human attribute name' do
+                is_expected.to have_tag(:th, text: 'Post title')
+              end
+            end
+          end
+        end
+
+        context 'sorting' do
+          context 'if no query object is present' do
+            it 'raises an ArgumentError' do
+              expect { row.column(:title, sorting: :by_title) }.to raise_error ArgumentError
+            end
+          end
+
+          context 'else' do
+            let(:query) { double('Query', sorting: sorting) }
+            let(:sorting) { double('Sorting') }
+
+            before do
+              allow(sorting).to receive(:scope_link).with(:by_title, 'Title', {}).
+                and_return('Link')
+            end
+
+            before { row.column(:title, sorting: :by_title) }
+
+            it 'generates a sorting scope link' do
+              is_expected.to have_tag(:th, text: 'Link')
+            end
+          end
+        end
+
+        context 'role' do
+          before { row.column(:author_name) }
+
+          it 'generates a role attribute with the snake-cased name of the attribute' do
+            is_expected.to have_tag(:th, with: { role: 'author-name' })
+          end
+        end
+
+        context 'with html options param' do
+          before { row.column(:title, class: 'foo') }
+
+          it 'uses it to build attributes' do
+            is_expected.to have_tag(:th, with: { class: 'foo' })
+          end
+        end
+      end
+
+      describe '#actions' do
+        subject { row.to_html }
+
+        context do
+          before { row.actions }
+
+          it 'renders a th cell with role "actions"' do
+            is_expected.to have_tag(:th, with: { role: 'actions' })
+          end
+
+          it 'renders a th cell with text "Actions"' do
+            is_expected.to have_tag(:th, text: 'Actions')
+          end
+        end
+
+        context 'with generic I18n set up' do
+          before do
+            I18n.backend.store_translations(
+              :en,
+              table: { actions: { title: 'Available actions' } }
+            )
+          end
+
+          it 'renders a th cell with I18n text' do
+            row.actions
+            is_expected.to have_tag(:th, text: 'Available actions')
+          end
+
+          context 'and specific I18n set up' do
+            before do
+              I18n.backend.store_translations(
+                :en,
+                table: { actions: { post: { title: 'Post actions' } } }
+              )
+            end
+
+            it 'uses the specific I18n text' do
+              row.actions
+              is_expected.to have_tag(:th, text: 'Post actions')
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/admino/table/presenter_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Admino
+  module Table
+    describe Presenter do
+      subject(:presenter) { presenter_klass.new(collection, Post, query, view) }
+      let(:presenter_klass) { Presenter }
+      let(:query) { double('Query') }
+      let(:view) { RailsViewContext.new }
+
+      let(:collection) { [ first_post, second_post ] }
+      let(:first_post) { Post.new('1') }
+      let(:second_post) { Post.new('2') }
+
+      let(:head_row) { double('HeadRow', to_html: '<td id="thead_td"></td>'.html_safe) }
+      let(:resource_row) { double('ResourceRow', to_html: '<td id="tbody_td"></td>'.html_safe) }
+
+      before do
+        allow(HeadRow).to receive(:new).with(Post, query, view).and_return(head_row)
+        allow(ResourceRow).to receive(:new).with(first_post, view).and_return(resource_row)
+        allow(ResourceRow).to receive(:new).with(second_post, view).and_return(resource_row)
+      end
+
+      describe '#to_html' do
+        let(:result) { presenter.to_html }
+
+        it 'outputs a table' do
+          expect(result).to have_tag(:table)
+        end
+
+        it 'outputs a thead with a single row' do
+          expect(result).to have_tag('table thead tr')
+        end
+
+        it 'outputs a tbody with a row for each collection member' do
+          expect(result).to have_tag('table tbody tr', count: 2)
+        end
+
+        context 'if the record responds to #dom_id' do
+          before do
+            allow(first_post).to receive(:dom_id).and_return('post_1')
+            allow(second_post).to receive(:dom_id).and_return('post_2')
+          end
+
+          it 'adds a record identifier to each collection row' do
+            expect(result).to have_tag('tbody tr#post_1:first-child')
+            expect(result).to have_tag('tbody tr#post_2:last-child')
+          end
+        end
+
+        it 'adds zebra classes to each collection row' do
+          expect(result).to have_tag('tbody tr.is-even:first-child')
+          expect(result).to have_tag('tbody tr.is-odd:last-child')
+        end
+
+        it 'delegates thead columns creation to .to_html HeadRow' do
+          expect(result).to have_tag('thead tr td#thead_td')
+        end
+
+        it 'delegates tbody columns creation to .to_html ResourceRow' do
+          expect(result).to have_tag('tbody tr td#tbody_td')
+        end
+
+        it 'allows passing table HTML options' do
+          expect(presenter.to_html(id: 'table')).to have_tag(:table, with: { id: 'table' })
+        end
+
+        context 'with a block' do
+          let(:block_call_args) do
+            block_call_args = []
+            presenter.to_html do |*args|
+              block_call_args << args
+            end
+            block_call_args
+          end
+
+          it 'calls it once passing the HeadRow instance' do
+            expect(block_call_args[0]).to eq [head_row, nil]
+          end
+
+          it 'calls it once for each collection member passing the ResourceRow instance and the member itself' do
+            expect(block_call_args[1]).to eq [resource_row, first_post]
+            expect(block_call_args[2]).to eq [resource_row, second_post]
+          end
+        end
+
+        context 'custom table HTML options' do
+          let(:presenter_klass) do
+            Class.new(Presenter) do
+              private
+
+              def table_html_options
+                { id: 'table' }
+              end
+
+              def thead_html_options
+                { id: 'thead' }
+              end
+
+              def thead_tr_html_options
+                { id: 'thead_tr' }
+              end
+
+              def tbody_html_options
+                { id: 'tbody' }
+              end
+
+              def tbody_tr_html_options(resource, index)
+                { class: "index-#{index}" }
+              end
+
+              def zebra_css_classes
+                %w(one two)
+              end
+            end
+          end
+
+          it "allows customizing the default table html attributes" do
+            expect(presenter.to_html).to have_tag(:table, with: { id: 'table' })
+          end
+
+          it "allows customizing the the default thead html attributes" do
+            expect(presenter.to_html).to have_tag(:thead, with: { id: 'thead' })
+          end
+
+          it "allows customizing the the default thead_tr html attributes" do
+            expect(presenter.to_html).to have_tag('thead tr#thead_tr')
+          end
+
+          it "allows customizing the the default tbody html attributes" do
+            expect(presenter.to_html).to have_tag(:tbody, with: { id: 'tbody' })
+          end
+
+          it "allows customizing the tbody_tr html attributes" do
+            expect(presenter.to_html).to have_tag("tbody tr.index-0:first-child")
+          end
+
+          it 'allows customizing zebra classes' do
+            expect(presenter.to_html).to have_tag("tbody tr.one:first-child")
+          end
+        end
+
+        context 'custom row builders' do
+          let(:presenter_klass) do
+            Class.new(Presenter) do
+              private
+
+              def head_row(*args)
+                OpenStruct.new(to_html: '<td id="custom_thead_td"></td>'.html_safe)
+              end
+
+              def resource_row(*args)
+                OpenStruct.new(to_html: '<td id="custom_tbody_td"></td>'.html_safe)
+              end
+            end
+          end
+
+          it 'allows customizing head row renderers' do
+            expect(presenter.to_html).to have_tag('thead tr td#custom_thead_td')
+          end
+
+          it 'allows customizing resource row renderers' do
+            expect(presenter.to_html).to have_tag('tbody tr td#custom_tbody_td')
+          end
+        end
+
+        context 'with empty collection and no collection_klass' do
+          let(:collection) { [] }
+          subject(:presenter) { presenter_klass.new(collection, nil, query, view) }
+
+          it 'raises an Exception' do
+            expect { result }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end
+