rgovdata 0.1.0

data/spec/unit/data/template_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe RGovData::Template do
+  subject { RGovData::Template }
+  it { should respond_to(:get) }
+
+  [
+    { :name => 'config_template.yml', :realm => nil, :expect => 'credentials'},
+    { :name => 'registry.yml', :realm => 'sg', :expect => 'description'},
+    { :name => 'registry.yml', :realm => :sg, :expect => 'description'},
+    { :name => 'registry.yml', :realm => 'zz', :expect => nil},
+    { :name => 'not_found.yml', :realm => nil, :expect => nil}
+  ].each do |options|
+    context "with #{options[:realm]}:#{options[:name]}" do
+
+      describe "##path" do
+        subject { RGovData::Template.path(options[:name],options[:realm]) }
+        it { File.exists?(subject).should == options[:expect].present? }
+      end
+
+      describe "##get" do
+        subject { RGovData::Template.get(options[:name],options[:realm]) }
+        if options[:expect]
+          it { should include(options[:expect]) }
+        else
+          it { should be_nil }
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/service/dataset/csv_dataset_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+include MocksHelper
+
+describe RGovData::CsvDataSet do
+
+  let(:dataset_key) { 'csv' }
+  let(:sample_file) { mock_file_path('sample.csv') }
+  let(:expect_row_count) { 820 }
+  let(:expect_headers) { ["Src", "Eqid", "Version", "Datetime", "Lat", "Lon", "Magnitude", "Depth", "NST", "Region"] }
+
+  let(:service) { RGovData::CsvService.new({:uri=>sample_file,:type=>'csv'}) }
+  let(:dataset) { RGovData::CsvDataSet.new({:dataset_key=>dataset_key},service) }
+
+  describe "#native_dataset_key" do
+    let(:expect) { dataset_key }
+    subject { dataset.native_dataset_key }
+    it { should eql(expect) }
+  end
+
+  describe "#attributes" do
+    subject { dataset.attributes }
+    it { should eql(expect_headers) }
+  end
+
+  describe "#records" do
+    subject { dataset.records }
+    its(:count) { should eql(expect_row_count) }
+
+    context "with a record_limit" do
+      let(:record_limit) { 3 }
+      before {
+        dataset.limit = record_limit
+      }
+      subject { dataset.records(true) }
+      it { should be_a(Array) }
+      its(:first) { should be_a(CSV::Row) }
+      its(:count) { should eql(record_limit) }
+    end
+  end
+  
+
+end

data/spec/unit/service/dataset/dataset_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe RGovData::DataSet do
+
+  let(:dataset_key) { 'Test' }
+  let(:service) { RGovData::Service.new({:type=>'dummy'}) }
+  let(:dataset) { RGovData::DataSet.new({:dataset_key=>dataset_key},service) }
+
+  describe "#limit" do
+    subject { dataset.limit }
+    context "not set" do
+      it { should be_nil }
+    end
+    context "set" do
+      let(:expect) { 5 }
+      before { dataset.limit = 5 }
+      it { should eql(expect) }
+    end
+  end
+
+  describe "#records" do
+    subject { dataset.records }
+    context "with only a single result from load_records" do
+      before {
+        dataset.stub(:load_records).and_return('single result')
+      }
+      it { should eql('single result') }
+    end
+    context "with only a single result from load_records" do
+      before {
+        dataset.stub(:load_records).and_return(['result 1','result 2'])
+      }
+      it { should be_a(Array) }
+    end
+  end
+
+end

data/spec/unit/service/dataset/file_dataset_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+include MocksHelper
+
+describe RGovData::FileDataSet do
+
+  let(:dataset_key) { 'file' }
+  let(:sample_file) { mock_file_path('sample.csv') }
+  let(:service) { RGovData::FileService.new({:uri=>sample_file,:type=>dataset_key}) }
+  let(:dataset) { RGovData::FileDataSet.new({:dataset_key=>dataset_key},service) }
+  
+  describe "#native_dataset_key" do
+    let(:expect) { dataset_key }
+    subject { dataset.native_dataset_key }
+    it { should eql(expect) }
+  end
+
+  describe "#attributes" do
+    let(:expect) { ['row'] }
+    subject { dataset.attributes }
+    it { should eql(expect) }
+  end
+
+  describe "#records" do
+    subject { dataset.records }
+    it { should be_a(StringIO) }
+  
+    context "with a record_limit" do
+      let(:record_limit) { 3 }
+      before {
+        dataset.limit = record_limit
+      }
+      subject { dataset.records(true) }
+      it { should be_a(Array) }
+      its(:first) { should be_a(String) }
+      its(:count) { should eql(record_limit) }
+    end
+  end
+
+
+end

data/spec/unit/service/dataset/odata_dataset_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe RGovData::OdataDataSet do
+
+  let(:credentialset) { 'basic' }
+  let(:dataset_key) { 'Test' }
+  let(:service) { RGovData::OdataService.new({:uri=>'uri',:type=>'odata',:credentialset=>credentialset}) }
+  let(:dataset) { RGovData::OdataDataSet.new({:dataset_key=>dataset_key},service) }
+
+  before {
+    # These tests won't call on a real service
+    OData::Service.any_instance.stub(:build_collections_and_classes).and_return(nil)
+    RGovData::Config.stub(:default_config_file).and_return(mock_configfile_path)
+    RGovData::Config.instance.load_default_config
+  }
+
+  describe "#native_dataset_key" do
+    let(:expect) { 'Test' }
+    subject { dataset.native_dataset_key }
+    it { should eql(expect) }
+  end
+
+  describe "#entity_name" do
+    {
+      'Test' => 'Test',
+      'TestSet'=>'Test'
+    }.each do |given_key,expect|
+      context "with dataset_key:#{given_key}" do
+        let(:dataset_key) { given_key }
+        subject { dataset.entity_name }
+        it { should eql(expect) }
+      end
+    end
+  end
+
+end

data/spec/unit/service/file_service_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RGovData::FileService do
+
+  let(:dataset_key) { 'file' }
+  let(:sample_file) { mock_file_path('sample.csv') }
+  let(:service) { RGovData::FileService.new({:uri=>sample_file,:type=>'file'}) }
+
+
+  describe "#dataset_keys" do
+    let(:expect) { [dataset_key] }
+    subject { service.dataset_keys }
+    it { should eql(expect) }
+  end
+
+  describe "#native_instance" do
+  end
+
+  describe "#datasets" do
+    subject { service.datasets }
+    it { should be_a(Array) }
+    its(:first) { should be_a(RGovData::FileDataSet) }
+  end
+
+end

data/spec/unit/service/listing_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe RGovData::ServiceListing do
+
+  describe "property:" do
+    subject { RGovData::ServiceListing.new }
+    [
+      :realm,:key,:name,:description,:keywords,:publisher,
+      :uri,:license,:type,:credentialset
+    ].each do |property|
+      describe property do
+        it "should support setter and getter" do
+          value = "x"
+          subject.send("#{property}=",value)
+          subject.send(property).should eql(value)
+        end
+      end
+    end
+  end
+
+  describe "#id" do
+    let(:realm) { :sg }
+    let(:key) { 'key_name' }
+    let(:expect) { '//sg/key_name' }
+    let(:listing) { RGovData::ServiceListing.new }
+    subject { listing }
+    before do
+      listing.realm = realm
+      listing.key = key
+    end
+    its(:id) { should eql(expect) }
+  end
+
+  describe "#service" do
+    [
+      {:type => :odata, :uri => 'http://example.com', :expect_class => RGovData::OdataService },
+      {:type => 'odata', :uri => 'http://example.com', :expect_class => RGovData::OdataService },
+      {:type => :csv, :uri => 'http://example.com', :expect_class => RGovData::FileService },
+      {:type => 'csv', :uri => 'http://example.com', :expect_class => RGovData::FileService },
+      {:type => :dummy, :uri => 'http://example.com', :expect_class => nil }
+    ].each do |options|
+      context "with type:#{options[:type]}" do
+        let(:listing) { RGovData::ServiceListing.new }
+        before do
+          listing.type = options[:type]
+          listing.uri = options[:uri]
+        end
+        subject { listing.service }
+        if options[:expect_class]
+          it { should be_a(options[:expect_class]) }
+        else
+          it { should be_nil }
+        end
+      end
+    end
+  end
+
+  describe "#datasets" do
+    let(:listing) { RGovData::ServiceListing.new }
+    let(:mock_datasets) { ['a','b'] }
+    before {
+      RGovData::Service.stub(:get_instance).and_return(RGovData::Service.new({:uri=>'uri',:type=>'type',:credentialset=>'credentialset'}))
+      RGovData::Service.any_instance.stub(:datasets).and_return(mock_datasets)
+    }
+    subject { listing.datasets }
+    it { should be_a(Array) }
+    it { should eql(mock_datasets) }
+
+    describe "#records" do
+      subject { listing.records }
+      it { should eql(mock_datasets) }
+    end
+
+    describe "#get_dataset" do
+      let(:key) { 'key' }
+      let(:mock_dataset_a) { 'mock_dataset_a' }
+      let(:mock_dataset_b) { 'mock_dataset_b' }
+      let(:mock_dataset) { [mock_dataset_a,mock_dataset_b] }
+      before {
+        RGovData::Service.any_instance.stub(:get_dataset).and_return(mock_dataset)
+      }
+      subject { listing.get_dataset(key) }
+      it { should eql(mock_dataset) }
+      describe "#find" do
+        subject { listing.find(key) }
+        it { should eql(mock_dataset_a) }
+      end
+      describe "#find_by_id" do
+        subject { listing.find_by_id(key) }
+        it { should eql(mock_dataset_a) }
+      end
+    end
+  end
+
+  describe "#to_s" do
+    its(:to_s) { should be_a(String) }
+  end
+
+  
+end

data/spec/unit/service/odata_service_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe RGovData::OdataService do
+
+  let(:credentialset) { 'basic' }
+  let(:service) { RGovData::OdataService.new({:uri=>'uri',:type=>'odata',:credentialset=>credentialset}) }
+
+  before {
+    # These tests won't call on a real service
+    OData::Service.any_instance.stub(:build_collections_and_classes).and_return(nil)
+    RGovData::Config.stub(:default_config_file).and_return(mock_configfile_path)
+    RGovData::Config.instance.load_default_config
+  }
+
+  describe "#native_instance" do
+    subject { service.native_instance }
+    it { should be_a(OData::Service) }
+
+    context "with basic credentials" do
+      subject { service.native_instance.instance_variable_get(:@rest_options) }
+      it "should have user set" do
+        subject[:user].should_not be_nil
+      end
+      it "should have password set" do
+        subject[:password].should_not be_nil
+      end
+    end
+
+    context "with projectnimbus credentials" do
+      let(:credentialset) { 'projectnimbus' }
+      subject { service.native_instance.instance_variable_get(:@rest_options) }
+      it "should have headers set" do
+        subject[:headers].should_not be_nil
+      end
+    end
+  end
+
+  describe "#datasets" do
+    
+  end
+
+end

data/spec/unit/service/service_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe RGovData::Service do
+
+  describe "##get_instance" do
+    context "with unsupported options" do
+      subject { RGovData::Service.get_instance({:uri=>'uri',:type=>'type',:transport=>'transport',:credentialset=>'credentialset'}) }
+      it { should be_nil }
+    end
+    context "with odata type" do
+      subject { RGovData::Service.get_instance({:uri=>'uri',:type=>'odata',:transport=>'odata',:credentialset=>'credentialset'}) }
+      it { should be_a(RGovData::OdataService) }
+    end
+    context "with csv type" do
+      subject { RGovData::Service.get_instance({:uri=>'uri',:type=>'csv',:transport=>'get',:credentialset=>'credentialset'}) }
+      it { should be_a(RGovData::FileService) }
+    end
+  end
+  
+  let(:service) { RGovData::Service.new({:realm=>:sg, :service_key=>'service_name', :uri=>'uri',:type=>'csv',:transport=>'get',:credentialset=>'credentialset'}) }
+  subject { service }
+  
+  it_behaves_like "includes common config"
+
+  describe "#native_instance" do
+    subject { service.native_instance }
+    it { should eql(service) }
+  end
+
+  describe "#meta_attributes" do
+    subject { service.meta_attributes }
+    it { should be_a(Array) }
+  end
+
+  describe "#initialization_hash" do
+    subject { service.initialization_hash }
+    let(:keys) { service.initialization_hash.keys }
+    it { should be_a(Hash) }
+    it "should contain members for all attributes" do
+      service.meta_attributes.each do |attribute|
+        keys.should include(attribute)
+      end
+    end
+  end
+
+  describe "#id" do
+    let(:expect) { '//sg/service_name' }
+    its(:id) { should eql(expect) }
+  end
+
+  describe "#datasets" do
+    let(:mock_dataset_a) { RGovData::DataSet.new({:dataset_key=>'mock_dataset_a'},service) }
+    let(:mock_dataset_b) { RGovData::DataSet.new({:dataset_key=>'mock_dataset_b'},service) }
+    let(:mock_datasets) { [mock_dataset_a,mock_dataset_b] }
+    before {
+      service.stub(:datasets).and_return(mock_datasets)
+    }
+    subject { service.datasets }
+    it { should be_a(Array) }
+    it { should eql(mock_datasets) }
+
+    describe "#records" do
+      subject { service.records }
+      it { should eql(mock_datasets) }
+    end
+
+    describe "#get_dataset" do
+      let(:key) { 'mock_dataset' }
+      subject { service.get_dataset(key) }
+      it { should eql(mock_datasets) }
+      describe "#find" do
+        subject { service.find(key) }
+        it { should eql(mock_dataset_a) }
+      end
+      describe "#find_by_id" do
+        subject { service.find_by_id(key) }
+        it { should eql(mock_dataset_a) }
+      end
+    end
+
+  end
+end