drive_time 0.0.3

data/spec/drive_time/builder/join_builder_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module DriveTime
+
+  describe JoinBuilder do
+
+    before(:each) do
+      @join_builder = JoinBuilder.new
+    end
+
+    it "should combine values into a single value" do
+      # All present
+      name_fields = ['Key1', 'Key2', 'Key3']
+      row_map = {'Key1' => 'Value1', 'Key2' => 'Value2', 'Key3' => 'Value3'}
+      @join_builder.build(name_fields, row_map).should == 'value1_value2_value3'
+
+    end
+
+    it "should ignore empty fields so long as they exist" do
+      name_fields = ['Key1', 'Key2', 'Key3']
+      row_map = {'Key1' => 'Value1', 'Key2' => '', 'Key3' => 'Value3'}
+      @join_builder.build(name_fields, row_map).should == 'value1_value3'
+    end
+
+    it "should not add anything to a single name" do
+      name_fields = ['Key3']
+      row_map = {'Key1' => 'Value1', 'Key2' => 'Value2', 'Key3' => 'Value3'}
+      @join_builder.build(name_fields, row_map).should == 'value3'
+    end
+
+    it "should raise a MissingFieldError if a field is missing" do
+
+      name_fields = ['Key1']
+      row_map = {}
+
+      expect { @join_builder.build(name_fields, row_map) }.to raise_error NameBuilder::MissingFieldError
+    end
+
+    it "should raise a NoFieldsError if all fields are missing" do
+
+      name_fields = ['Key1', 'Key2', 'Key3']
+      row_map = {'Key1' => '', 'Key2' => '', 'Key3' => ''}
+
+      expect { @join_builder.build(name_fields, row_map) }.to raise_error NameBuilder::NoFieldsError
+    end
+
+  end
+end

data/spec/drive_time/builder/name_builder_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module DriveTime
+
+  describe NameBuilder do
+
+    before(:each) do
+      @name_builder = NameBuilder.new
+    end
+
+    it "should combine names into a single name, adding a '.' for a middle initial" do
+      # All present
+      name_fields = ['First Name', 'Middle Names', 'Last Name']
+      row_map = {'First Name' => 'George', 'Middle Names' => 'W', 'Last Name' => 'Bush'}
+      @name_builder.build(name_fields, row_map).should == 'george_w._bush'
+    end
+
+    it "should combine names into a single name, adding no '.' for any longer middle name" do
+      # All present
+      name_fields = ['First Name', 'Middle Names', 'Last Name']
+      row_map = {'First Name' => 'George', 'Middle Names' => 'Wo', 'Last Name' => 'Bush'}
+      @name_builder.build(name_fields, row_map).should == 'george_wo_bush'
+    end
+
+  end
+end

data/spec/drive_time/class_name_map_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module DriveTime
+
+  describe ClassNameMap do
+
+    before :each do
+      @class_name_map = ClassNameMap.new
+      @class_a = "ClassA"
+      @class_b = "ClassB"
+      @class_c = "ClassC"
+      @class_d = "ClassD"
+      @class_e = "ClassD"
+      @class_name_map.save_mapping(@class_c, @class_d)
+    end
+
+    describe "when saving class mapping" do
+
+      context "when no mapped class name is given" do
+        it "should return the classname" do
+          @class_name_map.save_mapping(@class_a).should == @class_a
+        end
+      end
+
+      context "when a mapped class name is given" do
+        it "should return the mapping" do
+          @class_name_map.save_mapping(@class_a, @class_b).should == @class_b
+        end
+      end
+
+    end
+
+    describe "when resolving the original from mapped" do
+
+      context "when a mapping exists" do
+
+        it "should return the mapping" do
+          @class_name_map.save_mapping(@class_a, @class_b)
+          @class_name_map.resolve_original_from_mapped(@class_b).should == @class_a
+        end
+
+      end
+
+      context "when no mapping exists" do
+
+        it "should return the class" do
+          @class_name_map.save_mapping(@class_a)
+          @class_name_map.resolve_original_from_mapped(@class_a).should == @class_a
+        end
+
+      end
+
+    end
+
+    describe "when resolving the mapped from original" do
+
+      context "when a mapping exists" do
+
+        it "should return the original" do
+          @class_name_map.save_mapping(@class_a, @class_b)
+          @class_name_map.resolve_mapped_from_original(@class_a).should == @class_b
+        end
+
+      end
+
+      context "when no mapping exists" do
+
+        it "should return the class" do
+          @class_name_map.resolve_mapped_from_original(@class_e).should == @class_e
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/drive_time/converters/worksheet_converter_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module DriveTime
+
+  describe WorksheetConverter do
+
+    before(:each) do
+      @worksheet_converter = WorksheetConverter.new(nil, nil, nil, nil)
+    end
+
+    context 'build_id_for_model' do
+
+      it 'should build correct id for model using basic key' do
+
+        class WorksheetConverter
+          public :build_id_for_model
+        end
+
+        mapping = {:key => 'name'}
+        @worksheet_converter.row_map = {'name' => 'John'}
+
+        @worksheet_converter.build_id_for_model(mapping).should == 'john'
+      end
+
+      it 'should build correct id for model using join builder' do
+
+        class WorksheetConverter
+          public :build_id_for_model
+        end
+
+        mapping = {:key => {:builder => 'join', :from_fields => ['one', 'two', 'three'] } }
+        @worksheet_converter.row_map = {'one' => 'Apple', 'two' => 'Orange', 'three' => 'Plum'}
+
+        @worksheet_converter.build_id_for_model(mapping).should == 'apple_orange_plum'
+      end
+
+      it 'should build correct id for model using name builder' do
+
+        class WorksheetConverter
+          public :build_id_for_model
+        end
+
+        mapping = {:key => {:builder => 'name', :from_fields => ['forename', 'middle_name', 'surname'] } }
+        @worksheet_converter.row_map = {'forename' => 'George', 'middle_name' => 'W', 'surname' => 'Bush'}
+
+        @worksheet_converter.build_id_for_model(mapping).should == 'george_w._bush'
+      end
+
+      it 'should raise a NoFieldNameError if no field exists with key name' do
+
+        class WorksheetConverter
+          public :build_id_for_model
+        end
+
+        mapping = {:key => 'nonsense'}
+        @worksheet_converter.row_map = {'name' => 'John'}
+
+        expect { @worksheet_converter.build_id_for_model(mapping) }.to raise_error WorksheetConverter::NoFieldNameError
+      end
+
+    end
+
+  end
+end

data/spec/drive_time/field_expander_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+require "google_drive"
+
+module DriveTime
+
+  describe FieldExpander do
+
+    before :each do
+      @loader = Loader.new
+      @loader.stub :begin_session
+      @field_expander = FieldExpander.new(@loader)
+      @valid_file_path = "valid_file_path"
+
+      @invalid_token = "invalid_token"
+      @valid_expand_file_token = "expand_file"
+      @valid_expand_file_token_with_filename = "expand_file[#{@valid_file_path}]"
+      @valid_expand_spreadsheet_token = "expand_spreadsheet"
+      @valid_expand_spreadsheet_token_with_filename = "expand_spreadsheet[#{@valid_file_path}]"
+      @file = {name: 'file'} # need something in the object or Ruby treats it as blank
+      @file.stub :initialize
+      @file_contents = "12345"
+      @model_key = "model_key"
+      @worksheet = {name: 'worksheet'}
+      @spreadsheet = {name: 'spreadsheet'}
+    end
+
+    context "when supplied with a field containig an invalid token" do
+
+      it "should raise a TokenExpansionError" do
+        expect { @field_expander.expand(@invalid_token, @model_key) }.to raise_error TokenExpansionError
+      end
+
+    end
+
+    context "when supplied with a field containig an 'expand_file' token" do
+
+      context "when the file exists" do
+
+        it "should load the file" do
+          @loader.should_receive(:load_file_direct).with("#{@model_key}.txt").and_return(@file)
+          @file.should_receive(:download_to_string).and_return(@file_contents)
+          @field_expander.expand(@valid_expand_file_token, @model_key).should == @file_contents
+        end
+
+      end
+
+      context "when the file doesn't exist" do
+
+        it "should raise a TokenExpansionError" do
+          @loader.stub(:load_file_direct).and_return(nil)
+          expect { @field_expander.expand(@valid_expand_file_token, @model_key) }.to raise_error TokenExpansionError
+        end
+
+      end
+    end
+
+    context "when supplied with a field containig an 'expand_file' token and a filename" do
+
+      context "when the file exists" do
+
+        it "should load the file " do
+          @loader.should_receive(:load_file_direct).with("#{@valid_file_path}.txt").and_return(@file)
+          @file.should_receive(:download_to_string).and_return(@file_contents)
+          @field_expander.expand(@valid_expand_file_token_with_filename, @model_key).should == @file_contents
+        end
+
+      end
+
+      context "when the file doesn't exist" do
+
+        it "should raise a TokenExpansionError" do
+          @loader.stub(:load_file_direct).and_return(nil)
+          expect { @field_expander.expand(@valid_expand_file_token_with_filename, @model_key) }.to raise_error TokenExpansionError
+        end
+
+      end
+
+    end
+
+    context "when supplied with a field containig an 'expand_spreadsheet' token" do
+
+      context "when the spreadsheet exists" do
+
+        it "should load the spreadsheet" do
+          @file.stub(:worksheets).and_return([@worksheet])
+          @loader.should_receive(:load_spreadsheet_direct).with(@model_key).and_return(@file)
+          @field_expander.should_receive(:expand_worksheet).with(@worksheet)
+          @field_expander.expand(@valid_expand_spreadsheet_token, @model_key)
+        end
+
+      end
+
+      context "when the spreadsheet doesn't exist" do
+
+        it "should raise a TokenExpansionError" do
+          @loader.stub(:load_spreadsheet_direct).and_return(nil)
+          expect { @field_expander.expand(@valid_expand_spreadsheet_token, @model_key) }.to raise_error TokenExpansionError
+        end
+
+      end
+
+    end
+
+    context "when supplied with a field containig an 'expand_spreadsheet' token and a spreadsheet name" do
+
+      context "when the spreadsheet exists" do
+
+        it "should load the spreadsheet " do
+          @file.stub(:worksheets).and_return([@worksheet])
+          @loader.should_receive(:load_spreadsheet_direct).with(@valid_file_path).and_return(@file)
+          @field_expander.should_receive(:expand_worksheet).with(@worksheet).and_return(@file_contents)
+          @field_expander.expand(@valid_expand_spreadsheet_token_with_filename, @model_key)
+        end
+
+      end
+
+      context "when the spreadsheet doesn't exist" do
+
+        it "should raise a TokenExpansionError" do
+          @loader.stub(:load_spreadsheet_direct).and_return(nil)
+          expect { @field_expander.expand(@valid_expand_spreadsheet_token_with_filename, @model_key) }.to raise_error TokenExpansionError
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/drive_time/loader_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module DriveTime
+
+  VALID_SPREADSHEET_1_TITLE = 'Fixture 1'
+  VALID_SPREADSHEET_2_TITLE = 'Fixture 2'
+  INVALID_SPREADSHEET_TITLE = 'Invalid Title xccdtyyehdyd56ejr6'
+
+  describe Loader do
+
+    def last_access_time_for_cached_file(title)
+      cached_directory = ENV['CACHED_DIR']
+      file_name = "#{title}.yml"
+      file_path = File.join(cached_directory, file_name)
+      File.atime(file_path).to_i
+    end
+
+    def clear_cache_dir
+      cached_directory = ENV['CACHED_DIR']
+      FileUtils.rm Dir.glob("#{cached_directory}/*")
+    end
+
+    def cached_file_exists(file_name)
+      cached_directory = ENV['CACHED_DIR']
+      file_name = "#{VALID_SPREADSHEET_1_TITLE}.yml"
+      file_path = File.join(cached_directory, file_name)
+      return File.exists? file_path
+    end
+
+    before(:each ) do
+      @loader = Loader.new
+    end
+
+    context 'When not using cache' do
+
+      context 'when accessing a spreadsheet' do
+
+        it "should raise a SpreadsheetNotFoundError if a spreadsheet doesn't exist" do
+          expect{ @loader.load_spreadsheet(INVALID_SPREADSHEET_TITLE, false) }.to raise_error(Loader::SpreadsheetNotFoundError)
+        end
+
+        it "should download a Spreadsheet sucessfully" do
+          @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE, false).title.should == VALID_SPREADSHEET_1_TITLE
+        end
+
+      end
+
+      context 'when accessing a worksheet from with a loaded spreadsheet' do
+
+        before(:each) do
+          @spreadsheet = @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE, false)
+        end
+
+        it "should raise a SpreadsheetNotFoundError if a worksheet doesn't exist" do
+          expect{ @loader.load_worksheet_from_spreadsheet(@spreadsheet, 'nmgsgscg', false) }.to raise_error(Loader::WorksheetNotFoundError)
+        end
+
+        it "should download a Worksheet sucessfully" do
+          @loader.load_worksheet_from_spreadsheet(@spreadsheet, 'Label', false).title.should == 'Label'
+        end
+
+      end
+    end
+
+    context 'When using cache' do
+
+      before(:each) do
+        @spreadsheet = @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE, false)
+        # Save the time so we can check file access
+        @before = Time.now.to_i
+      end
+
+      context 'when accessing a spreadsheet' do
+        it "should pull a Spreadsheet from the cache if it exists" do
+          @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE).title.should == VALID_SPREADSHEET_1_TITLE
+          last_access_time_for_cached_file(VALID_SPREADSHEET_1_TITLE).should <= @before
+        end
+
+        it "should download a Spreadsheet if it isn't in the cache" do
+          clear_cache_dir
+          @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE, false).title.should == VALID_SPREADSHEET_1_TITLE
+        end
+
+        it "should save the spreadsheet to the cache" do
+          clear_cache_dir
+          @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE)
+          cached_file_exists(VALID_SPREADSHEET_1_TITLE).should be_true
+        end
+
+        it "should save the spreadsheet's worksheets to the cache" do
+          clear_cache_dir
+          @loader.load_spreadsheet(VALID_SPREADSHEET_1_TITLE)
+          cached_file_exists('Label').should be_true
+          cached_file_exists('Act').should be_true
+          cached_file_exists('Album').should be_true
+          cached_file_exists('Group').should be_true
+        end
+
+      end
+
+      context 'when accessing a worksheet from with a loaded spreadsheet' do
+
+        it "should download a Spreadsheet sucessfully" do
+          @loader.load_worksheet_from_spreadsheet(@spreadsheet, 'Label').title.should == 'Label'
+        end
+
+      end
+
+    end
+  end
+end

data/spec/drive_time/model_store_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'active_record'
+
+module DriveTime
+
+  describe ModelStore do
+
+    class ModelA
+    end
+
+    class ModelB
+    end
+
+    before(:each) do
+      @model_store = ModelStore.new
+      @model_a = ModelA.new
+      @model_b = ModelB.new
+    end
+
+    describe 'when models are added' do
+
+      it 'should allow an added model to be retrieved' do
+        @model_store.add_model(@model_a, 'model_a', ModelA)
+        @model_store.get_model(ModelA, 'model_a').should == @model_a
+      end
+
+      describe 'when the same model is added twice' do
+
+        it 'should raise a ModelAddedTwiceError' do
+          @model_store.add_model(@model_a, 'model_a', ModelA)
+          expect { @model_store.add_model(@model_a, 'model_a', ModelA) }.to raise_error(ModelStore::ModelAddedTwiceError)
+        end
+
+      end
+    end
+
+    describe 'when models are retieved' do
+
+      it 'should raise a NoModelsOfClassInStoreError if no model is stored of the given type' do
+        @model_store.add_model(@model_a, 'model_a', ModelA)
+        expect { @model_store.get_model(ModelB, 'model_a') }.to raise_error(ModelStore::NoModelsOfClassInStoreError)
+      end
+
+      it 'should raise a NoModelOfClassWithKeyInStoreError if no model is stored of the given type with the given key' do
+        @model_store.add_model(@model_a, 'model_a', ModelA)
+        expect { @model_store.get_model(ModelA, 'model_b') }.to raise_error(ModelStore::NoModelOfClassWithKeyInStoreError)
+      end
+
+    end
+
+  end
+end

data/spec/drive_time_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+# Mapped from Group
+
+module DriveTime
+
+  describe DriveTime do
+
+    it 'should process string correctly' do
+
+      input_string = ' a Test STRING-with-spaces- AND hyphens '
+      # All lower case
+      # Underscores replace speces and hyphens
+      # Leading and trailing whitespace is removed
+      expected_string = 'a_test_string-with-spaces-_and_hyphens'
+      result_string = DriveTime.underscore_from_text input_string
+      result_string.should == expected_string
+    end
+
+    it 'should process a title to a class' do
+      input_string = "Nonsense Things"
+      expected_string = "NonsenseThing"
+      result_string = DriveTime.class_name_from_title input_string
+      result_string.should == expected_string
+    end
+
+    it 'should only treat yes and y (in any case) as affirmative' do
+      # Positive
+      DriveTime.is_affirmative?('yes').should be_true
+      DriveTime.is_affirmative?('YES').should be_true
+      DriveTime.is_affirmative?('Yes').should be_true
+      DriveTime.is_affirmative?('y').should be_true
+      DriveTime.is_affirmative?('Y').should be_true
+      DriveTime.is_affirmative?(' Yes ').should be_true
+      # Negative
+      DriveTime.is_affirmative?('No').should be_false
+      DriveTime.is_affirmative?('').should be_false
+      DriveTime.is_affirmative?('N').should be_false
+      DriveTime.is_affirmative?('Yeses').should be_false
+      DriveTime.is_affirmative?('Example').should be_false
+    end
+
+  end
+end

data/spec/fixtures/mapping.yml

@@ -0,0 +1,55 @@
+namespace: DriveTime
+spreadsheets:
+  - title: Fixture 1
+    worksheets:
+      - title: Group
+        map_to_class: Act
+        key: name
+        fields:
+          - name: name
+          - name: formed
+        associations:
+          - name: member
+            builder: multi
+
+      - title: Album
+        key: name
+        fields:
+          - name: year
+        associations:
+          - name: label
+            builder: use_fields
+            field_names: [label_1, label_2, label_3]
+            singular: true
+          - name: act
+            singular: true
+
+      - title: Label
+        key: name
+        fields:
+          - name: genre
+          - name: website
+
+      - title: Member
+        key: name
+        fields:
+          - name: name
+          - name: real_name
+          #  from_fields: [forename, middle_names, surname]
+          - name: year_of_birth
+          - name: year_of_death
+
+  - title: Fixture 2
+    dependencies: [Fixture 1]
+    worksheets:
+      - title: Track
+        key:
+          builder: join
+          from_fields: [name, remix]
+        fields:
+          - name: name
+          - name: remix
+          - name: duration
+        associations:
+          - name: album
+            inverse: true

data/spec/full_tests.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class ModelBase
+
+  def initialize(data, params)
+  end
+
+  def save!
+  end
+end
+
+module DriveTime
+
+  class Act < ModelBase
+    attr_accessor :members
+    def initialize(data, params)
+      self.members = Array.new
+    end
+  end
+
+  class Album < ModelBase
+    attr_accessor :label
+    attr_accessor :act
+    attr_accessor :tracks
+    def initialize(data, params)
+      self.tracks = Array.new
+    end
+  end
+
+  class Label < ModelBase; end
+
+  class Member < ModelBase; end
+
+  class Track < ModelBase; end
+
+  describe DriveTime do
+
+    context 'with full spreadsheet and mapping' do
+      it 'should load spreadsheet and map to models' do
+        mappings_path = File.join(File.dirname(__FILE__),'fixtures/mapping.yml')
+        converter = SpreadsheetsConverter.new
+        converter.load mappings_path
+      end
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'dotenv'
+require 'drive_time'
+require "log4r"
+
+Dotenv.load
+DriveTime::log_level = Log4r::DEBUG