topographer 0.0.1

data/lib/Topographer/importer/strategy/import_new_record.rb

@@ -0,0 +1,17 @@
+class Importer::Strategy::ImportNewRecord < Importer::Strategy::Base
+
+  def import_record (source_data)
+    mapping_result = mapper.map_input(source_data)
+    new_model = mapper.model_class.new(mapping_result.data)
+    new_model.valid?
+    model_errors = new_model.errors.full_messages
+    status = get_import_status(mapping_result, model_errors)
+
+    new_model.save if should_persist_import?(status)
+
+    status
+  end
+
+end
+
+

data/lib/Topographer/importer/strategy/import_status.rb

@@ -0,0 +1,28 @@
+class Importer::Strategy::ImportStatus
+  attr_reader :errors, :input_identifier, :timestamp
+  attr_accessor :message
+
+  def initialize(input_identifier)
+    @input_identifier = input_identifier
+    @errors = {mapping: [],
+               validation: []}
+
+  end
+
+  def set_timestamp
+    @timestamp ||= DateTime.now
+  end
+
+  def add_error(error_source, error)
+    errors[error_source] << error
+  end
+
+  def error_count
+    errors.values.flatten.length
+  end
+
+  def errors?
+    errors.values.flatten.any?
+  end
+
+end

data/lib/Topographer/importer/strategy/update_record.rb

@@ -0,0 +1,33 @@
+class Importer::Strategy::UpdateRecord < Importer::Strategy::Base
+
+  def import_record (source_data)
+    mapping_result = mapper.map_input(source_data)
+
+    search_params = mapping_result.data.slice(*mapper.key_fields)
+    model_instance = mapper.model_class.where(search_params).first
+
+    if model_instance
+      model_instance.attributes = mapping_result.data
+      model_instance.valid?
+      model_errors = model_instance.errors.full_messages
+      status = get_import_status(mapping_result, model_errors)
+
+      model_instance.save if should_persist_import?(status)
+    else
+      status = get_import_status(mapping_result, ["Record not found with params: #{search_params.to_yaml}"])
+    end
+
+    status
+  end
+
+  def success_message
+    'Updated'
+  end
+
+  def failure_message
+    'Unable to update from import'
+  end
+
+end
+
+

data/lib/Topographer/version.rb

@@ -0,0 +1,3 @@
+module Topographer
+  VERSION = "0.0.1"
+end

data/lib/topographer.rb

@@ -0,0 +1,6 @@
+require 'Topographer/version'
+
+module Topographer
+  require 'Topographer/exceptions'
+  require 'Topographer/importer'
+end

data/spec/Cartographer/importer/helpers/write_log_to_csv_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Importer::Helpers::WriteLogToCSV do
+  let(:successful_entry) do
+    status = Importer::Strategy::ImportStatus.new('test-input')
+    status.set_timestamp
+    Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
+  end
+  let(:failed_entry) do
+    status = Importer::Strategy::ImportStatus.new('test-input')
+    status.set_timestamp
+    (1+rand(6)).times do |n|
+      status.add_error(:mapping, "Test error #{n}")
+    end
+    Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
+  end
+  let(:fatal_error) do
+    Importer::Logger::FatalErrorEntry.new('test-input', 'FATAL ERROR')
+  end
+  let(:successes) do
+    successes = []
+    2.times do
+      successes << successful_entry
+    end
+    successes
+  end
+  let(:failures) do
+    failures = []
+    3.times do
+      failures << failed_entry
+    end
+    failures
+  end
+  let(:fatal_errors) do
+    errors = []
+    4.times do
+      errors << fatal_error
+    end
+    errors
+  end
+  let(:logger) do
+    double 'Logger::Base',
+      successful_imports: 2,
+      failed_imports: 3,
+      total_imports: 5,
+      fatal_error?: false,
+      errors?: true,
+      successes: successes,
+      failures: failures,
+      fatal_errors: fatal_errors,
+      entries?: true,
+      all_entries: (successes + failures + fatal_errors)
+  end
+
+  describe '#write_log_to_csv' do
+    it 'should write a passed logger instance to a CSV file' do
+      file = double('file')
+      CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
+      file.should_receive(:<<).exactly(12).times
+      Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: true)
+    end
+    it 'should only write failures and fatal errors if write_all is false' do
+      file = double('file')
+      CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
+      file.should_receive(:<<).exactly(10).times
+      Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: false)
+    end
+  end
+end

data/spec/Cartographer/importer/helpers_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+class TestImportable
+  extend Importer::Helpers
+end
+
+describe Importer::Helpers do
+  describe ".boolify" do
+    it "returns true if given 'Yes'" do
+      expect(TestImportable.boolify('Yes')).to eql true
+    end
+
+    it "returns true if given 'True'" do
+      expect(TestImportable.boolify('True')).to eql true
+    end
+
+    it "returns false if given 'No'" do
+      expect(TestImportable.boolify('No')).to eql false
+    end
+
+    it "returns false if given 'False'" do
+      expect(TestImportable.boolify('False')).to eql false
+    end
+
+    it 'returns nil if the type is unknown' do
+      expect(TestImportable.boolify('Unknown')).to be_nil
+    end
+
+    it 'returns nil if it is given a nil' do
+      expect(TestImportable.boolify(nil)).to be_nil
+    end
+  end
+end

data/spec/Cartographer/importer/importable_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class TestImportable
+  extend Importer::Importable
+end
+
+describe Importer::Importable do
+  describe "#get_mapper" do
+    it 'should raise NotImplementedError' do
+      expect { TestImportable.get_mapper(nil) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/Cartographer/importer/importer_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'ostruct'
+
+class MockImportable < OpenStruct
+  include Importer::Importable
+
+  def self.create(params)
+    self.new(params)
+  end
+
+  def valid?
+    self.errors = OpenStruct.new(full_messages: [])
+    if field_2 == 'datum2'
+      true
+    else
+      self.errors = OpenStruct.new(full_messages: ['Field 2 is not datum2'])
+      false
+    end
+  end
+
+  def self.get_mapper(strategy_class)
+    case
+    when  strategy_class == HashImportStrategy
+      Importer::Mapper.build_mapper(MockImportable) do |mapping|
+        mapping.required_mapping 'Field1', 'field_1'
+        mapping.required_mapping 'Field2', 'field_2'
+        mapping.optional_mapping 'Field3', 'field_3'
+        mapping.ignored_column 'IgnoredField'
+      end
+    end
+  end
+
+end
+
+class HashImportStrategy < Importer::Strategy::Base
+  attr_reader :imported_data
+
+  def initialize(mapper)
+    @imported_data = []
+    @mapper = mapper
+  end
+
+  def import_record(source_data)
+    mapping_result = mapper.map_input(source_data)
+    new_model = mapper.model_class.new(mapping_result.data)
+    new_model.valid?
+    model_errors = new_model.errors.full_messages
+    status = get_import_status(mapping_result, model_errors)
+
+    @imported_data << new_model unless status.errors?
+
+    status
+  end
+
+end
+
+class MockInput
+  include Enumerable
+
+  def initialize
+
+  end
+  def get_header
+    ['Field1',
+     'Field2',
+     'Field3']
+  end
+
+  def input_identifier
+    'test'
+  end
+
+  def each
+    yield Importer::Input::SourceData.new('1', {'Field1' => 'datum1', 'Field2' => 'datum2'})
+    yield Importer::Input::SourceData.new('2', {'Field1' => 'datum2', 'Field2' => 'datum2', 'Field3' => 'datum3'})
+    yield Importer::Input::SourceData.new('3', {'Field1' => 'datum3', 'Field2' => 'invalid value!!!!1ONE'})  #I am INVALID!!!
+    yield Importer::Input::SourceData.new('4', {'Field1' => 'datum4', 'Field2' => 'datum2', 'Field3' => 'datum3', 'IgnoredField' => 'ignore me'})
+  end
+end
+
+describe Importer do
+  let(:input) { MockInput.new }
+  let(:model_class) { MockImportable }
+  let(:strategy_class) { HashImportStrategy }
+  let(:bad_input) do
+    double 'Input',
+           get_header: ['BadCol1', 'BadCol2', 'Field1', 'Field3'],
+           input_identifier: 'Test'
+  end
+  let(:simple_logger) { Importer::Logger::Simple.new }
+  let(:import_log) { Importer.import_data(input, model_class, strategy_class, simple_logger) }
+
+  describe '.import_data' do
+    it 'returns a logger instance' do
+      expect(import_log).to be simple_logger
+    end
+
+    it 'tries to import data from a valid import object' do
+      expect(import_log.total_imports).to be 4
+    end
+
+    it 'imports valid data and does not import invalid data' do
+      expect(import_log.successful_imports).to be 3
+    end
+
+    it 'logs invalid data' do
+      expect(import_log.errors?).to be_true
+      expect(import_log.failed_imports).to be 1
+    end
+
+    it 'does not import data with an invalid header' do
+      import_log = Importer.import_data(bad_input, model_class, strategy_class, simple_logger)
+      expect(import_log.errors?).to be_true
+      expect(import_log.fatal_error?).to be_true
+      expect(import_log.fatal_errors.first.message).
+        to match(/Invalid Input Header.+Missing Columns:\s+Field2.+Invalid Columns:\s+BadCol1.+BadCol2/)
+    end
+  end
+  describe '.build_mapper' do
+    it 'returns a mapper with the defined mappings' do
+      mapper = Importer.build_mapper(MockImportable) do |mapping|
+          mapping.required_mapping 'Field1', 'field_1'
+          mapping.required_mapping 'Field2', 'field_2'
+          mapping.optional_mapping 'Field3', 'field_3'
+          mapping.ignored_column 'IgnoredField'
+      end
+      expect(mapper.required_columns).to eql(['Field1', 'Field2'])
+      expect(mapper.optional_columns).to eql(['Field3'])
+      expect(mapper.ignored_columns).to eql(['IgnoredField'])
+    end
+  end
+end

data/spec/Cartographer/importer/logger/base_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Importer::Logger::Base do
+  let(:logger){Importer::Logger::Base.new}
+  describe '#log_fatal' do
+    it 'should log a fatal error' do
+      logger.log_fatal('test input', 'Fatal Error')
+      expect(logger.fatal_errors.first).to be_a Importer::Logger::LogEntry
+      expect(logger.fatal_errors.first)
+    end
+  end
+end

data/spec/Cartographer/importer/logger/fatal_error_entry_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Importer::Logger::FatalErrorEntry do
+  let(:entry) { Importer::Logger::FatalErrorEntry.new('test-input', 'failure message') }
+  describe '#failure?' do
+    it 'should return true' do
+      expect(entry.failure?).to be_true
+    end
+  end
+  describe '#success?' do
+    it 'should return false' do
+      expect(entry.success?).to be_false
+    end
+  end
+  describe '#source_identifier' do
+    it 'should return `import failure`' do
+      expect(entry.source_identifier).to eql 'import failure'
+    end
+  end
+  describe '#timestamp' do
+    it 'should have a timestamp' do
+      expect(entry.timestamp).to be_a(DateTime)
+    end
+  end
+  describe '#message' do
+    it 'should return the message it was initialized with' do
+      expect(entry.message).to eql('failure message')
+    end
+  end
+end
+

data/spec/Cartographer/importer/logger/simple_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Importer::Logger::Simple do
+
+  let(:logger) do
+    Importer::Logger::Simple.new
+  end
+
+  describe '#log_success' do
+    it 'logs a success' do
+      logger.log_success({record_id: 1,
+                          message: 'success'})
+      expect(logger.successful_imports).to eql 1
+      expect(logger.failed_imports).to eql 0
+    end
+  end
+
+  describe '#log_failure' do
+    it 'logs a failure' do
+      logger.log_failure({record_id: 1,
+                          message: 'failure'})
+      expect(logger.successful_imports).to eql 0
+      expect(logger.failed_imports).to eql 1
+    end
+  end
+
+  describe '#total_imports' do
+    it 'returns the total number of imports' do
+      logger.log_success({record_id: 1,
+                          message: 'success'})
+      logger.log_failure({record_id: 2,
+                          message: 'failure'})
+      expect(logger.total_imports).to eql 2
+    end
+  end
+
+  describe '#errors?' do
+    it 'returns true if there are fatal errors' do
+      logger.log_fatal('input', 'FATAL ERROR')
+      expect(logger.errors?).to be_true
+    end
+    it 'returns true if there are import errors' do
+      logger.log_failure({record_id: 2,
+                          message: 'failure'})
+      expect(logger.errors?).to be_true
+    end
+    it 'returns false if there are no errors' do
+      logger.log_success({record_id: 2,
+                          message: 'failure'})
+      expect(logger.errors?).to be_false
+    end
+  end
+end