omf_sfa 0.1.1

data/spec/am/am_manager_spec.rb

@@ -0,0 +1,307 @@
+
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/am/am_manager'
+require 'omf-sfa/resource'
+require "rspec/expectations"
+require 'omf_common/lobject'
+require 'omf_common/load_yaml'
+
+include OMF::SFA::AM
+
+def init_logger
+  OMF::Common::Loggable.init_log 'am_manager', :searchPath => File.join(File.dirname(__FILE__), 'am_manager')
+  @config = OMF::Common::YAML.load('omf-sfa-am', :path => [File.dirname(__FILE__) + '/../../etc/omf-sfa'])[:omf_sfa_am]
+end
+
+describe AMManager do
+
+  init_logger
+
+  before :all do
+    init_dm
+  end
+
+  let (:scheduler) do
+    scheduler = double('scheduler')
+    scheduler.stub(:get_nil_account).and_return(nil)
+    scheduler 
+  end
+
+  let (:manager) { AMManager.new(scheduler) }
+
+  context 'instance' do
+    it 'can create an AM Manager' do
+      manager
+    end
+
+    it 'can create an AM Manager' do
+      r = OMF::SFA::Resource::OResource.new(:name => 'r')
+      manager.manage_resource(r)
+    end
+  end
+
+  context 'account' do
+    let(:auth) { double('authorizer') }
+
+    before :each do
+      DataMapper.auto_migrate! # reset database
+    end
+
+    it 'can create account' do
+      auth.should_receive(:can_create_account?)#.with("02134")
+      account = manager.find_or_create_account({:name => 'a'}, auth) 
+      account.should be_a(OMF::SFA::Resource::OAccount)
+    end
+
+    it 'can find created account' do
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a'}, auth)
+
+      auth.should_receive(:can_view_account?).with(kind_of(OMF::SFA::Resource::OAccount))      
+      a2 = manager.find_or_create_account({:name => 'a'}, auth)
+      a1.should == a2
+
+      auth.should_receive(:can_view_account?).with(kind_of(OMF::SFA::Resource::OAccount))      
+      a3 = manager.find_account({:name => 'a'}, auth)
+      a1.should == a3
+    end
+
+    it 'throws exception when looking for non-exisiting account' do
+      lambda do 
+        manager.find_account({:name => 'a'}, auth)
+      end.should raise_error(UnavailableResourceException)
+    end
+
+    it 'can request all accounts visible to a user' do
+      manager.find_all_accounts(auth).should == []   
+
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a1'}, auth)
+
+      auth.should_receive(:can_view_account?)      
+      manager.find_all_accounts(auth).should == [a1]
+
+      auth.should_receive(:can_create_account?)
+      a2 = manager.find_or_create_account({:name => 'a2'}, auth)
+
+      auth.should_receive(:can_view_account?).exactly(2).times
+      manager.find_all_accounts(auth).should == [a1, a2]
+
+      auth.should_receive(:can_view_account?).exactly(2).times.and_raise(InsufficientPrivilegesException)    
+      manager.find_all_accounts(auth).should == []
+    end
+
+    it 'can request accounts which are active' do
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a1'}, auth)
+
+      auth.should_receive(:can_view_account?)      
+      a2 = manager.find_active_account({:name => 'a1'}, auth)
+      a2.should_not be_nil
+
+      # Expire account
+      a2.valid_until = Time.now - 100
+      a2.save
+      auth.should_receive(:can_view_account?)      
+      lambda do
+        manager.find_active_account({:name => 'a1'}, auth)
+      end.should raise_error(UnavailableResourceException) 
+    end
+
+    it 'can renew accounts' do
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a1'}, auth)
+
+      time = Time.now + 100
+      auth.should_receive(:can_view_account?)      
+      auth.should_receive(:can_renew_account?).with(a1, time)            
+      a2 = manager.renew_account_until({:name => 'a1'}, time, auth)
+      a2.should == a1
+      a2.valid_until.should == time
+    end
+
+    it 'can close account' do
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a1'}, auth)
+      a1.active?.should be_true
+      a1.closed?.should be_false
+
+      auth.should_receive(:can_view_account?)      
+      auth.should_receive(:can_close_account?).with(a1)   
+      a2 = manager.close_account({:name => 'a1'}, auth)
+      a2.reload
+      a2.active?.should be_false
+      a2.closed?.should be_true
+    end
+  end # context - account
+
+  context 'lease' do
+
+    let(:auth) { double('authorizer') }
+
+    before :each do
+      DataMapper.auto_migrate! # reset database
+    end
+
+    it 'can create lease' do
+      auth.should_receive(:can_create_lease?)
+      lease = manager.find_or_create_lease({:name => 'l1'}, {:valid_from => Time.now, :valid_until => Time.now + 100}, auth) 
+      lease.should be_a(OMF::SFA::Resource::OLease)
+    end
+
+    it 'can find created lease' do
+      auth.should_receive(:can_create_lease?)
+      a1 = manager.find_or_create_lease({:name => 'l1'}, {}, auth)
+
+      auth.should_receive(:can_view_lease?).with(kind_of(OMF::SFA::Resource::OLease))      
+      a2 = manager.find_or_create_lease({:name => 'l1'}, {}, auth)
+      a1.should == a2
+
+      auth.should_receive(:can_view_lease?).with(kind_of(OMF::SFA::Resource::OLease))      
+      a3 = manager.find_lease({:name => 'l1'}, auth)
+      a1.should == a3
+    end
+
+    it 'throws exception when looking for non-exisiting lease' do
+      lambda do 
+        manager.find_lease({:name => 'l1'}, auth)
+      end.should raise_error(UnavailableResourceException)
+    end
+
+    it "can request all user's leases" do
+
+      auth.should_receive(:can_create_account?)
+      a1 = manager.find_or_create_account({:name => 'a1'}, auth)
+
+      manager.find_all_leases_for_account(a1, auth).should == []   
+
+      auth.should_receive(:can_create_lease?)
+      l1 = manager.find_or_create_lease({:name => 'l1', :account => a1}, {}, auth)
+
+      auth.should_receive(:can_view_lease?)      
+      manager.find_all_leases_for_account(a1, auth).should == [l1]
+
+      auth.should_receive(:can_create_lease?)
+      l2 = manager.find_or_create_lease({:name => 'l2', :account => a1}, {}, auth)
+
+      auth.should_receive(:can_view_lease?).exactly(2).times
+      manager.find_all_leases_for_account(a1, auth).should == [l1, l2]
+
+      auth.should_receive(:can_view_lease?).exactly(2).times.and_raise(InsufficientPrivilegesException)    
+      manager.find_all_leases_for_account(a1, auth).should == []
+    end
+
+    it 'can modify leases' do
+      auth.should_receive(:can_create_lease?)
+      l1 = manager.find_or_create_lease({:name => 'l1'}, {}, auth)
+
+      valid_from = 1338847200
+      valid_until = 1338850800
+      auth.should_receive(:can_modify_lease?).with(l1)            
+      l2 = manager.modify_lease({:valid_from => valid_from, :valid_until => valid_until}, l1, auth)
+      l2.should == l1.reload
+      l2.valid_from.should == valid_from
+      l2.valid_until.should == valid_until
+    end
+
+    it 'can release a lease' do
+      auth.should_receive(:can_create_lease?)
+      l1 = manager.find_or_create_lease({:name => 'l1'}, {}, auth)
+
+      auth.should_receive(:can_release_lease?).with(l1)   
+      manager.release_lease(l1, auth)#.should be_true
+    end
+
+  end # context - lease
+
+  context 'resource' do
+    let(:account) { OMF::SFA::Resource::OAccount.new(:name => 'a') }
+    let(:auth) do
+      auth = double('authorizer') 
+      auth.stub(:account) { account }
+      auth    
+    end
+
+
+    before :each do
+      DataMapper.auto_migrate! # reset database
+      @r1 = OMF::SFA::Resource::OResource.new(:name => 'r1')
+      @r2 = OMF::SFA::Resource::OResource.new(:name => 'r2')
+      manager.manage_resources([@r1, @r2])
+    end
+
+    it 'find single resource belonging to anyone' do
+      auth.should_receive(:can_view_resource?).with(kind_of(OMF::SFA::Resource::OResource)) 
+      r = manager.find_resource({:name => 'r1'}, auth)
+      r.should be_a(OMF::SFA::Resource::OResource)   
+    end
+
+    it 'find single resource belonging to account' do
+      account = OMF::SFA::Resource::OAccount.new(:name => 'a')
+      auth.stub(:account) { account }
+
+      # resources belong to nil account, so they shouldn't be found
+      lambda do      
+        manager.find_resource_for_account({:name => 'r1'}, auth)
+      end.should raise_error(UnknownResourceException)
+
+      # now, assign them to this account
+      @r1.account = account
+      @r1.save
+      auth.should_receive(:can_view_resource?).with(@r1)      
+      r = manager.find_resource_for_account({:name => 'r1'}, auth)
+      r.should == @r1
+    end
+
+    it 'will create resource if not already available for the account' do
+      account = OMF::SFA::Resource::OAccount.create(:name => 'a')
+      auth.stub(:account) { account }
+
+      vr = OMF::SFA::Resource::OResource.create(:name => 'v1')
+      vr.should be_a(OMF::SFA::Resource::OResource)
+      scheduler.stub(:create_resource).and_return(vr)
+      scheduler.create_resource().should == vr
+
+      descr = {:name => 'v1'}
+      auth.should_receive(:can_create_resource?) #.with(descr, 'oresource')
+      #auth.should_receive(:can_view_resource?)
+      r = manager.find_or_create_resource_for_account(descr, 'oresource', auth)
+      r.should == vr
+    end
+
+    it 'will create resource from rspec' do
+      rspec = %{
+        <rspec xmlns="http://www.protogeni.net/resources/rspec/2" xmlns:omf="http://schema.mytestbed.net/sfa/rspec/1" type="request">
+          <node component_id="urn:publicid:IDN+openlab+node+node1" component_name="node1">
+          </node>
+        </rspec>
+      } 
+      req = Nokogiri.XML(rspec)
+
+      #vr = OMF::SFA::Resource::Node.new(:name => 'vn')
+      # vr.stub(:group?).and_return(false)
+      # vr.stub(:save)
+      # vr.should_receive(:create_from_xml)
+      scheduler.stub(:create_resource) do |resource_descr, type_to_create, authorizer|
+        resource_descr[:name].should == 'node1'
+        authorizer.should == auth
+        OMF::SFA::Resource::Node.new(resource_descr)
+      end
+      auth.should_receive(:can_create_resource?).with({:name => 'node1', :account => account}, anything)  
+      #auth.should_receive(:can_view_resource?)          
+      r = manager.update_resources_from_rspec(req.root, false, auth)
+      r.first.should be_instance_of(OMF::SFA::Resource::Node)
+    end
+
+    it 'will release a resource' do
+      auth.should_receive(:can_release_resource?).with(@r1)
+
+      scheduler.stub(:release_resource) do |resource, authorizer|
+        resource.destroy
+      end
+      manager.release_resource(@r1, auth)
+    end
+
+  end # context - resource
+
+end

data/spec/am/am_scheduler_spec.rb

@@ -0,0 +1,57 @@
+
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/am/am_manager'
+require 'omf-sfa/am/am_scheduler'
+require 'omf-sfa/resource'
+
+include OMF::SFA::AM
+
+describe AMScheduler do
+
+  before :all do
+    init_dm
+  end
+
+  let (:manager) { double('manager') }
+
+  let (:scheduler) { AMScheduler.new }
+
+  context 'instance' do
+    it 'can create a scheduler' do
+      scheduler
+    end
+  end
+
+  context 'resource' do
+    
+    # reset database
+    before :each do
+      DataMapper.auto_migrate!
+    end
+
+    let (:lease) { OMF::SFA::Resource::OLease.new(:name => 'l1') }
+
+    let (:account) { OMF::SFA::Resource::OAccount.new(:name => 'a') }
+
+    let (:auth) do
+      auth = double('authorizer')
+      auth.stub(:account) { account }
+      auth
+    end
+
+    it 'can create a resource' do
+      r = scheduler.create_resource({ :name => 'node1', :lease => lease, :account => account }, 'node', auth)
+      r.should be_kind_of(OMF::SFA::Resource::Node)
+      r.name.should be_eql('node1')
+      r.account.should be_equal(account)
+      r.leases.first.should be_equal(lease)
+    end
+
+    it 'can release a resource' do 
+      r = scheduler.create_resource({ :name => 'node1', :lease => lease, :account => account }, 'node', auth)
+      r = scheduler.release_resource(r, auth)
+      r.should be_true
+      OMF::SFA::Resource::Node.all.should be_empty
+    end
+  end
+end

data/spec/am/common.rb

@@ -0,0 +1,24 @@
+
+require 'omf-sfa/resource'
+
+def init_dm
+  # setup database
+  DataMapper::Logger.new($stdout, :info)
+  #DataMapper::Logger.new(STDOUT, :debug)
+  
+  DataMapper.setup(:default, 'sqlite::memory:')
+  #DataMapper.setup(:default, 'sqlite:///tmp/am_test.db')
+  DataMapper::Model.raise_on_save_failure = true 
+  DataMapper.finalize
+    
+  require  'dm-migrations'
+  DataMapper.auto_migrate!
+end
+
+def assert_sfa_xml(resource, expected)
+  doc = resource.to_sfa_xml()
+  
+  expected = format expected, 'xmlns="http://www.protogeni.net/resources/rspec/2" xmlns:omf="http://schema.mytestbed.net/sfa/rspec/1"'
+  exp = Nokogiri.XML(expected)
+  doc.should be_equivalent_to(exp)
+end

data/spec/resource/common.rb

@@ -0,0 +1,31 @@
+
+
+module OMF
+  module SFA
+    module Resource; end
+  end 
+end
+
+def init_dm
+  # setup database
+  DataMapper::Logger.new($stdout, :info)
+  #DataMapper::Logger.new(STDOUT, :debug)
+  
+  DataMapper.setup(:default, 'sqlite::memory:')
+  DataMapper::Model.raise_on_save_failure = true 
+  DataMapper.finalize
+    
+  require  'dm-migrations'
+  DataMapper.auto_migrate!
+end
+
+def assert_sfa_xml(resource, expected)
+  # doc = Nokogiri::XML::Document.new
+  # resource.to_sfa_xml(doc)
+
+  doc = resource.to_sfa_xml()
+  
+  expected = format expected, 'xmlns="http://www.protogeni.net/resources/rspec/2" xmlns:omf="http://schema.mytestbed.net/sfa/rspec/1"'
+  exp = Nokogiri.XML(expected)
+  doc.should be_equivalent_to(exp)
+end

data/spec/resource/node_spec.rb

@@ -0,0 +1,171 @@
+require 'equivalent-xml'
+
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/resource/ocomponent'
+require 'omf-sfa/resource/ogroup'
+require 'omf-sfa/resource/node'
+
+
+include OMF::SFA::Resource
+
+describe Node do
+  before :all do
+    init_dm
+  end
+  
+  it 'can create a node' do
+    Node.create()
+  end
+  
+  it 'can serialize a simple node' do
+    n = Node.create(:name => 'n1')
+    assert_sfa_xml n, %{
+      <node %s 
+          id="#{n.uuid}" 
+          omf:href="/resources/#{n.uuid}"
+          component_id="urn:publicid:IDN+mytestbed.net+node+#{n.uuid}" 
+          component_manager_id="authority+am" 
+          component_name="n1">
+        <available now="true"/>
+      </node>
+    }
+  end
+  
+  it 'can have an interface' do
+    n = Node.create(:name => 'n1')
+    n.interfaces << (if1 = Interface.create(:name => 'if1'))
+    
+    assert_sfa_xml n, %{
+      <node %s 
+          id="#{n.uuid}" 
+          omf:href="/resources/#{n.uuid}"
+          component_id="urn:publicid:IDN+mytestbed.net+node+#{n.uuid}" 
+          component_manager_id="authority+am" 
+          component_name="n1">
+        <available now="true"/>
+        <interface 
+            id="#{if1.uuid}" 
+            omf:href="/resources/#{if1.uuid}"
+            component_id="urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}" 
+            component_manager_id="authority+am" 
+            component_name="if1"
+        />
+      </node>
+    }
+  end
+  
+  it 'can have multiples interface' do
+    n = Node.create(:name => 'n1')
+    n.interfaces << (if1 = Interface.create(:name => 'if1'))
+    n.interfaces << (if2 = Interface.create(:name => 'if2'))    
+    
+    n.to_sfa_hash().should == {
+      "href" => "/resources/#{n.uuid}", "uuid" => n.uuid.to_s, "sfa_class" => "node",
+      "component_name" => "n1", "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+node+#{n.uuid}",
+      "available" => "true",
+      "interfaces" => [{
+        "href" => "/resources/#{if1.uuid}",
+        "uuid" => if1.uuid.to_s,
+        "sfa_class" => "interface",
+        "component_name" => "if1",
+        "component_manager_id" => "authority+am",
+        "component_id" => "urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}",
+      }, {
+        "href" => "/resources/#{if2.uuid}",
+        "uuid" => if2.uuid.to_s,
+        "sfa_class" => "interface",
+        "component_name" => "if2",
+        "component_manager_id" => "authority+am",
+        "component_id" => "urn:publicid:IDN+mytestbed.net+interface+#{if2.uuid}",
+      }]
+    }
+
+    assert_sfa_xml n, %{
+      <node %s 
+          id="#{n.uuid}" 
+          omf:href="/resources/#{n.uuid}"
+          component_id="urn:publicid:IDN+mytestbed.net+node+#{n.uuid}" 
+          component_manager_id="authority+am" 
+          component_name="n1">
+        <available now="true"/>
+        <interface 
+            id="#{if1.uuid}" 
+            omf:href="/resources/#{if1.uuid}"
+            component_id="urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}" 
+            component_manager_id="authority+am" 
+            component_name="if1"
+        />
+        <interface 
+            id="#{if2.uuid}" 
+            omf:href="/resources/#{if2.uuid}"
+            component_id="urn:publicid:IDN+mytestbed.net+interface+#{if2.uuid}" 
+            component_manager_id="authority+am" 
+            component_name="if2"
+        />
+      </node>
+    }
+    # doc = Nokogiri::XML::Document.new
+    # n.to_sfa_xml(doc)
+#     
+    # exp = Nokogiri.XML(%{
+            # <node 
+                # id="#{n.sfa_id}" 
+                # component_id="urn:publicid:IDN+mytestbed.net+node+n1" 
+                # component_manager_id="authority+am" 
+                # component_name="n1">
+              # <available now="true"/>
+              # <interface_ref component_id="urn:publicid:IDN+mytestbed.net+interface+if1"/>
+              # <interface_ref component_id="urn:publicid:IDN+mytestbed.net+interface+if2"/>
+            # </node>})
+    # doc.should be_equivalent_to(exp)    
+  end  
+  
+  it 'can have multiples identical interface' do
+    n = Node.create(:name => 'n1')
+    n.interfaces << (if1 = Interface.create(:name => 'if1'))
+    n.interfaces << if1
+    
+    n.to_sfa_hash().should == {
+      "href" => "/resources/#{n.uuid}", "uuid" => n.uuid.to_s, "sfa_class" => "node",
+      "component_name" => "n1", "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+node+#{n.uuid}",
+      "available" => "true",
+      "interfaces" => [{
+        "href" => "/resources/#{if1.uuid}",
+        "uuid" => if1.uuid.to_s,
+        "sfa_class" => "interface",
+        "component_name" => "if1",
+        "component_manager_id" => "authority+am",
+        "component_id" => "urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}",
+      }, {
+        "component_name" => "if1",
+        "href" => "/resources/#{if1.uuid}",
+        "uuid" => if1.uuid.to_s
+      }]
+    }
+    
+    assert_sfa_xml n, %{
+      <node %s 
+          id="#{n.uuid}" 
+          omf:href="/resources/#{n.uuid}"
+          component_id="urn:publicid:IDN+mytestbed.net+node+#{n.uuid}" 
+          component_manager_id="authority+am" 
+          component_name="n1">
+        <available now="true"/>
+        <interface 
+            id="#{if1.uuid}" 
+            omf:href="/resources/#{if1.uuid}"
+            component_id="urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}" 
+            component_manager_id="authority+am" 
+            component_name="if1"
+        />
+        <interface_ref
+            id_ref="#{if1.uuid}" 
+            component_id="urn:publicid:IDN+mytestbed.net+interface+#{if1.uuid}" 
+        />
+      </node>
+    }
+    
+  end  
+end

data/spec/resource/oaccount_spec.rb

@@ -0,0 +1,92 @@
+require "#{File.dirname(__FILE__)}/common"
+require 'omf-sfa/resource/oaccount'
+require 'json'
+
+include OMF::SFA::Resource
+
+class R < OResource
+end 
+
+describe OAccount do
+  before :all do
+    init_dm
+  end
+  
+  it 'can create an account' do
+    a = OAccount.create()
+  end
+  
+  it 'can create an account with a urn' do
+    #a = OAccount.create(:urn => "urn:foo")
+    a = OAccount.first_or_create(:urn => "urn:publicid:IDN+omf:test+account+1")
+  end
+  
+  it 'can create an account with a urn if it doesnt exist yet' do
+    a = OAccount.first_or_create(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+5d9d-4fb:127.0.0.1%3A8000")
+  end
+
+  it 'will return nil if no account found' do
+    a = OAccount.first(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+test")
+    a.should be_nil
+  end
+
+  it 'can create and find by urn' do
+
+    init_dm
+
+    a = OAccount.create(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+5d9d-4fb:127.0.0.1%3A8000")
+    b = OAccount.create(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+__test__")
+    
+    aa = OAccount.first(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+5d9d-4fb:127.0.0.1%3A8000")
+    bb = OAccount.first(:urn => "urn:publicid:IDN+geni:gpo:gcf+slice+__test__")
+
+    a.should == aa
+    b.should == bb
+  end
+  
+  it 'can create and find by a name' do
+    a = OAccount.create(:name => 'fooBar') 
+    b = OAccount.first(:name => 'fooBar')
+    a.should == b
+  end
+  
+  it 'resources have a NULL default account' do
+    r = R.create()
+    r.account.should == nil
+  end
+  
+  it 'resources can have an account' do
+    a = OAccount.create()
+    r = R.create(:account => a)
+    r.reload.account.should == a
+  end
+  
+  it 'resources can have an account which then can be nulled' do
+    a = OAccount.create()
+    r = R.create(:account => a)
+    r.account = nil
+    r.save
+    r.reload.account.should == nil
+  end
+  
+  it 'is is active when valid' do
+    a = OAccount.create()
+    #a.save
+    a.reload
+    a.active?.should == true
+  end
+  
+  it 'is is no longer active after valid_until' do
+    a = OAccount.create(:valid_until => Time.now - 1)
+    a.active?.should == false
+  end  
+
+  it 'has Time oproperties' do
+    a = OAccount.create(:valid_until => Time.now + 200)
+    a.valid_until.should be_a_kind_of(Time)
+
+    a.valid_until = Time.now + 100
+    a.valid_until.should be_a_kind_of(Time)
+  end
+
+end