decidim 0.5.1 → 0.6.0

data/decidim-assemblies/spec/commands/copy_assembly_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Decidim::Assemblies::Admin::CopyAssembly do
+  let(:organization) { create :organization }
+  let(:scope) { create :scope, organization: organization }
+  let(:errors) { double.as_null_object }
+  let!(:assembly) { create :assembly }
+  let!(:feature) { create :feature, manifest_name: :dummy, participatory_space: assembly }
+  let(:form) do
+    instance_double(
+      Decidim::Assemblies::Admin::AssemblyCopyForm,
+      invalid?: invalid,
+      title: { en: "title" },
+      slug: "copied_slug",
+      copy_categories?: copy_categories,
+      copy_features?: copy_features
+    )
+  end
+  let!(:category) do
+    create(
+      :category,
+      participatory_space: assembly
+    )
+  end
+
+  let(:invalid) { false }
+  let(:copy_categories) { false }
+  let(:copy_features) { false }
+
+  subject { described_class.new(form, assembly) }
+
+  context "when the form is not valid" do
+    let(:invalid) { true }
+
+    it "broadcasts invalid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when everything is ok" do
+    it "duplicates an assembly" do
+      expect { subject.call }.to change { Decidim::Assembly.count }.by(1)
+
+      old_assembly = Decidim::Assembly.first
+      new_assembly = Decidim::Assembly.last
+
+      expect(new_assembly.slug).to eq("copied_slug")
+      expect(new_assembly.title["en"]).to eq("title")
+      expect(new_assembly.published?).to be_falsy
+      expect(new_assembly.organization).to eq(old_assembly.organization)
+      expect(new_assembly.subtitle).to eq(old_assembly.subtitle)
+      expect(new_assembly.description).to eq(old_assembly.description)
+      expect(new_assembly.short_description).to eq(old_assembly.short_description)
+      expect(new_assembly.promoted).to eq(old_assembly.promoted)
+      expect(new_assembly.scope).to eq(old_assembly.scope)
+      expect(new_assembly.developer_group).to eq(old_assembly.developer_group)
+      expect(new_assembly.local_area).to eq(old_assembly.local_area)
+      expect(new_assembly.target).to eq(old_assembly.target)
+      expect(new_assembly.participatory_scope).to eq(old_assembly.participatory_scope)
+      expect(new_assembly.meta_scope).to eq(old_assembly.meta_scope)
+    end
+
+    it "broadcasts ok" do
+      expect { subject.call }.to broadcast(:ok)
+    end
+  end
+
+  context "when copy_categories exists" do
+    let(:copy_categories) { true }
+
+    it "duplicates a assembly and the categories" do
+      expect { subject.call }.to change { Decidim::Category.count }.by(1)
+      expect(Decidim::Category.pluck(:decidim_participatory_space_id).uniq.count).to eq 2
+
+      old_assembly_category = Decidim::Category.first
+      new_assembly_category = Decidim::Category.last
+
+      expect(new_assembly_category.name).to eq(old_assembly_category.name)
+      expect(new_assembly_category.description).to eq(old_assembly_category.description)
+      expect(new_assembly_category.parent).to eq(old_assembly_category.parent)
+    end
+  end
+
+  context "when copy_features exists" do
+    let(:copy_features) { true }
+
+    it "duplicates an assembly and the features" do
+      dummy_hook = proc {}
+      feature.manifest.on :copy, &dummy_hook
+      expect(dummy_hook).to receive(:call).with(new_feature: an_instance_of(Decidim::Feature), old_feature: feature)
+
+      expect { subject.call }.to change { Decidim::Feature.count }.by(1)
+
+      last_assembly = Decidim::Assembly.last
+      last_feature = Decidim::Feature.all.reorder(:id).last
+
+      expect(last_feature.participatory_space).to eq(last_assembly)
+      expect(last_feature.name).to eq(feature.name)
+      expect(last_feature.settings.attributes).to eq(feature.settings.attributes)
+      expect(last_feature.step_settings.keys).to eq(feature.step_settings.keys)
+      expect(last_feature.step_settings.values).to eq(feature.step_settings.values)
+    end
+  end
+end

data/decidim-assemblies/spec/commands/create_assembly_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Decidim::Assemblies::Admin::CreateAssembly do
+  let(:organization) { create :organization }
+  let(:scope) { create :scope, organization: organization }
+  let(:errors) { double.as_null_object }
+  let(:form) do
+    instance_double(
+      Decidim::Assemblies::Admin::AssemblyForm,
+      invalid?: invalid,
+      title: { en: "title" },
+      subtitle: { en: "subtitle" },
+      slug: "slug",
+      hashtag: "hashtag",
+      meta_scope: "meta scope",
+      hero_image: nil,
+      banner_image: nil,
+      promoted: nil,
+      developer_group: "developer group",
+      local_area: "local",
+      target: "target",
+      participatory_scope: "participatory scope",
+      participatory_structure: "participatory structure",
+      description: { en: "description" },
+      short_description: { en: "short_description" },
+      current_organization: organization,
+      scopes_enabled: true,
+      scope: scope,
+      errors: errors
+    )
+  end
+  let(:invalid) { false }
+
+  subject { described_class.new(form) }
+
+  context "when the form is not valid" do
+    let(:invalid) { true }
+
+    it "broadcasts invalid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when the assembly is not persisted" do
+    let(:invalid_assembly) do
+      instance_double(
+        Decidim::Assembly,
+        persisted?: false,
+        valid?: false,
+        errors: {
+          hero_image: "Image too big",
+          banner_image: "Image too big"
+        }
+      ).as_null_object
+    end
+
+    before do
+      expect(Decidim::Assembly).to receive(:new).and_return(invalid_assembly)
+    end
+
+    it "broadcasts invalid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+
+    it "adds errors to the form" do
+      expect(errors).to receive(:add).with(:hero_image, "Image too big")
+      expect(errors).to receive(:add).with(:banner_image, "Image too big")
+      subject.call
+    end
+  end
+
+  context "when everything is ok" do
+    it "creates an assembly" do
+      expect { subject.call }.to change { Decidim::Assembly.count }.by(1)
+    end
+
+    it "broadcasts ok" do
+      expect { subject.call }.to broadcast(:ok)
+    end
+  end
+end

data/decidim-assemblies/spec/commands/create_category_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decidim/admin/test/commands/create_category_examples"
+
+describe Decidim::Admin::CreateCategory do
+  include_examples "CreateCategory command" do
+    let(:participatory_space) { create(:assembly, organization: organization) }
+  end
+end

data/decidim-assemblies/spec/commands/destroy_category_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decidim/admin/test/commands/destroy_category_examples"
+
+describe Decidim::Admin::DestroyCategory do
+  include_examples "DestroyCategory command" do
+    let(:participatory_space) { create(:assembly, organization: organization) }
+  end
+end

data/decidim-assemblies/spec/commands/publish_assembly_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Decidim::Assemblies::Admin::PublishAssembly do
+  let(:my_assembly) { create :assembly, :unpublished }
+
+  subject { described_class.new(my_assembly) }
+
+  context "when the assembly is nil" do
+    let(:my_assembly) { nil }
+
+    it "is not valid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when the assembly is published" do
+    let(:my_assembly) { create :assembly }
+
+    it "is not valid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when the assembly is not published" do
+    it "is valid" do
+      expect { subject.call }.to broadcast(:ok)
+    end
+
+    it "publishes it" do
+      subject.call
+      my_assembly.reload
+      expect(my_assembly).to be_published
+    end
+  end
+end

data/decidim-assemblies/spec/commands/unpublish_assembly_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Decidim::Assemblies::Admin::UnpublishAssembly do
+  let(:my_assembly) { create :assembly }
+
+  subject { described_class.new(my_assembly) }
+
+  context "when the assembly is nil" do
+    let(:my_assembly) { nil }
+
+    it "is not valid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when the assembly is not published" do
+    let(:my_assembly) { create :assembly, :unpublished }
+
+    it "is not valid" do
+      expect { subject.call }.to broadcast(:invalid)
+    end
+  end
+
+  context "when the assembly is published" do
+    it "is valid" do
+      expect { subject.call }.to broadcast(:ok)
+    end
+
+    it "unpublishes it" do
+      subject.call
+      my_assembly.reload
+      expect(my_assembly).not_to be_published
+    end
+  end
+end

data/decidim-assemblies/spec/commands/update_assembly_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Assemblies
+    module Admin
+      describe UpdateAssembly do
+        describe "call" do
+          let(:my_assembly) { create :assembly }
+          let(:params) do
+            {
+              assembly: {
+                id: my_assembly.id,
+                title_en: "Foo title",
+                title_ca: "Foo title",
+                title_es: "Foo title",
+                subtitle_en: my_assembly.subtitle,
+                subtitle_ca: my_assembly.subtitle,
+                subtitle_es: my_assembly.subtitle,
+                slug: my_assembly.slug,
+                hashtag: my_assembly.hashtag,
+                meta_scope: my_assembly.meta_scope,
+                hero_image: nil,
+                banner_image: nil,
+                promoted: my_assembly.promoted,
+                description_en: my_assembly.description,
+                description_ca: my_assembly.description,
+                description_es: my_assembly.description,
+                short_description_en: my_assembly.short_description,
+                short_description_ca: my_assembly.short_description,
+                short_description_es: my_assembly.short_description,
+                current_organization: my_assembly.organization,
+                scopes_enabled: my_assembly.scopes_enabled,
+                scope: my_assembly.scope,
+                errors: my_assembly.errors,
+                show_statistics: my_assembly.show_statistics
+              }
+            }
+          end
+          let(:context) do
+            { current_organization: my_assembly.organization }
+          end
+          let(:form) do
+            AssemblyForm.from_params(params).with_context(context)
+          end
+          let(:command) { described_class.new(my_assembly, form) }
+
+          describe "when the form is not valid" do
+            before do
+              expect(form).to receive(:invalid?).and_return(true)
+            end
+
+            it "broadcasts invalid" do
+              expect { command.call }.to broadcast(:invalid)
+            end
+
+            it "doesn't update the assembly" do
+              command.call
+              my_assembly.reload
+
+              expect(my_assembly.title["en"]).not_to eq("Foo title")
+            end
+          end
+
+          describe "when the assembly is not valid" do
+            before do
+              expect(form).to receive(:invalid?).and_return(false)
+              expect(my_assembly).to receive(:valid?).at_least(:once).and_return(false)
+              my_assembly.errors.add(:hero_image, "Image too big")
+              my_assembly.errors.add(:banner_image, "Image too big")
+            end
+
+            it "broadcasts invalid" do
+              expect { command.call }.to broadcast(:invalid)
+            end
+
+            it "adds errors to the form" do
+              command.call
+
+              expect(form.errors[:hero_image]).not_to be_empty
+              expect(form.errors[:banner_image]).not_to be_empty
+            end
+          end
+
+          describe "when the form is valid" do
+            it "broadcasts ok" do
+              expect { command.call }.to broadcast(:ok)
+            end
+
+            it "updates the assembly" do
+              expect { command.call }.to broadcast(:ok)
+              my_assembly.reload
+
+              expect(my_assembly.title["en"]).to eq("Foo title")
+            end
+
+            context "when no homepage image is set" do
+              it "does not replace the homepage image" do
+                command.call
+                my_assembly.reload
+
+                expect(my_assembly.hero_image).to be_present
+              end
+            end
+
+            context "when no banner image is set" do
+              it "does not replace the banner image" do
+                command.call
+                my_assembly.reload
+
+                expect(my_assembly.banner_image).to be_present
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/decidim-assemblies/spec/commands/update_category_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decidim/admin/test/commands/update_category_examples"
+
+describe Decidim::Admin::UpdateCategory do
+  include_examples "UpdateCategory command" do
+    let(:participatory_space) { create(:assembly, organization: organization) }
+  end
+end

data/decidim-assemblies/spec/controllers/assemblies_controller_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Assemblies
+    describe AssembliesController, type: :controller do
+      routes { Decidim::Assemblies::Engine.routes }
+
+      let(:organization) { create(:organization) }
+
+      let!(:unpublished_assembly) do
+        create(
+          :assembly,
+          :unpublished,
+          organization: organization
+        )
+      end
+
+      let!(:published) do
+        create(
+          :assembly,
+          :published,
+          organization: organization
+        )
+      end
+
+      let!(:promoted) do
+        create(
+          :assembly,
+          :published,
+          :promoted,
+          organization: organization
+        )
+      end
+
+      before do
+        @request.env["decidim.current_organization"] = organization
+      end
+
+      describe "assemblies" do
+        it "includes only published, with promoted listed first" do
+          expect(controller.helpers.assemblies).to match_array([promoted, published])
+        end
+      end
+
+      describe "promoted_assemblies" do
+        it "includes only promoted" do
+          expect(controller.helpers.promoted_assemblies).to contain_exactly(promoted)
+        end
+      end
+
+      describe "GET show" do
+        context "when the assembly is unpublished" do
+          it "redirects to root path" do
+            get :show, params: { id: unpublished_assembly.id }
+
+            expect(response).to redirect_to("/")
+          end
+        end
+      end
+    end
+  end
+end