baarkerlounger
/
submit-social-housing-lettings-and-sales-data
mirror of https://github.com/communitiesuk/submit-social-housing-lettings-and-sales-data.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

CLDC-3289 Avoid freezing time (part 3) (#2445) 

* Refactor tests #1

* Update tasklist helper tests

* Update task list helper

* Fix test

* Rabase fixes

* Update model/validations tests

* Update som sales log specs

* Remove missing addresses csv tasks

* Update some tests for 2023 collection close

* More fixes

* Revert sales shared examples change

* Fix test

* Update test nemes, remove time stub
pull/2513/head v0.4.59
kosiakkatrina 7 months ago committed by GitHub
parent
3adfb29143
commit
8ce22d37c0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 26 additions and 2195 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      app/jobs/create_addresses_csv_job.rb
  2. 33
      app/jobs/email_missing_addresses_csv_job.rb
  3. 2
      app/models/derived_variables/sales_log_variables.rb
  4. 140
      app/services/csv/missing_addresses_csv_service.rb
  5. 129
      lib/tasks/import_address_from_csv.rake
  6. 118
      lib/tasks/send_missing_addresses_csv.rake
  7. 1
      spec/factories/sales_log.rb
  8. 2
      spec/fixtures/files/missing_lettings_logs_addresses.csv
  9. 4
      spec/fixtures/files/missing_lettings_logs_addresses_all_issues.csv
  10. 2
      spec/fixtures/files/missing_lettings_logs_town_or_city.csv
  11. 2
      spec/fixtures/files/missing_lettings_logs_wrong_uprn.csv
  12. 2
      spec/fixtures/files/missing_sales_logs_addresses.csv
  13. 4
      spec/fixtures/files/missing_sales_logs_addresses_all_issues.csv
  14. 2
      spec/fixtures/files/missing_sales_logs_town_or_city.csv
  15. 2
      spec/fixtures/files/missing_sales_logs_wrong_uprn.csv
  16. 49
      spec/jobs/create_addresses_csv_job_spec.rb
  17. 66
      spec/jobs/email_missing_addresses_csv_job_spec.rb
  18. 522
      spec/lib/tasks/correct_address_from_csv_spec.rb
  19. 519
      spec/lib/tasks/send_missing_addresses_csv_spec.rb
  20. 4
      spec/models/form/lettings/questions/stock_owner_spec.rb
  21. 74
      spec/models/sales_log_spec.rb
  22. 18
      spec/models/validations/sales/setup_validations_spec.rb
  23. 504
      spec/services/csv/missing_addresses_csv_service_spec.rb

22
app/jobs/create_addresses_csv_job.rb
Unescape View File

@ -1,22 +0,0 @@
class CreateAddressesCsvJob < ApplicationJob
queue_as :default
BYTE_ORDER_MARK = "\uFEFF".freeze # Required to ensure Excel always reads CSV as UTF-8
def perform(organisation, log_type)
csv_service = Csv::MissingAddressesCsvService.new(organisation, [])
case log_type
when "lettings"
csv_string = csv_service.create_lettings_addresses_csv
filename = "#{['lettings-logs-addresses', organisation.name, Time.zone.now].compact.join('-')}.csv"
when "sales"
csv_string = csv_service.create_sales_addresses_csv
filename = "#{['sales-logs-addresses', organisation.name, Time.zone.now].compact.join('-')}.csv"
end
storage_service = Storage::S3Service.new(Configuration::EnvConfigurationService.new, ENV["BULK_UPLOAD_BUCKET"])
storage_service.write_file(filename, BYTE_ORDER_MARK + csv_string)
Rails.logger.info("Created addresses file: #{filename}")
end
end

33
app/jobs/email_missing_addresses_csv_job.rb
Unescape View File

@ -1,33 +0,0 @@
class EmailMissingAddressesCsvJob < ApplicationJob
queue_as :default
BYTE_ORDER_MARK = "\uFEFF".freeze # Required to ensure Excel always reads CSV as UTF-8
EXPIRATION_TIME = 1.week.to_i
MISSING_ADDRESSES_THRESHOLD = 50
def perform(user_ids, organisation, log_type, issue_types, skip_uprn_issue_organisations)
csv_service = Csv::MissingAddressesCsvService.new(organisation, skip_uprn_issue_organisations)
case log_type
when "lettings"
csv_string = csv_service.create_missing_lettings_addresses_csv
filename = "#{['missing-lettings-logs-addresses', organisation.name, Time.zone.now].compact.join('-')}.csv"
email_method = :send_missing_lettings_addresses_csv_download_mail
when "sales"
csv_string = csv_service.create_missing_sales_addresses_csv
filename = "#{['missing-sales-logs-addresses', organisation.name, Time.zone.now].compact.join('-')}.csv"
email_method = :send_missing_sales_addresses_csv_download_mail
end
storage_service = Storage::S3Service.new(Configuration::EnvConfigurationService.new, ENV["BULK_UPLOAD_BUCKET"])
storage_service.write_file(filename, BYTE_ORDER_MARK + csv_string)
url = storage_service.get_presigned_url(filename, EXPIRATION_TIME)
user_ids.each do |id|
user = User.find(id)
next if user.blank?
CsvDownloadMailer.new.send(email_method, user, url, EXPIRATION_TIME, issue_types)
end
end
end

2
app/models/derived_variables/sales_log_variables.rb
Unescape View File

@ -31,7 +31,7 @@ module DerivedVariables::SalesLogVariables
if saledate && form.start_year_after_2024? && discounted_ownership_sale?
self.ppostcode_full = postcode_full
self.ppcodenk = 0 if postcode_full.present?
self.ppcodenk = pcodenk
self.prevloc = la
self.is_previous_la_inferred = is_la_inferred
self.previous_la_known = la_known

140
app/services/csv/missing_addresses_csv_service.rb
Unescape View File

@ -1,140 +0,0 @@
module Csv
class MissingAddressesCsvService
def initialize(organisation, skip_uprn_issue_organisations)
@organisation = organisation
@skip_uprn_issue_organisations = skip_uprn_issue_organisations
end
def create_missing_lettings_addresses_csv
logs_with_missing_addresses = @organisation.managed_lettings_logs
.imported_2023_with_old_form_id
.where(needstype: 1, address_line1: nil, town_or_city: nil, uprn_known: [0, nil])
logs_with_missing_town_or_city = @organisation.managed_lettings_logs
.imported_2023_with_old_form_id
.where(needstype: 1, town_or_city: nil, uprn_known: [0, nil])
.where.not(address_line1: nil)
logs_with_wrong_uprn = if @skip_uprn_issue_organisations.include?(@organisation.id)
[]
else
@organisation.managed_lettings_logs
.imported_2023
.where(needstype: 1)
.where.not(uprn: nil)
.where("uprn = propcode OR uprn = tenancycode OR town_or_city = 'Bristol'")
end
return if logs_with_missing_addresses.empty? && logs_with_missing_town_or_city.empty? && logs_with_wrong_uprn.empty?
CSV.generate(headers: true) do |csv|
csv << ["Issue type", "Log ID", "Tenancy start date", "Tenant code", "Property reference", "Log owner", "Owning organisation", "Managing organisation", "UPRN", "Address Line 1", "Address Line 2 (optional)", "Town or City", "County (optional)", "Property's postcode"]
logs_with_missing_addresses.each do |log|
csv << ["Full address required"] + lettings_log_to_csv_row(log)
end
logs_with_missing_town_or_city.each do |log|
csv << ["Missing town or city"] + lettings_log_to_csv_row(log)
end
logs_with_wrong_uprn.each do |log|
csv << ["Incorrect UPRN"] + lettings_log_to_csv_row(log)
end
end
end
def create_missing_sales_addresses_csv
logs_with_missing_addresses = @organisation.sales_logs
.imported_2023_with_old_form_id
.where(address_line1: nil, town_or_city: nil, uprn_known: [0, nil])
logs_with_missing_town_or_city = @organisation.sales_logs
.imported_2023_with_old_form_id
.where(town_or_city: nil, uprn_known: [0, nil])
.where.not(address_line1: nil)
logs_with_wrong_uprn = if @skip_uprn_issue_organisations.include?(@organisation.id)
[]
else
@organisation.sales_logs
.imported_2023
.where.not(uprn: nil)
.where("uprn = purchid OR town_or_city = 'Bristol'")
end
return if logs_with_missing_addresses.empty? && logs_with_missing_town_or_city.empty? && logs_with_wrong_uprn.empty?
CSV.generate(headers: true) do |csv|
csv << ["Issue type", "Log ID", "Sale completion date", "Purchaser code", "Log owner", "Owning organisation", "UPRN", "Address Line 1", "Address Line 2 (optional)", "Town or City", "County (optional)", "Property's postcode"]
logs_with_missing_addresses.each do |log|
csv << ["Full address required"] + sales_log_to_csv_row(log)
end
logs_with_missing_town_or_city.each do |log|
csv << ["Missing town or city"] + sales_log_to_csv_row(log)
end
logs_with_wrong_uprn.each do |log|
csv << ["Incorrect UPRN"] + sales_log_to_csv_row(log)
end
end
end
def create_lettings_addresses_csv
logs = @organisation.managed_lettings_logs.filter_by_year(2023)
CSV.generate(headers: true) do |csv|
csv << ["Log ID", "Tenancy start date", "Tenant code", "Property reference", "Log owner", "Owning organisation", "Managing organisation", "UPRN", "Address Line 1", "Address Line 2 (optional)", "Town or City", "County (optional)", "Property's postcode"]
logs.each do |log|
csv << lettings_log_to_csv_row(log)
end
end
end
def create_sales_addresses_csv
logs = @organisation.sales_logs.filter_by_year(2023)
CSV.generate(headers: true) do |csv|
csv << ["Log ID", "Sale completion date", "Purchaser code", "Log owner", "Owning organisation", "UPRN", "Address Line 1", "Address Line 2 (optional)", "Town or City", "County (optional)", "Property's postcode"]
logs.each do |log|
csv << sales_log_to_csv_row(log)
end
end
end
private
def sales_log_to_csv_row(log)
[log.id,
log.saledate&.to_date,
log.purchid,
log.assigned_to&.email,
log.owning_organisation&.name,
log.uprn,
log.address_line1,
log.address_line2,
log.town_or_city,
log.county,
log.postcode_full]
end
def lettings_log_to_csv_row(log)
[log.id,
log.startdate&.to_date,
log.tenancycode,
log.propcode,
log.assigned_to&.email,
log.owning_organisation&.name,
log.managing_organisation&.name,
log.uprn,
log.address_line1,
log.address_line2,
log.town_or_city,
log.county,
log.postcode_full]
end
end
end

129
lib/tasks/import_address_from_csv.rake
Unescape View File

@ -1,129 +0,0 @@
namespace :data_import do
desc "Import lettings address data from a csv file"
task :import_lettings_addresses_from_csv, %i[file_name] => :environment do |_task, args|
file_name = args[:file_name]
raise "Usage: rake data_import:import_lettings_addresses_from_csv['csv_file_name']" if file_name.blank?
s3_service = Storage::S3Service.new(Configuration::EnvConfigurationService.new, ENV["BULK_UPLOAD_BUCKET"])
file_io = s3_service.get_file_io(file_name)
file_io.set_encoding_by_bom
addresses_csv = CSV.parse(file_io, headers: true)
contains_issue_type = addresses_csv.headers.include?("Issue type")
addresses_csv.each do |row|
lettings_log_id = contains_issue_type ? row[1] : row[0]
uprn = contains_issue_type ? row[8] : row[7]
address_line1 = contains_issue_type ? row[9] : row[8]
address_line2 = contains_issue_type ? row[10] : row[9]
town_or_city = contains_issue_type ? row[11] : row[10]
county = contains_issue_type ? row[12] : row[11]
postcode_full = contains_issue_type ? row[13] : row[12]
if lettings_log_id.blank?
Rails.logger.info("Lettings log ID not provided for address: #{[address_line1, address_line2, town_or_city, county, postcode_full].join(', ')}")
next
end
if uprn.present?
Rails.logger.info("Lettings log with ID #{lettings_log_id} contains uprn, skipping log")
next
end
if address_line1.blank? || town_or_city.blank? || postcode_full.blank?
Rails.logger.info("Lettings log with ID #{lettings_log_id} is missing required address data, skipping log")
next
end
lettings_log = LettingsLog.find_by(id: lettings_log_id)
if lettings_log.blank?
Rails.logger.info("Could not find a lettings log with id #{lettings_log_id}")
next
end
lettings_log.uprn_known = 0
lettings_log.uprn = nil
lettings_log.uprn_confirmed = nil
lettings_log.address_line1 = address_line1
lettings_log.address_line2 = address_line2
lettings_log.town_or_city = town_or_city
lettings_log.county = county
lettings_log.postcode_full = postcode_full
lettings_log.postcode_known = lettings_log.postcode_full.present? ? 1 : nil
lettings_log.is_la_inferred = nil
lettings_log.la = nil
lettings_log.send("process_postcode_changes!")
lettings_log.values_updated_at = Time.zone.now
if lettings_log.save
Rails.logger.info("Updated lettings log #{lettings_log_id}, with address: #{[lettings_log.address_line1, lettings_log.address_line2, lettings_log.town_or_city, lettings_log.county, lettings_log.postcode_full].join(', ')}")
else
Rails.logger.error("Validation failed for lettings log with ID #{lettings_log.id}: #{lettings_log.errors.full_messages.join(', ')}}")
end
end
end
desc "Import sales address data from a csv file"
task :import_sales_addresses_from_csv, %i[file_name] => :environment do |_task, args|
file_name = args[:file_name]
raise "Usage: rake data_import:import_sales_addresses_from_csv['csv_file_name']" if file_name.blank?
s3_service = Storage::S3Service.new(Configuration::EnvConfigurationService.new, ENV["BULK_UPLOAD_BUCKET"])
file_io = s3_service.get_file_io(file_name)
file_io.set_encoding_by_bom
addresses_csv = CSV.parse(file_io, headers: true)
contains_issue_type = addresses_csv.headers.include?("Issue type")
addresses_csv.each do |row|
sales_log_id = contains_issue_type ? row[1] : row[0]
uprn = contains_issue_type ? row[6] : row[5]
address_line1 = contains_issue_type ? row[7] : row[6]
address_line2 = contains_issue_type ? row[8] : row[7]
town_or_city = contains_issue_type ? row[9] : row[8]
county = contains_issue_type ? row[10] : row[9]
postcode_full = contains_issue_type ? row[11] : row[10]
if sales_log_id.blank?
Rails.logger.info("Sales log ID not provided for address: #{[address_line1, address_line2, town_or_city, county, postcode_full].join(', ')}")
next
end
if uprn.present?
Rails.logger.info("Sales log with ID #{sales_log_id} contains uprn, skipping log")
next
end
if address_line1.blank? || town_or_city.blank? || postcode_full.blank?
Rails.logger.info("Sales log with ID #{sales_log_id} is missing required address data, skipping log")
next
end
sales_log = SalesLog.find_by(id: sales_log_id)
if sales_log.blank?
Rails.logger.info("Could not find a sales log with id #{sales_log_id}")
next
end
sales_log.uprn_known = 0
sales_log.uprn = nil
sales_log.uprn_confirmed = nil
sales_log.address_line1 = address_line1
sales_log.address_line2 = address_line2
sales_log.town_or_city = town_or_city
sales_log.county = county
sales_log.postcode_full = postcode_full
sales_log.pcodenk = sales_log.postcode_full.present? ? 0 : nil
sales_log.is_la_inferred = nil
sales_log.la = nil
sales_log.send("process_postcode_changes!")
sales_log.values_updated_at = Time.zone.now
if sales_log.save
Rails.logger.info("Updated sales log #{sales_log_id}, with address: #{[sales_log.address_line1, sales_log.address_line2, sales_log.town_or_city, sales_log.county, sales_log.postcode_full].join(', ')}")
else
Rails.logger.error("Validation failed for sales log with ID #{sales_log.id}: #{sales_log.errors.full_messages.join(', ')}}")
end
end
end
end

118
lib/tasks/send_missing_addresses_csv.rake
Unescape View File

@ -1,118 +0,0 @@
namespace :correct_addresses do
desc "Send missing lettings addresses csv"
task :send_missing_addresses_lettings_csv, %i[skip_uprn_issue_organisations] => :environment do |_task, args|
skip_uprn_issue_organisations = args[:skip_uprn_issue_organisations]&.split(" ")&.map(&:to_i) || []
Organisation.all.each do |organisation|
logs_impacted_by_missing_address = organisation.managed_lettings_logs
.imported_2023_with_old_form_id
.where(needstype: 1, address_line1: nil, town_or_city: nil, uprn_known: [0, nil]).count
logs_impacted_by_missing_town_or_city = organisation.managed_lettings_logs
.imported_2023_with_old_form_id
.where(needstype: 1, town_or_city: nil, uprn_known: [0, nil])
.where.not(address_line1: nil).count
logs_impacted_by_uprn_issue = if skip_uprn_issue_organisations.include?(organisation.id)
[]
else
organisation.managed_lettings_logs
.imported_2023
.where(needstype: 1)
.where.not(uprn: nil)
.where("uprn = propcode OR uprn = tenancycode")
end
logs_impacted_by_bristol_uprn_issue = if skip_uprn_issue_organisations.include?(organisation.id)
[]
else
organisation.managed_lettings_logs
.imported_2023
.where(needstype: 1)
.where.not(uprn: nil)
.where("town_or_city = 'Bristol'")
end
missing_addresses_threshold = EmailMissingAddressesCsvJob::MISSING_ADDRESSES_THRESHOLD
if logs_impacted_by_missing_address >= missing_addresses_threshold || logs_impacted_by_missing_town_or_city >= missing_addresses_threshold || logs_impacted_by_uprn_issue.any? || logs_impacted_by_bristol_uprn_issue.any?
issue_types = []
issue_types << "missing_address" if logs_impacted_by_missing_address.positive?
issue_types << "missing_town" if logs_impacted_by_missing_town_or_city.positive?
issue_types << "wrong_uprn" if logs_impacted_by_uprn_issue.any?
issue_types << "bristol_uprn" if logs_impacted_by_bristol_uprn_issue.any?
data_coordinators = organisation.users.where(role: 2).filter_by_active
users_to_contact = data_coordinators.any? ? data_coordinators : organisation.users.filter_by_active
EmailMissingAddressesCsvJob.perform_later(users_to_contact.map(&:id), organisation, "lettings", issue_types, skip_uprn_issue_organisations)
Rails.logger.info("Sending missing lettings addresses CSV for #{organisation.name} to #{users_to_contact.map(&:email).join(', ')}")
else
Rails.logger.info("Missing addresses below threshold for #{organisation.name}")
end
end
end
desc "Send missing sales addresses csv"
task :send_missing_addresses_sales_csv, %i[skip_uprn_issue_organisations] => :environment do |_task, args|
skip_uprn_issue_organisations = args[:skip_uprn_issue_organisations]&.split(" ")&.map(&:to_i) || []
Organisation.all.each do |organisation|
logs_impacted_by_missing_address = organisation.sales_logs
.imported_2023_with_old_form_id
.where(address_line1: nil, town_or_city: nil, uprn_known: [0, nil]).count
logs_impacted_by_missing_town_or_city = organisation.sales_logs
.imported_2023_with_old_form_id
.where(town_or_city: nil, uprn_known: [0, nil])
.where.not(address_line1: nil).count
logs_impacted_by_uprn_issue = if skip_uprn_issue_organisations.include?(organisation.id)
[]
else
organisation.sales_logs
.imported_2023
.where.not(uprn: nil)
.where("uprn = purchid OR town_or_city = 'Bristol'")
end
missing_addresses_threshold = EmailMissingAddressesCsvJob::MISSING_ADDRESSES_THRESHOLD
if logs_impacted_by_missing_address >= missing_addresses_threshold || logs_impacted_by_missing_town_or_city >= missing_addresses_threshold || logs_impacted_by_uprn_issue.any?
issue_types = []
issue_types << "missing_address" if logs_impacted_by_missing_address.positive?
issue_types << "missing_town" if logs_impacted_by_missing_town_or_city.positive?
issue_types << "wrong_uprn" if logs_impacted_by_uprn_issue.any?
data_coordinators = organisation.users.where(role: 2).filter_by_active
users_to_contact = data_coordinators.any? ? data_coordinators : organisation.users.filter_by_active
EmailMissingAddressesCsvJob.perform_later(users_to_contact.map(&:id), organisation, "sales", issue_types, skip_uprn_issue_organisations)
Rails.logger.info("Sending missing sales addresses CSV for #{organisation.name} to #{users_to_contact.map(&:email).join(', ')}")
else
Rails.logger.info("Missing addresses below threshold for #{organisation.name}")
end
end
end
desc "Send all 2023 lettings addresses csv"
task :create_lettings_addresses_csv, %i[organisation_id] => :environment do |_task, args|
organisation_id = args[:organisation_id]
raise "Usage: rake correct_addresses:create_lettings_addresses_csv['organisation_id']" if organisation_id.blank?
organisation = Organisation.find_by(id: organisation_id)
if organisation.present?
CreateAddressesCsvJob.perform_later(organisation, "lettings")
Rails.logger.info("Creating lettings addresses CSV for #{organisation.name}")
else
Rails.logger.error("Organisation with ID #{organisation_id} not found")
end
end
desc "Send all 2023 sales addresses csv"
task :create_sales_addresses_csv, %i[organisation_id] => :environment do |_task, args|
organisation_id = args[:organisation_id]
raise "Usage: rake correct_addresses:create_sales_addresses_csv['organisation_id']" if organisation_id.blank?
organisation = Organisation.find_by(id: organisation_id)
if organisation.present?
CreateAddressesCsvJob.perform_later(organisation, "sales")
Rails.logger.info("Creating sales addresses CSV for #{organisation.name}")
else
Rails.logger.error("Organisation with ID #{organisation_id} not found")
end
end
end

1
spec/factories/sales_log.rb
Unescape View File

@ -53,6 +53,7 @@ FactoryBot.define do
sex1 { "F" }
ecstat1 { 1 }
postcode_full { "A1 1AA" }
noint { 2 }
uprn_known { 0 }
end
trait :completed do

2
spec/fixtures/files/missing_lettings_logs_addresses.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Tenancy start date,Tenant code,Property reference,Log owner,Owning organisation,Managing organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Full address required,{id},2023-04-05,tenancycode,propcode,testy@example.com,Address org,Address org,,,,,,
1 Issue type Log ID Tenancy start date Tenant code Property reference Log owner Owning organisation Managing organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Full address required {id} 2023-04-05 tenancycode propcode testy@example.com Address org Address org

4
spec/fixtures/files/missing_lettings_logs_addresses_all_issues.csv vendored
Unescape View File

@ -1,4 +0,0 @@
Issue type,Log ID,Tenancy start date,Tenant code,Property reference,Log owner,Owning organisation,Managing organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Full address required,{id},2023-04-05,tenancycode,propcode,testy@example.com,Address org,Address org,,,,,,
Missing town or city,{id},2023-04-05,tenancycode,propcode,testy@example.com,Address org,Address org,,existing address,,,,
Incorrect UPRN,{id},2023-04-05,tenancycode,propcode,testy@example.com,Address org,Address org,123,Some Place,,Bristol,,BS1 1AD
1 Issue type Log ID Tenancy start date Tenant code Property reference Log owner Owning organisation Managing organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Full address required {id} 2023-04-05 tenancycode propcode testy@example.com Address org Address org
3 Missing town or city {id} 2023-04-05 tenancycode propcode testy@example.com Address org Address org existing address
4 Incorrect UPRN {id} 2023-04-05 tenancycode propcode testy@example.com Address org Address org 123 Some Place Bristol BS1 1AD

2
spec/fixtures/files/missing_lettings_logs_town_or_city.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Tenancy start date,Tenant code,Property reference,Log owner,Owning organisation,Managing organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Missing town or city,{id},2023-04-05,tenancycode,propcode,testy@example.com,Address org,Address org,,existing address,,,,
1 Issue type Log ID Tenancy start date Tenant code Property reference Log owner Owning organisation Managing organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Missing town or city {id} 2023-04-05 tenancycode propcode testy@example.com Address org Address org existing address

2
spec/fixtures/files/missing_lettings_logs_wrong_uprn.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Tenancy start date,Tenant code,Property reference,Log owner,Owning organisation,Managing organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Incorrect UPRN,{id},2023-04-05,tenancycode,12,testy@example.com,Address org,Address org,12,Some Place,,Newcastle,,EC1N 2TD
1 Issue type Log ID Tenancy start date Tenant code Property reference Log owner Owning organisation Managing organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Incorrect UPRN {id} 2023-04-05 tenancycode 12 testy@example.com Address org Address org 12 Some Place Newcastle EC1N 2TD

2
spec/fixtures/files/missing_sales_logs_addresses.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Sale completion date,Purchaser code,Log owner,Owning organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Full address required,{id},2023-04-05,purchaser code,testy@example.com,Address org,,,,,,
1 Issue type Log ID Sale completion date Purchaser code Log owner Owning organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Full address required {id} 2023-04-05 purchaser code testy@example.com Address org

4
spec/fixtures/files/missing_sales_logs_addresses_all_issues.csv vendored
Unescape View File

@ -1,4 +0,0 @@
Issue type,Log ID,Sale completion date,Purchaser code,Log owner,Owning organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Full address required,{id},2023-04-05,purchaser code,testy@example.com,Address org,,,,,,
Missing town or city,{id},2023-04-05,purchaser code,testy@example.com,Address org,,existing address line 1,,,,
Incorrect UPRN,{id},2023-04-05,purchaser code,testy@example.com,Address org,123,Some Place,,Bristol,,BS1 1AD
1 Issue type Log ID Sale completion date Purchaser code Log owner Owning organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Full address required {id} 2023-04-05 purchaser code testy@example.com Address org
3 Missing town or city {id} 2023-04-05 purchaser code testy@example.com Address org existing address line 1
4 Incorrect UPRN {id} 2023-04-05 purchaser code testy@example.com Address org 123 Some Place Bristol BS1 1AD

2
spec/fixtures/files/missing_sales_logs_town_or_city.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Sale completion date,Purchaser code,Log owner,Owning organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Missing town or city,{id},2023-04-05,purchaser code,testy@example.com,Address org,,existing address line 1,,,,
1 Issue type Log ID Sale completion date Purchaser code Log owner Owning organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Missing town or city {id} 2023-04-05 purchaser code testy@example.com Address org existing address line 1

2
spec/fixtures/files/missing_sales_logs_wrong_uprn.csv vendored
Unescape View File

@ -1,2 +0,0 @@
Issue type,Log ID,Sale completion date,Purchaser code,Log owner,Owning organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode
Incorrect UPRN,{id},2023-04-05,12,testy@example.com,Address org,12,Some Place,,Newcastle,,EC1N 2TD
1 Issue type Log ID Sale completion date Purchaser code Log owner Owning organisation UPRN Address Line 1 Address Line 2 (optional) Town or City County (optional) Property's postcode
2 Incorrect UPRN {id} 2023-04-05 12 testy@example.com Address org 12 Some Place Newcastle EC1N 2TD

49
spec/jobs/create_addresses_csv_job_spec.rb
Unescape View File

@ -1,49 +0,0 @@
require "rails_helper"
describe CreateAddressesCsvJob do
include Helpers
let(:job) { described_class.new }
let(:storage_service) { instance_double(Storage::S3Service) }
let(:mailer) { instance_double(CsvDownloadMailer) }
let(:missing_addresses_csv_service) { instance_double(Csv::MissingAddressesCsvService) }
let(:organisation) { build(:organisation) }
let(:users) { create_list(:user, 2) }
before do
allow(Storage::S3Service).to receive(:new).and_return(storage_service)
allow(storage_service).to receive(:write_file)
allow(Csv::MissingAddressesCsvService).to receive(:new).and_return(missing_addresses_csv_service)
allow(missing_addresses_csv_service).to receive(:create_lettings_addresses_csv).and_return("")
allow(missing_addresses_csv_service).to receive(:create_sales_addresses_csv).and_return("")
end
context "when sending all lettings logs csv" do
it "uses an appropriate filename in S3" do
expect(storage_service).to receive(:write_file).with(/lettings-logs-addresses-#{organisation.name}-.*\.csv/, anything)
expect(Rails.logger).to receive(:info).with(/Created addresses file: lettings-logs-addresses-#{organisation.name}-.*\.csv/)
job.perform(organisation, "lettings")
end
it "creates a MissingAddressesCsvService with the correct organisation and calls create all lettings logs adresses csv" do
expect(Csv::MissingAddressesCsvService).to receive(:new).with(organisation, [])
expect(missing_addresses_csv_service).to receive(:create_lettings_addresses_csv)
job.perform(organisation, "lettings")
end
end
context "when sending all sales logs csv" do
it "uses an appropriate filename in S3" do
expect(storage_service).to receive(:write_file).with(/sales-logs-addresses-#{organisation.name}-.*\.csv/, anything)
expect(Rails.logger).to receive(:info).with(/Created addresses file: sales-logs-addresses-#{organisation.name}-.*\.csv/)
job.perform(organisation, "sales")
end
it "creates a MissingAddressesCsvService with the correct organisation and calls create all sales logs adresses csv" do
expect(Csv::MissingAddressesCsvService).to receive(:new).with(organisation, [])
expect(missing_addresses_csv_service).to receive(:create_sales_addresses_csv)
job.perform(organisation, "sales")
end
end
end

66
spec/jobs/email_missing_addresses_csv_job_spec.rb
Unescape View File

@ -1,66 +0,0 @@
require "rails_helper"
describe EmailMissingAddressesCsvJob do
include Helpers
test_url = :test_url
let(:job) { described_class.new }
let(:storage_service) { instance_double(Storage::S3Service) }
let(:mailer) { instance_double(CsvDownloadMailer) }
let(:missing_addresses_csv_service) { instance_double(Csv::MissingAddressesCsvService) }
let(:organisation) { build(:organisation) }
let(:users) { create_list(:user, 2) }
before do
allow(Storage::S3Service).to receive(:new).and_return(storage_service)
allow(storage_service).to receive(:write_file)
allow(storage_service).to receive(:get_presigned_url).and_return(test_url)
allow(Csv::MissingAddressesCsvService).to receive(:new).and_return(missing_addresses_csv_service)
allow(missing_addresses_csv_service).to receive(:create_missing_lettings_addresses_csv).and_return("")
allow(missing_addresses_csv_service).to receive(:create_missing_sales_addresses_csv).and_return("")
allow(CsvDownloadMailer).to receive(:new).and_return(mailer)
allow(mailer).to receive(:send_missing_lettings_addresses_csv_download_mail)
allow(mailer).to receive(:send_missing_sales_addresses_csv_download_mail)
end
context "when sending missing lettings logs csv" do
it "uses an appropriate filename in S3" do
expect(storage_service).to receive(:write_file).with(/missing-lettings-logs-addresses-#{organisation.name}-.*\.csv/, anything)
job.perform(users.map(&:id), organisation, "lettings", %w[missing_address wrong_uprn], [1, 2])
end
it "creates a MissingAddressesCsvService with the correct organisation and calls create missing lettings logs adresses csv" do
expect(Csv::MissingAddressesCsvService).to receive(:new).with(organisation, [1, 2])
expect(missing_addresses_csv_service).to receive(:create_missing_lettings_addresses_csv)
job.perform(users.map(&:id), organisation, "lettings", %w[missing_address wrong_uprn], [1, 2])
end
it "sends emails to all the provided users" do
expect(mailer).to receive(:send_missing_lettings_addresses_csv_download_mail).with(users[0], test_url, instance_of(Integer), %w[missing_address wrong_uprn])
expect(mailer).to receive(:send_missing_lettings_addresses_csv_download_mail).with(users[1], test_url, instance_of(Integer), %w[missing_address wrong_uprn])
job.perform(users.map(&:id), organisation, "lettings", %w[missing_address wrong_uprn], [1, 2])
end
end
context "when sending missing sales logs csv" do
it "uses an appropriate filename in S3" do
expect(storage_service).to receive(:write_file).with(/missing-sales-logs-addresses-#{organisation.name}-.*\.csv/, anything)
job.perform(users.map(&:id), organisation, "sales", %w[missing_town], [2, 3])
end
it "creates a MissingAddressesCsvService with the correct organisation and calls create missing sales logs adresses csv" do
expect(Csv::MissingAddressesCsvService).to receive(:new).with(organisation, [2, 3])
expect(missing_addresses_csv_service).to receive(:create_missing_sales_addresses_csv)
job.perform(users.map(&:id), organisation, "sales", %w[missing_town], [2, 3])
end
it "sends emails to all the provided users" do
expect(mailer).to receive(:send_missing_sales_addresses_csv_download_mail).with(users[0], test_url, instance_of(Integer), %w[missing_town])
expect(mailer).to receive(:send_missing_sales_addresses_csv_download_mail).with(users[1], test_url, instance_of(Integer), %w[missing_town])
job.perform(users.map(&:id), organisation, "sales", %w[missing_town], [2, 3])
end
end
end

522
spec/lib/tasks/correct_address_from_csv_spec.rb
Unescape View File

@ -1,522 +0,0 @@
require "rails_helper"
require "rake"
RSpec.describe "data_import" do
def replace_entity_ids(log, second_log, third_log, fourth_log, export_template)
export_template.sub!(/\{id\}/, log.id.to_s)
export_template.sub!(/\{id2\}/, second_log.id.to_s)
export_template.sub!(/\{id3\}/, third_log.id.to_s)
export_template.sub!(/\{id4\}/, fourth_log.id.to_s)
end
before do
Timecop.freeze(Time.zone.local(2024, 3, 1))
Singleton.__init__(FormHandler)
allow(Storage::S3Service).to receive(:new).and_return(storage_service)
allow(Configuration::EnvConfigurationService).to receive(:new).and_return(env_config_service)
allow(ENV).to receive(:[])
allow(ENV).to receive(:[]).with("BULK_UPLOAD_BUCKET").and_return(instance_name)
allow(ENV).to receive(:[]).with("VCAP_SERVICES").and_return("dummy")
WebMock.stub_request(:get, /api\.postcodes\.io/)
.to_return(status: 200, body: "{\"status\":404,\"error\":\"Postcode not found\"}", headers: {})
WebMock.stub_request(:get, /api\.postcodes\.io\/postcodes\/B11BB/)
.to_return(status: 200, body: '{"status":200,"result":{"admin_district":"Westminster","codes":{"admin_district":"E08000035"}}}', headers: {})
end
after do
Timecop.return
Singleton.__init__(FormHandler)
end
describe ":import_lettings_addresses_from_csv", type: :task do
subject(:task) { Rake::Task["data_import:import_lettings_addresses_from_csv"] }
let(:instance_name) { "import_instance" }
let(:storage_service) { instance_double(Storage::S3Service) }
let(:env_config_service) { instance_double(Configuration::EnvConfigurationService) }
before do
Rake.application.rake_require("tasks/import_address_from_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:addresses_csv_path) { "addresses_reimport_123.csv" }
let(:all_addresses_csv_path) { "all_addresses_reimport_123.csv" }
let(:wrong_file_path) { "/test/no_csv_here.csv" }
let!(:lettings_log) do
create(:lettings_log,
uprn_known: nil,
uprn: nil,
uprn_confirmed: nil,
address_line1: nil,
address_line2: nil,
town_or_city: nil,
county: nil,
postcode_known: 1,
postcode_full: "A1 1AA",
la: "E06000064",
is_la_inferred: true)
end
let!(:lettings_logs) do
logs = build_list(:lettings_log,
3,
:setup_completed,
uprn_known: 1,
uprn: "121",
uprn_confirmed: nil,
address_line1: "wrong address line1",
address_line2: "wrong address 2",
town_or_city: "wrong town",
county: "wrong city",
postcode_known: 1,
postcode_full: "A1 1AA",
la: "E06000064",
is_la_inferred: true)
logs.each { |log| log.save!(validate: false) }
logs
end
before do
allow(storage_service).to receive(:get_file_io)
.with("addresses_reimport_123.csv")
.and_return(StringIO.new(replace_entity_ids(lettings_log, lettings_logs[0], lettings_logs[1], lettings_logs[2], File.open("./spec/fixtures/files/addresses_reimport.csv").read)))
allow(storage_service).to receive(:get_file_io)
.with("all_addresses_reimport_123.csv")
.and_return(StringIO.new(replace_entity_ids(lettings_log, lettings_logs[0], lettings_logs[1], lettings_logs[2], File.open("./spec/fixtures/files/addresses_reimport_all_logs.csv").read)))
end
context "when the file contains issue type column" do
it "updates the log address when old address was not given" do
task.invoke(addresses_csv_path)
lettings_log.reload
expect(lettings_log.uprn_known).to eq(0)
expect(lettings_log.uprn).to eq(nil)
expect(lettings_log.uprn_confirmed).to eq(nil)
expect(lettings_log.address_line1).to eq("address 1")
expect(lettings_log.address_line2).to eq("address 2")
expect(lettings_log.town_or_city).to eq("town")
expect(lettings_log.county).to eq("county")
expect(lettings_log.postcode_known).to eq(1)
expect(lettings_log.postcode_full).to eq("B1 1BB")
expect(lettings_log.la).to eq("E08000035")
expect(lettings_log.is_la_inferred).to eq(true)
end
it "updates the log address when old address was given" do
task.invoke(addresses_csv_path)
lettings_logs[0].reload
expect(lettings_logs[0].uprn_known).to eq(0)
expect(lettings_logs[0].uprn).to eq(nil)
expect(lettings_logs[0].uprn_confirmed).to eq(nil)
expect(lettings_logs[0].address_line1).to eq("address 3")
expect(lettings_logs[0].address_line2).to eq(nil)
expect(lettings_logs[0].town_or_city).to eq("city")
expect(lettings_logs[0].county).to eq(nil)
expect(lettings_logs[0].postcode_known).to eq(1)
expect(lettings_logs[0].postcode_full).to eq("B1 1BB")
expect(lettings_logs[0].la).to eq("E08000035")
expect(lettings_logs[0].is_la_inferred).to eq(true)
end
it "does not update log address when uprn is given" do
task.invoke(addresses_csv_path)
lettings_logs[1].reload
expect(lettings_logs[1].uprn_known).to eq(1)
expect(lettings_logs[1].uprn).to eq("121")
expect(lettings_logs[1].uprn_confirmed).to eq(nil)
expect(lettings_logs[1].address_line1).to eq("wrong address line1")
expect(lettings_logs[1].address_line2).to eq("wrong address 2")
expect(lettings_logs[1].town_or_city).to eq("wrong town")
expect(lettings_logs[1].county).to eq("wrong city")
expect(lettings_logs[1].postcode_known).to eq(1)
expect(lettings_logs[1].postcode_full).to eq("A1 1AA")
expect(lettings_logs[1].la).to eq("E06000064")
end
it "does not update log address when all required address fields are not present" do
task.invoke(addresses_csv_path)
lettings_logs[2].reload
expect(lettings_logs[2].uprn_known).to eq(1)
expect(lettings_logs[2].uprn).to eq("121")
expect(lettings_logs[2].uprn_confirmed).to eq(nil)
expect(lettings_logs[2].address_line1).to eq("wrong address line1")
expect(lettings_logs[2].address_line2).to eq("wrong address 2")
expect(lettings_logs[2].town_or_city).to eq("wrong town")
expect(lettings_logs[2].county).to eq("wrong city")
expect(lettings_logs[2].postcode_known).to eq(1)
expect(lettings_logs[2].postcode_full).to eq("A1 1AA")
expect(lettings_logs[2].la).to eq("E06000064")
end
it "reinfers the LA if the postcode doesn't change" do
lettings_log.update!(postcode_full: "B1 1BB")
task.invoke(addresses_csv_path)
lettings_log.reload
expect(lettings_log.postcode_full).to eq("B1 1BB")
expect(lettings_log.la).to eq("E08000035")
expect(lettings_log.is_la_inferred).to eq(true)
end
it "logs the progress of the update" do
expect(Rails.logger).to receive(:info).with("Updated lettings log #{lettings_log.id}, with address: address 1, address 2, town, county, B1 1BB")
expect(Rails.logger).to receive(:info).with("Updated lettings log #{lettings_logs[0].id}, with address: address 3, , city, , B1 1BB")
expect(Rails.logger).to receive(:info).with("Lettings log with ID #{lettings_logs[1].id} contains uprn, skipping log")
expect(Rails.logger).to receive(:info).with("Lettings log with ID #{lettings_logs[2].id} is missing required address data, skipping log")
expect(Rails.logger).to receive(:info).with("Lettings log ID not provided for address: Some Place, , Bristol, , BS1 1AD")
expect(Rails.logger).to receive(:info).with("Could not find a lettings log with id fake_id")
task.invoke(addresses_csv_path)
end
it "raises an error when no path is given" do
expect { task.invoke(nil) }.to raise_error(RuntimeError, "Usage: rake data_import:import_lettings_addresses_from_csv['csv_file_name']")
end
it "logs an error if a validation fails" do
lettings_log.ppcodenk = 0
lettings_log.ppostcode_full = "invalid_format"
lettings_log.save!(validate: false)
expect(Rails.logger).to receive(:error).with(/Validation failed for lettings log with ID #{lettings_log.id}: Ppostcode full/)
task.invoke(addresses_csv_path)
end
end
context "when the file does not contain issue type column" do
it "updates the log address when old address was not given" do
task.invoke(all_addresses_csv_path)
lettings_log.reload
expect(lettings_log.uprn_known).to eq(0)
expect(lettings_log.uprn).to eq(nil)
expect(lettings_log.uprn_confirmed).to eq(nil)
expect(lettings_log.address_line1).to eq("address 1")
expect(lettings_log.address_line2).to eq("address 2")
expect(lettings_log.town_or_city).to eq("town")
expect(lettings_log.county).to eq("county")
expect(lettings_log.postcode_known).to eq(1)
expect(lettings_log.postcode_full).to eq("B1 1BB")
expect(lettings_log.la).to eq("E08000035")
expect(lettings_log.is_la_inferred).to eq(true)
end
it "updates the log address when old address was given" do
task.invoke(all_addresses_csv_path)
lettings_logs[0].reload
expect(lettings_logs[0].uprn_known).to eq(0)
expect(lettings_logs[0].uprn).to eq(nil)
expect(lettings_logs[0].uprn_confirmed).to eq(nil)
expect(lettings_logs[0].address_line1).to eq("address 3")
expect(lettings_logs[0].address_line2).to eq(nil)
expect(lettings_logs[0].town_or_city).to eq("city")
expect(lettings_logs[0].county).to eq(nil)
expect(lettings_logs[0].postcode_known).to eq(1)
expect(lettings_logs[0].postcode_full).to eq("B1 1BB")
expect(lettings_logs[0].la).to eq("E08000035")
expect(lettings_logs[0].is_la_inferred).to eq(true)
end
it "does not update log address when uprn is given" do
task.invoke(all_addresses_csv_path)
lettings_logs[1].reload
expect(lettings_logs[1].uprn_known).to eq(1)
expect(lettings_logs[1].uprn).to eq("121")
expect(lettings_logs[1].uprn_confirmed).to eq(nil)
expect(lettings_logs[1].address_line1).to eq("wrong address line1")
expect(lettings_logs[1].address_line2).to eq("wrong address 2")
expect(lettings_logs[1].town_or_city).to eq("wrong town")
expect(lettings_logs[1].county).to eq("wrong city")
expect(lettings_logs[1].postcode_known).to eq(1)
expect(lettings_logs[1].postcode_full).to eq("A1 1AA")
expect(lettings_logs[1].la).to eq("E06000064")
end
it "does not update log address when all required address fields are not present" do
task.invoke(all_addresses_csv_path)
lettings_logs[2].reload
expect(lettings_logs[2].uprn_known).to eq(1)
expect(lettings_logs[2].uprn).to eq("121")
expect(lettings_logs[2].uprn_confirmed).to eq(nil)
expect(lettings_logs[2].address_line1).to eq("wrong address line1")
expect(lettings_logs[2].address_line2).to eq("wrong address 2")
expect(lettings_logs[2].town_or_city).to eq("wrong town")
expect(lettings_logs[2].county).to eq("wrong city")
expect(lettings_logs[2].postcode_known).to eq(1)
expect(lettings_logs[2].postcode_full).to eq("A1 1AA")
expect(lettings_logs[2].la).to eq("E06000064")
end
it "reinfers the LA if the postcode hasn't changed" do
lettings_log.update!(postcode_full: "B1 1BB")
task.invoke(all_addresses_csv_path)
lettings_log.reload
expect(lettings_log.postcode_full).to eq("B1 1BB")
expect(lettings_log.la).to eq("E08000035")
expect(lettings_log.is_la_inferred).to eq(true)
end
it "logs the progress of the update" do
expect(Rails.logger).to receive(:info).with("Updated lettings log #{lettings_log.id}, with address: address 1, address 2, town, county, B1 1BB")
expect(Rails.logger).to receive(:info).with("Updated lettings log #{lettings_logs[0].id}, with address: address 3, , city, , B1 1BB")
expect(Rails.logger).to receive(:info).with("Lettings log with ID #{lettings_logs[1].id} contains uprn, skipping log")
expect(Rails.logger).to receive(:info).with("Lettings log with ID #{lettings_logs[2].id} is missing required address data, skipping log")
expect(Rails.logger).to receive(:info).with("Lettings log ID not provided for address: Some Place, , Bristol, , BS1 1AD")
expect(Rails.logger).to receive(:info).with("Could not find a lettings log with id fake_id")
task.invoke(all_addresses_csv_path)
end
it "raises an error when no path is given" do
expect { task.invoke(nil) }.to raise_error(RuntimeError, "Usage: rake data_import:import_lettings_addresses_from_csv['csv_file_name']")
end
it "logs an error if a validation fails" do
lettings_log.ppcodenk = 0
lettings_log.ppostcode_full = "invalid_format"
lettings_log.save!(validate: false)
expect(Rails.logger).to receive(:error).with(/Validation failed for lettings log with ID #{lettings_log.id}: Ppostcode full/)
task.invoke(addresses_csv_path)
end
end
end
end
describe ":import_sales_addresses_from_csv", type: :task do
subject(:task) { Rake::Task["data_import:import_sales_addresses_from_csv"] }
let(:instance_name) { "import_instance" }
let(:storage_service) { instance_double(Storage::S3Service) }
let(:env_config_service) { instance_double(Configuration::EnvConfigurationService) }
before do
Rake.application.rake_require("tasks/import_address_from_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:addresses_csv_path) { "addresses_reimport_123.csv" }
let(:all_addresses_csv_path) { "all_addresses_reimport_123.csv" }
let(:wrong_file_path) { "/test/no_csv_here.csv" }
let!(:sales_log) do
create(:sales_log,
:completed,
uprn_known: nil,
uprn: nil,
uprn_confirmed: nil,
address_line1: nil,
address_line2: nil,
town_or_city: nil,
la: "E06000064",
is_la_inferred: true)
end
let!(:sales_logs) { create_list(:sales_log, 3, :completed, uprn_known: 1, uprn: "121", la: "E06000064", is_la_inferred: true) }
before do
allow(storage_service).to receive(:get_file_io)
.with("addresses_reimport_123.csv")
.and_return(StringIO.new(replace_entity_ids(sales_log, sales_logs[0], sales_logs[1], sales_logs[2], File.open("./spec/fixtures/files/sales_addresses_reimport.csv").read)))
allow(storage_service).to receive(:get_file_io)
.with("all_addresses_reimport_123.csv")
.and_return(StringIO.new(replace_entity_ids(sales_log, sales_logs[0], sales_logs[1], sales_logs[2], File.open("./spec/fixtures/files/sales_addresses_reimport_all_logs.csv").read)))
end
context "when the file contains issue type column" do
it "updates the log address when old address was not given" do
task.invoke(addresses_csv_path)
sales_log.reload
expect(sales_log.uprn_known).to eq(0)
expect(sales_log.uprn).to eq(nil)
expect(sales_log.uprn_confirmed).to eq(nil)
expect(sales_log.address_line1).to eq("address 1")
expect(sales_log.address_line2).to eq("address 2")
expect(sales_log.town_or_city).to eq("town")
expect(sales_log.county).to eq("county")
expect(sales_log.pcodenk).to eq(0)
expect(sales_log.postcode_full).to eq("B1 1BB")
expect(sales_log.la).to eq("E08000035")
expect(sales_log.is_la_inferred).to eq(true)
end
it "updates the log address when old address was given" do
task.invoke(addresses_csv_path)
sales_logs[0].reload
expect(sales_logs[0].uprn_known).to eq(0)
expect(sales_logs[0].uprn).to eq(nil)
expect(sales_logs[0].uprn_confirmed).to eq(nil)
expect(sales_logs[0].address_line1).to eq("address 3")
expect(sales_logs[0].address_line2).to eq(nil)
expect(sales_logs[0].town_or_city).to eq("city")
expect(sales_logs[0].county).to eq(nil)
expect(sales_logs[0].pcodenk).to eq(0)
expect(sales_logs[0].postcode_full).to eq("B1 1BB")
expect(sales_logs[0].la).to eq("E08000035")
expect(sales_logs[0].is_la_inferred).to eq(true)
end
it "does not update log address when uprn is given" do
task.invoke(addresses_csv_path)
sales_logs[1].reload
expect(sales_logs[1].uprn_known).to eq(1)
expect(sales_logs[1].uprn).to eq("121")
expect(sales_logs[1].uprn_confirmed).to eq(nil)
expect(sales_logs[1].address_line1).to eq("Wrong Address Line1")
expect(sales_logs[1].address_line2).to eq("Double Dependent Locality")
expect(sales_logs[1].town_or_city).to eq("Westminster")
expect(sales_logs[1].county).to eq(nil)
expect(sales_logs[1].pcodenk).to eq(0)
expect(sales_logs[1].postcode_full).to eq("LS16 6FT")
expect(sales_logs[1].la).to eq("E06000064")
end
it "does not update log address when all required address fields are not present" do
task.invoke(addresses_csv_path)
sales_logs[2].reload
expect(sales_logs[2].uprn_known).to eq(1)
expect(sales_logs[2].uprn).to eq("121")
expect(sales_logs[2].uprn_confirmed).to eq(nil)
expect(sales_logs[2].address_line1).to eq("Wrong Address Line1")
expect(sales_logs[2].address_line2).to eq("Double Dependent Locality")
expect(sales_logs[2].town_or_city).to eq("Westminster")
expect(sales_logs[2].county).to eq(nil)
expect(sales_logs[2].pcodenk).to eq(0)
expect(sales_logs[2].postcode_full).to eq("LS16 6FT")
expect(sales_logs[2].la).to eq("E06000064")
end
it "reinfers the LA if the postcode hasn't changed" do
sales_log.update!(postcode_full: "B1 1BB")
task.invoke(addresses_csv_path)
sales_log.reload
expect(sales_log.postcode_full).to eq("B1 1BB")
expect(sales_log.la).to eq("E08000035")
expect(sales_log.is_la_inferred).to eq(true)
end
it "logs the progress of the update" do
expect(Rails.logger).to receive(:info).with("Updated sales log #{sales_log.id}, with address: address 1, address 2, town, county, B1 1BB")
expect(Rails.logger).to receive(:info).with("Updated sales log #{sales_logs[0].id}, with address: address 3, , city, , B1 1BB")
expect(Rails.logger).to receive(:info).with("Sales log with ID #{sales_logs[1].id} contains uprn, skipping log")
expect(Rails.logger).to receive(:info).with("Sales log with ID #{sales_logs[2].id} is missing required address data, skipping log")
expect(Rails.logger).to receive(:info).with("Sales log ID not provided for address: Some Place, , Bristol, , BS1 1AD")
expect(Rails.logger).to receive(:info).with("Could not find a sales log with id fake_id")
task.invoke(addresses_csv_path)
end
it "raises an error when no path is given" do
expect { task.invoke(nil) }.to raise_error(RuntimeError, "Usage: rake data_import:import_sales_addresses_from_csv['csv_file_name']")
end
it "logs an error if a validation fails" do
sales_log.ppcodenk = 0
sales_log.ppostcode_full = "invalid_format"
sales_log.save!(validate: false)
expect(Rails.logger).to receive(:error).with(/Validation failed for sales log with ID #{sales_log.id}: Ppostcode full/)
task.invoke(addresses_csv_path)
end
end
context "when the file does not contain issue type column" do
it "updates the log address when old address was not given" do
task.invoke(all_addresses_csv_path)
sales_log.reload
expect(sales_log.uprn_known).to eq(0)
expect(sales_log.uprn).to eq(nil)
expect(sales_log.uprn_confirmed).to eq(nil)
expect(sales_log.address_line1).to eq("address 1")
expect(sales_log.address_line2).to eq("address 2")
expect(sales_log.town_or_city).to eq("town")
expect(sales_log.county).to eq("county")
expect(sales_log.pcodenk).to eq(0)
expect(sales_log.postcode_full).to eq("B1 1BB")
expect(sales_log.la).to eq("E08000035")
expect(sales_log.is_la_inferred).to eq(true)
end
it "updates the log address when old address was given" do
task.invoke(all_addresses_csv_path)
sales_logs[0].reload
expect(sales_logs[0].uprn_known).to eq(0)
expect(sales_logs[0].uprn).to eq(nil)
expect(sales_logs[0].uprn_confirmed).to eq(nil)
expect(sales_logs[0].address_line1).to eq("address 3")
expect(sales_logs[0].address_line2).to eq(nil)
expect(sales_logs[0].town_or_city).to eq("city")
expect(sales_logs[0].county).to eq(nil)
expect(sales_logs[0].pcodenk).to eq(0)
expect(sales_logs[0].postcode_full).to eq("B1 1BB")
expect(sales_logs[0].la).to eq("E08000035")
expect(sales_logs[0].is_la_inferred).to eq(true)
end
it "does not update log address when uprn is given" do
task.invoke(all_addresses_csv_path)
sales_logs[1].reload
expect(sales_logs[1].uprn_known).to eq(1)
expect(sales_logs[1].uprn).to eq("121")
expect(sales_logs[1].uprn_confirmed).to eq(nil)
expect(sales_logs[1].address_line1).to eq("Wrong Address Line1")
expect(sales_logs[1].address_line2).to eq("Double Dependent Locality")
expect(sales_logs[1].town_or_city).to eq("Westminster")
expect(sales_logs[1].county).to eq(nil)
expect(sales_logs[1].pcodenk).to eq(0)
expect(sales_logs[1].postcode_full).to eq("LS16 6FT")
expect(sales_logs[1].la).to eq("E06000064")
end
it "does not update log address when all required address fields are not present" do
task.invoke(all_addresses_csv_path)
sales_logs[2].reload
expect(sales_logs[2].uprn_known).to eq(1)
expect(sales_logs[2].uprn).to eq("121")
expect(sales_logs[2].uprn_confirmed).to eq(nil)
expect(sales_logs[2].address_line1).to eq("Wrong Address Line1")
expect(sales_logs[2].address_line2).to eq("Double Dependent Locality")
expect(sales_logs[2].town_or_city).to eq("Westminster")
expect(sales_logs[2].county).to eq(nil)
expect(sales_logs[2].pcodenk).to eq(0)
expect(sales_logs[2].postcode_full).to eq("LS16 6FT")
expect(sales_logs[2].la).to eq("E06000064")
end
it "reinfers the LA if the postcode hasn't changed" do
sales_log.update!(postcode_full: "B1 1BB")
task.invoke(all_addresses_csv_path)
sales_log.reload
expect(sales_log.postcode_full).to eq("B1 1BB")
expect(sales_log.la).to eq("E08000035")
expect(sales_log.is_la_inferred).to eq(true)
end
it "logs the progress of the update" do
expect(Rails.logger).to receive(:info).with("Updated sales log #{sales_log.id}, with address: address 1, address 2, town, county, B1 1BB")
expect(Rails.logger).to receive(:info).with("Updated sales log #{sales_logs[0].id}, with address: address 3, , city, , B1 1BB")
expect(Rails.logger).to receive(:info).with("Sales log with ID #{sales_logs[1].id} contains uprn, skipping log")
expect(Rails.logger).to receive(:info).with("Sales log with ID #{sales_logs[2].id} is missing required address data, skipping log")
expect(Rails.logger).to receive(:info).with("Sales log ID not provided for address: Some Place, , Bristol, , BS1 1AD")
expect(Rails.logger).to receive(:info).with("Could not find a sales log with id fake_id")
task.invoke(all_addresses_csv_path)
end
it "raises an error when no path is given" do
expect { task.invoke(nil) }.to raise_error(RuntimeError, "Usage: rake data_import:import_sales_addresses_from_csv['csv_file_name']")
end
it "logs an error if a validation fails" do
sales_log.ppcodenk = 0
sales_log.ppostcode_full = "invalid_format"
sales_log.save!(validate: false)
expect(Rails.logger).to receive(:error).with(/Validation failed for sales log with ID #{sales_log.id}: Ppostcode full/)
task.invoke(addresses_csv_path)
end
end
end
end
end

519
spec/lib/tasks/send_missing_addresses_csv_spec.rb
Unescape View File

@ -1,519 +0,0 @@
require "rails_helper"
require "rake"
RSpec.describe "correct_addresses" do
around do |example|
Timecop.freeze(Time.zone.local(2023, 10, 10)) do
Singleton.__init__(FormHandler)
example.run
end
end
describe ":send_missing_addresses_lettings_csv", type: :task do
subject(:task) { Rake::Task["correct_addresses:send_missing_addresses_lettings_csv"] }
before do
organisation.users.destroy_all
Rake.application.rake_require("tasks/send_missing_addresses_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:organisation) { create(:organisation, name: "test organisation") }
before do
stub_const("EmailMissingAddressesCsvJob::MISSING_ADDRESSES_THRESHOLD", 5)
end
context "when org has more than 5 missing addresses and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:lettings_log, 7, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, needstype: 1, old_form_id: "form_1", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "lettings", %w[missing_address], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 missing addresses and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 5, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, needstype: 1, old_form_id: "form_2", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[missing_address], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 missing addresses" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:lettings_log, 3, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, needstype: 1, old_form_id: "form_2", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
create_list(:lettings_log, 2, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: nil, needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job with organisations that is missing less addresses than threshold amount" do
expect { task.invoke }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when org has more than 5 missing town_or_city and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:lettings_log, 7, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: "exists", town_or_city: nil, needstype: 1, old_form_id: "form_1", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "lettings", %w[missing_town], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 missing town or city and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 5, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: "exists", town_or_city: nil, needstype: 1, old_form_id: "form_2", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[missing_town], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 missing town or city" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:lettings_log, 3, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: "address", town_or_city: nil, needstype: 1, old_form_id: "form_2", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
create_list(:lettings_log, 2, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: "address", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job with organisations that is missing less town or city data than threshold amount" do
expect { task.invoke }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when org has more than 5 wrong uprn and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:lettings_log, 7, :imported, :setup_completed, startdate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "123", town_or_city: "Bristol", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "lettings", %w[bristol_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 wrong uprn and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 5, :imported, :setup_completed, startdate: Time.zone.local(2023, 9, 9), uprn: "12", propcode: "12", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[wrong_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 wrong uprn" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 3, :imported, :setup_completed, startdate: Time.zone.local(2023, 9, 9), uprn: "123", town_or_city: "Bristol", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
create_list(:lettings_log, 2, :imported, :setup_completed, startdate: Time.zone.local(2023, 9, 9), uprn: "12", tenancycode: "12", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[wrong_uprn bristol_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing lettings addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org is included in skip_uprn_issue_organisations list" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:lettings_log, 5, :imported, startdate: Time.zone.local(2023, 9, 9), uprn: "12", propcode: "12", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job" do
expect { task.invoke(organisation.id.to_s) }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when org is included in skip_uprn_issue_organisations list but faces a different issue" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 5, :imported, startdate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, needstype: 1, old_form_id: "form_2", owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
create_list(:lettings_log, 5, :imported, startdate: Time.zone.local(2023, 9, 9), uprn: "12", propcode: "12", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job" do
expect { task.invoke(organisation.id.to_s) }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[missing_address], [organisation.id])
end
end
context "when skip_uprn_issue_organisations list is provided" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:lettings_log, 5, :imported, :setup_completed, startdate: Time.zone.local(2023, 9, 9), uprn: "12", propcode: "12", needstype: 1, owning_organisation: organisation, managing_organisation: organisation, assigned_to: data_provider)
end
it "does enqueues the job with correct skip_uprn_issue_organisations" do
expect { task.invoke("100 400") }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "lettings", %w[wrong_uprn], [100, 400])
end
end
end
end
describe ":send_missing_addresses_sales_csv", type: :task do
subject(:task) { Rake::Task["correct_addresses:send_missing_addresses_sales_csv"] }
before do
organisation.users.destroy_all
Rake.application.rake_require("tasks/send_missing_addresses_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:organisation) { create(:organisation, name: "test organisation") }
before do
stub_const("EmailMissingAddressesCsvJob::MISSING_ADDRESSES_THRESHOLD", 5)
end
context "when org has more than 5 missing addresses and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:sales_log, 7, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, old_form_id: "form_1", owning_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke("70 90") }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "sales", %w[missing_address], [70, 90])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 missing addresses and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:sales_log, 5, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, old_form_id: "form_2", owning_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "sales", %w[missing_address], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 missing addresses" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:sales_log, 3, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: nil, town_or_city: nil, old_form_id: "form_2", owning_organisation: organisation, assigned_to: data_provider)
create_list(:sales_log, 2, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: nil, owning_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job with organisations that is missing less addresses than threshold amount" do
expect { task.invoke }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when org has more than 5 missing town_or_city and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:sales_log, 7, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: "exists", town_or_city: nil, old_form_id: "form_1", owning_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "sales", %w[missing_town], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 missing town or city and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:sales_log, 5, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: "exists", town_or_city: nil, old_form_id: "form_2", owning_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "sales", %w[missing_town], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 missing town or city" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:sales_log, 3, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: "address", town_or_city: nil, old_form_id: "form_2", owning_organisation: organisation, assigned_to: data_provider)
create_list(:sales_log, 2, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), address_line1: "address", owning_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job with organisations that is missing less town or city data than threshold amount" do
expect { task.invoke }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when org has more than 5 wrong uprn and data coordinators" do
let!(:data_coordinator) { create(:user, :data_coordinator, organisation:, email: "data_coordinator1@example.com") }
let!(:data_coordinator2) { create(:user, :data_coordinator, organisation:, email: "data_coordinator2@example.com") }
before do
create(:user, :data_provider, organisation:, email: "data_provider1@example.com")
create_list(:sales_log, 7, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "123", town_or_city: "Bristol", owning_organisation: organisation, assigned_to: data_coordinator)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_coordinator.id, data_coordinator2.id), organisation, "sales", %w[wrong_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_coordinator1@example\.com, data_coordinator2@example\.com|data_coordinator2@example\.com, data_coordinator1@example\.com)$/))
task.invoke
end
end
context "when org has 5 wrong uprn and data providers only" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:sales_log, 5, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "12", purchid: "12", owning_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "sales", %w[wrong_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org has less than 5 wrong uprn" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:sales_log, 3, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "123", town_or_city: "Bristol", owning_organisation: organisation, assigned_to: data_provider)
create_list(:sales_log, 2, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "12", purchid: "12", owning_organisation: organisation, assigned_to: data_provider)
end
it "enqueues the job with correct organisations" do
expect { task.invoke }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "sales", %w[wrong_uprn], [])
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with(match(/^Sending missing sales addresses CSV for test organisation to (?:data_provider3@example\.com, data_provider4@example\.com|data_provider4@example\.com, data_provider3@example\.com)$/))
task.invoke
end
end
context "when org is included in skip_uprn_issue_organisations list" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
before do
create_list(:sales_log, 5, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "12", purchid: "12", owning_organisation: organisation, assigned_to: data_provider)
end
it "does not enqueue the job" do
expect { task.invoke("#{organisation.id} 4") }.not_to enqueue_job(EmailMissingAddressesCsvJob)
end
end
context "when skip_uprn_issue_organisations list is provided" do
let!(:data_provider) { create(:user, :data_provider, organisation:, email: "data_provider3@example.com") }
let!(:data_provider2) { create(:user, :data_provider, organisation:, email: "data_provider4@example.com") }
before do
create_list(:sales_log, 5, :completed, :imported, saledate: Time.zone.local(2023, 9, 9), uprn_known: 1, uprn: "12", purchid: "12", owning_organisation: organisation, assigned_to: data_provider)
end
it "does enqueues the job with correct skip_uprn_issue_organisations" do
expect { task.invoke("100 400") }.to enqueue_job(EmailMissingAddressesCsvJob).with(include(data_provider.id, data_provider2.id), organisation, "sales", %w[wrong_uprn], [100, 400])
end
end
end
end
describe ":create_lettings_addresses_csv", type: :task do
subject(:task) { Rake::Task["correct_addresses:create_lettings_addresses_csv"] }
before do
organisation.users.destroy_all
Rake.application.rake_require("tasks/send_missing_addresses_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:organisation) { create(:organisation, name: "test organisation") }
context "and organisation ID is provided" do
it "enqueues the job with correct organisation" do
expect { task.invoke(organisation.id) }.to enqueue_job(CreateAddressesCsvJob).with(organisation, "lettings")
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with("Creating lettings addresses CSV for test organisation")
task.invoke(organisation.id)
end
end
context "when organisation with given ID cannot be found" do
it "prints out error" do
expect(Rails.logger).to receive(:error).with("Organisation with ID fake not found")
task.invoke("fake")
end
end
context "when organisation ID is not given" do
it "raises an error" do
expect { task.invoke }.to raise_error(RuntimeError, "Usage: rake correct_addresses:create_lettings_addresses_csv['organisation_id']")
end
end
end
end
describe ":create_sales_addresses_csv", type: :task do
subject(:task) { Rake::Task["correct_addresses:create_sales_addresses_csv"] }
before do
organisation.users.destroy_all
Rake.application.rake_require("tasks/send_missing_addresses_csv")
Rake::Task.define_task(:environment)
task.reenable
end
context "when the rake task is run" do
let(:organisation) { create(:organisation, name: "test organisation") }
context "and organisation ID is provided" do
it "enqueues the job with correct organisation" do
expect { task.invoke(organisation.id) }.to enqueue_job(CreateAddressesCsvJob).with(organisation, "sales")
end
it "prints out the jobs enqueued" do
expect(Rails.logger).to receive(:info).with(nil)
expect(Rails.logger).to receive(:info).with("Creating sales addresses CSV for test organisation")
task.invoke(organisation.id)
end
end
context "when organisation with given ID cannot be found" do
it "prints out error" do
expect(Rails.logger).to receive(:error).with("Organisation with ID fake not found")
task.invoke("fake")
end
end
context "when organisation ID is not given" do
it "raises an error" do
expect { task.invoke }.to raise_error(RuntimeError, "Usage: rake correct_addresses:create_sales_addresses_csv['organisation_id']")
end
end
end
end
end

4
spec/models/form/lettings/questions/stock_owner_spec.rb
Unescape View File

@ -51,7 +51,7 @@ RSpec.describe Form::Lettings::Questions::StockOwner, type: :model do
let!(:org_rel) do
create(:organisation_relationship, child_organisation: user.organisation, parent_organisation: owning_org_2)
end
let(:log) { create(:lettings_log, owning_organisation: owning_org_1) }
let(:log) { build(:lettings_log, owning_organisation: owning_org_1) }
context "when user's org owns stock" do
let(:options) do
@ -201,7 +201,7 @@ RSpec.describe Form::Lettings::Questions::StockOwner, type: :model do
context "when user is support" do
let!(:user) { create(:user, :support) }
let!(:log) { create(:lettings_log) }
let!(:log) { build(:lettings_log, assigned_to: create(:user)) }
it "shows active orgs where organisation holds own stock" do
non_stock_organisation = create(:organisation, name: "Non-stockholding org", holds_own_stock: false)

74
spec/models/sales_log_spec.rb
Unescape View File

@ -6,16 +6,6 @@ RSpec.describe SalesLog, type: :model do
let(:owning_organisation) { create(:organisation) }
let(:assigned_to_user) { create(:user) }
before do
Timecop.freeze(Time.zone.local(2024, 3, 1))
Singleton.__init__(FormHandler)
end
after do
Timecop.return
Singleton.__init__(FormHandler)
end
include_examples "shared log examples", :sales_log
it "inherits from log" do
@ -143,11 +133,7 @@ RSpec.describe SalesLog, type: :model do
context "when proplen is not given" do
before do
Timecop.freeze(Time.zone.local(2023, 5, 1))
end
after do
Timecop.unfreeze
allow(Time).to receive(:now).and_return(Time.zone.local(2023, 5, 1))
end
it "is set to completed for a log with a saledate before 23/24" do
@ -232,18 +218,16 @@ RSpec.describe SalesLog, type: :model do
context "when filtering by year or nil" do
before do
Timecop.freeze(Time.utc(2021, 5, 3))
create(:sales_log, :in_progress, saledate: nil)
create(:sales_log, :in_progress, saledate: Time.zone.local(2021, 4, 1))
sales_log_3 = create(:sales_log, :in_progress)
sales_log_2021 = build(:sales_log, :in_progress)
sales_log_2021.saledate = Time.zone.local(2021, 4, 1)
sales_log_2021.save!(validate: false)
sales_log_3 = build(:sales_log, :in_progress)
sales_log_3.saledate = Time.zone.local(2022, 5, 1)
sales_log_3.save!(validate: false)
end
after do
Timecop.unfreeze
end
it "allows filtering on a single year or nil" do
expect(described_class.filter_by_years_or_nil(%w[2021]).count).to eq(2)
end
@ -580,36 +564,6 @@ RSpec.describe SalesLog, type: :model do
expect(record_from_db["la"]).to eq("E08000003")
end
context "with 22/23 logs" do
let(:address_sales_log_22_23) do
described_class.create({
owning_organisation:,
assigned_to: assigned_to_user,
ppcodenk: 1,
postcode_full: "CA10 1AA",
saledate: Time.zone.local(2022, 5, 2),
})
end
before do
WebMock.stub_request(:get, /api\.postcodes\.io\/postcodes\/CA101AA/)
.to_return(status: 200, body: '{"status":200,"result":{"admin_district":"Cumberland","codes":{"admin_district":"E06000064"}}}', headers: {})
Timecop.freeze(2023, 5, 1)
Singleton.__init__(FormHandler)
end
after do
Timecop.unfreeze
end
it "correctly sets la as nil" do
record_from_db = described_class.find(address_sales_log_22_23.id)
expect(address_sales_log_22_23.la).to eq(nil)
expect(record_from_db["la"]).to eq(nil)
end
end
context "with 23/24 logs" do
let(:address_sales_log_23_24) do
described_class.create({
@ -624,13 +578,6 @@ RSpec.describe SalesLog, type: :model do
before do
WebMock.stub_request(:get, /api\.postcodes\.io\/postcodes\/CA101AA/)
.to_return(status: 200, body: '{"status":200,"result":{"admin_district":"Eden","codes":{"admin_district":"E07000030"}}}', headers: {})
Timecop.freeze(2023, 5, 2)
Singleton.__init__(FormHandler)
end
after do
Timecop.unfreeze
end
it "correctly infers new la" do
@ -664,13 +611,6 @@ RSpec.describe SalesLog, type: :model do
before do
WebMock.stub_request(:get, /api\.postcodes\.io\/postcodes\/CA101AA/)
.to_return(status: 200, body: '{"status":200,"result":{"admin_district":"Eden","codes":{"admin_district":"E07000030"}}}', headers: {})
Timecop.freeze(2024, 5, 2)
Singleton.__init__(FormHandler)
end
after do
Timecop.unfreeze
end
it "sets previous postcode for discounted sale" do
@ -983,7 +923,7 @@ RSpec.describe SalesLog, type: :model do
end
context "when searching logs" do
let!(:sales_log_to_search) { create(:sales_log, :completed, purchid: "to search", postcode_full: "ME0 0WW") }
let!(:sales_log_to_search) { create(:sales_log, purchid: "to search", postcode_full: "ME0 0WW") }
before do
create_list(:sales_log, 5, :completed)

18
spec/models/validations/sales/setup_validations_spec.rb
Unescape View File

@ -67,9 +67,13 @@ RSpec.describe Validations::Sales::SetupValidations do
end
end
context "when saledate is in the 22/23 collection year" do
context "when saledate is in an open previous collection year" do
let(:record) { build(:sales_log, saledate: Time.zone.local(2024, 1, 1)) }
before do
allow(FormHandler.instance).to receive(:sales_in_crossover_period?).and_return(true)
end
it "does not add an error" do
setup_validator.validate_saledate_collection_year(record)
@ -77,9 +81,13 @@ RSpec.describe Validations::Sales::SetupValidations do
end
end
context "when saledate is before the 22/23 collection year" do
context "when saledate is before an open collection year" do
let(:record) { build(:sales_log, saledate: Time.zone.local(2020, 5, 1)) }
before do
allow(FormHandler.instance).to receive(:sales_in_crossover_period?).and_return(true)
end
it "adds error" do
setup_validator.validate_saledate_collection_year(record)
@ -87,9 +95,13 @@ RSpec.describe Validations::Sales::SetupValidations do
end
end
context "when saledate is after the 22/23 collection year" do
context "when saledate is after an open collection year" do
let(:record) { build(:sales_log, saledate: Time.zone.local(2025, 4, 1)) }
before do
allow(FormHandler.instance).to receive(:sales_in_crossover_period?).and_return(true)
end
it "adds error" do
setup_validator.validate_saledate_collection_year(record)

504
spec/services/csv/missing_addresses_csv_service_spec.rb
Unescape View File

@ -1,504 +0,0 @@
require "rails_helper"
RSpec.describe Csv::MissingAddressesCsvService do
let(:organisation) { create(:organisation, name: "Address org") }
let(:user) { create(:user, organisation:, email: "testy@example.com") }
let(:service) { described_class.new(organisation, skip_uprn_issue_organisations) }
let(:skip_uprn_issue_organisations) { [100, 200] }
around do |example|
Timecop.freeze(Time.zone.local(2023, 4, 5)) do
Singleton.__init__(FormHandler)
example.run
end
end
def replace_entity_ids(lettings_log, export_template)
export_template.sub!(/\{id\}/, lettings_log.id.to_s)
end
describe "#create_missing_lettings_addresses_csv" do
let!(:lettings_log) do
create(:lettings_log,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
address_line1: nil,
town_or_city: nil,
old_id: "old_id",
old_form_id: "old_form_id",
needstype: 1,
uprn_known: 0)
end
let!(:lettings_log_missing_town) do
create(:lettings_log,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
address_line1: "existing address",
town_or_city: nil,
old_id: "older_id",
old_form_id: "old_form_id",
needstype: 1,
uprn_known: 0)
end
let!(:lettings_log_wrong_uprn) do
create(:lettings_log,
:completed,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
uprn: "123",
uprn_known: 1,
old_id: "oldest_id",
needstype: 1)
end
context "when the organisation has logs with missing addresses, missing town or city and wrong uprn" do
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(lettings_log, File.open("spec/fixtures/files/missing_lettings_logs_addresses_all_issues.csv").read)
expected_content = replace_entity_ids(lettings_log_missing_town, expected_content)
expected_content = replace_entity_ids(lettings_log_wrong_uprn, expected_content)
csv = service.create_missing_lettings_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with missing addresses only" do
before do
lettings_log_missing_town.update!(town_or_city: "towncity")
lettings_log_wrong_uprn.update!(uprn: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(lettings_log, File.open("spec/fixtures/files/missing_lettings_logs_addresses.csv").read)
csv = service.create_missing_lettings_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with missing town or city only" do
before do
lettings_log.update!(address_line1: "existing address", town_or_city: "towncity")
lettings_log_wrong_uprn.update!(uprn: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(lettings_log_missing_town, File.open("spec/fixtures/files/missing_lettings_logs_town_or_city.csv").read)
csv = service.create_missing_lettings_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with wrong uprn only" do
before do
lettings_log.update!(address_line1: "existing address", town_or_city: "towncity")
lettings_log_missing_town.update!(town_or_city: "towncity")
lettings_log_wrong_uprn.update!(uprn_known: 1, uprn: "12", propcode: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(lettings_log_wrong_uprn, File.open("spec/fixtures/files/missing_lettings_logs_wrong_uprn.csv").read)
csv = service.create_missing_lettings_addresses_csv
expect(csv).to eq(expected_content)
end
context "and the organisation is marked as an organisation to skip" do
let(:skip_uprn_issue_organisations) { [organisation.id] }
it "returns nil" do
expect(service.create_missing_lettings_addresses_csv).to be_nil
end
end
end
context "when the organisation only has supported housing logs with missing addresses or town or city" do
before do
lettings_log.update!(needstype: 2)
lettings_log_missing_town.update!(needstype: 2)
lettings_log_wrong_uprn.update!(needstype: 2)
end
it "returns nil" do
expect(service.create_missing_lettings_addresses_csv).to be_nil
end
end
context "when the organisation only has logs with missing addresses or town or city from 2022" do
before do
lettings_log.startdate = Time.zone.local(2022, 4, 5)
lettings_log.save!(validate: false)
lettings_log_missing_town.startdate = Time.zone.local(2022, 4, 5)
lettings_log_missing_town.save!(validate: false)
lettings_log_wrong_uprn.startdate = Time.zone.local(2022, 4, 5)
lettings_log_wrong_uprn.save!(validate: false)
end
it "returns nil" do
expect(service.create_missing_lettings_addresses_csv).to be_nil
end
end
context "when the organisation has any address and town or city fields filled in or correct uprn" do
before do
lettings_log.update!(address_line1: "address_line1", town_or_city: "towncity")
lettings_log_missing_town.update!(address_line1: "address_line1", town_or_city: "towncity")
lettings_log_wrong_uprn.update!(uprn: "12")
end
it "returns nil" do
expect(service.create_missing_lettings_addresses_csv).to be_nil
end
end
end
describe "#create_missing_sales_addresses_csv" do
let!(:sales_log) do
create(:sales_log,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
address_line1: nil,
town_or_city: nil,
old_id: "old_id",
old_form_id: "old_form_id",
uprn_known: 0)
end
let!(:sales_log_missing_town) do
create(:sales_log,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
address_line1: "existing address line 1",
town_or_city: nil,
old_id: "older_id",
old_form_id: "old_form_id",
uprn_known: 0)
end
let!(:sales_log_wrong_uprn) do
create(:sales_log,
:completed,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
uprn: "123",
town_or_city: "Bristol",
old_id: "oldest_id",
uprn_known: 1,
uprn_confirmed: 1,
la: nil)
end
context "when the organisation has logs with missing addresses, town or city and wrong uprn" do
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(sales_log, File.open("spec/fixtures/files/missing_sales_logs_addresses_all_issues.csv").read)
expected_content = replace_entity_ids(sales_log_missing_town, expected_content)
expected_content = replace_entity_ids(sales_log_wrong_uprn, expected_content)
csv = service.create_missing_sales_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with missing addresses" do
before do
sales_log_missing_town.update!(town_or_city: "towncity")
sales_log_wrong_uprn.update!(uprn: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(sales_log, File.open("spec/fixtures/files/missing_sales_logs_addresses.csv").read)
csv = service.create_missing_sales_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with missing town_or_city only" do
before do
sales_log.update!(address_line1: "address", town_or_city: "towncity")
sales_log_wrong_uprn.update!(uprn: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(sales_log_missing_town, File.open("spec/fixtures/files/missing_sales_logs_town_or_city.csv").read)
csv = service.create_missing_sales_addresses_csv
expect(csv).to eq(expected_content)
end
end
context "when the organisation has logs with wrong uprn only" do
before do
sales_log.update!(address_line1: "address", town_or_city: "towncity")
sales_log_missing_town.update!(town_or_city: "towncity")
sales_log_wrong_uprn.update!(uprn: "12", purchid: "12")
end
it "returns a csv with relevant logs" do
expected_content = replace_entity_ids(sales_log_wrong_uprn, File.open("spec/fixtures/files/missing_sales_logs_wrong_uprn.csv").read)
csv = service.create_missing_sales_addresses_csv
expect(csv).to eq(expected_content)
end
context "and the organisation is marked as an organisation to skip" do
let(:skip_uprn_issue_organisations) { [organisation.id] }
it "returns nil" do
expect(service.create_missing_sales_addresses_csv).to be_nil
end
end
end
context "when the organisation only has logs with missing addresses from 2022" do
before do
sales_log.saledate = Time.zone.local(2022, 4, 5)
sales_log.save!(validate: false)
sales_log_missing_town.saledate = Time.zone.local(2022, 4, 5)
sales_log_missing_town.save!(validate: false)
sales_log_wrong_uprn.saledate = Time.zone.local(2022, 4, 5)
sales_log_wrong_uprn.save!(validate: false)
end
it "returns nil" do
expect(service.create_missing_sales_addresses_csv).to be_nil
end
end
context "when the organisation has address fields filled in" do
before do
sales_log.update!(town_or_city: "town", address_line1: "line1")
sales_log_missing_town.update!(town_or_city: "town")
sales_log_wrong_uprn.update!(uprn: "12")
end
it "returns nil" do
expect(service.create_missing_sales_addresses_csv).to be_nil
end
end
end
describe "#create_lettings_addresses_csv" do
context "when the organisation has lettings logs" do
let!(:lettings_log) do
create(:lettings_log,
tenancycode: "tenancycode1",
propcode: "propcode1",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
address_line1: "address",
town_or_city: "town",
old_id: "old_id_1",
old_form_id: "old_form_id_1",
needstype: 1,
uprn_known: 0)
end
let!(:lettings_log_missing_address) do
create(:lettings_log,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
address_line1: nil,
town_or_city: nil,
old_id: "old_id",
old_form_id: "old_form_id",
needstype: 1,
uprn_known: 0)
end
let!(:lettings_log_missing_town) do
create(:lettings_log,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
address_line1: "existing address",
town_or_city: nil,
old_id: "older_id",
old_form_id: "old_form_id",
needstype: 1,
uprn_known: 0)
end
let!(:lettings_log_wrong_uprn) do
create(:lettings_log,
:completed,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
uprn: "123",
uprn_known: 1,
old_id: "oldest_id",
needstype: 1)
end
let!(:lettings_log_not_imported) do
create(:lettings_log,
:completed,
tenancycode: "tenancycode",
propcode: "propcode",
startdate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
managing_organisation: organisation,
uprn: "123",
uprn_known: 1,
needstype: 1)
end
before do
lettings_log = create(:lettings_log, :completed, managing_organisation: organisation, old_id: "exists")
lettings_log.startdate = Time.zone.local(2022, 4, 5)
lettings_log.save!(validate: false)
end
it "returns a csv with relevant logs" do
csv = CSV.parse(service.create_lettings_addresses_csv)
expect(csv.count).to eq(6)
expect(csv).to include([lettings_log.id.to_s, "2023-04-05", "tenancycode1", "propcode1", "testy@example.com", "Address org", "Address org", nil, "address", nil, "town", nil, nil])
expect(csv).to include([lettings_log_missing_address.id.to_s, "2023-04-05", "tenancycode", "propcode", "testy@example.com", "Address org", "Address org", nil, nil, nil, nil, nil, nil])
expect(csv).to include([lettings_log_missing_town.id.to_s, "2023-04-05", "tenancycode", "propcode", "testy@example.com", "Address org", "Address org", nil, "existing address", nil, nil, nil, nil])
expect(csv).to include([lettings_log_wrong_uprn.id.to_s, "2023-04-05", "tenancycode", "propcode", "testy@example.com", "Address org", "Address org", "123", "Some Place", nil, "Bristol", nil, "BS1 1AD"])
expect(csv).to include([lettings_log_not_imported.id.to_s, "2023-04-05", "tenancycode", "propcode", "testy@example.com", "Address org", "Address org", "123", "Some Place", nil, "Bristol", nil, "BS1 1AD"])
end
end
context "when the organisation does not have relevant lettings logs" do
before do
lettings_log = create(:lettings_log, managing_organisation: organisation)
lettings_log.startdate = Time.zone.local(2022, 4, 5)
lettings_log.save!(validate: false)
end
it "returns only headers" do
csv = service.create_lettings_addresses_csv
expect(csv).to eq "Log ID,Tenancy start date,Tenant code,Property reference,Log owner,Owning organisation,Managing organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode\n"
end
end
end
describe "#create_sales_addresses_csv" do
context "when the organisation has sales" do
let!(:sales_log) do
create(:sales_log,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
address_line1: "address",
town_or_city: "city",
old_id: "old_id_1",
old_form_id: "old_form_id_1",
uprn_known: 0)
end
let!(:sales_log_missing_address) do
create(:sales_log,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
address_line1: nil,
town_or_city: nil,
old_id: "old_id",
old_form_id: "old_form_id",
uprn_known: 0)
end
let!(:sales_log_missing_town) do
create(:sales_log,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
address_line1: "existing address line 1",
town_or_city: nil,
old_id: "older_id",
old_form_id: "old_form_id",
uprn_known: 0)
end
let!(:sales_log_wrong_uprn) do
create(:sales_log,
:completed,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
uprn: "123",
town_or_city: "Bristol",
old_id: "oldest_id",
uprn_known: 1,
uprn_confirmed: 1,
la: nil)
end
let!(:sales_log_not_imported) do
create(:sales_log,
:completed,
purchid: "purchaser code",
saledate: Time.zone.local(2023, 4, 5),
assigned_to: user,
owning_organisation: organisation,
uprn: "123",
town_or_city: "Bristol",
uprn_known: 1,
uprn_confirmed: 1,
la: nil)
end
before do
sales_log = create(:sales_log, :completed)
sales_log.saledate = Time.zone.local(2022, 4, 5)
sales_log.save!(validate: false)
end
it "returns a csv with relevant logs" do
csv = CSV.parse(service.create_sales_addresses_csv)
expect(csv.count).to eq(6)
expect(csv).to include([sales_log.id.to_s, "2023-04-05", "purchaser code", "testy@example.com", "Address org", nil, "address", nil, "city", nil, nil])
expect(csv).to include([sales_log_missing_address.id.to_s, "2023-04-05", "purchaser code", "testy@example.com", "Address org", nil, nil, nil, nil, nil, nil])
expect(csv).to include([sales_log_missing_town.id.to_s, "2023-04-05", "purchaser code", "testy@example.com", "Address org", nil, "existing address line 1", nil, nil, nil, nil])
expect(csv).to include([sales_log_wrong_uprn.id.to_s, "2023-04-05", "purchaser code", "testy@example.com", "Address org", "123", "Some Place", nil, "Bristol", nil, "BS1 1AD"])
expect(csv).to include([sales_log_not_imported.id.to_s, "2023-04-05", "purchaser code", "testy@example.com", "Address org", "123", "Some Place", nil, "Bristol", nil, "BS1 1AD"])
end
end
context "when the organisation does not have relevant sales logs" do
before do
sales_log = create(:sales_log, :completed)
sales_log.saledate = Time.zone.local(2022, 4, 5)
sales_log.save!(validate: false)
end
it "returns only headers" do
csv = service.create_sales_addresses_csv
expect(csv).to eq("Log ID,Sale completion date,Purchaser code,Log owner,Owning organisation,UPRN,Address Line 1,Address Line 2 (optional),Town or City,County (optional),Property's postcode\n")
end
end
end
end
Write Preview
Loading…
Cancel
Save