f55d2ab891
When configuring phases in a process, we were validating the start date or the end date is present, the other date is present too. However, in other parts of the application we were checking whether a phase is enabled and then assumed its dates were present if the phase was enabled. However, we weren't validating this behavior, so it was possible to enable a phase and leaving its dates blank, causing the application to crash. So, as suggested by Alberto, we're changing the validation rule so phase dates are mandatory when a phase is enabled. With this rule, the old validation rules are not necessary. I've considered leaving them in order to avoid database inconsistencies. However, I realized records having a disabled phase with its start and end dates have always been valid. This means applications checking for the presence of these dates instead of checking whether the phase is enabled have never worked properly. We don't have to change the logic anywhere else because as mentioned we were already checking phases are enabled before using their dates.
368 lines
14 KiB
Ruby
368 lines
14 KiB
Ruby
require "rails_helper"
|
|
|
|
describe Legislation::Process do
|
|
let(:process) { create(:legislation_process) }
|
|
|
|
it_behaves_like "acts as paranoid", :legislation_process
|
|
it_behaves_like "globalizable", :legislation_process
|
|
|
|
it "is valid" do
|
|
expect(process).to be_valid
|
|
end
|
|
|
|
it "assigns default values to new processes" do
|
|
process = Legislation::Process.new
|
|
|
|
expect(process.background_color).to be_present
|
|
expect(process.font_color).to be_present
|
|
end
|
|
|
|
describe "dates validations" do
|
|
it "is invalid if draft is enabled but draft_start_date is not present" do
|
|
process = build(:legislation_process, draft_phase_enabled: true, draft_start_date: nil)
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:draft_start_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if draft is enabled but draft_end_date is not present" do
|
|
process = build(:legislation_process, draft_phase_enabled: true, draft_end_date: "")
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:draft_end_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if debate phase is enabled but debate_start_date is not present" do
|
|
process = build(:legislation_process, debate_phase_enabled: true, debate_start_date: nil)
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:debate_start_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if debate phase is enabled but debate_end_date is not present" do
|
|
process = build(:legislation_process, debate_phase_enabled: true, debate_end_date: "")
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:debate_end_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if proposals phase is enabled but proposals_phase_start_date is not present" do
|
|
process = build(:legislation_process, proposals_phase_enabled: true, proposals_phase_start_date: nil)
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:proposals_phase_start_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if proposals phase is enabled but proposals_phase_end_date is not present" do
|
|
process = build(:legislation_process, proposals_phase_enabled: true, proposals_phase_end_date: "")
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:proposals_phase_end_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if allegations phase is enabled but allegations_start_date is not present" do
|
|
process = build(:legislation_process, allegations_phase_enabled: true,
|
|
allegations_start_date: nil,)
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:allegations_start_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is invalid if allegations phase is enabled but allegations_end_date is not present" do
|
|
process = build(:legislation_process, allegations_phase_enabled: true, allegations_end_date: "")
|
|
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:allegations_end_date]).to include("can't be blank")
|
|
end
|
|
|
|
it "is valid if start dates are missing and the phase is disabled" do
|
|
draft_disabled = build(:legislation_process,
|
|
draft_phase_enabled: false,
|
|
draft_start_date: nil)
|
|
|
|
debate_disabled = build(:legislation_process,
|
|
debate_phase_enabled: false,
|
|
debate_start_date: nil)
|
|
|
|
proposals_disabled = build(:legislation_process,
|
|
proposals_phase_enabled: false,
|
|
proposals_phase_start_date: nil)
|
|
|
|
allegations_disabled = build(:legislation_process,
|
|
allegations_phase_enabled: false,
|
|
allegations_start_date: nil)
|
|
|
|
expect(draft_disabled).to be_valid
|
|
expect(debate_disabled).to be_valid
|
|
expect(proposals_disabled).to be_valid
|
|
expect(allegations_disabled).to be_valid
|
|
end
|
|
|
|
it "is valid if end dates are missing and the phase is disabled" do
|
|
draft_disabled = build(:legislation_process,
|
|
draft_phase_enabled: false,
|
|
draft_end_date: nil)
|
|
|
|
debate_disabled = build(:legislation_process,
|
|
debate_phase_enabled: false,
|
|
debate_end_date: nil)
|
|
|
|
proposals_disabled = build(:legislation_process,
|
|
proposals_phase_enabled: false,
|
|
proposals_phase_end_date: nil)
|
|
|
|
allegations_disabled = build(:legislation_process,
|
|
allegations_phase_enabled: false,
|
|
allegations_end_date: nil)
|
|
|
|
expect(draft_disabled).to be_valid
|
|
expect(debate_disabled).to be_valid
|
|
expect(proposals_disabled).to be_valid
|
|
expect(allegations_disabled).to be_valid
|
|
end
|
|
|
|
it "is valid if start and end dates are missing and the phase is disabled" do
|
|
draft_disabled = build(:legislation_process,
|
|
draft_phase_enabled: false,
|
|
draft_start_date: nil,
|
|
draft_end_date: nil)
|
|
|
|
debate_disabled = build(:legislation_process,
|
|
debate_phase_enabled: false,
|
|
debate_start_date: nil,
|
|
debate_end_date: nil)
|
|
|
|
proposals_disabled = build(:legislation_process,
|
|
proposals_phase_enabled: false,
|
|
proposals_phase_start_date: nil,
|
|
proposals_phase_end_date: nil)
|
|
|
|
allegations_disabled = build(:legislation_process,
|
|
allegations_phase_enabled: false,
|
|
allegations_start_date: nil,
|
|
allegations_end_date: nil)
|
|
|
|
expect(draft_disabled).to be_valid
|
|
expect(debate_disabled).to be_valid
|
|
expect(proposals_disabled).to be_valid
|
|
expect(allegations_disabled).to be_valid
|
|
end
|
|
end
|
|
|
|
describe "date ranges validations" do
|
|
it "is invalid if end_date is before start_date" do
|
|
process = build(:legislation_process, start_date: Date.current,
|
|
end_date: Date.current - 1.day)
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:end_date]).to include("must be on or after the start date")
|
|
end
|
|
|
|
it "is valid if end_date is the same as start_date" do
|
|
process = build(:legislation_process, start_date: Date.current - 1.day,
|
|
end_date: Date.current - 1.day)
|
|
expect(process).to be_valid
|
|
end
|
|
|
|
it "is valid if debate_end_date is the same as debate_start_date" do
|
|
process = build(:legislation_process, debate_start_date: Date.current - 1.day,
|
|
debate_end_date: Date.current - 1.day)
|
|
expect(process).to be_valid
|
|
end
|
|
|
|
it "is invalid if debate_end_date is before debate_start_date" do
|
|
process = build(:legislation_process, debate_start_date: Date.current,
|
|
debate_end_date: Date.current - 1.day)
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:debate_end_date])
|
|
.to include("must be on or after the debate start date")
|
|
end
|
|
|
|
it "is valid if draft_end_date is the same as draft_start_date" do
|
|
process = build(:legislation_process, draft_start_date: Date.current - 1.day,
|
|
draft_end_date: Date.current - 1.day)
|
|
expect(process).to be_valid
|
|
end
|
|
|
|
it "is invalid if draft_end_date is before draft_start_date" do
|
|
process = build(:legislation_process, draft_start_date: Date.current,
|
|
draft_end_date: Date.current - 1.day)
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:draft_end_date])
|
|
.to include("must be on or after the draft start date")
|
|
end
|
|
|
|
it "is invalid if allegations_end_date is before allegations_start_date" do
|
|
process = build(:legislation_process, allegations_start_date: Date.current,
|
|
allegations_end_date: Date.current - 1.day)
|
|
expect(process).to be_invalid
|
|
expect(process.errors.messages[:allegations_end_date])
|
|
.to include("must be on or after the comments start date")
|
|
end
|
|
|
|
it "is valid if allegations_end_date is the same as allegations_start_date" do
|
|
process = build(:legislation_process, allegations_start_date: Date.current - 1.day,
|
|
allegations_end_date: Date.current - 1.day)
|
|
expect(process).to be_valid
|
|
end
|
|
end
|
|
|
|
describe "filter scopes" do
|
|
describe "open and past filters" do
|
|
let!(:process_1) do
|
|
create(:legislation_process, start_date: Date.current - 2.days, end_date: Date.current + 1.day)
|
|
end
|
|
|
|
let!(:process_2) do
|
|
create(:legislation_process, start_date: Date.current + 1.day, end_date: Date.current + 3.days)
|
|
end
|
|
|
|
let!(:process_3) do
|
|
create(:legislation_process, start_date: Date.current - 4.days, end_date: Date.current - 3.days)
|
|
end
|
|
|
|
it "filters open" do
|
|
open_processes = ::Legislation::Process.open
|
|
|
|
expect(open_processes).to eq [process_1]
|
|
expect(open_processes).not_to include [process_2]
|
|
end
|
|
|
|
it "filters past" do
|
|
past_processes = ::Legislation::Process.past
|
|
|
|
expect(past_processes).to eq [process_3]
|
|
end
|
|
end
|
|
|
|
it "filters draft phase" do
|
|
process_before_draft = create(
|
|
:legislation_process,
|
|
draft_start_date: Date.current - 3.days,
|
|
draft_end_date: Date.current - 2.days
|
|
)
|
|
|
|
process_with_draft_disabled = create(
|
|
:legislation_process,
|
|
draft_start_date: Date.current - 2.days,
|
|
draft_end_date: Date.current + 2.days,
|
|
draft_phase_enabled: false
|
|
)
|
|
|
|
process_with_draft_enabled = create(
|
|
:legislation_process,
|
|
draft_start_date: Date.current - 2.days,
|
|
draft_end_date: Date.current + 2.days,
|
|
draft_phase_enabled: true
|
|
)
|
|
|
|
process_with_draft_only_today = create(
|
|
:legislation_process,
|
|
draft_start_date: Date.current,
|
|
draft_end_date: Date.current,
|
|
draft_phase_enabled: true
|
|
)
|
|
|
|
processes_not_in_draft = ::Legislation::Process.not_in_draft
|
|
|
|
expect(processes_not_in_draft).to match_array [process_before_draft, process_with_draft_disabled]
|
|
expect(processes_not_in_draft).not_to include(process_with_draft_enabled)
|
|
expect(processes_not_in_draft).not_to include(process_with_draft_only_today)
|
|
end
|
|
end
|
|
|
|
describe "#status" do
|
|
it "detects planned phase" do
|
|
process.update!(start_date: Date.current + 2.days)
|
|
expect(process.status).to eq(:planned)
|
|
end
|
|
|
|
it "detects closed phase" do
|
|
process.update!(end_date: Date.current - 2.days)
|
|
expect(process.status).to eq(:closed)
|
|
end
|
|
|
|
it "detects open phase" do
|
|
expect(process.status).to eq(:open)
|
|
end
|
|
end
|
|
|
|
describe "Header colors" do
|
|
it "valid format colors" do
|
|
process1 = create(:legislation_process, background_color: "123", font_color: "#fff")
|
|
process2 = create(:legislation_process, background_color: "#fff", font_color: "123")
|
|
process3 = create(:legislation_process, background_color: "", font_color: "")
|
|
process4 = create(:legislation_process, background_color: "#abf123", font_color: "fff123")
|
|
expect(process1).to be_valid
|
|
expect(process2).to be_valid
|
|
expect(process3).to be_valid
|
|
expect(process4).to be_valid
|
|
end
|
|
|
|
it "invalid format colors" do
|
|
expect do
|
|
create(:legislation_process, background_color: "#123ghi", font_color: "#fff")
|
|
end.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Background color is invalid")
|
|
|
|
expect do
|
|
create(:legislation_process, background_color: "#fff", font_color: "ggg")
|
|
end.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Font color is invalid")
|
|
end
|
|
end
|
|
|
|
describe "milestone_tags" do
|
|
context "without milestone_tags" do
|
|
let(:process) { create(:legislation_process) }
|
|
|
|
it "do not have milestone_tags" do
|
|
expect(process.milestone_tag_list).to eq([])
|
|
expect(process.milestone_tags).to eq([])
|
|
end
|
|
|
|
it "add a new milestone_tag" do
|
|
process.milestone_tag_list = "tag1,tag2"
|
|
|
|
expect(process.milestone_tag_list).to eq(["tag1", "tag2"])
|
|
end
|
|
end
|
|
|
|
context "with milestone_tags" do
|
|
let(:process) { create(:legislation_process, :with_milestone_tags) }
|
|
|
|
it "has milestone_tags" do
|
|
expect(process.reload.milestone_tag_list.count).to eq(1)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe ".search" do
|
|
let!(:traffic) do
|
|
create(:legislation_process,
|
|
title: "Traffic regulation",
|
|
summary: "Lane structure",
|
|
description: "From top to bottom")
|
|
end
|
|
|
|
let!(:animal_farm) do
|
|
create(:legislation_process,
|
|
title: "Hierarchy structure",
|
|
summary: "Pigs at the top",
|
|
description: "Napoleon in charge of the traffic")
|
|
end
|
|
|
|
it "returns only matching polls" do
|
|
expect(Legislation::Process.search("lane")).to eq [traffic]
|
|
expect(Legislation::Process.search("pigs")).to eq [animal_farm]
|
|
expect(Legislation::Process.search("nothing here")).to be_empty
|
|
end
|
|
|
|
it "gives more weight to name" do
|
|
expect(Legislation::Process.search("traffic")).to eq [traffic, animal_farm]
|
|
expect(Legislation::Process.search("structure")).to eq [animal_farm, traffic]
|
|
end
|
|
|
|
it "gives more weight to summary than description" do
|
|
expect(Legislation::Process.search("top")).to eq [animal_farm, traffic]
|
|
end
|
|
end
|
|
end
|