occi 2.2.2 → 2.3.0

data/lib/occi/parser.rb

@@ -1,6 +1,10 @@
+require 'rubygems'
 require 'json'
 require 'nokogiri'
 require 'hashie/mash'
+require 'rubygems/package'
+require 'zlib'
+require 'tempfile'
 require 'occi/collection'
 require 'occi/log'
 require 'occiantlr/OCCIANTLRParser'
@@ -8,58 +12,41 @@ require 'occiantlr/OCCIANTLRParser'
 module OCCI
   class Parser
 
-=begin
-          if content_type.includes?('multipart')
-            # TODO: implement multipart handling
-            # handle file upload
-            if params['file'] != nil
-              OCCI::Log.debug("Location of Image #{params['file'][:tempfile].path}")
-              $image_path = OCCI::Server.config[:one_image_tmp_dir] + '/' + params['file'][:filename]
-              FileUtils.cp(params['file'][:tempfile].path, $image_path)
-            end
-
-            # handle file upload in multipart requests
-            request.POST.values.each do |body|
-              if body.kind_of?(String)
-                parse_text(body)
-              elsif body.kind_of?(Hash)
-                if body['type'].include?('application/json')
-                  # try to parse body as JSON object
-                  parse_json(body.read)
-                elsif body['type'].include?('text/plain') # text/plain
-                  parse_text(body.read)
-                end unless body['type'].nil?
-              end
-            end
-          end
-=end
+    # Declaring Class constants for OVF XML namespaces (defined in OVF specification ver.1.1)
+    OVF   ="http://schemas.dmtf.org/ovf/envelope/1"
+    RASD  ="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
+    VSSD  ="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
+    OVFENV="http://schemas.dmtf.org/ovf/environment/1"
+    CIM   ="http://schemas.dmtf.org/wbem/wscim/1/common"
 
     # Parses an OCCI message and extracts OCCI relevant information
     # @param [String] media_type the media type of the OCCI message
     # @param [String] body the body of the OCCI message
     # @param [true, false] category for text/plain and text/occi media types information e.g. from the HTTP request location is needed to determine if the OCCI message includes a category or an entity
+    # @param [OCCI::Core::Resource,OCCI::Core::Link] entity_type entity type to use for parsing of text plain entities
     # @param [Hash] header optional header of the OCCI message
     # @return [Array<Array, OCCI::Collection>] list consisting of an array of locations and the OCCI object collection
-    def self.parse(media_type, body, category=false, header={ })
-      OCCI::Log.debug('### Parsing request data to OCCI data structure ###')
+    def self.parse(media_type, body, category=false, entity_type=OCCI::Core::Resource, header={ })
+      OCCI::Log.debug '### Parsing request data to OCCI data structure ###'
       collection = OCCI::Collection.new
 
       locations = self.header_locations(header)
-      category ? collection = self.header_categories(header) : collection = self.header_entity(header) if locations.empty?
+      category ? collection = self.header_categories(header) : collection = self.header_entity(header, entity_type) if locations.empty?
 
       case media_type
-        when 'text/occi'
         when 'text/uri-list'
           body.each_line { |line| locations << URI.parse(line) }
         when 'text/plain', nil
           locations.concat self.text_locations(body)
-            category ? collection = self.text_categories(body) : collection = self.text_entity(body) if locations.empty? && collection.empty?
+          category ? collection = self.text_categories(body) : collection = self.text_entity(body, entity_type) if locations.empty? && collection.empty?
         when 'application/occi+json', 'application/json'
           collection = self.json(body)
         when 'application/occi+xml', 'application/xml'
           collection = self.xml(body)
-        #when 'application/ovf+xml'
-        #  collection = self.ovf(body)
+        when 'application/ovf', 'application/ovf+xml'
+          collection = self.ovf(body)
+        when 'application/ova'
+          collection = self.ova(body)
         else
           raise "Content Type not supported"
       end
@@ -78,14 +65,14 @@ module OCCI
       category_strings = header['HTTP_CATEGORY'].to_s.split(',')
       category_strings.each do |cat|
         category = OCCIANTLR::Parser.new('Category: ' + cat).category
-        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind) }
-        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin) }
-        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action) }
+        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
       end
       collection
     end
 
-    def self.header_entity(header)
+    def self.header_entity(header, entity_type)
       collection       = OCCI::Collection.new
       entity           = Hashie::Mash.new
       category_strings = header['HTTP_CATEGORY'].to_s.split(',')
@@ -97,14 +84,11 @@ module OCCI
       entity.kind = categories.kinds.first.scheme + categories.kinds.first.term
       entity.mixins = categories.mixins.collect { |mixin| mixin.scheme + mixin.term } if categories.mixins.any?
       attribute_strings.each { |attr| entity.attributes!.merge!(OCCIANTLR::Parser.new('X-OCCI-Attribute: ' + attr).x_occi_attribute) }
-      kind = OCCI::Model.get_by_id(entity.kind)
-      # TODO: error handling
-      return collection if kind.nil?
-      if kind.entity_type == OCCI::Core::Link.name
-        entity.target = link.attributes.occi!.core!.target
-        entity.source = link.attributes.occi!.core!.source
+      if entity_type == OCCI::Core::Link
+        entity.target = link.attributes!.occi!.core!.target
+        entity.source = link.attributes!.occi!.core!.source
         collection.links << OCCI::Core::Link.new(entity)
-      elsif kind.entity_type == OCCI::Core::Resource.name
+      elsif entity_type == OCCI::Core::Resource
         link_strings = header['HTTP_LINK'].to_s.split(',')
         link_strings.each { |link| entity.links << OCCIANTLR::Parser.new('Link: ' + link).link }
         collection.resources << OCCI::Core::Resource.new(entity)
@@ -121,14 +105,14 @@ module OCCI
       text.each_line do |line|
         category = OCCIANTLR::Parser.new(line).category
         next if category.nil?
-        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind) }
-        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin) }
-        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action) }
+        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
       end
       collection
     end
 
-    def self.text_entity(text)
+    def self.text_entity(text, entity_type)
       collection = OCCI::Collection.new
       entity     = Hashie::Mash.new
       links      = []
@@ -140,14 +124,11 @@ module OCCI
       end
       entity.kind = categories.kinds.first.scheme + categories.kinds.first.term if categories.kinds.first
       entity.mixins = categories.mixins.collect { |mixin| mixin.scheme + mixin.term } if entity.mixins
-      kind = OCCI::Model.get_by_id(entity.kind)
-      # TODO: error handling
-      return collection if kind.nil?
-      if OCCI::Model.get_by_id(entity.kind).entity_type == OCCI::Core::Link.name
-        entity.target = links.first.attributes.occi!.core!.target
-        entity.source = links.first.attributes.occi!.core!.source
+      if entity_type == OCCI::Core::Link
+        entity.target = links.first.attributes!.occi!.core!.target
+        entity.source = links.first.attributes!.occi!.core!.source
         collection.links << OCCI::Core::Link.new(entity)
-      elsif OCCI::Model.get_by_id(entity.kind).entity_type == OCCI::Core::Resource.name
+      elsif entity_type == OCCI::Core::Resource
         entity.links = links
         collection.resources << OCCI::Core::Resource.new(entity)
       end unless entity.kind.nil?
@@ -157,27 +138,173 @@ module OCCI
     def self.json(json)
       collection = OCCI::Collection.new
       hash       = Hashie::Mash.new(JSON.parse(json))
-      collection.kinds.concat hash.kinds.collect { |kind| OCCI::Core::Kind.new(kind) } if hash.kinds
-      collection.mixins.concat hash.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin) } if hash.mixins
-      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource) } if hash.resources
-      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link) } if hash.links
+      collection.kinds.concat hash.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if hash.kinds
+      collection.mixins.concat hash.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
+      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.links) } if hash.resources
+      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link.kind, link.mixins, link.attributes) } if hash.links
       collection
     end
 
     def self.xml(xml)
       collection = OCCI::Collection.new
       hash       = Hashie::Mash.new(Hash.from_xml(Nokogiri::XML(xml)))
-      collection.kinds.concat hash.kinds.collect { |kind| OCCI::Core::Kind.new(kind) } if hash.kinds
-      collection.mixins.concat hash.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin) } if hash.mixins
-      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource) } if hash.resources
-      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link) } if hash.links
+      collection.kinds.concat hash.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if hash.kinds
+      collection.mixins.concat hash.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
+      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.links) } if hash.resources
+      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link.kind, link.mixins, link.attributes) } if hash.links
       collection
     end
 
-    #def self.ovf(ovf)
-    # TODO: implement ovf / ova messages
-    #end
 
+    ####################Helper method for calculation of storage size based on allocation units configured###########
+    def self.calculate_capacity_bytes(capacity, alloc_units_bytes)
+      total_capacity_bytes = alloc_units_bytes * capacity.to_i
+      total_capacity_bytes
+    end
+
+
+    def self.calculate_capacity_gb(capacity)
+      capacity_gb = capacity/(2**30)
+      capacity_gb
+    end
+
+
+    def self.alloc_units_bytes(alloc_units)
+      units = alloc_units.split('*')
+      #check units[1] is nil??
+      units[1].strip!
+      alloc_vars        = units[1].split('^')
+      alloc_units_bytes = (alloc_vars[0].to_i**alloc_vars[1].to_i)
+      alloc_units_bytes
+    end
+
+    ###############End of Helper methods for OVF Parsing ##################################################################
+
+    def self.ova(ova)
+      tar   = Gem::Package::TarReader.new(StringIO.new(ova))
+      ovf   = mf = cert = nil
+      files = { }
+      tar.each do |entry|
+        tempfile = Tempfile.new(entry.full_name)
+        tempfile.write(entry.read)
+        tempfile.close
+        files[entry.full_name] = tempfile.path
+        ovf = tempfile.path if entry.full_name.end_with? '.ovf'
+        mf = tempfile.path if entry.full_name.end_with? '.mf'
+        cert = tempfile.path if entry.full_name.end_with? '.cert'
+      end
+
+      File.read(mf).each_line do |line|
+        name = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.first
+        sha1 = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.last
+        puts Digest::SHA1.hexdigest(files[name])
+        raise "SHA1 mismatch for file #{name}" if Digest::SHA1.hexdigest(File.read(files[name])) != sha1
+      end if mf
+
+      raise 'no ovf file found' if ovf.nil?
+
+      self.ovf(File.read(ovf), files)
+    end
+
+    def self.ovf(ovf, files={ })
+      collection = OCCI::Collection.new
+      doc        = Nokogiri::XML(ovf)
+      references = { }
+
+      doc.xpath('envelope:Envelope/envelope:References/envelope:File', 'envelope' => "#{Parser::OVF}").each do |file|
+        href = URI.parse(file.attributes['href'].to_s)
+        if href.relative?
+          references[file.attributes['id'].to_s] = 'file://' + files[href.to_s] if files[href.to_s]
+        else
+          references[file.attributes['id'].to_s] = href
+        end
+      end
+
+      doc.xpath('envelope:Envelope/envelope:DiskSection/envelope:Disk', 'envelope' => "#{Parser::OVF}").each do |disk|
+        storage = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#storage')
+        if disk.attributes['fileRef']
+          storagelink                               = OCCI::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
+          storagelink.attributes.occi!.core!.title  = disk.attributes['fileRef'].to_s
+          storagelink.attributes.occi!.core!.target = references[disk.attributes['fileRef'].to_s]
+          storage.attributes.occi!.core!.title      = disk.attributes['diskId'].to_s
+          storage.links << storagelink
+        else
+          #OCCI accepts storage size in GB
+          #OVF ver 1.1: The capacity of a virtual disk shall be specified by the ovf:capacity attribute with an xs:long integer
+          #value. The default unit odf allocation shall be bytes. The optional string attribute
+          #ovf:capacityAllocationUnits may be used to specify a particular unit of allocation.
+          alloc_units = disk.attributes['capacityAllocationUnits'].to_s
+          if alloc_units.empty?
+            # The capacity is defined in bytes , convert to GB and pass it to OCCI
+            capacity = disk.attributes['capacity'].to_s
+            capacity =capacity.to_i
+          else
+            alloc_unit_bytes = self.alloc_units_bytes(alloc_units)
+            capacity         = self.calculate_capacity_bytes(disk.attributes['capacity'].to_s, alloc_unit_bytes)
+          end
+          capacity_gb = self.calculate_capacity_gb(capacity)
+          OCCI::Log.debug('capacity in gb ' + capacity_gb.to_s)
+          storage.attributes.occi!.storage!.size = capacity_gb.to_s if capacity_gb
+          storage.attributes.occi!.core!.title = disk.attributes['diskId'].to_s if disk.attributes['diskId']
+        end
+        collection.resources << storage
+      end
+
+      doc.xpath('envelope:Envelope/envelope:NetworkSection/envelope:Network', 'envelope' => "#{Parser::OVF}").each do |nw|
+        network                              = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#network')
+        network.attributes.occi!.core!.title = nw.attributes['name'].to_s
+        collection.resources << network
+      end
+
+      # Iteration through all the virtual hardware sections,and a sub-iteration on each Item defined in the Virtual Hardware section
+      doc.xpath('envelope:Envelope/envelope:VirtualSystem', 'envelope' => "#{Parser::OVF}").each do |virtsys|
+        compute = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#compute')
+
+        doc.xpath('envelope:Envelope/envelope:VirtualSystem/envelope:VirtualHardwareSection', 'envelope' => "#{Parser::OVF}").each do |virthwsec|
+          compute.attributes.occi!.core!.summary = virthwsec.xpath("item:Info/text()", 'item' => "#{Parser::RASD}").to_s
+
+          virthwsec.xpath('envelope:Item', 'envelope' => "#{Parser::OVF}").each do |resource_alloc|
+            resType = resource_alloc.xpath("item:ResourceType/text()", 'item' => "#{Parser::RASD}")
+            case resType.to_s
+              # 4 is the ResourceType for memory in the CIM_ResourceAllocationSettingData
+              when "4" then
+                compute.attributes.occi!.compute!.memory = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{Parser::RASD}").to_s.to_i
+              # 3 is the ResourceType for processor in the CIM_ResourceAllocationSettingData
+              when "3" then
+                compute.attributes.occi!.compute!.cores = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{Parser::RASD}").to_s.to_i
+              when "10" then
+                networkinterface                              = OCCI::Core::Link.new('http://schemas.ogf.org/occi/infrastructure#networkinterface')
+                networkinterface.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{Parser::RASD}").to_s
+                id                                            = resource_alloc.xpath("item:Connection/text()", 'item' => "#{Parser::RASD}").to_s
+                network                                       = collection.resources.select { |resource| resource.attributes.occi!.core!.title == id }.first
+                raise "Network with id #{id} not found" unless network
+                networkinterface.attributes.occi!.core!.target = network.location
+              when "17" then
+                storagelink                              = OCCI::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
+                storagelink.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{Parser::RASD}").to_s
+                # extract the mountpoint
+                host_resource                            = resource_alloc.xpath("item:HostResource/text()", 'item' => "#{Parser::RASD}").to_s
+                if host_resource.start_with? 'ovf:/disk/'
+                  id      = host_resource.gsub('ovf:/disk/', '')
+                  storage = collection.resources.select { |resource| resource.attributes.occi!.core!.title == id }.first
+                  raise "Disk with id #{id} not found" unless storage
+                  storagelink.attributes.occi!.core!.target = storage.location
+                elsif host_resource.start_with? 'ovf:/file/'
+                  id                                        = host_resource.gsub('ovf:/file/','')
+                  storagelink.attributes.occi!.core!.target = references[id]
+                end
+                compute.links << storagelink
+            end
+            ##Add the cpu architecture
+            #system_sec                                      = virthwsec.xpath('envelope:System', 'envelope' => "#{Parser::OVF}")
+            #virtsys_type                                    = system_sec.xpath('vssd_:VirtualSystemType/text()', 'vssd_' => "#{Parser::VSSD}")
+            #compute.attributes.occi!.compute!.architecture = virtsys_type
+          end
+        end
+        collection.resources << compute
+      end
+      collection
+    end
   end
 
 end

data/lib/occi/version.rb

@@ -1,3 +1,3 @@
 module OCCI
-  VERSION = "2.2.2" unless defined?(::OCCI::VERSION)
+  VERSION = "2.3.0" unless defined?(::OCCI::VERSION)
 end

data/spec/occi/client_spec.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'occi'
+
+module OCCI
+  describe Client do
+
+    it "should do something" do
+
+      # TODO: Implement scenarios for client
+    end
+  end
+end

data/spec/occi/log_spec.rb

@@ -7,7 +7,8 @@ module OCCI
     describe "log messages" do
       it "should log a message to a pipe" do
         r, w = IO.pipe
-        OCCI::Log.new(w, OCCI::Log::INFO)
+        logger = OCCI::Log.new(w)
+        logger.level = OCCI::Log::INFO
         OCCI::Log.info("Test")
         r.readline.include?("Test")
       end

data/spec/occi/model_spec.rb

@@ -4,23 +4,52 @@ require 'occi/model'
 describe "Model" do
 
   it "initializes Core Model successfully" do
-    OCCI::Model.register_core
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/core#entity').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/core#resource').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/core#link').should be_kind_of OCCI::Core::Kind
+    model = OCCI::Model.new
+    model.get_by_id('http://schemas.ogf.org/occi/core#entity').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/core#resource').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/core#link').should be_kind_of OCCI::Core::Kind
   end
 
   it "initializes Infrastructure Model successfully" do
-    OCCI::Model.register_files('etc/model/infrastructure/')
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#compute').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#os_tpl').should be_kind_of OCCI::Core::Mixin
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#resource_tpl').should be_kind_of OCCI::Core::Mixin
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#network').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure/network#ipnetwork').should be_kind_of OCCI::Core::Mixin
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#networkinterface').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface').should be_kind_of OCCI::Core::Mixin
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#storage').should be_kind_of OCCI::Core::Kind
-    OCCI::Model.get_by_id('http://schemas.ogf.org/occi/infrastructure#storagelink').should be_kind_of OCCI::Core::Kind
+    model = OCCI::Model.new
+    model.register_infrastructure
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#compute').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#os_tpl').should be_kind_of OCCI::Core::Mixin
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#resource_tpl').should be_kind_of OCCI::Core::Mixin
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#network').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure/network#ipnetwork').should be_kind_of OCCI::Core::Mixin
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#networkinterface').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface').should be_kind_of OCCI::Core::Mixin
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#storage').should be_kind_of OCCI::Core::Kind
+    model.get_by_id('http://schemas.ogf.org/occi/infrastructure#storagelink').should be_kind_of OCCI::Core::Kind
+  end
+
+  it "returns all registered categories" do
+    model = OCCI::Model.new
+    collection = model.get
+    collection.kind_of? OCCI::Collection
+    collection.kinds.should have(3).kinds
+    collection.mixins.should be_empty
+    collection.actions.should be_empty
+    collection.resources.should be_empty
+    collection.links.should be_empty
+  end
+
+  it "returns categories with filter" do
+    model = OCCI::Model.new
+    model.register_infrastructure
+    compute = OCCI::Core::Kind.new('http://schemas.ogf.org/occi/infrastructure#','compute')
+    ipnetwork = OCCI::Core::Mixin.new('http://schemas.ogf.org/occi/infrastructure/network#','ipnetwork')
+    filter = OCCI::Collection.new
+    filter.kinds << compute
+    filter.mixins << ipnetwork
+    collection = model.get(filter)
+    collection.kind_of? OCCI::Collection
+    collection.kinds.first.attributes.should be_kind_of OCCI::Core::AttributeProperties
+    collection.mixins.first.attributes.should be_kind_of OCCI::Core::AttributeProperties
+    collection.actions.should be_empty
+    collection.resources.should be_empty
+    collection.links.should be_empty
   end
 
 end

data/spec/occi/parser_spec.rb

@@ -5,8 +5,23 @@ describe "Parser" do
 
   it "should parse OCCI message with entity in text plain format" do
     media_type = 'text/plain'
-    body = %Q|Category: compute; scheme="http://schemas.ogf.org/occi/infrastructure#"; class="kind"\nX-OCCI-Attribute: occi.compute.cores=2|
-    category = false
-    OCCI::Parser.parse(media_type,body,category)
+    body       = %Q|Category: compute; scheme="http://schemas.ogf.org/occi/infrastructure#"; class="kind"\nX-OCCI-Attribute: occi.compute.cores=2|
+    locations, collection = OCCI::Parser.parse(media_type, body)
+  end
+
+  it "should parse an OVA container" do
+    media_type = 'application/ova'
+    body       = File.read('spec/occi/test.ova')
+    locations, collection = OCCI::Parser.parse(media_type, body)
+    storage_resources = collection.resources.select { |resource| resource.kind == 'http://schemas.ogf.org/occi/infrastructure#storage' }
+    storage_resources.should have(1).storage_resource
+    storage_resources.first.attributes.occi!.core!.title.should == 'lamp'
+    network_resources = collection.resources.select { |resource| resource.kind == 'http://schemas.ogf.org/occi/infrastructure#network' }
+    network_resources.should have(1).network_resource
+    network_resources.first.attributes.occi!.core!.title.should == 'VM Network'
+    compute_resources = collection.resources.select { |resource| resource.kind == 'http://schemas.ogf.org/occi/infrastructure#compute' }
+    compute_resources.should have(1).compute_resource
+    compute_resources.first.attributes.occi!.compute!.cores.should == 1
+    compute_resources.first.attributes.occi!.compute!.memory.should == 256
   end
 end