require 'rails_helper'
require 'licitacao_helper'

RSpec.configure do |c|
	c.include LicitacaoHelper
end

RSpec.describe Licitacao::Lote, type: :model do
	it { is_expected.to belong_to(:ganhador).class_name("Licitacao::PessoaDoProjeto").with_foreign_key(:ganhador_id) }
	it { is_expected.to have_many(:rodadas).dependent(:destroy) }
	it { is_expected.to have_many(:lances).through(:rodadas) }
	it { is_expected.to have_many(:itens_do_lote).dependent(:destroy) }
	it { is_expected.to have_many(:itens_do_projeto_por_pessoa).through(:itens_do_lote) }

	# before(:each) do
	# 	FactoryBot.reload
	# end

	def preenche_lances pessoas_do_projeto
		pessoas_do_projeto.each_with_index do |p, n|
			lote.rodadas.last.lances.find_by(pessoa_do_projeto_id: p.id).update!(valor: 10 + (3-n))
		end
	end

	it 'atribui_numero' do
		projeto = FactoryBot.create :licitacao_projeto, :por_lote

		expect(projeto.lotes.first.numero).to eq 1
	end

	describe '#abrir_lances' do
		context 'quando lances_abertos = true' do
			it 'levanta exceção' do
				lote = FactoryBot.create :licitacao_lote, lances_abertos: true
				expect { lote.abrir_lances }.to raise_error('Lances já estão abertos')
			end
		end
		context 'quando lances_abertos = false' do
			let(:lote) { FactoryBot.create :licitacao_lote, :completo, lances_abertos: false }
			context 'e não há rodadas' do
				it 'cria rodada inicial' do
					expect { lote.abrir_lances }.to change(lote.rodadas, :count).from(0).to(2	)
				end
			end
			context 'e há rodadas' do
				it 'Não muda a quantidade de rodadas' do
					rodada = lote.rodadas.build(numero: 1)
					rodada.save(validate: false)
					expect { lote.abrir_lances }.not_to change(lote.rodadas, :count)
				end
			end

			it 'atualiza lances_abertos para true' do
				expect { lote.abrir_lances }.to change(lote, :lances_abertos).from(false).to(true)
			end
		end
		context 'quando o lote não possui cotações para todos os itens' do
			context 'e a forma de agrupamento é por item' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :por_item, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					lote.update_column(:lances_abertos, false)
					expect { lote.abrir_lances }.to raise_error('Não existem propostas para esse item/lote ou foram anuladas.')
				end
			end
			context 'e a forma de agrupamento é por lote' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :por_lote, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					lote.update_column(:lances_abertos, false)
					expect { lote.abrir_lances }.to raise_error('Não existem propostas para esse item/lote ou foram anuladas.')
				end
			end
			context 'e a forma de agrupamento é global' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :global, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					lote.update_column(:lances_abertos, false)
					expect { lote.abrir_lances }.to raise_error('Não existem propostas para esse item/lote ou foram anuladas.')
				end
			end
		end
	end

	describe '#fechar_lances' do
		context 'quando lances_abertos = true' do
			# it 'salva id do ganhador no lote' do
			# 	lote = FactoryBot.create( :licitacao_lote, :completo, lances_abertos: true )
			# 	projeto = FactoryBot.create( :licitacao_projeto )
			# 	pessoa_do_projeto = FactoryBot.create( :licitacao_pessoa_do_projeto, projeto_id: projeto.id )
			# 	item_do_lote = FactoryBot.create(:licitacao_item_do_lote , lote_id: lote.id , anulado: false )
			# 	itens_do_projeto_por_pessoa = FactoryBot.build(:item_do_projeto_por_pessoa ,item_do_lote_id: item_do_lote.id, pessoa_do_projeto_id: pessoa_do_projeto.id)
			# 	rodada = FactoryBot.create(:licitacao_rodada, lote_id: lote.id)
			# 	lance = FactoryBot.create(:licitacao_lance , rodada_id: rodada.id , pessoa_do_projeto_id: lote.primeiro_colocado.id)
			# 	expect { lote.fechar_lances }.to change(lote, :ganhador).from(nil).to(primeiro_lugar[:pessoa_do_projeto])


			# 	# allow(lote).to receive(:primeiro_colocado).and_return(primeiro_lugar)
			# 	# lote.save
			# 	# primeiro_lugar = {pessoa_do_projeto: lote.pessoas_do_projeto.first, valor: 500}
			# 	# FactoryBot.create(:licitacao_rodada, lote_id: lote.id)
			# 	# lote.save
			# 	# lote.save


			# 	# projeto = FactoryBot.create( :licitacao_projeto )
			# 	# lote = build(projeto_id: projeto.id, numero: 1, lances_abertos: true, criterio_de_julgamento: 1, tipo: 0 )

			# end
		end
		context 'quando lances_abertos = false' do
			it 'levanta exceção' do
				lote = FactoryBot.create :licitacao_lote, lances_abertos: false
				expect { lote.fechar_lances }.to raise_error('Lances já estão fechados')
			end
		end
	end

	describe 'totalizadores' do
		before(:all) do
			DatabaseCleaner.strategy = :transaction
			DatabaseCleaner.start

			@pedido = FactoryBot.create :pedido, :fechado
		end
		after(:all) do
			DatabaseCleaner.clean
		end

		context 'total' do
			it 'por_menor_valor' do
				projeto = FactoryBot.create :licitacao_projeto, :por_lote, pedido_id: @pedido.id, tipo_de_totalizacao: :menor_valor

				expect(projeto.lotes.first.total).to eq 400
			end

			it 'por_valor_medio' do
				projeto = FactoryBot.create :licitacao_projeto, :por_lote, pedido_id: @pedido.id, tipo_de_totalizacao: :valor_medio

				expect(projeto.lotes.first.total).to eq 600
			end
		end
	end

	describe '#pessoas_do_projeto_elegiveis_para_lances_verbais' do
		let(:processo) { FactoryBot.create :licitacao_processo }
		let(:lote) { processo.lotes.last }
		context 'quando existem pelo menos 3 empresas dentro do limite de 10%' do
			it 'retorna essas empresas' do
				cria_pessoas_do_projeto_e_propostas(quantidade: 5, intervalo: 3) # 100 -> 103 -> 106 -> 109 -> 112,  tornando os 4 primeiros elegíveis
				expect(lote.pessoas_do_projeto_elegiveis_para_lances_verbais.sort).to eq processo.pessoas_do_projeto.first(4).to_a
			end
		end
		context 'quando existem menos de 3 empresas dentro do limite de 10%' do
			it 'retorna todas as empresas que tem alguma das 3 menores propostas' do
				lote.pessoas_do_projeto_elegiveis_para_lances_verbais.each { |pessoa| pessoa.delete}
				cria_pessoas_do_projeto_e_propostas(quantidade: 5, intervalo: 6) # 100 -> 106 -> 112 -> 118 -> 124. Apenas os 2 primeiros seriam elegíveis, então entram os 3 primeiros
				expect(lote.pessoas_do_projeto_elegiveis_para_lances_verbais.sort).to eq processo.pessoas_do_projeto.first(3).to_a
			end
		end
	end

	context 'retorna media ou menor valor' do
		let(:processo) { FactoryBot.create :licitacao_processo, :global }
		let(:lote) {
			processo.lotes.first
		}
		describe '#media_dos_valores' do
				it 'retorna a media' do
					cria_pessoas_do_projeto_e_propostas(quantidade: 1)

					expect(lote.media_dos_valores).to eq 60
			end
		end

		describe '#menor_cotacao_dos_itens' do
				it 'retorna menor valor' do
					cria_pessoas_do_projeto_e_propostas(quantidade: 1)
					expect(lote.menor_cotacao_dos_itens).to eq 40
			end
		end
	end


	describe '#primeiro_colocado' do
		context 'quando o processo é convite' do
			let(:processo) { FactoryBot.create :licitacao_processo, :dispensa}
			let(:lote) { processo.lotes.first }
			context 'e existem propostas cadastradas' do
				it 'retorna o menor' do
					pending("Implementar")
					fail
				end
			end
		end
		context 'quando o processo não é de dispensa' do

			let(:processo) { FactoryBot.create :licitacao_processo, :global }
			let(:lote) {
				processo.lotes.first
			}
			#A rodada 0 já existe e está concluída. Portanto, este teste não passa
			#context 'e não existem rodadas' do
			#	it 'retorna erro' do
			#		cria_pessoas_do_projeto_e_propostas(quantidade: 1)
			#		lote.abrir_lances
			#		expect { lote.primeiro_colocado }.to raise_error("não há rodadas.")
			#	end
			#end
			context 'e lances estão abertos' do
				it 'retorna erro' do
					pessoas_do_projeto = cria_pessoas_do_projeto_e_propostas(quantidade: 1, intervalo: 1)
					lote.abrir_lances
					preenche_lances(pessoas_do_projeto)
					expect { lote.abrir_lances }.to raise_error("Lances já estão abertos")
				end
			end
			context 'e existe empate ficto' do
				it 'retorna erro' do
					medio_porte = processo.pessoas_do_projeto.create!( pessoa_id: FactoryBot.create(:pessoa_juridica, porte: :medio_porte).id )
					microempresa = processo.pessoas_do_projeto.create!( pessoa_id: FactoryBot.create(:pessoa_juridica, porte: :microempresa).id )

					preenche_propostas(processo.pessoas_do_projeto, 4)
					lote.abrir_lances

					lote.rodadas.last.lances.find_by(pessoa_do_projeto_id: medio_porte.id).update!(valor: 1000)
					lote.rodadas.last.lances.find_by(pessoa_do_projeto_id: microempresa.id).update!(valor: 900)

					lote.rodadas.last.send(:gera_nova_rodada)
					lote.rodadas.last.lances.find_by(pessoa_do_projeto_id: medio_porte.id).update!(valor: 870)
					lote.rodadas.last.lances.find_by(pessoa_do_projeto_id: microempresa.id).update!(valor: nil, desistir: true)

					expect { lote.fechar_lances }.to raise_error("Empate ficto detectado.")
				end
			end
			context 'e existem mais de uma empresa disputando' do
				it 'retorna erro' do
					pessoas_do_projeto = cria_pessoas_do_projeto_e_propostas(quantidade: 3, intervalo: 1)
					lote.abrir_lances
					preenche_lances(pessoas_do_projeto)
					lote.update_column(:lances_abertos, false)
					expect { lote.primeiro_colocado }.to raise_error("Só é possível encerrar quando houver um vencedor.")
				end
			end
			context 'e existe apenas uma empresa disputando' do
				it 'retorna o menor' do
					pessoas_do_projeto = cria_pessoas_do_projeto_e_propostas(quantidade: 1)
					lote.abrir_lances
					preenche_lances(pessoas_do_projeto)

					lote.rodadas.last.send(:gera_nova_rodada)

					expect(lote.primeiro_colocado).to eq ({ pessoa_do_projeto: pessoas_do_projeto.first, valor: 13.0 })
				end
			end
		end
	end

	describe '#atribui_ganhador' do
		let(:processo) { FactoryBot.create :licitacao_processo, :por_item, status: :em_sessao }
		context 'quando o lote é de melhor técnica' do
			let(:lote) { FactoryBot.create :licitacao_lote, :melhor_tecnica, projeto_id: processo.id }
			context 'e não foram adicionadas notas aos licitantes' do
				it 'ganhador fica nulo' do
					lote.reload
					cria_pessoas_do_projeto_e_propostas(quantidade: 3, intervalo: 1)
					expect(lote.pessoas_do_projeto_do_lote.count).to eq 3
				end
			end
			context 'e foram adicionadas notas aos licitantes' do
				it 'salva o ganhador no lote' do
						lote.reload
						cria_pessoas_do_projeto_e_propostas(quantidade: 3, intervalo: 1)

						atributos_pessoas_do_lote = {
							pessoas_do_projeto_do_lote_attributes: lote.pessoas_do_projeto_do_lote.each_with_index.inject({}) { |hash, (ppl, index)|
								hash.merge({index.to_s => {id: ppl.id, nota_tecnica: index}})
							}
						}

						expect {
							lote.update(atributos_pessoas_do_lote)
						}.to change(lote, :ganhador).from(nil).to(lote.pessoas_do_projeto_do_lote.last.pessoa_do_projeto)
				end
			end
		end

		context 'quando o lote não é de melhor técnica' do
			let(:processo) { FactoryBot.create :licitacao_processo, :por_item }
			let(:lote) { FactoryBot.create :licitacao_lote }
			it 'não salva ganhador ao salvar lote' do
				cria_pessoas_do_projeto_e_propostas(quantidade: 3, intervalo: 1)

				atributos_pessoas_do_lote = {
					pessoas_do_projeto_do_lote_attributes: lote.pessoas_do_projeto_do_lote.each_with_index.inject({}) { |hash, (ppl, index)|
						hash.merge({index.to_s => {id: ppl.id, habilitado: false}})
					}
				}
				expect {
					lote.update(atributos_pessoas_do_lote)
				}.not_to change(lote, :ganhador)
			end
		end
	end


	# VALIDAÇÕES
	describe '#projeto_nao_deve_ter_mais_de_um_lote' do
		context 'quando o projeto é global' do
			it 'não permite mais de um lote' do
				projeto = FactoryBot.create :licitacao_projeto, :global
				lote_novo = Licitacao::Lote.create(projeto_id: projeto.id)
				expect(lote_novo.errors[:projeto_id]).to include "Projeto global não pode ter mais de um lote"
			end
		end
	end

	describe 'validação de ganhador' do
		context 'ao fechar lances' do
			context 'sem rodadas' do
				it 'salva' do
					lote = FactoryBot.create :licitacao_lote, lances_abertos: false
					expect(lote).to be_valid
				end
			end
			context 'com rodadas' do
				let(:processo) { FactoryBot.create :licitacao_processo, :global }
				let(:lote) {
					processo.lotes.first
				}
				context 'quando há apenas uma empresa concorrendo e é desempate' do
					it 'salva' do
						pessoas_do_projeto = cria_pessoas_do_projeto_e_propostas(quantidade: 1, intervalo: 1)
						lote.abrir_lances
						preenche_lances(pessoas_do_projeto)

						lote.rodadas.last.send(:gera_nova_rodada)
						expect(lote).to be_persisted
					end
				end
				context 'quando há mais de uma empresa concorrendo' do
					it 'retorna erro' do
						cria_pessoas_do_projeto_e_propostas(quantidade: 3, intervalo: 1)
						lote.abrir_lances
						preenche_lances(lote.processo.pessoas_do_projeto)
						expect { lote.update(lances_abertos: false) }.to raise_error("Só é possível encerrar quando houver um vencedor.")
					end
				end
			end
		end
		context 'ao abrir lances' do
			it 'salva' do
				lote = FactoryBot.create :licitacao_lote, lances_abertos: false
				lote.lances_abertos = true
				lote.validate
				expect(lote).to be_valid
			end
		end
	end

	describe 'lote_por_desconto?' do
		it 'retorna true'do
			item_do_pedido_por_desconto = FactoryBot.create :item_do_pedido, tipo: 'por_desconto'
			lote = FactoryBot.create :licitacao_lote, lances_abertos: false
			_item_do_lote = FactoryBot.create :licitacao_item_do_lote, lote_id: lote.id, item_do_pedido_id: item_do_pedido_por_desconto.id
			expect(lote.lote_por_desconto?).to eq true
		end
	end

	describe 'lote_por_preco?' do
		it 'retorna true'do
			item_do_pedido_por_preco= FactoryBot.create :item_do_pedido, tipo: 'por_preco'
			lote = FactoryBot.create :licitacao_lote, lances_abertos: false
			_item_do_lote = FactoryBot.create :licitacao_item_do_lote, lote_id: lote.id, item_do_pedido_id: item_do_pedido_por_preco.id
			expect(lote.lote_por_preco?).to eq true
		end
	end

	describe 'lote_por_valor_previsto?' do
		it 'retorna true'do
			item_do_pedido_por_preco = FactoryBot.create :item_do_pedido, :por_valor_previsto
			lote = FactoryBot.create :licitacao_lote, lances_abertos: false
			_item_do_lote = FactoryBot.create :licitacao_item_do_lote, lote_id: lote.id, item_do_pedido_id: item_do_pedido_por_preco.id
			expect(lote.lote_por_valor_previsto?).to eq true
		end
	end

	describe '#modalidade_de_licitacao_deve_ser_pregao' do
		let(:lote) { FactoryBot.create :licitacao_lote, :completo }
		context 'quando a modalidade da licitação' do
			context 'é inválida (convite)' do
				before(:each) do
					allow_any_instance_of(Licitacao::PessoaDoProjeto).to receive( :preenchimento_da_proposta_final_corresponde_ao_lance_final ).and_return(true)
					lote.processo.por_item!
					lote.processo.convite!
				end

				context 'e o lote é atualizado para abrir os lances' do
					it 'adiciona erro ao lote' do
						lote.update(lances_abertos: true)
						expect(lote.errors[:lances_abertos]).to include("não pode ser verdadeiro caso modalidade de licitação seja convite")
					end
				end

				context 'e o lote é atualizado para fechar os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: false)
						expect(lote).to be_valid
					end
				end
			end

			context 'é válida (pregao_presencial)' do
				before(:each) do
					allow_any_instance_of(Licitacao::PessoaDoProjeto).to receive( :preenchimento_da_proposta_final_corresponde_ao_lance_final ).and_return(true)
					lote.processo.pregao_presencial!
				end

				context 'e o lote é atualizado para abrir os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: true)
						expect(lote).to be_valid
					end
				end

				context 'e o lote é atualizado para fechar os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: false)
						expect(lote).to be_valid
					end
				end
			end
		end
	end

	describe '#licitacao_deve_estar_em_sessao' do
		let(:lote) { FactoryBot.create :licitacao_lote }
		context 'quando o status da licitação' do
			context 'é inválida (aberto)' do
				before(:each) do
					allow_any_instance_of(Licitacao::PessoaDoProjeto).to receive( :preenchimento_da_proposta_final_corresponde_ao_lance_final ).and_return(true)
					lote.processo.aberto!
				end

				context 'e o lote é atualizado para abrir os lances' do
					it 'adiciona erro ao lote' do
						lote.update(lances_abertos: true)
						expect(lote.errors[:lances_abertos]).to include("não pode ser verdadeiro caso a fase do processo seja aberto")
					end
				end

				context 'e o lote é atualizado para fechar os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: false)
						expect(lote).to be_valid
					end
				end
			end

			context 'é válida (em_sessao)' do
				before(:each) do
					lote.processo.ir_para_sessao!
				end

				context 'e o lote é atualizado para abrir os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: true)
						expect(lote).to be_valid
					end
				end

				context 'e o lote é atualizado para fechar os lances' do
					it 'valida o lote' do
						lote.update(lances_abertos: false)
						expect(lote).to be_valid
					end
				end
			end
		end
	end

	describe '#salva_ganhador' do
		context "com parâmetros válidos" do
			it 'salva o ganhador e habilita' do
				lote = FactoryBot.create :licitacao_lote, :completo, lances_abertos: true
				ganhador = lote.pessoas_do_projeto.first
				segundo_licitante = lote.pessoas_do_projeto.second
				ganhador_params = {ganhador_id: ganhador.id, justificativa: 'Justificativa para o ganhador'}
				expect { lote.salva_ganhador(ganhador_params) }.to change(lote, :ganhador).from(nil).to(ganhador)

				ganhador_do_lote = Licitacao::PessoaDoProjetoDoLote.find_by(lote_id: lote.id, pessoa_do_projeto_id: ganhador.id)
				expect(ganhador_do_lote.habilitado).to be_truthy

				segunda_pessoa_do_lote = Licitacao::PessoaDoProjetoDoLote.find_by(lote_id: lote.id, pessoa_do_projeto_id: segundo_licitante.id)
				expect(segunda_pessoa_do_lote.habilitado).to be_falsey
			end
		end

		context "com parâmetros inválidos" do
			it "retorna falso" do
				lote = FactoryBot.create :licitacao_lote, :completo, :tecnica_e_preco, lances_abertos: true
				ganhador_params = {ganhador_id: nil, justificativa: ''}
				expect(lote.salva_ganhador(ganhador_params)).to be_falsey
			end
		end
	end

	describe "#pessoas_do_projeto_com_cotacao" do
		it "deve retornar um array de pessoas_do_projeto com cotação" do
			lote = FactoryBot.create :licitacao_lote, :completo
			lote.reload
			lote.pessoas_do_projeto_do_lote.each do |pessoa_do_projeto_do_lote|
				lote.itens_do_lote.ativos.each do |item|
					item_do_projeto = FactoryBot.create(:item_do_projeto_por_pessoa, pessoa_do_projeto_id: pessoa_do_projeto_do_lote.pessoa_do_projeto.id, item_do_lote_id: item.id )
				end
				pessoa_do_projeto_do_lote.pessoa_do_projeto.reload
			end
			pessoas_do_projeto_com_cotacao = lote.pessoas_do_projeto_com_cotacao
			expect(pessoas_do_projeto_com_cotacao).to be_an_instance_of(Array)
			expect(pessoas_do_projeto_com_cotacao).to include lote.pessoas_do_projeto.first
			expect(pessoas_do_projeto_com_cotacao).to include lote.pessoas_do_projeto.second
		end
	end

	describe "#pessoas_do_projeto_do_lote_com_cotacao" do
		it "deve retornar um array de pessoas_do_projeto_do_lote com cotação" do
			lote = FactoryBot.create :licitacao_lote, :completo
			lote.reload
			lote.pessoas_do_projeto_do_lote.each do |pessoa_do_projeto_do_lote|
				lote.itens_do_lote.ativos.each do |item|
					item_do_projeto = FactoryBot.create(:item_do_projeto_por_pessoa, pessoa_do_projeto_id: pessoa_do_projeto_do_lote.pessoa_do_projeto.id, item_do_lote_id: item.id )
				end
				pessoa_do_projeto_do_lote.pessoa_do_projeto.reload
			end
			pessoas_do_projeto_do_lote_com_cotacao = lote.pessoas_do_projeto_do_lote_com_cotacao
			expect(pessoas_do_projeto_do_lote_com_cotacao).to be_an_instance_of(Array)
			expect(pessoas_do_projeto_do_lote_com_cotacao).to include lote.pessoas_do_projeto_do_lote.first
			expect(pessoas_do_projeto_do_lote_com_cotacao).to include lote.pessoas_do_projeto_do_lote.second
		end
	end

	describe '#todos_os_itens_do_lote_devem_ter_cotacoes' do
		context "quando não tem cotações" do
			context 'quando o lote do processo é global' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :global, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					expect { lote.todos_os_itens_do_lote_devem_ter_cotacoes }.to raise_error('Todos os itens devem ter propostas preenchidas')
				end
			end
			context 'quando o lote do processo é por item' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :por_item, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					expect { lote.todos_os_itens_do_lote_devem_ter_cotacoes }.to raise_error('Nenhuma empresa preencheu proposta para este item')
				end
			end
			context 'quando o lote do processo é por lote' do
				let(:processo) { FactoryBot.create :licitacao_processo, forma_de_agrupamento: :por_lote, status: :em_sessao }
				let(:lote) { processo.lotes.first }
				it 'retorna mensagem de erro' do
					expect { lote.todos_os_itens_do_lote_devem_ter_cotacoes }.to raise_error('Nem todos os itens do lote tem proposta preenchida')
				end
			end
		end
	end

	describe '#tem_licitante_com_cotacoes?' do
		context 'quando não tem pessoas do projeto com cotações' do
			let(:processo) { FactoryBot.create :licitacao_processo, :por_lote, status: :em_sessao }
			let(:lote) { processo.lotes.first }
			it 'retorna false' do
				processo.pessoas_do_projeto.update_all(classificado: false)
				expect(lote.tem_licitante_com_cotacoes?).to be_falsey
			end
		end
		context 'quando tem cotação para todos' do
			it 'retorna true' do
				projeto = FactoryBot.create :licitacao_projeto, status: :em_sessao
				pessoa_do_projeto = FactoryBot.create(:licitacao_pessoa_do_projeto, projeto_id: projeto.id)
				projeto.lotes.each do |lote|
					lote.itens_do_lote.each do |il|
						FactoryBot.create(:item_do_projeto_por_pessoa, item_do_lote_id: il.id, pessoa_do_projeto_id: pessoa_do_projeto.id)
					end
				end
				expect(projeto.lotes.first.tem_licitante_com_cotacoes?).to be_truthy
			end
		end
	end

	describe "#todos_os_itens_do_lote_tem_cotacoes?" do
		context 'quando tem cotação para todos' do
			it 'retorna true' do
				projeto = FactoryBot.create :licitacao_projeto, status: :em_sessao
				pessoa_do_projeto = FactoryBot.create(:licitacao_pessoa_do_projeto, projeto_id: projeto.id)
				projeto.lotes.each do |lote|
					lote.itens_do_lote.each do |il|
						FactoryBot.create(:item_do_projeto_por_pessoa, item_do_lote_id: il.id, pessoa_do_projeto_id: pessoa_do_projeto.id)
					end
				end
				expect(projeto.lotes.first.todos_os_itens_do_lote_tem_cotacoes?).to be_truthy
			end
		end
	end

end