symphonia 2.1.7

data/spec/controllers/api_controller_spec.rb

@@ -0,0 +1,9 @@
+module Symphonia
+  RSpec.describe ApiController do
+    routes { Symphonia::Engine.routes }
+
+    it "#index" do
+      get :index
+    end
+  end
+end

data/spec/controllers/filters_controller_spec.rb

@@ -0,0 +1,35 @@
+module Symphonia
+  RSpec.describe FiltersController do
+    routes { Symphonia::Engine.routes }
+
+    context 'no user' do
+
+      it '#options' do
+        get :options, params: { type: 'User' }
+        expect(response).to redirect_to login_path
+      end
+
+    end
+
+    context 'logged in', logged: true do
+
+      context 'without valid params' do
+
+        it '#options' do
+          get :options, params: { type: 'User' }
+          expect(response).to have_http_status :not_found
+        end
+
+      end
+
+      context 'correct' do
+
+        it '#options' do
+          get :options, params: { type: 'Symphonia::User' }
+          expect(response).to have_http_status :success
+        end
+
+      end
+    end
+  end
+end

data/spec/controllers/images_controller_spec.rb

@@ -0,0 +1,5 @@
+module Symphonia
+  RSpec.describe ImagesController do
+
+  end
+end

data/spec/controllers/login_controller_spec.rb

@@ -0,0 +1,20 @@
+class DummyController < ::ApplicationController
+  include Symphonia::ControllerExtensions
+  before_action :require_admin
+end
+
+RSpec.describe ::DummyController, type: :controller do
+
+  controller do
+    def admin_action
+      raise StandardError
+    end
+  end
+
+  it "redirect to login form" do
+    routes.draw { get "admin_action", to: "dummy#admin_action" }
+    get :admin_action
+    expect(response).to redirect_to("/login")
+  end
+
+end

data/spec/controllers/roles_controller_spec.rb

@@ -0,0 +1,12 @@
+# require_relative '../spec_helper.rb'
+
+module Symphonia
+  describe RolesController, type: 'controller', logged: :admin do
+    routes { Symphonia::Engine.routes }
+    subject { Symphonia::Role }
+
+    include_examples 'a controller actions', :role
+
+  end
+
+end

data/spec/controllers/users_controller_spec.rb

@@ -0,0 +1,47 @@
+# require_relative '../spec_helper.rb'
+module Symphonia
+  describe UsersController, type: 'controller' do
+    routes { Symphonia::Engine.routes }
+    subject { Symphonia::User }
+
+    let(:user) { FactoryBot.create(:user) }
+
+    context 'as admin', logged: :admin do
+      include ActiveJob::TestHelper
+
+      include_examples 'a controller actions', :user
+
+      context 'not found' do
+        it '#show' do
+          get :show, params: {id: 0 }
+          expect(response).to have_http_status :not_found
+        end
+      end
+
+      it '#archive' do
+        user.update_columns status: 'active'
+        expect ( post :archive, params: { id: user } )
+        expect(response).to redirect_to users_url
+        expect(user.reload.status).to eq 'archived'
+      end
+
+      it '#unarchive' do
+        user.update_columns status: 'archived'
+        expect( post :unarchive, params: { id: user } )
+        expect(ActionMailer::DeliveryJob).to have_been_enqueued
+        expect(response).to redirect_to users_url
+        expect(user.reload.status).to eq 'active'
+      end
+    end
+
+    context 'as regular use', logged: true do
+
+      it '#index' do
+        get :index
+        expect(response).to have_http_status :forbidden
+      end
+    end
+
+  end
+
+end

data/spec/factories/factories.rb

@@ -0,0 +1,52 @@
+FactoryBot.define do
+  factory :user, class: 'Symphonia::User' do
+    sequence(:first_name) { |n| "#{Faker::Name.first_name} #{n}" }
+    sequence(:last_name) { |n| "#{Faker::Name.last_name} #{n}" }
+    sequence(:email) { |n| "#{n}" + Faker::Internet.email }
+    login { email }
+    admin { false }
+    password { SecureRandom.hex(16) }
+    password_confirmation { password }
+    last_request_at { Time.now }
+
+    trait :admin do
+      admin { true }
+    end
+
+    trait :with_preferences do
+      transient do
+        preference_names { [] }
+      end
+      after(:build) do |user, evaluator|
+        user.preferences = evaluator.preference_names.collect { |pref_name| FactoryBot.create(:email_preference, name: pref_name) }
+      end
+    end
+    factory :admin_user, traits: [:admin]
+  end
+
+  factory :role, class: 'Symphonia::Role' do
+    sequence(:name) { |n| "#{Faker::Job.title} #{n}" }
+  end
+
+  factory :attachment, class: 'Symphonia::Attachment' do
+    association :attachable, factory: :user
+  end
+
+  factory :file, parent: :attachment, class: 'Symphonia::CommonFile' do
+    attachment { File.new(File.expand_path('../../support/common_file.txt', __FILE__)) }
+  end
+
+  factory :image, parent: :attachment, class: 'Symphonia::Image' do
+    attachment { File.new(File.expand_path('../../support/symphonia.jpg', __FILE__)) }
+  end
+
+  factory :preference, class: 'Symphonia::Preference' do
+
+    factory :email_preference, class: 'Symphonia::EmailPreference' do
+      trait :user_registered do
+        name { :notify_after_user_registered }
+      end
+    end
+  end
+end
+

data/spec/helpers/symphonia/application_helper_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe Symphonia::ApplicationHelper do
+  describe "#title" do
+    it "returns the default title" do
+      expect(helper.title("Holub")).to match /<(h1)\s.*id=\Wpage_header\W\s.*Holub<\/\1>/
+    end
+
+    it "with symbol" do
+      expect(helper.title(:title)).to match /<(h1)\s.*id=\Wpage_header\W\s.*Title<\/\1>/
+    end
+
+    it "with back" do
+      expect(helper.title("Head", back: true)).to include "history.back()"
+    end
+
+    it "with custom back" do
+      expect(helper.title("Head", back: "/path")).to include "/path"
+    end
+
+    it "xhr without back" do
+      allow(helper.request).to receive(:xhr?).and_return true
+      expect(helper.title("Head", back: true)).to match /<(h5)\s.*id=\Wpage_header\W\s.*Head<\/\1>/
+    end
+  end
+
+  describe "#render_flash_messages" do
+    it "render error" do
+      r = helper.render_flash_messages(error: "flash message")
+      expect(r).to include "danger"
+    end
+    it "render notice" do
+      r = helper.render_flash_messages(notice: "flash message")
+      expect(r).to include "success"
+    end
+    it "render warning" do
+      r = helper.render_flash_messages(warning: "flash message")
+      expect(r).to include "warning"
+    end
+    it "render info" do
+      r = helper.render_flash_messages(info: "flash message")
+      expect(r).to include "info"
+    end
+  end
+
+  describe "#format_html" do
+    it "plain text" do
+      expect(helper.format_html("sojka")).to eq "<div class=\"formatted-text\"><p>sojka</p>\n</div>"
+    end
+    it "plain text" do
+      expect(helper.format_html("# sojka")).to eq "<div class=\"formatted-text\"><h1>sojka</h1>\n</div>"
+    end
+  end
+
+  describe "#render_no_data" do
+    it "default" do
+      expect(helper.render_no_data).to include t(:text_no_data), "nodata"
+    end
+
+    it "custom message" do
+      expect(helper.render_no_data("Sorry bro")).to include "Sorry bro", "nodata"
+    end
+  end
+end

data/spec/mailers/previews/symphonia/notifier_preview.rb

@@ -0,0 +1,27 @@
+module Symphonia
+  class NotifierPreview < ::ActionMailer::Preview
+
+    def test_mail
+      Notifier.test_mail(User.last)
+    end
+
+    def user_registered
+      Notifier.user_registered(User.last)
+    end
+
+    def reset_password_user
+      Notifier.reset_password_user(User.last)
+    end
+
+    def activation_user
+      Notifier.activation_user(User.last)
+    end
+
+    def user_change_to_active
+      Notifier.user_change_to_active(User.last)
+    end
+
+
+  end
+
+end

data/spec/mailers/symphonia/notifier_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../../rails_helper'
+
+module Symphonia
+  RSpec.describe Notifier do
+    let(:user) { FactoryBot.create(:user) }
+    before(:each) { I18n.locale = :cs }
+
+    context '#test_mail' do
+      let(:mail) { described_class.test_mail(user) }
+
+      it 'renders the headers' do
+        expect(mail.subject).to eq('Symphonia testing mail')
+        expect(mail.to).to eq([user.email])
+      end
+
+      it 'renders the body' do
+        expect(mail.body.encoded).to match('Testing mail from Symphonia system')
+      end
+    end
+
+    context '#activation_user' do
+      let(:mail) { described_class.activation_user(user) }
+
+      it 'renders the headers' do
+        expect(mail.subject).to match 'Aktivace'
+        expect(mail.to).to eq([user.email])
+      end
+
+      it 'renders the body' do
+        expect(mail.body.encoded).to match user.perishable_token
+      end
+    end
+
+    context '#user_change_to_active' do
+      let(:mail) { described_class.user_change_to_active(user) }
+
+      it 'renders the headers' do
+        expect(mail.subject).to match 'aktivován'
+        expect(mail.to).to eq([user.email])
+      end
+
+      it 'renders the body' do
+        expect(mail.body.encoded).to match "users/#{user.id}"
+      end
+    end
+
+    context '#reset_password_user' do
+      let(:mail) { described_class.reset_password_user(user) }
+
+      it 'renders the headers' do
+        expect(mail.subject).to match 'heslo'
+        expect(mail.to).to eq([user.email])
+      end
+
+      it 'renders the body' do
+        expect(mail.body.encoded).to match "reset_password/#{user.perishable_token}"
+      end
+    end
+
+    context '#user_registered' do
+      let(:notify) { FactoryBot.create(:email_preference, :user_registered) }
+      let!(:admin) { FactoryBot.create(:user, { preferences: [notify]}) }
+      let(:mail) { described_class.user_registered(user) }
+
+      it 'renders the headers' do
+        expect(mail.subject).to match 'nový uživatel'
+        expect(mail.to).to eq([admin.email])
+      end
+
+      it 'renders the body' do
+        expect(mail.body.encoded).to match user.name
+      end
+    end
+
+  end
+end

data/spec/models/attachment_spec.rb

@@ -0,0 +1,22 @@
+describe Symphonia::Attachment do
+
+  context 'files' do
+    let(:file) { FactoryBot.create(:file) }
+    it '#create' do
+      expect { file }.to change(described_class, :count).by 1
+    end
+
+    it 'just create common file' do
+      f = nil
+      expect { f = FactoryBot.create(:file, attachable: nil) }.to change(described_class, :count).by 1
+      expect(f.attachable).to be_nil
+    end
+  end
+
+  context 'images' do
+    let(:image) { FactoryBot.create(:image) }
+    it '#create' do
+      expect { image }.to change(described_class, :count).by 1
+    end
+  end
+end

data/spec/models/query/attribute_spec.rb

@@ -0,0 +1,8 @@
+RSpec.describe Symphonia::ModelAttributes do
+  subject { DummyQueryEntity.query.new }
+  context "sort" do
+    it "no sort" do
+      expect(subject.columns[2].sort?).to eq false
+    end
+  end
+end

data/spec/models/query/symphonia_query_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe Symphonia::Query do
+
+  subject do
+    q = described_class.new
+    q.model = DummyQueryEntity
+    q
+  end
+
+  describe "#available_filters" do
+    it "include name filter" do
+      expect(subject.available_filters.first&.name).to eq :name
+    end
+  end
+
+  describe "#initialize" do
+    it "empty" do
+      q = described_class.new
+      q.model = DummyQueryEntity
+      expect(q.entity).to eq DummyQueryEntity
+      expect(q.filters).to be_blank
+    end
+
+    it "default filters" do
+      q = described_class.new(filters: { name: "!cip" })
+      q.model = DummyQueryEntity
+      expect(q.filters.size).to eq 1
+      filter = q.filters.first
+      expect(filter.value).to eq "cip"
+    end
+
+    it "legacy fallback" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).twice
+      described_class.new(spy("Controller"), default_order: "cip")
+    end
+  end
+
+  describe "#from_params" do
+    it "blank" do
+      q = DummyQueryEntity.query.new(filters: { name: "!clip" })
+      expect { q.from_params({}) }.not_to raise_error
+      expect(q.filters).not_to be_blank
+    end
+
+    it "with filters" do
+      q = DummyQueryEntity.query.new(filters: { name: "!clip" })
+      expect { q.from_params(set_filter: "1") }.not_to raise_error
+      expect(q.filters).to be_blank
+    end
+
+    it "columns" do
+      q = DummyQueryEntity.query.new
+      expect(q.column_names).to match_array [:name, :status, :author]
+      q.from_params(column_names: "name")
+      expect(q.column_names).to match_array [:name]
+    end
+  end
+
+  describe "#entities" do
+    it "get entities" do
+      # scope = spy
+      # expect(subject).to receive(:scope).and_return(scope)
+      Symphonia::User.query.new.entities
+    end
+  end
+
+  describe "#columns" do
+
+  end
+
+end

data/spec/models/role_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Symphonia::Role do
+  subject { FactoryBot.create :role, permissions: [:view_users] }
+
+  describe "#allowed_to?" do
+    it "false" do
+      expect(subject.allowed_to?( :non_exists)).to eq false
+    end
+
+    it "true" do
+      expect(subject.allowed_to?(:view_users)).to eq true
+    end
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe Symphonia::User do
+  subject { FactoryBot.create(:user, email: "test@dummy.com") }
+  it "#like" do
+    expect(Symphonia::User.like(subject.mail)).to be_all Symphonia::User
+  end
+
+  it "#to_s" do
+    expect(subject.to_s).to eq "#{subject.first_name} #{subject.last_name}"
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,13 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'simplecov'
+SimpleCov.start 'rails' do
+  add_filter "/lib/generators"
+  add_filter "/bin"
+end
+
+require File.expand_path("../dummy/config/environment.rb", __FILE__)
+# Prevent database truncation if the environment is production
+abort('The Rails environment is running in production mode!') if Rails.env.production?
+
+require_relative 'spec_helper'

data/spec/requests/accounts_spec.rb

@@ -0,0 +1,118 @@
+describe Symphonia::AccountsController do
+
+  before(:each) do
+    Symphonia.config[:allow_registrations] = true
+  end
+
+  context '#register' do
+    it 'GET' do
+      get '/register'
+      expect(response).to have_http_status :success
+    end
+
+    context 'POST' do
+
+      it 'pending' do
+        expect { post '/register', params: { user: FactoryBot.attributes_for(:user) } }.to change(Symphonia::User, :count).by 1
+        expect(response).to have_http_status :redirect
+        expect(Symphonia::User.last.status).to eq 'pending'
+      end
+
+      it 'self activation' do
+        Symphonia.config[:self_activation_enabled] = true
+
+        expect { post '/register', params: { user: FactoryBot.attributes_for(:user) } }.to change(Symphonia::User, :count).by 1
+        expect(response).to have_http_status :redirect
+        expect(Symphonia::User.last.status).to eq 'active'
+      end
+
+      it 'invalid' do
+        expect { post '/register', params: { user: { login: Faker::Internet.user_name } } }.to change(Symphonia::User, :count).by 0
+        expect(response).to have_http_status :success
+      end
+    end
+  end
+
+  context 'pending' do
+    let(:pending_user) { FactoryBot.create(:user, status: 'pending', password: 'heslo123', password_confirmation: 'heslo123')}
+
+    it '#login' do
+      post symphonia.user_sessions_path, params: { login_session: { login: pending_user.login, password: 'heslo123' }}
+      expect(response).to have_http_status :success
+      expect(Symphonia::User.current.id).not_to eq pending_user.id
+    end
+  end
+
+  context 'with user', logged: true do
+
+    it '#new_activation' do
+      get symphonia.new_activation_account_path
+      expect(response).to have_http_status :success
+    end
+
+  end
+
+  context '#lost_password' do
+
+    it 'js' do
+      get symphonia.lost_password_account_path, xhr: true
+      expect(response).to have_http_status :success
+    end
+
+    it 'html' do
+      get symphonia.lost_password_account_path
+      expect(response).to have_http_status :success
+    end
+
+  end
+
+  context '#reset_password' do
+    let(:token) { SecureRandom.hex(3) }
+    let(:password) { SecureRandom.hex(8) }
+    let(:user) { FactoryBot.create(:user, status: 'active') }
+
+    context 'GET' do
+
+      it 'valid token' do
+        user.update_columns(perishable_token: token)
+        get symphonia.reset_password_path(id: token)
+        expect(response).to have_http_status :success
+      end
+
+      it 'invalid token' do
+        user
+        get symphonia.reset_password_path(id: token)
+        expect(response).to have_http_status :not_found
+      end
+    end
+
+    context 'PUT' do
+      before { FactoryBot.create(:user, status: 'active'); user.update_columns(perishable_token: token) }
+
+      it 'valid token' do
+        put symphonia.reset_password_account_path(id: token, password: password, password_confirmation: password )
+        expect(response).to redirect_to symphonia.user_current_path
+        expect(flash[:notice]).not_to be :blank
+      end
+
+      it 'invalid password' do
+        put symphonia.reset_password_account_path(id: token, password: '12', password_confirmation: '11' )
+        expect(response).to have_http_status :success
+        expect(flash[:notice]).to be_nil
+      end
+
+    end
+
+
+
+  end
+
+  context 'form for user', logged: true do
+    let(:regular_user) { FactoryBot.create(:user) }
+    it '/admin/account' do
+      get '/admin/account'
+      expect(response).to have_http_status :success
+    end
+  end
+
+end

data/spec/requests/attachments_controller_spec.rb

@@ -0,0 +1,23 @@
+describe Symphonia::AttachmentsController, logged: true do
+
+  let!(:file) { FactoryBot.create(:file) }
+  let(:images) { FactoryBot.create_list(:image, 3, attachable_id: nil, attachable_type: nil) }
+
+  it '#show' do
+    get symphonia.attachment_path(file)
+    expect(response.body).to match file.attachment.url(:original)
+  end
+
+  it '#destroy' do
+    expect{ delete(symphonia.attachment_path(file)) }.to change(Symphonia::Attachment, :count).by -1
+  end
+
+  it '#reorder' do
+    expect { images }.to change(Symphonia::Image, :count).by 3
+    patch symphonia.reorder_attachment_path images.last, 1
+    expect(response).to have_http_status :success
+    imgs = Symphonia::Image.order(:position).to_a
+    expect(imgs.first.id).to be > imgs.last.id
+  end
+
+end

data/spec/requests/login_spec.rb

@@ -0,0 +1,26 @@
+describe 'login' do
+
+  let(:regular_user) { FactoryBot.create(:user, password: 'heslo123', password_confirmation: 'heslo123')}
+
+  it 'login form' do
+    get symphonia.login_path
+    expect(response).to have_http_status(:success)
+  end
+
+  it 'login process' do
+    expect(Symphonia::User.current).to be_a Symphonia::User::Anonymous
+    post symphonia.user_sessions_path, params: { login_session: { login: regular_user.login, password: 'heslo123' }}
+    expect(response).to have_http_status :redirect
+    expect(Symphonia::User.current.id).to eq regular_user.id
+  end
+
+  context 'logged', logged: true do
+
+    it '#logout' do
+      expect(Symphonia::User.current).to be_a Symphonia::User
+      delete symphonia.logout_path
+      expect(response).to redirect_to '/'
+    end
+  end
+
+end

data/spec/requests/roles_spec.rb

@@ -0,0 +1,10 @@
+module Symphonia
+  describe Role, logged: :admin do
+    subject { 'role' }
+
+    let(:route) { symphonia }
+    include_examples 'a requests', :name
+
+  end
+
+end