openc_bot 0.0.11

data/spec/lib/helpers/text_spec.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+require_relative '../../spec_helper'
+require 'openc_bot/helpers/text'
+
+describe OpencBot::Helpers::Text do
+  describe "#normalise_utf8_spaces" do
+    it "should convert UTF-8 spaces to normal spaces" do
+      raw_and_normalised_text = {
+        "Hello World" => "Hello World",
+        '' => '',
+        nil => nil,
+        " \xC2\xA0\xC2\xA0 Mr Fred Flintstone  \xC2\xA0" => '    Mr Fred Flintstone   ',
+        "AVTOPREVOZNIŠTVO - PREVOZ BLAGA ROBERT FLORJANČIČ S.P." => "AVTOPREVOZNIŠTVO - PREVOZ BLAGA ROBERT FLORJANČIČ S.P."
+                                  }
+      raw_and_normalised_text.each do |raw_text, normalised_text|
+        OpencBot::Helpers::Text.normalise_utf8_spaces(raw_text).should == normalised_text
+      end
+    end
+  end
+
+  describe "#strip_all_spaces" do
+    it "should strip all spaces from text" do
+      OpencBot::Helpers::Text.strip_all_spaces(" \n \xC2\xA0\xC2\xA0 Mr Fred Flintstone\n  ").should == 'Mr Fred Flintstone'
+    end
+
+    it "should not strip UTF8 chars that aren't spaces" do
+      OpencBot::Helpers::Text.strip_all_spaces("   \xC3\x8Dan Flintstone\n  ").should == 'Ían Flintstone'
+    end
+
+    it "should replace UTF8 space with normal space" do
+      OpencBot::Helpers::Text.strip_all_spaces("   Mr\xC2\xA0Fred Flintstone\n  ").should == 'Mr Fred Flintstone'
+    end
+
+    it "should not mess with other UTF8 characters" do
+      utf8_name = "AVTOPREVOZNIŠTVO - PREVOZ BLAGA ROBERT FLORJANČIČ S.P."
+      OpencBot::Helpers::Text.strip_all_spaces(utf8_name).should == utf8_name
+    end
+
+    it "should return nil when nil given" do
+      OpencBot::Helpers::Text.strip_all_spaces(nil).should be_nil
+    end
+
+    it "should replace multiple spaces with single space" do
+      OpencBot::Helpers::Text.strip_all_spaces("   Mr\xC2\xA0Fred  Percy Flintstone\n  ").should == 'Mr Fred Percy Flintstone'
+    end
+
+  end
+
+
+end

data/spec/lib/openc_bot/incrementers/common_spec.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+require_relative '../../../spec_helper'
+require 'openc_bot'
+require 'openc_bot/incrementers'
+
+describe OpencBot::ManualIncrementer do
+  before do
+    @app_path = File.expand_path(File.join(File.dirname(__FILE__), "../../.."))
+    @incrementer = OpencBot::ManualIncrementer.new(:manual_incrementer, :fields => [:url], :app_path => @app_path, :show_progress => false)
+    @incrementer.sqlite_magic_connection.execute("DELETE FROM items")
+    @incrementer.reset_current
+  end
+  
+  after do
+    @incrementer.sqlite_magic_connection.execute("DROP TABLE items")
+  end
+
+  it "should return same stuff as saved, plus an id" do
+    hashes = [
+      {"name" => "tony", "address" => "number 0", "url" => "http://example.com/tony"},
+      {"name" => "jude", "address" => "number 1", "url" => "http://example.com/jude"},
+      {"name" => "brig", "address" => "number 2", "url" => "http://example.com/brig"}
+    ]
+    hashes.each do |h|
+      @incrementer.add_row(h)
+    end
+    @incrementer.enum.each.with_index(1) do |row, i|
+      # id assignment in sqlite is 1 indexed, not 0
+      row.should == hashes[i - 1].merge("_id" => i)
+    end
+  end
+
+  it "should resume from where left off" do
+    hashes = [
+              {"name" => "tony", "address" => "number 1", "url" => "http://example.com/tony"},
+              {"name" => "jude", "address" => "number 2", "url" => "http://example.com/jude"},
+              {"name" => "brig", "address" => "number 3", "url" => "http://example.com/brig"}
+             ]
+    hashes.each do |h|
+      @incrementer.add_row(h)
+    end
+    counter = @incrementer.enum
+    counter.next.should == hashes[0].merge("_id" => 1)
+    counter.next.should == hashes[1].merge("_id" => 2)
+
+    @new_incrementer = OpencBot::ManualIncrementer.new(:manual_incrementer, :app_path => @app_path, :fields => [:url])
+    # TODO: effectively performs id >= current_row['_id'] which results
+    # in the same row being run twice across the two separate runs.
+    # Is this desired behaviour?
+    @new_incrementer.resumable.next.should == hashes[1].merge("_id" => 2)
+  end
+
+  it "should be relatively fast to save" do
+    hashes = []
+    (0...2000).each do |n|
+      hashes << {'number' => n}
+    end
+    hashes.each do |h|
+      @incrementer.add_row(h)
+    end
+  end
+
+  it "should be relatively fast to skip" do
+    hashes = []
+    (0...2000).each do |n|
+      hashes << {'number' => n}
+    end
+    hashes.each do |h|
+      @incrementer.add_row(h)
+    end
+    counter = @incrementer.enum
+    start_time = Time.now
+    1000.times do
+      counter.next
+    end
+    end_time = Time.now
+    @new_incrementer = OpencBot::ManualIncrementer.new(:manual_incrementer, :app_path => @app_path, :fields => [:url])
+    # TODO: effectively performs id >= current_row['_id'] which results
+    # in the same row being run twice across the two separate runs.
+    # Is this desired behaviour?
+    @new_incrementer.resumable.next["number"].should == 999
+  end
+end

data/spec/lib/openc_bot_spec.rb

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+require_relative '../spec_helper'
+require 'openc_bot'
+require_relative '../dummy_classes/foo_bot'
+
+describe "A module that extends OpencBot" do
+
+  before do
+    @dummy_connection = double('database_connection')
+    FooBot.stub(:sqlite_magic_connection).and_return(@dummy_connection)
+  end
+
+  it "should include ScraperWiki methods" do
+    FooBot.should respond_to(:save_sqlite)
+  end
+
+  it "should define OpencBotError exception as subclass of StandardError" do
+    OpencBot::OpencBotError.superclass.should be StandardError
+  end
+
+  it "should define DatabaseError exception as subclass of OpencBotError" do
+    OpencBot::DatabaseError.superclass.should be OpencBot::OpencBotError
+  end
+
+  it "should define InvalidDataError exception as subclass of OpencBotError" do
+    OpencBot::InvalidDataError.superclass.should be OpencBot::OpencBotError
+  end
+
+  describe '#insert_or_update' do
+    before do
+      @datum = {:foo => 'bar', :foo2 => 'bar2', :foo3 => 'bar3', :foo4 => 'bar4'}
+      @unique_keys = [:foo2,:foo3]
+      @expected_query = "INSERT INTO foo_table (foo,foo2,foo3,foo4) VALUES (:foo,:foo2,:foo3,:foo4)"
+    end
+
+    it "should delegate to connection" do
+      @dummy_connection.should_receive(:insert_or_update).with(@unique_keys, @datum, 'foo_table')
+      FooBot.insert_or_update(@unique_keys, @datum, 'foo_table')
+    end
+
+    it "should use ocdata table by default" do
+      @dummy_connection.should_receive(:insert_or_update).with(@unique_keys, @datum, 'ocdata')
+      FooBot.insert_or_update(@unique_keys, @datum)
+    end
+  end
+
+  describe '#unlock_database' do
+    it "should start and end transaction on database" do
+      @dummy_connection.should_receive(:execute).with('BEGIN TRANSACTION; END;')
+      FooBot.unlock_database
+    end
+  end
+
+  describe '#verbose?' do
+    it 'should return false if ENV["VERBOSE"] not set' do
+      FooBot.verbose?.should be_false
+    end
+
+    it 'should return false if ENV["VERBOSE"] set' do
+      ENV["VERBOSE"] = 'true'
+      FooBot.verbose?.should be_true
+      ENV["VERBOSE"] = nil # reset
+    end
+  end
+
+  describe '#save_run_report' do
+
+    it 'should save_data in ocrunreports table' do
+      FooBot.should_receive(:save_data).with(anything, anything, :ocrunreports)
+      FooBot.save_run_report(:foo => 'bar')
+    end
+
+    it 'should convert run data into JSON' do
+      dummy_time = Time.now
+      Time.stub(:now).and_return(dummy_time)
+      expected_run_report = ({ :foo => 'bar' }).to_json
+      FooBot.should_receive(:save_data).with(anything, { :report => expected_run_report, :run_at => dummy_time.to_s }, anything)
+      FooBot.save_run_report(:foo => 'bar')
+    end
+
+    it 'should use timestamp as unique key' do
+      FooBot.should_receive(:save_data).with([:run_at], anything, anything)
+      FooBot.save_run_report(:foo => 'bar')
+    end
+  end
+
+  describe "normalise_utf8_spaces private method" do
+    it "should convert UTF-8 spaces to normal spaces" do
+      raw_and_normalised_text = {
+        "Hello World" => "Hello World",
+        '' => '',
+        nil => nil,
+        " \xC2\xA0\xC2\xA0 Mr Fred Flintstone  \xC2\xA0" => '    Mr Fred Flintstone   ',
+                                  }
+      raw_and_normalised_text.each do |raw_text, normalised_text|
+        FooBot.send(:normalise_utf8_spaces, raw_text).should == normalised_text
+      end
+    end
+  end
+
+  describe "#sqlite_magic_connection" do
+    it "should override default ScraperWiki#sqlite_magic_connection to use module name and adjacent db directory" do
+      FooBot.unstub(:sqlite_magic_connection)
+      expected_db_loc = File.expand_path(File.join(File.dirname(__FILE__),'..','db','foobot.db'))
+      SqliteMagic::Connection.should_receive(:new).with(expected_db_loc).and_return(@dummy_sqlite_magic_connection)
+      FooBot.sqlite_magic_connection
+    end
+  end
+
+  describe "#root_directory" do
+    it "should return directory one up from that containing module" do
+      FooBot.root_directory.should == File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    end
+  end
+
+end

data/spec/schemas/company-schema_spec.rb

@@ -0,0 +1,676 @@
+# encoding: UTF-8
+require 'json-schema'
+require 'active_support/core_ext'
+require 'debugger'
+
+describe 'company-schema' do
+  before do
+    @schema = File.join(File.dirname(__FILE__),'..','..','schemas','company-schema.json')
+  end
+
+  it "should validate simple company" do
+    valid_company_params =
+      [
+        { :name => 'Foo Inc',
+          :company_number => '12345',
+          :jurisdiction_code => 'ie'
+        },
+        { :name => 'Foo Inc',
+          :company_number => '12345',
+          :jurisdiction_code => 'us_de',
+          :registered_address => '32 Foo St, Footown,'
+        }
+      ]
+      valid_company_params.each do |valid_params|
+        errors = validate_datum_and_return_errors(valid_params)
+        errors.should be_empty, "Valid params were not valid: #{valid_params}"
+      end
+  end
+
+  it "should validate complex company" do
+    valid_company_params =
+      { :name => 'Foo Inc',
+        :company_number => '12345',
+        :jurisdiction_code => 'us_de',
+        :incorporation_date => '2010-10-20',
+        :dissolution_date => '2012-01-12'
+      }
+    errors = validate_datum_and_return_errors(valid_company_params)
+    errors.should be_empty
+  end
+
+  it "should not validate invalid company" do
+    invalid_company_params =
+      [
+        { :name => 'Foo Inc',
+          :jurisdiction_code => 'ie'
+        },
+        { :name => 'Foo Inc',
+          :jurisdiction_code => 'usa_de',
+          :company_number => '12345'
+        },
+        { :name => 'Bar',
+          :jurisdiction_code => 'us_de',
+          :company_number => ''
+        },
+        { :name => 'Foo Inc',
+          :jurisdiction_code => 'a',
+          :company_number => '12345'
+        },
+        { :name => '',
+          :jurisdiction_code => 'us_de',
+          :company_number => '12345'
+        },
+        { :name => 'Foo Inc',
+          :jurisdiction_code => 'us_de',
+          :company_number => '12345',
+          :foo => 'bar'
+        }
+    ]
+    invalid_company_params.each do |invalid_params|
+      errors = validate_datum_and_return_errors(invalid_params)
+      errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+    end
+  end
+
+  context "and company has registered_address" do
+    it "should be valid if it is a string" do
+      valid_company_params =
+        { :name => 'Foo Inc',
+          :company_number => '12345',
+          :jurisdiction_code => 'us_de',
+          :registered_address => '32 Foo St, Footown,'
+        }
+      errors = validate_datum_and_return_errors(valid_company_params)
+      errors.should be_empty
+    end
+
+    it "should be valid if it is nil" do
+      valid_company_params =
+        { :name => 'Foo Inc',
+          :company_number => '12345',
+          :jurisdiction_code => 'us_de',
+          :registered_address => nil
+        }
+      errors = validate_datum_and_return_errors(valid_company_params)
+      errors.should be_empty
+    end
+
+    it "should be valid if it is a valid address object" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :registered_address => { :street_address => '32 Foo St', :locality => 'Footown', :region => 'Fooshire', :postal_code => 'FO1 2BA' }
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :registered_address => { :street_address => '32 Foo St' }
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :registered_address => { :postal_code => 'FO1 2BA' }
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+    end
+
+    it "should not be valid if it is not a valid address object" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :registered_address => []
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :registered_address => ''
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :registered_address => {:country => 'Germany'}
+          },
+          # { :name => 'Foo Inc',
+          #   :company_number => '12345',
+          #   :jurisdiction_code => 'us_de',
+          #   :registered_address => {:country => 'Germany'}
+          # }
+        ]
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+    end
+  end
+
+  context "and company has previous names" do
+    it "should validate valid previous names data" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :previous_names => [{:company_name => 'FooBar Inc'},
+                                {:company_name => 'FooBaz', :con_date => '2012-07-22'},
+                                {:company_name => 'FooBaz', :con_date => '2012-07-22', :start_date => '2008-01-08'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            # allow empty arrays
+            :previous_names => []
+          }
+        ]
+      valid_company_params.each do |valid_params|
+        errors = validate_datum_and_return_errors(valid_params)
+        errors.should be_empty, "Valid params were not valid: #{valid_params}"
+      end
+    end
+
+    it "should not validated invalid previous names data" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :previous_names => 'some name'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :previous_names => ['some name']
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :previous_names => [{:name => 'Baz Inc'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :previous_names => [{:company_name => ''}]
+          }
+        ]
+
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+
+    end
+  end
+
+  context "and company has branch flag" do
+    it "should be valid if it is F or L or nil" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :branch => 'F'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :branch => 'L'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :branch => nil
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+
+    end
+
+    it "should not be valid if it is not F or L" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :branch => 'X'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :branch => 'FOO'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :branch => ''
+          }
+        ]
+        invalid_company_params.each do |invalid_params|
+          errors = validate_datum_and_return_errors(invalid_params)
+          errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+        end
+
+    end
+  end
+
+  context "and company has all_attributes" do
+    it "should allow arbitrary elements to all_attributes hash" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:foo => 'bar', :some_number => 42, :an_array => [1,2,3]}
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'us_de',
+            :all_attributes => {}
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+    end
+
+    it "should require jurisdiction_of_origin to be a non-empty string or null" do
+      valid_params_1 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:jurisdiction_of_origin => 'Some Country'}
+          }
+      valid_params_2 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:jurisdiction_of_origin => nil}
+          }
+      invalid_params_1 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:jurisdiction_of_origin => ''}
+          }
+      invalid_params_2 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:jurisdiction_of_origin => 43}
+          }
+      validate_datum_and_return_errors(valid_params_1).should be_empty
+      validate_datum_and_return_errors(valid_params_2).should be_empty
+      validate_datum_and_return_errors(invalid_params_1).should_not be_empty
+      validate_datum_and_return_errors(invalid_params_2).should_not be_empty
+    end
+
+    it "should require home_company_number to be a non-empty string or null" do
+      require_all_attributes_attribute_to_be_string_or_nil(:home_company_number)
+    end
+
+    it "should require home_legal_name to be a non-empty string or null" do
+      require_all_attributes_attribute_to_be_string_or_nil(:home_legal_name)
+    end
+
+    it "should require registered_agent_name to be a string or nil" do
+      require_all_attributes_attribute_to_be_string_or_nil(:registered_agent_name)
+    end
+
+    it "should require registered_agent_address to be a string or nil" do
+      require_all_attributes_attribute_to_be_string_or_nil(:registered_agent_address)
+    end
+
+    it "should require number_of_employees to be an positive" do
+      valid_params =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:number_of_employees => 42}
+          }
+      invalid_params_1 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:number_of_employees => ''}
+          }
+      invalid_params_2 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:number_of_employees => 'foo'}
+          }
+      invalid_params_3 =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :all_attributes => {:number_of_employees => -1}
+          }
+      validate_datum_and_return_errors(valid_params).should be_empty
+      validate_datum_and_return_errors(invalid_params_1).should_not be_empty
+      validate_datum_and_return_errors(invalid_params_2).should_not be_empty
+      validate_datum_and_return_errors(invalid_params_3).should_not be_empty
+    end
+  end
+
+  context "and company has officers" do
+    it "should validate if officers are valid" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => [{:name => 'Fred Flintstone'},
+                          {:name => 'Barney Rubble', :position => 'Director'},
+                          {:name => 'Barney Rubble', :other_attributes => {:foo => 'bar'}},
+                          {:name => 'Pebbles', :start_date => '2010-12-22', :end_date => '2011-01-03'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            # allow empty arrays
+            :officers => []
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}"
+        end
+    end
+
+    it "should not validate if officers are not valid" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => [{:name => ''}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => [{:position => 'Director'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => 'some body'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => [{:name => 'Fred',  :other_attributes => 'non object'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :officers => ['some body']
+          }
+        ]
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+    end
+  end
+
+  context "and company has filings" do
+    it "should validate if filings are valid" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:title => 'Annual Report', :date => '2010-11-22'},
+                          {:description => 'Another type of filing', :date => '2010-11-22'},
+                          {:title => 'Annual Report', :description => 'Another type of filing', :uid => '12345A321', :date => '2010-11-22'},
+                          {:filing_type_name => 'Some type', :date => '2010-11-22'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:title => 'Annual Report', :date => '2010-11-22', :other_attributes => {:foo => 'bar'}},
+                          {:filing_type_name => 'Some type', :filing_type_code => '10-K', :date => '2010-11-22'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            # allow empty arrays
+            :filings => []
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+    end
+
+    it "should not validate if filings are not valid" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:filing_type_name => 'Some type'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => 'foo filing'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => ['foo filing']
+          }
+        ]
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+    end
+
+    it "should require either title or description or filing_type_name to be present" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:filing_type_name => 'Some type', :date => '2010-11-22'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:description => 'Some type', :date => '2010-11-22'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:title => 'Some type', :date => '2010-11-22'}]
+          }
+        ]
+      invalid_params =
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :filings => [ {:uid => '12345', :date => '2010-11-22'}]
+          }
+      valid_company_params.each do |valid_params|
+        errors = validate_datum_and_return_errors(valid_params)
+        errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+      end
+
+      validate_datum_and_return_errors(invalid_params).should_not be_empty
+    end
+  end
+
+  context "and company has share_parcels" do
+    it "should validate if share_parcels are valid" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels =>
+              [ { :number_of_shares => 1234,
+                  :shareholders => [ {:name => 'Fred Flintstone'} ],
+                  :confidence => 42
+                 },
+                { :percentage_of_shares => 23.5,
+                  :shareholders => [ {:name => 'Barney Rubble'},
+                                     {:name => 'Wilma Flintstone'} ]
+                },
+              ]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            # allow empty arrays
+            :share_parcels => []
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+    end
+
+    it "should not validate if share_parcels are not valid" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels =>
+             [{ :percentage_of_shares => '23.5',
+                :shareholders => [ {:name => ''} ]}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels =>
+             [{ :percentage_of_shares => '23.5',
+                :shareholders => []}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels =>
+             [{ :percentage_of_shares => '23.5'}]
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels => 'foo filing'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :share_parcels => ['foo filing']
+          }
+        ]
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+    end
+  end
+
+  context "and company has total_shares" do
+    it "should validate if total_shares are valid" do
+      valid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares =>
+             { :number => 123,
+               :share_class => 'Ordinary' }
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares =>
+             { :number => 123 }
+          }
+        ]
+        valid_company_params.each do |valid_params|
+          errors = validate_datum_and_return_errors(valid_params)
+          errors.should be_empty, "Valid params were not valid: #{valid_params}.Errors = #{errors}"
+        end
+    end
+
+    it "should not validate if share_parcels are not valid" do
+      invalid_company_params =
+        [
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares =>
+             { :share_class => 'Ordinary' }
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares =>
+             { :number => 123,
+               :share_class => '' }
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares => 'foo filing'
+          },
+          { :name => 'Foo Inc',
+            :company_number => '12345',
+            :jurisdiction_code => 'ie',
+            :total_shares => ['foo filing']
+          }
+        ]
+      invalid_company_params.each do |invalid_params|
+        errors = validate_datum_and_return_errors(invalid_params)
+        errors.should_not be_empty, "Invalid params were not invalid: #{invalid_params}"
+      end
+    end
+  end
+
+  def validate_datum_and_return_errors(record)
+    errors = JSON::Validator.fully_validate(
+      @schema,
+      record.to_json,
+      {:errors_as_objects => true})
+  end
+
+  def require_all_attributes_attribute_to_be_string_or_nil(attribute_name)
+      ['Some String', nil].each do |val|
+        valid_params =
+            { :name => 'Foo Inc',
+              :company_number => '12345',
+              :jurisdiction_code => 'ie',
+              :all_attributes => {attribute_name => val}
+            }
+        validate_datum_and_return_errors(valid_params).should be_empty, "Valid params were not validated: #{valid_params}"
+      end
+
+      ['', 43].each do |val|
+        invalid_params =
+            { :name => 'Foo Inc',
+              :company_number => '12345',
+              :jurisdiction_code => 'ie',
+              :all_attributes => {attribute_name => val}
+            }
+        validate_datum_and_return_errors(invalid_params).should_not be_empty, "Invalid params were validated: #{invalid_params}"
+      end
+  end
+
+end