alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/libraries/shell_spec.rb

@@ -1,121 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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 definition' do
-            before { allow(Element).to receive(:definitions).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
-          end
-
-          context 'that has no definition' do
-            before { allow(Element).to receive(:definitions).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

@@ -1,111 +0,0 @@
-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) do
-        {
-          'name' => 'text',
-          'settings' => {
-            'tinymce' => {
-              'foo' => 'bar'
-            }
-          }
-        }
-      end
-
-      let(:element_definition) do
-        {
-          'name' => 'article',
-          'contents' => [content_definition]
-        }
-      end
-
-      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) do
-            {'name' => 'text'}
-          end
-
-          it { is_expected.to eq([]) }
-        end
-
-        context 'with element definition having nil as contents value' do
-          let(:element_definition) do
-            {
-              'name' => 'element',
-              'contents' => nil
-            }
-          end
-
-          it "returns empty array" do
-            is_expected.to eq([])
-          end
-        end
-
-        context 'with content settings tinymce set to true only' do
-          let(:element_definition) do
-            {
-              'name' => 'element',
-              'contents' => [
-                'name' => 'headline',
-                'settings' => {
-                  'tinymce' => true
-                }
-              ]
-            }
-          end
-
-          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

@@ -1,10 +0,0 @@
-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/alchemy/messages_spec.rb

@@ -1,21 +0,0 @@
-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/alchemy/attachment_spec.rb

@@ -1,250 +0,0 @@
-# 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
-
-      after { attachment.destroy }
-    end
-
-    describe 'urlname sanitizing' do
-      it "escapes unsafe url characters" do
-        attachment.file_name = 'f#%&cking cute kitten pic.png'
-        expect(attachment.urlname).to eq('f%23%25%26cking+cute+kitten+pic')
-      end
-
-      it "removes format suffix from end of file name" do
-        attachment.file_name = 'pic.png.png'
-        expect(attachment.urlname).to eq('pic+png')
-      end
-
-      it "converts dots into escaped spaces" do
-        attachment.file_name = 'cute.kitten.pic.png'
-        expect(attachment.urlname).to eq('cute+kitten+pic')
-      end
-
-      it "escapes umlauts in the name" do
-        attachment.file_name = 'süßes katzenbild.png'
-        expect(attachment.urlname).to eq('s%C3%BC%C3%9Fes+katzenbild')
-      end
-    end
-
-    describe 'validations' do
-      context "having a png, but only pdf allowed" do
-        before do
-          allow(Config).to receive(:get) do
-            {'allowed_filetypes' => {'alchemy/attachments' => ['pdf']}}
-          end
-        end
-
-        it "should not be valid" do
-          expect(attachment).not_to be_valid
-        end
-      end
-
-      context "having a png and everything allowed" do
-        before do
-          allow(Config).to receive(:get) do
-            {'allowed_filetypes' => {'alchemy/attachments' => ['*']}}
-          end
-        end
-
-        it "should be valid" do
-          expect(attachment).to be_valid
-        end
-      end
-
-      context "having a filename with special characters" do
-        before do
-           attachment.file_name = 'my FileNämü.pdf'
-           attachment.save
-        end
-
-        it "should be valid" do
-          expect(attachment).to be_valid
-        end
-      end
-
-      context "having a filename with unallowed character" do
-        before do
-          attachment.file_name = 'my FileNämü?!.pdf'
-          attachment.save
-        end
-
-        it "should not be valid" do
-          expect(attachment).not_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