<%% end %>
<%% end %>
diff --git a/lib/rails/generators/alchemy/menus/templates/node.html.haml b/lib/generators/alchemy/menus/templates/node.html.haml
similarity index 71%
rename from lib/rails/generators/alchemy/menus/templates/node.html.haml
rename to lib/generators/alchemy/menus/templates/node.html.haml
index 555998f0cc..f186012dad 100644
--- a/lib/rails/generators/alchemy/menus/templates/node.html.haml
+++ b/lib/generators/alchemy/menus/templates/node.html.haml
@@ -10,7 +10,4 @@
rel: node.nofollow? ? 'nofollow' : nil
- if node.children.any?
%ul.dropdown-menu
- = render partial: options[:node_partial_name],
- collection: node.children.includes(:page, :children),
- locals: { options: options },
- as: 'node'
+ = render node.children.includes(:page, :children), as: 'node'
diff --git a/lib/rails/generators/alchemy/menus/templates/node.html.slim b/lib/generators/alchemy/menus/templates/node.html.slim
similarity index 70%
rename from lib/rails/generators/alchemy/menus/templates/node.html.slim
rename to lib/generators/alchemy/menus/templates/node.html.slim
index f7d6d3e166..b07bb2355f 100644
--- a/lib/rails/generators/alchemy/menus/templates/node.html.slim
+++ b/lib/generators/alchemy/menus/templates/node.html.slim
@@ -10,7 +10,4 @@
rel: node.nofollow? ? 'nofollow' : nil
- if node.children.any?
ul.dropdown-menu
- = render partial: options[:node_partial_name],
- collection: node.children.includes(:page, :children),
- locals: { options: options },
- as: 'node'
+ = render node.children.includes(:page, :children), as: 'node'
diff --git a/lib/rails/generators/alchemy/menus/templates/wrapper.html.erb b/lib/generators/alchemy/menus/templates/wrapper.html.erb
similarity index 76%
rename from lib/rails/generators/alchemy/menus/templates/wrapper.html.erb
rename to lib/generators/alchemy/menus/templates/wrapper.html.erb
index 5480e7055f..5d8767acba 100644
--- a/lib/rails/generators/alchemy/menus/templates/wrapper.html.erb
+++ b/lib/generators/alchemy/menus/templates/wrapper.html.erb
@@ -1,6 +1,6 @@
<%% cache menu do %>
- <%%= render partial: options[:node_partial_name],
+ <%%= render partial: menu.to_partial_path,
collection: menu.children.includes(:page, :children),
locals: { options: options },
as: 'node' %>
diff --git a/lib/rails/generators/alchemy/menus/templates/wrapper.html.haml b/lib/generators/alchemy/menus/templates/wrapper.html.haml
similarity index 73%
rename from lib/rails/generators/alchemy/menus/templates/wrapper.html.haml
rename to lib/generators/alchemy/menus/templates/wrapper.html.haml
index 62a9e09222..b4f4533630 100644
--- a/lib/rails/generators/alchemy/menus/templates/wrapper.html.haml
+++ b/lib/generators/alchemy/menus/templates/wrapper.html.haml
@@ -1,6 +1,6 @@
- cache menu do
%ul.nav
- = render partial: options[:node_partial_name],
+ = render partial: menu.to_partial_path,
collection: menu.children.includes(:page, :children),
locals: { options: options },
as: 'node'
diff --git a/lib/rails/generators/alchemy/menus/templates/wrapper.html.slim b/lib/generators/alchemy/menus/templates/wrapper.html.slim
similarity index 73%
rename from lib/rails/generators/alchemy/menus/templates/wrapper.html.slim
rename to lib/generators/alchemy/menus/templates/wrapper.html.slim
index 704b5b9ac4..83845288ff 100644
--- a/lib/rails/generators/alchemy/menus/templates/wrapper.html.slim
+++ b/lib/generators/alchemy/menus/templates/wrapper.html.slim
@@ -1,6 +1,6 @@
- cache menu do
ul.nav
- = render partial: options[:node_partial_name],
+ = render partial: menu.to_partial_path,
collection: menu.children.includes(:page, :children),
locals: { options: options },
as: 'node'
diff --git a/lib/rails/generators/alchemy/module/module_generator.rb b/lib/generators/alchemy/module/module_generator.rb
similarity index 92%
rename from lib/rails/generators/alchemy/module/module_generator.rb
rename to lib/generators/alchemy/module/module_generator.rb
index 7d6651b1c6..a2a08bcb16 100644
--- a/lib/rails/generators/alchemy/module/module_generator.rb
+++ b/lib/generators/alchemy/module/module_generator.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-require 'rails'
+require "rails"
module Alchemy
module Generators
class ModuleGenerator < ::Rails::Generators::Base
desc "This generator generates an Alchemy module for you."
argument :module_name, banner: "your_module_name"
- source_root File.expand_path('templates', __dir__)
+ source_root File.expand_path("templates", __dir__)
def init
@module_name = module_name.downcase
diff --git a/lib/rails/generators/alchemy/module/templates/ability.rb.tt b/lib/generators/alchemy/module/templates/ability.rb.tt
similarity index 100%
rename from lib/rails/generators/alchemy/module/templates/ability.rb.tt
rename to lib/generators/alchemy/module/templates/ability.rb.tt
diff --git a/lib/rails/generators/alchemy/module/templates/controller.rb.tt b/lib/generators/alchemy/module/templates/controller.rb.tt
similarity index 100%
rename from lib/rails/generators/alchemy/module/templates/controller.rb.tt
rename to lib/generators/alchemy/module/templates/controller.rb.tt
diff --git a/lib/rails/generators/alchemy/module/templates/module_config.rb.tt b/lib/generators/alchemy/module/templates/module_config.rb.tt
similarity index 100%
rename from lib/rails/generators/alchemy/module/templates/module_config.rb.tt
rename to lib/generators/alchemy/module/templates/module_config.rb.tt
diff --git a/lib/rails/generators/alchemy/page_layouts/page_layouts_generator.rb b/lib/generators/alchemy/page_layouts/page_layouts_generator.rb
similarity index 81%
rename from lib/rails/generators/alchemy/page_layouts/page_layouts_generator.rb
rename to lib/generators/alchemy/page_layouts/page_layouts_generator.rb
index 1ceb9ce2b1..d747a96c57 100644
--- a/lib/rails/generators/alchemy/page_layouts/page_layouts_generator.rb
+++ b/lib/generators/alchemy/page_layouts/page_layouts_generator.rb
@@ -1,14 +1,14 @@
# frozen_string_literal: true
-require_relative '../base'
+require_relative "../base"
module Alchemy
module Generators
class PageLayoutsGenerator < Base
desc "This generator generates your page_layouts view partials."
- source_root File.expand_path('templates', __dir__)
+ source_root File.expand_path("templates", __dir__)
def create_partials
- @page_layouts = load_alchemy_yaml('page_layouts.yml')
+ @page_layouts = load_alchemy_yaml("page_layouts.yml")
return unless @page_layouts
@page_layouts.each do |page_layout|
diff --git a/lib/rails/generators/alchemy/page_layouts/templates/layout.html.erb b/lib/generators/alchemy/page_layouts/templates/layout.html.erb
similarity index 100%
rename from lib/rails/generators/alchemy/page_layouts/templates/layout.html.erb
rename to lib/generators/alchemy/page_layouts/templates/layout.html.erb
diff --git a/lib/rails/generators/alchemy/page_layouts/templates/layout.html.haml b/lib/generators/alchemy/page_layouts/templates/layout.html.haml
similarity index 100%
rename from lib/rails/generators/alchemy/page_layouts/templates/layout.html.haml
rename to lib/generators/alchemy/page_layouts/templates/layout.html.haml
diff --git a/lib/rails/generators/alchemy/page_layouts/templates/layout.html.slim b/lib/generators/alchemy/page_layouts/templates/layout.html.slim
similarity index 100%
rename from lib/rails/generators/alchemy/page_layouts/templates/layout.html.slim
rename to lib/generators/alchemy/page_layouts/templates/layout.html.slim
diff --git a/lib/rails/generators/alchemy/site_layouts/site_layouts_generator.rb b/lib/generators/alchemy/site_layouts/site_layouts_generator.rb
similarity index 88%
rename from lib/rails/generators/alchemy/site_layouts/site_layouts_generator.rb
rename to lib/generators/alchemy/site_layouts/site_layouts_generator.rb
index aba495be9d..0cf8f8d2a4 100644
--- a/lib/rails/generators/alchemy/site_layouts/site_layouts_generator.rb
+++ b/lib/generators/alchemy/site_layouts/site_layouts_generator.rb
@@ -1,11 +1,11 @@
# frozen_string_literal: true
-require_relative '../base'
+require_relative "../base"
module Alchemy
module Generators
class SiteLayoutsGenerator < Base
desc "This generator generates your site layouts view partials."
- source_root File.expand_path('templates', __dir__)
+ source_root File.expand_path("templates", __dir__)
def create_partials
@sites = Alchemy::Site.all
diff --git a/lib/rails/generators/alchemy/site_layouts/templates/layout.html.erb b/lib/generators/alchemy/site_layouts/templates/layout.html.erb
similarity index 100%
rename from lib/rails/generators/alchemy/site_layouts/templates/layout.html.erb
rename to lib/generators/alchemy/site_layouts/templates/layout.html.erb
diff --git a/lib/rails/generators/alchemy/site_layouts/templates/layout.html.haml b/lib/generators/alchemy/site_layouts/templates/layout.html.haml
similarity index 100%
rename from lib/rails/generators/alchemy/site_layouts/templates/layout.html.haml
rename to lib/generators/alchemy/site_layouts/templates/layout.html.haml
diff --git a/lib/rails/generators/alchemy/site_layouts/templates/layout.html.slim b/lib/generators/alchemy/site_layouts/templates/layout.html.slim
similarity index 100%
rename from lib/rails/generators/alchemy/site_layouts/templates/layout.html.slim
rename to lib/generators/alchemy/site_layouts/templates/layout.html.slim
diff --git a/lib/rails/generators/alchemy/views/views_generator.rb b/lib/generators/alchemy/views/views_generator.rb
similarity index 77%
rename from lib/rails/generators/alchemy/views/views_generator.rb
rename to lib/generators/alchemy/views/views_generator.rb
index a9750a87ef..edb7952008 100644
--- a/lib/rails/generators/alchemy/views/views_generator.rb
+++ b/lib/generators/alchemy/views/views_generator.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: true
-require 'rails'
+require "rails"
module Alchemy
module Generators
@@ -22,17 +22,17 @@ class ViewsGenerator < ::Rails::Generators::Base
def copy_alchemy_views
views_to_copy.each do |dir|
- directory dir, Rails.root.join('app/views/alchemy', dir)
+ directory dir, Rails.root.join("app/views/alchemy", dir)
end
end
private
def views_to_copy
- if @options['except']
- ALCHEMY_VIEWS - @options['except']
- elsif @options['only']
- ALCHEMY_VIEWS.select { |v| @options['only'].include?(v) }
+ if @options["except"]
+ ALCHEMY_VIEWS - @options["except"]
+ elsif @options["only"]
+ ALCHEMY_VIEWS.select { |v| @options["only"].include?(v) }
else
ALCHEMY_VIEWS
end
diff --git a/lib/rails/generators/alchemy/install/install_generator.rb b/lib/rails/generators/alchemy/install/install_generator.rb
deleted file mode 100644
index 17598238ca..0000000000
--- a/lib/rails/generators/alchemy/install/install_generator.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-require 'rails'
-
-module Alchemy
- module Generators
- class InstallGenerator < ::Rails::Generators::Base
- desc "Installs Alchemy into your App."
-
- class_option :skip_demo_files,
- type: :boolean,
- default: false,
- desc: "Skip creation of demo element, page and application layout."
-
- source_root File.expand_path('files', __dir__)
-
- def copy_config
- copy_file "#{config_path}/config.yml", "config/alchemy/config.yml"
- end
-
- def copy_yml_files
- %w(elements page_layouts menus).each do |file|
- template "#{__dir__}/templates/#{file}.yml.tt", "config/alchemy/#{file}.yml"
- end
- end
-
- def install_assets
- copy_file "all.js", "vendor/assets/javascripts/alchemy/admin/all.js"
- copy_file "all.css", "vendor/assets/stylesheets/alchemy/admin/all.css"
- end
-
- def copy_demo_views
- return if @options[:skip_demo_files]
-
- copy_file "application.html.erb", "app/views/layouts/application.html.erb"
- copy_file "article.scss", "app/assets/stylesheets/alchemy/elements/article.scss"
-
- stylesheet_require = " *= require_tree ./alchemy/elements\n"
- if File.exist?("app/assets/stylesheets/application.css")
- insert_into_file "app/assets/stylesheets/application.css", stylesheet_require,
- before: " */"
- else
- create_file "app/assets/stylesheets/application.css", "/*\n#{stylesheet_require} */\n"
- end
-
- copy_file "_article.html.erb", "app/views/alchemy/elements/_article.html.erb"
- copy_file "_standard.html.erb", "app/views/alchemy/page_layouts/_standard.html.erb"
- copy_file "alchemy.en.yml", "config/locales/alchemy.en.yml"
- end
-
- def copy_dragonfly_config
- template "#{__dir__}/templates/dragonfly.rb.tt", "config/initializers/dragonfly.rb"
- end
-
- def install_gutentag_migrations
- rake 'gutentag:install:migrations'
- end
-
- private
-
- def config_path
- @_config_path ||= File.expand_path('../../../../../config/alchemy', __dir__)
- end
- end
- end
-end
diff --git a/lib/tasks/alchemy/convert.rake b/lib/tasks/alchemy/convert.rake
deleted file mode 100644
index 2ae48e28e6..0000000000
--- a/lib/tasks/alchemy/convert.rake
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-namespace :alchemy do
- namespace :convert do
- namespace :urlnames do
- desc "Converts the urlname of all pages to nested url paths."
- task to_nested: [:environment] do
- unless Alchemy::Config.get(:url_nesting)
- raise "\nURL nesting is disabled! Please enable url_nesting in `config/alchemy/config.yml` first.\n\n"
- end
-
- puts "Converting..."
- pages = Alchemy::Page.contentpages
- count = pages.count
- pages.each_with_index do |page, n|
- puts "Updating page #{n + 1} of #{count}"
- page.update_urlname!
- end
- puts "Done."
- end
-
- desc "Converts the urlname of all pages to contain the slug only."
- task to_slug: [:environment] do
- if Alchemy::Config.get(:url_nesting)
- raise "\nURL nesting is enabled! Please disable url_nesting in `config/alchemy/config.yml` first.\n\n"
- end
-
- puts "Converting..."
- pages = Alchemy::Page.contentpages
- count = pages.count
- pages.each_with_index do |page, n|
- puts "Updating page #{n + 1} of #{count}"
- page.update_attribute :urlname, page.slug
- end
- puts "Done."
- end
- end
- end
-end
diff --git a/lib/tasks/alchemy/db.rake b/lib/tasks/alchemy/db.rake
index 3dab98e15a..d5c2b07af7 100644
--- a/lib/tasks/alchemy/db.rake
+++ b/lib/tasks/alchemy/db.rake
@@ -1,10 +1,9 @@
# frozen_string_literal: true
-require 'alchemy/seeder'
+require "alchemy/seeder"
namespace :alchemy do
namespace :db do
-
desc "Seeds the database with Alchemy defaults"
task seed: [:environment] do
Alchemy::Seeder.seed!
diff --git a/lib/tasks/alchemy/install.rake b/lib/tasks/alchemy/install.rake
index 27fd3d62ff..c84a2433cd 100644
--- a/lib/tasks/alchemy/install.rake
+++ b/lib/tasks/alchemy/install.rake
@@ -1,5 +1,5 @@
# frozen_string_literal: true
-require 'thor'
+require "thor"
class Alchemy::InstallTask < Thor
include Thor::Actions
@@ -30,7 +30,7 @@ end
namespace :alchemy do
desc "Installs Alchemy CMS into your app."
- task :install do
+ task install: "alchemy:yarn:install" do
install_helper = Alchemy::InstallTask.new
puts "\nAlchemy Installer"
diff --git a/lib/tasks/alchemy/tidy.rake b/lib/tasks/alchemy/tidy.rake
index 856ab588f4..29b390d026 100644
--- a/lib/tasks/alchemy/tidy.rake
+++ b/lib/tasks/alchemy/tidy.rake
@@ -1,13 +1,13 @@
# frozen_string_literal: true
-require 'alchemy/tasks/tidy'
+require "alchemy/tasks/tidy"
namespace :alchemy do
namespace :tidy do
desc "Tidy up Alchemy database."
task :up do
- Rake::Task['alchemy:tidy:element_positions'].invoke
- Rake::Task['alchemy:tidy:content_positions'].invoke
- Rake::Task['alchemy:tidy:remove_orphaned_records'].invoke
+ Rake::Task["alchemy:tidy:element_positions"].invoke
+ Rake::Task["alchemy:tidy:content_positions"].invoke
+ Rake::Task["alchemy:tidy:remove_orphaned_records"].invoke
end
desc "Fixes element positions."
@@ -22,8 +22,8 @@ namespace :alchemy do
desc "Remove orphaned records (elements & contents)."
task remove_orphaned_records: [:environment] do
- Rake::Task['alchemy:tidy:remove_orphaned_elements'].invoke
- Rake::Task['alchemy:tidy:remove_orphaned_contents'].invoke
+ Rake::Task["alchemy:tidy:remove_orphaned_elements"].invoke
+ Rake::Task["alchemy:tidy:remove_orphaned_contents"].invoke
end
desc "Remove orphaned elements."
@@ -40,7 +40,7 @@ namespace :alchemy do
task elements_usage: :environment do
puts "\n"
removable_elements = []
- names = Alchemy::Element.definitions.map { |e| e['name'] }
+ names = Alchemy::Element.definitions.map { |e| e["name"] }
longest_name = names.max_by { |name| name.to_s.length }.length + 1
names.sort.each do |name|
names = Alchemy::Element.where(name: name)
@@ -49,7 +49,7 @@ namespace :alchemy do
if count.zero?
removable_elements.push(name)
else
- spacer = ' ' * (longest_name - name.length)
+ spacer = " " * (longest_name - name.length)
puts "#{name}#{spacer}is used\t#{count}\ttime(s) on\t#{page_count}\tpublic page(s)"
end
end
diff --git a/lib/tasks/alchemy/upgrade.rake b/lib/tasks/alchemy/upgrade.rake
index ccf58bed5e..45c134dcc8 100644
--- a/lib/tasks/alchemy/upgrade.rake
+++ b/lib/tasks/alchemy/upgrade.rake
@@ -1,28 +1,27 @@
# frozen_string_literal: true
-require 'alchemy/upgrader'
-require 'alchemy/version'
+require "alchemy/upgrader"
+require "alchemy/version"
namespace :alchemy do
desc "Upgrades your app to AlchemyCMS v#{Alchemy::VERSION}."
task upgrade: [
- 'alchemy:upgrade:prepare'
+ "alchemy:upgrade:prepare",
+ "alchemy:upgrade:5.0:run",
] do
Alchemy::Upgrader.display_todos
end
namespace :upgrade do
- desc 'Alchemy Upgrader: Prepares the database and updates Alchemys configuration file.'
+ desc "Alchemy Upgrader: Prepares the database and updates Alchemys configuration file."
task prepare: [
- 'alchemy:upgrade:database',
- 'alchemy:upgrade:config'
+ "alchemy:upgrade:database",
+ "alchemy:upgrade:config",
]
desc "Alchemy Upgrader: Prepares the database."
task database: [
- 'alchemy:upgrade:5.0:install_gutentag_migrations',
- 'alchemy:install:migrations',
- 'db:migrate',
- 'alchemy:db:seed'
+ "alchemy:install:migrations",
+ "db:migrate",
]
desc "Alchemy Upgrader: Copy configuration file."
@@ -30,18 +29,35 @@ namespace :alchemy do
Alchemy::Upgrader.copy_new_config_file
end
- desc 'Upgrade Alchemy to v5.0'
- task '5.0' => [
- 'alchemy:upgrade:prepare'
+ desc "Upgrade Alchemy to v5.0"
+ task "5.0" => [
+ "alchemy:upgrade:prepare",
+ "alchemy:upgrade:5.0:run",
] do
Alchemy::Upgrader.display_todos
end
- namespace '5.0' do
- desc 'Install Gutentag migrations'
+ namespace "5.0" do
+ task "run" => [
+ "alchemy:upgrade:5.0:install_gutentag_migrations",
+ "alchemy:upgrade:5.0:remove_layout_roots",
+ "alchemy:upgrade:5.0:remove_root_page",
+ ]
+
+ desc "Install Gutentag migrations"
task install_gutentag_migrations: [:environment] do
Alchemy::Upgrader::FivePointZero.install_gutentag_migrations
end
+
+ desc "Remove layout root pages"
+ task remove_layout_roots: [:environment] do
+ Alchemy::Upgrader::FivePointZero.remove_layout_roots
+ end
+
+ desc "Remove root page"
+ task remove_root_page: [:environment] do
+ Alchemy::Upgrader::FivePointZero.remove_root_page
+ end
end
end
end
diff --git a/package.json b/package.json
new file mode 100644
index 0000000000..c5150b560e
--- /dev/null
+++ b/package.json
@@ -0,0 +1,45 @@
+{
+ "name": "@alchemy_cms/admin",
+ "version": "0.2.0",
+ "description": "AlchemyCMS",
+ "browser": "package/admin.js",
+ "files": [
+ "package/**/*"
+ ],
+ "directories": {
+ "lib": "package"
+ },
+ "scripts": {
+ "test": "jest"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/AlchemyCMS/alchemy_cms.git"
+ },
+ "keywords": [],
+ "author": "Thomas von Deyen",
+ "license": "BSD-3-Clause",
+ "bugs": {
+ "url": "https://github.com/AlchemyCMS/alchemy_cms/issues"
+ },
+ "homepage": "https://github.com/AlchemyCMS/alchemy_cms#readme",
+ "dependencies": {
+ "sortablejs": "^1.10.2"
+ },
+ "devDependencies": {
+ "@babel/core": "^7.9.6",
+ "@babel/preset-env": "^7.9.6",
+ "babel-jest": "^26.0.1",
+ "jest": "^25.2.7",
+ "prettier": "^2.0.2",
+ "xhr-mock": "^2.5.1"
+ },
+ "jest": {
+ "globals": {
+ "Alchemy": {}
+ },
+ "roots": [
+ "package"
+ ]
+ }
+}
diff --git a/package/admin.js b/package/admin.js
new file mode 100644
index 0000000000..ac4cdad839
--- /dev/null
+++ b/package/admin.js
@@ -0,0 +1,14 @@
+import translate from "./src/i18n"
+import NodeTree from "./src/node_tree"
+
+// Global Alchemy object
+if (typeof window.Alchemy === "undefined") {
+ window.Alchemy = {}
+}
+
+// Enhance the global Alchemy object with imported features
+Object.assign(Alchemy, {
+ // Global utility method for translating a given string
+ t: translate,
+ NodeTree
+})
diff --git a/package/src/__tests__/i18n.spec.js b/package/src/__tests__/i18n.spec.js
new file mode 100644
index 0000000000..0f2ffbbeae
--- /dev/null
+++ b/package/src/__tests__/i18n.spec.js
@@ -0,0 +1,70 @@
+import translate from "../i18n"
+
+describe("translate", () => {
+ describe("if Alchemy.locale is not set", () => {
+ it("Throws an error", () => {
+ expect(() => {
+ translate("help")
+ }).toThrow("Alchemy.locale is not set")
+ })
+ })
+
+ describe("if Alchemy.locale is set to a known locale", () => {
+ beforeEach(() => {
+ Alchemy.locale = "en"
+ })
+
+ describe("if translation is present", () => {
+ it("Returns translated string", () => {
+ expect(translate("help")).toEqual("Help")
+ })
+
+ describe("if key includes a period", () => {
+ describe("that is translated", () => {
+ it("splits into group", () => {
+ expect(translate("formats.date")).toEqual("Y-m-d")
+ })
+ })
+
+ describe("that is not translated", () => {
+ it("returns key", () => {
+ expect(translate("formats.lala")).toEqual("formats.lala")
+ })
+ })
+
+ describe("that has unknown group", () => {
+ it("returns key", () => {
+ expect(translate("foo.bar")).toEqual("foo.bar")
+ })
+ })
+ })
+
+ describe("if replacement is given", () => {
+ it("replaces it", () => {
+ expect(translate("allowed_chars", 5)).toEqual("of 5 chars")
+ })
+ })
+ })
+
+ describe("if translation is not present", () => {
+ it("Returns passed string", () => {
+ expect(translate("foo")).toEqual("foo")
+ })
+ })
+ })
+
+ describe("if Alchemy.locale is set to a unknown locale", () => {
+ beforeEach(() => {
+ Alchemy.locale = "kl"
+ })
+
+ it("Returns passed string and logs a warning", () => {
+ const spy = jest.spyOn(console, "warn").mockImplementation(() => {})
+ expect(translate("help")).toEqual("help")
+ expect(spy.mock.calls).toEqual([
+ ["Translations for locale kl not found!"]
+ ])
+ spy.mockRestore()
+ })
+ })
+})
diff --git a/package/src/i18n.js b/package/src/i18n.js
new file mode 100644
index 0000000000..a96bca74cb
--- /dev/null
+++ b/package/src/i18n.js
@@ -0,0 +1,48 @@
+import translationData from "./translations"
+
+const KEY_SEPARATOR = /\./
+
+function currentLocale() {
+ if (Alchemy.locale == null) {
+ throw "Alchemy.locale is not set! Please set Alchemy.locale to a locale string in order to translate something."
+ }
+ return Alchemy.locale
+}
+
+function getTranslations() {
+ const locale = currentLocale()
+ const translations = translationData[locale]
+
+ if (translations) {
+ return translations
+ }
+ console.warn(`Translations for locale ${locale} not found!`)
+ return {}
+}
+
+function nestedTranslation(translations, key) {
+ const keys = key.split(KEY_SEPARATOR)
+ const group = translations[keys[0]]
+ if (group) {
+ return group[keys[1]] || key
+ }
+ return key
+}
+
+function getTranslation(key) {
+ const translations = getTranslations()
+
+ if (KEY_SEPARATOR.test(key)) {
+ return nestedTranslation(translations, key)
+ }
+ return translations[key] || key
+}
+
+export default function translate(key, replacement) {
+ let translation = getTranslation(key)
+
+ if (replacement) {
+ return translation.replace(/%\{.+\}/, replacement)
+ }
+ return translation
+}
diff --git a/package/src/node_tree.js b/package/src/node_tree.js
new file mode 100644
index 0000000000..f44447c9cf
--- /dev/null
+++ b/package/src/node_tree.js
@@ -0,0 +1,72 @@
+import Sortable from "sortablejs"
+import ajax from "./utils/ajax"
+import { on } from "./utils/events"
+
+function displayNodeFolders() {
+ document.querySelectorAll("li.menu-item").forEach((el) => {
+ const leftIconArea = el.querySelector(".nodes_tree-left_images")
+ const list = el.querySelector(".children")
+ const node = { folded: el.dataset.folded === "true", id: el.dataset.id }
+
+ if (list.children.length > 0 || node.folded) {
+ leftIconArea.innerHTML = HandlebarsTemplates.node_folder({ node: node })
+ } else {
+ leftIconArea.innerHTML = " "
+ }
+ })
+}
+
+function onFinishDragging(evt) {
+ const url = Alchemy.routes.move_api_node_path(evt.item.dataset.id)
+ const data = {
+ target_parent_id: evt.to.dataset.nodeId,
+ new_position: evt.newIndex
+ }
+
+ ajax("PATCH", url, data)
+ .then(() => {
+ const message = Alchemy.t("Successfully moved menu item")
+ Alchemy.growl(message)
+ displayNodeFolders()
+ })
+ .catch((error) => {
+ Alchemy.growl(error.message || error, "error")
+ })
+}
+
+function handleNodeFolders() {
+ on("click", ".nodes_tree", ".node_folder", function () {
+ const nodeId = this.dataset.nodeId
+ const menu_item = this.closest("li.menu-item")
+ const url = Alchemy.routes.toggle_folded_api_node_path(nodeId)
+ const list = menu_item.querySelector(".children")
+
+ ajax("PATCH", url)
+ .then(() => {
+ list.classList.toggle("folded")
+ menu_item.dataset.folded =
+ menu_item.dataset.folded == "true" ? "false" : "true"
+ displayNodeFolders()
+ })
+ .catch((error) => {
+ Alchemy.growl(error.message || error)
+ })
+ })
+}
+
+export default function NodeTree() {
+ handleNodeFolders()
+ displayNodeFolders()
+
+ document.querySelectorAll(".nodes_tree ul.children").forEach((el) => {
+ new Sortable(el, {
+ group: "nodes",
+ animation: 150,
+ fallbackOnBody: true,
+ swapThreshold: 0.65,
+ handle: ".node_name",
+ invertSwap: true,
+ onEnd: onFinishDragging
+ })
+ })
+}
diff --git a/package/src/translations.js b/package/src/translations.js
new file mode 100644
index 0000000000..602e29fee7
--- /dev/null
+++ b/package/src/translations.js
@@ -0,0 +1,32 @@
+const translations = {
+ en: {
+ allowed_chars: "of %{count} chars",
+ cancel: "Cancel",
+ cancelled: "Cancelled",
+ click_to_edit: "click to edit",
+ complete: "Complete",
+ element_dirty_notice:
+ "This element has unsaved changes. Do you really want to fold it?",
+ help: "Help",
+ ok: "Ok",
+ page_dirty_notice:
+ "You have unsaved changes on this page. They will be lost if you continue.",
+ page_found: "Page found",
+ pages_found: "Pages found",
+ url_validation_failed: "The url has no valid format.",
+ warning: "Warning!",
+ "File is too large": "File is too large",
+ "File is too small": "File is too small",
+ "File type not allowed": "File type not allowed",
+ "Maximum number of files exceeded": "Maximum number of files exceeded.",
+ "Uploaded bytes exceed file size": "Uploaded bytes exceed file size",
+ formats: {
+ datetime: "Y-m-d H:i",
+ date: "Y-m-d",
+ time: "H:i",
+ time_24hr: false
+ }
+ }
+}
+
+export default translations
diff --git a/package/src/utils/__tests__/ajax.spec.js b/package/src/utils/__tests__/ajax.spec.js
new file mode 100644
index 0000000000..52f3077e0b
--- /dev/null
+++ b/package/src/utils/__tests__/ajax.spec.js
@@ -0,0 +1,124 @@
+import xhrMock from "xhr-mock"
+import ajax from "../ajax"
+
+const token = "s3cr3t"
+
+beforeEach(() => {
+ document.head.innerHTML = ``
+ xhrMock.setup()
+})
+
+describe("ajax('get')", () => {
+ it("sends X-CSRF-TOKEN header", async () => {
+ xhrMock.get("/users", (req, res) => {
+ expect(req.header("X-CSRF-TOKEN")).toEqual(token)
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("get", "/users")
+ })
+
+ it("sends Content-Type header", async () => {
+ xhrMock.get("/users", (req, res) => {
+ expect(req.header("Content-Type")).toEqual(
+ "application/json; charset=utf-8"
+ )
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("get", "/users")
+ })
+
+ it("sends Accept header", async () => {
+ xhrMock.get("/users", (req, res) => {
+ expect(req.header("Accept")).toEqual("application/json")
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("get", "/users")
+ })
+
+ it("returns JSON", async () => {
+ xhrMock.get("/users", (_req, res) => {
+ return res.status(200).body('{"email":"mail@example.com"}')
+ })
+ await ajax("get", "/users").then((res) => {
+ expect(res.data).toEqual({ email: "mail@example.com" })
+ })
+ })
+
+ it("JSON parse errors get rejected", async () => {
+ xhrMock.get("/users", (_req, res) => {
+ return res.status(200).body('email => "mail@example.com"')
+ })
+ expect.assertions(1)
+ await ajax("get", "/users").catch((e) => {
+ expect(e.message).toMatch("Unexpected token")
+ })
+ })
+
+ it("network errors get rejected", async () => {
+ xhrMock.get("/users", () => {
+ return Promise.reject(new Error())
+ })
+ expect.assertions(1)
+ await ajax("get", "/users").catch((e) => {
+ expect(e.message).toEqual("An error occurred during the transaction")
+ })
+ })
+
+ it("server errors get rejected", async () => {
+ xhrMock.get("/users", (_req, res) => {
+ return res.status(401).body('{"error":"Unauthorized"}')
+ })
+ expect.assertions(1)
+ await ajax("get", "/users").catch((e) => {
+ expect(e.error).toEqual("Unauthorized")
+ })
+ })
+
+ it("server errors parsing errors get rejected", async () => {
+ xhrMock.get("/users", (_req, res) => {
+ return res.status(401).body("Unauthorized")
+ })
+ expect.assertions(1)
+ await ajax("get", "/users").catch((e) => {
+ expect(e.message).toMatch("Unexpected token")
+ })
+ })
+})
+
+describe("ajax('post')", () => {
+ it("sends X-CSRF-TOKEN header", async () => {
+ xhrMock.post("/users", (req, res) => {
+ expect(req.header("X-CSRF-TOKEN")).toEqual(token)
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("post", "/users")
+ })
+
+ it("sends Content-Type header", async () => {
+ xhrMock.post("/users", (req, res) => {
+ expect(req.header("Content-Type")).toEqual(
+ "application/json; charset=utf-8"
+ )
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("post", "/users")
+ })
+
+ it("sends Accept header", async () => {
+ xhrMock.post("/users", (req, res) => {
+ expect(req.header("Accept")).toEqual("application/json")
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("post", "/users")
+ })
+
+ it("sends JSON data", async () => {
+ xhrMock.post("/users", (req, res) => {
+ expect(req.body()).toEqual('{"email":"mail@example.com"}')
+ return res.status(200).body('{"message":"Ok"}')
+ })
+ await ajax("post", "/users", { email: "mail@example.com" })
+ })
+})
+
+afterEach(() => xhrMock.teardown())
diff --git a/package/src/utils/__tests__/events.spec.js b/package/src/utils/__tests__/events.spec.js
new file mode 100644
index 0000000000..e9b56634eb
--- /dev/null
+++ b/package/src/utils/__tests__/events.spec.js
@@ -0,0 +1,38 @@
+import { on } from "../events"
+
+describe("on", () => {
+ const callback = jest.fn()
+
+ beforeEach(() => {
+ document.body.innerHTML = `
+
+
One
+
Two
+
+ `
+ })
+
+ it("adds event listener to base node", () => {
+ const baseNode = document.querySelector(".list")
+ const spy = jest.spyOn(baseNode, "addEventListener")
+ on("click", ".list", ".item", callback)
+ expect(spy).toHaveBeenCalledWith("click", expect.any(Function))
+ spy.mockReset()
+ })
+
+ it("event triggered on matching child node calls callback", () => {
+ const childNode = document.querySelector(".first.item")
+ on("click", ".list", ".item", callback)
+ childNode.click()
+ expect(callback).toHaveBeenCalledWith(expect.any(MouseEvent))
+ })
+
+ it("event triggered on child of registered target still calls callback", () => {
+ const child = document.querySelector(".first.item span")
+ on("click", ".list", ".item", callback)
+ child.click()
+ expect(callback).toHaveBeenCalledWith(expect.any(MouseEvent))
+ })
+
+ afterEach(() => callback.mockReset())
+})
diff --git a/package/src/utils/ajax.js b/package/src/utils/ajax.js
new file mode 100644
index 0000000000..3266a7a4ad
--- /dev/null
+++ b/package/src/utils/ajax.js
@@ -0,0 +1,48 @@
+function buildPromise(xhr) {
+ return new Promise((resolve, reject) => {
+ xhr.onload = () => {
+ if (xhr.status >= 200 && xhr.status < 400) {
+ try {
+ resolve({
+ data: JSON.parse(xhr.responseText),
+ status: xhr.status
+ })
+ } catch (error) {
+ reject(error)
+ }
+ } else {
+ try {
+ reject(JSON.parse(xhr.responseText))
+ } catch (error) {
+ reject(error)
+ }
+ }
+ }
+ xhr.onerror = () => {
+ reject(new Error("An error occurred during the transaction"))
+ }
+ })
+}
+
+function getToken() {
+ const metaTag = document.querySelector('meta[name="csrf-token"]')
+ return metaTag.attributes.content.textContent
+}
+
+export default function ajax(method, url, data) {
+ const xhr = new XMLHttpRequest()
+ const promise = buildPromise(xhr)
+
+ xhr.open(method, url)
+ xhr.setRequestHeader("Content-type", "application/json; charset=utf-8")
+ xhr.setRequestHeader("Accept", "application/json")
+ xhr.setRequestHeader("X-CSRF-Token", getToken())
+
+ if (data) {
+ xhr.send(JSON.stringify(data))
+ } else {
+ xhr.send()
+ }
+
+ return promise
+}
diff --git a/package/src/utils/events.js b/package/src/utils/events.js
new file mode 100644
index 0000000000..8d085ae993
--- /dev/null
+++ b/package/src/utils/events.js
@@ -0,0 +1,16 @@
+export function on(eventName, baseSelector, targetSelector, callback) {
+ document.querySelectorAll(baseSelector).forEach((baseNode) => {
+ baseNode.addEventListener(eventName, (evt) => {
+ const targets = Array.from(baseNode.querySelectorAll(targetSelector))
+ let currentNode = evt.target
+
+ while (currentNode !== baseNode) {
+ if (targets.includes(currentNode)) {
+ callback.call(currentNode, evt)
+ return
+ }
+ currentNode = currentNode.parentElement
+ }
+ })
+ })
+}
diff --git a/spec/controllers/alchemy/admin/attachments_controller_spec.rb b/spec/controllers/alchemy/admin/attachments_controller_spec.rb
index 8ec06a7697..3a6a697cd1 100644
--- a/spec/controllers/alchemy/admin/attachments_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/attachments_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::AttachmentsController do
@@ -10,8 +10,8 @@ module Alchemy
let(:file) do
fixture_file_upload(
- File.expand_path('../../../fixtures/500x500.png', __dir__),
- 'image/png'
+ File.expand_path("../../../fixtures/500x500.png", __dir__),
+ "image/png",
)
end
@@ -28,7 +28,7 @@ module Alchemy
context "when params[:tagged_with] is set" do
it "should filter the records by tags" do
expect(Attachment).to receive(:tagged_with).and_return(Attachment.all)
- get :index, params: {tagged_with: "pdf"}
+ get :index, params: { tagged_with: "pdf" }
end
end
@@ -38,8 +38,8 @@ module Alchemy
context "is set" do
it "it renders the archive_overlay partial" do
expect(Content).to receive(:find_by).and_return(content)
- get :index, params: {content_id: content.id}
- expect(response).to render_template(partial: '_archive_overlay')
+ get :index, params: { content_id: content.id }
+ expect(response).to render_template(partial: "_archive_overlay")
expect(assigns(:content)).to eq(content)
end
end
@@ -52,17 +52,17 @@ module Alchemy
end
end
- describe 'file_type filter' do
+ describe "file_type filter" do
let!(:png) { create(:alchemy_attachment) }
let!(:jpg) do
create :alchemy_attachment,
- file: File.new(File.expand_path('../../../fixtures/image3.jpeg', __dir__))
+ file: File.new(File.expand_path("../../../fixtures/image3.jpeg", __dir__))
end
- context 'with params[:file_type]' do
- it 'loads only attachments with matching content type' do
- get :index, params: {file_type: 'image/jpeg'}
+ context "with params[:file_type]" do
+ it "loads only attachments with matching content type" do
+ get :index, params: { file_type: "image/jpeg" }
expect(assigns(:attachments).to_a).to eq([jpg])
expect(assigns(:attachments).to_a).to_not eq([png])
end
@@ -70,46 +70,46 @@ module Alchemy
end
end
- describe '#show' do
+ describe "#show" do
before do
expect(Attachment).to receive(:find).and_return(attachment)
end
it "renders the show template" do
- get :show, params: {id: attachment.id}
+ get :show, params: { id: attachment.id }
expect(response).to render_template(:show)
end
end
- describe '#create' do
+ describe "#create" do
subject { post :create, params: params }
- context 'with passing validations' do
- let(:params) { {attachment: {file: file}} }
+ context "with passing validations" do
+ let(:params) { { attachment: { file: file } } }
it "renders json response with success message" do
subject
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
expect(response.status).to eq(201)
json = JSON.parse(response.body)
- expect(json).to have_key('growl_message')
- expect(json).to have_key('files')
+ expect(json).to have_key("growl_message")
+ expect(json).to have_key("files")
end
end
- context 'with failing validations' do
- include_context 'with invalid file'
+ context "with failing validations" do
+ include_context "with invalid file"
- let(:params) { {attachment: {file: invalid_file}} }
+ let(:params) { { attachment: { file: invalid_file } } }
- it_behaves_like 'having a json uploader error message'
+ it_behaves_like "having a json uploader error message"
end
end
- describe '#update' do
+ describe "#update" do
let(:params) do
{
- id: attachment.id, attachment: {name: ''}
+ id: attachment.id, attachment: { name: "" },
}
end
@@ -122,25 +122,25 @@ module Alchemy
context "when file is passed" do
let(:file) do
fixture_file_upload(
- File.expand_path('../../../fixtures/image2.PNG', __dir__),
- 'image/png'
+ File.expand_path("../../../fixtures/image2.PNG", __dir__),
+ "image/png",
)
end
- context 'with passing validations' do
+ context "with passing validations" do
let(:params) do
{
- id: attachment.id, attachment: {file: file}
+ id: attachment.id, attachment: { file: file },
}
end
it "renders json response with success message" do
subject
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
expect(response.status).to eq(202)
json = JSON.parse(response.body)
- expect(json).to have_key('growl_message')
- expect(json).to have_key('files')
+ expect(json).to have_key("growl_message")
+ expect(json).to have_key("files")
end
it "replaces the file" do
@@ -149,25 +149,25 @@ module Alchemy
end
end
- context 'with passing validations' do
+ context "with passing validations" do
it "redirects to index path" do
is_expected.to redirect_to admin_attachments_path
end
- context 'with search params' do
+ context "with search params" do
let(:search_filter_params) do
{
- q: {name_or_file_name_cont: 'kitten'},
- tagged_with: 'cute',
- file_type: 'pdf',
- page: 2
+ q: { name_or_file_name_cont: "kitten" },
+ tagged_with: "cute",
+ file_type: "pdf",
+ page: 2,
}
end
subject do
put :update, params: {
- id: attachment.id, attachment: {name: ''}
- }.merge(search_filter_params)
+ id: attachment.id, attachment: { name: "" },
+ }.merge(search_filter_params)
end
it "passes them along" do
@@ -176,8 +176,8 @@ module Alchemy
end
end
- context 'with failing validations' do
- include_context 'with invalid file'
+ context "with failing validations" do
+ include_context "with invalid file"
it "renders edit form" do
is_expected.to render_template(:edit)
@@ -185,33 +185,33 @@ module Alchemy
end
end
- describe '#destroy' do
+ describe "#destroy" do
before do
expect(Attachment).to receive(:find).and_return(attachment)
end
it "destroys the attachment and sets a success message" do
expect(attachment).to receive(:destroy)
- delete :destroy, params: {id: 1}, xhr: true
+ delete :destroy, params: { id: 1 }, xhr: true
expect(assigns(:attachment)).to eq(attachment)
expect(assigns(:url)).not_to be_blank
expect(flash[:notice]).not_to be_blank
end
- context 'with search params' do
+ context "with search params" do
let(:search_filter_params) do
{
- q: {name_or_file_name_cont: 'kitten'},
- tagged_with: 'cute',
- file_type: 'pdf',
- page: 2
+ q: { name_or_file_name_cont: "kitten" },
+ tagged_with: "cute",
+ file_type: "pdf",
+ page: 2,
}
end
it "passes them along" do
expect(attachment).to receive(:destroy) { true }
- delete :destroy, params: {id: 1}.merge(search_filter_params), xhr: true
- expect(assigns(:url)).to eq admin_attachments_url(search_filter_params.merge(host: 'test.host'))
+ delete :destroy, params: { id: 1 }.merge(search_filter_params), xhr: true
+ expect(assigns(:url)).to eq admin_attachments_url(search_filter_params.merge(host: "test.host"))
end
end
end
@@ -222,8 +222,8 @@ module Alchemy
end
it "sends the file as download" do
- get :download, params: {id: attachment.id}
- expect(response.headers['Content-Disposition']).to match(/attachment/)
+ get :download, params: { id: attachment.id }
+ expect(response.headers["Content-Disposition"]).to match(/attachment/)
end
end
end
diff --git a/spec/controllers/alchemy/admin/base_controller_spec.rb b/spec/controllers/alchemy/admin/base_controller_spec.rb
index 861319d2e9..cce76cd11a 100644
--- a/spec/controllers/alchemy/admin/base_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/base_controller_spec.rb
@@ -1,38 +1,38 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
describe Alchemy::Admin::BaseController do
- describe '#raise_exception?' do
+ describe "#raise_exception?" do
subject { controller.send(:raise_exception?) }
- context 'in test mode' do
+ context "in test mode" do
before { expect(Rails.env).to receive(:test?).and_return true }
it { is_expected.to be_truthy }
end
- context 'not in test mode' do
+ context "not in test mode" do
before { expect(Rails.env).to receive(:test?).and_return false }
it { is_expected.to be_falsey }
- context 'and in page preview' do
+ context "and in page preview" do
before { expect(controller).to receive(:is_page_preview?).and_return true }
it { is_expected.to be_truthy }
end
- context 'and not in page preview' do
+ context "and not in page preview" do
before { expect(controller).to receive(:is_page_preview?).and_return false }
it { is_expected.to be_falsey }
end
end
end
- describe '#set_translation' do
- context 'with unavailable locale in the session' do
+ describe "#set_translation" do
+ context "with unavailable locale in the session" do
before do
allow(I18n).to receive(:default_locale) { :es }
allow(I18n).to receive(:available_locales) { [:es] }
- allow(controller).to receive(:session) { { alchemy_locale: 'kl'} }
+ allow(controller).to receive(:session) { { alchemy_locale: "kl"} }
end
it "sets I18n.locale to the default locale" do
@@ -42,27 +42,27 @@
end
end
- describe '#is_page_preview?' do
+ describe "#is_page_preview?" do
subject { controller.send(:is_page_preview?) }
it { is_expected.to be_falsey }
- context 'is pages controller and show action' do
+ context "is pages controller and show action" do
before do
- expect(controller).to receive(:controller_path).and_return('alchemy/admin/pages')
- expect(controller).to receive(:action_name).and_return('show')
+ expect(controller).to receive(:controller_path).and_return("alchemy/admin/pages")
+ expect(controller).to receive(:action_name).and_return("show")
end
it { is_expected.to be_truthy }
end
end
- context 'when current_alchemy_user is present' do
- let!(:page_1) { create(:alchemy_page, name: 'Page 1') }
- let!(:page_2) { create(:alchemy_page, name: 'Page 2') }
+ context "when current_alchemy_user is present" do
+ let!(:page_1) { create(:alchemy_page, name: "Page 1") }
+ let!(:page_2) { create(:alchemy_page, name: "Page 2") }
let(:user) { create(:alchemy_dummy_user, :as_admin) }
- context 'and she has locked pages' do
+ context "and she has locked pages" do
before do
allow(controller).to receive(:current_alchemy_user) { user }
[page_1, page_2].each_with_index do |p, i|
@@ -70,9 +70,9 @@
end
end
- it 'loads locked pages ordered by locked_at date' do
+ it "loads locked pages ordered by locked_at date" do
controller.send(:load_locked_pages)
- expect(assigns(:locked_pages).pluck(:name)).to eq(['Page 2', 'Page 1'])
+ expect(assigns(:locked_pages).pluck(:name)).to eq(["Page 2", "Page 1"])
end
end
end
diff --git a/spec/controllers/alchemy/admin/clipboard_controller_spec.rb b/spec/controllers/alchemy/admin/clipboard_controller_spec.rb
index 09b90b81d5..c9f57d8dc7 100644
--- a/spec/controllers/alchemy/admin/clipboard_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/clipboard_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::ClipboardController do
@@ -15,47 +15,47 @@ module Alchemy
session[:alchemy_clipboard] = {}
end
- describe '#index' do
- context 'with `remarkable_type` being an allowed type' do
- it 'is successful' do
- get :index, params: {remarkable_type: 'elements'}
+ describe "#index" do
+ context "with `remarkable_type` being an allowed type" do
+ it "is successful" do
+ get :index, params: {remarkable_type: "elements"}
expect(response).to be_successful
end
end
- context 'with `remarkable_type` not an allowed type' do
- it 'raises 400 Bad Request' do
+ context "with `remarkable_type` not an allowed type" do
+ it "raises 400 Bad Request" do
expect {
- get :index, params: {remarkable_type: 'evil'}
+ get :index, params: {remarkable_type: "evil"}
}.to raise_error(ActionController::BadRequest)
end
end
end
- context 'for elements' do
+ context "for elements" do
before do
expect(Element).to receive(:find).and_return(element)
end
describe "#insert" do
it "should hold element ids" do
- post :insert, params: {remarkable_type: 'elements', remarkable_id: element.id}, xhr: true
- expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
+ post :insert, params: {remarkable_type: "elements", remarkable_id: element.id}, xhr: true
+ expect(session[:alchemy_clipboard]["elements"]).to eq([{"id" => element.id.to_s, "action" => "copy"}])
end
it "should not have the same element twice" do
- session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
- post :insert, params: {remarkable_type: 'elements', remarkable_id: element.id}, xhr: true
- expect(session[:alchemy_clipboard]['elements'].collect { |e| e['id'] }).not_to eq([element.id, element.id])
+ session[:alchemy_clipboard]["elements"] = [{"id" => element.id.to_s, "action" => "copy"}]
+ post :insert, params: {remarkable_type: "elements", remarkable_id: element.id}, xhr: true
+ expect(session[:alchemy_clipboard]["elements"].collect { |e| e["id"] }).not_to eq([element.id, element.id])
end
end
describe "#delete" do
it "should remove element ids from clipboard" do
- session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
- session[:alchemy_clipboard]['elements'] << {'id' => another_element.id.to_s, 'action' => 'copy'}
- delete :remove, params: {remarkable_type: 'elements', remarkable_id: another_element.id}, xhr: true
- expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
+ session[:alchemy_clipboard]["elements"] = [{"id" => element.id.to_s, "action" => "copy"}]
+ session[:alchemy_clipboard]["elements"] << {"id" => another_element.id.to_s, "action" => "copy"}
+ delete :remove, params: {remarkable_type: "elements", remarkable_id: another_element.id}, xhr: true
+ expect(session[:alchemy_clipboard]["elements"]).to eq([{"id" => element.id.to_s, "action" => "copy"}])
end
end
end
@@ -63,17 +63,17 @@ module Alchemy
describe "#clear" do
context "with elements as remarkable_type" do
it "should clear the elements clipboard" do
- session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s}]
- delete :clear, params: {remarkable_type: 'elements'}, xhr: true
- expect(session[:alchemy_clipboard]['elements']).to be_empty
+ session[:alchemy_clipboard]["elements"] = [{"id" => element.id.to_s}]
+ delete :clear, params: {remarkable_type: "elements"}, xhr: true
+ expect(session[:alchemy_clipboard]["elements"]).to be_empty
end
end
context "with pages as remarkable_type" do
it "should clear the pages clipboard" do
- session[:alchemy_clipboard]['pages'] = [{'id' => public_page.id.to_s}]
- delete :clear, params: {remarkable_type: 'pages'}, xhr: true
- expect(session[:alchemy_clipboard]['pages']).to be_empty
+ session[:alchemy_clipboard]["pages"] = [{"id" => public_page.id.to_s}]
+ delete :clear, params: {remarkable_type: "pages"}, xhr: true
+ expect(session[:alchemy_clipboard]["pages"]).to be_empty
end
end
end
diff --git a/spec/controllers/alchemy/admin/dashboard_controller_spec.rb b/spec/controllers/alchemy/admin/dashboard_controller_spec.rb
index 2b4ca871f6..fb2861566c 100644
--- a/spec/controllers/alchemy/admin/dashboard_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/dashboard_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::DashboardController do
@@ -10,14 +10,14 @@ module Alchemy
before { authorize_user(user) }
- describe '#index' do
+ describe "#index" do
before do
allow(Page).to receive(:from_current_site).and_return(
double(
all_last_edited_from: [],
locked_by: [],
- locked: []
- )
+ locked: [],
+ ),
)
end
@@ -31,9 +31,9 @@ module Alchemy
expect(assigns(:all_locked_pages)).to eq([])
end
- context 'with user class having logged_in scope' do
- context 'with other users online' do
- let(:another_user) { mock_model('DummyUser') }
+ context "with user class having logged_in scope" do
+ context "with other users online" do
+ let(:another_user) { mock_model("DummyUser") }
before do
expect(Alchemy.user_class).to receive(:logged_in).and_return([another_user])
@@ -45,7 +45,7 @@ module Alchemy
end
end
- context 'without other users online' do
+ context "without other users online" do
it "does not assign @online_users" do
get :index
expect(assigns(:online_users)).to eq([])
@@ -53,7 +53,7 @@ module Alchemy
end
end
- context 'user having signed in before' do
+ context "user having signed in before" do
before do
expect(user).to receive(:sign_in_count).and_return(5)
expect(user).to receive(:last_sign_in_at).and_return(Time.current)
@@ -71,22 +71,22 @@ module Alchemy
end
end
- describe '#info' do
+ describe "#info" do
it "assigns @alchemy_version with the current Alchemy version" do
get :info
expect(assigns(:alchemy_version)).to eq(Alchemy.version)
end
end
- describe '#update_check' do
+ describe "#update_check" do
before do
WebMock.enable!
end
context "requesting rubygems.org" do
before do
- stub_request(:get, 'https://rubygems.org/api/v1/versions/alchemy_cms.json').to_return(
- status: 200, body: '[{"number": "3.0.0.alpha"}, {"number": "2.6.0"}, {"number": "2.5.1"}]'
+ stub_request(:get, "https://rubygems.org/api/v1/versions/alchemy_cms.json").to_return(
+ status: 200, body: '[{"number": "3.0.0.alpha"}, {"number": "2.6.0"}, {"number": "2.5.1"}]',
)
end
@@ -97,8 +97,8 @@ module Alchemy
it "should render 'false'" do
get :update_check
- expect(response.code).to eq('200')
- expect(response.body).to eq('false')
+ expect(response.code).to eq("200")
+ expect(response.body).to eq("false")
end
end
@@ -109,25 +109,25 @@ module Alchemy
it "should render 'true'" do
get :update_check
- expect(response.code).to eq('200')
- expect(response.body).to eq('true')
+ expect(response.code).to eq("200")
+ expect(response.body).to eq("true")
end
end
end
context "if rubygems.org is unavailable" do
before do
- stub_request(:get, 'https://rubygems.org/api/v1/versions/alchemy_cms.json').to_return(status: 503)
- stub_request(:get, 'https://api.github.com/repos/AlchemyCMS/alchemy_cms/tags').to_return(
- status: 200, body: '[{"name": "v2.6.0"}, {"name": "v2.5.0"}]'
+ stub_request(:get, "https://rubygems.org/api/v1/versions/alchemy_cms.json").to_return(status: 503)
+ stub_request(:get, "https://api.github.com/repos/AlchemyCMS/alchemy_cms/tags").to_return(
+ status: 200, body: '[{"name": "v2.6.0"}, {"name": "v2.5.0"}]',
)
allow(Alchemy).to receive(:version).and_return("2.6.2")
end
it "should request github.com" do
get :update_check
- expect(response.code).to eq('200')
- expect(response.body).to eq('false')
+ expect(response.code).to eq("200")
+ expect(response.body).to eq("false")
end
end
@@ -138,7 +138,7 @@ module Alchemy
it "should have status code 503" do
get :update_check
- expect(response.code).to eq('503')
+ expect(response.code).to eq("503")
end
end
diff --git a/spec/controllers/alchemy/admin/elements_controller_spec.rb b/spec/controllers/alchemy/admin/elements_controller_spec.rb
index 9ffc9e32a5..b87b39b2e7 100644
--- a/spec/controllers/alchemy/admin/elements_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/elements_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::ElementsController do
@@ -13,14 +13,14 @@ module Alchemy
before { authorize_user(:as_author) }
- describe '#index' do
+ describe "#index" do
let!(:alchemy_page) { create(:alchemy_page) }
let!(:element) { create(:alchemy_element, page: alchemy_page) }
let!(:trashed_element) { create(:alchemy_element, page: alchemy_page).tap(&:trash!) }
let!(:nested_element) { create(:alchemy_element, :nested, page: alchemy_page) }
let!(:hidden_element) { create(:alchemy_element, page: alchemy_page, public: false) }
- context 'with fixed elements' do
+ context "with fixed elements" do
let!(:fixed_element) do
create(:alchemy_element, :fixed,
page: alchemy_page)
@@ -50,7 +50,7 @@ module Alchemy
end
end
- describe '#order' do
+ describe "#order" do
let(:element_1) { create(:alchemy_element) }
let(:element_2) { create(:alchemy_element, page: page) }
let(:element_3) { create(:alchemy_element, page: page) }
@@ -62,8 +62,8 @@ module Alchemy
expect(Element.all.pluck(:id)).to eq(element_ids)
end
- context 'with missing [:element_ids] param' do
- it 'does not raise any error and silently rejects to order' do
+ context "with missing [:element_ids] param" do
+ it "does not raise any error and silently rejects to order" do
expect {
post :order, params: {page_id: page.id}, xhr: true
}.to_not raise_error
@@ -73,21 +73,21 @@ module Alchemy
context "when nested inside parent element" do
let(:parent) { create(:alchemy_element) }
- it 'touches the cache key of parent element' do
+ it "touches the cache key of parent element" do
expect(Element).to receive(:find_by) { parent }
expect(parent).to receive(:touch) { true }
post :order, params: {
page_id: page.id,
element_ids: element_ids,
- parent_element_id: parent.id
+ parent_element_id: parent.id,
}, xhr: true
end
- it 'assigns parent element id to each element' do
+ it "assigns parent element id to each element" do
post :order, params: {
page_id: page.id,
element_ids: element_ids,
- parent_element_id: parent.id
+ parent_element_id: parent.id,
}, xhr: true
[element_1, element_2, element_3].each do |element|
expect(element.reload.parent_element_id).to eq parent.id
@@ -121,7 +121,7 @@ module Alchemy
end
end
- describe '#new' do
+ describe "#new" do
let(:alchemy_page) { build_stubbed(:alchemy_page) }
before do
@@ -135,9 +135,9 @@ module Alchemy
context "with elements in clipboard" do
let(:element) { build_stubbed(:alchemy_element) }
- let(:clipboard_items) { [{'id' => element.id.to_s, 'action' => 'copy'}] }
+ let(:clipboard_items) { [{"id" => element.id.to_s, "action" => "copy"}] }
- before { clipboard['elements'] = clipboard_items }
+ before { clipboard["elements"] = clipboard_items }
it "should load all elements from clipboard" do
expect(Element).to receive(:all_from_clipboard_for_page).and_return(clipboard_items)
@@ -147,29 +147,29 @@ module Alchemy
end
end
- describe '#create' do
- describe 'insertion position' do
+ describe "#create" do
+ describe "insertion position" do
before { element }
it "should insert the element at bottom of list" do
- post :create, params: {element: {name: 'news', page_id: alchemy_page.id}}, xhr: true
+ post :create, params: {element: {name: "news", page_id: alchemy_page.id}}, xhr: true
expect(alchemy_page.elements.count).to eq(2)
- expect(alchemy_page.elements.last.name).to eq('news')
+ expect(alchemy_page.elements.last.name).to eq("news")
end
context "on a page with a setting for insert_elements_at of top" do
before do
expect(PageLayout).to receive(:get).at_least(:once).and_return({
- 'name' => 'news',
- 'elements' => ['news'],
- 'insert_elements_at' => 'top'
+ "name" => "news",
+ "elements" => ["news"],
+ "insert_elements_at" => "top",
})
end
it "should insert the element at top of list" do
- post :create, params: {element: {name: 'news', page_id: alchemy_page.id}}, xhr: true
+ post :create, params: {element: {name: "news", page_id: alchemy_page.id}}, xhr: true
expect(alchemy_page.elements.count).to eq(2)
- expect(alchemy_page.elements.first.name).to eq('news')
+ expect(alchemy_page.elements.first.name).to eq("news")
end
end
end
@@ -178,7 +178,7 @@ module Alchemy
let(:parent_element) { create(:alchemy_element, :with_nestable_elements, page: alchemy_page) }
it "creates the element in the parent element" do
- post :create, params: {element: {name: 'slide', page_id: alchemy_page.id, parent_element_id: parent_element.id}}, xhr: true
+ post :create, params: {element: {name: "slide", page_id: alchemy_page.id, parent_element_id: parent_element.id}}, xhr: true
expect(Alchemy::Element.last.parent_element_id).to eq(parent_element.id)
end
end
@@ -187,7 +187,7 @@ module Alchemy
render_views
before do
- clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s, 'action' => 'cut'}]
+ clipboard["elements"] = [{"id" => element_in_clipboard.id.to_s, "action" => "cut"}]
end
it "should create an element from clipboard" do
@@ -199,7 +199,7 @@ module Alchemy
context "and with cut as action parameter" do
it "should also remove the element id from clipboard" do
post :create, params: {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}, xhr: true
- expect(session[:alchemy_clipboard]['elements'].detect { |item| item['id'] == element_in_clipboard.id.to_s }).to be_nil
+ expect(session[:alchemy_clipboard]["elements"].detect { |item| item["id"] == element_in_clipboard.id.to_s }).to be_nil
end
end
@@ -214,7 +214,7 @@ module Alchemy
end
end
- context 'if element could not be saved' do
+ context "if element could not be saved" do
subject { post :create, params: {element: {page_id: alchemy_page.id}} }
before do
@@ -227,11 +227,11 @@ module Alchemy
end
end
- describe '#update' do
+ describe "#update" do
let(:page) { build_stubbed(:alchemy_page) }
let(:element) { build_stubbed(:alchemy_element, page: page) }
- let(:contents_parameters) { ActionController::Parameters.new(1 => {ingredient: 'Title'}) }
- let(:element_parameters) { ActionController::Parameters.new(tag_list: 'Tag 1', public: false) }
+ let(:contents_parameters) { ActionController::Parameters.new(1 => {ingredient: "Title"}) }
+ let(:element_parameters) { ActionController::Parameters.new(tag_list: "Tag 1", public: false) }
before do
expect(Element).to receive(:find).and_return element
@@ -259,9 +259,9 @@ module Alchemy
end
end
- describe 'params security' do
+ describe "params security" do
context "contents params" do
- let(:parameters) { ActionController::Parameters.new(contents: {1 => {ingredient: 'Title'}}) }
+ let(:parameters) { ActionController::Parameters.new(contents: {1 => {ingredient: "Title"}}) }
specify ":contents is required" do
expect(controller.params).to receive(:fetch).and_return(parameters)
@@ -284,7 +284,7 @@ module Alchemy
expect(parameters).to receive(:fetch).with(:element, {}).and_return(parameters)
end
- context 'with taggable element' do
+ context "with taggable element" do
before do
controller.instance_variable_set(:'@element', mock_model(Element, taggable?: true))
end
@@ -295,7 +295,7 @@ module Alchemy
end
end
- context 'with not taggable element' do
+ context "with not taggable element" do
before do
controller.instance_variable_set(:'@element', mock_model(Element, taggable?: false))
end
@@ -308,7 +308,7 @@ module Alchemy
end
end
- describe '#trash' do
+ describe "#trash" do
subject { delete :trash, params: {id: element.id}, xhr: true }
let(:element) { build_stubbed(:alchemy_element) }
@@ -321,7 +321,7 @@ module Alchemy
end
end
- describe '#fold' do
+ describe "#fold" do
subject { post :fold, params: {id: element.id}, xhr: true }
let(:element) { build_stubbed(:alchemy_element) }
@@ -331,7 +331,7 @@ module Alchemy
expect(Element).to receive(:find).and_return element
end
- context 'if element is folded' do
+ context "if element is folded" do
before { expect(element).to receive(:folded).and_return true }
it "sets folded to false." do
@@ -340,7 +340,7 @@ module Alchemy
end
end
- context 'if element is not folded' do
+ context "if element is not folded" do
before { expect(element).to receive(:folded).and_return false }
it "sets folded to true." do
diff --git a/spec/controllers/alchemy/admin/essence_files_controller_spec.rb b/spec/controllers/alchemy/admin/essence_files_controller_spec.rb
index ffae4c8678..2bed1b95dd 100644
--- a/spec/controllers/alchemy/admin/essence_files_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/essence_files_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::EssenceFilesController do
@@ -10,51 +10,53 @@ module Alchemy
authorize_user(:as_admin)
end
- let(:essence_file) { mock_model('EssenceFile', :attachment= => nil, content: content) }
- let(:content) { mock_model('Content') }
- let(:attachment) { mock_model('Attachment') }
+ let(:essence_file) { mock_model("EssenceFile", :attachment= => nil, content: content) }
+ let(:content) { mock_model("Content") }
+ let(:attachment) { mock_model("Attachment") }
- describe '#edit' do
+ describe "#edit" do
before do
- expect(EssenceFile).to receive(:find)
- .with(essence_file.id.to_s)
- .and_return(essence_file)
+ expect(EssenceFile).to receive(:find).with(essence_file.id.to_s) { essence_file }
end
it "assigns @essence_file with the EssenceFile found by id" do
- get :edit, params: {id: essence_file.id}
+ get :edit, params: { id: essence_file.id }
expect(assigns(:essence_file)).to eq(essence_file)
end
it "should assign @content with essence_file's content" do
- get :edit, params: {id: essence_file.id}
+ get :edit, params: { id: essence_file.id }
expect(assigns(:content)).to eq(content)
end
end
- describe '#update' do
+ describe "#update" do
let(:essence_file) { create(:alchemy_essence_file) }
+ let(:params) do
+ {
+ id: essence_file.id,
+ essence_file: {
+ title: "new title",
+ css_class: "left",
+ link_text: "Download this file",
+ },
+ }
+ end
+
before do
- expect(EssenceFile).to receive(:find).and_return(essence_file)
+ expect(EssenceFile).to receive(:find) { essence_file }
end
it "should update the attributes of essence_file" do
- put :update, params: {
- id: essence_file.id,
- essence_file: {
- title: 'new title',
- css_class: 'left',
- link_text: 'Download this file'
- }
- }, xhr: true
- expect(essence_file.title).to eq 'new title'
- expect(essence_file.css_class).to eq 'left'
- expect(essence_file.link_text).to eq 'Download this file'
+ put :update, params: params, xhr: true
+ expect(essence_file.title).to eq "new title"
+ expect(essence_file.css_class).to eq "left"
+ expect(essence_file.link_text).to eq "Download this file"
end
end
- describe '#assign' do
+ describe "#assign" do
let(:content) { create(:alchemy_content) }
before do
@@ -64,20 +66,20 @@ module Alchemy
end
it "should assign @attachment with the Attachment found by attachment_id" do
- put :assign, params: {content_id: content.id, attachment_id: attachment.id}, xhr: true
+ put :assign, params: { content_id: content.id, attachment_id: attachment.id }, xhr: true
expect(assigns(:attachment)).to eq(attachment)
end
it "should assign @content.essence.attachment with the attachment found by id" do
expect(content.essence).to receive(:attachment=).with(attachment)
- put :assign, params: {content_id: content.id, attachment_id: attachment.id}, xhr: true
+ put :assign, params: { content_id: content.id, attachment_id: attachment.id }, xhr: true
end
- it "updates the @content.updated_at column" do
- content.update_column(:updated_at, 3.days.ago)
+ it "updates the elements updated_at column" do
+ content.element.update_column(:updated_at, 3.days.ago)
expect {
- put :assign, params: {content_id: content.id, attachment_id: attachment.id}, xhr: true
- }.to change(content, :updated_at)
+ put :assign, params: { content_id: content.id, attachment_id: attachment.id }, xhr: true
+ }.to change(content.element, :updated_at)
end
end
end
diff --git a/spec/controllers/alchemy/admin/essence_pictures_controller_spec.rb b/spec/controllers/alchemy/admin/essence_pictures_controller_spec.rb
index 01ab27c7f4..5e93626027 100644
--- a/spec/controllers/alchemy/admin/essence_pictures_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/essence_pictures_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::EssencePicturesController do
@@ -12,42 +12,42 @@ module Alchemy
let(:content) { Content.new }
let(:picture) { Picture.new }
- describe '#edit' do
+ describe "#edit" do
before do
expect(EssencePicture).to receive(:find).and_return(essence)
expect(Content).to receive(:find).and_return(content)
end
- it 'should assign @essence_picture and @content instance variables' do
- post :edit, params: {id: 1, content_id: 1}
+ it "should assign @essence_picture and @content instance variables" do
+ post :edit, params: { id: 1, content_id: 1 }
expect(assigns(:essence_picture)).to be_a(EssencePicture)
expect(assigns(:content)).to be_a(Content)
end
end
- describe '#crop' do
+ describe "#crop" do
before do
expect(EssencePicture).to receive(:find).and_return(essence)
end
- context 'with no picture assigned' do
+ context "with no picture assigned" do
before do
expect(essence).to receive(:picture).at_least(:once).and_return(nil)
end
it "renders error message" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:no_image_notice)).to eq(Alchemy.t(:no_image_for_cropper_found))
end
end
- context 'with picture assigned' do
+ context "with picture assigned" do
let(:default_mask) do
{
x1: 0,
y1: 0,
x2: 300,
- y2: 250
+ y2: 250,
}
end
@@ -60,44 +60,44 @@ module Alchemy
allow(content).to receive(:settings) { settings }
end
- context 'with no render_size present in essence' do
+ context "with no render_size present in essence" do
before do
expect(essence).to receive(:render_size).at_least(:once).and_return(nil)
end
- context 'with sizes in content settings' do
+ context "with sizes in content settings" do
let(:settings) do
- { size: '300x250' }
+ { size: "300x250" }
end
it "sets sizes to given values" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:min_size)).to eq({ width: 300, height: 250 })
end
end
- context 'with no sizes in content settngs' do
+ context "with no sizes in content settngs" do
it "sets sizes to zero" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:min_size)).to eq({ width: 0, height: 0 })
end
end
end
- context 'with render_size present in essence' do
+ context "with render_size present in essence" do
it "sets sizes from these values" do
- expect(essence).to receive(:render_size).at_least(:once).and_return('30x25')
+ expect(essence).to receive(:render_size).at_least(:once).and_return("30x25")
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:min_size)).to eq({ width: 30, height: 25 })
end
- context 'when width or height is not fixed' do
- it 'infers the height from the image file preserving the aspect ratio' do
- expect(essence).to receive(:render_size).at_least(:once).and_return('30x')
+ context "when width or height is not fixed" do
+ it "infers the height from the image file preserving the aspect ratio" do
+ expect(essence).to receive(:render_size).at_least(:once).and_return("30x")
- get :crop, params: {id: 1}
- expect(assigns(:min_size)).to eq({ width: 30, height: 0})
+ get :crop, params: { id: 1 }
+ expect(assigns(:min_size)).to eq({ width: 30, height: 0 })
end
context "and aspect ratio set on the contents settings" do
@@ -105,96 +105,96 @@ module Alchemy
{ fixed_ratio: "2" }
end
- it 'does not infer the height from the image file preserving the aspect ratio' do
- expect(essence).to receive(:render_size).at_least(:once).and_return('x25')
+ it "does not infer the height from the image file preserving the aspect ratio" do
+ expect(essence).to receive(:render_size).at_least(:once).and_return("x25")
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:min_size)).to eq({ width: 50, height: 25 })
end
end
end
- context 'when width or height is not fixed and an aspect ratio is given' do
+ context "when width or height is not fixed and an aspect ratio is given" do
context "and aspect ratio set on the contents setting" do
let(:settings) do
{ fixed_ratio: "0.5" }
end
- it 'width is given, it infers the height from width and ratio' do
- expect(essence).to receive(:render_size).at_least(:once).and_return('30x')
+ it "width is given, it infers the height from width and ratio" do
+ expect(essence).to receive(:render_size).at_least(:once).and_return("30x")
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:min_size)).to eq({ width: 30, height: 60 })
end
end
- it 'infers the height from the image file preserving the aspect ratio' do
- expect(essence).to receive(:render_size).at_least(:once).and_return('x25')
+ it "infers the height from the image file preserving the aspect ratio" do
+ expect(essence).to receive(:render_size).at_least(:once).and_return("x25")
- get :crop, params: {id: 1}
- expect(assigns(:min_size)).to eq({ width: 0, height: 25})
+ get :crop, params: { id: 1 }
+ expect(assigns(:min_size)).to eq({ width: 0, height: 25 })
end
end
end
- context 'no crop sizes present in essence' do
+ context "no crop sizes present in essence" do
before do
expect(essence).to receive(:crop_from).and_return(nil)
allow(essence).to receive(:crop_size).and_return(nil)
end
it "assigns default mask boxes" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:initial_box)).to eq(default_mask)
expect(assigns(:default_box)).to eq(default_mask)
end
end
- context 'crop sizes present in essence' do
- let(:mask) { {'x1' => '0', 'y1' => '0', 'x2' => '120', 'y2' => '160'} }
+ context "crop sizes present in essence" do
+ let(:mask) { { "x1" => "0", "y1" => "0", "x2" => "120", "y2" => "160" } }
before do
- allow(essence).to receive(:crop_from).and_return('0x0')
- allow(essence).to receive(:crop_size).and_return('120x160')
+ allow(essence).to receive(:crop_from).and_return("0x0")
+ allow(essence).to receive(:crop_size).and_return("120x160")
end
it "assigns cropping boxes" do
expect(essence).to receive(:cropping_mask).and_return(mask)
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:initial_box)).to eq(mask)
expect(assigns(:default_box)).to eq(default_mask)
end
end
- context 'with fixed_ratio set to false' do
+ context "with fixed_ratio set to false" do
let(:settings) do
{ fixed_ratio: false }
end
it "sets ratio to false" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:ratio)).to eq(false)
end
end
- context 'with fixed_ratio set to a non float string' do
+ context "with fixed_ratio set to a non float string" do
let(:settings) do
- { fixed_ratio: '123,45' }
+ { fixed_ratio: "123,45" }
end
it "doesn't set a fixed ratio" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:ratio)).to eq(false)
end
end
- context 'with no fixed_ratio set' do
+ context "with no fixed_ratio set" do
let(:settings) do
- { size: '80x60' }
+ { size: "80x60" }
end
it "sets a fixed ratio from sizes" do
- get :crop, params: {id: 1}
+ get :crop, params: { id: 1 }
expect(assigns(:ratio)).to eq(80.0 / 60.0)
end
end
@@ -209,29 +209,29 @@ module Alchemy
let(:attributes) do
{
- render_size: '1x1',
- alt_tag: 'Alt Tag',
- caption: 'Caption',
- css_class: 'CSS Class',
- title: 'Title'
+ render_size: "1x1",
+ alt_tag: "Alt Tag",
+ caption: "Caption",
+ css_class: "CSS Class",
+ title: "Title",
}
end
it "updates the essence attributes" do
expect(essence).to receive(:update).and_return(true)
- put :update, params: {id: 1, essence_picture: attributes}, xhr: true
+ put :update, params: { id: 1, essence_picture: attributes }, xhr: true
end
it "saves the cropping mask" do
expect(essence).to receive(:update).and_return(true)
put :update, params: {
- id: 1,
- essence_picture: {
- render_size: '1x1',
- crop_from: '0x0',
- crop_size: '100x100'
- }
- }, xhr: true
+ id: 1,
+ essence_picture: {
+ render_size: "1x1",
+ crop_from: "0x0",
+ crop_size: "100x100",
+ },
+ }, xhr: true
end
context 'with render_gravity params' do
@@ -311,7 +311,7 @@ module Alchemy
end
end
- describe '#assign' do
+ describe "#assign" do
let(:content) { create(:alchemy_content) }
before do
@@ -321,15 +321,15 @@ module Alchemy
end
it "should assign a Picture" do
- put :assign, params: {content_id: '1', picture_id: '1'}, xhr: true
+ put :assign, params: { content_id: "1", picture_id: "1" }, xhr: true
expect(assigns(:content).essence.picture).to eq(picture)
end
- it "updates the content timestamp" do
- content.update_column(:updated_at, 3.days.ago)
+ it "updates the element timestamp" do
+ content.element.update_column(:updated_at, 3.days.ago)
expect {
- put :assign, params: {content_id: '1', picture_id: '1'}, xhr: true
- }.to change(content, :updated_at)
+ put :assign, params: { content_id: "1", picture_id: "1" }, xhr: true
+ }.to change(content.element, :updated_at)
end
end
end
diff --git a/spec/controllers/alchemy/admin/languages_controller_spec.rb b/spec/controllers/alchemy/admin/languages_controller_spec.rb
index 0944a97b63..f109154fc5 100644
--- a/spec/controllers/alchemy/admin/languages_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/languages_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
describe Alchemy::Admin::LanguagesController do
routes { Alchemy::Engine.routes }
@@ -10,7 +10,7 @@
end
describe "#index" do
- context 'without a site' do
+ context "without a site" do
it "redirects to the sites admin" do
get :index
expect(response).to redirect_to(admin_sites_path)
@@ -23,14 +23,14 @@
end
let!(:site_2) do
- create(:alchemy_site, host: 'another-site.com')
+ create(:alchemy_site, host: "another-site.com")
end
let!(:site_2_language) do
site_2.default_language
end
- it 'only shows languages from current site' do
+ it "only shows languages from current site" do
get :index
expect(assigns(:languages)).to include(default_site_language)
expect(assigns(:languages)).to_not include(site_2_language)
@@ -52,27 +52,27 @@
end
describe "#new" do
- context 'without a site' do
+ context "without a site" do
it "redirects to the sites admin" do
get :new
expect(response).to redirect_to(admin_sites_path)
end
- end
+ end
- context 'with a site' do
- let!(:site) { create(:alchemy_site) }
+ context "with a site" do
+ let!(:site) { create(:alchemy_site) }
- it "has default language's page_layout set" do
- get :new
- expect(assigns(:language).page_layout).
- to eq(Alchemy::Config.get(:default_language)['page_layout'])
- end
- end
+ it "has default language's page_layout set" do
+ get :new
+ expect(assigns(:language).page_layout).
+ to eq(Alchemy::Config.get(:default_language)["page_layout"])
+ end
+ end
end
describe "#create" do
- context 'with valid params' do
- it 'redirects to the pages admin' do
+ context "with valid params" do
+ it "redirects to the pages admin" do
post :create, params: {
language: {
name: "English",
@@ -81,18 +81,18 @@
page_layout: "index",
public: true,
default: true,
- site_id: create(:alchemy_site)
- }
+ site_id: create(:alchemy_site),
+ },
}
language = Alchemy::Language.last
expect(response).to redirect_to admin_pages_path(language_id: language)
- expect(flash[:notice]).to eq('Language successfully created.')
+ expect(flash[:notice]).to eq("Language successfully created.")
end
end
- context 'with invalid params' do
- it 'shows the form again' do
- post :create, params: { language: { name: '' } }
+ context "with invalid params" do
+ it "shows the form again" do
+ post :create, params: { language: { name: "" } }
expect(response).to render_template(:new)
end
end
@@ -101,22 +101,22 @@
describe "#destroy" do
let(:language) { create(:alchemy_language) }
- context 'with pages attached' do
+ context "with pages attached" do
let!(:page) { create(:alchemy_page, language: language) }
- it 'returns with error message' do
+ it "returns with error message" do
delete :destroy, params: { id: language.id }
expect(response).to redirect_to admin_languages_path
expect(flash[:warning]).to \
- eq('Pages are still attached to this language. Please remove them first.')
+ eq("Pages are still attached to this language. Please remove them first.")
end
end
- context 'without pages' do
- it 'removes the language' do
+ context "without pages" do
+ it "removes the language" do
delete :destroy, params: { id: language.id }
expect(response).to redirect_to admin_languages_path
- expect(flash[:notice]).to eq('Language successfully removed.')
+ expect(flash[:notice]).to eq("Language successfully removed.")
end
end
end
@@ -136,7 +136,7 @@
context "having a referer" do
before do
expect_any_instance_of(ActionDispatch::Request).to receive(:referer) do
- '/admin/pages'
+ "/admin/pages"
end
end
diff --git a/spec/controllers/alchemy/admin/layoutpages_controller_spec.rb b/spec/controllers/alchemy/admin/layoutpages_controller_spec.rb
index 32aaddc044..266bd6037f 100644
--- a/spec/controllers/alchemy/admin/layoutpages_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/layoutpages_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::LayoutpagesController do
@@ -11,19 +11,23 @@ module Alchemy
end
describe "#index" do
- context 'with no language present' do
- it 'redirects to the languages admin' do
+ context "with no language present" do
+ it "redirects to the languages admin" do
get :index
expect(response).to redirect_to(admin_languages_path)
end
end
- context 'with a language present' do
+ context "with a language present" do
let!(:language) { create(:alchemy_language) }
- it "should assign @layout_root" do
- get :index
- expect(assigns(:layout_root)).to be_a(Page)
+ context "and layoutpages present" do
+ let!(:layoutpages) { create_list(:alchemy_page, 2, :layoutpage, language: language) }
+
+ it "should assign @layout_pages" do
+ get :index
+ expect(assigns(:layout_pages)).to match_array(layoutpages)
+ end
end
it "should assign @languages" do
@@ -33,23 +37,23 @@ module Alchemy
context "with multiple sites" do
let!(:site_2) do
- create(:alchemy_site, host: 'another-site.com')
+ create(:alchemy_site, host: "another-site.com")
end
- context 'if no language exists for the current site' do
- it 'redirects to the languages admin' do
+ context "if no language exists for the current site" do
+ it "redirects to the languages admin" do
get :index, session: { alchemy_site_id: site_2.id }
expect(response).to redirect_to(admin_languages_path)
end
end
- context 'if an language exists for the current site' do
+ context "if an language exists for the current site" do
let!(:language) { create(:alchemy_language) }
let!(:language_2) do
create(:alchemy_language, site: site_2)
end
- it 'only shows languages from current site' do
+ it "only shows languages from current site" do
get :index, session: { alchemy_site_id: site_2.id }
expect(assigns(:languages)).to_not include(language)
expect(assigns(:languages)).to include(language_2)
diff --git a/spec/controllers/alchemy/admin/nodes_controller_spec.rb b/spec/controllers/alchemy/admin/nodes_controller_spec.rb
index 9039223b69..82cfb3a334 100644
--- a/spec/controllers/alchemy/admin/nodes_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/nodes_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Admin::NodesController do
@@ -10,70 +10,70 @@ module Alchemy
authorize_user(:as_admin)
end
- describe '#index' do
- context 'if no language is present' do
- it 'redirects to the language admin' do
+ describe "#index" do
+ context "if no language is present" do
+ it "redirects to the language admin" do
get :index
expect(response).to redirect_to(admin_languages_path)
end
end
- context 'if root nodes present' do
+ context "if root nodes present" do
let!(:root_node) { create(:alchemy_node) }
let!(:child_node) { create(:alchemy_node, parent_id: root_node.id) }
it "loads only root nodes from current language" do
get :index
- expect(assigns('root_nodes').to_a).to eq([root_node])
- expect(assigns('root_nodes').to_a).to_not eq([child_node])
+ expect(assigns("root_nodes").to_a).to eq([root_node])
+ expect(assigns("root_nodes").to_a).to_not eq([child_node])
end
end
end
- describe '#new' do
- context 'if no language is present' do
- it 'redirects to the language admin' do
+ describe "#new" do
+ context "if no language is present" do
+ it "redirects to the language admin" do
get :new
expect(response).to redirect_to(admin_languages_path)
end
end
- context 'if language is present' do
+ context "if language is present" do
let!(:default_language) { create(:alchemy_language) }
it "sets the current language on new node" do
get :new
- expect(assigns('node').language).to eq(default_language)
+ expect(assigns("node").language).to eq(default_language)
end
- context 'with parent id in params' do
+ context "with parent id in params" do
it "sets it to new node" do
get :new, params: { parent_id: 1 }
- expect(assigns('node').parent_id).to eq(1)
+ expect(assigns("node").parent_id).to eq(1)
end
end
end
end
- describe '#create' do
- context 'with valid params' do
+ describe "#create" do
+ context "with valid params" do
let(:language) { create(:alchemy_language) }
it "creates node and redirects to index" do
expect {
- post :create, params: { node: { name: 'Node', language_id: language.id, site_id: language.site_id } }
+ post :create, params: { node: { menu_type: "main_menu", language_id: language.id } }
}.to change { Alchemy::Node.count }.by(1)
expect(response).to redirect_to(admin_nodes_path)
end
end
end
- describe '#update' do
+ describe "#update" do
let(:node) { create(:alchemy_node) }
- context 'with valid params' do
+ context "with valid params" do
it "redirects to nodes path" do
- put :update, params: { id: node.id, node: { name: 'Node'} }
+ put :update, params: { id: node.id, node: { name: "Node"} }
expect(response).to redirect_to(admin_nodes_path)
end
end
diff --git a/spec/controllers/alchemy/admin/pictures_controller_spec.rb b/spec/controllers/alchemy/admin/pictures_controller_spec.rb
index e14220b07a..b94e43c3c8 100644
--- a/spec/controllers/alchemy/admin/pictures_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/pictures_controller_spec.rb
@@ -1,19 +1,19 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
RSpec.shared_examples :redirecting_to_picture_library do
let(:params) do
{
- filter: 'latest',
+ filter: "latest",
page: 2,
- q: {name_or_image_file_name_cont: 'kitten'},
- size: 'small',
- tagged_with: 'cat'
+ q: {name_or_image_file_name_cont: "kitten"},
+ size: "small",
+ tagged_with: "cat",
}
end
- it 'redirects to index keeping all query, filter and page params' do
+ it "redirects to index keeping all query, filter and page params" do
is_expected.to redirect_to admin_pictures_path(params)
end
end
@@ -26,62 +26,62 @@ module Alchemy
authorize_user(:as_admin)
end
- describe '#index' do
- context 'with search params' do
- let!(:picture_1) { create(:alchemy_picture, name: 'cute kitten') }
- let!(:picture_2) { create(:alchemy_picture, name: 'nice beach') }
+ describe "#index" do
+ context "with search params" do
+ let!(:picture_1) { create(:alchemy_picture, name: "cute kitten") }
+ let!(:picture_2) { create(:alchemy_picture, name: "nice beach") }
- it 'assigns @pictures with filtered pictures' do
- get :index, params: {q: {name_or_image_file_name_cont: 'kitten'}}
+ it "assigns @pictures with filtered pictures" do
+ get :index, params: {q: {name_or_image_file_name_cont: "kitten"}}
expect(assigns(:pictures)).to include(picture_1)
expect(assigns(:pictures)).to_not include(picture_2)
end
end
- context 'with filter params' do
+ context "with filter params" do
let!(:picture_1) { create(:alchemy_picture) }
let!(:picture_2) { create(:alchemy_picture, tag_list: %w(kitten)) }
- it 'assigns @pictures with filtered pictures' do
- get :index, params: {filter: 'without_tag'}
+ it "assigns @pictures with filtered pictures" do
+ get :index, params: {filter: "without_tag"}
expect(assigns(:pictures)).to include(picture_1)
expect(assigns(:pictures)).to_not include(picture_2)
end
end
- context 'with tag params' do
+ context "with tag params" do
let!(:picture_1) { create(:alchemy_picture, tag_list: %w(water)) }
let!(:picture_2) { create(:alchemy_picture, tag_list: %w(kitten)) }
let!(:picture_3) { create(:alchemy_picture, tag_list: %w(water nature)) }
- it 'assigns @pictures with filtered pictures' do
- get :index, params: {tagged_with: 'water'}
+ it "assigns @pictures with filtered pictures" do
+ get :index, params: {tagged_with: "water"}
expect(assigns(:pictures)).to include(picture_1)
expect(assigns(:pictures)).to_not include(picture_2)
expect(assigns(:pictures)).to include(picture_3)
end
end
- context 'with multiple tag params' do
+ context "with multiple tag params" do
let!(:picture_1) { create(:alchemy_picture, tag_list: %w(water)) }
let!(:picture_2) { create(:alchemy_picture, tag_list: %w(water nature)) }
- it 'assigns @pictures with filtered pictures' do
- get :index, params: {tagged_with: 'water,nature'}
+ it "assigns @pictures with filtered pictures" do
+ get :index, params: {tagged_with: "water,nature"}
expect(assigns(:pictures)).to_not include(picture_1)
expect(assigns(:pictures)).to include(picture_2)
end
end
- it 'assigns @size to default value' do
+ it "assigns @size to default value" do
get :index
- expect(assigns(:size)).to eq('medium')
+ expect(assigns(:size)).to eq("medium")
end
context "with params[:size] set to 'large'" do
- it 'assigns @size to large' do
- get :index, params: {size: 'large'}
- expect(assigns(:size)).to eq('large')
+ it "assigns @size to large" do
+ get :index, params: {size: "large"}
+ expect(assigns(:size)).to eq("large")
end
end
@@ -89,7 +89,7 @@ module Alchemy
context "is set" do
it "for html requests it renders the archive_overlay partial" do
get :index, params: {content_id: 1}
- expect(response).to render_template(partial: '_archive_overlay')
+ expect(response).to render_template(partial: "_archive_overlay")
end
it "for ajax requests it renders the archive_overlay template" do
@@ -107,101 +107,101 @@ module Alchemy
end
end
- describe '#create' do
+ describe "#create" do
subject { post :create, params: params }
- let(:params) { {picture: {name: ''}} }
- let(:picture) { mock_model('Picture', humanized_name: 'Cute kittens', to_jq_upload: {}) }
+ let(:params) { {picture: {name: ""}} }
+ let(:picture) { mock_model("Picture", humanized_name: "Cute kittens", to_jq_upload: {}) }
- context 'with passing validations' do
+ context "with passing validations" do
before do
expect(Picture).to receive(:new).and_return(picture)
- expect(picture).to receive(:name=).and_return('Cute kittens')
- expect(picture).to receive(:name).and_return('Cute kittens')
+ expect(picture).to receive(:name=).and_return("Cute kittens")
+ expect(picture).to receive(:name).and_return("Cute kittens")
expect(picture).to receive(:save).and_return(true)
end
it "renders json response with success message" do
subject
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
expect(response.status).to eq(201)
json = JSON.parse(response.body)
- expect(json).to have_key('growl_message')
- expect(json).to have_key('files')
+ expect(json).to have_key("growl_message")
+ expect(json).to have_key("files")
end
end
- context 'with failing validations' do
- it_behaves_like 'having a json uploader error message'
+ context "with failing validations" do
+ it_behaves_like "having a json uploader error message"
end
end
- describe '#show' do
- let(:picture) { create(:alchemy_picture, name: 'kitten') }
+ describe "#show" do
+ let(:picture) { create(:alchemy_picture, name: "kitten") }
- it 'assigns @picture' do
+ it "assigns @picture" do
get :show, params: {id: picture.id}
expect(assigns(:picture).id).to eq(picture.id)
end
- context 'with assignments' do
+ context "with assignments" do
let!(:page) { create(:alchemy_page) }
let!(:element) { create(:alchemy_element, page: page) }
let!(:content) { create(:alchemy_content, element: element) }
let!(:essence) { create(:alchemy_essence_picture, content: content, picture: picture) }
- it 'assigns all essence pictures having an assignment to @assignments' do
+ it "assigns all essence pictures having an assignment to @assignments" do
get :show, params: {id: picture.id}
expect(assigns(:assignments)).to eq([essence])
end
end
- context 'with previous picture existing' do
- let!(:previous) { create(:alchemy_picture, name: 'abraham') }
+ context "with previous picture existing" do
+ let!(:previous) { create(:alchemy_picture, name: "abraham") }
- it 'assigns @previous to previous picture' do
+ it "assigns @previous to previous picture" do
get :show, params: {id: picture.id}
expect(assigns(:previous).id).to eq(previous.id)
end
end
- context 'with next picture existing' do
- let!(:next_picture) { create(:alchemy_picture, name: 'zebra') }
+ context "with next picture existing" do
+ let!(:next_picture) { create(:alchemy_picture, name: "zebra") }
- it 'assigns @next to next picture' do
+ it "assigns @next to next picture" do
get :show, params: {id: picture.id}
expect(assigns(:next).id).to eq(next_picture.id)
end
end
end
- describe '#edit_multiple' do
- let(:pictures) { [mock_model('Picture', tag_list: 'kitten')] }
+ describe "#edit_multiple" do
+ let(:pictures) { [mock_model("Picture", tag_list: "kitten")] }
before { expect(Picture).to receive(:where).and_return(pictures) }
- it 'assigns pictures instance variable' do
+ it "assigns pictures instance variable" do
get :edit_multiple
expect(assigns(:pictures)).to eq(pictures)
end
- it 'assigns tags instance variable' do
+ it "assigns tags instance variable" do
get :edit_multiple
- expect(assigns(:tags)).to include('kitten')
+ expect(assigns(:tags)).to include("kitten")
end
end
- describe '#update' do
+ describe "#update" do
subject do
- put :update, params: {id: 1, picture: {name: ''}}, xhr: true
+ put :update, params: {id: 1, picture: {name: ""}}, xhr: true
end
- let(:picture) { build_stubbed(:alchemy_picture, name: 'Cute kitten') }
+ let(:picture) { build_stubbed(:alchemy_picture, name: "Cute kitten") }
before do
expect(Picture).to receive(:find).and_return(picture)
end
- context 'with passing validations' do
+ context "with passing validations" do
before do
expect(picture).to receive(:update).and_return(true)
end
@@ -210,11 +210,11 @@ module Alchemy
subject
expect(assigns(:message)[:body]).to \
eq(Alchemy.t(:picture_updated_successfully, name: picture.name))
- expect(assigns(:message)[:type]).to eq('notice')
+ expect(assigns(:message)[:type]).to eq("notice")
end
end
- context 'with failing validations' do
+ context "with failing validations" do
before do
expect(picture).to receive(:update).and_return(false)
end
@@ -222,12 +222,12 @@ module Alchemy
it "sets error notice" do
subject
expect(assigns(:message)[:body]).to eq(Alchemy.t(:picture_update_failed))
- expect(assigns(:message)[:type]).to eq('error')
+ expect(assigns(:message)[:type]).to eq("error")
end
end
end
- describe '#update_multiple' do
+ describe "#update_multiple" do
let(:picture) { build_stubbed(:alchemy_picture) }
let(:pictures) { [picture] }
@@ -252,25 +252,25 @@ module Alchemy
it_behaves_like :redirecting_to_picture_library do
let(:subject) do
delete :delete_multiple, params: {
- picture_ids: %w(1 2)
+ picture_ids: %w(1 2),
}.merge(params)
end
end
let(:deletable_picture) do
- mock_model('Picture', name: 'pic of the pig', deletable?: true)
+ mock_model("Picture", name: "pic of the pig", deletable?: true)
end
let(:not_deletable_picture) do
- mock_model('Picture', name: 'pic of the chick', deletable?: false)
+ mock_model("Picture", name: "pic of the chick", deletable?: false)
end
context "no picture_ids given" do
- let(:picture_ids) { '' }
+ let(:picture_ids) { "" }
it "should give a warning about not deleting any pictures" do
subject
- expect(flash[:warn]).to match('Could not delete Pictures')
+ expect(flash[:warn]).to match("Could not delete Pictures")
end
end
@@ -284,7 +284,7 @@ module Alchemy
it "should delete the pictures give a notice about deleting them" do
subject
- expect(flash[:notice]).to match('successfully')
+ expect(flash[:notice]).to match("successfully")
end
end
@@ -298,15 +298,15 @@ module Alchemy
it "should give a warning for the non deletable pictures and delete the others" do
expect(deletable_picture).to receive(:destroy)
subject
- expect(flash[:warn]).to match('could not be deleted')
+ expect(flash[:warn]).to match("could not be deleted")
end
end
- context 'with error happening' do
+ context "with error happening" do
let(:picture_ids) { deletable_picture.id.to_s }
before do
- expect(Picture).to receive(:find).and_raise('yada')
+ expect(Picture).to receive(:find).and_raise("yada")
end
it "sets error message" do
@@ -322,8 +322,8 @@ module Alchemy
end
end
- describe '#destroy' do
- let(:picture) { build_stubbed(:alchemy_picture, name: 'Cute kitten') }
+ describe "#destroy" do
+ let(:picture) { build_stubbed(:alchemy_picture, name: "Cute kitten") }
before do
expect(Picture).to receive(:find).and_return(picture)
@@ -336,9 +336,9 @@ module Alchemy
expect(flash[:notice]).not_to be_blank
end
- context 'if an error happens' do
+ context "if an error happens" do
before do
- expect(picture).to receive(:destroy).and_raise('yada')
+ expect(picture).to receive(:destroy).and_raise("yada")
end
it "shows error notice" do
@@ -357,51 +357,51 @@ module Alchemy
end
end
- describe '#items_per_page' do
+ describe "#items_per_page" do
subject { controller.send(:items_per_page) }
before do
expect(controller).to receive(:params).at_least(:once) { params }
end
- context 'in overlay' do
+ context "in overlay" do
let(:params) { {content_id: :id, size: size} }
- context 'with params[:size] set to medium' do
- let(:size) { 'medium' }
+ context "with params[:size] set to medium" do
+ let(:size) { "medium" }
it { is_expected.to eq(9) }
end
- context 'with params[:size] set to small' do
- let(:size) { 'small' }
+ context "with params[:size] set to small" do
+ let(:size) { "small" }
it { is_expected.to eq(25) }
end
- context 'with params[:size] set to large' do
- let(:size) { 'large' }
+ context "with params[:size] set to large" do
+ let(:size) { "large" }
it { is_expected.to eq(4) }
end
end
- context 'in archive' do
+ context "in archive" do
let(:params) { {size: size} }
- context 'with params[:size] set to medium' do
- let(:size) { 'medium' }
+ context "with params[:size] set to medium" do
+ let(:size) { "medium" }
it { is_expected.to eq(20) }
- context 'with cookie set' do
+ context "with cookie set" do
before do
@request.cookies[:alchemy_pictures_per_page] = 2
end
it { is_expected.to eq(2) }
- context 'with params[:per_page] given' do
+ context "with params[:per_page] given" do
let(:params) { {per_page: 8, size: size} }
it { is_expected.to eq(8) }
@@ -409,14 +409,14 @@ module Alchemy
end
end
- context 'with params[:size] set to small' do
- let(:size) { 'small' }
+ context "with params[:size] set to small" do
+ let(:size) { "small" }
it { is_expected.to eq(60) }
end
- context 'with params[:size] set to large' do
- let(:size) { 'large' }
+ context "with params[:size] set to large" do
+ let(:size) { "large" }
it { is_expected.to eq(12) }
end
diff --git a/spec/controllers/alchemy/admin/resources_controller_spec.rb b/spec/controllers/alchemy/admin/resources_controller_spec.rb
index ac3cccc6a1..349e6d4096 100644
--- a/spec/controllers/alchemy/admin/resources_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/resources_controller_spec.rb
@@ -1,16 +1,16 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
describe Admin::EventsController do
it "should include ResourcesHelper" do
expect(controller.respond_to?(:resource_window_size)).to be_truthy
end
- describe '#index' do
+ describe "#index" do
let(:params) { Hash.new }
- let!(:peter) { create(:event, name: 'Peter') }
- let!(:lustig) { create(:event, name: 'Lustig') }
+ let!(:peter) { create(:event, name: "Peter") }
+ let!(:lustig) { create(:event, name: "Lustig") }
before do
authorize_user(:as_admin)
@@ -22,7 +22,7 @@
expect(assigns(:events)).to include(lustig)
end
- context 'with search query given' do
+ context "with search query given" do
let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: "PeTer"}} }
it "returns only matching records" do
@@ -32,7 +32,7 @@
end
context "but searching for record with certain association" do
- let(:bauwagen) { create(:location, name: 'Bauwagen') }
+ let(:bauwagen) { create(:location, name: "Bauwagen") }
let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: "Bauwagen"}} }
before do
@@ -47,7 +47,7 @@
end
end
- context 'with sort parameter given' do
+ context "with sort parameter given" do
let(:params) { {q: {s: "name desc"}} }
it "returns records in the defined order" do
@@ -56,15 +56,15 @@
end
end
- context 'without sort parameter given' do
- context 'if resource has name attribute' do
+ context "without sort parameter given" do
+ context "if resource has name attribute" do
it "returns records sorted by name" do
get :index
expect(assigns(:events)).to eq([lustig, peter])
end
end
- context 'if resource has no name attribute' do
+ context "if resource has no name attribute" do
let!(:booking1) { Booking.create!(from: 2.week.from_now) }
let!(:booking2) { Booking.create!(from: 1.weeks.from_now) }
@@ -83,59 +83,70 @@ def resource_handler
end
end
- describe '#update' do
- let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: 'some_query'}, page: 6} }
+ describe "#update" do
+ let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: "some_query"}, page: 6} }
- context 'with regular noun model name' do
- let(:peter) { create(:event, name: 'Peter') }
+ context "with regular noun model name" do
+ let(:peter) { create(:event, name: "Peter") }
- it 'redirects to index, keeping the current location parameters' do
+ it "redirects to index, keeping the current location parameters" do
post :update, params: {id: peter.id, event: {name: "Hans"}}.merge(params)
expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q%5Bname_or_hidden_name_or_description_or_location_name_cont%5D=some_query")
end
end
- context 'with zero plural noun model name' do
- let!(:peter) { create(:series, name: 'Peter') }
- let(:params) { {q: { name_cont: 'some_query'}, page: 6} }
+ context "with zero plural noun model name" do
+ let!(:peter) { create(:series, name: "Peter") }
+ let(:params) { {q: { name_cont: "some_query"}, page: 6} }
- it 'redirects to index, keeping the current location parameters' do
- expect(controller).to receive(:controller_path) { 'admin/series' }
+ it "redirects to index, keeping the current location parameters" do
+ expect(controller).to receive(:controller_path) { "admin/series" }
post :update, params: {id: peter.id, series: {name: "Hans"}}.merge(params)
expect(response.redirect_url).to eq("http://test.host/admin/series?page=6&q%5Bname_cont%5D=some_query")
end
end
end
- describe '#create' do
- let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: 'some_query'}, page: 6} }
+ describe "#create" do
+ let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: "some_query"}, page: 6} }
let!(:location) { create(:location) }
- context 'with regular noun model name' do
- it 'redirects to index, keeping the current location parameters' do
+ context "with regular noun model name" do
+ it "redirects to index, keeping the current location parameters" do
post :create, params: {event: {name: "Hans", location_id: location.id}}.merge(params)
expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q%5Bname_or_hidden_name_or_description_or_location_name_cont%5D=some_query")
end
end
- context 'with zero plural noun model name' do
- let(:params) { {q: {name_cont: 'some_query'}, page: 6} }
+ context "with zero plural noun model name" do
+ let(:params) { {q: {name_cont: "some_query"}, page: 6} }
- it 'redirects to index, keeping the current location parameters' do
- expect(controller).to receive(:controller_path) { 'admin/series' }
+ it "redirects to index, keeping the current location parameters" do
+ expect(controller).to receive(:controller_path) { "admin/series" }
post :create, params: {series: {name: "Hans"}}.merge(params)
expect(response.redirect_url).to eq("http://test.host/admin/series?page=6&q%5Bname_cont%5D=some_query")
end
end
end
- describe '#destroy' do
- let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: 'some_query'}, page: 6} }
- let!(:peter) { create(:event, name: 'Peter') }
+ describe "#destroy" do
+ let(:params) { {q: {name_or_hidden_name_or_description_or_location_name_cont: "some_query"}, page: 6} }
+ let!(:peter) { create(:event, name: "Peter") }
- it 'redirects to index, keeping the current location parameters' do
+ it "redirects to index, keeping the current location parameters" do
delete :destroy, params: {id: peter.id}.merge(params)
expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q%5Bname_or_hidden_name_or_description_or_location_name_cont%5D=some_query")
end
+
+ context "If the resource is not destroyable" do
+ let!(:undestroyable) { create(:event, name: "Undestructible") }
+
+ it "adds an error flash" do
+ delete :destroy, params: {id: undestroyable.id}.merge(params)
+
+ expect(response.redirect_url).to eq("http://test.host/admin/events?page=6&q%5Bname_or_hidden_name_or_description_or_location_name_cont%5D=some_query")
+ expect(flash[:error]).to eq("This is the undestructible event!")
+ end
+ end
end
end
diff --git a/spec/controllers/alchemy/admin/sites_controller_spec.rb b/spec/controllers/alchemy/admin/sites_controller_spec.rb
index d23aa3eeeb..af19397f17 100644
--- a/spec/controllers/alchemy/admin/sites_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/sites_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
describe Alchemy::Admin::SitesController do
routes { Alchemy::Engine.routes }
@@ -10,18 +10,18 @@
end
describe "#create" do
- context 'with valid params' do
- it 'redirects to the languages admin' do
- post :create, params: { site: { host: '*' } }
+ context "with valid params" do
+ it "redirects to the languages admin" do
+ post :create, params: { site: { host: "*" } }
site = Alchemy::Site.last
expect(response).to redirect_to admin_languages_path(site_id: site)
- expect(flash[:notice]).to eq('Please create a default language for this site.')
+ expect(flash[:notice]).to eq("Please create a default language for this site.")
end
end
- context 'with invalid params' do
- it 'shows the form again' do
- post :create, params: { site: { host: '' } }
+ context "with invalid params" do
+ it "shows the form again" do
+ post :create, params: { site: { host: "" } }
expect(response).to render_template(:new)
end
end
@@ -30,22 +30,22 @@
describe "#destroy" do
let(:site) { create(:alchemy_site) }
- context 'with languages attached' do
+ context "with languages attached" do
let!(:language) { create(:alchemy_language, site: site) }
- it 'returns with error message' do
+ it "returns with error message" do
delete :destroy, params: { id: site.id }
expect(response).to redirect_to admin_sites_path
expect(flash[:warning]).to \
- eq('Languages are still attached to this site. Please remove them first.')
+ eq("Languages are still attached to this site. Please remove them first.")
end
end
- context 'without languages' do
- it 'removes the site' do
+ context "without languages" do
+ it "removes the site" do
delete :destroy, params: { id: site.id }
expect(response).to redirect_to admin_sites_path
- expect(flash[:notice]).to eq('Website successfully removed.')
+ expect(flash[:notice]).to eq("Website successfully removed.")
end
end
end
diff --git a/spec/controllers/alchemy/admin/tags_controller_spec.rb b/spec/controllers/alchemy/admin/tags_controller_spec.rb
index b1d0f31c8c..8ed53cb767 100644
--- a/spec/controllers/alchemy/admin/tags_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/tags_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
module Admin
@@ -9,29 +9,29 @@ module Admin
before { authorize_user(:as_admin) }
- describe '#create' do
- context 'without required params' do
+ describe "#create" do
+ context "without required params" do
render_views
it "does not create tag" do
- post :create, params: {tag: {name: ''}}
+ post :create, params: {tag: {name: ""}}
expect(response.body).to have_content("can't be blank")
end
end
- context 'with required params' do
+ context "with required params" do
it "creates tag and redirects to tags view" do
expect {
- post :create, params: {tag: {name: 'Foo'}}
+ post :create, params: {tag: {name: "Foo"}}
}.to change { Gutentag::Tag.count }.by(1)
expect(response).to redirect_to admin_tags_path
end
end
end
- describe '#edit' do
- let(:tag) { Gutentag::Tag.create(name: 'Sputz') }
- let(:another_tag) { Gutentag::Tag.create(name: 'Hutzl') }
+ describe "#edit" do
+ let(:tag) { Gutentag::Tag.create(name: "Sputz") }
+ let(:another_tag) { Gutentag::Tag.create(name: "Hutzl") }
before { another_tag; tag }
@@ -42,17 +42,17 @@ module Admin
end
end
- describe '#update' do
- let(:tag) { Gutentag::Tag.create(name: 'Sputz') }
+ describe "#update" do
+ let(:tag) { Gutentag::Tag.create(name: "Sputz") }
it "changes tags name" do
- put :update, params: {id: tag.id, tag: {name: 'Foo'}}
+ put :update, params: {id: tag.id, tag: {name: "Foo"}}
expect(response).to redirect_to(admin_tags_path)
- expect(tag.reload.name).to eq('Foo')
+ expect(tag.reload.name).to eq("Foo")
end
- context 'with merg_to param given' do
- let(:another_tag) { Gutentag::Tag.create(name: 'Hutzl') }
+ context "with merg_to param given" do
+ let(:another_tag) { Gutentag::Tag.create(name: "Hutzl") }
it "replaces tag with other tag" do
expect(Alchemy::Tag).to receive(:replace)
diff --git a/spec/controllers/alchemy/admin/translations_spec.rb b/spec/controllers/alchemy/admin/translations_spec.rb
index 0661f29583..6271d887b1 100644
--- a/spec/controllers/alchemy/admin/translations_spec.rb
+++ b/spec/controllers/alchemy/admin/translations_spec.rb
@@ -1,16 +1,16 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
describe Alchemy::Admin::DashboardController do
routes { Alchemy::Engine.routes }
context "in admin backend" do
- let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: 'de') }
+ let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: "de") }
before { authorize_user(dummy_user) }
- context 'if locale is available' do
+ context "if locale is available" do
before do
expect(Alchemy::I18n).to receive(:available_locales).at_least(:once) do
[:de, :nl, :en]
@@ -18,26 +18,26 @@
end
it "should be possible to set the locale of the admin backend via params" do
- get :index, params: {admin_locale: 'nl'}
+ get :index, params: {admin_locale: "nl"}
expect(::I18n.locale).to eq(:nl)
end
it "should store the current locale in the session" do
- get :index, params: {admin_locale: 'nl'}
+ get :index, params: {admin_locale: "nl"}
expect(session[:alchemy_locale]).to eq(:nl)
end
it "should be possible to change the current locale in the session" do
- get :index, params: {admin_locale: 'de'}
+ get :index, params: {admin_locale: "de"}
expect(session[:alchemy_locale]).to eq(:de)
- get :index, params: {admin_locale: 'en'}
+ get :index, params: {admin_locale: "en"}
expect(session[:alchemy_locale]).to eq(:en)
end
end
- context 'with unknown locale' do
+ context "with unknown locale" do
it "it uses the users default language" do
- get :index, params: {admin_locale: 'ko'}
+ get :index, params: {admin_locale: "ko"}
expect(::I18n.locale).to eq(:de)
end
end
@@ -51,7 +51,7 @@
context "if user has no preferred locale" do
let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: nil) }
- context 'if locale is available' do
+ context "if locale is available" do
before do
expect(Alchemy::I18n).to receive(:available_locales).at_least(:once) do
[:es, :nl]
@@ -59,7 +59,7 @@
end
it "should use the browsers language setting" do
- request.headers['ACCEPT-LANGUAGE'] = 'es-ES'
+ request.headers["ACCEPT-LANGUAGE"] = "es-ES"
get :index
expect(::I18n.locale).to eq(:es)
end
@@ -70,7 +70,7 @@
context "if language doesn't return a valid locale symbol" do
it "should use the browsers language setting" do
- request.headers['ACCEPT-LANGUAGE'] = 'es-ES'
+ request.headers["ACCEPT-LANGUAGE"] = "es-ES"
get :index
expect(::I18n.locale).to eq(:es)
end
diff --git a/spec/controllers/alchemy/admin/trash_controller_spec.rb b/spec/controllers/alchemy/admin/trash_controller_spec.rb
index acba8ceb16..708ee66b4f 100644
--- a/spec/controllers/alchemy/admin/trash_controller_spec.rb
+++ b/spec/controllers/alchemy/admin/trash_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
module Admin
diff --git a/spec/controllers/alchemy/api/contents_controller_spec.rb b/spec/controllers/alchemy/api/contents_controller_spec.rb
index 3d0d56a4cc..d4fba343aa 100644
--- a/spec/controllers/alchemy/api/contents_controller_spec.rb
+++ b/spec/controllers/alchemy/api/contents_controller_spec.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Api::ContentsController do
routes { Alchemy::Engine.routes }
- describe '#index' do
+ describe "#index" do
let!(:page) { create(:alchemy_page) }
let!(:element) { create(:alchemy_element, page: page) }
let!(:content) { create(:alchemy_content, element: element) }
@@ -15,15 +15,15 @@ module Alchemy
get :index, params: {format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
expect(result).to have_key("contents")
- expect(result['contents'].size).to eq(Alchemy::Content.count)
+ expect(result["contents"].size).to eq(Alchemy::Content.count)
end
- context 'with element_id' do
+ context "with element_id" do
let!(:other_element) { create(:alchemy_element, page: page) }
let!(:other_content) { create(:alchemy_content, element: other_element) }
@@ -31,31 +31,31 @@ module Alchemy
get :index, params: {element_id: other_element.id, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
expect(result).to have_key("contents")
- expect(result['contents'].size).to eq(1)
- expect(result['contents'][0]['element_id']).to eq(other_element.id)
+ expect(result["contents"].size).to eq(1)
+ expect(result["contents"][0]["element_id"]).to eq(other_element.id)
end
end
- context 'with empty element_id' do
+ context "with empty element_id" do
it "returns all contents" do
get :index, params: {element_id: element.id, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
expect(result).to have_key("contents")
- expect(result['contents'].size).to eq(Alchemy::Content.count)
+ expect(result["contents"].size).to eq(Alchemy::Content.count)
end
end
- context 'as author' do
+ context "as author" do
before do
authorize_user(build(:alchemy_dummy_user, :as_author))
end
@@ -64,18 +64,18 @@ module Alchemy
get :index, params: {format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('contents')
- expect(result['contents'].size).to eq(Alchemy::Content.count)
+ expect(result).to have_key("contents")
+ expect(result["contents"].size).to eq(Alchemy::Content.count)
end
end
end
- describe '#show' do
- context 'with no other params given' do
+ describe "#show" do
+ context "with no other params given" do
let(:page) { create(:alchemy_page) }
let(:element) { create(:alchemy_element, page: page) }
let(:content) { create(:alchemy_content, element: element) }
@@ -84,58 +84,58 @@ module Alchemy
get :show, params: {id: content.id, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result['id']).to eq(content.id)
+ expect(result["id"]).to eq(content.id)
end
- context 'requesting an restricted content' do
+ context "requesting an restricted content" do
let(:page) { create(:alchemy_page, restricted: true) }
it "responds with 403" do
get :show, params: {id: content.id, format: :json}
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
expect(response.status).to eq(403)
result = JSON.parse(response.body)
expect(result).to have_key("error")
- expect(result['error']).to eq("Not authorized")
+ expect(result["error"]).to eq("Not authorized")
end
end
end
- context 'with element_id and name params given' do
+ context "with element_id and name params given" do
let!(:page) { create(:alchemy_page) }
let!(:element) { create(:alchemy_element, page: page) }
let!(:content) { create(:alchemy_content, element: element) }
- it 'returns the named content from element with given id.' do
+ it "returns the named content from element with given id." do
get :show, params: {element_id: element.id, name: content.name, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result['id']).to eq(content.id)
+ expect(result["id"]).to eq(content.id)
end
end
- context 'with empty element_id or name param' do
- it 'returns 404 error.' do
- get :show, params: {element_id: '', name: '', format: :json}
+ context "with empty element_id or name param" do
+ it "returns 404 error." do
+ get :show, params: {element_id: "", name: "", format: :json}
expect(response.status).to eq(404)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
expect(result).to have_key("error")
- expect(result['error']).to eq("Record not found")
+ expect(result["error"]).to eq("Record not found")
end
end
end
diff --git a/spec/controllers/alchemy/api/elements_controller_spec.rb b/spec/controllers/alchemy/api/elements_controller_spec.rb
index ddd3118252..0173aeda63 100644
--- a/spec/controllers/alchemy/api/elements_controller_spec.rb
+++ b/spec/controllers/alchemy/api/elements_controller_spec.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Api::ElementsController do
routes { Alchemy::Engine.routes }
- describe '#index' do
+ describe "#index" do
let(:page) { create(:alchemy_page, :public) }
before do
@@ -18,15 +18,15 @@ module Alchemy
get :index, params: {format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].last['nested_elements']).to_not be_empty
- expect(result['elements'].size).to eq(Alchemy::Element.not_nested.count)
+ expect(result).to have_key("elements")
+ expect(result["elements"].last["nested_elements"]).to_not be_empty
+ expect(result["elements"].size).to eq(Alchemy::Element.not_nested.count)
end
- context 'with page_id param' do
+ context "with page_id param" do
let!(:other_page) { create(:alchemy_page, :public) }
let!(:other_element) { create(:alchemy_element, page: other_page) }
@@ -34,62 +34,62 @@ module Alchemy
get :index, params: {page_id: other_page.id, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].size).to eq(1)
- expect(result['elements'][0]['page_id']).to eq(other_page.id)
+ expect(result).to have_key("elements")
+ expect(result["elements"].size).to eq(1)
+ expect(result["elements"][0]["page_id"]).to eq(other_page.id)
end
end
- context 'with empty page_id param' do
+ context "with empty page_id param" do
it "returns all not nested elements" do
- get :index, params: {page_id: '', format: :json}
+ get :index, params: {page_id: "", format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].size).to eq(Alchemy::Element.not_nested.count)
+ expect(result).to have_key("elements")
+ expect(result["elements"].size).to eq(Alchemy::Element.not_nested.count)
end
end
- context 'with named param' do
- let!(:other_element) { create(:alchemy_element, page: page, name: 'news') }
+ context "with named param" do
+ let!(:other_element) { create(:alchemy_element, page: page, name: "news") }
it "returns only elements named like this." do
- get :index, params: {named: 'news', format: :json}
+ get :index, params: {named: "news", format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].size).to eq(1)
- expect(result['elements'][0]['name']).to eq('news')
+ expect(result).to have_key("elements")
+ expect(result["elements"].size).to eq(1)
+ expect(result["elements"][0]["name"]).to eq("news")
end
end
- context 'with empty named param' do
+ context "with empty named param" do
it "returns all not nested elements" do
- get :index, params: {named: '', format: :json}
+ get :index, params: {named: "", format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].size).to eq(Alchemy::Element.not_nested.count)
+ expect(result).to have_key("elements")
+ expect(result["elements"].size).to eq(Alchemy::Element.not_nested.count)
end
end
- context 'as author' do
+ context "as author" do
before do
authorize_user(build(:alchemy_dummy_user, :as_author))
end
@@ -98,17 +98,17 @@ module Alchemy
get :index, params: {format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('elements')
- expect(result['elements'].size).to eq(Alchemy::Element.not_nested.count)
+ expect(result).to have_key("elements")
+ expect(result["elements"].size).to eq(Alchemy::Element.not_nested.count)
end
end
end
- describe '#show' do
+ describe "#show" do
let(:page) { create(:alchemy_page) }
let(:element) { create(:alchemy_element, page: page, position: 1) }
@@ -116,26 +116,26 @@ module Alchemy
get :show, params: {id: element.id, format: :json}
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result['id']).to eq(element.id)
+ expect(result["id"]).to eq(element.id)
end
- context 'requesting an restricted element' do
+ context "requesting an restricted element" do
let(:page) { create(:alchemy_page, restricted: true) }
it "responds with 403" do
get :show, params: {id: element.id, format: :json}
expect(response.status).to eq(403)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('error')
- expect(result['error']).to eq("Not authorized")
+ expect(result).to have_key("error")
+ expect(result["error"]).to eq("Not authorized")
end
end
end
diff --git a/spec/controllers/alchemy/api/pages_controller_spec.rb b/spec/controllers/alchemy/api/pages_controller_spec.rb
index 67f08cee50..57b96dc1ee 100644
--- a/spec/controllers/alchemy/api/pages_controller_spec.rb
+++ b/spec/controllers/alchemy/api/pages_controller_spec.rb
@@ -1,61 +1,61 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe Api::PagesController do
routes { Alchemy::Engine.routes }
- describe '#index' do
- context 'without a Language present' do
+ describe "#index" do
+ context "without a Language present" do
let(:result) { JSON.parse(response.body) }
- it 'returns JSON' do
- get :index, params: {format: :json}
- expect(result['pages']).to eq([])
+ it "returns JSON" do
+ get :index, params: { format: :json }
+ expect(result["pages"]).to eq([])
end
end
- context 'with a language and a page present' do
+ context "with a language and a page present" do
let!(:page) { create(:alchemy_page, :public) }
let(:result) { JSON.parse(response.body) }
- it 'returns JSON' do
- get :index, params: {format: :json}
+ it "returns JSON" do
+ get :index, params: { format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
- expect(result).to have_key('pages')
+ expect(response.media_type).to eq("application/json")
+ expect(result).to have_key("pages")
end
it "returns all public pages" do
- get :index, params: {format: :json}
+ get :index, params: { format: :json }
- expect(result['pages'].size).to eq(2)
+ expect(result["pages"].size).to eq(2)
end
- context 'as author' do
+ context "as author" do
before do
authorize_user(build(:alchemy_dummy_user, :as_author))
end
it "returns all pages" do
- get :index, params: {format: :json}
+ get :index, params: { format: :json }
- expect(result['pages'].size).to eq(Alchemy::Page.count)
+ expect(result["pages"].size).to eq(Alchemy::Page.count)
end
end
- it 'includes meta data' do
+ it "includes meta data" do
get :index, params: { format: :json }
- expect(result['pages'].size).to eq(2)
- expect(result['meta']['page']).to be_nil
- expect(result['meta']['per_page']).to eq(2)
- expect(result['meta']['total_count']).to eq(2)
+ expect(result["pages"].size).to eq(2)
+ expect(result["meta"]["page"]).to be_nil
+ expect(result["meta"]["per_page"]).to eq(2)
+ expect(result["meta"]["total_count"]).to eq(2)
end
- context 'with page param given' do
+ context "with page param given" do
let!(:page1) { create(:alchemy_page) }
let!(:page2) { create(:alchemy_page) }
@@ -63,49 +63,49 @@ module Alchemy
expect(Kaminari.config).to receive(:default_per_page).at_least(:once) { 1 }
end
- it 'returns paginated result' do
+ it "returns paginated result" do
get :index, params: { page: 2, format: :json }
- expect(result['pages'].size).to eq(1)
- expect(result['meta']['page']).to eq(2)
- expect(result['meta']['per_page']).to eq(1)
- expect(result['meta']['total_count']).to eq(2)
+ expect(result["pages"].size).to eq(1)
+ expect(result["meta"]["page"]).to eq(2)
+ expect(result["meta"]["per_page"]).to eq(1)
+ expect(result["meta"]["total_count"]).to eq(2)
end
end
- context 'with ransack query param given' do
- it 'returns filtered result' do
+ context "with ransack query param given" do
+ it "returns filtered result" do
get :index, params: { q: { name_eq: page.name }, format: :json }
- expect(result['pages'].size).to eq(1)
+ expect(result["pages"].size).to eq(1)
end
end
end
- describe '#nested' do
- let!(:page) { create(:alchemy_page, :public, page_layout: 'contact') }
+ describe "#nested" do
+ let!(:page) { create(:alchemy_page, :public, page_layout: "contact") }
it "returns all pages as nested json tree without admin related infos", :aggregate_failures do
- get :nested, params: {format: :json}
+ get :nested, params: { format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('pages')
- expect(result['pages'].size).to eq(1)
- expect(result['pages'][0]).to have_key('children')
- expect(result['pages'][0]['children'].size).to eq(1)
+ expect(result).to have_key("pages")
+ expect(result["pages"].size).to eq(1)
+ expect(result["pages"][0]).to have_key("children")
+ expect(result["pages"][0]["children"].size).to eq(1)
- child = result['pages'][0]['children'][0]
+ child = result["pages"][0]["children"][0]
- expect(child['name']).to eq(page.name)
- expect(child).to_not have_key('definition_missing')
- expect(child).to_not have_key('folded')
- expect(child).to_not have_key('locked')
- expect(child).to_not have_key('permissions')
- expect(child).to_not have_key('status_titles')
+ expect(child["name"]).to eq(page.name)
+ expect(child).to_not have_key("definition_missing")
+ expect(child).to_not have_key("folded")
+ expect(child).to_not have_key("locked")
+ expect(child).to_not have_key("permissions")
+ expect(child).to_not have_key("status_titles")
end
context "as author" do
@@ -114,54 +114,54 @@ module Alchemy
end
it "returns all pages as nested json tree with admin related infos", :aggregate_failures do
- get :nested, params: {format: :json}
+ get :nested, params: { format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('pages')
- expect(result['pages'].size).to eq(1)
- expect(result['pages'][0]).to have_key('children')
- expect(result['pages'][0]['children'].size).to eq(1)
+ expect(result).to have_key("pages")
+ expect(result["pages"].size).to eq(1)
+ expect(result["pages"][0]).to have_key("children")
+ expect(result["pages"][0]["children"].size).to eq(1)
- child = result['pages'][0]['children'][0]
+ child = result["pages"][0]["children"][0]
- expect(child['name']).to eq(page.name)
- expect(child).to have_key('definition_missing')
- expect(child).to have_key('folded')
- expect(child).to have_key('locked')
- expect(child).to have_key('permissions')
- expect(child).to have_key('status_titles')
+ expect(child["name"]).to eq(page.name)
+ expect(child).to have_key("definition_missing")
+ expect(child).to have_key("folded")
+ expect(child).to have_key("locked")
+ expect(child).to have_key("permissions")
+ expect(child).to have_key("status_titles")
end
end
context "when a page_id is passed" do
- it 'returns all pages as nested json from this page only' do
- get :nested, params: {page_id: page.id, format: :json}
+ it "returns all pages as nested json from this page only" do
+ get :nested, params: { page_id: page.id, format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('pages')
- expect(result['pages'][0]['name']).to eq(page.name)
+ expect(result).to have_key("pages")
+ expect(result["pages"][0]["name"]).to eq(page.name)
end
end
context "when `elements=true` is passed" do
- it 'returns all pages as nested json tree with elements included' do
- get :nested, params: {elements: 'true', format: :json}
+ it "returns all pages as nested json tree with elements included" do
+ get :nested, params: { elements: "true", format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('pages')
- expect(result['pages'][0]).to have_key('elements')
+ expect(result).to have_key("pages")
+ expect(result["pages"][0]).to have_key("elements")
end
context "and elements is a comma separated list of element names" do
@@ -169,128 +169,129 @@ module Alchemy
page.send(:generate_elements)
end
- it 'returns all pages as nested json tree with only these elements included' do
- get :nested, params: {elements: 'headline,text', format: :json}
+ it "returns all pages as nested json tree with only these elements included" do
+ get :nested, params: { elements: "headline,text", format: :json }
result = JSON.parse(response.body)
- elements = result['pages'][0]['children'][0]['elements']
- element_names = elements.collect { |element| element['name'] }
- expect(element_names).to include('headline', 'text')
- expect(element_names).to_not include('contactform')
+ elements = result["pages"][0]["children"][0]["elements"]
+ element_names = elements.collect { |element| element["name"] }
+ expect(element_names).to include("headline", "text")
+ expect(element_names).to_not include("contactform")
end
end
end
end
end
- describe '#show' do
- context 'for existing page' do
- let(:page) { create(:alchemy_page, :public, urlname: 'a-page') }
+ describe "#show" do
+ context "for existing page" do
+ let(:page) { create(:alchemy_page, :public, urlname: "a-page") }
it "returns page as json" do
- get :show, params: {urlname: page.urlname, format: :json}
+ get :show, params: { urlname: page.urlname, format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result['id']).to eq(page.id)
+ expect(result["id"]).to eq(page.id)
+ expect(result["url_path"]).to eq("/a-page")
end
- context 'requesting an restricted page' do
- let(:page) { create(:alchemy_page, restricted: true, urlname: 'a-page') }
+ context "requesting an restricted page" do
+ let(:page) { create(:alchemy_page, restricted: true, urlname: "a-page") }
it "responds with 403" do
- get :show, params: {urlname: page.urlname, format: :json}
+ get :show, params: { urlname: page.urlname, format: :json }
expect(response.status).to eq(403)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('error')
- expect(result['error']).to eq("Not authorized")
+ expect(result).to have_key("error")
+ expect(result["error"]).to eq("Not authorized")
end
end
- context 'requesting a not public page' do
- let(:page) { create(:alchemy_page, urlname: 'a-page') }
+ context "requesting a not public page" do
+ let(:page) { create(:alchemy_page, urlname: "a-page") }
it "responds with 403" do
- get :show, params: {urlname: page.urlname, format: :json}
+ get :show, params: { urlname: page.urlname, format: :json }
expect(response.status).to eq(403)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('error')
- expect(result['error']).to eq("Not authorized")
+ expect(result).to have_key("error")
+ expect(result["error"]).to eq("Not authorized")
end
end
end
- context 'requesting an unknown page' do
+ context "requesting an unknown page" do
it "responds with 404" do
- get :show, params: {urlname: 'not-existing', format: :json}
+ get :show, params: { urlname: "not-existing", format: :json }
expect(response.status).to eq(404)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result).to have_key('error')
- expect(result['error']).to eq("Record not found")
+ expect(result).to have_key("error")
+ expect(result["error"]).to eq("Record not found")
end
context "because of requesting not existing language" do
let(:page) { create(:alchemy_page, :public) }
it "responds with 404" do
- get :show, params: {urlname: page.urlname, locale: 'na', format: :json}
+ get :show, params: { urlname: page.urlname, locale: "na", format: :json }
expect(response.status).to eq(404)
end
end
end
- context 'requesting a page with id' do
+ context "requesting a page with id" do
let(:page) { create(:alchemy_page, :public) }
it "responds with json" do
- get :show, params: {urlname: page.id, format: :json}
+ get :show, params: { urlname: page.id, format: :json }
expect(response.status).to eq(200)
- expect(response.media_type).to eq('application/json')
+ expect(response.media_type).to eq("application/json")
result = JSON.parse(response.body)
- expect(result['id']).to eq(page.id)
+ expect(result["id"]).to eq(page.id)
end
end
- context 'in an environment with multiple languages' do
+ context "in an environment with multiple languages" do
let!(:default_language) { create(:alchemy_language, :english, default: true) }
let(:klingon) { create(:alchemy_language, :klingon) }
- context 'having two pages with the same url names in different languages' do
+ context "having two pages with the same url names in different languages" do
let!(:english_page) { create(:alchemy_page, :public, language: default_language, name: "same-name") }
let!(:klingon_page) { create(:alchemy_page, :public, language: klingon, name: "same-name") }
- context 'when a locale is given' do
- it 'renders the page related to its language' do
- get :show, params: {urlname: "same-name", locale: klingon_page.language_code, format: :json}
+ context "when a locale is given" do
+ it "renders the page related to its language" do
+ get :show, params: { urlname: "same-name", locale: klingon_page.language_code, format: :json }
result = JSON.parse(response.body)
- expect(result['id']).to eq(klingon_page.id)
+ expect(result["id"]).to eq(klingon_page.id)
end
end
- context 'when no locale is given' do
- it 'renders the page of the default language' do
- get :show, params: {urlname: "same-name", format: :json}
+ context "when no locale is given" do
+ it "renders the page of the default language" do
+ get :show, params: { urlname: "same-name", format: :json }
result = JSON.parse(response.body)
- expect(result['id']).to eq(english_page.id)
+ expect(result["id"]).to eq(english_page.id)
end
end
end
diff --git a/spec/controllers/alchemy/attachments_controller_spec.rb b/spec/controllers/alchemy/attachments_controller_spec.rb
index f25a409004..86b8b6ef2e 100644
--- a/spec/controllers/alchemy/attachments_controller_spec.rb
+++ b/spec/controllers/alchemy/attachments_controller_spec.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe AttachmentsController do
@@ -12,7 +12,7 @@ module Alchemy
expect { get :download, params: {id: 0} }.to raise_error(ActiveRecord::RecordNotFound)
end
- context 'with public attachment' do
+ context "with public attachment" do
before do
allow(Attachment).to receive(:find).and_return(attachment)
end
@@ -20,35 +20,35 @@ module Alchemy
it "sends download as attachment." do
get :download, params: {id: attachment.id}
expect(response.status).to eq(200)
- expect(response.headers['Content-Disposition']).to match(/attachment/)
+ expect(response.headers["Content-Disposition"]).to match(/attachment/)
end
it "sends download inline." do
get :show, params: {id: attachment.id}
expect(response.status).to eq(200)
- expect(response.headers['Content-Disposition']).to match(/inline/)
+ expect(response.headers["Content-Disposition"]).to match(/inline/)
end
context "adds Content-Length to header" do
it "when downloading attachment" do
get :download, params: {id: attachment.id}
- expect(response.headers['Content-Length']).to eq(attachment.file_size.to_s)
+ expect(response.headers["Content-Length"]).to eq(attachment.file_size.to_s)
end
it "when showing attachment" do
get :show, params: {id: attachment.id}
- expect(response.headers['Content-Length']).to eq(attachment.file_size.to_s)
+ expect(response.headers["Content-Length"]).to eq(attachment.file_size.to_s)
end
end
end
- context 'with restricted attachment' do
+ context "with restricted attachment" do
before do
allow(attachment).to receive(:restricted?).and_return(true)
allow(Attachment).to receive(:find).and_return(attachment)
end
- context 'as anonymous user' do
+ context "as anonymous user" do
it "should not be possible to download attachments from restricted pages" do
get :download, params: {id: attachment.id}
expect(response.status).to eq(302)
diff --git a/spec/controllers/alchemy/base_controller_spec.rb b/spec/controllers/alchemy/base_controller_spec.rb
index 1ad49a6ba8..8287779e22 100644
--- a/spec/controllers/alchemy/base_controller_spec.rb
+++ b/spec/controllers/alchemy/base_controller_spec.rb
@@ -1,11 +1,11 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe BaseController do
- describe '#set_locale' do
- context 'with Language.current set' do
+ describe "#set_locale" do
+ context "with Language.current set" do
let(:language) { create(:alchemy_language, :klingon) }
before { Alchemy::Language.current = language }
@@ -16,7 +16,7 @@ module Alchemy
end
end
- context 'without Language.current set' do
+ context "without Language.current set" do
before { Alchemy::Language.current = nil }
it "does not set the ::I18n.locale" do
@@ -59,14 +59,14 @@ module Alchemy
let!(:default_site) { create(:alchemy_site, :default) }
let!(:site_2) do
- create(:alchemy_site, host: 'another-host.com')
+ create(:alchemy_site, host: "another-host.com")
end
let!(:site_2_language_2) do
create(:alchemy_language, :klingon, site: site_2)
end
- it 'only is true for current site' do
+ it "only is true for current site" do
is_expected.to be(false)
end
end
@@ -83,7 +83,7 @@ module Alchemy
context "and current language is not the default locale" do
before do
- allow(Alchemy::Language).to receive(:current) { double(code: 'kl') }
+ allow(Alchemy::Language).to receive(:current) { double(code: "kl") }
allow(::I18n).to receive(:default_locale) { :de }
end
@@ -92,7 +92,7 @@ module Alchemy
context "and current language is the default locale" do
before do
- allow(Alchemy::Language).to receive(:current) { double(code: 'de') }
+ allow(Alchemy::Language).to receive(:current) { double(code: "de") }
allow(::I18n).to receive(:default_locale) { :de }
end
@@ -100,7 +100,7 @@ module Alchemy
end
context "and passed in locale is not the default locale" do
- subject(:prefix_locale?) { controller.prefix_locale?('en') }
+ subject(:prefix_locale?) { controller.prefix_locale?("en") }
before do
allow(::I18n).to receive(:default_locale) { :de }
@@ -110,7 +110,7 @@ module Alchemy
end
context "and passed in locale is the default locale" do
- subject(:prefix_locale?) { controller.prefix_locale?('de') }
+ subject(:prefix_locale?) { controller.prefix_locale?("de") }
before do
allow(::I18n).to receive(:default_locale) { :de }
diff --git a/spec/controllers/alchemy/elements_controller_spec.rb b/spec/controllers/alchemy/elements_controller_spec.rb
index 2ddfc9869f..bcbe46c07a 100644
--- a/spec/controllers/alchemy/elements_controller_spec.rb
+++ b/spec/controllers/alchemy/elements_controller_spec.rb
@@ -1,17 +1,17 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe ElementsController do
routes { Alchemy::Engine.routes }
let(:public_page) { create(:alchemy_page, :public) }
- let(:element) { create(:alchemy_element, page: public_page, name: 'download') }
+ let(:element) { create(:alchemy_element, page: public_page, name: "download") }
let(:restricted_page) { create(:alchemy_page, :public, restricted: true) }
- let(:restricted_element) { create(:alchemy_element, page: restricted_page, name: 'download') }
+ let(:restricted_element) { create(:alchemy_element, page: restricted_page, name: "download") }
- describe '#show' do
+ describe "#show" do
it "should render available elements" do
get :show, params: {id: element.id}
expect(response.status).to eq(200)
diff --git a/spec/controllers/alchemy/messages_controller_spec.rb b/spec/controllers/alchemy/messages_controller_spec.rb
index 43c5a4579d..504544b568 100644
--- a/spec/controllers/alchemy/messages_controller_spec.rb
+++ b/spec/controllers/alchemy/messages_controller_spec.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
module Alchemy
describe MessagesController do
routes { Alchemy::Engine.routes }
- let(:page) { mock_model('Page') }
+ let(:page) { mock_model("Page") }
before do
controller.instance_variable_set(:@page, page)
@@ -14,7 +14,7 @@ module Alchemy
end
describe "#index" do
- let(:page) { mock_model('Page', {urlname: 'contact', page_layout: 'contact'}) }
+ let(:page) { mock_model("Page", {urlname: "contact", page_layout: "contact"}) }
it "should redirect to @page" do
expect(get(:index)).to redirect_to(show_page_path(urlname: page.urlname))
@@ -24,17 +24,17 @@ module Alchemy
describe "#new" do
it "should render the alchemy/pages/show template" do
get :new
- expect(get(:new)).to render_template('alchemy/pages/show')
+ expect(get(:new)).to render_template("alchemy/pages/show")
end
end
describe "#create" do
subject do
- post :create, params: {message: {email: ''}}
+ post :create, params: {message: {email: ""}}
end
- let(:page) { mock_model('Page', get_language_root: mock_model('Page')) }
- let(:element) { mock_model('Element', page: page, ingredient: '') }
+ let(:page) { mock_model("Page", get_language_root: mock_model("Page")) }
+ let(:element) { mock_model("Element", page: page, ingredient: "") }
let(:message) { Message.new }
it "should raise ActiveRecord::RecordNotFound if element of contactform could not be found" do
@@ -44,7 +44,7 @@ module Alchemy
context "if validation of message" do
before do
allow(Element).to receive(:find_by).and_return(element)
- allow(element).to receive(:ingredient).with(:success_page).and_return('thank-you')
+ allow(element).to receive(:ingredient).with(:success_page).and_return("thank-you")
allow_any_instance_of(Message).to receive(:contact_form_id).and_return(1)
end
@@ -54,7 +54,7 @@ module Alchemy
end
it "should render 'alchemy/pages/show' template" do
- expect(subject).to render_template('alchemy/pages/show')
+ expect(subject).to render_template("alchemy/pages/show")
end
end
@@ -69,16 +69,16 @@ module Alchemy
subject
end
- describe '#mail_to' do
+ describe "#mail_to" do
context "with element having mail_to ingredient" do
before do
- allow(element).to receive(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
+ allow(element).to receive(:ingredient).with(:mail_to).and_return("peter@schroeder.de")
message
allow(Message).to receive(:new).and_return(message)
end
it "returns the ingredient" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "peter@schroeder.de", "", "")
subject
end
end
@@ -91,22 +91,22 @@ module Alchemy
end
it "returns the config value" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "your.mail@your-domain.com", "", "")
subject
end
end
end
- describe '#mail_from' do
+ describe "#mail_from" do
context "with element having mail_from ingredient" do
before do
- allow(element).to receive(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
+ allow(element).to receive(:ingredient).with(:mail_from).and_return("peter@schroeder.de")
message
allow(Message).to receive(:new).and_return(message)
end
it "returns the ingredient" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "", "peter@schroeder.de", "")
subject
end
end
@@ -119,22 +119,22 @@ module Alchemy
end
it "returns the config value" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "", "your.mail@your-domain.com", "")
subject
end
end
end
- describe '#subject' do
+ describe "#subject" do
context "with element having subject ingredient" do
before do
- allow(element).to receive(:ingredient).with(:subject).and_return('A new message')
+ allow(element).to receive(:ingredient).with(:subject).and_return("A new message")
message
allow(Message).to receive(:new).and_return(message)
end
it "returns the ingredient" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, '', '', 'A new message')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "", "", "A new message")
subject
end
end
@@ -147,7 +147,7 @@ module Alchemy
end
it "returns the config value" do
- expect(MessagesMailer).to receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
+ expect(MessagesMailer).to receive(:contact_form_mail).with(message, "", "", "A new contact form message")
subject
end
end
@@ -155,20 +155,20 @@ module Alchemy
describe "#redirect_to_success_page" do
context "if 'success_page' ingredient of element" do
- context 'is set with urlname string' do
+ context "is set with urlname string" do
before do
- allow(element).to receive(:ingredient).with(:success_page).and_return('success-page')
+ allow(element).to receive(:ingredient).with(:success_page).and_return("success-page")
end
it "should redirect to the given urlname" do
expect(
- subject
- ).to redirect_to(show_page_path(urlname: 'success-page'))
+ subject,
+ ).to redirect_to(show_page_path(urlname: "success-page"))
end
end
- context 'is set with page instance' do
- let(:page) { build(:alchemy_page, name: 'Success', urlname: 'success-page') }
+ context "is set with page instance" do
+ let(:page) { build(:alchemy_page, name: "Success", urlname: "success-page") }
before do
allow(element).to receive(:ingredient).with(:success_page).and_return(page)
@@ -176,8 +176,8 @@ module Alchemy
it "should redirect to the given urlname" do
expect(
- subject
- ).to redirect_to(show_page_path(urlname: 'success-page'))
+ subject,
+ ).to redirect_to(show_page_path(urlname: "success-page"))
end
end
end
@@ -191,34 +191,34 @@ module Alchemy
before do
allow(controller).to receive(:mailer_config) do
{
- 'fields' => %w(email),
- 'forward_to_page' => true,
- 'mail_success_page' => 'mailer-config-success-page'
+ "fields" => %w(email),
+ "forward_to_page" => true,
+ "mail_success_page" => "mailer-config-success-page",
}
end
- allow(Page).to receive(:find_by).and_return double(urlname: 'mailer-config-success-page')
+ allow(Page).to receive(:find_by).and_return double(urlname: "mailer-config-success-page")
end
it "redirect to the given success page" do
expect(
- subject
- ).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
+ subject,
+ ).to redirect_to(show_page_path(urlname: "mailer-config-success-page"))
end
end
context "and mailer_config has no instructions for success_page" do
- let(:language) { mock_model('Language', code: 'en', locale: 'en', pages: double(find_by: build_stubbed(:alchemy_page))) }
+ let(:language) { mock_model("Language", code: "en", locale: "en", pages: double(find_by: build_stubbed(:alchemy_page))) }
before do
- allow(controller).to receive(:mailer_config).and_return({'fields' => %w(email)})
- allow(Language).to receive(:current_root_page).and_return double(urlname: 'lang-root')
+ allow(controller).to receive(:mailer_config).and_return({"fields" => %w(email)})
+ allow(Language).to receive(:current_root_page).and_return double(urlname: "lang-root")
end
it "should redirect to the language root page" do
allow(Language).to receive(:current).and_return(language)
expect(
- subject
- ).to redirect_to(show_page_path(urlname: 'lang-root'))
+ subject,
+ ).to redirect_to(show_page_path(urlname: "lang-root"))
end
end
end
diff --git a/spec/controllers/alchemy/on_page_layout_mixin_spec.rb b/spec/controllers/alchemy/on_page_layout_mixin_spec.rb
index 2c07c94a9d..2c3fc3fc8b 100644
--- a/spec/controllers/alchemy/on_page_layout_mixin_spec.rb
+++ b/spec/controllers/alchemy/on_page_layout_mixin_spec.rb
@@ -1,18 +1,18 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
-RSpec.describe Alchemy::PagesController, 'OnPageLayout mixin', type: :controller do
+RSpec.describe Alchemy::PagesController, "OnPageLayout mixin", type: :controller do
routes { Alchemy::Engine.routes }
before(:all) do
ApplicationController.extend Alchemy::OnPageLayout
end
- let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
+ let(:page) { create(:alchemy_page, :public, page_layout: "standard") }
- describe '.on_page_layout' do
- context 'with :all as argument for page_layout' do
+ describe ".on_page_layout" do
+ context "with :all as argument for page_layout" do
before do
ApplicationController.class_eval do
on_page_layout(:all) do
@@ -43,7 +43,7 @@
end
end
- context 'with :standard as argument for page_layout' do
+ context "with :standard as argument for page_layout" do
before do
ApplicationController.class_eval do
on_page_layout(:standard) do
@@ -52,28 +52,28 @@
end
end
- context 'and page having standard layout' do
+ context "and page having standard layout" do
context "for show action" do
- let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
+ let(:page) { create(:alchemy_page, :public, page_layout: "standard") }
- it 'runs the callback' do
+ it "runs the callback" do
get :show, params: {urlname: page.urlname}
expect(assigns(:successful_for_standard)).to eq(true)
end
end
context "for index action" do
- let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+ let!(:page) { create(:alchemy_page, :language_root, page_layout: "standard") }
- it 'runs the callback' do
+ it "runs the callback" do
get :index
expect(assigns(:successful_for_standard)).to eq(true)
end
end
end
- context 'and page not having standard layout' do
- let(:page) { create(:alchemy_page, :public, page_layout: 'news') }
+ context "and page not having standard layout" do
+ let(:page) { create(:alchemy_page, :public, page_layout: "news") }
context "for show action" do
it "doesn't run the callback" do
@@ -83,7 +83,7 @@
end
context "for index action" do
- let!(:page) { create(:alchemy_page, :language_root, page_layout: 'news') }
+ let!(:page) { create(:alchemy_page, :language_root, page_layout: "news") }
it "doesn't run the callback" do
get :index
@@ -93,7 +93,7 @@
end
end
- context 'when defining two callbacks for different page layouts' do
+ context "when defining two callbacks for different page layouts" do
context "for show action" do
before do
ApplicationController.class_eval do
@@ -141,7 +141,7 @@
end
end
- context 'when defining two callbacks for the same page_layout' do
+ context "when defining two callbacks for the same page_layout" do
before do
ApplicationController.class_eval do
on_page_layout(:standard) do
@@ -155,7 +155,7 @@
end
context "for show action" do
- it 'runs both callbacks' do
+ it "runs both callbacks" do
get :show, params: {urlname: page.urlname}
expect(assigns(:successful_for_standard_first)).to eq(true)
expect(assigns(:successful_for_standard_second)).to eq(true)
@@ -163,9 +163,9 @@
end
context "for index action" do
- let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+ let!(:page) { create(:alchemy_page, :language_root, page_layout: "standard") }
- it 'runs both callbacks' do
+ it "runs both callbacks" do
get :index
expect(assigns(:successful_for_standard_first)).to eq(true)
expect(assigns(:successful_for_standard_second)).to eq(true)
@@ -173,7 +173,7 @@
end
end
- context 'when block is given' do
+ context "when block is given" do
before do
ApplicationController.class_eval do
on_page_layout :standard do
@@ -182,24 +182,24 @@
end
end
- context 'for show action' do
- it 'evaluates the given block' do
+ context "for show action" do
+ it "evaluates the given block" do
get :show, params: {urlname: page.urlname}
expect(assigns(:successful_for_callback_method)).to eq(true)
end
end
- context 'for index action' do
- let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+ context "for index action" do
+ let!(:page) { create(:alchemy_page, :language_root, page_layout: "standard") }
- it 'evaluates the given block' do
+ it "evaluates the given block" do
get :index
expect(assigns(:successful_for_callback_method)).to eq(true)
end
end
end
- context 'when callback method name is given' do
+ context "when callback method name is given" do
before do
ApplicationController.class_eval do
on_page_layout :standard, :run_method
@@ -210,25 +210,25 @@ def run_method
end
end
- context 'for show action' do
- it 'runs the given callback method' do
+ context "for show action" do
+ it "runs the given callback method" do
get :show, params: {urlname: page.urlname}
expect(assigns(:successful_for_callback_method)).to eq(true)
end
end
- context 'for index action' do
- let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
+ context "for index action" do
+ let!(:page) { create(:alchemy_page, :language_root, page_layout: "standard") }
- it 'runs the given callback method' do
+ it "runs the given callback method" do
get :index
expect(assigns(:successful_for_callback_method)).to eq(true)
end
end
end
- context 'when neither callback method name nor block given' do
- it 'raises an ArgumentError' do
+ context "when neither callback method name nor block given" do
+ it "raises an ArgumentError" do
expect do
ApplicationController.class_eval do
on_page_layout :standard
@@ -237,7 +237,7 @@ def run_method
end
end
- context 'when passing two page_layouts for a callback' do
+ context "when passing two page_layouts for a callback" do
before do
ApplicationController.class_eval do
on_page_layout([:standard, :news]) do
@@ -247,7 +247,7 @@ def run_method
end
%w(standard news).each do |page_layout|
- it 'evaluates the given callback on both page_layouts for show action' do
+ it "evaluates the given callback on both page_layouts for show action" do
page = create(:alchemy_page, :public, page_layout: page_layout)
get :show, params: {urlname: page.urlname}
@@ -256,7 +256,7 @@ def run_method
end
%w(standard news).each do |page_layout|
- it 'evaluates the given callback on both page_layouts for index action' do
+ it "evaluates the given callback on both page_layouts for index action" do
create(:alchemy_page, :language_root, page_layout: page_layout)
get :index
@@ -267,7 +267,7 @@ def run_method
end
end
-RSpec.describe ApplicationController, 'OnPageLayout mixin', type: :controller do
+RSpec.describe ApplicationController, "OnPageLayout mixin", type: :controller do
before(:all) do
ApplicationController.extend Alchemy::OnPageLayout
end
@@ -279,7 +279,7 @@ def index
end
end
- context 'in another controller' do
+ context "in another controller" do
before do
ApplicationController.class_eval do
on_page_layout(:standard) do
@@ -288,7 +288,7 @@ def index
end
end
- it 'callback does not run' do
+ it "callback does not run" do
get :index
expect(assigns(:another_controller)).to eq(true)
expect(assigns(:successful_for_another_controller)).to eq(nil)
@@ -296,14 +296,14 @@ def index
end
end
-RSpec.describe Alchemy::Admin::PagesController, 'OnPageLayout mixin', type: :controller do
+RSpec.describe Alchemy::Admin::PagesController, "OnPageLayout mixin", type: :controller do
routes { Alchemy::Engine.routes }
before(:all) do
ApplicationController.extend Alchemy::OnPageLayout
end
- context 'in admin/pages_controller' do
+ context "in admin/pages_controller" do
before do
ApplicationController.class_eval do
on_page_layout(:standard) do
@@ -314,16 +314,16 @@ def index
end
context "for show action" do
- let(:page) { create(:alchemy_page, page_layout: 'standard') }
+ let(:page) { create(:alchemy_page, page_layout: "standard") }
- it 'callback also runs' do
+ it "callback also runs" do
get :show, params: {id: page.id}
expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(true)
end
end
context "for index action" do
- it 'does not run callback' do
+ it "does not run callback" do
get :index
expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(nil)
end
diff --git a/spec/controllers/alchemy/pages_controller_spec.rb b/spec/controllers/alchemy/pages_controller_spec.rb
index 20c07e6ca1..1a01297168 100644
--- a/spec/controllers/alchemy/pages_controller_spec.rb
+++ b/spec/controllers/alchemy/pages_controller_spec.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
-require 'ostruct'
-require 'rails_helper'
+require "ostruct"
+require "rails_helper"
module Alchemy
describe PagesController do
@@ -10,15 +10,15 @@ module Alchemy
let(:default_language) { create(:alchemy_language) }
let(:default_language_root) do
- create(:alchemy_page, :language_root, language: default_language, name: 'Home')
+ create(:alchemy_page, :language_root, language: default_language, name: "Home")
end
let(:page) do
create :alchemy_page, :public,
parent_id: default_language_root.id,
- page_layout: 'news',
- name: 'News',
- urlname: 'news',
+ page_layout: "news",
+ name: "News",
+ urlname: "news",
language: default_language,
autogenerate_elements: true
end
@@ -28,46 +28,46 @@ module Alchemy
end
describe "#index" do
- context 'without a site or language present' do
- it 'returns a 404' do
+ context "without a site or language present" do
+ it "returns a 404" do
expect { get(:index) }.to raise_exception(
ActionController::RoutingError,
- 'Alchemy::Page not found "/"'
+ 'Alchemy::Page not found "/"',
)
end
end
- context 'with site and language root present' do
+ context "with site and language root present" do
before do
default_language_root
end
- it 'renders :show template' do
+ it "renders :show template" do
expect(get(:index)).to render_template(:show)
end
- context 'requesting nothing' do
- it 'loads default language root page' do
+ context "requesting nothing" do
+ it "loads default language root page" do
get :index
expect(assigns(:page)).to eq(default_language_root)
end
- it 'sets @root_page to default language root' do
+ it "sets @root_page to default language root" do
get :index
expect(assigns(:root_page)).to eq(default_language_root)
end
- context 'and the root page is not public' do
+ context "and the root page is not public" do
before do
default_language_root.update!(public_on: nil)
end
- context 'and redirect_to_public_child is set to false' do
+ context "and redirect_to_public_child is set to false" do
before do
stub_alchemy_config(:redirect_to_public_child, false)
end
- it 'raises routing error (404)' do
+ it "raises routing error (404)" do
expect {
get :index
}.to raise_error(ActionController::RoutingError)
@@ -77,7 +77,7 @@ module Alchemy
before do
ApplicationController.extend Alchemy::OnPageLayout
ApplicationController.class_eval do
- on_page_layout('index') { "do something" }
+ on_page_layout("index") { "do something" }
end
end
@@ -89,44 +89,44 @@ module Alchemy
end
end
- context 'and redirect_to_public_child is set to true' do
+ context "and redirect_to_public_child is set to true" do
before do
stub_alchemy_config(:redirect_to_public_child, true)
end
- context 'that has a public child' do
+ context "that has a public child" do
let!(:public_child) do
create(:alchemy_page, :public, parent: default_language_root)
end
- it 'loads this page' do
+ it "loads this page" do
get :index
expect(assigns(:page)).to eq(public_child)
end
end
- context 'that has a non public child' do
+ context "that has a non public child" do
let!(:non_public_child) do
create(:alchemy_page, parent: default_language_root)
end
- context 'that has a public child' do
+ context "that has a public child" do
let!(:public_child) do
create(:alchemy_page, :public, parent: non_public_child)
end
- it 'loads this page' do
+ it "loads this page" do
get :index
expect(assigns(:page)).to eq(public_child)
end
end
- context 'that has a non public child' do
+ context "that has a non public child" do
before do
create(:alchemy_page, parent: non_public_child)
end
- it 'raises routing error (404)' do
+ it "raises routing error (404)" do
expect {
get :index
}.to raise_error(ActionController::RoutingError)
@@ -137,34 +137,34 @@ module Alchemy
end
end
- context 'requesting non default locale' do
- let!(:english) do
- create(:alchemy_language, :english, default: false)
+ context "requesting non default locale" do
+ let!(:klingon) do
+ create(:alchemy_language, :klingon, default: false)
end
let!(:start_page) do
create :alchemy_page, :language_root,
- language: english,
- name: 'Start Page'
+ language: klingon,
+ name: "Start Page"
end
before do
- allow(::I18n).to receive(:default_locale) { 'de' }
+ allow(::I18n).to receive(:default_locale) { "de" }
end
- it 'loads the root page of that language' do
- get :index, params: {locale: 'en'}
+ it "loads the root page of that language" do
+ get :index, params: { locale: "kl" }
expect(assigns(:page)).to eq(start_page)
end
- it 'sets @root_page to root page of that language' do
- get :index, params: {locale: 'en'}
+ it "sets @root_page to root page of that language" do
+ get :index, params: { locale: "kl" }
expect(assigns(:root_page)).to eq(start_page)
end
end
end
- describe 'requesting a not yet public page' do
+ describe "requesting a not yet public page" do
let(:not_yet_public) do
create :alchemy_page,
parent: default_language_root,
@@ -173,12 +173,12 @@ module Alchemy
it "renders 404" do
expect {
- get :show, params: {urlname: not_yet_public.urlname}
+ get :show, params: { urlname: not_yet_public.urlname }
}.to raise_error(ActionController::RoutingError)
end
end
- describe 'requesting a no longer public page' do
+ describe "requesting a no longer public page" do
let(:no_longer_public) do
create :alchemy_page,
parent: default_language_root,
@@ -188,12 +188,12 @@ module Alchemy
it "renders 404" do
expect {
- get :show, params: {urlname: no_longer_public.urlname}
+ get :show, params: { urlname: no_longer_public.urlname }
}.to raise_error(ActionController::RoutingError)
end
end
- describe 'requesting a still public page' do
+ describe "requesting a still public page" do
let(:still_public_page) do
create :alchemy_page,
parent: default_language_root,
@@ -202,12 +202,12 @@ module Alchemy
end
it "renders page" do
- get :show, params: {urlname: still_public_page.urlname}
+ get :show, params: { urlname: still_public_page.urlname }
expect(response).to be_successful
end
end
- describe 'requesting a page without time limit' do
+ describe "requesting a page without time limit" do
let(:still_public_page) do
create :alchemy_page,
parent: default_language_root,
@@ -216,7 +216,7 @@ module Alchemy
end
it "renders page" do
- get :show, params: {urlname: still_public_page.urlname}
+ get :show, params: { urlname: still_public_page.urlname }
expect(response).to be_successful
end
end
@@ -225,20 +225,20 @@ module Alchemy
render_views
it "should render a rss feed" do
- get :show, params: {urlname: page.urlname, format: :rss}
- expect(response.media_type).to eq('application/rss+xml')
+ get :show, params: { urlname: page.urlname, format: :rss }
+ expect(response.media_type).to eq("application/rss+xml")
end
it "should include content" do
- page.elements.first.content_by_name('news_headline').essence.update_columns(body: 'Peters Petshop')
- get :show, params: {urlname: 'news', format: :rss}
+ page.elements.first.content_by_name("news_headline").essence.update_columns(body: "Peters Petshop")
+ get :show, params: { urlname: "news", format: :rss }
expect(response.body).to match /Peters Petshop/
end
end
context "requested for a page that does not contain a feed" do
it "should render xml 404 error" do
- get :show, params: {urlname: default_language_root.urlname, format: :rss}
+ get :show, params: { urlname: default_language_root.urlname, format: :rss }
expect(response.status).to eq(404)
end
end
@@ -246,9 +246,9 @@ module Alchemy
describe "Layout rendering" do
context "with ajax request" do
it "should not render a layout" do
- get :show, params: {urlname: page.urlname}, xhr: true
+ get :show, params: { urlname: page.urlname }, xhr: true
expect(response).to render_template(:show)
- expect(response).not_to render_template(layout: 'application')
+ expect(response).not_to render_template(layout: "application")
end
end
end
@@ -256,19 +256,18 @@ module Alchemy
describe "url nesting" do
render_views
- let(:catalog) { create(:alchemy_page, :public, name: "Catalog", urlname: 'catalog', parent: default_language_root, language: default_language, visible: true) }
- let(:products) { create(:alchemy_page, :public, name: "Products", urlname: 'products', parent: catalog, language: default_language, visible: true) }
- let(:product) { create(:alchemy_page, :public, name: "Screwdriver", urlname: 'screwdriver', parent: products, language: default_language, autogenerate_elements: true, visible: true) }
+ let(:catalog) { create(:alchemy_page, :public, name: "Catalog", urlname: "catalog", parent: default_language_root, language: default_language) }
+ let(:products) { create(:alchemy_page, :public, name: "Products", urlname: "products", parent: catalog, language: default_language) }
+ let(:product) { create(:alchemy_page, :public, name: "Screwdriver", urlname: "screwdriver", parent: products, language: default_language, autogenerate_elements: true) }
before do
allow(Alchemy.user_class).to receive(:admins).and_return(OpenStruct.new(count: 1))
- stub_alchemy_config(:url_nesting, true)
- product.elements.find_by_name('article').contents.essence_texts.first.essence.update_column(:body, 'screwdriver')
+ product.elements.find_by_name("article").contents.essence_texts.first.essence.update_column(:body, "screwdriver")
end
context "with correct levelnames in params" do
it "should show the requested page" do
- get :show, params: {urlname: 'catalog/products/screwdriver'}
+ get :show, params: { urlname: "catalog/products/screwdriver" }
expect(response.status).to eq(200)
expect(response.body).to have_content("screwdriver")
end
@@ -277,7 +276,7 @@ module Alchemy
context "with incorrect levelnames in params" do
it "should render a 404 page" do
expect {
- get :show, params: {urlname: 'catalog/faqs/screwdriver'}
+ get :show, params: { urlname: "catalog/faqs/screwdriver" }
}.to raise_error(ActionController::RoutingError)
end
end
@@ -286,7 +285,7 @@ module Alchemy
context "when a non-existent page is requested" do
it "should rescue a RoutingError with rendering a 404 page." do
expect {
- get :show, params: {urlname: 'doesntexist'}
+ get :show, params: { urlname: "doesntexist" }
}.to raise_error(ActionController::RoutingError)
end
end
@@ -299,22 +298,22 @@ module Alchemy
context "with no lang parameter present" do
it "should store defaults language id in the session." do
- get :show, params: {urlname: page.urlname}
+ get :show, params: { urlname: page.urlname }
expect(controller.session[:alchemy_language_id]).to eq(Language.default.id)
end
it "should store default language as class var." do
- get :show, params: {urlname: page.urlname}
+ get :show, params: { urlname: page.urlname }
expect(Language.current).to eq(Language.default)
end
end
end
end
- context 'in an environment with multiple languages' do
+ context "in an environment with multiple languages" do
let(:klingon) { create(:alchemy_language, :klingon) }
- context 'having two pages with the same url names in different languages' do
+ context "having two pages with the same url names in different languages" do
render_views
let!(:klingon_page) { create(:alchemy_page, :public, language: klingon, name: "same-name", autogenerate_elements: true) }
@@ -322,35 +321,35 @@ module Alchemy
before do
# Set a text in an essence rendered on the page so we can match against that
- klingon_page.essence_texts.first.update_column(:body, 'klingon page')
+ klingon_page.essence_texts.first.update_column(:body, "klingon page")
end
- it 'renders the page related to its language' do
- get :show, params: {urlname: "same-name", locale: klingon_page.language_code}
+ it "renders the page related to its language" do
+ get :show, params: { urlname: "same-name", locale: klingon_page.language_code }
expect(response.body).to have_content("klingon page")
end
end
end
- describe '#page_etag' do
+ describe "#page_etag" do
subject { controller.send(:page_etag) }
before do
- expect(page).to receive(:cache_key).and_return('aaa')
- controller.instance_variable_set('@page', page)
+ expect(page).to receive(:cache_key).and_return("aaa")
+ controller.instance_variable_set("@page", page)
end
it "returns the etag for response headers" do
- expect(subject).to eq('aaa')
+ expect(subject).to eq("aaa")
end
- context 'with user logged in' do
+ context "with user logged in" do
before do
- authorize_user(mock_model(Alchemy.user_class, cache_key: 'bbb'))
+ authorize_user(mock_model(Alchemy.user_class, cache_key: "bbb"))
end
it "returns another etag for response headers" do
- expect(subject).to eq('aaabbb')
+ expect(subject).to eq("aaabbb")
end
end
end
diff --git a/spec/decorators/alchemy/content_editor_spec.rb b/spec/decorators/alchemy/content_editor_spec.rb
index 8d7572e145..69cf742917 100644
--- a/spec/decorators/alchemy/content_editor_spec.rb
+++ b/spec/decorators/alchemy/content_editor_spec.rb
@@ -1,21 +1,21 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
RSpec.describe Alchemy::ContentEditor do
let(:essence) { Alchemy::EssenceText.new }
let(:content) { Alchemy::Content.new(id: 1, essence: essence) }
let(:content_editor) { described_class.new(content) }
- describe '#content' do
- it 'returns content object' do
+ describe "#content" do
+ it "returns content object" do
expect(content_editor.content).to eq(content)
end
end
describe "#css_classes" do
it "includes content_editor class" do
- expect(content_editor.css_classes).to include('content_editor')
+ expect(content_editor.css_classes).to include("content_editor")
end
it "includes essence partial class" do
@@ -33,39 +33,39 @@
end
end
- describe '#to_partial_path' do
+ describe "#to_partial_path" do
subject { content_editor.to_partial_path }
- it 'returns the editor partial path' do
- is_expected.to eq('alchemy/essences/essence_text_editor')
+ it "returns the editor partial path" do
+ is_expected.to eq("alchemy/essences/essence_text_editor")
end
end
- describe '#form_field_name' do
+ describe "#form_field_name" do
it "returns a name value for form fields with ingredient as default" do
- expect(content_editor.form_field_name).to eq('contents[1][ingredient]')
+ expect(content_editor.form_field_name).to eq("contents[1][ingredient]")
end
- context 'with a essence column given' do
+ context "with a essence column given" do
it "returns a name value for form fields for that column" do
- expect(content_editor.form_field_name(:link_title)).to eq('contents[1][link_title]')
+ expect(content_editor.form_field_name(:link_title)).to eq("contents[1][link_title]")
end
end
end
- describe '#form_field_id' do
+ describe "#form_field_id" do
it "returns a id value for form fields with ingredient as default" do
- expect(content_editor.form_field_id).to eq('contents_1_ingredient')
+ expect(content_editor.form_field_id).to eq("contents_1_ingredient")
end
- context 'with a essence column given' do
+ context "with a essence column given" do
it "returns a id value for form fields for that column" do
- expect(content_editor.form_field_id(:link_title)).to eq('contents_1_link_title')
+ expect(content_editor.form_field_id(:link_title)).to eq("contents_1_link_title")
end
end
end
- describe '#respond_to?(:to_model)' do
+ describe "#respond_to?(:to_model)" do
subject { content_editor.respond_to?(:to_model) }
it { is_expected.to be(false) }
diff --git a/spec/decorators/alchemy/element_editor_spec.rb b/spec/decorators/alchemy/element_editor_spec.rb
index 5d2f71f828..469a3b4220 100644
--- a/spec/decorators/alchemy/element_editor_spec.rb
+++ b/spec/decorators/alchemy/element_editor_spec.rb
@@ -1,90 +1,90 @@
# frozen_string_literal: true
-require 'rails_helper'
+require "rails_helper"
RSpec.describe Alchemy::ElementEditor do
let(:element) { Alchemy::Element.new }
let(:element_editor) { described_class.new(element) }
- describe '#element' do
- it 'returns element object' do
+ describe "#element" do
+ it "returns element object" do
expect(element_editor.element).to eq(element)
end
end
- describe '#to_partial_path' do
+ describe "#to_partial_path" do
subject { element_editor.to_partial_path }
- it 'returns the editor partial path' do
- is_expected.to eq('alchemy/admin/elements/element')
+ it "returns the editor partial path" do
+ is_expected.to eq("alchemy/admin/elements/element")
end
end
- describe '#css_classes' do
+ describe "#css_classes" do
subject { element_editor.css_classes }
it "returns css classes for element editor partial" do
- is_expected.to include('element-editor')
+ is_expected.to include("element-editor")
end
- context 'with element is folded' do
+ context "with element is folded" do
let(:element) { build_stubbed(:alchemy_element, folded: true) }
- it { is_expected.to include('folded') }
+ it { is_expected.to include("folded") }
end
- context 'with element is expanded' do
+ context "with element is expanded" do
let(:element) { build_stubbed(:alchemy_element, folded: false) }
- it { is_expected.to include('expanded') }
+ it { is_expected.to include("expanded") }
end
- context 'with element is taggable' do
+ context "with element is taggable" do
before do
allow(element).to receive(:taggable?) { true }
end
- it { is_expected.to include('taggable') }
+ it { is_expected.to include("taggable") }
end
- context 'with element is not taggable' do
+ context "with element is not taggable" do
before do
allow(element).to receive(:taggable?) { false }
end
- it { is_expected.to include('not-taggable') }
+ it { is_expected.to include("not-taggable") }
end
- context 'with element having content_definitions' do
+ context "with element having content_definitions" do
before do
allow(element).to receive(:content_definitions) { [1] }
end
- it { is_expected.to include('with-contents') }
+ it { is_expected.to include("with-contents") }
end
- context 'with element not having content_definitions' do
+ context "with element not having content_definitions" do
before do
allow(element).to receive(:content_definitions) { [] }
end
- it { is_expected.to include('without-contents') }
+ it { is_expected.to include("without-contents") }
end
- context 'with element having nestable_elements' do
+ context "with element having nestable_elements" do
before do
allow(element).to receive(:nestable_elements) { [1] }
end
- it { is_expected.to include('nestable') }
+ it { is_expected.to include("nestable") }
end
- context 'with element not having nestable_elements' do
+ context "with element not having nestable_elements" do
before do
allow(element).to receive(:nestable_elements) { [] }
end
- it { is_expected.to include('not-nestable') }
+ it { is_expected.to include("not-nestable") }
end
end
@@ -124,7 +124,7 @@
end
end
- describe '#respond_to?(:to_model)' do
+ describe "#respond_to?(:to_model)" do
subject { element_editor.respond_to?(:to_model) }
it { is_expected.to be(false) }
diff --git a/spec/dummy/Rakefile b/spec/dummy/Rakefile
index 488c551fee..d2a78aa258 100644
--- a/spec/dummy/Rakefile
+++ b/spec/dummy/Rakefile
@@ -3,6 +3,6 @@
# Add your own tasks in files placed in lib/tasks ending in .rake,
# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-require_relative 'config/application'
+require_relative "config/application"
Rails.application.load_tasks
diff --git a/spec/dummy/app/controllers/login_controller.rb b/spec/dummy/app/controllers/login_controller.rb
index a64f2242d5..9ab5b154e4 100644
--- a/spec/dummy/app/controllers/login_controller.rb
+++ b/spec/dummy/app/controllers/login_controller.rb
@@ -2,6 +2,6 @@
class LoginController < ApplicationController
def new
- render plain: 'Please login'
+ render plain: "Please login"
end
end
diff --git a/spec/dummy/app/models/dummy_model.rb b/spec/dummy/app/models/dummy_model.rb
index 1a021d5283..7a369c9ff7 100644
--- a/spec/dummy/app/models/dummy_model.rb
+++ b/spec/dummy/app/models/dummy_model.rb
@@ -1,5 +1,5 @@
# frozen_string_literal: true
class DummyModel < ActiveRecord::Base
- acts_as_essence ingredient_column: 'data'
+ acts_as_essence ingredient_column: "data"
end
diff --git a/spec/dummy/app/models/dummy_user.rb b/spec/dummy/app/models/dummy_user.rb
index ab60542797..1f8f9f9811 100644
--- a/spec/dummy/app/models/dummy_user.rb
+++ b/spec/dummy/app/models/dummy_user.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
class DummyUser < ActiveRecord::Base
- has_many :folded_pages, class_name: 'Alchemy::FoldedPage'
+ has_many :folded_pages, class_name: "Alchemy::FoldedPage"
attr_writer :alchemy_roles, :name
def self.logged_in
diff --git a/spec/dummy/app/models/event.rb b/spec/dummy/app/models/event.rb
index b63fbc7ffd..51ce96545c 100644
--- a/spec/dummy/app/models/event.rb
+++ b/spec/dummy/app/models/event.rb
@@ -5,17 +5,27 @@ class Event < ActiveRecord::Base
validates_presence_of :name
belongs_to :location
+ before_destroy :abort_if_name_is_undestructible
scope :starting_today, -> { where(starts_at: Time.current.at_midnight..Date.tomorrow.at_midnight) }
scope :future, -> { where("starts_at > ?", Date.tomorrow.at_midnight) }
def self.alchemy_resource_relations
{
- location: {attr_method: 'name', attr_type: 'string'}
+ location: {attr_method: "name", attr_type: "string"},
}
end
def self.alchemy_resource_filters
%w(starting_today future)
end
+
+ private
+
+ def abort_if_name_is_undestructible
+ if name == "Undestructible"
+ errors.add(:base, "This is the undestructible event!")
+ throw(:abort)
+ end
+ end
end
diff --git a/spec/dummy/app/views/alchemy/elements/_menu.html.erb b/spec/dummy/app/views/alchemy/elements/_menu.html.erb
new file mode 100644
index 0000000000..f33c169bb8
--- /dev/null
+++ b/spec/dummy/app/views/alchemy/elements/_menu.html.erb
@@ -0,0 +1,5 @@
+<%- cache(menu) do -%>
+ <%= element_view_for(menu) do |el| -%>
+ <%= el.render :menu %>
+ <%- end -%>
+<%- end -%>
diff --git a/spec/dummy/app/views/alchemy/menus/footer_navigation/_node.html.erb b/spec/dummy/app/views/alchemy/menus/footer_navigation/_node.html.erb
index ed71624a72..e2453605f5 100644
--- a/spec/dummy/app/views/alchemy/menus/footer_navigation/_node.html.erb
+++ b/spec/dummy/app/views/alchemy/menus/footer_navigation/_node.html.erb
@@ -8,10 +8,7 @@
rel: node.nofollow? ? 'nofollow' : nil %>
<% if node.children.any? %>