alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/spec_helper.rb

@@ -1,90 +0,0 @@
-if ENV['TRAVIS']
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
-else
-  require 'simplecov'
-  SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
-  SimpleCov.start 'rails'
-end
-
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require File.expand_path("../dummy/config/environment.rb", __FILE__)
-require 'rspec/rails'
-require 'rails/test_help'
-require 'capybara/poltergeist'
-require 'capybara/rails'
-require 'database_cleaner'
-require 'rspec-activemodel-mocks'
-
-require 'alchemy/seeder'
-require 'alchemy/test_support/controller_requests'
-require 'alchemy/test_support/essence_shared_examples'
-require 'alchemy/test_support/integration_helpers'
-require 'alchemy/test_support/factories'
-
-require_relative 'factories'
-require_relative "support/hint_examples.rb"
-require_relative "support/transformation_examples.rb"
-
-ActionMailer::Base.delivery_method = :test
-ActionMailer::Base.perform_deliveries = true
-ActionMailer::Base.default_url_options[:host] = "test.com"
-
-Rails.backtrace_cleaner.remove_silencers!
-# Disable rails loggin for faster IO. Remove this if you want to have a test.log
-Rails.logger.level = 4
-
-# Configure capybara for integration testing
-Capybara.default_driver = :rack_test
-Capybara.default_selector = :css
-Capybara.register_driver :poltergeist do |app|
-  Capybara::Poltergeist::Driver.new(app)
-end
-Capybara.javascript_driver = :poltergeist
-Capybara.ignore_hidden_elements = false
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.raise_errors_for_deprecations!
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-  config.include ActiveSupport::Testing::TimeHelpers
-  config.include Alchemy::Engine.routes.url_helpers
-  config.include Alchemy::TestSupport::ControllerRequests, type: :controller
-  [:controller, :feature, :request].each do |type|
-    config.include Alchemy::TestSupport::IntegrationHelpers, type: type
-  end
-  config.include FactoryGirl::Syntax::Methods
-
-  config.use_transactional_fixtures = false
-  # Make sure the database is clean and ready for test
-  config.before(:suite) do
-    DatabaseCleaner.clean_with(:truncation)
-    Alchemy::Shell.silence!
-    Alchemy::Seeder.seed!
-  end
-
-  # All specs are running in transactions, but feature specs not.
-  config.before(:each) do |example|
-    Alchemy::Site.current = nil
-    ::I18n.locale = :en
-    if example.metadata[:type] == :feature
-      DatabaseCleaner.strategy = :truncation
-    else
-      DatabaseCleaner.strategy = :transaction
-    end
-    DatabaseCleaner.start
-  end
-
-  # After each spec the database gets cleaned. (via rollback or truncate for feature specs)
-  # After every feature spec the database gets seeded so the next spec can rely on that data.
-  config.append_after(:each) do
-    DatabaseCleaner.clean
-    if RSpec.current_example.metadata[:type] == :feature
-      allow(Alchemy::Seeder).to receive(:puts)
-      Alchemy::Seeder.seed!
-    end
-  end
-end

data/spec/support/ci/install_phantomjs

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-version=phantomjs-1.8.1-linux-i686
-cd
-wget http://phantomjs.googlecode.com/files/$version.tar.bz2
-tar xjf $version.tar.bz2
-mv $version phantomjs

data/spec/support/hint_examples.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  shared_examples_for "having a hint" do
-    describe '#hint' do
-      context 'with hint as text' do
-        before do
-          expect(subject).to receive(:definition).and_return({'hint' => 'The hint'})
-        end
-
-        it "returns the hint" do
-          expect(subject.hint).to eq('The hint')
-        end
-      end
-
-      context 'with hint set to true' do
-        before do
-          expect(subject).to receive(:definition).and_return({'hint' => true})
-          expect(Alchemy).to receive(:t).and_return('The hint')
-        end
-
-        it "returns the hint from translation" do
-          expect(subject.hint).to eq('The hint')
-        end
-      end
-    end
-  end
-end

data/spec/support/test_tweaks.rb

@@ -1,31 +0,0 @@
-# https://gist.github.com/mperham/3049152
-# Fixes Capybara database connection issues
-class ActiveRecord::Base
-  mattr_accessor :shared_connection
-  @@shared_connection = nil
-
-  def self.connection
-    @@shared_connection || ConnectionPool::Wrapper.new(size: 1) { retrieve_connection }
-  end
-end
-ActiveRecord::Base.shared_connection = ActiveRecord::Base.connection
-
-# fast truncation of all tables that need truncations (select is 10x faster then truncate)
-# http://grosser.it/2012/07/03/rubyactiverecord-fastest-way-to-truncate-test-database/
-def truncate_all_tables
-  config = ActiveRecord::Base.configurations[::Rails.env]
-  connection = ActiveRecord::Base.connection
-  connection.disable_referential_integrity do
-    connection.tables.each do |table_name|
-      next if connection.select_value("SELECT count(*) FROM #{table_name}") == 0
-      case config["adapter"]
-      when "mysql2", "postgresql"
-          connection.execute("TRUNCATE #{table_name}")
-      when "sqlite3"
-          connection.execute("DELETE FROM #{table_name}")
-          connection.execute("DELETE FROM sqlite_sequence where name='#{table_name}'")
-      end
-    end
-    connection.execute("VACUUM") if config["adapter"] == "sqlite3"
-  end
-end

data/spec/support/transformation_examples.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  shared_examples_for "has image transformations" do
-    describe "#thumbnail_size" do
-      context "picture is 300x400 and has no crop size" do
-        it "should return the correct recalculated size value" do
-          allow(picture).to receive(:image_file_width) { 400 }
-          allow(picture).to receive(:image_file_height) { 300 }
-
-          expect(picture.thumbnail_size).to eq('111x83')
-        end
-      end
-
-      context "picture is 300x400 and has no crop size" do
-        it "should return the correct recalculated size value" do
-          allow(picture).to receive(:image_file_width) { 300 }
-          allow(picture).to receive(:image_file_height) { 400 }
-
-          expect(picture.thumbnail_size).to eq('70x93')
-        end
-      end
-
-      context "picture has crop_size of 400x300" do
-        it "scales to 400x300 if that is the size of the cropped image" do
-          allow(picture).to receive(:crop_size) { "400x300" }
-          expect(picture.thumbnail_size).to eq('111x83')
-        end
-      end
-
-      context "picture has crop_size of 0x0" do
-        it "returns default thumbnail size" do
-          allow(picture).to receive(:crop_size) { "0x0" }
-          expect(picture.thumbnail_size).to eq('111x93')
-        end
-      end
-    end
-
-    describe '#landscape_format?' do
-      subject { picture.landscape_format? }
-
-      context 'image has landscape format' do
-        before { allow(picture).to receive(:image_file).and_return double(landscape?: true) }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'image has portrait format' do
-        before { allow(picture).to receive(:image_file).and_return double(landscape?: false) }
-
-        it { is_expected.to be_falsey }
-      end
-
-      it "is aliased as landscape?" do
-        expect(picture.respond_to?(:landscape?)).to be_truthy
-      end
-    end
-
-    describe '#portrait_format?' do
-      subject { picture.portrait_format? }
-
-      context 'image has portrait format' do
-        before { allow(picture).to receive(:image_file).and_return double(portrait?: true) }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'image has landscape format' do
-        before { allow(picture).to receive(:image_file).and_return double(portrait?: false) }
-
-        it { is_expected.to be_falsey }
-      end
-
-      it "is aliased as portrait?" do
-        expect(picture.respond_to?(:portrait?)).to be_truthy
-      end
-    end
-
-    describe '#square_format?' do
-      subject { picture.square_format? }
-
-      context 'image has square format' do
-        before { expect(picture).to receive(:image_file).and_return double(aspect_ratio: 1.0) }
-
-        it { is_expected.to be_truthy }
-      end
-
-      context 'image has rectangle format' do
-        before { expect(picture).to receive(:image_file).and_return double(aspect_ratio: 8.0) }
-
-        it { is_expected.to be_falsey }
-      end
-
-      it "is aliased as square?" do
-        expect(picture.respond_to?(:square?)).to be_truthy
-      end
-    end
-
-    describe '#default_mask' do
-      before do
-        allow(picture).to receive(:image_file_width) { 200 }
-        allow(picture).to receive(:image_file_height) { 100 }
-      end
-
-      it "should return a Hash" do
-        expect(picture.default_mask({ width: 10, height: 10 })).to be_a(Hash)
-      end
-
-      it "should return a Hash with four keys x1, x2, y1, y2" do
-        expect(picture.default_mask({ width: 10, height: 10 }).keys.sort).to eq([:x1, :x2, :y1, :y2])
-      end
-
-      it "should return a Hash where all values are Integer" do
-        expect(picture.default_mask({ width: 13, height: 13 }).all? do |_k, v|
-          v.is_a? Integer
-        end).to be_truthy
-      end
-
-      context "making a default cropping mask" do
-        it "to 200x50 pixel, the hash should be {x1: 0, y1: 25, x2: 200, y2: 75}" do
-          expect(picture.default_mask({ width: 200, height: 50 })).to eq({x1: 0, y1: 25, x2: 200, y2: 75})
-        end
-
-        it "to 0x0 pixel, it should not crop the picture" do
-          expect(picture.default_mask({ width: 0, height: 0 })).to eq({x1: 0, y1: 0, x2: 200, y2: 100})
-        end
-
-        it "to 50x100 pixel, the hash should be {x1: 75, y1: 0, x2: 125, y2: 100}" do
-          expect(picture.default_mask({ width: 50, height: 100 })).to eq({x1: 75, y1: 0, x2: 125, y2: 100})
-        end
-
-        it "to 50x50 pixel, the hash should be {x1: 50, y1: 0, x2: 150, y2: 100}" do
-          expect(picture.default_mask({ width: 50, height: 50 })).to eq({x1: 50, y1: 0, x2: 150, y2: 100})
-        end
-
-        it "to 400x200 pixel, the hash should be {x1: 0, y1: 0, x2: 200, y2: 100}" do
-          expect(picture.default_mask({ width: 400, height: 200 })).to eq({x1: 0, y1: 0, x2: 200, y2: 100})
-        end
-
-        it "to 400x100 pixel, the hash should be {x1: 0, y1: 25, x2: 200, y2: 75}" do
-          expect(picture.default_mask({ width: 400, height: 100 })).to eq({x1: 0, y1: 25, x2: 200, y2: 75})
-        end
-
-        it "to 200x200 pixel, the hash should be {x1: 50, y1: 0, x2: 150, y2: 100}" do
-          expect(picture.default_mask({ width: 200, height: 200 })).to eq({x1: 50, y1: 0, x2: 150, y2: 100})
-        end
-      end
-    end
-
-    describe "#can_be_cropped_to" do
-      context "picture is 300x400 and shall be cropped to 200x100" do
-        it "should return true" do
-          allow(picture).to receive(:image_file_width) { 400 }
-          allow(picture).to receive(:image_file_height) { 300 }
-
-          expect(picture.can_be_cropped_to("200x100")).to be_truthy
-        end
-      end
-
-      context "picture is 300x400 and shall be cropped to 600x500" do
-        it "should return false" do
-          allow(picture).to receive(:image_file_width) { 400 }
-          allow(picture).to receive(:image_file_height) { 300 }
-
-          expect(picture.can_be_cropped_to("600x500")).to be_falsey
-        end
-      end
-
-      context "picture is 300x400 and shall be cropped to 600x500 with upsample set to true" do
-        it "should return true" do
-          allow(picture).to receive(:image_file_width) { 400 }
-          allow(picture).to receive(:image_file_height) { 300 }
-
-          expect(picture.can_be_cropped_to("600x500", true)).to be_truthy
-        end
-      end
-    end
-  end
-end

data/spec/tasks/helpers_spec.rb

@@ -1,217 +0,0 @@
-require 'spec_helper'
-require 'alchemy/tasks/helpers'
-
-module Alchemy
-  class Foo
-    extend Tasks::Helpers
-  end
-
-  describe "Tasks:Helpers" do
-    let(:config) do
-      { 'test' => {
-          'adapter'  => 'mysql2',
-          'username' => 'testuser',
-          'password' => '123456',
-          'host'     => 'localhost'
-        }
-      }
-    end
-
-    before do
-      allow(File).to receive(:exist?) { true }
-      allow(File).to receive(:read) do
-<<-END
-test:
-  adapter: mysql2
-  username: testuser
-  password: "123456"
-  host: localhost
-END
-      end
-    end
-
-    describe "#database_dump_command" do
-      subject { Foo.database_dump_command(adapter) }
-
-      context "when config for RAILS_ENV not found" do
-        let(:adapter) { 'mysql2' }
-
-        before { allow(Foo).to receive(:environment).and_return('huh?') }
-
-        it "should raise an error" do
-          expect { subject }.to raise_error(RuntimeError)
-        end
-      end
-
-      context "when given a not supported database adapter" do
-        let(:adapter) { 'oracle' }
-
-        it "should raise an error" do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "for mysql adapter" do
-        let(:adapter) { 'mysql2' }
-
-        it "uses the mysqldump command" do
-          is_expected.to include('mysqldump ')
-        end
-
-        context "when a username is set in the config file" do
-          it { is_expected.to include("--user='testuser'") }
-        end
-
-        context "when a password is set in the config file" do
-          it { is_expected.to include("--password='123456'") }
-        end
-
-        context "when a host is set in the config file" do
-          context "and the host is localhost" do
-            it { is_expected.not_to include("--host=") }
-          end
-
-          context "and the host is anything but not localhost" do
-            before do
-              allow(File).to receive(:read).and_return("test:\n  host: mydomain.com")
-            end
-            it { is_expected.to include("--host='mydomain.com'") }
-          end
-        end
-      end
-
-      context "for postgresql adapter" do
-        let(:adapter) { 'postgresql' }
-
-        it "uses the pg_dump command with clean option" do
-          is_expected.to include('pg_dump --clean')
-        end
-
-        context "when a username is set in the config file" do
-          it { is_expected.to include("--username='testuser'") }
-        end
-
-        context "when a password is set in the config file" do
-          it { is_expected.to include("PGPASSWORD='123456'") }
-        end
-
-        context "when a host is set in the config file" do
-          context "and the host is localhost" do
-            it { is_expected.not_to include("--host=") }
-          end
-
-          context "and the host is anything but not localhost" do
-            before do
-              allow(File).to receive(:read).and_return("test:\n  host: mydomain.com")
-            end
-            it { is_expected.to include("--host='mydomain.com'") }
-          end
-        end
-      end
-
-      after do
-        Foo.instance_variable_set("@database_config", nil) # resets the memoization
-      end
-    end
-
-    describe "#database_import_command" do
-      subject { Foo.database_import_command(adapter) }
-
-      context "when config for RAILS_ENV not found" do
-        let(:adapter) { 'mysql' }
-
-        before { allow(Foo).to receive(:environment).and_return('huh?') }
-
-        it "should raise an error" do
-          expect { subject }.to raise_error(RuntimeError)
-        end
-      end
-
-      context "when given a not supported database adapter" do
-        let(:adapter) { 'oracle' }
-
-        it "should raise an error" do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "for mysql adapter" do
-        let(:adapter) { 'mysql' }
-
-        it "uses the mysql command" do
-          is_expected.to include('mysql ')
-        end
-
-        context "when a username is set in the config file" do
-          it { is_expected.to include("--user='testuser'") }
-        end
-
-        context "when a password is set in the config file" do
-          it { is_expected.to include("--password='123456'") }
-        end
-
-        context "when a host is set in the config file" do
-          context "and the host is localhost" do
-            it { is_expected.not_to include("--host=") }
-          end
-
-          context "and the host is anything but not localhost" do
-            before do
-              allow(File).to receive(:read).and_return("test:\n  host: mydomain.com")
-            end
-            it { is_expected.to include("--host='mydomain.com'") }
-          end
-        end
-      end
-
-      context "for postgresql adapter" do
-        let(:adapter) { 'postgresql' }
-
-        it "uses the psql command" do
-          is_expected.to include('psql ')
-        end
-
-        context "when a username is set in the config file" do
-          it { is_expected.to include("--username='testuser'") }
-        end
-
-        context "when a password is set in the config file" do
-          it { is_expected.to include("PGPASSWORD='123456'") }
-        end
-
-        context "when a host is set in the config file" do
-          context "and the host is localhost" do
-            it { is_expected.not_to include("--host=") }
-          end
-
-          context "and the host is anything but not localhost" do
-            before do
-              allow(File).to receive(:read).and_return("test:\n  host: mydomain.com")
-            end
-            it { is_expected.to include("--host='mydomain.com'") }
-          end
-        end
-      end
-
-      after do
-        Foo.instance_variable_set("@database_config", nil) # resets the memoization
-      end
-    end
-
-    describe "#database_config" do
-      it "should memoize the results" do
-        expect(Foo.database_config).to eq(config['test'])
-        config['username'] = 'newuser'
-        expect(Foo.database_config).to eq(config['test'])
-      end
-
-      context 'for missing database config file' do
-        before { allow(File).to receive(:exist?).and_return( false) }
-
-        it "raises error" do
-          expect { Foo.database_config }.to raise_error(RuntimeError)
-        end
-      end
-    end
-  end
-end