tenon 1.1.8 → 2.0.0

data/spec/controllers/tenon/pages_controller_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::PagesController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-  let(:page) { double.as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-  end
-
-  describe 'GET index.html' do
-    it 'should render the index template' do
-      get :index, format: 'html'
-      expect(response).to render_template('index')
-    end
-  end
-
-  describe 'GET index.json' do
-    context 'without params[q:]' do
-      it 'should get the pages and order them by lft' do
-        expect(Tenon::Page).to receive(:order).with(:lft) { double.as_null_object }
-        get :index, format: 'json'
-      end
-    end
-
-    context 'with params[q:]' do
-      it 'should search the pages and then order them by lft' do
-        args = ['tenon_pages.title ILIKE ?', '%search%']
-        expect(Tenon::Page).to receive(:where).with(args) { Tenon::Page }
-        expect(Tenon::Page).to receive(:map) { Tenon::Page }
-        expect(Tenon::Page).to receive(:flatten) { Tenon::Page }
-        expect(Tenon::Page).to receive(:uniq) { Tenon::Page }
-        expect(Tenon::Page).to receive(:sort_by) { Tenon::Page }
-        get :index, format: 'json', q: 'search'
-      end
-    end
-  end
-
-  describe 'GET new' do
-    it 'should set the parent_id to params[:parent_id]' do
-      Tenon::Page.stub(:new) { page }
-      get :new, parent_id: 1
-      expect(assigns[:page]).to have_received(:parent_id=).with('1')
-    end
-  end
-
-  describe 'POST reorder' do
-    it 'should reorder the pages' do
-      expect(Tenon::Page).to receive(:reorder!).with(%w(1 2 3), '1')
-      post :reorder, item_list: [1, 2, 3], parent_id: 1
-    end
-
-    it "shouldn't render anything" do
-      Tenon::Page.stub(:reorder!)
-      post :reorder, item_list: [1, 2, 3], parent_id: 1
-      expect(response.body).to eq('')
-    end
-  end
-end

data/spec/controllers/tenon/posts_controller_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::PostsController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-  let(:post) { double.as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { posts_path }
-    controller.stub(:after_update_path) { posts_path }
-  end
-
-  describe 'PATCH update' do
-    before do
-      Tenon::Post.stub(:find) { double.as_null_object }
-    end
-
-    it "should instantiate the post_category_ids collection if it's empty" do
-      patch :update, id: 1, post: { blah: 'blah' }
-      expect(controller.params[:post][:post_category_ids]).to eq([])
-    end
-  end
-end

data/spec/controllers/tenon/resources_controller_spec.rb

@@ -1,352 +0,0 @@
-# We test the GalleriesController as it inherits completely from
-# resources controller.  Other controllers should only test
-# methods that they override.
-
-require 'spec_helper'
-
-describe Tenon::GalleriesController do
-  routes { Tenon::Engine.routes }
-
-  let(:gallery) { mock_model(Tenon::Gallery).as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { '/tenon/galleries' }
-  end
-
-  context 'with an administrator' do
-    let(:user) do
-      double(
-        :staff? => true,
-        :is_super_admin? => false,
-        :is_admin? => true
-      )
-    end
-
-    describe 'GET index.html' do
-      it 'should respond with success' do
-        get :index, format: 'html'
-        expect(response).to be_success
-      end
-
-      it 'should render the template' do
-        get :index, format: 'html'
-        expect(response).to render_template('index')
-      end
-
-      it 'should set params[:page] to 1' do
-        get :index, format: 'html'
-        expect(controller.params[:page]).to eq(1)
-      end
-
-      it 'should not override a valid page parameter' do
-        get :index, format: 'html', page: '5'
-        expect(controller.params[:page]).to eq('5')
-      end
-    end
-
-    describe 'GET index.json' do
-      before do
-        [:all, :where, :paginate].each do |query|
-          Tenon::Gallery.stub(query) { Tenon::Gallery }
-        end
-      end
-
-      it 'should respond with success' do
-        get :index, format: 'json'
-        expect(response).to be_success
-      end
-
-      it 'should render the template' do
-        get :index, format: 'json'
-        expect(response).to render_template('index')
-      end
-
-      it 'should attempt to get all the resources' do
-        expect(Tenon::Gallery).to receive(:all) { Tenon::Gallery }
-        get :index, format: 'json'
-      end
-
-      it 'should paginate the resources' do
-        expect(Tenon::Gallery).to receive(:paginate).and_return(Tenon::Gallery)
-        get :index, format: 'json'
-      end
-
-      it 'should decorate the resources' do
-        expect(Tenon::PaginatingDecorator).to receive(:decorate).with(Tenon::Gallery)
-        get :index, format: 'json'
-      end
-
-      it 'should search the resources when params[:q] is supplied' do
-        search_args = ['tenon_galleries.title ILIKE ?', '%test%']
-        expect(Tenon::Gallery).to receive(:where).with(search_args)
-        get :index, format: 'json', q: 'test'
-      end
-    end
-
-    describe 'GET new' do
-      it 'should respond with success' do
-        get :new
-        expect(response).to be_success
-      end
-
-      it 'should render the template' do
-        get :new
-        expect(response).to render_template('new')
-      end
-
-      it 'should instantiate a resource' do
-        expect(Tenon::Gallery).to receive(:new) { gallery }
-        get :new
-      end
-    end
-
-    describe 'GET edit' do
-      before do
-        Tenon::Gallery.stub(:find) { gallery }
-      end
-
-      it 'should respond with success' do
-        get :edit, id: 1
-        expect(response).to be_success
-      end
-
-      it 'should render the template' do
-        get :edit, id: 1
-        expect(response).to render_template('edit')
-      end
-
-      it 'should find a resource' do
-        expect(Tenon::Gallery).to receive(:find).with('1')
-        get :edit, id: 1
-      end
-    end
-
-    describe 'POST create' do
-      before do
-        Tenon::Gallery.stub(:new) { gallery }
-      end
-
-      let(:params) { { 'test' => 'test' } }
-
-      it 'should instantiate a resource' do
-        expect(Tenon::Gallery).to receive(:new).with(params) { gallery }
-        post :create, gallery: params
-      end
-
-      it 'should attempt to save it' do
-        expect(gallery).to receive(:save)
-        post :create, gallery: params
-      end
-
-      context 'with an unsuccessful save' do
-        before do
-          gallery.stub(:errors) { { anything: 'will do' } }
-        end
-
-        it 'should respond with success' do
-          post :create, gallery: params
-          expect(response).to be_success
-        end
-
-        it 'should render the new template' do
-          post :create, format: 'html', gallery: params
-          expect(response).to render_template('new')
-        end
-      end
-
-      context 'with a successful save' do
-        it 'should redirect to index' do
-          post :create, gallery: params
-          expect(response).to redirect_to("/tenon/galleries/#{assigns[:gallery].id}/edit")
-        end
-      end
-    end
-
-    describe 'PATCH update' do
-      before do
-        Tenon::Gallery.stub(:find) { gallery }
-      end
-
-      let(:params) { { 'test' => 'test' } }
-
-      it 'should find a resource' do
-        expect(Tenon::Gallery).to receive(:find).with('1') { gallery }
-        patch :update, gallery: params, id: 1
-      end
-
-      it 'should attempt to update it' do
-        expect(gallery).to receive(:update_attributes).with(params)
-        patch :update, gallery: params, id: 1
-      end
-
-      context 'with an unsuccessful save' do
-        before do
-          gallery.stub(:errors) { { anything: 'will do' } }
-          gallery.stub(:update_attributes) { false }
-        end
-
-        it 'should respond with success' do
-          patch :update, gallery: params, id: 1
-          expect(response).to be_success
-        end
-
-        it 'should render the edit template' do
-          patch :update, gallery: params, id: 1
-          expect(response).to render_template('edit')
-        end
-
-        it 'should not set the flash' do
-          patch :update, gallery: params, id: 1
-          expect(controller.flash[:notice]).to be_blank
-        end
-      end
-
-      context 'with a successful save' do
-        it 'should redirect to index' do
-          patch :update, gallery: params, id: 1
-          expect(response).to redirect_to("/tenon/galleries/#{assigns[:gallery].id}/edit")
-        end
-
-        it 'should set the flash' do
-          patch :update, gallery: params, id: 1
-          expect(controller.flash[:notice]).not_to be_blank
-        end
-      end
-    end
-
-    describe 'DELETE destroy' do
-      let(:gallery) { double.as_null_object }
-
-      before do
-        Tenon::Gallery.stub(:find) { gallery }
-      end
-
-      it 'should find the resource' do
-        expect(Tenon::Gallery).to receive(:find).with('1') { gallery }
-        delete :destroy, id: 1
-      end
-
-      it 'should try to destroy the resource' do
-        expect(gallery).to receive(:destroy)
-        delete :destroy, id: 1
-      end
-
-      context 'on successful destruction' do
-        before do
-          gallery.stub(:destroy) { true }
-        end
-
-        it 'should redirect to index' do
-          delete :destroy, id: 1
-          expect(response).to redirect_to('/tenon/galleries')
-        end
-      end
-
-      context 'on failure' do
-        let(:errors) { { anything: 'will do' } }
-        before do
-          gallery.stub(:destroy) { false }
-          gallery.stub(:errors) { errors }
-        end
-
-        it 'should render errors' do
-          delete :destroy, id: 1, format: 'json'
-          expect(response.body).to eq({ 'errors' => errors }.to_json)
-        end
-      end
-    end
-  end
-
-  context 'when not an administrator' do
-    let(:user) { double(:staff? => false) }
-
-    describe 'GET index' do
-      it 'should redirect' do
-        get :index
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'GET new' do
-      it 'should redirect' do
-        get :new
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'GET edit' do
-      it 'should redirect' do
-        get :edit, id: 1
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'POST create' do
-      it 'should redirect' do
-        post :create, gallery: {}
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'PATCH update' do
-      it 'should redirect' do
-        patch :update, id: 1
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'DELETE destroy' do
-      it 'should redirect' do
-        delete :destroy, id: 1
-        expect(response).to be_redirect
-      end
-    end
-  end
-
-  context 'when not logged in at all' do
-    let(:user) { nil }
-
-    describe 'GET index' do
-      it 'should redirect' do
-        get :index
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'GET new' do
-      it 'should redirect' do
-        get :new
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'GET edit' do
-      it 'should redirect' do
-        get :edit, id: 1
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'POST create' do
-      it 'should redirect' do
-        post :create, gallery: {}
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'PATCH update' do
-      it 'should redirect' do
-        patch :update, id: 1
-        expect(response).to be_redirect
-      end
-    end
-
-    describe 'DELETE destroy' do
-      it 'should redirect' do
-        delete :destroy, id: 1
-        expect(response).to be_redirect
-      end
-    end
-  end
-end

data/spec/controllers/tenon/settings_controller_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::SettingsController do
-  routes { Tenon::Engine.routes }
-
-  let(:settings) { double.as_null_object }
-  before do
-    controller.stub(:current_user) { user }
-    stub_const('Tenon::MySettings', settings)
-  end
-
-  context 'as not an admin' do
-    let(:user) do
-      double(
-        :staff? => false,
-        :is_super_admin? => false,
-        :is_admin? => false
-      )
-    end
-
-    describe 'PATCH update' do
-      it 'should redirect to /login' do
-        patch :update
-        expect(response).to redirect_to(new_user_session_path)
-      end
-    end
-
-    describe 'GET show' do
-      it 'should redirect to /login' do
-        get :show
-        expect(response).to redirect_to(new_user_session_path)
-      end
-    end
-  end
-
-  context 'as an admin' do
-    let(:user) do
-      double(
-        :staff? => true,
-        :is_super_admin? => false,
-        :is_admin? => true
-      )
-    end
-
-    describe 'PATCH update' do
-      it 'should assign a setting for each param setting submitted' do
-        expect(Tenon::MySettings).to receive(:one=).with('one')
-        expect(Tenon::MySettings).to receive(:two=).with('two')
-        patch :update, settings: { one: 'one', two: 'two' }
-      end
-
-      it 'should set the flash' do
-        patch :update, settings: { one: 'one', two: 'two' }
-        expect(controller.flash[:notice]).not_to be_blank
-      end
-    end
-
-    describe 'GET show' do
-      it 'should assign settings to Tenon::MySettings' do
-        get :show
-        expect(assigns[:settings]).to eq(Tenon::MySettings)
-      end
-    end
-  end
-end

data/spec/controllers/tenon/simple_resources_controller_spec.rb

@@ -1,42 +0,0 @@
-# We test the PostCategoriesController as it inherits completely from
-# resources controller.  Other controllers should only test
-# methods that they override.  SimpleResourcesController inherits
-# from Tenon::ResourcesController, there are only two actions to
-# test here.
-
-require 'spec_helper'
-
-describe Tenon::PostCategoriesController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-
-  before do
-    controller.stub(:current_user) { user }
-    controller.stub(:polymorphic_index_path) { '/tenon/banners' }
-  end
-
-  describe 'GET index' do
-    it 'should instantiate a new resource' do
-      expect(Tenon::PostCategory).to receive(:new)
-      get :index
-    end
-  end
-
-  describe 'GET edit' do
-    before do
-      Tenon::PostCategory.stub(:find) { double.as_null_object }
-    end
-
-    it 'should render the form partial' do
-      get :edit, id: 1
-      expect(response).to render_template(partial: 'tenon/post_categories/_form')
-    end
-  end
-end

data/spec/controllers/tenon/users_controller_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe Tenon::UsersController do
-  routes { Tenon::Engine.routes }
-
-  let(:user) do
-    double(
-      :staff? => true,
-      :is_super_admin? => false,
-      :is_admin? => true
-    )
-  end
-  let(:user_dbl) { double.as_null_object }
-
-  before do
-    controller.stub(:current_user) { user }
-  end
-
-  describe 'GET index.html' do
-    it 'should be success' do
-      get :index
-      expect(response).to be_success
-    end
-
-    it 'should render the index template' do
-      get :index
-      expect(response).to render_template(:index)
-    end
-  end
-
-  describe 'GET index.json' do
-    before do
-      [:all, :exclude_super_admins, :where, :paginate].each do |query|
-        Tenon::User.stub(query) { Tenon::User }
-      end
-    end
-
-    context 'when current_user is_super_admin?' do
-      before do
-        user.stub(:is_super_admin?) { true }
-      end
-
-      it 'should get all the users' do
-        expect(Tenon::User).to receive(:all)
-        get :index, format: 'json'
-      end
-    end
-
-    context 'when current_user is_admin?' do
-      # Proper settings from let statement at top
-
-      it 'should get everyone but the super admins' do
-        expect(Tenon::User).to receive(:exclude_super_admins)
-        get :index, format: 'json'
-      end
-    end
-
-    context 'when params[:q] is passed' do
-      it 'should search the users' do
-        search_args = ['email ILIKE ?', '%search%']
-        expect(Tenon::User).to receive(:where).with(search_args)
-        get :index, format: 'json', q: 'search'
-      end
-    end
-
-    it 'should paginate the users' do
-      expect(Tenon::User).to receive(:paginate)
-      get :index, format: 'json'
-    end
-  end
-
-  describe 'POST create' do
-    context 'when the user is an admin' do
-      it 'should not allow the user to assign a super_admin role' do
-        super_admin_role = Tenon::Role.create(title: 'Super Admin')
-        post :create, user: { role_ids: [super_admin_role.id] }
-        expect(assigns[:user].role_ids).not_to include(super_admin_role.id)
-      end
-    end
-
-    context 'when the user is a super_admin' do
-      before { user.stub(:is_super_admin?) { true } }
-      it 'should allow the user to assign a super_admin role' do
-        super_admin_role = Tenon::Role.create(title: 'Super Admin')
-        post :create, user: { role_ids: [super_admin_role.id] }
-        expect(assigns[:user].role_ids).to include(super_admin_role.id)
-      end
-    end
-  end
-
-  describe 'PUT update' do
-    let(:edited_user) { Tenon::User.new }
-    before { Tenon::User.stub(:find) { edited_user } }
-
-    context 'when the user is an admin' do
-      it 'should not allow the user to assign a super_admin role' do
-        super_admin_role = Tenon::Role.create(title: 'Super Admin')
-        put :update, id: 1, user: { role_ids: [super_admin_role.id] }
-        expect(assigns[:user].role_ids).not_to include(super_admin_role.id)
-      end
-    end
-
-    context 'when the user is a super_admin' do
-      before { user.stub(:is_super_admin?) { true } }
-      it 'should allow the user to assign a super_admin role' do
-        super_admin_role = Tenon::Role.create(title: 'Super Admin')
-        put :update, id: 1, user: { role_ids: [super_admin_role.id] }
-        expect(assigns[:user].role_ids).to include(super_admin_role.id)
-      end
-    end
-  end
-end