rgovdata 0.1.0

data/spec/integration/service/sg/nlb_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+# This runs integration tests against the actual OData service
+# It uses credentials from the rgovdata.conf file in the project root folder
+describe "SG NLB Service" do
+  let(:config) { RGovData::Config.instance }
+  before :all do
+    config.load_config(integration_test_config_filename, {:generate_default => true,:required => true})
+  end
+  after :all do
+    config.clear
+  end
+
+  describe "ServiceListing" do
+    let(:id) { '//sg/nlb' }
+    let(:dataset_key) { 'LibrarySet' }
+    let(:example_attribute) { 'LibraryID' }
+    let(:record_class) { Library }
+
+    let(:service_listing) { RGovData::Catalog.get(id) }
+
+    subject { service_listing }
+    it { should be_a(RGovData::ServiceListing) }
+
+    describe "#service" do
+      let(:service) { service_listing.service }
+      subject { service }
+      it { should be_a(RGovData::Service) }
+      describe "#dataset_keys" do
+        subject { service.dataset_keys }
+        it { should include(dataset_key) }
+      end
+    end
+
+    describe "#find" do
+      let(:dataset) { service_listing.find(dataset_key) }
+      subject { dataset }
+      it { should be_a(RGovData::OdataDataSet) }
+      describe "#attributes" do
+        subject { dataset.attributes }
+        it { should include(example_attribute) }
+      end
+      describe "#records" do
+        let(:record_limit) { 3 }
+        before {
+          dataset.limit = record_limit
+        }
+        subject { dataset.records }
+        it { should be_a(Array) }
+        its(:first) { should be_a(record_class) }
+        its(:count) { should eql(record_limit) }
+      end
+
+    end
+  end
+
+end

data/spec/integration/service/sg/places_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+# This runs integration tests against the actual OData service
+# It uses credentials from the rgovdata.conf file in the project root folder
+# describe "Places.sg Service" do
+#   let(:config) { RGovData::Config.instance }
+#   before :all do
+#     config.load_config(integration_test_config_filename, {:generate_default => true,:required => true})
+#   end
+#   after :all do
+#     config.clear
+#   end
+#
+#   describe "ServiceListing" do
+#     let(:id) { '//sg/places' }
+#     let(:dataset_key) { 'Places' }
+#     let(:example_attribute) { 'company_name' }
+#     let(:record_class) { Places }
+#
+#     let(:service_listing) { RGovData::Catalog.get(id) }
+#
+#     subject { service_listing }
+#     it { should be_a(RGovData::ServiceListing) }
+#
+#     describe "#service" do
+#       let(:service) { service_listing.service }
+#       subject { service }
+#       it { should be_a(RGovData::Service) }
+#       describe "#dataset_keys" do
+#         subject { service.dataset_keys }
+#         it { should include(dataset_key) }
+#         context "map to collections" do
+#           let(:collections) { service.native_instance.instance_variable_get(:@collections) }
+#           it "should include all" do
+#             collections.each do |collection|
+#               subject.should include(collection)
+#             end
+#           end
+#         end
+#       end
+#       # describe "#classes" do
+#       #   subject { service.native_instance.classes }
+#       #   it { puts subject.inspect }
+#       # end
+#       # describe "#class_metadata" do
+#       #   subject { service.native_instance.class_metadata }
+#       #   it { puts subject.inspect }
+#       # end
+#     end
+#
+#     describe "#find" do
+#       let(:dataset) { service_listing.find(dataset_key) }
+#       subject { dataset }
+#       it { should be_a(RGovData::OdataDataSet) }
+#       describe "#attributes" do
+#         subject { dataset.attributes }
+#         it { should include(example_attribute) }
+#       end
+#       describe "#records" do
+#         let(:record_limit) { 3 }
+#         before {
+#           dataset.limit = record_limit
+#         }
+#         subject { dataset.records }
+#         it { should be_a(Array) }
+#         its(:first) { should be_a(record_class) }
+#         its(:count) { should eql(record_limit) }
+#       end
+#
+#     end
+#   end
+#
+# end

data/spec/integration/service/us/eqs7day-M1_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+# This runs integration tests against the actual csv file service
+# It uses credentials from the rgovdata.conf file in the project root folder
+describe "Worldwide M1+ Earthquakes" do
+  let(:config) { RGovData::Config.instance }
+  before :all do
+    config.load_config(integration_test_config_filename, {:generate_default => true,:required => true})
+  end
+  after :all do
+    config.clear
+  end
+
+  describe "ServiceListing" do
+    let(:id) { '//us/eqs7day-M1' }
+    let(:dataset_key) { :csv }
+    let(:expect_attributes) { ["Src", "Eqid", "Version", "Datetime", "Lat", "Lon", "Magnitude", "Depth", "NST", "Region"] }
+    let(:record_class) { CSV::Row }
+
+    let(:service_listing) { RGovData::Catalog.get(id) }
+
+    subject { service_listing }
+    it { should be_a(RGovData::ServiceListing) }
+
+    describe "#service" do
+      let(:service) { service_listing.service }
+      subject { service }
+      it { should be_a(RGovData::Service) }
+      describe "#dataset_keys" do
+        subject { service.dataset_keys }
+        it { should include(dataset_key) }
+      end
+    end
+
+    describe "#find" do
+      let(:dataset) { service_listing.find(dataset_key) }
+      subject { dataset }
+      it { should be_a(RGovData::CsvDataSet) }
+      describe "#attributes" do
+        subject { dataset.attributes }
+        it { should eql(expect_attributes) }
+      end
+      describe "#records" do
+        let(:record_limit) { 3 }
+        before {
+          dataset.limit = record_limit
+        }
+        subject { dataset.records(true) }
+        it { should be_a(Array) }
+        its(:first) { should be_a(record_class) }
+        its(:count) { should eql(record_limit) }
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rgovdata'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  # config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # config.use_transactional_fixtures = true
+
+end

data/spec/support/config_examples.rb

@@ -0,0 +1,8 @@
+shared_examples_for "includes common config" do
+  # Expects on entry:
+  # +subject+ is set to the instance to test
+  describe "#config" do
+    it { should respond_to(:config) }
+    its(:config) { should be_a(RGovData::Config) }
+  end
+end

data/spec/support/mocks.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+
+module MocksHelper
+  def mock_file_path(key)
+    Pathname.new(File.dirname(__FILE__)).join('..','fixtures',key).to_s
+  end
+  def mock_text(key)
+    IO.read(mock_file_path(key))
+  end
+  def mock_xml(key)
+    Nokogiri::XML(mock_text(key))
+  end
+  def mock_rails_root
+    Pathname.new(File.dirname(__FILE__)).join('..','fixtures','rails_root')
+  end
+  def mock_configfile_path
+    Pathname.new(File.dirname(__FILE__)).join('..','fixtures','rgovdata.conf').to_s
+  end
+  def mock_configfile_path_notfound
+    Pathname.new(File.dirname(__FILE__)).join('..','fixtures','rgovdata-notfound.conf').to_s
+  end
+end

data/spec/support/utility.rb

@@ -0,0 +1,18 @@
+def get_temp_file(basename)
+  require 'tempfile'
+  f = Tempfile.new(basename)
+  path = f.path
+  f.close!()
+  path
+end
+
+def supported_realms
+  [:sg,:us]
+end
+
+# Returns the config for integration testing
+def integration_test_config_filename
+  filename = "#{File.dirname(__FILE__)}/../../#{RGovData::Config::BASE_NAME}"
+  STDERR.puts "Running integration tests with config: #{filename}"
+  filename
+end

data/spec/unit/catalog/base_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe RGovData::Catalog do
+
+  supported_realms.each do |realm|
+    context "with realm #{realm}" do
+      let(:catalog) { RGovData::Catalog.new(realm) }
+      subject { catalog }
+      its(:realm) { should eql(realm) }
+      describe "#services" do
+        subject { catalog.services }
+        it { should be_a(Array) }
+        its(:first) { should be_a(RGovData::ServiceListing) }
+      end
+    end
+  end
+
+  describe "#get_service" do
+    let(:catalog) { RGovData::Catalog.new(:sg) }
+    subject { catalog.get_service(key) }
+    context "with multiple matches" do
+      let(:key) { 'l' }
+      it { should be_a(Array) }
+      its(:first) { should be_a(RGovData::ServiceListing) }
+    end
+    context "with single match" do
+      let(:key) { 'nlb' }
+      it { should be_a(RGovData::ServiceListing) }
+      its(:realm) { should eql(:sg) }
+      its(:key) { should eql(key) }
+    end
+  end
+
+  describe "#realms" do
+    subject { RGovData::Catalog.new(nil).realms }
+    it { should be_a(Array) }
+    it "should include supported realms" do
+      subject.each do |realm_cat|
+        supported_realms.should include(realm_cat.realm)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    its(:to_s) { should be_a(String) }
+  end
+
+  describe "#records" do
+    context "without realm" do
+      subject { RGovData::Catalog.new(nil).records }
+      it { should be_a(Array) }
+      its(:first) { should be_a(RGovData::Catalog) }
+    end
+    context "with realm" do
+      subject { RGovData::Catalog.new(supported_realms.first).records }
+      it { should be_a(Array) }
+      its(:first) { should be_a(RGovData::ServiceListing) }
+    end
+  end
+
+  describe "##get" do
+    subject { RGovData::Catalog.get(key) }
+    context "with nil selector" do
+      let(:key) { nil }
+      it { should be_a(RGovData::Catalog) }
+      its(:realm) { should be_nil }
+    end
+    context "with blank selector" do
+      let(:key) { '' }
+      it { should be_a(RGovData::Catalog) }
+      its(:realm) { should be_nil }
+    end
+    context "with no realm" do
+      let(:key) { '//' }
+      it { should be_a(RGovData::Catalog) }
+      its(:realm) { should be_nil }
+    end
+    context "with realm only" do
+      ['//sg','::sg'].each do |key_test|
+        let(:key) { key_test}
+        it { should be_a(RGovData::Catalog) }
+        its(:realm) { should eql(:sg) }
+      end
+    end
+    context "with realm and service" do
+      let(:key) { '//sg/nlb' }
+      it { should be_a(RGovData::ServiceListing) }
+      its(:realm) { should eql(:sg) }
+      its(:key) { should eql('nlb') }
+    end
+  end
+
+end

data/spec/unit/catalog/registry_strategy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RGovData::RegistryStrategy do
+  {
+    :sg => {:class => RGovData::InternalRegistry}
+  }.each do |realm,options|
+    context "with realm #{realm}" do
+      describe "##instance_for_realm" do
+        subject { RGovData::RegistryStrategy.instance_for_realm(realm) }
+        it { should be_a(options[:class]) }
+        its(:realm) { should eql(realm) }
+        its(:load_services) { should be_a(Array) }
+      end
+    end
+  end
+
+  describe "#load_services" do
+    subject { RGovData::RegistryStrategy.new.load_services}
+    it { should eql([]) }
+  end
+
+  describe "#realm" do
+    let(:realm) { :xy }
+    subject { RGovData::RegistryStrategy.new(realm) }
+    its(:realm) { should eql(realm) }
+  end
+
+end

data/spec/unit/config/config_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+include MocksHelper
+
+describe RGovData::Config do
+  let(:config) { RGovData::Config.instance }
+
+  describe "##default_config_file" do
+    subject { RGovData::Config }
+    its(:default_config_file) { should match(RGovData::Config::BASE_NAME) }
+    it "should accept override parameter" do
+      subject.default_config_file('foo').should match(/foo/)
+    end
+  end
+
+  describe "##template" do
+    subject { RGovData::Config.template }
+    it { should be_a(String) }
+  end
+
+  describe "#show_status" do
+    it { config.should respond_to(:show_status) }
+  end
+
+  describe "#load_default_config" do
+    before {
+      ENV['rgovdata_username'] = nil
+      ENV['rgovdata_password'] = nil
+    }
+    context "with Rails environment" do
+      let(:expect) { 'rails_root_username' }
+      before {
+        config.stub(:rails_root).and_return(mock_rails_root)
+        config.load_default_config
+      }
+      subject { config.credentialsets['basic']['username']}
+      it "should load settings from the Rails.root/config/BASE_NAME file" do
+        should eql(expect)
+      end
+    end
+
+    context "with config file in pwd" do
+      let(:expect) { 'mock_username' }
+      before {
+        config.class.stub(:default_config_file).and_return(mock_configfile_path)
+        config.load_default_config
+      }
+      subject { config.credentialsets['basic']['username']}
+      it "should load settings from the pwd file" do
+        should eql(expect)
+      end
+    end
+
+    context "with no config file and no env setting" do
+      let(:expect) { nil }
+      before {
+        config.class.stub(:default_config_file).and_return(mock_configfile_path_notfound)
+        config.load_default_config
+      }
+      subject { config.credentialsets['basic']}
+      it "should load settings from the pwd file" do
+        should eql(expect)
+      end
+    end
+  end
+
+  describe "#load_config" do
+    let(:temp_config_file) { get_temp_file('rgovdata_config_test_') }
+    let(:config) { RGovData::Config.instance }
+    after do
+      File.delete(temp_config_file) if File.exists?(temp_config_file)
+    end
+    it "should not generate template file if auto-generation not enabled" do
+      expect {
+        config.load_config(temp_config_file,{:generate_default => false})
+      }.to raise_error(RGovData::Config::ConfigurationFileNotFound)
+    end
+    it "should generate template file if auto-generation is enabled" do
+      expect {
+        config.load_config(temp_config_file)
+      }.to raise_error(RGovData::Config::ConfigurationFileInitialized)
+      File.exists?(temp_config_file).should be_true
+    end
+  end
+
+  describe "#credentialsets" do
+    before :all do
+      config.load_config(config.class.template_path,{:generate_default => false})
+    end
+    {
+      "basic" => { "username" => "_insert_your_username_here_", "password" => "your_password"},
+      "projectnimbus" => { "AccountKey" => "_insert_your_key_here_", "UniqueUserID" => "00000000000000000000000000000001"}
+    }.each do |credentialset,options|
+      context credentialset do
+        subject { config.credentialsets[credentialset] }
+        it { should be_a(Hash)}
+        options.keys.each do |key|
+          describe key do
+            subject { config.credentialsets[credentialset][key] }
+            it { should eql(options[key]) }
+          end
+        end
+      end
+    end
+  end
+
+  {
+    'projectnimbus_account_key' => {:credentialset=>'projectnimbus', :item=>'AccountKey', :alt=>'UniqueUserID'},
+    'projectnimbus_unique_user_id' => {:credentialset=>'projectnimbus', :item=>'UniqueUserID', :alt=>'AccountKey'},
+    'rgovdata_username' => {:credentialset=>'basic', :item=>'username', :alt=>'password'},
+    'rgovdata_password' => {:credentialset=>'basic', :item=>'password', :alt=>'username'}
+  }.each do |override,options|
+    describe "#credentialsets ENV['#{override}'] override" do
+      let(:key) { 'abcdefg' }
+      before {
+        ENV[override] = key
+        config.load_config(config.class.template_path,{:generate_default => false})
+      }
+      after { ENV[override] = nil }
+      subject { config.credentialsets[options[:credentialset]][options[:item]] }
+      it { should eql(key) }
+      describe "other keys" do
+        subject { config.credentialsets[options[:credentialset]][options[:alt]] }
+        it "should not be affected" do
+          should_not be_nil
+        end
+      end
+    end
+  end
+
+end