Remove spending proposal specs, deprecated feature with flaky tests

2017-08-01 20:50:32 +02:00
parent 095f8a704d
commit 5ede222346
5 changed files with 0 additions and 1975 deletions
--- a/spec/features/admin/spending_proposals_spec.rb
+++ b/spec/features/admin/spending_proposals_spec.rb
@@ -1,678 +0,0 @@
 require 'rails_helper'
 feature 'Admin spending proposals' do
  background do
    Setting["feature.spending_proposals"] = true
    Setting['feature.spending_proposal_features.voting_allowed'] = true
    admin = create(:administrator)
    login_as(admin.user)
  end
  after do
    Setting['feature.spending_proposals'] = nil
    Setting['feature.spending_proposal_features.voting_allowed'] = nil
  end
  context "Feature flag" do
    scenario 'Disabled with a feature flag' do
      Setting['feature.spending_proposals'] = nil
      expect{ visit admin_spending_proposals_path }.to raise_exception(FeatureFlags::FeatureDisabled)
    end
  end
  context "Index" do
    scenario 'Displaying spending proposals' do
      spending_proposal = create(:spending_proposal)
      visit admin_spending_proposals_path
      expect(page).to have_content(spending_proposal.title)
    end
    scenario 'Displaying assignments info' do
      spending_proposal1 = create(:spending_proposal)
      spending_proposal2 = create(:spending_proposal)
      spending_proposal3 = create(:spending_proposal)
      valuator1 = create(:valuator, user: create(:user, username: 'Olga'), description: 'Valuator Olga')
      valuator2 = create(:valuator, user: create(:user, username: 'Miriam'), description: 'Valuator Miriam')
      admin = create(:administrator, user: create(:user, username: 'Gema'))
      spending_proposal1.valuators << valuator1
      spending_proposal2.valuator_ids = [valuator1.id, valuator2.id]
      spending_proposal3.update(administrator_id: admin.id)
      visit admin_spending_proposals_path
      within("#spending_proposal_#{spending_proposal1.id}") do
        expect(page).to have_content("No admin assigned")
        expect(page).to have_content("Valuator Olga")
      end
      within("#spending_proposal_#{spending_proposal2.id}") do
        expect(page).to have_content("No admin assigned")
        expect(page).to have_content("Valuator Olga")
        expect(page).to have_content("Valuator Miriam")
      end
      within("#spending_proposal_#{spending_proposal3.id}") do
        expect(page).to have_content("Gema")
        expect(page).to have_content("No valuators assigned")
      end
    end
    scenario "Filtering by geozone", :js do
      geozone = create(:geozone, name: "District 9")
      create(:spending_proposal, title: "Realocate visitors", geozone: geozone)
      create(:spending_proposal, title: "Destroy the city")
      visit admin_spending_proposals_path
      expect(page).to have_link("Realocate visitors")
      expect(page).to have_link("Destroy the city")
      select "All city", from: "geozone_id"
      expect(page).to have_link("Destroy the city")
      expect(page).to_not have_link("Realocate visitors")
      select "All zones", from: "geozone_id"
      expect(page).to have_link("Realocate visitors")
      expect(page).to have_link("Destroy the city")
      select "District 9", from: "geozone_id"
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      click_link("Realocate visitors")
      click_link("Back")
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      click_link("Realocate visitors")
      click_link("Edit classification")
      expect(page).to have_button("Update")
      click_link("Back")
      expect(page).to_not have_button("Update")
      expect(page).to have_link("Back")
      click_link("Back")
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
    end
    scenario "Filtering by admin", :js do
      user = create(:user, username: 'Admin 1')
      administrator = create(:administrator, user: user)
      create(:spending_proposal, title: "Realocate visitors", administrator: administrator)
      create(:spending_proposal, title: "Destroy the city")
      visit admin_spending_proposals_path
      expect(page).to have_link("Realocate visitors")
      expect(page).to have_link("Destroy the city")
      select "Admin 1", from: "administrator_id"
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      select "All administrators", from: "administrator_id"
      expect(page).to have_content('There are 2 spending proposals')
      expect(page).to have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      select "Admin 1", from: "administrator_id"
      expect(page).to have_content('There is 1 spending proposal')
      click_link("Realocate visitors")
      click_link("Back")
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      click_link("Realocate visitors")
      click_link("Edit classification")
      expect(page).to have_button("Update")
      expect(page).to have_link("Back")
      click_link("Back")
      expect(page).to_not have_button("Update")
      expect(page).to have_link("Back")
      click_link("Back")
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
    end
    scenario "Filtering by valuator", :js do
      user = create(:user)
      valuator = create(:valuator, user: user, description: 'Valuator 1')
      spending_proposal = create(:spending_proposal, title: "Realocate visitors")
      spending_proposal.valuators << valuator
      create(:spending_proposal, title: "Destroy the city")
      visit admin_spending_proposals_path
      expect(page).to have_link("Realocate visitors")
      expect(page).to have_link("Destroy the city")
      select "Valuator 1", from: "valuator_id"
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      select "All valuators", from: "valuator_id"
      expect(page).to have_content('There are 2 spending proposals')
      expect(page).to have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      select "Valuator 1", from: "valuator_id"
      expect(page).to have_content('There is 1 spending proposal')
      click_link("Realocate visitors")
      click_link("Back")
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
      click_link("Realocate visitors")
      click_link("Edit classification")
      expect(page).to have_button("Update")
      expect(page).to have_link("Back")
      click_link("Back")
      expect(page).to_not have_button("Update")
      expect(page).to have_link("Back")
      click_link("Back")
      expect(page).to have_content('There is 1 spending proposal')
      expect(page).to_not have_link("Destroy the city")
      expect(page).to have_link("Realocate visitors")
    end
    scenario "Current filter is properly highlighted" do
      filters_links = {'valuation_open' => 'Open',
                       'without_admin' => 'Without assigned admin',
                       'managed' => 'Managed',
                       'valuating' => 'Under valuation',
                       'valuation_finished' => 'Valuation finished',
                       'all' => 'All'}
      visit admin_spending_proposals_path
      expect(page).to_not have_link(filters_links.values.first)
      filters_links.keys.drop(1).each { |filter| expect(page).to have_link(filters_links[filter]) }
      filters_links.each_pair do |current_filter, link|
        visit admin_spending_proposals_path(filter: current_filter)
        expect(page).to_not have_link(link)
        (filters_links.keys - [current_filter]).each do |filter|
          expect(page).to have_link(filters_links[filter])
        end
      end
    end
    scenario "Filtering by assignment status" do
      assigned = create(:spending_proposal, title: "Assigned idea", administrator: create(:administrator))
      valuating = create(:spending_proposal, title: "Evaluating...")
      valuating.valuators << create(:valuator)
      visit admin_spending_proposals_path(filter: 'valuation_open')
      expect(page).to have_content("Assigned idea")
      expect(page).to have_content("Evaluating...")
      visit admin_spending_proposals_path(filter: 'without_admin')
      expect(page).to have_content("Evaluating...")
      expect(page).to_not have_content("Assigned idea")
      visit admin_spending_proposals_path(filter: 'managed')
      expect(page).to have_content("Assigned idea")
      expect(page).to_not have_content("Evaluating...")
    end
    scenario "Filtering by valuation status" do
      valuating = create(:spending_proposal, title: "Ongoing valuation")
      valuated = create(:spending_proposal, title: "Old idea", valuation_finished: true)
      valuating.valuators << create(:valuator)
      valuated.valuators << create(:valuator)
      visit admin_spending_proposals_path(filter: 'valuation_open')
      expect(page).to have_content("Ongoing valuation")
      expect(page).to_not have_content("Old idea")
      visit admin_spending_proposals_path(filter: 'valuating')
      expect(page).to have_content("Ongoing valuation")
      expect(page).to_not have_content("Old idea")
      visit admin_spending_proposals_path(filter: 'valuation_finished')
      expect(page).to_not have_content("Ongoing valuation")
      expect(page).to have_content("Old idea")
      visit admin_spending_proposals_path(filter: 'all')
      expect(page).to have_content("Ongoing valuation")
      expect(page).to have_content("Old idea")
    end
    scenario "Filtering by tag" do
      create(:spending_proposal, title: 'Educate the children', tag_list: 'Education')
      create(:spending_proposal, title: 'More schools',         tag_list: 'Education')
      create(:spending_proposal, title: 'More hospitals',       tag_list: 'Health')
      visit admin_spending_proposals_path
      expect(page).to have_css(".spending_proposal", count: 3)
      expect(page).to have_content("Educate the children")
      expect(page).to have_content("More schools")
      expect(page).to have_content("More hospitals")
      visit admin_spending_proposals_path(tag_name: 'Education')
      expect(page).to_not have_content("More hospitals")
      expect(page).to have_css(".spending_proposal", count: 2)
      expect(page).to have_content("Educate the children")
      expect(page).to have_content("More schools")
      click_link("Educate the children")
      click_link("Back")
      expect(page).to_not have_content("More hospitals")
      expect(page).to have_content("Educate the children")
      expect(page).to have_content("More schools")
      click_link("Educate the children")
      click_link("Edit classification")
      expect(page).to have_button("Update")
      click_link("Back")
      expect(page).to_not have_button("Update")
      click_link("Back")
      expect(page).to_not have_content("More hospitals")
      expect(page).to have_content("Educate the children")
      expect(page).to have_content("More schools")
    end
  end
  scenario 'Show' do
    administrator = create(:administrator, user: create(:user, username: 'Ana', email: 'ana@admins.org'))
    valuator = create(:valuator, user: create(:user, username: 'Rachel', email: 'rachel@valuators.org'))
    spending_proposal = create(:spending_proposal,
                                geozone: create(:geozone),
                                association_name: 'People of the neighbourhood',
                                price: 1234,
                                price_first_year: 1000,
                                feasible: false,
                                feasible_explanation: 'It is impossible',
                                administrator: administrator)
    spending_proposal.valuators << valuator
    visit admin_spending_proposals_path
    click_link spending_proposal.title
    expect(page).to have_content(spending_proposal.title)
    expect(page).to have_content(spending_proposal.description)
    expect(page).to have_content(spending_proposal.author.name)
    expect(page).to have_content(spending_proposal.association_name)
    expect(page).to have_content(spending_proposal.geozone.name)
    expect(page).to have_content('1234')
    expect(page).to have_content('1000')
    expect(page).to have_content('Not feasible')
    expect(page).to have_content('It is impossible')
    expect(page).to have_content('Ana (ana@admins.org)')
    within('#assigned_valuators') do
      expect(page).to have_content('Rachel (rachel@valuators.org)')
    end
  end
  context "Edit" do
    scenario "Change title, description or geozone" do
      spending_proposal = create(:spending_proposal)
      create(:geozone, name: "Barbate")
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit'
      fill_in 'spending_proposal_title', with: 'Potatoes'
      fill_in 'spending_proposal_description', with: 'Carrots'
      select 'Barbate', from: 'spending_proposal[geozone_id]'
      click_button 'Update'
      expect(page).to have_content 'Potatoes'
      expect(page).to have_content 'Carrots'
      expect(page).to have_content 'Barbate'
    end
    scenario "Add administrator" do
      spending_proposal = create(:spending_proposal)
      administrator = create(:administrator, user: create(:user, username: 'Marta', email: 'marta@admins.org'))
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit classification'
      select 'Marta (marta@admins.org)', from: 'spending_proposal[administrator_id]'
      click_button 'Update'
      expect(page).to have_content 'Investment project updated succesfully.'
      expect(page).to have_content 'Assigned administrator: Marta'
    end
    scenario "Add valuators" do
      spending_proposal = create(:spending_proposal)
      valuator1 = create(:valuator, user: create(:user, username: 'Valentina', email: 'v1@valuators.org'))
      valuator2 = create(:valuator, user: create(:user, username: 'Valerian',  email: 'v2@valuators.org'))
      valuator3 = create(:valuator, user: create(:user, username: 'Val',       email: 'v3@valuators.org'))
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit classification'
      check "spending_proposal_valuator_ids_#{valuator1.id}"
      check "spending_proposal_valuator_ids_#{valuator3.id}"
      click_button 'Update'
      expect(page).to have_content 'Investment project updated succesfully.'
      within('#assigned_valuators') do
        expect(page).to have_content('Valentina (v1@valuators.org)')
        expect(page).to have_content('Val (v3@valuators.org)')
        expect(page).to_not have_content('Undefined')
        expect(page).to_not have_content('Valerian (v2@valuators.org)')
      end
    end
    scenario "Adds existing tags", :js do
      create(:spending_proposal, tag_list: 'Education, Health')
      spending_proposal = create(:spending_proposal)
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit classification'
      find('.js-add-tag-link', text: 'Education').click
      fill_in 'spending_proposal_title', with: 'Updated title'
      click_button 'Update'
      expect(page).to have_content 'Investment project updated succesfully.'
      within "#tags" do
        expect(page).to have_content 'Education'
        expect(page).to_not have_content 'Health'
      end
    end
    scenario "Adds non existent tags" do
      spending_proposal = create(:spending_proposal)
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit classification'
      fill_in 'spending_proposal_tag_list', with: 'Refugees, Solidarity'
      click_button 'Update'
      expect(page).to have_content 'Investment project updated succesfully.'
      within "#tags" do
        expect(page).to have_content 'Refugees'
        expect(page).to have_content 'Solidarity'
      end
    end
    scenario "Errors on update" do
      spending_proposal = create(:spending_proposal)
      create(:geozone, name: "Barbate")
      visit admin_spending_proposal_path(spending_proposal)
      click_link 'Edit'
      fill_in 'spending_proposal_title', with: ''
      click_button 'Update'
      expect(page).to have_content "can't be blank"
    end
  end
  context 'Summary' do
    scenario "Diplays cost for every geozone" do
      california = create(:geozone)
      new_york   = create(:geozone)
      proposal1 = create(:spending_proposal, price: '10000000', geozone: nil,        feasible: true, valuation_finished: true)
      proposal1 = create(:spending_proposal, price: '5000000',  geozone: nil,        feasible: true, valuation_finished: true)
      proposal3 = create(:spending_proposal, price: '1000000',  geozone: california, feasible: true, valuation_finished: true)
      proposal4 = create(:spending_proposal, price: '500000',   geozone: california, feasible: true, valuation_finished: true)
      proposal5 = create(:spending_proposal, price: '30000',    geozone: new_york,   feasible: true, valuation_finished: true)
      visit admin_spending_proposals_path
      click_link "Investment project summary"
      expect(page).to have_content "Summary for investment projects"
      within("#geozone_all_city") do
        expect(page).to have_css(".name",                        text: "All city")
        expect(page).to have_css(".finished-and-feasible-count", text: 2)
        expect(page).to have_css(".total-price",                 text: "$15,000,000")
      end
      within("#geozone_#{california.id}") do
        expect(page).to have_css(".name",                        text: california.name)
        expect(page).to have_css(".finished-and-feasible-count", text: 2)
        expect(page).to have_css(".total-price",                 text: "$1,500,000")
      end
      within("#geozone_#{new_york.id}") do
        expect(page).to have_css(".name",                        text: new_york.name)
        expect(page).to have_css(".finished-and-feasible-count", text: 1)
        expect(page).to have_css(".total-price",                 text: '$30,000')
      end
    end
    scenario "Displays total number of proposals for every geozone" do
      california = create(:geozone)
      new_york   = create(:geozone)
      proposal1 = create(:spending_proposal, geozone: nil)
      proposal1 = create(:spending_proposal, geozone: nil)
      proposal3 = create(:spending_proposal, geozone: california)
      proposal4 = create(:spending_proposal, geozone: california)
      proposal5 = create(:spending_proposal, geozone: new_york)
      visit admin_spending_proposals_path
      click_link "Investment project summary"
      expect(page).to have_content "Summary for investment projects"
      within("#geozone_all_city") do
        expect(page).to have_css(".total-count", text: 2)
      end
      within("#geozone_#{california.id}") do
        expect(page).to have_css(".total-count", text: 2)
      end
      within("#geozone_#{new_york.id}") do
        expect(page).to have_css(".total-count", text: 1)
      end
    end
    scenario "Displays finished and unfeasible for every geozone" do
      california = create(:geozone)
      new_york   = create(:geozone)
      proposal1 = create(:spending_proposal, geozone: nil,        feasible: false, valuation_finished: true)
      proposal2 = create(:spending_proposal, geozone: nil,        feasible: false, valuation_finished: true)
      proposal3 = create(:spending_proposal, geozone: california, feasible: false, valuation_finished: true)
      proposal4 = create(:spending_proposal, geozone: california, feasible: false, valuation_finished: true)
      proposal5 = create(:spending_proposal, geozone: new_york,   feasible: false, valuation_finished: true)
      proposal6 = create(:spending_proposal, geozone: new_york,   feasible: true,  valuation_finished: true)
      visit admin_spending_proposals_path
      click_link "Investment project summary"
      expect(page).to have_content "Summary for investment projects"
      within("#geozone_all_city") do
        expect(page).to have_css(".finished-and-unfeasible-count", text: 2)
      end
      within("#geozone_#{california.id}") do
        expect(page).to have_css(".finished-and-unfeasible-count", text: 2)
      end
      within("#geozone_#{new_york.id}") do
        expect(page).to have_css(".finished-and-unfeasible-count", text: 1)
      end
    end
    scenario "Displays finished proposals for every geozone" do
      california = create(:geozone)
      new_york   = create(:geozone)
      proposal1 = create(:spending_proposal, geozone: nil,        valuation_finished: true)
      proposal2 = create(:spending_proposal, geozone: nil,        valuation_finished: true)
      proposal3 = create(:spending_proposal, geozone: california, valuation_finished: true)
      proposal4 = create(:spending_proposal, geozone: california, valuation_finished: true)
      proposal5 = create(:spending_proposal, geozone: new_york,   valuation_finished: true)
      proposal6 = create(:spending_proposal, geozone: new_york,   valuation_finished: false)
      visit admin_spending_proposals_path
      click_link "Investment project summary"
      expect(page).to have_content "Summary for investment projects"
      within("#geozone_all_city") do
        expect(page).to have_css(".finished-count", text: 2)
      end
      within("#geozone_#{california.id}") do
        expect(page).to have_css(".finished-count", text: 2)
      end
      within("#geozone_#{new_york.id}") do
        expect(page).to have_css(".finished-count", text: 1)
      end
    end
    scenario "Displays proposals in evaluation for every geozone" do
      california = create(:geozone)
      new_york   = create(:geozone)
      proposal1 = create(:spending_proposal, geozone: nil,        valuation_finished: false)
      proposal2 = create(:spending_proposal, geozone: nil,        valuation_finished: false)
      proposal3 = create(:spending_proposal, geozone: california, valuation_finished: false)
      proposal4 = create(:spending_proposal, geozone: california, valuation_finished: false)
      proposal5 = create(:spending_proposal, geozone: new_york,   valuation_finished: false)
      valuator = create(:valuator, user: create(:user, username: 'Olga'))
      SpendingProposal.all.each do |sp|
        sp.valuators << valuator
      end
      proposal6 = create(:spending_proposal, geozone: new_york, valuation_finished: false)
      visit admin_spending_proposals_path
      click_link "Investment project summary"
      expect(page).to have_content "Summary for investment projects"
      within("#geozone_all_city") do
        expect(page).to have_css(".in-evaluation-count", text: 2)
      end
      within("#geozone_#{california.id}") do
        expect(page).to have_css(".in-evaluation-count", text: 2)
      end
      within("#geozone_#{new_york.id}") do
        expect(page).to have_css(".in-evaluation-count", text: 1)
      end
    end
    context "Second table" do
      scenario "should not display proposals without votes" do
        california = create(:geozone)
        new_york   = create(:geozone)
        proposal1 = create(:spending_proposal, geozone: nil,        valuation_finished: true)
        proposal2 = create(:spending_proposal, geozone: nil,        valuation_finished: true)
        proposal3 = create(:spending_proposal, geozone: california, valuation_finished: true)
        proposal4 = create(:spending_proposal, geozone: california, valuation_finished: true)
        proposal5 = create(:spending_proposal, geozone: new_york,   valuation_finished: true)
        proposal6 = create(:spending_proposal, geozone: new_york,   valuation_finished: false)
        create(:vote, votable: proposal1)
        create(:vote, votable: proposal2)
        create(:vote, votable: proposal3)
        visit admin_spending_proposals_path
        click_link "Investment project summary"
        expect(page).to have_content "Summary for investment projects"
        within("#all-proposals") do
          within("#geozone_all_city") do
            expect(page).to have_css(".finished-count", text: 2)
          end
          within("#geozone_#{california.id}") do
            expect(page).to have_css(".finished-count", text: 2)
          end
          within("#geozone_#{new_york.id}") do
            expect(page).to have_css(".finished-count", text: 1)
          end
        end
        within("#proposals-with-votes") do
          within("#geozone_all_city") do
            expect(page).to have_css(".finished-count", text: 2)
          end
          within("#geozone_#{california.id}") do
            expect(page).to have_css(".finished-count", text: 1)
          end
          expect(page).to_not have_css("#geozone_#{new_york.id}")
        end
      end
    end
  end
 end
--- a/spec/features/management/spending_proposals_spec.rb
+++ b/spec/features/management/spending_proposals_spec.rb
@@ -1,230 +0,0 @@
 require 'rails_helper'
 feature 'Spending Proposals' do
  background do
    Setting['feature.spending_proposals'] = true
    Setting['feature.spending_proposal_features.voting_allowed'] = true
    login_as_manager
  end
  after do
    Setting['feature.spending_proposals'] = nil
    Setting['feature.spending_proposal_features.voting_allowed'] = nil
  end
  context "Create" do
    scenario 'Creating spending proposals on behalf of someone' do
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Create spending proposal"
      within(".account-info") do
        expect(page).to have_content "Identified as"
        expect(page).to have_content (user.username).to_s
        expect(page).to have_content (user.email).to_s
        expect(page).to have_content (user.document_number).to_s
      end
      fill_in 'spending_proposal_title', with: 'Build a park in my neighborhood'
      fill_in 'spending_proposal_description', with: 'There is no parks here...'
      fill_in 'spending_proposal_external_url', with: 'http://moarparks.com'
      check 'spending_proposal_terms_of_service'
      click_button 'Create'
      expect(page).to have_content 'Spending proposal created successfully.'
      expect(page).to have_content 'Build a park in my neighborhood'
      expect(page).to have_content 'There is no parks here...'
      expect(page).to have_content 'All city'
      expect(page).to have_content 'http://moarparks.com'
      expect(page).to have_content user.name
      expect(page).to have_content I18n.l(SpendingProposal.last.created_at.to_date)
      expect(current_path).to eq(management_spending_proposal_path(SpendingProposal.last))
    end
    scenario "Should not allow unverified users to create spending proposals" do
      user = create(:user)
      login_managed_user(user)
      click_link "Create spending proposal"
      expect(page).to have_content "User is not verified"
    end
  end
  context "Searching" do
    scenario "by title" do
      spending_proposal1 = create(:spending_proposal, title: "Show me what you got")
      spending_proposal2 = create(:spending_proposal, title: "Get Schwifty")
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Support spending proposals"
      fill_in "search", with: "what you got"
      click_button "Search"
      expect(current_path).to eq(management_spending_proposals_path)
      within("#investment-projects") do
        expect(page).to have_css('.investment-project', count: 1)
        expect(page).to have_content(spending_proposal1.title)
        expect(page).to_not have_content(spending_proposal2.title)
        expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal1)}']", text: spending_proposal1.title)
        expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal1)}']", text: spending_proposal1.description)
      end
    end
    scenario "by district" do
      spending_proposal1 = create(:spending_proposal, title: "Hey ho", geozone_id: create(:geozone, name: "District 9").id)
      spending_proposal2 = create(:spending_proposal, title: "Let's go", geozone_id: create(:geozone, name: "Area 52").id)
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Support spending proposals"
      fill_in "search", with: "Area 52"
      click_button "Search"
      expect(current_path).to eq(management_spending_proposals_path)
      within("#investment-projects") do
        expect(page).to have_css('.investment-project', count: 1)
        expect(page).to_not have_content(spending_proposal1.title)
        expect(page).to have_content(spending_proposal2.title)
        expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal2)}']", text: spending_proposal2.title)
        expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal2)}']", text: spending_proposal2.description)
      end
    end
  end
  scenario "Listing" do
    spending_proposal1 = create(:spending_proposal, title: "Show me what you got")
    spending_proposal2 = create(:spending_proposal, title: "Get Schwifty")
    user = create(:user, :level_two)
    login_managed_user(user)
    click_link "Support spending proposals"
    expect(current_path).to eq(management_spending_proposals_path)
    within(".account-info") do
      expect(page).to have_content "Identified as"
      expect(page).to have_content (user.username).to_s
      expect(page).to have_content (user.email).to_s
      expect(page).to have_content (user.document_number).to_s
    end
    within("#investment-projects") do
      expect(page).to have_css('.investment-project', count: 2)
      expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal1)}']", text: spending_proposal1.title)
      expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal1)}']", text: spending_proposal1.description)
      expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal2)}']", text: spending_proposal2.title)
      expect(page).to have_css("a[href='#{management_spending_proposal_path(spending_proposal2)}']", text: spending_proposal2.description)
    end
  end
  context "Voting" do
    scenario 'Voting spending proposals on behalf of someone in index view', :js do
      spending_proposal = create(:spending_proposal)
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Support spending proposals"
      within("#investment-projects") do
        find('.in-favor a').click
        expect(page).to have_content "1 support"
        expect(page).to have_content "You have already supported this. Share it!"
      end
      expect(current_path).to eq(management_spending_proposals_path)
    end
    scenario 'Voting spending proposals on behalf of someone in show view', :js do
      spending_proposal = create(:spending_proposal)
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Support spending proposals"
      within("#investment-projects") do
        click_link spending_proposal.title
      end
      find('.in-favor a').click
      expect(page).to have_content "1 support"
      expect(page).to have_content "You have already supported this. Share it!"
      expect(current_path).to eq(management_spending_proposal_path(spending_proposal))
    end
    scenario "Should not allow unverified users to vote proposals" do
      spending_proposal = create(:spending_proposal)
      user = create(:user)
      login_managed_user(user)
      click_link "Support spending proposals"
      expect(page).to have_content "User is not verified"
    end
  end
  context "Printing" do
    scenario 'Printing spending proposals' do
      16.times { create(:spending_proposal, geozone_id: nil) }
      click_link "Print spending proposals"
      expect(page).to have_css('.investment-project', count: 15)
      expect(page).to have_css("a[href='javascript:window.print();']", text: 'Print')
    end
    scenario "Filtering spending proposals by geozone to be printed", :js do
      district_9 = create(:geozone, name: "District Nine")
      create(:spending_proposal, title: 'Change district 9', geozone: district_9, cached_votes_up: 10)
      create(:spending_proposal, title: 'Destroy district 9', geozone: district_9, cached_votes_up: 100)
      create(:spending_proposal, title: 'Nuke district 9', geozone: district_9, cached_votes_up: 1)
      create(:spending_proposal, title: 'Add new districts to the city', geozone_id: nil)
      user = create(:user, :level_two)
      login_managed_user(user)
      click_link "Print spending proposals"
      expect(page).to have_content "Investment projects with scope: All city"
      within '#investment-projects' do
        expect(page).to have_content('Add new districts to the city')
        expect(page).to_not have_content('Change district 9')
        expect(page).to_not have_content('Destroy district 9')
        expect(page).to_not have_content('Nuke district 9')
      end
      select 'District Nine', from: 'geozone'
      expect(page).to have_content "Investment projects with scope: District Nine"
      expect(current_url).to include("geozone=#{district_9.id}")
      within '#investment-projects' do
        expect(page).to_not have_content('Add new districts to the city')
        expect('Destroy district 9').to appear_before('Change district 9')
        expect('Change district 9').to appear_before('Nuke district 9')
      end
    end
  end
 end
--- a/spec/features/spending_proposals_spec.rb
+++ b/spec/features/spending_proposals_spec.rb
@@ -1,199 +0,0 @@
 require 'rails_helper'
 feature 'Spending proposals' do
  let(:author) { create(:user, :level_two, username: 'Isabel') }
  background do
    Setting['feature.spending_proposals'] = true
    Setting['feature.spending_proposal_features.voting_allowed'] = true
  end
  after do
    Setting['feature.spending_proposals'] = nil
    Setting['feature.spending_proposal_features.voting_allowed'] = nil
  end
  scenario 'Index' do
    spending_proposals = [create(:spending_proposal), create(:spending_proposal), create(:spending_proposal, feasible: true)]
    unfeasible_spending_proposal = create(:spending_proposal, feasible: false)
    visit spending_proposals_path
    expect(page).to have_selector('#investment-projects .investment-project', count: 3)
    spending_proposals.each do |spending_proposal|
      within('#investment-projects') do
        expect(page).to have_content spending_proposal.title
        expect(page).to have_css("a[href='#{spending_proposal_path(spending_proposal)}']", text: spending_proposal.title)
        expect(page).to_not have_content(unfeasible_spending_proposal.title)
      end
    end
  end
  context("Search") do
    scenario 'Search by text' do
      spending_proposal1 = create(:spending_proposal, title: "Get Schwifty")
      spending_proposal2 = create(:spending_proposal, title: "Schwifty Hello")
      spending_proposal3 = create(:spending_proposal, title: "Do not show me")
      visit spending_proposals_path
      within(".expanded #search_form") do
        fill_in "search", with: "Schwifty"
        click_button "Search"
      end
      within("#investment-projects") do
        expect(page).to have_css('.investment-project', count: 2)
        expect(page).to have_content(spending_proposal1.title)
        expect(page).to have_content(spending_proposal2.title)
        expect(page).to_not have_content(spending_proposal3.title)
      end
    end
  end
  context("Filters") do
    scenario 'by geozone' do
      geozone1 = create(:geozone)
      spending_proposal1 = create(:spending_proposal, geozone: geozone1)
      spending_proposal2 = create(:spending_proposal, geozone: create(:geozone))
      spending_proposal3 = create(:spending_proposal, geozone: geozone1)
      spending_proposal4 = create(:spending_proposal)
      visit spending_proposals_path
      within(".geozone") do
        click_link geozone1.name
      end
      within("#investment-projects") do
        expect(page).to have_css('.investment-project', count: 2)
        expect(page).to have_content(spending_proposal1.title)
        expect(page).to have_content(spending_proposal3.title)
        expect(page).to_not have_content(spending_proposal2.title)
        expect(page).to_not have_content(spending_proposal4.title)
      end
    end
    scenario 'by unfeasibility' do
      geozone1 = create(:geozone)
      spending_proposal1 = create(:spending_proposal, feasible: false)
      spending_proposal2 = create(:spending_proposal, feasible: true)
      spending_proposal3 = create(:spending_proposal)
      visit spending_proposals_path
      within("#sidebar") do
        click_link "Unfeasible"
      end
      within("#investment-projects") do
        expect(page).to have_css('.investment-project', count: 1)
        expect(page).to have_content(spending_proposal1.title)
        expect(page).to_not have_content(spending_proposal2.title)
        expect(page).to_not have_content(spending_proposal3.title)
      end
    end
  end
  scenario 'Create' do
    login_as(author)
    visit new_spending_proposal_path
    fill_in 'spending_proposal_title', with: 'Build a skyscraper'
    fill_in 'spending_proposal_description', with: 'I want to live in a high tower over the clouds'
    fill_in 'spending_proposal_external_url', with: 'http://http://skyscraperpage.com/'
    fill_in 'spending_proposal_association_name', with: 'People of the neighbourhood'
    select  'All city', from: 'spending_proposal_geozone_id'
    check 'spending_proposal_terms_of_service'
    click_button 'Create'
    expect(page).to have_content 'Spending proposal created successfully'
    expect(page).to have_content('Build a skyscraper')
    expect(page).to have_content('I want to live in a high tower over the clouds')
    expect(page).to have_content('Isabel')
    expect(page).to have_content('People of the neighbourhood')
    expect(page).to have_content('All city')
  end
  scenario 'Create with invisible_captcha honeypot field' do
    login_as(author)
    visit new_spending_proposal_path
    fill_in 'spending_proposal_title', with: 'I am a bot'
    fill_in 'spending_proposal_subtitle', with: 'This is the honeypot'
    fill_in 'spending_proposal_description', with: 'This is the description'
    select  'All city', from: 'spending_proposal_geozone_id'
    check 'spending_proposal_terms_of_service'
    click_button 'Create'
    expect(page.status_code).to eq(200)
    expect(page.html).to be_empty
    expect(current_path).to eq(spending_proposals_path)
  end
  scenario 'Create spending proposal too fast' do
    allow(InvisibleCaptcha).to receive(:timestamp_threshold).and_return(Float::INFINITY)
    login_as(author)
    visit new_spending_proposal_path
    fill_in 'spending_proposal_title', with: 'I am a bot'
    fill_in 'spending_proposal_description', with: 'This is the description'
    select  'All city', from: 'spending_proposal_geozone_id'
    check 'spending_proposal_terms_of_service'
    click_button 'Create'
    expect(page).to have_content 'Sorry, that was too quick! Please resubmit'
    expect(current_path).to eq(new_spending_proposal_path)
  end
  scenario 'Create notice' do
    login_as(author)
    visit new_spending_proposal_path
    fill_in 'spending_proposal_title', with: 'Build a skyscraper'
    fill_in 'spending_proposal_description', with: 'I want to live in a high tower over the clouds'
    fill_in 'spending_proposal_external_url', with: 'http://http://skyscraperpage.com/'
    fill_in 'spending_proposal_association_name', with: 'People of the neighbourhood'
    select  'All city', from: 'spending_proposal_geozone_id'
    check 'spending_proposal_terms_of_service'
    click_button 'Create'
    expect(page).to have_content 'Spending proposal created successfully'
    expect(page).to have_content 'You can access it from My activity'
  end
  scenario 'Errors on create' do
    login_as(author)
    visit new_spending_proposal_path
    click_button 'Create'
    expect(page).to have_content error_message
  end
  scenario "Show" do
    spending_proposal = create(:spending_proposal,
                                geozone: create(:geozone),
                                association_name: 'People of the neighbourhood')
    visit spending_proposal_path(spending_proposal)
    expect(page).to have_content(spending_proposal.title)
    expect(page).to have_content(spending_proposal.description)
    expect(page).to have_content(spending_proposal.author.name)
    expect(page).to have_content(spending_proposal.association_name)
    expect(page).to have_content(spending_proposal.geozone.name)
    within("#spending_proposal_code") do
      expect(page).to have_content(spending_proposal.id)
    end
  end
 end
--- a/spec/features/valuation/spending_proposals_spec.rb
+++ b/spec/features/valuation/spending_proposals_spec.rb
@@ -1,479 +0,0 @@
 require 'rails_helper'
 feature 'Valuation spending proposals' do
  background do
    Setting['feature.spending_proposals'] = true
    Setting['feature.spending_proposal_features.voting_allowed'] = true
    @valuator = create(:valuator, user: create(:user, username: 'Rachel', email: 'rachel@valuators.org'))
    login_as(@valuator.user)
  end
  after do
    Setting['feature.spending_proposals'] = nil
    Setting['feature.spending_proposal_features.voting_allowed'] = nil
  end
  scenario 'Disabled with a feature flag' do
    Setting['feature.spending_proposals'] = nil
    expect{ visit valuation_spending_proposals_path }.to raise_exception(FeatureFlags::FeatureDisabled)
  end
  scenario 'Index shows spending proposals assigned to current valuator' do
    spending_proposal1 = create(:spending_proposal)
    spending_proposal2 = create(:spending_proposal)
    spending_proposal1.valuators << @valuator
    visit valuation_spending_proposals_path
    expect(page).to have_content(spending_proposal1.title)
    expect(page).to_not have_content(spending_proposal2.title)
  end
  scenario 'Index shows no spending proposals to admins no valuators' do
    spending_proposal1 = create(:spending_proposal)
    spending_proposal2 = create(:spending_proposal)
    spending_proposal1.valuators << @valuator
    logout
    login_as create(:administrator).user
    visit valuation_spending_proposals_path
    expect(page).to_not have_content(spending_proposal1.title)
    expect(page).to_not have_content(spending_proposal2.title)
  end
  scenario 'Index orders spending proposals by votes' do
    spending_proposal10 = create(:spending_proposal, cached_votes_up: 10)
    spending_proposal100 = create(:spending_proposal, cached_votes_up: 100)
    spending_proposal1 = create(:spending_proposal, cached_votes_up: 1)
    spending_proposal1.valuators << @valuator
    spending_proposal10.valuators << @valuator
    spending_proposal100.valuators << @valuator
    visit valuation_spending_proposals_path
    expect(spending_proposal100.title).to appear_before(spending_proposal10.title)
    expect(spending_proposal10.title).to appear_before(spending_proposal1.title)
  end
  scenario 'Index shows assignments info' do
    spending_proposal1 = create(:spending_proposal)
    spending_proposal2 = create(:spending_proposal)
    spending_proposal3 = create(:spending_proposal)
    valuator1 = create(:valuator, user: create(:user))
    valuator2 = create(:valuator, user: create(:user))
    valuator3 = create(:valuator, user: create(:user))
    spending_proposal1.valuator_ids = [@valuator.id]
    spending_proposal2.valuator_ids = [@valuator.id, valuator1.id, valuator2.id]
    spending_proposal3.valuator_ids = [@valuator.id, valuator3.id]
    visit valuation_spending_proposals_path
    within("#spending_proposal_#{spending_proposal1.id}") do
      expect(page).to have_content("Rachel")
    end
    within("#spending_proposal_#{spending_proposal2.id}") do
      expect(page).to have_content("3 valuators assigned")
    end
    within("#spending_proposal_#{spending_proposal3.id}") do
      expect(page).to have_content("2 valuators assigned")
    end
  end
  scenario "Index filtering by geozone", :js do
    geozone = create(:geozone, name: "District 9")
    spending_proposal1 = create(:spending_proposal, title: "Realocate visitors", geozone: geozone)
    spending_proposal2 = create(:spending_proposal, title: "Destroy the city")
    spending_proposal1.valuators << @valuator
    spending_proposal2.valuators << @valuator
    visit valuation_spending_proposals_path
    expect(page).to have_link("Realocate visitors")
    expect(page).to have_link("Destroy the city")
    click_link "District 9", exact: false
    expect(page).to have_link("Realocate visitors")
    expect(page).to_not have_link("Destroy the city")
    click_link "All city", exact: false
    expect(page).to have_link("Destroy the city")
    expect(page).to_not have_link("Realocate visitors")
    click_link "All zones", exact: false
    expect(page).to have_link("Realocate visitors")
    expect(page).to have_link("Destroy the city")
  end
  scenario "Current filter is properly highlighted" do
    filters_links = {'valuating' => 'Under valuation',
                     'valuation_finished' => 'Valuation finished'}
    visit valuation_spending_proposals_path
    expect(page).to_not have_link(filters_links.values.first)
    filters_links.keys.drop(1).each { |filter| expect(page).to have_link(filters_links[filter]) }
    filters_links.each_pair do |current_filter, link|
      visit valuation_spending_proposals_path(filter: current_filter)
      expect(page).to_not have_link(link)
      (filters_links.keys - [current_filter]).each do |filter|
        expect(page).to have_link(filters_links[filter])
      end
    end
  end
  scenario "Index filtering by valuation status" do
    valuating = create(:spending_proposal, title: "Ongoing valuation")
    valuated = create(:spending_proposal, title: "Old idea", valuation_finished: true)
    valuating.valuators << @valuator
    valuated.valuators << @valuator
    visit valuation_spending_proposals_path(filter: 'valuation_open')
    expect(page).to have_content("Ongoing valuation")
    expect(page).to_not have_content("Old idea")
    visit valuation_spending_proposals_path(filter: 'valuating')
    expect(page).to have_content("Ongoing valuation")
    expect(page).to_not have_content("Old idea")
    visit valuation_spending_proposals_path(filter: 'valuation_finished')
    expect(page).to_not have_content("Ongoing valuation")
    expect(page).to have_content("Old idea")
  end
  feature 'Show' do
    scenario 'visible for assigned valuators' do
      administrator = create(:administrator, user: create(:user, username: 'Ana', email: 'ana@admins.org'))
      valuator2 = create(:valuator, user: create(:user, username: 'Rick', email: 'rick@valuators.org'))
      spending_proposal = create(:spending_proposal,
                                  geozone: create(:geozone),
                                  association_name: 'People of the neighbourhood',
                                  price: 1234,
                                  feasible: false,
                                  feasible_explanation: 'It is impossible',
                                  administrator: administrator)
      spending_proposal.valuators << [@valuator, valuator2]
      visit valuation_spending_proposals_path
      click_link spending_proposal.title
      expect(page).to have_content(spending_proposal.title)
      expect(page).to have_content(spending_proposal.description)
      expect(page).to have_content(spending_proposal.author.name)
      expect(page).to have_content(spending_proposal.association_name)
      expect(page).to have_content(spending_proposal.geozone.name)
      expect(page).to have_content('1234')
      expect(page).to have_content('Not feasible')
      expect(page).to have_content('It is impossible')
      expect(page).to have_content('Ana (ana@admins.org)')
      within('#assigned_valuators') do
        expect(page).to have_content('Rachel (rachel@valuators.org)')
        expect(page).to have_content('Rick (rick@valuators.org)')
      end
    end
    scenario 'visible for admins' do
      logout
      login_as create(:administrator).user
      administrator = create(:administrator, user: create(:user, username: 'Ana', email: 'ana@admins.org'))
      valuator2 = create(:valuator, user: create(:user, username: 'Rick', email: 'rick@valuators.org'))
      spending_proposal = create(:spending_proposal,
                                  geozone: create(:geozone),
                                  association_name: 'People of the neighbourhood',
                                  price: 1234,
                                  feasible: false,
                                  feasible_explanation: 'It is impossible',
                                  administrator: administrator)
      spending_proposal.valuators << [@valuator, valuator2]
      visit valuation_spending_proposal_path(spending_proposal)
      expect(page).to have_content(spending_proposal.title)
      expect(page).to have_content(spending_proposal.description)
      expect(page).to have_content(spending_proposal.author.name)
      expect(page).to have_content(spending_proposal.association_name)
      expect(page).to have_content(spending_proposal.geozone.name)
      expect(page).to have_content('1234')
      expect(page).to have_content('Not feasible')
      expect(page).to have_content('It is impossible')
      expect(page).to have_content('Ana (ana@admins.org)')
      within('#assigned_valuators') do
        expect(page).to have_content('Rachel (rachel@valuators.org)')
        expect(page).to have_content('Rick (rick@valuators.org)')
      end
    end
    scenario 'not visible for not assigned valuators' do
      logout
      login_as create(:valuator).user
      administrator = create(:administrator, user: create(:user, username: 'Ana', email: 'ana@admins.org'))
      valuator2 = create(:valuator, user: create(:user, username: 'Rick', email: 'rick@valuators.org'))
      spending_proposal = create(:spending_proposal,
                                  geozone: create(:geozone),
                                  association_name: 'People of the neighbourhood',
                                  price: 1234,
                                  feasible: false,
                                  feasible_explanation: 'It is impossible',
                                  administrator: administrator)
      spending_proposal.valuators << [@valuator, valuator2]
      expect { visit valuation_spending_proposal_path(spending_proposal) }.to raise_error "Not Found"
    end
  end
  feature 'Valuate' do
    background do
      @spending_proposal = create(:spending_proposal,
                                geozone: create(:geozone),
                                administrator: create(:administrator))
      @spending_proposal.valuators << @valuator
    end
    scenario 'Dossier empty by default' do
      visit valuation_spending_proposals_path
      click_link @spending_proposal.title
      within('#price') { expect(page).to have_content('Undefined') }
      within('#price_first_year') { expect(page).to have_content('Undefined') }
      within('#time_scope') { expect(page).to have_content('Undefined') }
      within('#feasibility') { expect(page).to have_content('Undefined') }
      expect(page).to_not have_content('Valuation finished')
      expect(page).to_not have_content('Internal comments')
    end
    scenario 'Edit dossier' do
      visit valuation_spending_proposals_path
      within("#spending_proposal_#{@spending_proposal.id}") do
        click_link "Edit"
      end
      fill_in 'spending_proposal_price', with: '12345'
      fill_in 'spending_proposal_price_first_year', with: '9876'
      fill_in 'spending_proposal_price_explanation', with: 'Very cheap idea'
      choose  'spending_proposal_feasible_true'
      fill_in 'spending_proposal_feasible_explanation', with: 'Everything is legal and easy to do'
      fill_in 'spending_proposal_time_scope', with: '19 months'
      fill_in 'spending_proposal_internal_comments', with: 'Should be double checked by the urbanism area'
      click_button 'Save changes'
      expect(page).to have_content "Dossier updated"
      visit valuation_spending_proposals_path
      click_link @spending_proposal.title
      within('#price') { expect(page).to have_content('12345') }
      within('#price_first_year') { expect(page).to have_content('9876') }
      expect(page).to have_content('Very cheap idea')
      within('#time_scope') { expect(page).to have_content('19 months') }
      within('#feasibility') { expect(page).to have_content('Feasible') }
      expect(page).to_not have_content('Valuation finished')
      expect(page).to have_content('Internal comments')
      expect(page).to have_content('Should be double checked by the urbanism area')
    end
    scenario 'Feasibility can be marked as pending' do
      visit valuation_spending_proposal_path(@spending_proposal)
      click_link 'Edit dossier'
      expect(find "#spending_proposal_feasible_nil").to be_checked
      choose 'spending_proposal_feasible_true'
      click_button 'Save changes'
      visit edit_valuation_spending_proposal_path(@spending_proposal)
      expect(find "#spending_proposal_feasible_nil").to_not be_checked
      expect(find "#spending_proposal_feasible_true").to be_checked
      choose 'spending_proposal_feasible_nil'
      click_button 'Save changes'
      visit edit_valuation_spending_proposal_path(@spending_proposal)
      expect(find "#spending_proposal_feasible_nil").to be_checked
    end
    scenario 'Feasibility selection makes proper fields visible', :js do
      feasible_true_fields  = ['Price (€)', 'Cost during the first year (€)', 'Price explanation', 'Time scope']
      feasible_false_fields = ['Feasibility explanation']
      feasible_any_fields   = ['Valuation finished', 'Internal comments']
      feasible_nil_fields   = feasible_true_fields + feasible_false_fields + feasible_any_fields
      visit edit_valuation_spending_proposal_path(@spending_proposal)
      expect(find "#spending_proposal_feasible_nil").to be_checked
      feasible_nil_fields.each do |field|
        expect(page).to have_content(field)
      end
      choose 'spending_proposal_feasible_true'
      feasible_false_fields.each do |field|
        expect(page).to_not have_content(field)
      end
      (feasible_true_fields + feasible_any_fields).each do |field|
        expect(page).to have_content(field)
      end
      choose 'spending_proposal_feasible_false'
      feasible_true_fields.each do |field|
        expect(page).to_not have_content(field)
      end
      (feasible_false_fields + feasible_any_fields).each do |field|
        expect(page).to have_content(field)
      end
      click_button 'Save changes'
      visit edit_valuation_spending_proposal_path(@spending_proposal)
      expect(find "#spending_proposal_feasible_false").to be_checked
      feasible_true_fields.each do |field|
        expect(page).to_not have_content(field)
      end
      (feasible_false_fields + feasible_any_fields).each do |field|
        expect(page).to have_content(field)
      end
      choose 'spending_proposal_feasible_nil'
      feasible_nil_fields.each do |field|
        expect(page).to have_content(field)
      end
    end
    scenario 'Finish valuation' do
      visit valuation_spending_proposal_path(@spending_proposal)
      click_link 'Edit dossier'
      check 'spending_proposal_valuation_finished'
      click_button 'Save changes'
      visit valuation_spending_proposals_path
      expect(page).to_not have_content @spending_proposal.title
      click_link 'Valuation finished'
      expect(page).to have_content @spending_proposal.title
      click_link @spending_proposal.title
      expect(page).to have_content('Valuation finished')
    end
    scenario 'Validates price formats' do
      visit valuation_spending_proposals_path
      within("#spending_proposal_#{@spending_proposal.id}") do
        click_link "Edit"
      end
      fill_in 'spending_proposal_price', with: '12345,98'
      fill_in 'spending_proposal_price_first_year', with: '9876.6'
      click_button 'Save changes'
      expect(page).to have_content('2 errors')
      expect(page).to have_content('Only integer numbers', count: 2)
    end
  end
  context "Summary" do
    background do
      admin = create(:administrator)
      login_as(admin.user)
    end
    scenario "Summary table" do
      scarlett = create(:valuator)
      john = create(:valuator)
      finished_and_feasible1 = create(:spending_proposal, valuation_finished: true, feasible: true, price: '3000000')
      finished_and_feasible2 = create(:spending_proposal, valuation_finished: true, feasible: true, price: '7000000')
      finished_and_unfeasible1 = create(:spending_proposal, valuation_finished: true, feasible: false)
      finished_and_unfeasible2 = create(:spending_proposal, valuation_finished: true, feasible: false)
      in_evaluation1 = create(:spending_proposal, feasible: true, valuation_finished: false)
      in_evaluation2 = create(:spending_proposal, feasible: true, valuation_finished: false)
      finished_and_feasible1.valuators << scarlett
      finished_and_feasible2.valuators << scarlett
      finished_and_unfeasible1.valuators << john
      finished_and_unfeasible2.valuators << john
      in_evaluation1.valuators << scarlett
      in_evaluation2.valuators << john
      visit admin_spending_proposals_path
      click_link "Valuator summary"
      expect(page).to have_content "Valuator summary for investment projects"
      within("#valuator_#{scarlett.id}") do
        expect(page).to have_css(".finished-and-feasible-count", text: '2')
        expect(page).to have_css(".finished-and-unfeasible-count", text: '0')
        expect(page).to have_css(".finished-count", text: '2')
        expect(page).to have_css(".in-evaluation-count", text: '1')
        expect(page).to have_css(".total-count", text: '3')
        expect(page).to have_css(".total-price", text: "$10,000,000.00")
      end
      within("#valuator_#{john.id}") do
        expect(page).to have_css(".finished-and-feasible-count", text: '0')
        expect(page).to have_css(".finished-and-unfeasible-count", text: '2')
        expect(page).to have_css(".finished-count", text: '2')
        expect(page).to have_css(".in-evaluation-count", text: '1')
        expect(page).to have_css(".total-count", text: '3')
        expect(page).to have_css(".total-price", text: '$0.00')
      end
    end
    scenario "Order by investment project count" do
      isabel = create(:valuator)
      john = create(:valuator)
      scarlett = create(:valuator)
      3.times { create(:spending_proposal, valuators: [scarlett])}
      1.times { create(:spending_proposal, valuators: [john])}
      2.times { create(:spending_proposal, valuators: [isabel])}
      visit admin_spending_proposals_path
      click_link "Valuator summary"
      expect(scarlett.email).to appear_before(isabel.email)
      expect(isabel.email).to appear_before(john.email)
    end
    scenario "Back link" do
      visit admin_spending_proposals_path
      click_link "Valuator summary"
      expect(page).to have_content "Valuator summary for investment projects"
      click_link "Go back"
      expect(page).to have_content "Investment projects for participatory budgeting"
    end
  end
 end
--- a/spec/models/spending_proposal_spec.rb
+++ b/spec/models/spending_proposal_spec.rb
@@ -1,389 +0,0 @@
 require 'rails_helper'
 describe SpendingProposal do
  let(:spending_proposal) { build(:spending_proposal) }
  it "should be valid" do
    expect(spending_proposal).to be_valid
  end
  it "should not be valid without an author" do
    spending_proposal.author = nil
    expect(spending_proposal).to_not be_valid
  end
  describe "#title" do
    it "should not be valid without a title" do
      spending_proposal.title = nil
      expect(spending_proposal).to_not be_valid
    end
    it "should not be valid when very short" do
      spending_proposal.title = "abc"
      expect(spending_proposal).to_not be_valid
    end
    it "should not be valid when very long" do
      spending_proposal.title = "a" * 81
      expect(spending_proposal).to_not be_valid
    end
  end
  describe "#description" do
    it "should be sanitized" do
      spending_proposal.description = "<script>alert('danger');</script>"
      spending_proposal.valid?
      expect(spending_proposal.description).to eq("alert('danger');")
    end
    it "should not be valid when very long" do
      spending_proposal.description = "a" * 6001
      expect(spending_proposal).to_not be_valid
    end
  end
  describe "#feasible_explanation" do
    it "should be valid if valuation not finished" do
      spending_proposal.feasible_explanation = ""
      spending_proposal.valuation_finished = false
      expect(spending_proposal).to be_valid
    end
    it "should be valid if valuation finished and feasible" do
      spending_proposal.feasible_explanation = ""
      spending_proposal.feasible = true
      spending_proposal.valuation_finished = true
      expect(spending_proposal).to be_valid
    end
    it "should not be valid if valuation finished and unfeasible" do
      spending_proposal.feasible_explanation = ""
      spending_proposal.feasible = false
      spending_proposal.valuation_finished = true
      expect(spending_proposal).to_not be_valid
    end
  end
  describe "dossier info" do
    describe "#feasibility" do
      it "can be feasible" do
        spending_proposal.feasible = true
        expect(spending_proposal.feasibility).to eq "feasible"
      end
      it "can be not-feasible" do
        spending_proposal.feasible = false
        expect(spending_proposal.feasibility).to eq "not_feasible"
      end
      it "can be undefined" do
        spending_proposal.feasible = nil
        expect(spending_proposal.feasibility).to eq "undefined"
      end
    end
    describe "#unfeasible?" do
      it "returns true when not feasible" do
        spending_proposal.feasible = false
        expect(spending_proposal.unfeasible?).to eq true
      end
      it "returns false when feasible" do
        spending_proposal.feasible = true
        expect(spending_proposal.unfeasible?).to eq false
      end
    end
    describe "#unfeasible_email_pending?" do
      let(:spending_proposal) { create(:spending_proposal) }
      it "returns true when marked as unfeasibable and valuation_finished" do
        spending_proposal.update(feasible: false, valuation_finished: true)
        expect(spending_proposal.unfeasible_email_pending?).to eq true
      end
      it "returns false when marked as feasible" do
        spending_proposal.update(feasible: true)
        expect(spending_proposal.unfeasible_email_pending?).to eq false
      end
      it "returns false when marked as feasable and valuation_finished" do
        spending_proposal.update(feasible: true, valuation_finished: true)
        expect(spending_proposal.unfeasible_email_pending?).to eq false
      end
      it "returns false when unfeasible email already sent" do
        spending_proposal.update(unfeasible_email_sent_at: 1.day.ago)
        expect(spending_proposal.unfeasible_email_pending?).to eq false
      end
    end
    describe "#send_unfeasible_email" do
      let(:spending_proposal) { create(:spending_proposal) }
      it "sets the time when the unfeasible email was sent" do
        expect(spending_proposal.unfeasible_email_sent_at).to_not be
        spending_proposal.send_unfeasible_email
        expect(spending_proposal.unfeasible_email_sent_at).to be
      end
      it "send an email" do
        expect {spending_proposal.send_unfeasible_email}.to change { ActionMailer::Base.deliveries.count }.by(1)
      end
    end
    describe "#code" do
      let(:spending_proposal) { create(:spending_proposal) }
      it "returns the proposal id" do
        expect(spending_proposal.code).to include((spending_proposal.id).to_s)
      end
      it "returns the administrator id when assigned" do
        spending_proposal.administrator = create(:administrator)
        expect(spending_proposal.code).to include("#{spending_proposal.id}-A#{spending_proposal.administrator.id}")
      end
    end
  end
  describe "by_admin" do
    it "should return spending proposals assigned to specific administrator" do
      spending_proposal1 = create(:spending_proposal, administrator_id: 33)
      spending_proposal2 = create(:spending_proposal)
      by_admin = SpendingProposal.by_admin(33)
      expect(by_admin.size).to eq(1)
      expect(by_admin.first).to eq(spending_proposal1)
    end
  end
  describe "by_valuator" do
    it "should return spending proposals assigned to specific valuator" do
      spending_proposal1 = create(:spending_proposal)
      spending_proposal2 = create(:spending_proposal)
      spending_proposal3 = create(:spending_proposal)
      valuator1 = create(:valuator)
      valuator2 = create(:valuator)
      spending_proposal1.valuators << valuator1
      spending_proposal2.valuators << valuator2
      spending_proposal3.valuators << [valuator1, valuator2]
      by_valuator = SpendingProposal.by_valuator(valuator1.id)
      expect(by_valuator.size).to eq(2)
      expect(by_valuator.sort).to eq([spending_proposal1, spending_proposal3].sort)
    end
  end
  describe "scopes" do
    describe "valuation_open" do
      it "should return all spending proposals with false valuation_finished" do
        spending_proposal1 = create(:spending_proposal, valuation_finished: true)
        spending_proposal2 = create(:spending_proposal)
        valuation_open = SpendingProposal.valuation_open
        expect(valuation_open.size).to eq(1)
        expect(valuation_open.first).to eq(spending_proposal2)
      end
    end
    describe "without_admin" do
      it "should return all open spending proposals without assigned admin" do
        spending_proposal1 = create(:spending_proposal, valuation_finished: true)
        spending_proposal2 = create(:spending_proposal, administrator: create(:administrator))
        spending_proposal3 = create(:spending_proposal)
        without_admin = SpendingProposal.without_admin
        expect(without_admin.size).to eq(1)
        expect(without_admin.first).to eq(spending_proposal3)
      end
    end
    describe "managed" do
      it "should return all open spending proposals with assigned admin but without assigned valuators" do
        spending_proposal1 = create(:spending_proposal, administrator: create(:administrator))
        spending_proposal2 = create(:spending_proposal, administrator: create(:administrator), valuation_finished: true)
        spending_proposal3 = create(:spending_proposal, administrator: create(:administrator))
        spending_proposal1.valuators << create(:valuator)
        managed = SpendingProposal.managed
        expect(managed.size).to eq(1)
        expect(managed.first).to eq(spending_proposal3)
      end
    end
    describe "valuating" do
      it "should return all spending proposals with assigned valuator but valuation not finished" do
        spending_proposal1 = create(:spending_proposal)
        spending_proposal2 = create(:spending_proposal)
        spending_proposal3 = create(:spending_proposal, valuation_finished: true)
        spending_proposal2.valuators << create(:valuator)
        spending_proposal3.valuators << create(:valuator)
        valuating = SpendingProposal.valuating
        expect(valuating.size).to eq(1)
        expect(valuating.first).to eq(spending_proposal2)
      end
    end
    describe "valuation_finished" do
      it "should return all spending proposals with valuation finished" do
        spending_proposal1 = create(:spending_proposal)
        spending_proposal2 = create(:spending_proposal)
        spending_proposal3 = create(:spending_proposal, valuation_finished: true)
        spending_proposal2.valuators << create(:valuator)
        spending_proposal3.valuators << create(:valuator)
        valuation_finished = SpendingProposal.valuation_finished
        expect(valuation_finished.size).to eq(1)
        expect(valuation_finished.first).to eq(spending_proposal3)
      end
    end
    describe "feasible" do
      it "should return all feasible spending proposals" do
        feasible_spending_proposal = create(:spending_proposal, feasible: true)
        create(:spending_proposal)
        expect(SpendingProposal.feasible).to eq [feasible_spending_proposal]
      end
    end
    describe "unfeasible" do
      it "should return all unfeasible spending proposals" do
        unfeasible_spending_proposal = create(:spending_proposal, feasible: false)
        create(:spending_proposal, feasible: true)
        expect(SpendingProposal.unfeasible).to eq [unfeasible_spending_proposal]
      end
    end
    describe "not_unfeasible" do
      it "should return all not unfeasible spending proposals" do
        not_unfeasible_spending_proposal_1 = create(:spending_proposal, feasible: true)
        not_unfeasible_spending_proposal_2 = create(:spending_proposal)
        create(:spending_proposal, feasible: false)
        not_unfeasibles = SpendingProposal.not_unfeasible
        expect(not_unfeasibles.size).to eq(2)
        expect(not_unfeasibles.include?(not_unfeasible_spending_proposal_1)).to eq(true)
        expect(not_unfeasibles.include?(not_unfeasible_spending_proposal_2)).to eq(true)
      end
    end
  end
  describe 'Supports' do
    let(:user)        { create(:user, :level_two) }
    let(:luser)       { create(:user) }
    let(:district)    { create(:geozone) }
    let(:city_sp)     { create(:spending_proposal) }
    let(:district_sp) { create(:spending_proposal, geozone: district) }
    before do
      Setting["feature.spending_proposals"] = true
      Setting['feature.spending_proposal_features.voting_allowed'] = true
    end
    after do
      Setting["feature.spending_proposals"] = nil
      Setting['feature.spending_proposal_features.voting_allowed'] = nil
    end
    describe '#reason_for_not_being_votable_by' do
      it "rejects not logged in users" do
        expect(city_sp.reason_for_not_being_votable_by(nil)).to eq(:not_logged_in)
        expect(district_sp.reason_for_not_being_votable_by(nil)).to eq(:not_logged_in)
      end
      it "rejects not verified users" do
        expect(city_sp.reason_for_not_being_votable_by(luser)).to eq(:not_verified)
        expect(district_sp.reason_for_not_being_votable_by(luser)).to eq(:not_verified)
      end
      it "rejects unfeasible spending proposals" do
        unfeasible = create(:spending_proposal, feasible: false, valuation_finished: true)
        expect(unfeasible.reason_for_not_being_votable_by(user)).to eq(:unfeasible)
      end
      it "rejects organizations" do
        create(:organization, user: user)
        expect(city_sp.reason_for_not_being_votable_by(user)).to eq(:organization)
        expect(district_sp.reason_for_not_being_votable_by(user)).to eq(:organization)
      end
      it "rejects votes when voting is not allowed (via admin setting)" do
        Setting["feature.spending_proposal_features.voting_allowed"] = nil
        expect(city_sp.reason_for_not_being_votable_by(user)).to eq(:not_voting_allowed)
        expect(district_sp.reason_for_not_being_votable_by(user)).to eq(:not_voting_allowed)
      end
      it "accepts valid votes when voting is allowed" do
        Setting["feature.spending_proposal_features.voting_allowed"] = true
        expect(city_sp.reason_for_not_being_votable_by(user)).to be_nil
        expect(district_sp.reason_for_not_being_votable_by(user)).to be_nil
        Setting["feature.spending_proposal_features.voting_allowed"] = nil
      end
    end
  end
  describe "responsible_name" do
    let(:user) { create(:user, document_number: "123456") }
    let!(:spending_proposal) { create(:spending_proposal, author: user) }
    it "gets updated with the document_number" do
      expect(spending_proposal.responsible_name).to eq("123456")
    end
    it "does not get updated if the user is erased" do
      user.erase
      expect(user.erased_at).to be
      spending_proposal.touch
      expect(spending_proposal.responsible_name).to eq("123456")
    end
  end
  describe "total votes" do
    before do
      Setting["feature.spending_proposals"] = true
      Setting['feature.spending_proposal_features.voting_allowed'] = true
    end
    after do
      Setting["feature.spending_proposals"] = nil
      Setting['feature.spending_proposal_features.voting_allowed'] = nil
    end
    it "takes into account physical votes in addition to web votes" do
      sp = create(:spending_proposal)
      sp.register_vote(create(:user, :level_two), true)
      expect(sp.total_votes).to eq(1)
      sp.physical_votes = 10
      expect(sp.total_votes).to eq(11)
    end
  end
  describe "#with_supports" do
    it "should return proposals with supports" do
      sp1 = create(:spending_proposal)
      sp2 = create(:spending_proposal)
      create(:vote, votable: sp1)
      expect(SpendingProposal.with_supports).to include(sp1)
      expect(SpendingProposal.with_supports).to_not include(sp2)
    end
  end
 end