1
            

            

            class Admin::UsersController < Admin::ResourceController
          
        
      
        

          

            1
            

            

              paginate_models
          
        
      
        

          

            1
            

            

              only_allow_access_to :index, :show, :new, :create, :edit, :update, :remove, :destroy,
          
        
      
        

          

            
            

            

                                   when: :admin,
          
        
      
        

          

            
            

            

                                   denied_url: { controller: 'pages', action: 'index' },
          
        
      
        

          

            
            

            

                                   denied_message: 'You must have administrative privileges to perform this action.'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              before_action :ensure_deletable, only: %i[remove destroy]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def show
          
        
      
        

          

            
            

            

                redirect_to edit_admin_user_path(params[:id])
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def create
          
        
      
        

          

            
            

            

                user = User.new(user_params)
          
        
      
        

          

            
            

            

                if user.save
          
        
      
        

          

            
            

            

                  flash[:notice] = 'User was created.'
          
        
      
        

          

            
            

            

                  redirect_to admin_users_path
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  flash[:error] = 'There was an error saving the user. Please try again.'
          
        
      
        

          

            
            

            

                  render :new
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def update
          
        
      
        

          

            
            

            

                user_params = params[model_symbol].permit!
          
        
      
        

          

            
            

            

                if user_params && user_params['admin'] == false && model == current_user
          
        
      
        

          

            
            

            

                  user_params.delete('admin')
          
        
      
        

          

            
            

            

                  announce_cannot_remove_self_from_admin_role
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                model.skip_password_validation = true unless user_params[:password_confirmation].present?
          
        
      
        

          

            
            

            

                if model.update(user_params)
          
        
      
        

          

            
            

            

                  response_for :update
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  flash[:error] = 'There was an error saving the user. Please try again.'
          
        
      
        

          

            
            

            

                  render :edit
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def ensure_deletable
          
        
      
        

          

            
            

            

                if current_user.id.to_s == params[:id].to_s
          
        
      
        

          

            
            

            

                  announce_cannot_delete_self
          
        
      
        

          

            
            

            

                  redirect_to admin_users_path
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def user_params
          
        
      
        

          

            
            

            

                params.require(:user).permit(:first_name, :last_name, :admin, :designer,
          
        
      
        

          

            
            

            

                                             :password, :password_confirmation, :email, :site_id, :notes)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def announce_cannot_delete_self
          
        
      
        

          

            
            

            

                flash[:error] = t('users_controller.cannot_delete_self')
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def announce_cannot_remove_self_from_admin_role
          
        
      
        

          

            
            

            

                flash[:error] = 'You cannot remove yourself from the admin role.'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Admin::UsersHelper
          
        
      
        

          

            1
            

            

              def roles(user)
          
        
      
        

          

            
            

            

                roles = []
          
        
      
        

          

            
            

            

                roles << I18n.t('admin') if user.admin?
          
        
      
        

          

            
            

            

                roles << I18n.t('designer') if user.designer?
          
        
      
        

          

            
            

            

                roles.join(', ')
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Layout < ActiveRecord::Base
          
        
      
        

          

            
            

            

              # Default Order
          
        
      
        

          

            1
            

            

              default_scope { order('name') }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Associations
          
        
      
        

          

            1
            

            

              has_many :pages
          
        
      
        

          

            1
            

            

              belongs_to :created_by, class_name: 'User'
          
        
      
        

          

            1
            

            

              belongs_to :updated_by, class_name: 'User'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Validations
          
        
      
        

          

            1
            

            

              validates_presence_of :name
          
        
      
        

          

            1
            

            

              validates_uniqueness_of :name
          
        
      
        

          

            1
            

            

              validates_length_of :name, maximum: 100
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe ApplicationController, :type => :controller do
          
        
      
        

          

            1
            

            

              routes { TrustyCms::Engine.routes }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              it 'should initialize the javascript and stylesheets arrays' do
          
        
      
        

          

            
            

            

                controller.send :set_javascripts_and_stylesheets
          
        
      
        

          

            
            

            

                expect(controller.send(:instance_variable_get, :@javascripts)).not_to be_nil
          
        
      
        

          

            
            

            

                expect(controller.send(:instance_variable_get, :@javascripts)).to be_instance_of(Array)
          
        
      
        

          

            
            

            

                expect(controller.send(:instance_variable_get, :@stylesheets)).not_to be_nil
          
        
      
        

          

            
            

            

                expect(controller.send(:instance_variable_get, :@stylesheets)).to be_instance_of(Array)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'self.template_name' do
          
        
      
        

          

            1
            

            

                it "should return 'index' when the controller action_name is 'index'" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return('index')
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('index')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                ['new', 'create'].each do |action|
          
        
      
        

          

            2
            

            

                  it "should return 'new' when the action_name is #{action}" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return(action)
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('new')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                ['edit', 'update'].each do |action|
          
        
      
        

          

            2
            

            

                  it "should return 'edit' when the action_name is #{action}" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return(action)
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('edit')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                ['remove', 'destroy'].each do |action|
          
        
      
        

          

            2
            

            

                  it "should return 'remove' when the action_name is #{action}" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return(action)
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('remove')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                it "should return 'show' when the action_name is show" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return('show')
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('show')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                it "should return the action_name when the action_name is a non-standard name" do
          
        
      
        

          

            
            

            

                  allow(controller).to receive(:action_name).and_return('other')
          
        
      
        

          

            
            

            

                  expect(controller.template_name).to eq('other')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe "set_timezone" do
          
        
      
        

          

            1
            

            

                it "should use TrustyCms::Config['local.timezone']" do
          
        
      
        

          

            
            

            

                  TrustyCms::Config['local.timezone'] = 'UTC'
          
        
      
        

          

            
            

            

                  controller.send(:set_timezone)
          
        
      
        

          

            
            

            

                  expect(Time.zone.name).to eq('UTC')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it "should default to config.time_zone" do
          
        
      
        

          

            
            

            

                  TrustyCms::Config.initialize_cache # to clear out setting from previous tests
          
        
      
        

          

            
            

            

                  controller.send(:set_timezone)
          
        
      
        

          

            
            

            

                  expect(Time.zone.name).to eq('UTC')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe Admin::UsersController, :type => :controller do
          
        
      
        

          

            1
            

            

              routes { TrustyCms::Engine.routes }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :layout do
          
        
      
        

          

            1
            

            

                name { 'Main Layout' }
          
        
      
        

          

            1
            

            

                content { <<-CONTENT }
          
        
      
        

          

            
            

            

                <html>
          
        
      
        

          

            
            

            

                  <head>
          
        
      
        

          

            
            

            

                    <title><r:title /></title>
          
        
      
        

          

            
            

            

                  </head>
          
        
      
        

          

            
            

            

                  <body>
          
        
      
        

          

            
            

            

                    <r:content />
          
        
      
        

          

            
            

            

                  </body>
          
        
      
        

          

            
            

            

                </html>
          
        
      
        

          

            
            

            

                    CONTENT
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            1
            

            

              factory :page do
          
        
      
        

          

            1
            

            

                title       { 'Page' }
          
        
      
        

          

            1
            

            

                breadcrumb  { title }
          
        
      
        

          

            1
            

            

                slug        { title.slugify }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                trait :with_parts do
          
        
      
        

          

            1
            

            

                  page_parts { [FactoryBot.create(:page_part, name: 'body')] }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                trait :with_children do
          
        
      
        

          

            1
            

            

                  children { [FactoryBot.create(:page, :with_parts)] }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :page_with_layout do
          
        
      
        

          

            1
            

            

                  layout
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :page_with_page_parts do
          
        
      
        

          

            1
            

            

                  page_parts
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :file_not_found_page, class: FileNotFoundPage do
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :parent do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :published_page do
          
        
      
        

          

            1
            

            

                  status_id { Status[:published].id }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  factory :article do
          
        
      
        

          

            1
            

            

                    title { generate(:article_title)}
          
        
      
        

          

            1
            

            

                    slug { generate(:article_slug)}
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  factory :page_with_body_page_part do
          
        
      
        

          

            1
            

            

                    after(:create) { |page| page.parts.create(name: 'body', content: "#{page.title} body.") }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  factory :page_with_body_and_sidebar_parts do
          
        
      
        

          

            1
            

            

                    after(:create) { |page| page.parts.create(name: 'body', content: "#{page.title} body.") }
          
        
      
        

          

            1
            

            

                    after(:create) { |page| page.parts.create(name: 'sidebar', content: "#{page.title} sidebar.") }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :home do |home|
          
        
      
        

          

            1
            

            

                  title { 'Home' }
          
        
      
        

          

            1
            

            

                  slug { '/' }
          
        
      
        

          

            1
            

            

                  status_id { Status[:published].id }
          
        
      
        

          

            1
            

            

                  parent_id { nil }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              sequence :article_slug do |n|
          
        
      
        

          

            
            

            

                "article#{('-' + n.to_s) unless n == 1 }"
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              sequence :article_title do |n|
          
        
      
        

          

            
            

            

                "Article#{(' ' + n.to_s) unless n == 1 }"
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :page_part do
          
        
      
        

          

            1
            

            

                name { 'unnamed' }
          
        
      
        

          

            1
            

            

                content { name }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            1
            

            

              factory :user do
          
        
      
        

          

            1
            

            

                name { 'User' }
          
        
      
        

          

            1
            

            

                email { 'email@test.com' }
          
        
      
        

          

            1
            

            

                login { 'user' }
          
        
      
        

          

            1
            

            

                password { 'password' }
          
        
      
        

          

            1
            

            

                password_confirmation { password }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :admin do
          
        
      
        

          

            1
            

            

                  name { 'Admin' }
          
        
      
        

          

            1
            

            

                  login { 'admin' }
          
        
      
        

          

            1
            

            

                  email { 'admin@example.com' }
          
        
      
        

          

            1
            

            

                  admin { true }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :existing do
          
        
      
        

          

            1
            

            

                  name { 'Existing' }
          
        
      
        

          

            1
            

            

                  login { 'existing' }
          
        
      
        

          

            1
            

            

                  email { 'existing@example.com' }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :designer do
          
        
      
        

          

            1
            

            

                  name { 'Designer' }
          
        
      
        

          

            1
            

            

                  login { 'designer' }
          
        
      
        

          

            1
            

            

                  email { '' }
          
        
      
        

          

            1
            

            

                  designer { true }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                factory :non_admin do
          
        
      
        

          

            1
            

            

                  name { 'Non Admin' }
          
        
      
        

          

            1
            

            

                  login { 'non_admin' }
          
        
      
        

          

            1
            

            

                  admin { false }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'rails_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe 'Configuration (Settings)' do
          
        
      
        

          

            1
            

            

              fixtures :users
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              before(:each) do
          
        
      
        

          

            
            

            

                @admin = users(:captain_janeway)
          
        
      
        

          

            
            

            

                login_as(@admin, :scope => :user)
          
        
      
        

          

            
            

            

                click_link 'Settings'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # it 'has personal and site preferences' do
          
        
      
        

          

            
            

            

              #   expect(page).to have_content 'Personal Preferences'
          
        
      
        

          

            
            

            

              #   expect(page).to have_content 'Configuration'
          
        
      
        

          

            
            

            

              # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # it 'lets you edit your personal preferences' do
          
        
      
        

          

            
            

            

              #   click_button 'Edit Preferences'
          
        
      
        

          

            
            

            

              #   fill_in 'Name', with: 'Captain Kathryn Janeway'
          
        
      
        

          

            
            

            

              #   click_button 'Save Changes'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              #   expect(page).to have_content 'Name Captain Kathryn Janeway'
          
        
      
        

          

            
            

            

              # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # it 'lets you edit the site preferences' do
          
        
      
        

          

            
            

            

              #   click_button 'Edit Configuration'
          
        
      
        

          

            
            

            

              #   fill_in 'Site Title', with: 'My Special Site'
          
        
      
        

          

            
            

            

              #   click_button 'Save Changes'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              #   within '#site_title' do
          
        
      
        

          

            
            

            

              #     expect(page).to have_content  'My Special Site'
          
        
      
        

          

            
            

            

              #   end
          
        
      
        

          

            
            

            

              # end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'rails_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe 'Layouts (Design)' do
          
        
      
        

          

            1
            

            

              fixtures :users
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              before(:each) do
          
        
      
        

          

            
            

            

                @admin = users(:captain_janeway)
          
        
      
        

          

            
            

            

                login_as(@admin, :scope => :user)
          
        
      
        

          

            
            

            

                click_link 'Design'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'without any layouts' do
          
        
      
        

          

            
            

            

                # it 'says it has no layouts' do
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'No Layouts'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # it 'lets you add a layout' do
          
        
      
        

          

            
            

            

                #   click_link 'New Layout'
          
        
      
        

          

            
            

            

                #   fill_in 'Name', with: 'Petunias'
          
        
      
        

          

            
            

            

                #   fill_in 'Body', with: 'Wisteria'
          
        
      
        

          

            
            

            

                #   click_button 'Create Layout'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Petunias'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'with a layout' do
          
        
      
        

          

            1
            

            

                before(:each) do
          
        
      
        

          

            
            

            

                  Layout.create!(name: 'Petunias', content: 'Wisteria')
          
        
      
        

          

            
            

            

                  visit '/admin/layouts'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # it 'lets you edit the layout' do
          
        
      
        

          

            
            

            

                #   click_link 'Petunias'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Edit Layout'
          
        
      
        

          

            
            

            

                #   expect(page).to have_field 'Name', with: 'Petunias'
          
        
      
        

          

            
            

            

                #   expect(page).to have_field 'Body', with: 'Wisteria'
          
        
      
        

          

            
            

            

                #   expect(page).to have_button 'Save Changes'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Last Updated by Kathryn Janeway'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # it 'lets you remove the layout' do
          
        
      
        

          

            
            

            

                #   click_link 'Remove'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Are you sure you want to permanently remove the following layout?'
          
        
      
        

          

            
            

            

                #   click_button 'Delete Layout'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'No Layouts'
          
        
      
        

          

            
            

            

                #   expect(page).to have_link 'New Layout'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'rails_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe 'Pages' do
          
        
      
        

          

            1
            

            

              fixtures :users
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              before(:each) do
          
        
      
        

          

            
            

            

                @admin = users(:captain_janeway)
          
        
      
        

          

            
            

            

                login_as(@admin, :scope => :user)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'without any pages' do
          
        
      
        

          

            
            

            

                # it 'can create a new homepage' do
          
        
      
        

          

            
            

            

                #   click_link 'New Homepage'
          
        
      
        

          

            
            

            

                #   fill_in 'Page Title', with: 'Voyager Home'
          
        
      
        

          

            
            

            

                #   fill_in 'Breadcrumb', with: 'Home'
          
        
      
        

          

            
            

            

                #   click_button 'Create Page'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   within 'table#pages' do
          
        
      
        

          

            
            

            

                #     expect(page).to have_selector 'tbody tr', count: 1
          
        
      
        

          

            
            

            

                #     expect(page).to have_link 'Voyager Home'
          
        
      
        

          

            
            

            

                #     expect(page).to have_link 'Add Child'
          
        
      
        

          

            
            

            

                #     expect(page).to have_link 'Normal Page'
          
        
      
        

          

            
            

            

                #     expect(page).to have_link 'File Not Found'
          
        
      
        

          

            
            

            

                #     expect(page).to have_link 'Remove'
          
        
      
        

          

            
            

            

                #   end
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'with only a homepage' do
          
        
      
        

          

            1
            

            

                before(:each) do
          
        
      
        

          

            
            

            

                  Page.create!(title: 'Voyager Home', breadcrumb: 'Home', slug: '/')
          
        
      
        

          

            
            

            

                  visit '/admin/pages'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # it 'lets you edit the homepage' do
          
        
      
        

          

            
            

            

                #   click_link 'Voyager Home'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   expect(page).to have_field 'Page Title', with: 'Voyager Home'
          
        
      
        

          

            
            

            

                #   expect(page).to have_button 'Save Changes'
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Last Updated by Kathryn Janeway'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # it 'lets you remove the homepage' do
          
        
      
        

          

            
            

            

                #   click_link 'Remove'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'Are you sure you want to permanently remove the following Page?'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   click_button 'Delete Page'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   expect(page).to have_content 'No Pages'
          
        
      
        

          

            
            

            

                #   expect(page).to have_link 'New Homepage'
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe Layout do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              let(:layout){ FactoryBot.build(:layout) }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'name' do
          
        
      
        

          

            1
            

            

                it 'is invalid when blank' do
          
        
      
        

          

            
            

            

                  layout = FactoryBot.build(:layout, name: '')
          
        
      
        

          

            
            

            

                  layout.valid?
          
        
      
        

          

            
            

            

                  expect(layout.errors[:name]).to include("This field is required.")
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'should validate uniqueness of' do
          
        
      
        

          

            
            

            

                  layout = FactoryBot.build(:layout, name: 'Normal', content: "Content!")
          
        
      
        

          

            
            

            

                  layout.save!
          
        
      
        

          

            
            

            

                  other = FactoryBot.build(:layout, name: 'Normal', content: "Content!")
          
        
      
        

          

            
            

            

                  expect{other.save!}.to raise_error(ActiveRecord::RecordInvalid)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'should validate length of' do
          
        
      
        

          

            
            

            

                  layout = FactoryBot.build(:layout, name: 'x' * 100)
          
        
      
        

          

            
            

            

                  expect(layout.errors[:name]).to be_blank
          
        
      
        

          

            
            

            

                  layout = FactoryBot.build(:layout, name: 'x' * 101)
          
        
      
        

          

            
            

            

                  expect{layout.save!}.to raise_error(ActiveRecord::RecordInvalid)
          
        
      
        

          

            
            

            

                  expect(layout.errors[:name]).to include("This must not be longer than 100 characters")
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # This file is copied to spec/ when you run 'rails generate rspec:install'
          
        
      
        

          

            1
            

            

            ENV["RAILS_ENV"] ||= 'test'
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            1
            

            

            require 'rspec/rails'
          
        
      
        

          

            1
            

            

            require 'capybara/rails'
          
        
      
        

          

            1
            

            

            require 'capybara/poltergeist'
          
        
      
        

          

            1
            

            

            Capybara.javascript_driver = :poltergeist
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            Capybara.register_driver :poltergeist do |app|
          
        
      
        

          

            
            

            

              Capybara::Poltergeist::Driver.new(app, timeout: 60)
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'database_cleaner'
          
        
      
        

          

            1
            

            

            DatabaseCleaner.strategy = :truncation, {except: %w[config]}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Requires supporting ruby files with custom matchers and macros, etc, in
          
        
      
        

          

            
            

            

            # spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
          
        
      
        

          

            
            

            

            # run as spec files by default. This means that files in spec/support that end
          
        
      
        

          

            
            

            

            # in _spec.rb will both be required and run as specs, causing the specs to be
          
        
      
        

          

            
            

            

            # run twice. It is recommended that you do not name files matching this glob to
          
        
      
        

          

            
            

            

            # end with _spec.rb. You can configure this pattern with with the --pattern
          
        
      
        

          

            
            

            

            # option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
          
        
      
        

          

            1
            

            

            Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            RSpec.configure do |config|
          
        
      
        

          

            
            

            

              # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
          
        
      
        

          

            1
            

            

              config.fixture_path = "#{::TRUSTY_CMS_ROOT}/spec/fixtures"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # If you're not using ActiveRecord, or you'd prefer not to run each of your
          
        
      
        

          

            
            

            

              # examples within a transaction, remove the following line or assign false
          
        
      
        

          

            
            

            

              # instead of true.
          
        
      
        

          

            1
            

            

              config.use_transactional_fixtures = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # RSpec Rails can automatically mix in different behaviours to your tests
          
        
      
        

          

            
            

            

              # based on their file location, for example enabling you to call `get` and
          
        
      
        

          

            
            

            

              # `post` in specs under `spec/controllers`.
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              # You can disable this behaviour by removing the line below, and instead
          
        
      
        

          

            
            

            

              # explicitly tag your specs with their type, e.g.:
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              #     RSpec.describe UsersController, :type => :controller do
          
        
      
        

          

            
            

            

              #       # ...
          
        
      
        

          

            
            

            

              #     end
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              # The different available types are documented in the features, such as in
          
        
      
        

          

            
            

            

              # https://relishapp.com/rspec/rspec-rails/docs
          
        
      
        

          

            1
            

            

              config.infer_spec_type_from_file_location!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              config.before(:suite) do
          
        
      
        

          

            1
            

            

                TrustyCms::Config.initialize_cache
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                configs = [
          
        
      
        

          

            
            

            

                  ['admin.title', 'TrustyCMS'],
          
        
      
        

          

            
            

            

                  ['admin.subtitle', 'Publishing for Small Teams'],
          
        
      
        

          

            
            

            

                  ['defaults.page.parts', 'body, extended'],
          
        
      
        

          

            
            

            

                  ['defaults.page.status', 'Draft'],
          
        
      
        

          

            
            

            

                  ['defaults.page.filter', nil],
          
        
      
        

          

            
            

            

                  ['defaults.page.fields', 'Keywords, Description'],
          
        
      
        

          

            
            

            

                  ['defaults.snippet.filter', nil],
          
        
      
        

          

            
            

            

                  ['session_timeout', '1209600'], # 2.weeks.to_s ????
          
        
      
        

          

            
            

            

                  ['default_locale', 'en'],
          
        
      
        

          

            
            

            

                ]
          
        
      
        

          

            
            

            

                configs.each do |key, value|
          
        
      
        

          

            
            

            

                  c = TrustyCms::Config.find_or_initialize_by(key: key)
          
        
      
        

          

            
            

            

                  c.value = value
          
        
      
        

          

            
            

            

                  c.save
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              config.after(:each) do
          
        
      
        

          

            
            

            

                DatabaseCleaner.clean
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # Commonly occurring user actions in tests.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # This takes a username and by default assumes the password is 'password'.
          
        
      
        

          

            1
            

            

            def log_in_as(login, plaintext_password = 'password')
          
        
      
        

          

            
            

            

              visit '/'
          
        
      
        

          

            
            

            

              fill_in 'username_or_email', with: login
          
        
      
        

          

            
            

            

              fill_in 'password', with: plaintext_password
          
        
      
        

          

            
            

            

              click_on 'Login'
          
        
      
        

          

            
            

            

            end