Foodsoft/foodsoft
1
1
Fork 0
Code Issues 36 Pull requests 5 Projects 1 Releases Wiki Activity

chore: rubocop

Browse source 
chore: fix api test conventions

chore: rubocop -A spec/

chore: more rubocop -A

fix failing test

rubocop fixes

removes helper methods that are in my opinion dead code

more rubocop fixes

rubocop -a --auto-gen-config
This commit is contained in:
Philipp Rothmann 2023-05-12 13:01:12 +02:00 • committed by Philipp Rothmann
parent f6fb804bbe
commit fb2b4d8a8a
331 changed files with 4263 additions and 4507 deletions
Download patch file Download diff file Expand all files Collapse all files

40
spec/models/article_spec.rb
View file

@ -1,11 +1,11 @@
require_relative '../spec_helper'
describe Article do
let(:supplier) { create :supplier }
let(:article) { create :article, supplier: supplier }
let(:supplier) { create(:supplier) }
let(:article) { create(:article, supplier: supplier) }
it 'has a unique name' do
article2 = build :article, supplier: supplier, name: article.name
article2 = build(:article, supplier: supplier, name: article.name)
expect(article2).to be_invalid
end
@ -21,21 +21,21 @@ describe Article do
end
it 'returns false when invalid unit' do
article1 = build :article, supplier: supplier, unit: 'invalid'
article1 = build(:article, supplier: supplier, unit: 'invalid')
expect(article.convert_units(article1)).to be false
end
it 'converts from ST to KI (german foodcoops legacy)' do
article1 = build :article, supplier: supplier, unit: 'ST'
article2 = build :article, supplier: supplier, name: 'banana 10-12 St', price: 12.34, unit: 'KI'
article1 = build(:article, supplier: supplier, unit: 'ST')
article2 = build(:article, supplier: supplier, name: 'banana 10-12 St', price: 12.34, unit: 'KI')
new_price, new_unit_quantity = article1.convert_units(article2)
expect(new_unit_quantity).to eq 10
expect(new_price).to eq 1.23
end
it 'converts from g to kg' do
article1 = build :article, supplier: supplier, unit: 'kg'
article2 = build :article, supplier: supplier, unit: 'g', price: 0.12, unit_quantity: 1500
article1 = build(:article, supplier: supplier, unit: 'kg')
article2 = build(:article, supplier: supplier, unit: 'g', price: 0.12, unit_quantity: 1500)
new_price, new_unit_quantity = article1.convert_units(article2)
expect(new_unit_quantity).to eq 1.5
expect(new_price).to eq 120
@ -43,7 +43,7 @@ describe Article do
end
it 'computes changed article attributes' do
article2 = build :article, supplier: supplier, name: 'banana'
article2 = build(:article, supplier: supplier, name: 'banana')
expect(article.unequal_attributes(article2)[:name]).to eq 'banana'
end
@ -83,7 +83,7 @@ describe Article do
end
it 'is knows its open order' do
order = create :order, supplier: supplier, article_ids: [article.id]
order = create(:order, supplier: supplier, article_ids: [article.id])
expect(article.in_open_order).to eq(order)
end
@ -91,26 +91,26 @@ describe Article do
expect(article.shared_article).to be_nil
end
describe 'connected to a shared database', :type => :feature do
let(:shared_article) { create :shared_article }
let(:supplier) { create :supplier, shared_supplier_id: shared_article.supplier_id }
let(:article) { create :article, supplier: supplier, order_number: shared_article.order_number }
describe 'connected to a shared database', type: :feature do
let(:shared_article) { create(:shared_article) }
let(:supplier) { create(:supplier, shared_supplier_id: shared_article.supplier_id) }
let(:article) { create(:article, supplier: supplier, order_number: shared_article.order_number) }
it 'can be found in the shared database' do
expect(article.shared_article).to_not be_nil
expect(article.shared_article).not_to be_nil
end
it 'can find updates' do
changed = article.shared_article_changed?
expect(changed).to_not be_falsey
expect(changed).not_to be_falsey
expect(changed.length).to be > 1
end
it 'can be synchronised' do
# TODO move article sync from supplier to article
# TODO: move article sync from supplier to article
article # need to reference for it to exist when syncing
updated_article = supplier.sync_all[0].select { |s| s[0].id == article.id }.first[0]
article.update(updated_article.attributes.reject { |k, v| k == 'id' or k == 'type' })
article.update(updated_article.attributes.reject { |k, _v| %w[id type].include?(k) })
expect(article.name).to eq(shared_article.name)
# now synchronising shouldn't change anything anymore
expect(article.shared_article_changed?).to be_falsey
@ -131,9 +131,9 @@ describe Article do
article.unit = '200g'
article.shared_updated_on -= 1 # to make update do something
article.save!
# TODO get sync functionality in article
# TODO: get sync functionality in article
updated_article = supplier.sync_all[0].select { |s| s[0].id == article.id }.first[0]
article.update!(updated_article.attributes.reject { |k, v| k == 'id' or k == 'type' })
article.update!(updated_article.attributes.reject { |k, _v| %w[id type].include?(k) })
expect(article.unit).to eq '200g'
expect(article.unit_quantity).to eq 5
expect(article.price).to be_within(0.005).of(shared_article.price / 5)

66
spec/models/bank_transaction_spec.rb
View file

@ -1,24 +1,32 @@
require_relative '../spec_helper'
describe BankTransaction do
let(:bank_account) { create :bank_account }
let(:ordergroup) { create :ordergroup }
let(:supplier) { create :supplier, iban: Faker::Bank.iban }
let!(:user) { create :user, groups: [ordergroup] }
let!(:ftt_a) { create :financial_transaction_type, name_short: 'A' }
let!(:ftt_b) { create :financial_transaction_type, name_short: 'B' }
let(:bank_account) { create(:bank_account) }
let(:ordergroup) { create(:ordergroup) }
let(:supplier) { create(:supplier, iban: Faker::Bank.iban) }
let!(:user) { create(:user, groups: [ordergroup]) }
let!(:ftt_a) { create(:financial_transaction_type, name_short: 'A') }
let!(:ftt_b) { create(:financial_transaction_type, name_short: 'B') }
describe 'supplier' do
let!(:invoice1) { create :invoice, supplier: supplier, number: '11', amount: 10 }
let!(:invoice2) { create :invoice, supplier: supplier, number: '22', amount: 20 }
let!(:invoice3) { create :invoice, supplier: supplier, number: '33', amount: 30 }
let!(:invoice4) { create :invoice, supplier: supplier, number: '44', amount: 40 }
let!(:invoice5) { create :invoice, supplier: supplier, number: '55', amount: 50 }
let!(:invoice1) { create(:invoice, supplier: supplier, number: '11', amount: 10) }
let!(:invoice2) { create(:invoice, supplier: supplier, number: '22', amount: 20) }
let!(:invoice3) { create(:invoice, supplier: supplier, number: '33', amount: 30) }
let!(:invoice4) { create(:invoice, supplier: supplier, number: '44', amount: 40) }
let!(:invoice5) { create(:invoice, supplier: supplier, number: '55', amount: 50) }
let!(:bank_transaction1) { create :bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '11', amount: 10 }
let!(:bank_transaction2) { create :bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '22', amount: -20 }
let!(:bank_transaction3) { create :bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '33,44', amount: -70 }
let!(:bank_transaction4) { create :bank_transaction, bank_account: bank_account, iban: supplier.iban, text: '55', amount: -50 }
let!(:bank_transaction1) do
create(:bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '11', amount: 10)
end
let!(:bank_transaction2) do
create(:bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '22', amount: -20)
end
let!(:bank_transaction3) do
create(:bank_transaction, bank_account: bank_account, iban: supplier.iban, reference: '33,44', amount: -70)
end
let!(:bank_transaction4) do
create(:bank_transaction, bank_account: bank_account, iban: supplier.iban, text: '55', amount: -50)
end
it 'ignores invoices with invalid amount' do
expect(bank_transaction1.assign_to_invoice).to be false
@ -49,14 +57,26 @@ describe BankTransaction do
end
describe 'ordergroup' do
let!(:bank_transaction1) { create :bank_transaction, bank_account: bank_account, reference: "invalid", amount: 10 }
let!(:bank_transaction2) { create :bank_transaction, bank_account: bank_account, reference: "FS99A10", amount: 10 }
let!(:bank_transaction3) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}.99A10", amount: 10 }
let!(:bank_transaction4) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10", amount: 99 }
let!(:bank_transaction5) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10", amount: 10 }
let!(:bank_transaction6) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10B20", amount: 30 }
let!(:bank_transaction7) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}.#{user.id}A10", amount: 10 }
let!(:bank_transaction8) { create :bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}X10", amount: 10 }
let!(:bank_transaction1) { create(:bank_transaction, bank_account: bank_account, reference: 'invalid', amount: 10) }
let!(:bank_transaction2) { create(:bank_transaction, bank_account: bank_account, reference: 'FS99A10', amount: 10) }
let!(:bank_transaction3) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}.99A10", amount: 10)
end
let!(:bank_transaction4) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10", amount: 99)
end
let!(:bank_transaction5) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10", amount: 10)
end
let!(:bank_transaction6) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}A10B20", amount: 30)
end
let!(:bank_transaction7) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}.#{user.id}A10", amount: 10)
end
let!(:bank_transaction8) do
create(:bank_transaction, bank_account: bank_account, reference: "FS#{ordergroup.id}X10", amount: 10)
end
it 'ignores transaction with invalid reference' do
expect(bank_transaction1.assign_to_ordergroup).to be_nil

4
spec/models/delivery_spec.rb
View file

@ -1,8 +1,8 @@
require_relative '../spec_helper'
describe Delivery do
let(:delivery) { create :delivery }
let(:stock_article) { create :stock_article, price: 3 }
let(:delivery) { create(:delivery) }
let(:stock_article) { create(:stock_article, price: 3) }
it 'creates new stock_changes' do
delivery.new_stock_changes = ([

23
spec/models/group_order_article_spec.rb
View file

@ -1,10 +1,10 @@
require_relative '../spec_helper'
describe GroupOrderArticle do
let(:user) { create :user, groups: [create(:ordergroup)] }
let(:user) { create(:user, groups: [create(:ordergroup)]) }
let(:order) { create(:order) }
let(:go) { create :group_order, order: order, ordergroup: user.ordergroup }
let(:goa) { create :group_order_article, group_order: go, order_article: order.order_articles.first }
let(:go) { create(:group_order, order: order, ordergroup: user.ordergroup) }
let(:goa) { create(:group_order_article, group_order: go, order_article: order.order_articles.first) }
it 'has zero quantity by default' do expect(goa.quantity).to eq(0) end
it 'has zero tolerance by default' do expect(goa.tolerance).to eq(0) end
@ -12,9 +12,9 @@ describe GroupOrderArticle do
it 'has zero total price by default' do expect(goa.total_price).to eq(0) end
describe do
let(:article) { create :article, supplier: order.supplier, unit_quantity: 1 }
let(:oa) { order.order_articles.create(:article => article) }
let(:goa) { create :group_order_article, group_order: go, order_article: oa }
let(:article) { create(:article, supplier: order.supplier, unit_quantity: 1) }
let(:oa) { order.order_articles.create(article: article) }
let(:goa) { create(:group_order_article, group_order: go, order_article: oa) }
it 'can be ordered by piece' do
goa.update_quantities(1, 0)
@ -23,7 +23,8 @@ describe GroupOrderArticle do
end
it 'can be ordered in larger amounts' do
quantity, tolerance = rand(13..99), rand(0..99)
quantity = rand(13..99)
tolerance = rand(0..99)
goa.update_quantities(quantity, tolerance)
expect(goa.quantity).to eq(quantity)
expect(goa.tolerance).to eq(tolerance)
@ -52,10 +53,10 @@ describe GroupOrderArticle do
end
describe 'distribution strategy' do
let(:article) { create :article, supplier: order.supplier, unit_quantity: 1 }
let(:oa) { order.order_articles.create(:article => article) }
let(:goa) { create :group_order_article, group_order: go, order_article: oa }
let!(:goaq) { create :group_order_article_quantity, group_order_article: goa, quantity: 4, tolerance: 6 }
let(:article) { create(:article, supplier: order.supplier, unit_quantity: 1) }
let(:oa) { order.order_articles.create(article: article) }
let(:goa) { create(:group_order_article, group_order: go, order_article: oa) }
let!(:goaq) { create(:group_order_article_quantity, group_order_article: goa, quantity: 4, tolerance: 6) }
it 'can calculate the result for the distribution strategy "first order first serve"' do
res = goa.calculate_result(2)

6
spec/models/group_order_spec.rb
View file

@ -1,8 +1,8 @@
require_relative '../spec_helper'
describe GroupOrder do
let(:user) { create :user, groups: [create(:ordergroup)] }
let(:order) { create :order }
let(:user) { create(:user, groups: [create(:ordergroup)]) }
let(:order) { create(:order) }
# the following two tests are currently disabled - https://github.com/foodcoops/foodsoft/issues/158
@ -15,7 +15,7 @@ describe GroupOrder do
# end
describe do
let(:go) { create :group_order, order: order, ordergroup: user.ordergroup }
let(:go) { create(:group_order, order: order, ordergroup: user.ordergroup) }
it 'has zero price initially' do
expect(go.price).to eq(0)

65
spec/models/order_article_spec.rb
View file

@ -1,14 +1,14 @@
require 'spec_helper'
describe OrderArticle do
let(:order) { create :order, article_count: 1 }
let(:order) { create(:order, article_count: 1) }
let(:oa) { order.order_articles.first }
it 'is not ordered by default' do
expect(OrderArticle.ordered.count).to eq 0
end
[:units_to_order, :units_billed, :units_received].each do |units|
%i[units_to_order units_billed units_received].each do |units|
it "is ordered when there are #{units.to_s.gsub '_', ' '}" do
oa.update_attribute units, rand(1..99)
expect(OrderArticle.ordered.count).to eq 1
@ -46,15 +46,15 @@ describe OrderArticle do
end
describe 'redistribution' do
let(:admin) { create :user, groups: [create(:workgroup, role_finance: true)] }
let(:article) { create :article, unit_quantity: 3 }
let(:order) { create :order, article_ids: [article.id] }
let(:go1) { create :group_order, order: order }
let(:go2) { create :group_order, order: order }
let(:go3) { create :group_order, order: order }
let(:goa1) { create :group_order_article, group_order: go1, order_article: oa }
let(:goa2) { create :group_order_article, group_order: go2, order_article: oa }
let(:goa3) { create :group_order_article, group_order: go3, order_article: oa }
let(:admin) { create(:user, groups: [create(:workgroup, role_finance: true)]) }
let(:article) { create(:article, unit_quantity: 3) }
let(:order) { create(:order, article_ids: [article.id]) }
let(:go1) { create(:group_order, order: order) }
let(:go2) { create(:group_order, order: order) }
let(:go3) { create(:group_order, order: order) }
let(:goa1) { create(:group_order_article, group_order: go1, order_article: oa) }
let(:goa2) { create(:group_order_article, group_order: go2, order_article: oa) }
let(:goa3) { create(:group_order_article, group_order: go3, order_article: oa) }
# set quantities of group_order_articles
def set_quantities(q1, q2, q3)
@ -79,21 +79,21 @@ describe OrderArticle do
it 'does nothing when nothing has changed' do
set_quantities [3, 2], [1, 3], [1, 0]
expect(oa.redistribute 6, [:tolerance, nil]).to eq [1, 0]
expect(oa.redistribute(6, [:tolerance, nil])).to eq [1, 0]
goa_reload
expect([goa1, goa2, goa3].map(&:result).map(&:to_i)).to eq [4, 1, 1]
end
it 'works when there is nothing to distribute' do
set_quantities [3, 2], [1, 3], [1, 0]
expect(oa.redistribute 0, [:tolerance, nil]).to eq [0, 0]
expect(oa.redistribute(0, [:tolerance, nil])).to eq [0, 0]
goa_reload
expect([goa1, goa2, goa3].map(&:result)).to eq [0, 0, 0]
end
it 'works when quantity needs to be reduced' do
set_quantities [3, 2], [1, 3], [1, 0]
expect(oa.redistribute 4, [:tolerance, nil]).to eq [0, 0]
expect(oa.redistribute(4, [:tolerance, nil])).to eq [0, 0]
goa_reload
expect([goa1, goa2, goa3].map(&:result)).to eq [3, 1, 0]
end
@ -101,28 +101,28 @@ describe OrderArticle do
it 'works when quantity is increased within quantity' do
set_quantities [3, 0], [2, 0], [2, 0]
expect([goa1, goa2, goa3].map(&:result)).to eq [3, 2, 1]
expect(oa.redistribute 7, [:tolerance, nil]).to eq [0, 0]
expect(oa.redistribute(7, [:tolerance, nil])).to eq [0, 0]
goa_reload
expect([goa1, goa2, goa3].map(&:result).map(&:to_i)).to eq [3, 2, 2]
end
it 'works when there is just one for the first' do
set_quantities [3, 2], [1, 3], [1, 0]
expect(oa.redistribute 1, [:tolerance, nil]).to eq [0, 0]
expect(oa.redistribute(1, [:tolerance, nil])).to eq [0, 0]
goa_reload
expect([goa1, goa2, goa3].map(&:result)).to eq [1, 0, 0]
end
it 'works when there is tolerance and left-over' do
set_quantities [3, 2], [1, 1], [1, 0]
expect(oa.redistribute 10, [:tolerance, nil]).to eq [3, 2]
expect(oa.redistribute(10, [:tolerance, nil])).to eq [3, 2]
goa_reload
expect([goa1, goa2, goa3].map(&:result)).to eq [5, 2, 1]
end
it 'works when redistributing without tolerance' do
set_quantities [3, 2], [1, 3], [1, 0]
expect(oa.redistribute 8, [nil]).to eq [3]
expect(oa.redistribute(8, [nil])).to eq [3]
goa_reload
expect([goa1, goa2, goa3].map(&:result)).to eq [3, 1, 1]
end
@ -131,17 +131,18 @@ describe OrderArticle do
describe 'boxfill' do
before { FoodsoftConfig[:use_boxfill] = true }
let(:article) { create :article, unit_quantity: 6 }
let(:order) { create :order, article_ids: [article.id], starts: 1.week.ago }
let(:article) { create(:article, unit_quantity: 6) }
let(:order) { create(:order, article_ids: [article.id], starts: 1.week.ago) }
let(:oa) { order.order_articles.first }
let(:go) { create :group_order, order: order }
let(:goa) { create :group_order_article, group_order: go, order_article: oa }
let(:go) { create(:group_order, order: order) }
let(:goa) { create(:group_order_article, group_order: go, order_article: oa) }
shared_examples "boxfill" do |success, q|
shared_examples 'boxfill' do |success, q|
# initial situation
before do
goa.update_quantities(*q.keys[0])
oa.update_results!; oa.reload
oa.update_results!
oa.reload
end
# check starting condition
@ -172,11 +173,11 @@ describe OrderArticle do
let(:boxfill_from) { 1.hour.from_now }
context 'decreasing the missing units' do
include_examples "boxfill", true, [6, 0] => [5, 0], [6, 0, 0] => [5, 0, 1]
include_examples 'boxfill', true, [6, 0] => [5, 0], [6, 0, 0] => [5, 0, 1]
end
context 'decreasing the tolerance' do
include_examples "boxfill", true, [1, 2] => [1, 1], [1, 2, 3] => [1, 1, 4]
include_examples 'boxfill', true, [1, 2] => [1, 1], [1, 2, 3] => [1, 1, 4]
end
end
@ -184,27 +185,27 @@ describe OrderArticle do
let(:boxfill_from) { 1.second.ago }
context 'changing nothing in particular' do
include_examples "boxfill", true, [4, 1] => [4, 1], [4, 1, 1] => [4, 1, 1]
include_examples 'boxfill', true, [4, 1] => [4, 1], [4, 1, 1] => [4, 1, 1]
end
context 'increasing missing units' do
include_examples "boxfill", false, [3, 0] => [2, 0], [3, 0, 3] => [3, 0, 3]
include_examples 'boxfill', false, [3, 0] => [2, 0], [3, 0, 3] => [3, 0, 3]
end
context 'increasing tolerance' do
include_examples "boxfill", true, [2, 1] => [2, 2], [2, 1, 3] => [2, 2, 2]
include_examples 'boxfill', true, [2, 1] => [2, 2], [2, 1, 3] => [2, 2, 2]
end
context 'decreasing quantity to fix missing units' do
include_examples "boxfill", true, [7, 0] => [6, 0], [7, 0, 5] => [6, 0, 0]
include_examples 'boxfill', true, [7, 0] => [6, 0], [7, 0, 5] => [6, 0, 0]
end
context 'decreasing quantity keeping missing units equal' do
include_examples "boxfill", false, [7, 0] => [1, 0], [7, 0, 5] => [7, 0, 5]
include_examples 'boxfill', false, [7, 0] => [1, 0], [7, 0, 5] => [7, 0, 5]
end
context 'moving tolerance to quantity' do
include_examples "boxfill", true, [4, 2] => [6, 0], [4, 2, 0] => [6, 0, 0]
include_examples 'boxfill', true, [4, 2] => [6, 0], [4, 2, 0] => [6, 0, 0]
end
# @todo enable test when tolerance doesn't count in missing_units
# context 'decreasing tolerance' do

59
spec/models/order_spec.rb
View file

@ -1,14 +1,14 @@
require_relative '../spec_helper'
describe Order do
let!(:ftt) { create :financial_transaction_type }
let(:user) { create :user, groups: [create(:ordergroup)] }
let!(:ftt) { create(:financial_transaction_type) }
let(:user) { create(:user, groups: [create(:ordergroup)]) }
it 'automaticly finishes ended' do
create :order, created_by: user, starts: Date.yesterday, ends: 1.hour.from_now
create :order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago
create :order, created_by: user, starts: Date.yesterday, ends: 1.hour.from_now, end_action: :auto_close
order = create :order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago, end_action: :auto_close
create(:order, created_by: user, starts: Date.yesterday, ends: 1.hour.from_now)
create(:order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago)
create(:order, created_by: user, starts: Date.yesterday, ends: 1.hour.from_now, end_action: :auto_close)
order = create(:order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago, end_action: :auto_close)
Order.finish_ended!
order.reload
@ -19,10 +19,10 @@ describe Order do
end
describe 'state scopes and boolean getters' do
let!(:open_order) { create :order, state: 'open' }
let!(:finished_order) { create :order, state: 'finished' }
let!(:received_order) { create :order, state: 'received' }
let!(:closed_order) { create :order, state: 'closed' }
let!(:open_order) { create(:order, state: 'open') }
let!(:finished_order) { create(:order, state: 'finished') }
let!(:received_order) { create(:order, state: 'received') }
let!(:closed_order) { create(:order, state: 'closed') }
it 'retrieves open orders in the "open" scope' do
expect(Order.open.count).to eq(1)
@ -72,8 +72,9 @@ describe Order do
end
it 'sends mail if min_order_quantity has been reached' do
create :user, groups: [create(:ordergroup)]
create :order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago, end_action: :auto_close_and_send_min_quantity
create(:user, groups: [create(:ordergroup)])
create(:order, created_by: user, starts: Date.yesterday, ends: 1.hour.ago,
end_action: :auto_close_and_send_min_quantity)
Order.finish_ended!
expect(ActionMailer::Base.deliveries.count).to eq 1
@ -84,7 +85,7 @@ describe Order do
end
it 'needs order articles' do
supplier = create :supplier, article_count: 0
supplier = create(:supplier, article_count: 0)
expect(build(:order, supplier: supplier)).to be_invalid
end
@ -93,35 +94,35 @@ describe Order do
end
describe 'with articles' do
let(:order) { create :order }
let(:order) { create(:order) }
it 'is open by default' do expect(order).to be_open end
it 'is not finished by default' do expect(order).to_not be_finished end
it 'is not closed by default' do expect(order).to_not be_closed end
it 'is not finished by default' do expect(order).not_to be_finished end
it 'is not closed by default' do expect(order).not_to be_closed end
it 'has valid order articles' do
order.order_articles.each { |oa| expect(oa).to be_valid }
end
it 'can be finished' do
# TODO randomise user
# TODO: randomise user
order.finish!(user)
expect(order).to_not be_open
expect(order).not_to be_open
expect(order).to be_finished
expect(order).to_not be_closed
expect(order).not_to be_closed
end
it 'can be closed' do
# TODO randomise user
# TODO: randomise user
order.finish!(user)
order.close!(user)
expect(order).to_not be_open
expect(order).not_to be_open
expect(order).to be_closed
end
end
describe 'with a default end date' do
let(:order) { create :order }
let(:order) { create(:order) }
before do
FoodsoftConfig[:order_schedule] = { ends: { recurr: 'FREQ=WEEKLY;BYDAY=MO', time: '9:00' } }
@ -138,10 +139,10 @@ describe Order do
end
describe 'mapped to GroupOrders' do
let!(:user) { create :user, groups: [create(:ordergroup)] }
let!(:order) { create :order }
let!(:order2) { create :order }
let!(:go) { create :group_order, order: order, ordergroup: user.ordergroup }
let!(:user) { create(:user, groups: [create(:ordergroup)]) }
let!(:order) { create(:order) }
let!(:order2) { create(:order) }
let!(:go) { create(:group_order, order: order, ordergroup: user.ordergroup) }
it 'to map a user\'s GroupOrders to a list of Orders' do
orders = Order.ordergroup_group_orders_map(user.ordergroup)
@ -156,10 +157,10 @@ describe Order do
describe 'balancing charges correct amounts' do
let!(:transport) { rand(0.1..26.0).round(2) }
let!(:order) { create :order, article_count: 1 }
let!(:order) { create(:order, article_count: 1) }
let!(:oa) { order.order_articles.first }
let!(:go) { create :group_order, order: order, transport: transport }
let!(:goa) { create :group_order_article, group_order: go, order_article: oa, quantity: 1 }
let!(:go) { create(:group_order, order: order, transport: transport) }
let!(:goa) { create(:group_order_article, group_order: go, order_article: oa, quantity: 1) }
before do
goa.update_quantities(1, 0)

76
spec/models/ordergroup_spec.rb
View file

@ -1,22 +1,22 @@
require_relative '../spec_helper'
describe Ordergroup do
let(:ftc1) { create :financial_transaction_class }
let(:ftc2) { create :financial_transaction_class }
let(:ftt1) { create :financial_transaction_type, financial_transaction_class: ftc1 }
let(:ftt2) { create :financial_transaction_type, financial_transaction_class: ftc2 }
let(:ftt3) { create :financial_transaction_type, financial_transaction_class: ftc2 }
let(:user) { create :user, groups: [create(:ordergroup)] }
let(:ftc1) { create(:financial_transaction_class) }
let(:ftc2) { create(:financial_transaction_class) }
let(:ftt1) { create(:financial_transaction_type, financial_transaction_class: ftc1) }
let(:ftt2) { create(:financial_transaction_type, financial_transaction_class: ftc2) }
let(:ftt3) { create(:financial_transaction_type, financial_transaction_class: ftc2) }
let(:user) { create(:user, groups: [create(:ordergroup)]) }
it 'shows no active ordergroups when all orders are older than 3 months' do
order = create :order, starts: 4.months.ago
order = create(:order, starts: 4.months.ago)
user.ordergroup.group_orders.create!(order: order)
expect(Ordergroup.active).to be_empty
end
it 'shows active ordergroups when there are recent orders' do
order = create :order, starts: 2.days.ago
order = create(:order, starts: 2.days.ago)
user.ordergroup.group_orders.create!(order: order)
expect(Ordergroup.active).not_to be_empty
@ -24,17 +24,17 @@ describe Ordergroup do
describe 'sort correctly' do
it 'by name' do
group_b = create :ordergroup, name: 'bbb'
group_a = create :ordergroup, name: 'aaa'
group_c = create :ordergroup, name: 'ccc'
group_b = create(:ordergroup, name: 'bbb')
group_a = create(:ordergroup, name: 'aaa')
group_c = create(:ordergroup, name: 'ccc')
expect(Ordergroup.sort_by_param('name')).to eq([group_a, group_b, group_c])
end
it 'reverse by name' do
group_b = create :ordergroup, name: 'bbb'
group_a = create :ordergroup, name: 'aaa'
group_c = create :ordergroup, name: 'ccc'
group_b = create(:ordergroup, name: 'bbb')
group_a = create(:ordergroup, name: 'aaa')
group_c = create(:ordergroup, name: 'ccc')
expect(Ordergroup.sort_by_param('name_reverse')).to eq([group_c, group_b, group_a])
end
@ -43,9 +43,9 @@ describe Ordergroup do
users_b = [create(:user)]
users_a = []
users_c = [create(:user), create(:user), create(:user)]
group_b = create :ordergroup, name: 'bbb', user_ids: users_b.map(&:id)
group_a = create :ordergroup, name: 'aaa', user_ids: users_a.map(&:id)
group_c = create :ordergroup, name: 'ccc', user_ids: users_c.map(&:id)
group_b = create(:ordergroup, name: 'bbb', user_ids: users_b.map(&:id))
group_a = create(:ordergroup, name: 'aaa', user_ids: users_a.map(&:id))
group_c = create(:ordergroup, name: 'ccc', user_ids: users_c.map(&:id))
expect(Ordergroup.sort_by_param('members_count')).to eq([group_a, group_b, group_c])
end
@ -54,39 +54,39 @@ describe Ordergroup do
users_b = [create(:user)]
users_a = []
users_c = [create(:user), create(:user), create(:user)]
group_b = create :ordergroup, name: 'bbb', user_ids: users_b.map(&:id)
group_a = create :ordergroup, name: 'aaa', user_ids: users_a.map(&:id)
group_c = create :ordergroup, name: 'ccc', user_ids: users_c.map(&:id)
group_b = create(:ordergroup, name: 'bbb', user_ids: users_b.map(&:id))
group_a = create(:ordergroup, name: 'aaa', user_ids: users_a.map(&:id))
group_c = create(:ordergroup, name: 'ccc', user_ids: users_c.map(&:id))
expect(Ordergroup.sort_by_param('members_count_reverse')).to eq([group_c, group_b, group_a])
end
it 'by last_user_activity' do
user_b = create :user, last_activity: 3.days.ago
user_a = create :user, last_activity: 5.days.ago
user_c = create :user, last_activity: Time.now
group_b = create :ordergroup, name: 'bbb', user_ids: [user_b.id]
group_a = create :ordergroup, name: 'aaa', user_ids: [user_a.id]
group_c = create :ordergroup, name: 'ccc', user_ids: [user_c.id]
user_b = create(:user, last_activity: 3.days.ago)
user_a = create(:user, last_activity: 5.days.ago)
user_c = create(:user, last_activity: Time.now)
group_b = create(:ordergroup, name: 'bbb', user_ids: [user_b.id])
group_a = create(:ordergroup, name: 'aaa', user_ids: [user_a.id])
group_c = create(:ordergroup, name: 'ccc', user_ids: [user_c.id])
expect(Ordergroup.sort_by_param('last_user_activity')).to eq([group_a, group_b, group_c])
end
it 'reverse by last_user_activity' do
user_b = create :user, last_activity: 3.days.ago
user_a = create :user, last_activity: 5.days.ago
user_c = create :user, last_activity: Time.now
group_b = create :ordergroup, name: 'bbb', user_ids: [user_b.id]
group_a = create :ordergroup, name: 'aaa', user_ids: [user_a.id]
group_c = create :ordergroup, name: 'ccc', user_ids: [user_c.id]
user_b = create(:user, last_activity: 3.days.ago)
user_a = create(:user, last_activity: 5.days.ago)
user_c = create(:user, last_activity: Time.now)
group_b = create(:ordergroup, name: 'bbb', user_ids: [user_b.id])
group_a = create(:ordergroup, name: 'aaa', user_ids: [user_a.id])
group_c = create(:ordergroup, name: 'ccc', user_ids: [user_c.id])
expect(Ordergroup.sort_by_param('last_user_activity_reverse')).to eq([group_c, group_b, group_a])
end
it 'by last_order' do
group_b = create :ordergroup, name: 'bbb'
group_a = create :ordergroup, name: 'aaa'
group_c = create :ordergroup, name: 'ccc'
group_b = create(:ordergroup, name: 'bbb')
group_a = create(:ordergroup, name: 'aaa')
group_c = create(:ordergroup, name: 'ccc')
group_b.group_orders.create! order: create(:order, starts: 6.days.ago)
group_a.group_orders.create! order: create(:order, starts: 4.months.ago)
group_c.group_orders.create! order: create(:order, starts: Time.now)
@ -95,9 +95,9 @@ describe Ordergroup do
end
it 'reverse by last_order' do
group_b = create :ordergroup, name: 'bbb'
group_a = create :ordergroup, name: 'aaa'
group_c = create :ordergroup, name: 'ccc'
group_b = create(:ordergroup, name: 'bbb')
group_a = create(:ordergroup, name: 'aaa')
group_c = create(:ordergroup, name: 'ccc')
group_b.group_orders.create! order: create(:order, starts: 6.days.ago)
group_a.group_orders.create! order: create(:order, starts: 4.months.ago)
group_c.group_orders.create! order: create(:order, starts: Time.now)

46
spec/models/supplier_spec.rb
View file

@ -1,17 +1,19 @@
require_relative '../spec_helper'
describe Supplier do
let(:supplier) { create :supplier }
let(:supplier) { create(:supplier) }
context 'syncs from file' do
it 'imports and updates articles' do
article1 = create(:article, supplier: supplier, order_number: 177813, unit: '250 g', price: 0.1)
article2 = create(:article, supplier: supplier, order_number: 12345)
article1 = create(:article, supplier: supplier, order_number: 177_813, unit: '250 g', price: 0.1)
article2 = create(:article, supplier: supplier, order_number: 12_345)
supplier.articles = [article1, article2]
options = { filename: 'foodsoft_file_01.csv' }
options[:outlist_absent] = true
options[:convert_units] = true
updated_article_pairs, outlisted_articles, new_articles = supplier.sync_from_file(Rails.root.join('spec/fixtures/foodsoft_file_01.csv'), options)
updated_article_pairs, outlisted_articles, new_articles = supplier.sync_from_file(
Rails.root.join('spec/fixtures/foodsoft_file_01.csv'), options
)
expect(new_articles.length).to be > 0
expect(updated_article_pairs.first[1][:name]).to eq 'Tomaten'
expect(outlisted_articles.first).to eq article2
@ -19,14 +21,16 @@ describe Supplier do
end
it 'return correct tolerance' do
supplier = create :supplier, articles: create_list(:article, 1, unit_quantity: 1)
supplier = create(:supplier)
supplier.articles = create_list(:article, 1, unit_quantity: 1)
expect(supplier.has_tolerance?).to be false
supplier2 = create :supplier, articles: create_list(:article, 1, unit_quantity: 2)
supplier2 = create(:supplier)
supplier2.articles = create_list(:article, 1, unit_quantity: 2)
expect(supplier2.has_tolerance?).to be true
end
it 'deletes the supplier and its articles' do
supplier = create :supplier, article_count: 3
supplier = create(:supplier, article_count: 3)
supplier.articles.each { |a| allow(a).to receive(:mark_as_deleted) }
supplier.mark_as_deleted
supplier.articles.each { |a| expect(a).to have_received(:mark_as_deleted) }
@ -34,29 +38,29 @@ describe Supplier do
end
it 'has a unique name' do
supplier2 = build :supplier, name: supplier.name
supplier2 = build(:supplier, name: supplier.name)
expect(supplier2).to be_invalid
end
it 'has valid articles' do
supplier = create :supplier, article_count: true
supplier = create(:supplier, article_count: true)
supplier.articles.each { |a| expect(a).to be_valid }
end
context 'connected to a shared supplier' do
let(:shared_sync_method) { nil }
let(:shared_supplier) { create :shared_supplier }
let(:supplier) { create :supplier, shared_supplier: shared_supplier, shared_sync_method: shared_sync_method }
let(:shared_supplier) { create(:shared_supplier) }
let(:supplier) { create(:supplier, shared_supplier: shared_supplier, shared_sync_method: shared_sync_method) }
let!(:synced_shared_article) { create :shared_article, shared_supplier: shared_supplier }
let!(:updated_shared_article) { create :shared_article, shared_supplier: shared_supplier }
let!(:new_shared_article) { create :shared_article, shared_supplier: shared_supplier }
let!(:synced_shared_article) { create(:shared_article, shared_supplier: shared_supplier) }
let!(:updated_shared_article) { create(:shared_article, shared_supplier: shared_supplier) }
let!(:new_shared_article) { create(:shared_article, shared_supplier: shared_supplier) }
let!(:removed_article) { create :article, supplier: supplier, order_number: '10001-ABC' }
let!(:removed_article) { create(:article, supplier: supplier, order_number: '10001-ABC') }
let!(:updated_article) do
updated_shared_article.build_new_article(supplier).tap do |article|
article.article_category = create :article_category
article.origin = "FubarX1"
article.origin = 'FubarX1'
article.shared_updated_on = 1.day.ago
article.save!
end
@ -75,7 +79,7 @@ describe Supplier do
it 'returns the expected articles' do
updated_article_pairs, outlisted_articles, new_articles = supplier.sync_all
expect(updated_article_pairs).to_not be_empty
expect(updated_article_pairs).not_to be_empty
expect(updated_article_pairs[0][0].id).to eq updated_article.id
expect(updated_article_pairs[0][1].keys).to include :origin
@ -91,13 +95,13 @@ describe Supplier do
it 'returns the expected articles' do
updated_article_pairs, outlisted_articles, new_articles = supplier.sync_all
expect(updated_article_pairs).to_not be_empty
expect(updated_article_pairs).not_to be_empty
expect(updated_article_pairs[0][0].id).to eq updated_article.id
expect(updated_article_pairs[0][1].keys).to include :origin
expect(outlisted_articles).to eq [removed_article]
expect(new_articles).to_not be_empty
expect(new_articles).not_to be_empty
expect(new_articles[0].order_number).to eq new_shared_article.number
expect(new_articles[0].availability?).to be true
end
@ -109,13 +113,13 @@ describe Supplier do
it 'returns the expected articles' do
updated_article_pairs, outlisted_articles, new_articles = supplier.sync_all
expect(updated_article_pairs).to_not be_empty
expect(updated_article_pairs).not_to be_empty
expect(updated_article_pairs[0][0].id).to eq updated_article.id
expect(updated_article_pairs[0][1].keys).to include :origin
expect(outlisted_articles).to eq [removed_article]
expect(new_articles).to_not be_empty
expect(new_articles).not_to be_empty
expect(new_articles[0].order_number).to eq new_shared_article.number
expect(new_articles[0].availability?).to be false
end

92
spec/models/user_spec.rb
View file

@ -2,9 +2,9 @@ require_relative '../spec_helper'
describe User do
it 'is correctly created' do
user = create :user,
user = create(:user,
nick: 'johnnydoe', first_name: 'Johnny', last_name: 'DoeBar',
email: 'johnnydoe@foodcoop.test', phone: '+1234567890'
email: 'johnnydoe@foodcoop.test', phone: '+1234567890')
expect(user.nick).to eq('johnnydoe')
expect(user.first_name).to eq('Johnny')
expect(user.last_name).to eq('DoeBar')
@ -14,7 +14,7 @@ describe User do
end
describe 'does not have the role' do
let(:user) { create :user }
let(:user) { create(:user) }
it 'admin' do expect(user.role_admin?).to be_falsey end
it 'finance' do expect(user.role_finance?).to be_falsey end
@ -24,7 +24,7 @@ describe User do
end
describe do
let(:user) { create :user, password: 'blahblahblah' }
let(:user) { create(:user, password: 'blahblahblah') }
it 'can authenticate with correct password' do
expect(User.authenticate(user.nick, 'blahblahblah')).to be_truthy
@ -74,124 +74,124 @@ describe User do
end
describe 'admin' do
let(:user) { create :admin }
let(:user) { create(:admin) }
it 'default admin role' do expect(user.role_admin?).to be_truthy end
end
describe 'sort correctly' do
it 'by nick' do
user_b = create :user, nick: 'bbb'
user_a = create :user, nick: 'aaa'
user_c = create :user, nick: 'ccc'
user_b = create(:user, nick: 'bbb')
user_a = create(:user, nick: 'aaa')
user_c = create(:user, nick: 'ccc')
expect(User.sort_by_param('nick')).to eq([user_a, user_b, user_c])
end
it 'reverse by nick' do
user_b = create :user, nick: 'bbb'
user_a = create :user, nick: 'aaa'
user_c = create :user, nick: 'ccc'
user_b = create(:user, nick: 'bbb')
user_a = create(:user, nick: 'aaa')
user_c = create(:user, nick: 'ccc')
expect(User.sort_by_param('nick_reverse')).to eq([user_c, user_b, user_a])
end
it 'by name' do
user_b = create :user, first_name: 'aaa', last_name: 'bbb'
user_a = create :user, first_name: 'aaa', last_name: 'aaa'
user_c = create :user, first_name: 'ccc', last_name: 'aaa'
user_b = create(:user, first_name: 'aaa', last_name: 'bbb')
user_a = create(:user, first_name: 'aaa', last_name: 'aaa')
user_c = create(:user, first_name: 'ccc', last_name: 'aaa')
expect(User.sort_by_param('name')).to eq([user_a, user_b, user_c])
end
it 'reverse by name' do
user_b = create :user, first_name: 'aaa', last_name: 'bbb'
user_a = create :user, first_name: 'aaa', last_name: 'aaa'
user_c = create :user, first_name: 'ccc', last_name: 'aaa'
user_b = create(:user, first_name: 'aaa', last_name: 'bbb')
user_a = create(:user, first_name: 'aaa', last_name: 'aaa')
user_c = create(:user, first_name: 'ccc', last_name: 'aaa')
expect(User.sort_by_param('name_reverse')).to eq([user_c, user_b, user_a])
end
it 'by email' do
user_b = create :user, email: 'bbb@dummy.com'
user_a = create :user, email: 'aaa@dummy.com'
user_c = create :user, email: 'ccc@dummy.com'
user_b = create(:user, email: 'bbb@dummy.com')
user_a = create(:user, email: 'aaa@dummy.com')
user_c = create(:user, email: 'ccc@dummy.com')
expect(User.sort_by_param('email')).to eq([user_a, user_b, user_c])
end
it 'reverse by email' do
user_b = create :user, email: 'bbb@dummy.com'
user_a = create :user, email: 'aaa@dummy.com'
user_c = create :user, email: 'ccc@dummy.com'
user_b = create(:user, email: 'bbb@dummy.com')
user_a = create(:user, email: 'aaa@dummy.com')
user_c = create(:user, email: 'ccc@dummy.com')
expect(User.sort_by_param('email_reverse')).to eq([user_c, user_b, user_a])
end
it 'by phone' do
user_b = create :user, phone: 'bbb'
user_a = create :user, phone: 'aaa'
user_c = create :user, phone: 'ccc'
user_b = create(:user, phone: 'bbb')
user_a = create(:user, phone: 'aaa')
user_c = create(:user, phone: 'ccc')
expect(User.sort_by_param('phone')).to eq([user_a, user_b, user_c])
end
it 'reverse by phone' do
user_b = create :user, phone: 'bbb'
user_a = create :user, phone: 'aaa'
user_c = create :user, phone: 'ccc'
user_b = create(:user, phone: 'bbb')
user_a = create(:user, phone: 'aaa')
user_c = create(:user, phone: 'ccc')
expect(User.sort_by_param('phone_reverse')).to eq([user_c, user_b, user_a])
end
it 'by last_activity' do
user_b = create :user, last_activity: 3.days.ago
user_a = create :user, last_activity: 5.days.ago
user_c = create :user, last_activity: Time.now
user_b = create(:user, last_activity: 3.days.ago)
user_a = create(:user, last_activity: 5.days.ago)
user_c = create(:user, last_activity: Time.now)
expect(User.sort_by_param('last_activity')).to eq([user_a, user_b, user_c])
end
it 'reverse by last_activity' do
user_b = create :user, last_activity: 3.days.ago
user_a = create :user, last_activity: 5.days.ago
user_c = create :user, last_activity: Time.now
user_b = create(:user, last_activity: 3.days.ago)
user_a = create(:user, last_activity: 5.days.ago)
user_c = create(:user, last_activity: Time.now)
expect(User.sort_by_param('last_activity_reverse')).to eq([user_c, user_b, user_a])
end
it 'by ordergroup' do
user_b = create :user, groups: [create(:workgroup, name: 'a'), create(:ordergroup, name: 'bb')]
user_a = create :user, groups: [create(:workgroup, name: 'b'), create(:ordergroup, name: 'aa')]
user_c = create :user, groups: [create(:workgroup, name: 'c'), create(:ordergroup, name: 'cc')]
user_b = create(:user, groups: [create(:workgroup, name: 'a'), create(:ordergroup, name: 'bb')])
user_a = create(:user, groups: [create(:workgroup, name: 'b'), create(:ordergroup, name: 'aa')])
user_c = create(:user, groups: [create(:workgroup, name: 'c'), create(:ordergroup, name: 'cc')])
expect(User.sort_by_param('ordergroup')).to eq([user_a, user_b, user_c])
end
it 'reverse by ordergroup' do
user_b = create :user, groups: [create(:workgroup, name: 'a'), create(:ordergroup, name: 'bb')]
user_a = create :user, groups: [create(:workgroup, name: 'b'), create(:ordergroup, name: 'aa')]
user_c = create :user, groups: [create(:workgroup, name: 'c'), create(:ordergroup, name: 'cc')]
user_b = create(:user, groups: [create(:workgroup, name: 'a'), create(:ordergroup, name: 'bb')])
user_a = create(:user, groups: [create(:workgroup, name: 'b'), create(:ordergroup, name: 'aa')])
user_c = create(:user, groups: [create(:workgroup, name: 'c'), create(:ordergroup, name: 'cc')])
expect(User.sort_by_param('ordergroup_reverse')).to eq([user_c, user_b, user_a])
end
it 'and users are only listed once' do
create :user
create(:user)
expect(User.sort_by_param('ordergroup').size).to eq(1)
end
it 'and users belonging to a workgroup are only listed once' do
create :admin
create(:admin)
expect(User.sort_by_param('ordergroup').size).to eq(1)
end
it 'and users belonging to 2 ordergroups are only listed once' do
user = create :user
create :ordergroup, user_ids: [user.id]
create :ordergroup, user_ids: [user.id]
user = create(:user)
create(:ordergroup, user_ids: [user.id])
create(:ordergroup, user_ids: [user.id])
expect(User.sort_by_param('ordergroup').size).to eq(1)
end