omf_sfa 0.1.1

data/spec/resource/ocomponent_spec.rb

@@ -0,0 +1,225 @@
+
+require 'equivalent-xml'
+
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/resource/ocomponent'
+require 'omf-sfa/resource/ogroup'
+require 'omf-sfa/resource/group_component'
+
+include OMF::SFA::Resource
+
+class TComp < OComponent
+  sfa_class 'T'
+end
+
+class TComp2 < TComp
+  oproperty :available, Boolean, :default => true
+  sfa_class 'T2'  
+  sfa :available #, :attr_value => 'now'
+end 
+
+
+
+describe OComponent do
+  before :all do
+    init_dm
+  end
+
+  before :each do
+    GURN.clear_cache
+  end
+
+  it 'can create a basic component' do
+    OComponent.create()
+  end
+
+  it 'can destroy a basic component' do
+    OComponent.create().destroy
+  end
+
+  it 'has default domain' do
+    c = OComponent.create
+    c.domain.should == OComponent.default_domain
+  end
+
+  it 'has default domain' do
+    c = OComponent.create(:domain => 'the_domain')
+    c.domain.should == 'the_domain'
+  end  
+
+  it 'can be sfa-xml serialised' do
+    c = TComp.create(:name => :foo)
+    assert_sfa_xml c,%{<T %s id="#{c.uuid}" 
+        omf:href="/resources/#{c.uuid}"
+        component_id="urn:publicid:IDN+mytestbed.net+T+#{c.uuid}" 
+        component_manager_id="authority+am"
+        component_name="foo"/>}
+  end
+
+  it 'can have simple attributes' do
+    c = TComp2.create(:name => :foo)
+    c.to_sfa_hash().should == {
+      "href" => "/resources/#{c.uuid}", "uuid" => c.uuid.to_s, 
+      "sfa_class" => "T2",
+      "component_name" => "foo", "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+T2+#{c.uuid}",
+      "available" => "true"
+    }
+    assert_sfa_xml c, %{
+      <T2 %s
+    id="#{c.uuid}" 
+      omf:href="/resources/#{c.uuid}"
+    component_id="urn:publicid:IDN+mytestbed.net+T2+#{c.uuid}" 
+    component_manager_id="authority+am" 
+    component_name="foo">
+        <available>true</available>
+      </T2>}
+  end
+
+  it 'can have group components' do
+    g = GroupComponent.create(:name => 'g')
+    g.to_sfa_hash().should == {
+      "href" => "/resources/#{g.uuid}", "uuid" => g.uuid.to_s, 
+      "sfa_class" => "group",
+      "component_name" => "g", "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+group+#{g.uuid}",
+      "components" => []
+    }
+
+    g.to_hash.should == {:name => "g", :type=>"group", :uuid=>"#{g.uuid}", :href=>"/resources/#{g.uuid}", :resources => []}
+    assert_sfa_xml g, %{
+        <group %s 
+      id="#{g.uuid}"
+      omf:href="/resources/#{g.uuid}"
+      component_id="urn:publicid:IDN+mytestbed.net+group+#{g.uuid}" 
+      component_manager_id="authority+am" 
+      component_name="g">
+    <components/>
+        </group>                  
+    }
+  end
+
+  it 'can have group components holding components' do
+    g = GroupComponent.create(:name => 'g')
+    g.contains_resources << (n = TComp.create(:name => 'n'))
+
+    g.to_hash.should == {
+      :name=>"g", 
+      :uuid => g.uuid.to_s,
+      :type=> "group", 
+      :href=> "/resources/#{g.uuid}", 
+      :resources => [{
+        :name => "n", 
+        :type => "T", 
+        :status=>"unknown", 
+        :domain => "mytestbed.net", 
+        :uuid => n.uuid.to_s,
+        :href=> "/resources/#{n.uuid}", 
+      }]
+    }
+    g.to_sfa_hash().should == {
+      "href" => "/resources/#{g.uuid}", "uuid" => g.uuid.to_s, "sfa_class" => "group",
+      "component_name" => "g", "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+group+#{g.uuid}",
+      "components" => [{
+        "href" => "/resources/#{n.uuid}",
+        "uuid" => n.uuid.to_s,
+        "component_name" => "n",
+        "component_manager_id" => "authority+am",
+        "component_id" => "urn:publicid:IDN+mytestbed.net+T+#{n.uuid}",
+        "sfa_class" => "T"
+      }]
+    }
+    assert_sfa_xml g, %{
+        <group %s
+      id="#{g.uuid}"
+      omf:href="/resources/#{g.uuid}"
+      component_id="urn:publicid:IDN+mytestbed.net+group+#{g.uuid}" 
+      component_manager_id="authority+am" component_name="g">
+    <components>
+      <T 
+        id="#{n.uuid}" 
+        omf:href="/resources/#{n.uuid}"
+        component_id="urn:publicid:IDN+mytestbed.net+T+#{n.uuid}" 
+        component_manager_id="authority+am" 
+        component_name="n"/>
+    </components>
+        </group>                  
+    }
+  end
+
+  it 'can have group components holding other groups' do
+    g = GroupComponent.create(:name => 'g')
+    g.contains_resources << (g2 = GroupComponent.create(:name => 'g2'))
+
+    g.to_hash.should == {
+      :name => "g", 
+      :type => "group", 
+      :uuid => g.uuid.to_s, 
+      :href => "/resources/#{g.uuid}",      
+      :resources => [{
+        :name => "g2", 
+        :type => "group", 
+        :href => "/resources/#{g2.uuid}",        
+        :resources => [], 
+        :uuid => g2.uuid.to_s
+      }]
+    }
+    g.to_sfa_hash().should == {
+      "component_name" => "g", 
+      "component_manager_id" => "authority+am", 
+      "href" => "/resources/#{g.uuid}", 
+      "uuid" => g.uuid.to_s,
+      "sfa_class" => "group",
+      "component_id" => "urn:publicid:IDN+mytestbed.net+group+#{g.uuid}",
+      "components" => [{
+        "component_name" => "g2",
+        "href" => "/resources/#{g2.uuid}",
+        "uuid" => g2.uuid.to_s,
+        "sfa_class" => "group",
+        "component_manager_id" => "authority+am",
+        "component_id" => "urn:publicid:IDN+mytestbed.net+group+#{g2.uuid}",
+        "components" => []
+      }]
+    }
+
+
+    assert_sfa_xml g, %{
+        <group %s
+      id="#{g.uuid}" 
+      omf:href="/resources/#{g.uuid}"
+      component_id="urn:publicid:IDN+mytestbed.net+group+#{g.uuid}" 
+      component_manager_id="authority+am" component_name="g">
+    <components>
+      <group 
+        id="#{g2.uuid}" 
+        omf:href="/resources/#{g2.uuid}"
+        component_id="urn:publicid:IDN+mytestbed.net+group+#{g2.uuid}" 
+        component_manager_id="authority+am" 
+        component_name="g2">
+        <components/>
+      </group>
+    </components>
+        </group>                  
+    }
+  end
+
+  it 'should be able to provide a clone of itself' do
+    c1 = OComponent.create(:name => 'comp1')
+    c2 = c1.clone
+    c2.provided_by = c1
+
+    c2.save
+
+    c1.provides << c2  
+    c1.save
+
+    c1.reload
+    c2.reload
+
+    c1.provides.should == [c2]
+    c2.provided_by.should == c1
+  end
+
+end
+

data/spec/resource/ogroup_spec.rb

@@ -0,0 +1,93 @@
+
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/resource/ogroup'
+
+include OMF::SFA::Resource
+
+describe OGroup do
+  before :all do
+    init_dm
+    r1_id = UUIDTools::UUID.random_create
+    g1_id = UUIDTools::UUID.random_create
+  end
+  
+  before :each do
+    #DataMapper.repository.delete
+  end
+  
+  it 'can create a group' do
+    OGroup.create()
+  end
+
+  it 'can contain resources' do
+    g = OGroup.create()
+    r = OResource.create()
+
+    g.contains_resources << r
+    g.save    
+    g.reload
+    r.reload
+    
+    g.contains_resources.size.should == 1
+  end
+  
+  it 'should also show up on the resource side' do
+    g = OGroup.create()
+    gid = g.uuid
+    r = OResource.create()
+  
+    g.contains_resources << r
+    g.save    
+    g.reload
+    r.reload
+    
+    ga = r.included_in_groups
+    ga.size.should == 1
+    ga[0].uuid.should == gid
+  end
+  
+  it 'can contain multiple resources' do
+    g = OGroup.create()
+
+    g.contains_resources << OResource.create()
+    g.contains_resources << OResource.create()
+    g.save
+    g.reload
+    
+    g.contains_resources.size.should == 2
+  end
+  
+  it 'can contain multiple resources and remove them' do
+    g = OGroup.create()
+    g.contains_resources << OResource.create(:name => 'r1')
+    g.contains_resources << OResource.create()
+    g.save
+    g.reload
+    
+    g.empty_group
+    g.save
+    g.reload
+
+    g.contains_resources.size.should == 0
+    OResource.first(:name => 'r1').should_not == nil
+  end
+  
+  
+  it 'can contain other groups as well' do
+    parent = OGroup.create(:name => :parent)
+    child = OGroup.create(:name => :child)
+
+    parent.contains_resources << child
+    parent.save
+    child.save
+    
+    parent.reload
+    child.reload
+    
+    parent.contains_resources.size.should == 1
+    child.included_in_groups.size.should == 1
+    child.included_in_groups[0].name.should == 'parent'
+  end
+
+end
+    

data/spec/resource/oresource_spec.rb

@@ -0,0 +1,208 @@
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/resource/oresource'
+require 'omf-sfa/resource/node'
+require 'omf-sfa/resource/ogroup'
+require 'json'
+
+include OMF::SFA::Resource
+
+def init_logger
+  OMF::Common::Loggable.init_log 'OResource', :searchPath => File.join(File.dirname(__FILE__), 'OResource')
+  #@config = OMF::Common::YAML.load('omf-sfa-am', :path => [File.dirname(__FILE__) + '/../../etc/omf-sfa'])[:omf_sfa_am]
+end
+
+class TA < OResource
+  oproperty :flag, Boolean, :default => true
+end 
+
+class A < OResource
+  oproperty :b, :B
+  oproperty :ba, :B, :functional => false  
+end 
+
+class B < OResource
+end 
+
+class G < OResource
+  oproperty :g, :o_group
+end
+
+describe OResource do
+
+  init_logger
+
+  before :each do
+    init_dm
+  end
+  
+  it 'can create a basic resource' do
+    OResource.create()
+  end
+
+  it 'can destroy a basic resource' do
+    OResource.create().destroy
+  end
+
+  it 'assigns a UUID by default' do  
+    r = OResource.create()
+    r.uuid.should_not be(nil)
+  end
+  
+  it 'can serialize' do
+    o = OResource.create()
+    js = o.to_json
+    o.reload
+    # http://www.ruby-lang.org/en/news/2013/02/22/json-dos-cve-2013-0269/
+    # alternative: o2 = JSON.load(js)
+    o2 = JSON.parse(js, :create_additions => true)
+    o2.uuid.should == o.uuid
+  end
+  
+  it 'can be serialized into a hash' do
+    o = OResource.create(:name => :foo)
+    o.to_hash.should == {:type=>"unknown", :name=>"foo", :uuid=>"#{o.uuid.to_s}", :href => "/resources/#{o.uuid}"}   
+  end
+  
+  
+  it 'can have simple properties' do
+    o = OResource.create()
+    o.o_properties.create(:name => 'p1', :value => 'v1')
+    o.o_properties.create(:name => 'p2', :value => 123)    
+    o.save
+    o.reload
+    
+    p = o.o_properties[0]
+    p.name.should == 'p1'
+    p.value.should == 'v1'
+
+    p2 = o.o_properties[1]
+    p2.name.should == 'p2'
+    p2.value.should == 123
+    
+  end
+  
+  it 'can have properties pointing to other resources' do 
+    o1 = OResource.create(:name => 'o1')
+    o2 = OResource.create(:name => 'o2')
+    u2 = o2.uuid
+        
+    o1.oproperties.create(:name => 'p1', :value => o2)
+    o1.save
+    o1.reload; o2.reload    
+    
+    p = o1.oproperties[0]
+    v = p.value
+    v.class.should == OResource
+    v.uuid.should == u2
+  end  
+  
+  it 'can have named properties as [] on resource' do
+    o = OResource.create(:name => 'foobar')
+    o['name'].should == 'foobar'
+    
+    o['foo'] = 1
+    o['foo'].should == 1
+    o[:foo].should == 1
+    o.save
+    o.reload
+    o['foo'].should == 1
+  end
+  
+  it 'can define properties with +oproperty+' do
+    o = TA.create(:name => 'o')
+    o.flag = true
+    o.save
+    
+    o.reload
+    o.flag.should == true
+    o.to_hash.should == {:type=>"unknown", :uuid=>"#{o.uuid}", :href => "/resources/#{o.uuid}", :name => 'o', :flag => true}   
+  end
+  
+  it 'can have properties linking to other object' do
+    a = A.create(:name => 'a')
+    a.b.should == nil
+    a.bas.should == []    
+    
+    b = B.create
+    a.b = b
+    
+    a.save
+    a.reload
+    
+    a.b.uuid.should == b.uuid
+    a.to_hash.should == {
+      :type=>"unknown", :uuid=>"#{a.uuid}", :href => "/resources/#{a.uuid}", :name => 'a',
+      :b => b.uuid.to_s
+    }       
+  end
+  
+  it 'can have properties linking to groups' do
+    r = G.create(:name => 'r')
+    g = OGroup.create(:name => 'g')
+    r.g = g
+    
+    r.g.should == g
+    r.to_hash.should == {:name => "r", :type=>"unknown", :uuid=>"#{r.uuid}", :g => g.uuid.to_s, :href => "/resources/#{r.uuid}"}
+  end
+
+  it 'can have non-functional properties' do
+    a = A.create(:name => 'a')
+    a.bas.should == []    
+    
+    a.save
+    a.reload
+
+    b = B.create
+    a.bas = b
+    #a.bas << b
+    a.bas.should == [b]    
+    a.save
+    a.reload
+    
+    a.bas.should == [b]
+
+    b2 = B.create
+    a.bas << b2
+    a.save
+    a.reload
+
+    a.bas.should == [b, b2]
+    a.to_hash.should == {
+      :type=>"unknown", :uuid=>"#{a.uuid}", :href=>"/resources/#{a.uuid}", :name => 'a',
+      :bas => [b.uuid.to_s, b2.uuid.to_s]
+    }             
+
+    a.bas = []
+    a.save
+    a.reload
+    a.bas.should == []
+  end
+
+  it 'returns properties as a hash' do
+    a = A.create
+    b = B.create
+    a.bas << b
+    a.b = b
+    a.save
+    a.reload
+
+    a.oproperties_as_hash.should == {'b' => b, 'bas' => [b]}
+  end
+
+  it 'can have Time oproperties' do
+    class Bar < OResource
+    end
+
+    class Foo < Bar
+      oproperty :created_at, DataMapper::Property::Time
+    end
+
+    f = Foo.new
+    f.created_at = Time.now
+    f.save
+
+    f.created_at.should be_a_kind_of(Time)
+  end
+
+end
+