icss 0.1.3 → 0.3.2

data/spec/protocol/protocol_catalog_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'icss'
+
+describe Icss::Meta::Protocol do
+  before do
+    Icss::Meta::Protocol.send :flush_registry
+    Icss::Meta::Protocol._catalog_loaded = true #prevent automatic loading of catalog
+  end
+  let(:protocol){ Icss::Meta::Protocol.receive(:protocol => 'test', :namespace => 'name.space') }
+  
+  # Calling receive adds protocol to registry with after_receiver
+  describe :registry do
+    specify { Icss::Meta::Protocol.registry.should include('name.space.test' => protocol) }
+  end
+  
+  describe '#find' do
+    context 'specific protocol name parameters' do
+      before { protocol } # load protocol into registry
+      it('return protocol'){ Icss::Meta::Protocol.find('name.space.test').should == protocol }
+      it('should error if not found'){ lambda{ Icss::Meta::Protocol.find('name.space.not.found') }.should raise_error(Icss::NotFoundError) }
+      it('should error for wildcard name'){ lambda{ Icss::Meta::Protocol.find('name.*.test') }.should raise_error(Icss::NotFoundError) }
+    end
+    
+    context 'wildcard protocol name parameters' do
+      before { protocol } # load protocol into registry
+      context ':all' do
+        it('accepts wilcard names'){ Icss::Meta::Protocol.find(:all, 'name.*').should == [protocol] }
+        it('returns empty array if not found'){ Icss::Meta::Protocol.find(:all, 'not.*.found').should == [] }
+      end
+      
+      context ':first' do
+        it('accepts wilcard names'){ Icss::Meta::Protocol.find(:first, 'name.*').should == protocol }
+        it('returns nil if not found'){ Icss::Meta::Protocol.find(:first, 'not.*.found').should be_nil }
+      end
+      
+      context ':last' do
+        it('accepts wilcard names'){ Icss::Meta::Protocol.find(:last, 'name.*').should == protocol }
+        it('returns nil if not found'){ Icss::Meta::Protocol.find(:last, 'not.*.found').should be_nil }
+      end
+    end
+  end
+  describe '#all, #first, #last' do 
+    before { protocol } # load protocol into registry
+    it('#all returns all protocols'){ Icss::Meta::Protocol.all.should == [protocol] }
+    it('#first returns first of all protocols'){ Icss::Meta::Protocol.first.should == protocol }
+    it('#last returns last of all protocols'){ Icss::Meta::Protocol.last.should == protocol }
+  end
+end

data/spec/protocol/protocol_validations_spec.rb

@@ -0,0 +1,176 @@
+require 'rubygems'
+require 'rspec'
+require 'icss'
+
+def template_icss
+  return <<EOS
+---
+namespace: foo.bar
+protocol: baz
+
+data_assets:
+- name: test_data_asset
+  location: data/test_data.tsv
+  type: test_data_record
+
+messages:
+  search:
+    doc: A testable template message
+    request:
+    - name: test_request
+      type: test_request_record
+    response: test_data_record
+    samples:
+    - request:
+      - first_param: foo
+        second_param: bar
+
+targets:
+  catalog:
+  - name: test_catalog_entry
+    title: Test Icss
+    description: This is a template Icss to test the error handling of the Icss library.
+    tags:
+    - test
+    - icss
+    - template
+    messages:
+    - search
+    packages:
+    - data_assets:
+      - test_data_asset
+
+types:
+- name: test_request_record
+  doc: A template request record
+  type: record
+  fields:
+  - name: first_param
+    doc: The first test parameter
+    type: string
+  - name: second param
+    doc: The second test parameter
+    type: string
+
+- name: test_complex_data
+  doc: A template complex data type
+  type: record
+  fields:
+  - name: field_one
+    doc: A simple field for a complex data type
+    type: string
+  - name: field_two
+    doc: Another simple field for a complex data type
+    type: string
+
+- name: test_data_record
+  doc: A template data record
+  type: record
+  fields:
+  - name: simple_data
+    doc: A simple piece of data
+    type: int
+  - name: complex_data
+    doc: A complex piece of data
+    type: test_complex_data
+
+EOS
+end
+
+describe "Icss::Meta::Protocol validations" do
+  before :each do
+    @template = YAML.load(template_icss)
+  end
+  
+  after :all do
+    Icss::Meta::TypeFactory.send :remove_instance_variable, :"@default_namespace"
+  end
+
+  it "should be able to receive a correctly formatted template Icss" do
+    lambda { @icss =Icss::Meta::Protocol.receive @template }.should_not raise_error
+    @icss.errors.should be_empty
+  end
+
+  it "should contain keys for all fields even if not included in the Icss file" do
+    @icss = Icss::Meta::Protocol.receive @template
+    @icss.keys.map{|k| k.to_s }.sort.should == (@template.keys | %w[code_assets _doc_hints _extra_params tags categories credits doc title]).sort
+  end
+
+  it "should generate an error when the namespace is formatted incorrectly" do
+    @template['namespace'] = '$bad_namespace'
+    Icss::Meta::Protocol.receive(@template).errors.keys.should == [:namespace]
+  end
+
+  it "should generate an error when the protocol is formatted incorrectly" do
+    @template['protocol'] = '$bad_protocol'
+    Icss::Meta::Protocol.receive(@template).errors.keys.should == [:protocol]
+  end
+
+  # context "Catalog Target" do
+  #
+  #   it "should generate an error when an undefined data_asset is specified" do
+  #     @template['targets']['catalog'].first['packages'].first['data_assets'] = ['fake_data_asset']
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:catalog]
+  #   end
+  #
+  #   it "should generate an error when an undefined message name is specified" do
+  #     @template['targets']['catalog'].first['messages'] = ['fake_message']
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:catalog]
+  #   end
+  #
+  # end
+  #
+  # context "Data Assets" do
+  #
+  #   it "should generate an error when an asset's type is undefined" do
+  #     @template['data_assets'].first['type'] = 'fake_data_asset'
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:data_assets]
+  #   end
+  #
+  # end
+  #
+  # context "Messages" do
+  #
+  #   it "should generate an error when a message's request type is undefined" do
+  #     @template['messages']['search']['request'].first['type'] = 'fake_request_type'
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:messages]
+  #   end
+  #
+  #   it "should generate an error when a message's response type is undefined" do
+  #     @template['messages']['search']['response'] = 'fake_response_type'
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:messages]
+  #   end
+  #
+  #   it "should generate an error when a message's sample request types do not match the request record" do
+  #     @template['messages']['search']['samples'].first['request'] = [{ 'foo' => 'bar' }]
+  #     Icss::Meta::Protocol.receive(@template).errors.keys.should == [:messages]
+  #   end
+  #
+  # end
+
+  context "Types" do
+
+    it "should raise an error when an bad type definition is given for a specific type" do
+      @template['types'].push({
+          'name' => 'fake_type_record',
+          'type' => 'fake'
+        })
+      lambda{ Icss::Meta::Protocol.receive(@template) }.should raise_error(Icss::NotFoundError, /Cannot find.*fake/)
+    end
+
+    it "should generate an error when an undefined type definition is given for a specific field" do
+      @template['types'].push({
+          'name' => 'fake_type_record',
+          'type' => 'record',
+          'fields' => [{
+              'name' => 'fake_field',
+              'type' => 'fake_type'
+            }]
+        })
+      lambda{ Icss::Meta::Protocol.receive(@template) }.should raise_error(Icss::NotFoundError, /Cannot find.*fake_type/)
+      
+    end
+
+  end
+
+end

data/spec/protocol/source_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'icss'
+
+describe Icss::Meta::Source do
+  before do
+    Icss::Meta::Source.send :flush_registry
+    Icss::Meta::Source._catalog_loaded = true #prevent automatic loading of catalog
+  end
+  let(:source){ Icss::Meta::Source.receive(:source_id => 'sources.test', :title => 'Test source', :description => 'Source description', :url => 'http://test.com') }
+  
+  describe '#name' do
+    specify { source.name.should == 'test' }
+  end
+  
+  describe '#fullname' do  
+    specify { source.fullname.should == 'sources.test' }
+  end
+  
+  
+  
+  # Calling receive adds source to registry with after_receiver
+  describe :registry do
+    specify { Icss::Meta::Source.registry.should include('sources.test' => source) }
+  end
+  
+  describe '#find' do
+    context 'specific source name parameters' do
+      before { source } # load source into registry
+      it('return source'){ Icss::Meta::Source.find('sources.test').should == source }
+      it('should error if not found'){ lambda{ Icss::Meta::Source.find('sources.not_found') }.should raise_error(Icss::NotFoundError) }
+      it('should error for wildcard name'){ lambda{ Icss::Meta::Source.find('sources.*.test') }.should raise_error(Icss::NotFoundError) }
+    end
+    
+    context 'wildcard source name parameters' do
+      before { source } # load source into registry
+      context ':all' do
+        it('accepts wilcard names'){ Icss::Meta::Source.find(:all, 'sources.*').should == [source] }
+        it('returns empty array if not found'){ Icss::Meta::Source.find(:all, 'not.*.found').should == [] }
+      end
+      
+      context ':first' do
+        it('accepts wilcard names'){ Icss::Meta::Source.find(:first, 'sources.*').should == source }
+        it('returns nil if not found'){ Icss::Meta::Source.find(:first, 'not.*.found').should be_nil }
+      end
+      
+      context ':last' do
+        it('accepts wilcard names'){ Icss::Meta::Source.find(:last, 'sources.*').should == source }
+        it('returns nil if not found'){ Icss::Meta::Source.find(:last, 'not.*.found').should be_nil }
+      end
+    end
+  end
+  describe '#all, #first, #last' do 
+    before { source } # load source into registry
+    it('#all returns all sources'){ Icss::Meta::Source.all.should == [source] }
+    it('#first returns first of all sources'){ Icss::Meta::Source.first.should == source }
+    it('#last returns last of all sources'){ Icss::Meta::Source.last.should == source }
+  end
+  
+  describe '#to_hash' do
+    it { source.to_hash.should == {:source_id => 'sources.test',
+                                   :title => 'Test source',
+                                   :description => 'Source description',
+                                   :url => 'http://test.com'}}
+  end
+end

data/spec/protocol_spec.rb

@@ -1,26 +1,27 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'icss'
 
-describe Icss::Protocol do
+describe Icss::Meta::Protocol do
+  
   let(:simple_icss) do
-    Icss::Protocol.receive_from_file(ICSS_ROOT_DIR('examples/chronic.icss.yaml'))
+    Icss::Meta::Protocol.receive_from_file(ENV.root_path('examples/chronic.icss.yaml'))
   end
 
   it 'loads cleanly' do
-    simple_icss.name.should == 'chronic'
-    simple_icss.fullname.should == 'util.time.chronic'
+    simple_icss.basename.should == 'chronic'
+    simple_icss.fullname.should == 'st.time_utils.chronic'
   end
 
   describe '#fullname' do
-    it 'has namespace and name' do
-      simple_icss.fullname.should == 'util.time.chronic'
+    it 'has namespace and basename' do
+      simple_icss.fullname.should == 'st.time_utils.chronic'
       simple_icss.namespace = nil
       simple_icss.fullname.should == 'chronic'
     end
   end
   describe '#path' do
     it 'is a / separated version of the name, with no / at start' do
-      simple_icss.path.should == 'util/time/chronic'
+      simple_icss.path.should == 'st/time_utils/chronic'
     end
   end
   describe '#doc' do
@@ -31,7 +32,7 @@ describe Icss::Protocol do
 
   describe 'types' do
     it 'has an array of types' do
-      simple_icss.types.map(&:name).should == ['chronic_parse_params', 'chronic_parse_response']
+      simple_icss.types.map(&:basename).should == ['chronic_parse_params', 'chronic_parse_response']
     end
   end
 
@@ -41,73 +42,126 @@ describe Icss::Protocol do
     end
 
     it 'named each message for its key' do
-      simple_icss.messages['parse'].name.should == 'parse'
+      simple_icss.messages['parse'].basename.should == 'parse'
       simple_icss.receive!({ :messages => { 'foo' => { :request => [] } }})
-      simple_icss.messages['foo'].name.should == 'foo'
+      simple_icss.messages['foo'].basename.should == 'foo'
     end
 
     it '#find_message' do
       msg = simple_icss.find_message(:parse)
-      msg.should be_a(Icss::Message) ; msg.name.should == 'parse'
-      msg = simple_icss.find_message('util.time.parse')
-      msg.should be_a(Icss::Message) ; msg.name.should == 'parse'
-      msg = simple_icss.find_message('util/time/parse')
-      msg.should be_a(Icss::Message) ; msg.name.should == 'parse'
+      msg.should be_a(Icss::Meta::Message) ; msg.basename.should == 'parse'
+      msg = simple_icss.find_message('st.time_utils.parse')
+      msg.should be_a(Icss::Meta::Message) ; msg.basename.should == 'parse'
+      msg = simple_icss.find_message('st/time_utils/parse')
+      msg.should be_a(Icss::Meta::Message) ; msg.basename.should == 'parse'
     end
   end
 
   describe 'targets' do
     it 'has a hash of targets' do
-      simple_icss.targets.keys.should == ['catalog']
-      simple_icss.targets['catalog'].first.should be_a(Icss::CatalogTarget)
-      simple_icss.targets['catalog'].first.name.should == 'util_time_chronic_parse'
+      simple_icss.targets.keys.should == [:catalog]
+      simple_icss.targets[:catalog].first.should be_a(Icss::CatalogTarget)
+      simple_icss.targets[:catalog].first.basename.should == 'st_time_utils_chronic_parse'
+    end
+  end
+  
+  describe 'license' do
+    it 'returns nil if no license_id specified' do
+      simple_icss.license.should be_nil
+    end
+    it 'raises Icss::NotFoundError if license_id specified and not found' do
+      simple_icss.license_id = 'not_found_license'
+      lambda{ simple_icss.license }.should raise_error(Icss::NotFoundError, /Cannot find .*/)
+    end
+    it 'returns the Icss::Meta::License object' do
+      license = Icss::Meta::License.receive_from_file(ENV.root_path('examples/license.icss.yaml'))
+      simple_icss.license_id = 'licenses.example'
+      simple_icss.license.should == license
+    end
+  end
+  
+  
+  
+  describe 'sources' do
+    it 'returns empty array if no source_ids specified' do
+      simple_icss.sources.should == {}
+    end
+    it 'raises Icss::NotFoundError if license_id specified and not found' do
+      simple_icss.credits = { :role => 'not_found_license' }
+      lambda{ simple_icss.sources }.should raise_error(Icss::NotFoundError, /Cannot find .*/)
+    end
+    it 'returns array of Icss::Meta::Source objects' do
+      source2 = Icss::Meta::Source.receive_from_file(ENV.root_path('examples/source2.icss.yaml'))
+      source1 = Icss::Meta::Source.receive_from_file(ENV.root_path('examples/source1.icss.yaml'))
+      simple_icss.credits = {:main => 'sources.source1', :uploaded => 'sources.source2'}
+      simple_icss.sources.should == { :main => source1, :uploaded => source2 }
     end
   end
-
-  # describe 'tree_merge!' do
-  #   it 'merges recursively'
-  # end
 
   describe 'validations' do
     it 'validates protocol name' do
       simple_icss.should be_valid
-      simple_icss.protocol = '' ;    simple_icss.should_not be_valid ; simple_icss.errors[:protocol].should == ["can't be blank"]
-      simple_icss.protocol = '1bz' ; simple_icss.should_not be_valid ; simple_icss.errors[:protocol].should == ["must start with [A-Za-z_] and contain only [A-Za-z0-9_]."]
+      simple_icss.protocol = '' ;    simple_icss.should_not be_valid ; simple_icss.errors[:protocol].should include("can't be blank")
+      simple_icss.protocol = '1bz' ; simple_icss.should_not be_valid ; simple_icss.errors[:protocol].should include("must start with [A-Za-z_] and contain only [A-Za-z0-9_].")
     end
 
     it 'validates namespace' do
       simple_icss.should be_valid
-      simple_icss.namespace = '' ;    simple_icss.should_not be_valid ; simple_icss.errors[:namespace].should == ["can't be blank"]
-      simple_icss.namespace = '1bz' ; simple_icss.should_not be_valid ; simple_icss.errors[:namespace].first.should =~ /must be a dot-s/
+      simple_icss.namespace = '' ;    simple_icss.should_not be_valid ; simple_icss.errors[:namespace].should include("can't be blank")
+      simple_icss.namespace = '1bz' ; simple_icss.should_not be_valid ; simple_icss.errors[:namespace].first.should =~ /Segments that start with.*joined by.*dots/
     end
   end
 
   describe '#to_hash' do
     it 'roundtrips' do
+      simple_icss.license_id = 'licenses.example'
+      simple_icss.credits    = { :original => 'sources.source1' }
+      simple_icss.tags       = ['tag1', 'tag2', 'tag3']
+      simple_icss.categories = ['category1', 'category2', 'category3']
       hsh = simple_icss.to_hash
       hsh.should == {
-        :namespace=>"util.time", :protocol=>"chronic",
+        :namespace=>"st.time_utils", :protocol=>"chronic",
         :doc=>"A series of calls hooking into the Chronic ruby gem",
+        :license_id=>"licenses.example",
+        :credits=>{:original=>"sources.source1"},
+        :tags=>['tag1', 'tag2', 'tag3'],
+        :categories=>['category1', 'category2', 'category3'],
         :types => [
-          {:name=>"chronic_parse_params",   :doc=>"Query API parameters for the /util/time/chronic/parse call", :type=>:record,
+          {:name=>"st.time_utils.chronic_parse_params",
+           :namespace=>"st.time_utils",
+           :type=>:record,
+           :doc=>"Query API parameters for the /st/time_utils/chronic/parse call",
             :fields=>[
-              {:name=>"time_str", :type=>:string, :doc=>"The string to parse."},
-              {:name=>"context", :type=>:symbol, :doc=>"<tt>past</tt> or <tt>future</tt> (defaults to <tt>future</tt>)\nIf your string represents a birthday, you can set <tt>context</tt> to <tt>past</tt> and if an ambiguous string is given, it will assume it is in the past. Specify <tt>future</tt> or omit to set a future context."},
-              {:name=>"now", :type=>:time, :doc=>"Time (defaults to Time.now)\nBy setting <tt>:now</tt> to a Time, all computations will be based off of that time instead of Time.now. If set to nil, Chronic will use the current time in UTC. You must supply a date that unambiguously parses with the much-less-generous ruby Time.parse()"},
-              {:name=>"ambiguous_time_range", :type=>:int, :doc=>"Integer or <tt>:none</tt> (defaults to <tt>6</tt> (6am-6pm))\nIf an Integer is given, ambiguous times (like 5:00) will be assumed to be within the range of that time in the AM to that time in the PM. For example, if you set it to <tt>7</tt>, then the parser will look for the time between 7am and 7pm. In the case of 5:00, it would assume that means 5:00pm. If <tt>:none</tt> is given, no assumption will be made, and the first matching instance of that time will be used."}
+              {:name=>:time_str,             :type=>:string, :doc=>"The string to parse."},
+              {:name=>:context,              :type=>:symbol, :doc=>"<tt>past</tt> or <tt>future</tt> (defaults to <tt>future</tt>)\nIf your string represents a birthday, you can set <tt>context</tt> to <tt>past</tt> and if an ambiguous string is given, it will assume it is in the past. Specify <tt>future</tt> or omit to set a future context."},
+              {:name=>:now,                  :type=>:time,   :doc=>"Time (defaults to Time.now)\nBy setting <tt>:now</tt> to a Time, all computations will be based off of that time instead of Time.now. If set to nil, Chronic will use the current time in UTC. You must supply a date that unambiguously parses with the much-less-generous ruby Time.parse()"},
+              {:name=>:ambiguous_time_range, :type=>:int,    :doc=>"Integer or <tt>:none</tt> (defaults to <tt>6</tt> (6am-6pm))\nIf an Integer is given, ambiguous times (like 5:00) will be assumed to be within the range of that time in the AM to that time in the PM. For example, if you set it to <tt>7</tt>, then the parser will look for the time between 7am and 7pm. In the case of 5:00, it would assume that means 5:00pm. If <tt>:none</tt> is given, no assumption will be made, and the first matching instance of that time will be used."}
             ]},
-          {:name=>"chronic_parse_response", :doc=>"Query API response for the /util/time/chronic/parse call",   :type=>:record,
+          {:name=>"st.time_utils.chronic_parse_response",
+           :namespace=>"st.time_utils",
+           :type=>:record,
+           :doc=>"Query API response for the /util/time/chronic/parse call",
             :fields=>[
-              {:name=>"time", :type=>:string, :doc=>"The UTC parsed time, as a \"ISO 8601 combined date time\":http://en.wikipedia.org/wiki/ISO_8601 string."},
-              {:name=>"epoch_seconds", :type=>:int, :doc=>"The UTC parsed time, as \"epoch seconds\":http://en.wikipedia.org/wiki/Epoch_seconds integer."}
+              {:name=>:time,                 :type=>:string, :doc=>"The UTC parsed time, as a \"ISO 8601 combined date time\":http://en.wikipedia.org/wiki/ISO_8601 string."},
+              {:name=>:epoch_seconds,        :type=>:int,    :doc=>"The UTC parsed time, as \"epoch seconds\":http://en.wikipedia.org/wiki/Epoch_seconds integer."}
             ]}
         ],
         :messages => {
-          'parse' => {:doc=>"\nChronic is a natural language date/time parser written in pure Ruby. See below\nfor the wide variety of formats Chronic will parse.", :request=>[{:name=>"chronic_parse_params", :type=>"chronic_parse_params"}], :response=>"chronic_parse_response", :samples=>[{:request=>[{"time_str"=>"one hour ago", "now"=>"2007-03-16T12:09:08Z"}], :response=>{"epoch_seconds"=>1174043348, "time"=>"2007-03-16T11:09:08Z"}, :url=>"?now=2007-03-16T12%3A09%3A08Z&time_str=one%20hour%20ago"}, {:request=>[{"time_str"=>"Yesterday", "now"=>"5:06:07T2010-08-08Z"}], :response=>{"epoch_seconds"=>1281182400, "time"=>"2010-08-07T12:00:00Z"}, :url=>"?now=5%3A06%3A07%202010-08-08&time_str=Yesterday"}, {:url=>"?time_str=5pm+on+November+4th&context=past"}]},
+          :parse => {
+            :request  =>[{:name=>:chronic_parse_params, :type=>"st.time_utils.chronic_parse_params"}],
+            :response =>"st.time_utils.chronic_parse_response",
+            :doc=>"\nChronic is a natural language date/time parser written in pure Ruby. See below\nfor the wide variety of formats Chronic will parse.",
+            :samples  =>[{
+                :request=>[{"time_str"=>"one hour ago", "now"=>"2007-03-16T12:09:08Z"}],
+                :response=>{"epoch_seconds"=>1174043348, "time"=>"2007-03-16T11:09:08Z"}, :url=>"?now=2007-03-16T12%3A09%3A08Z&time_str=one%20hour%20ago"},
+              {:request=>[{"time_str"=>"Yesterday", "now"=>"5:06:07T2010-08-08Z"}],
+                :response=>{"epoch_seconds"=>1281182400, "time"=>"2010-08-07T12:00:00Z"}, :url=>"?now=5%3A06%3A07%202010-08-08&time_str=Yesterday"},
+              {:url=>"?time_str=5pm+on+November+4th&context=past"}]
+          },
         },
         :data_assets=>[],
         :code_assets=>[{:location=>"code/chronic_endpoint.rb"}],
-        :targets => {"catalog"=>[{:name=>"util_time_chronic_parse", :title=>"Utils - Parse Times", :description=>"An API call to parse human-readable date / time strings", :tags=>["apiawesome", "ruby", "gems", "chronic", "time", "date", "util", "parse"], :messages=>["parse"]}]},
+        :targets => {:catalog=>[{:name=>"st_time_utils_chronic_parse", :title=>"Utils - Parse Times", :description=>"An API call to parse human-readable date / time strings", :tags=>["apiawesome", "ruby", "gems", "chronic", "time", "date", "util", "parse"], :messages=>["parse"]}]},
       }
     end
   end