dorsale 3.14.3 → 3.14.4

data/features/step_definitions/flyboy_task_comments_steps.rb

@@ -1,10 +0,0 @@
-When(/^I create a new task comment$/) do
-  fill_in "task_comment_progress", with: "50"
-  fill_in "task_comment_description", with: "I-am-the-task-comment-description"
-  find("form[id*=task_comment] [type=submit]").click
-end
-
-Then(/^the task comment is created$/) do
-  expect(@task.comments.count).to eq 1
-  expect(page).to have_content "I-am-the-task-comment-description"
-end

data/features/step_definitions/flyboy_tasks_steps.rb

@@ -1,196 +0,0 @@
-Given(/^an existing done task$/) do
-  @done_task = create(:flyboy_task, done: true)
-end
-
-Given(/^an existing undone task$/) do
-  @undone_task = create(:flyboy_task, done: false)
-end
-
-Given(/^an existing task named "(.*?)"$/) do |name|
-  create(:flyboy_task, name: name)
-end
-
-Given(/^an existing task$/) do
-  @task = create(:flyboy_task)
-end
-
-Given(/^an existing snoozable task$/) do
-  @task = create(:flyboy_task, term: Date.current)
-end
-
-Given(/^(\d+) existing tasks$/) do |n|
-  n.to_i.times do
-    create(:flyboy_task)
-  end
-end
-
-Given(/^a task with an owner that's the term is today$/) do
-  @task = create(:flyboy_task,
-    :term          => Date.current,
-    :reminder_type => "custom",
-    :reminder_date => Date.yesterday,
-    :owner         => create(:user),
-  )
-end
-
-Given(/^a task without owner$/) do
-  @task = create(:flyboy_task,
-    :term          => Date.current,
-    :reminder_type => "custom",
-    :reminder_date => Date.yesterday,
-    :owner         => nil,
-  )
-end
-
-Given(/^a closed task with an owner$/) do
-  @task = create(:flyboy_task,
-    :term          => Date.current,
-    :reminder_type => "custom",
-    :reminder_date => Date.yesterday,
-    :owner         => create(:user),
-    :progress      => 100,
-    :done          => true,
-  )
-end
-
-When(/^the flyboy daily crons run$/) do
-  ActionMailer::Base.deliveries.clear
-  Dorsale::Flyboy::TaskCrons.send_daily_term_emails!
-end
-
-When(/^I create a task$/) do
-  find("a[href*='tasks/new']").click
-  find("form[id*=task] [type=submit]").click # First submit to see errors
-  fill_in "task_name", with: "I-am-the-task-title"
-  fill_in "task_description", with: "I-am-the-task-description"
-  select @user.name
-  find("form[id*=task] [type=submit]").click
-end
-
-When(/^I go to the tasks section$/) do
-  visit dorsale.flyboy_tasks_path
-end
-
-When(/^I consult this task$/) do
-  click_link @task.name
-end
-
-When(/^I update this task$/) do
-  visit dorsale.flyboy_task_path(@task)
-  find("a[href$='tasks/#{@task.id}/edit']").click
-  fill_in "task_name", with: "New-task-title"
-  find("form[id*=task] [type=submit]").click
-end
-
-When(/^I complete this task$/) do
-  find("a[href$=complete]").click
-end
-
-When(/^I snooze this task$/) do
-  find("a[href*=snooze]").click
-end
-
-When(/^I filter tasks by done$/) do
-  select "Terminée"
-  find(".filters [type=submit]:last-child").click
-end
-
-When(/^I filter tasks by undone$/) do
-  select "Non terminé"
-  find(".filters [type=submit]:last-child").click
-end
-
-When(/^(?:I|he|she) reset filters$/) do
-  find(".filters .reset").click
-end
-
-When(/^I delete this task$/) do
-  visit dorsale.flyboy_task_path(@task)
-  find("a[href$='tasks/#{@task.id}/edit']").click
-  find(".context a[data-method=delete]").click
-end
-
-Then(/^I am on the created task$/) do
-  @task = Dorsale::Flyboy::Task.last_created
-  expect(current_path).to eq dorsale.flyboy_task_path(@task)
-end
-
-Then(/^the task is created$/) do
-  expect(page).to have_content "I-am-the-task-title"
-end
-
-Then(/^I see this task$/) do
-  expect(current_path).to eq dorsale.flyboy_task_path(@task)
-end
-
-Then(/^I am on the updated task$/) do
-  expect(current_path).to eq dorsale.flyboy_task_path(@task)
-end
-
-Then(/^the task is updated$/) do
-  expect(page).to have_content "New-task-title"
-end
-
-Then(/^I am on the tasks section$/) do
-  expect(current_path).to eq dorsale.flyboy_tasks_path
-end
-
-Then(/^the task is deleted$/) do
-  expect(page).to have_no_content @task.name
-end
-
-Then(/^the task is completed$/) do
-  expect(page).to have_content "100%"
-end
-
-Then(/^the task is snoozed$/) do
-  expect(page).to have_no_selector "a[href*=snooze]"
-end
-
-Then(/^I am on this task$/) do
-  expect(current_path).to eq dorsale.flyboy_task_path(@task)
-end
-
-Then(/^only done tasks appear$/) do
-  expect(page).to have_content @done_task.name
-  expect(page).to have_no_content @undone_task.name
-end
-
-Then(/^only undone tasks appear$/) do
-  expect(page).to have_no_content @done_task.name
-  expect(page).to have_content @undone_task.name
-end
-
-Then(/^all tasks appear$/) do
-  expect(page).to have_content @done_task.name
-  expect(page).to have_content @undone_task.name
-end
-
-Then(/^only the "Hello" task appear$/) do
-  expect(page).to have_content "Hello"
-  expect(page).to have_no_content "World"
-end
-
-Then(/^tasks are paginated$/) do
-  expect(all("tr.task").count).to eq 50
-  expect(page).to have_selector ".pagination"
-end
-
-Then(/^no email is sent$/) do
-  expect(ActionMailer::Base.deliveries.count).to eq 0
-end
-
-Then(/^the owner receive an email$/) do
-  expect(ActionMailer::Base.deliveries.count).to eq 1
-  email = ActionMailer::Base.deliveries.last
-  expect(email.to).to include @task.owner.email
-end
-
-When(/^I go on the new task page$/) do
-  visit dorsale.new_flyboy_task_path
-end
-
-Then(/^selected task term is "([^"]*)"$/) do |expected_value|
-  value = find("#task_term option[selected]").text
-  expect(value).to eq expected_value
-end

data/features/step_definitions/tasks_summary_steps.rb

@@ -1,30 +0,0 @@
-Given(/^an expired tasks$/) do
-  @task = create(:flyboy_task, owner: @user, term: Date.current-1)
-end
-
-Given(/^a task that expire tommorow$/) do
-  @task = create(:flyboy_task, owner: @user, term: Date.current+1)
-end
-
-Given(/^a task that expire today$/) do
-  @task = create(:flyboy_task, owner: @user, term: Date.current)
-end
-
-When(/^he go to the tasks summary page$/) do
-  visit dorsale.summary_flyboy_tasks_path
-end
-
-Then(/^the task is classed as 'expired'$/) do
-  expect(page).to have_content("En retard")
-  expect(page).to have_content(@task.name)
-end
-
-Then(/^the task is classed as 'Expire Today'$/) do
-  expect(page).to have_content("Aujourd'hui")
-  expect(page).to have_content(@task.name)
-end
-
-Then(/^the task is classed as 'Expire tommorow'$/) do
-  expect(page).to have_content("Demain")
-  expect(page).to have_content(@task.name)
-end

data/features/step_definitions/users_management_step.rb

@@ -1,29 +0,0 @@
-When(/^he goes to the users section$/) do
-  visit dorsale.users_path
-end
-
-When(/^he creates a new user$/) do
-  find("[href$='users/new']").click
-  fill_in "user_email", with: "toto@toto.fr"
-  find("[type=submit]").click
-end
-
-Then(/^the user is visible in the user list$/) do
-  expect(page).to have_content I18n.t("messages.users.create_ok")
-  expect(page).to have_content "toto@toto.fr"
-end
-
-When(/^he click on update user button$/) do
-  expect(page).to have_content @user.email
-  find("#main [href$=edit]").click
-end
-
-When(/^he update the user$/) do
-  fill_in "user_email", with: "toto@toto.fr"
-  find("[type=submit]").click
-end
-
-Then(/^the user's new informations are visible in the users list$/) do
-  expect(page).to have_content I18n.t("messages.users.update_ok")
-  expect(page).to have_content "toto@toto.fr"
-end

data/features/support/env.rb

@@ -1,8 +0,0 @@
-ENV["RAILS_ROOT"] ||= File.expand_path("../../spec/dummy", __dir__)
-require "cucumber/rails"
-require "agilibox/cucumber_config"
-def Zonebie.set_random_timezone
-  # https://github.com/agilidee/dorsale/issues/273
-end
-Agilibox::CucumberConfig.require_all_helpers!
-Agilibox::CucumberConfig.require_cuprite!

data/features/users_management.feature

@@ -1,18 +0,0 @@
-@javascript
-Feature: Manage users
-  As an user
-  I can manage users
-  In order to provide them an access
-
-  Background:
-    Given an authenticated user
-    When he goes to the users section
-
-  Scenario: Create a User
-    And he creates a new user
-    Then the user is visible in the user list
-
-  Scenario: Update a User
-    And he click on update user button
-    And he update the user
-    Then the user's new informations are visible in the users list

data/spec/controllers/dorsale/alexandrie/attachments_controller_spec.rb

@@ -1,145 +0,0 @@
-require "rails_helper"
-
-describe Dorsale::Alexandrie::AttachmentsController, type: :controller do
-  routes { Dorsale::Engine.routes }
-
-  let(:uploaded_file) {
-    path = Rails.root.join("..", "..", "spec", "files", "pdf.pdf").to_s
-    Rack::Test::UploadedFile.new(path, "application/pdf")
-  }
-
-  let(:valid_attributes) {
-    attachable = DummyModel.create!(name: "A")
-
-    {
-      :attachable_id   => attachable.id,
-      :attachable_type => attachable.class.to_s,
-      :file            => uploaded_file,
-    }
-  }
-
-  let(:user) { create(:user) }
-
-  before(:each) { sign_in(user) }
-
-  let(:attachment) { create(:alexandrie_attachment) }
-
-  describe "sorting" do
-    let!(:attachable) { create(:billing_machine_quotation) }
-
-    let!(:attachment1) {
-      create(:alexandrie_attachment,
-        :attachable      => attachable,
-        :name            => "AAA",
-        :created_at      => "2010-01-01",
-        :updated_at      => "2010-01-01",
-        :attachment_type => create(:alexandrie_attachment_type, name: "AAA"),
-      )
-    }
-
-    let!(:attachment2) {
-      create(:alexandrie_attachment,
-        :attachable      => attachable,
-        :name            => "ZZZ",
-        :created_at      => "2020-01-01",
-        :updated_at      => "2020-01-01",
-        :attachment_type => create(:alexandrie_attachment_type, name: "ZZZ"),
-      )
-    }
-
-    before do
-      allow_any_instance_of(described_class).to \
-        receive(:find_attachable_from_params).and_return(attachable)
-    end
-
-    it "should sort by name" do
-      get :index, params: {sort: "name"}
-      expect(assigns :attachments).to eq [attachment1, attachment2]
-    end
-
-    it "should sort by -name" do
-      get :index, params: {sort: "-name"}
-      expect(assigns :attachments).to eq [attachment2, attachment1]
-    end
-
-    it "should sort by created_at" do
-      get :index, params: {sort: "created_at"}
-      expect(assigns :attachments).to eq [attachment1, attachment2]
-    end
-
-    it "should sort by -created_at" do
-      get :index, params: {sort: "-created_at"}
-      expect(assigns :attachments).to eq [attachment2, attachment1]
-    end
-
-    it "should sort by updated_at" do
-      get :index, params: {sort: "updated_at"}
-      expect(assigns :attachments).to eq [attachment1, attachment2]
-    end
-
-    it "should sort by -updated_at" do
-      get :index, params: {sort: "-updated_at"}
-      expect(assigns :attachments).to eq [attachment2, attachment1]
-    end
-
-    it "should sort by attachment_type_name" do
-      get :index, params: {sort: "attachment_type_name"}
-      expect(assigns :attachments).to eq [attachment1, attachment2]
-    end
-
-    it "should sort by -attachment_type_name" do
-      get :index, params: {sort: "-attachment_type_name"}
-      expect(assigns :attachments).to eq [attachment2, attachment1]
-    end
-  end # describe "sorting"
-
-  describe "create" do
-    it "should create attachment" do
-      post :create, params: {attachment: valid_attributes}
-      expect(assigns(:attachment)).to be_persisted
-    end
-
-    it "should render list" do
-      post :create, params: {attachment: valid_attributes}
-      expect(response).to be_ok
-      expect(response).to render_template :index
-    end
-  end
-
-  describe "edit" do
-    it "should render list" do
-      get :edit, params: {id: attachment}
-      expect(response).to be_ok
-      expect(response).to render_template :index
-    end
-  end
-
-  describe "update" do
-    it "should update attachment" do
-      patch :update, params: {id: attachment, attachment: {name: "new_name"}}
-      expect(attachment.reload.name).to eq "new_name"
-    end
-
-    it "should render list" do
-      patch :update, params: {id: attachment}
-      expect(response).to be_ok
-      expect(response).to render_template :index
-    end
-  end
-
-  describe "destroy" do
-    let!(:attachment) { create(:alexandrie_attachment) }
-
-    it "should delete attachment" do
-      expect {
-        delete :destroy, params: {id: attachment}
-      }.to change(::Dorsale::Alexandrie::Attachment, :count).by(-1)
-    end
-
-    it "should render list" do
-      delete :destroy, params: {id: attachment}
-      expect(response).to be_ok
-      expect(response).to render_template :index
-    end
-  end
-end

data/spec/controllers/dorsale/billing_machine/invoices_controller_spec.rb

@@ -1,153 +0,0 @@
-require "rails_helper"
-
-describe Dorsale::BillingMachine::InvoicesController, type: :controller do
-  routes { Dorsale::Engine.routes }
-
-  let(:user) { create(:user) }
-  before(:each) { sign_in(user) }
-
-  describe "#preview" do
-    render_views
-
-    it "should render show" do
-      post :preview
-      expect(response).to render_template(:show)
-    end
-
-    it "should not save" do
-      post :preview
-      @invoice = assigns(:invoice)
-      expect(@invoice).to be_valid
-      expect(@invoice).to_not be_persisted
-    end
-  end # describe "#preview" do
-
-  describe "XLSX export" do
-    render_views
-
-    it "should be ok" do
-      3.times { create(:billing_machine_invoice_line) }
-      get :index, params: {format: :xlsx}
-      expect(response).to be_ok
-    end
-  end # describe "XLSX export"
-
-  describe "PDF export" do
-    render_views
-
-    it "should be ok" do
-      3.times {
-        invoice = create(:billing_machine_invoice)
-        Dorsale::BillingMachine::PdfFileGenerator.(invoice)
-      }
-      get :index, params: {format: :pdf}
-      expect(response).to be_ok
-    end
-  end # describe "PDF export"
-
-  describe "filters" do
-    describe "filter by date" do
-      before do
-        Timecop.freeze "2016-11-08 12:00:00"
-        @today      = create(:billing_machine_invoice, date: "2016-11-08")
-        @yesterday  = create(:billing_machine_invoice, date: "2016-11-07")
-        @tomorrow   = create(:billing_machine_invoice, date: "2016-11-09")
-        @last_week  = create(:billing_machine_invoice, date: "2016-11-04")
-        @last_month = create(:billing_machine_invoice, date: "2016-10-18")
-        @last_year  = create(:billing_machine_invoice, date: "2015-10-18")
-      end
-
-      def filter(period)
-        cookies[:filters] = {"bm_time_period" => period.to_s}.to_json
-        get :index
-      end
-
-      it "should filter by all_time" do
-        filter :all_time
-        expect(assigns :invoices).to contain_exactly(
-          @today,
-          @yesterday,
-          @tomorrow,
-          @last_week,
-          @last_month,
-          @last_year,
-        )
-      end
-
-      it "should filter by today" do
-        filter :today
-        expect(assigns :invoices).to contain_exactly(@today)
-      end
-
-      it "should filter by yesterday" do
-        filter :yesterday
-        expect(assigns :invoices).to contain_exactly(@yesterday)
-      end
-
-      it "should filter by this_week" do
-        filter :this_week
-        expect(assigns :invoices).to contain_exactly(@today, @yesterday, @tomorrow)
-      end
-
-      it "should filter by this_month" do
-        filter :this_month
-        expect(assigns :invoices).to contain_exactly(@today, @yesterday, @tomorrow, @last_week)
-      end
-
-      it "should filter by this_year" do
-        filter :this_year
-        expect(assigns :invoices).to \
-          contain_exactly(@today, @yesterday, @tomorrow, @last_week, @last_month)
-      end
-
-      it "should filter by last_week" do
-        filter :last_week
-        expect(assigns :invoices).to contain_exactly(@last_week)
-      end
-
-      it "should filter by last_month" do
-        filter :last_month
-        expect(assigns :invoices).to contain_exactly(@last_month)
-      end
-
-      it "should filter by last_year" do
-        filter :last_year
-        expect(assigns :invoices).to contain_exactly(@last_year)
-      end
-    end # describe "filter by date"
-
-    describe "filter by payment status" do
-      before do
-        Timecop.freeze "2016-11-08 12:00:00"
-        @paid       = create(:billing_machine_invoice, paid: true,  due_date: "2016-01-08")
-        @pending    = create(:billing_machine_invoice, paid: false, due_date: "2016-11-10")
-        @late       = create(:billing_machine_invoice, paid: false, due_date: "2016-06-05")
-      end
-
-      def filter(value)
-        cookies[:filters] = {"bm_payment_status" => value.to_s}.to_json
-        get :index
-      end
-
-      it "should filter by paid" do
-        filter :paid
-        expect(assigns :invoices).to contain_exactly(@paid)
-      end
-
-      it "should filter by unpaid" do
-        filter :unpaid
-        expect(assigns :invoices).to contain_exactly(@pending, @late)
-      end
-
-      it "should filter by pending" do
-        filter :pending
-        expect(assigns :invoices).to contain_exactly(@pending)
-      end
-
-      it "should filter by late" do
-        filter :late
-        expect(assigns :invoices).to contain_exactly(@late)
-      end
-    end # describe "filter by payment status"
-  end # describe "filters"
-end