lc_alchemy_cms 3.2.0

data/spec/libraries/shell_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'alchemy/shell'
+
+module Alchemy
+
+  # Class fixture
+  class MyToDoList
+    extend Shell
+  end
+
+  describe Shell do
+
+    before { allow(MyToDoList).to receive(:puts) }
+
+    describe '.todo' do
+      it "should add given string as a todo by delegating to .add_todo" do
+        expect(MyToDoList).to receive(:add_todo).with(["", "new todo"])
+        MyToDoList.todo("new todo")
+      end
+    end
+
+    describe '.todos' do
+      it "should be an Array" do
+        expect(MyToDoList.todos).to be_a(Array)
+      end
+    end
+
+    describe '.add_todo' do
+      it "should add the given string to the .todos array" do
+        MyToDoList.add_todo('1')
+        MyToDoList.add_todo('2')
+        expect(MyToDoList.todos).to eq(['1', '2'])
+      end
+    end
+
+    describe '.display_todos' do
+      context 'if there are todos in the list' do
+        before do
+          allow(MyToDoList).to receive(:todos).and_return(['My first todo', 'My second todo'])
+        end
+
+        it "should log them" do
+          expect(MyToDoList).to receive(:log).at_least(1).times
+          MyToDoList.display_todos
+        end
+
+        it "should iterate through the todos with an index" do
+          expect(MyToDoList.todos).to receive(:each_with_index)
+          MyToDoList.display_todos
+        end
+      end
+
+      context 'if there are todos in the list' do
+        before do
+          allow(MyToDoList).to receive(:todos).and_return([])
+        end
+
+        it "should not log anything" do
+          expect(MyToDoList).not_to receive(:log)
+          MyToDoList.display_todos
+        end
+      end
+    end
+
+    describe '.log' do
+      before { Alchemy::Shell.verbose! }
+
+      context 'if the message type is "skip"' do
+        it "the output color should be yellow and cleared again" do
+          expect(MyToDoList).to receive(:color).with(:yellow)
+          expect(MyToDoList).to receive(:color).with(:clear)
+          MyToDoList.log('in yellow, please', :skip)
+        end
+      end
+
+      context 'if the message type is "error"' do
+        it "the output color should be yellow and cleared again" do
+          expect(MyToDoList).to receive(:color).with(:red)
+          expect(MyToDoList).to receive(:color).with(:clear)
+          MyToDoList.log('in red, please', :error)
+        end
+      end
+
+      context 'if the message type is "message"' do
+        it "the output color should just be cleared" do
+          expect(MyToDoList).to receive(:color).with(:clear)
+          MyToDoList.log('cleared, please', :message)
+        end
+      end
+
+      context 'if no message type is given' do
+        it "the output color should be green" do
+          expect(MyToDoList).to receive(:color).with(:green)
+          expect(MyToDoList).to receive(:color).with(:clear)
+          MyToDoList.log('in green, please')
+        end
+      end
+    end
+
+    describe '.color' do
+
+      context 'if given name is a constant of Thor::Shell::Color' do
+        before do
+          allow(Thor::Shell::Color).to receive(:const_defined?).and_return(true)
+        end
+
+        it "should call the constant" do
+          expect_any_instance_of(String).to receive(:constantize).and_return('')
+          MyToDoList.send(:color, :red)
+        end
+      end
+
+      context 'if given name is not a defined constant of Thor::Shell::Color' do
+        before do
+          allow(Thor::Shell::Color).to receive(:const_defined?).and_return(false)
+        end
+
+        it "should return en empty string" do
+          expect(MyToDoList.send(:color, :not_existing)).to eq('')
+        end
+      end
+    end
+
+  end
+end

data/spec/libraries/template_tracker_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Alchemy
+  module CacheDigests
+    describe TemplateTracker do
+      subject { TemplateTracker.call(name, nil) }
+
+      describe '#dependencies' do
+        context 'with alchemy/pages/show given as template name' do
+          let(:name) { 'alchemy/pages/show' }
+          before { allow(PageLayout).to receive(:all).and_return([{'name' => 'intro'}, {'name' => 'contact'}]) }
+
+          it "returns all page layout view partial names" do
+            is_expected.to include('alchemy/page_layouts/_intro', 'alchemy/page_layouts/_contact')
+          end
+        end
+
+        context 'with a page layout given as template name' do
+          let(:name) { 'alchemy/page_layouts/_intro' }
+          let(:page_layout) { {'name' => 'intro', 'elements' => ['text']} }
+          before { allow(PageLayout).to receive(:get).and_return(page_layout) }
+
+          it "returns all element layout view partial names for that layout" do
+            is_expected.to include('alchemy/elements/_text_view')
+          end
+
+          context 'and page layout having cells' do
+            let(:page_layout) { {'name' => 'intro', 'elements' => ['text'], 'cells' => ['header']} }
+
+            it "returns all cell view partial names for that layout" do
+              is_expected.to include('alchemy/cells/_header')
+            end
+          end
+        end
+
+        context 'with a cell given as template name' do
+          let(:name) { 'alchemy/cells/_header' }
+          before { allow(Cell).to receive(:definition_for).and_return({'name' => 'header', 'elements' => ['text']}) }
+
+          it "returns all element layout view partial names for that cell" do
+            is_expected.to include('alchemy/elements/_text_view')
+          end
+        end
+
+        context 'with an element given as name' do
+          let(:name) { 'alchemy/elements/_text_view' }
+          let(:elements) { [{'name' => 'text', 'contents' => [{'type' => 'EssenceText'}]}] }
+
+          context 'that is having a description' do
+            before { allow(Element).to receive(:descriptions).and_return(elements) }
+
+            it "returns all essence layout view partial names for that element" do
+              is_expected.to include('alchemy/essences/_essence_text_view')
+            end
+
+            context 'and element has picture_gallery enabled' do
+              let(:elements) { [{'name' => 'text', 'picture_gallery' => true}] }
+
+              it "has EssencePicture as template dependency" do
+                is_expected.to include('alchemy/essences/_essence_picture_view')
+              end
+            end
+
+            context 'and element has available_contents defined' do
+              let(:elements) { [{'name' => 'text', 'available_contents' => ['type' => 'EssenceFile']}] }
+
+              it "has these essences as template dependency" do
+                is_expected.to include('alchemy/essences/_essence_file_view')
+              end
+            end
+          end
+
+          context 'that has no description' do
+            before { allow(Element).to receive(:descriptions).and_return([]) }
+
+            it "returns empty array" do
+              is_expected.to be_empty
+            end
+          end
+        end
+
+        context 'with not an alchemy template given as name' do
+          let(:name) { 'shop/cart' }
+
+          it "calls rails template tracker" do
+            expect(ActionView::DependencyTracker::ERBTracker).to receive(:call).with(name, nil)
+            subject
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/libraries/tinymce_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Tinymce do
+
+    describe '.init' do
+      subject { Tinymce.init }
+
+      it "returns the default config" do
+        is_expected.to eq(Tinymce.class_variable_get('@@init'))
+      end
+    end
+
+    describe '.init=' do
+      let(:another_config) { {theme_advanced_buttons3: 'table'} }
+
+      it "merges the default config with given config" do
+        Tinymce.init = another_config
+        expect(Tinymce.init).to include(another_config)
+      end
+    end
+
+    context 'Methods for contents with custom tinymce config.' do
+      let(:content_definition) { {'name' => 'text', 'settings' => {'tinymce' => {'foo' => 'bar'}}} }
+      let(:element_definition) { {'name' => 'article', 'contents' => [content_definition]} }
+
+      describe '.custom_config_contents' do
+        subject { Tinymce.custom_config_contents }
+
+        before do
+          allow(Element).to receive(:definitions).and_return([element_definition])
+          # Preventing memoization
+          Tinymce.class_variable_set('@@custom_config_contents', nil)
+        end
+
+        it "returns an array of content definitions that contain custom tinymce config and element name" do
+          is_expected.to be_an(Array)
+          is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
+        end
+
+        context 'with no contents having custom tinymce config' do
+          let(:content_definition) { {'name' => 'text'} }
+          it { is_expected.to eq([]) }
+        end
+
+        context 'with element definition having nil as contents value' do
+          let(:element_definition) { {'name' => 'element', 'contents' => nil} }
+
+          it "returns empty array" do
+            is_expected.to eq([])
+          end
+        end
+
+        context 'with a page given' do
+          let(:page) { mock_model('Page') }
+          subject { Tinymce.custom_config_contents(page) }
+
+          it "only returns custom tinymce config for elements of that page" do
+            expect(page).to receive(:element_definitions).and_return([element_definition])
+            is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/libraries/userstamp_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'Alchemy::AuthAccessors' do
+  describe '.user_class' do
+    it "injects userstamp class methods" do
+      expect(Alchemy.user_class).to respond_to(:stamper_class_name)
+      expect(Alchemy.user_class.stamper_class_name).to eq(:DummyUser)
+    end
+  end
+end

data/spec/mailers/messages_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Messages do
+
+    let(:message) { Message.new(email: 'jon@doe.com', message: 'Lorem ipsum') }
+    let(:mail) { Messages.contact_form_mail(message, 'admin@page.com', 'contact@page.com', 'Subject') }
+
+    it "delivers a mail to owner" do
+      expect(mail.to).to eq(['admin@page.com'])
+      expect(mail.subject).to eq('Subject')
+    end
+
+    it "reply_to should be set to senders email" do
+      expect(mail.reply_to).to eq([message.email])
+    end
+
+    it "mail body includes message" do
+      expect(mail.body).to match /#{message.message}/
+    end
+
+  end
+end

data/spec/models/attachment_spec.rb

@@ -0,0 +1,227 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Alchemy
+  describe Attachment do
+    let(:file)       { File.new(File.expand_path('../../fixtures/image with spaces.png', __FILE__)) }
+    let(:attachment) { Attachment.new(file: file) }
+
+    describe 'after assign' do
+      it "stores the file mime type into database" do
+        attachment.update(file: file)
+        expect(attachment.file_mime_type).not_to be_blank
+      end
+    end
+
+    describe 'after create' do
+      before { attachment.save! }
+
+      it "should have a humanized name" do
+        expect(attachment.name).to eq("image with spaces")
+      end
+
+      it "should have a valid file_name" do
+        expect(attachment.file_name).to eq("image-with-spaces.png")
+      end
+
+      after { attachment.destroy }
+    end
+
+    describe 'urlname sanitizing' do
+      it "should sanitize url characters in the filename" do
+        attachment.file_name = 'f#%&cking cute kitten pic.png'
+        attachment.save!
+        expect(attachment.urlname).to eq('f-cking-cute-kitten-pic.png')
+      end
+
+      it "should sanitize lot of dots in the name" do
+        attachment.file_name = 'cute.kitten.pic.png'
+        attachment.save!
+        expect(attachment.urlname).to eq('cute-kitten-pic.png')
+      end
+
+      it "should sanitize umlauts in the name" do
+        attachment.file_name = 'süßes katzenbild.png'
+        attachment.save!
+        expect(attachment.urlname).to eq('suesses-katzenbild.png')
+      end
+
+      after { attachment.destroy }
+    end
+
+    describe 'validations' do
+
+      context "having a png, but only pdf allowed" do
+        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
+
+        it "should not be valid" do
+          expect(attachment).not_to be_valid
+        end
+      end
+
+      context "having a png and everything allowed" do
+        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
+
+        it "should be valid" do
+          expect(attachment).to be_valid
+        end
+      end
+
+    end
+
+    context 'PNG image' do
+      subject { stub_model(Attachment, file_name: 'kitten.png') }
+
+      describe '#extension' do
+        subject { super().extension }
+        it { is_expected.to eq("png") }
+      end
+    end
+
+    describe 'css classes' do
+      context 'mp3 file' do
+        subject { stub_model(Attachment, file_mime_type: 'audio/mpeg') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("audio") }
+        end
+      end
+
+      context 'video file' do
+        subject { stub_model(Attachment, file_mime_type: 'video/mpeg') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("video") }
+        end
+      end
+
+      context 'png file' do
+        subject { stub_model(Attachment, file_mime_type: 'image/png') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("image") }
+        end
+      end
+
+      context 'vcf file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/vcard') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("vcard") }
+        end
+      end
+
+      context 'zip file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/zip') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("archive") }
+        end
+      end
+
+      context 'flash file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/x-shockwave-flash') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("flash") }
+        end
+      end
+
+      context 'photoshop file' do
+        subject { stub_model(Attachment, file_mime_type: 'image/x-psd') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("psd") }
+        end
+      end
+
+      context 'text file' do
+        subject { stub_model(Attachment, file_mime_type: 'text/plain') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("text") }
+        end
+      end
+
+      context 'rtf file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/rtf') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("rtf") }
+        end
+      end
+
+      context 'pdf file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/pdf') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("pdf") }
+        end
+      end
+
+      context 'word file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/msword') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("word") }
+        end
+      end
+
+      context 'excel file' do
+        subject { stub_model(Attachment, file_mime_type: 'application/vnd.ms-excel') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("excel") }
+        end
+      end
+
+      context 'unknown file' do
+        subject { stub_model(Attachment, file_mime_type: '') }
+
+        describe '#icon_css_class' do
+          subject { super().icon_css_class }
+          it { is_expected.to eq("file") }
+        end
+      end
+    end
+
+    describe '#restricted?' do
+      subject { attachment.restricted? }
+
+      context 'if only on restricted pages' do
+        before do
+          pages = double(any?: true)
+          expect(pages).to receive(:not_restricted).and_return([])
+          expect(attachment).to receive(:pages).twice.and_return(pages)
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'if not only on restricted pages' do
+        let(:page) { mock_model(Page) }
+
+        before do
+          pages = double(any?: true)
+          expect(pages).to receive(:not_restricted).and_return([page])
+          expect(attachment).to receive(:pages).twice.and_return(pages)
+        end
+
+        it { is_expected.to be_falsey }
+      end
+    end
+
+  end
+end