omf_common 6.0.0.pre.10 → 6.0.0.pre.11

data/test/omf_common/comm/xmpp/topic_spec.rb

@@ -0,0 +1,113 @@
+require 'fixture/pubsub'
+require 'em/minitest/spec'
+
+require 'omf_common/comm/xmpp/topic'
+
+describe OmfCommon::Comm::XMPP::Topic do
+  before do
+    @client = Blather::Client.new
+    @stream = MiniTest::Mock.new
+    @stream.expect(:send, true, [Blather::Stanza])
+    @client.post_init @stream, Blather::JID.new('n@d/r')
+    @xmpp = OmfCommon::Comm::XMPP::Communicator.new
+
+    OmfCommon.stub :comm, @xmpp do
+      Blather::Client.stub :new, @client do
+        @stream.expect(:send, true, [Blather::Stanza::PubSub::Create])
+        @topic = OmfCommon::Comm::XMPP::Topic.create(:test_topic)
+      end
+    end
+  end
+
+  describe "when calling operation method" do
+    it "must send create message" do
+      OmfCommon.stub :comm, @xmpp do
+        Blather::Client.stub :new, @client do
+          published = Blather::XMPPNode.parse(published_xml)
+
+          write_callback = proc do |event|
+            event.must_be_kind_of Blather::Stanza::PubSub::Publish
+            published.id = event.id
+            @client.receive_data published
+          end
+
+          @client.stub :write, write_callback do
+            @topic.create(:bob, { hrn: 'bob' })
+          end
+        end
+      end
+    end
+  end
+
+  describe "when informed message received" do
+    include EM::MiniTest::Spec
+
+    it "must react to omf created message" do
+      OmfCommon.stub :comm, @xmpp do
+        Blather::Client.stub :new, @client do
+          omf_create = OmfCommon::Message.create(:create, { type: 'engine' })
+          omf_create.stub :mid, "bf840fe9-c176-4fae-b7de-6fc27f183f76" do
+            omf_created = Blather::XMPPNode.parse(omf_created_xml)
+            @client.receive_data omf_created
+            @topic.on_creation_ok(omf_create) do |n|
+              n.must_equal OmfCommon::Message.parse(omf_created.items.first.payload)
+              done!
+            end
+          end
+        end
+      end
+      wait!
+    end
+
+    it "must react to omf status message" do
+      OmfCommon.stub :comm, @xmpp do
+        Blather::Client.stub :new, @client do
+          omf_request = OmfCommon::Message.create(:request, [:bob])
+          omf_request.stub :mid, "bf840fe9-c176-4fae-b7de-6fc27f183f76" do
+            omf_status = Blather::XMPPNode.parse(omf_status_xml)
+            @client.receive_data omf_status
+            @topic.on_status(omf_request) do |n|
+              n.must_equal OmfCommon::Message.parse(omf_status.items.first.payload)
+              done!
+            end
+          end
+        end
+      end
+      wait!
+    end
+
+    it "must react to omf release message" do
+      OmfCommon.stub :comm, @xmpp do
+        Blather::Client.stub :new, @client do
+          omf_release = OmfCommon::Message.create(:release, nil, { res_id: '100' })
+          omf_release.stub :mid, "bf840fe9-c176-4fae-b7de-6fc27f183f76" do
+            omf_released = Blather::XMPPNode.parse(omf_released_xml)
+            @client.receive_data omf_released
+            @topic.on_released(omf_release) do |n|
+              n.must_equal OmfCommon::Message.parse(omf_released.items.first.payload)
+              done!
+            end
+          end
+        end
+      end
+      wait!
+    end
+
+    it "must react to omf failed message" do
+      OmfCommon.stub :comm, @xmpp do
+        Blather::Client.stub :new, @client do
+          omf_create = OmfCommon::Message.create(:create, { type: 'engine' })
+          omf_create.stub :mid, "bf840fe9-c176-4fae-b7de-6fc27f183f76" do
+            omf_failed = Blather::XMPPNode.parse(omf_failed_xml)
+            @client.receive_data omf_failed
+            @topic.on_creation_failed(omf_create) do |n|
+              n.must_equal OmfCommon::Message.parse(omf_failed.items.first.payload)
+              done!
+            end
+          end
+        end
+      end
+      wait!
+    end
+  end
+end

data/test/omf_common/comm_spec.rb

@@ -3,6 +3,7 @@ require 'test_helper'
 describe OmfCommon::Comm do
   describe 'when initialised with a pubsub implementation' do
     it 'must return a instance with all methods defined in corresponding module loaded' do
+      skip
       @comm = OmfCommon::Comm.new(:xmpp)
       %w(connect disconnect create_topic delete_topic subscribe unsubscribe publish affiliations).each do |m|
         @comm.must_respond_to m

data/test/omf_common/message/xml/message_spec.rb

@@ -0,0 +1,136 @@
+require 'test_helper'
+require 'omf_common/message/xml/message'
+
+include OmfCommon
+
+describe OmfCommon::Message::XML::Message do
+  describe "when create message initialised" do
+    before do
+      # We will test prop value other than just strings
+      @message = Message::XML::Message.create(:create,
+                                     { type: 'bob', p1: 'p1_value', p2: { unit: 'u', precision: 2 } },
+                                     { rtype: 'bob', guard: { p1: 'p1_value' } })
+    end
+
+    it "must to be validated using relaxng schema" do
+      @message.valid?.must_equal true
+    end
+
+    it "must be able to be serialised as XML" do
+      @message.to_xml.must_match /^<create(.+)create>$/m
+      @message.to_xml.must_match /<rtype>bob<\/rtype>/m
+      @message.to_xml.must_match /<props(.+)props>/m
+      @message.to_xml.must_match /<guard(.+)guard>/m
+    end
+  end
+
+  describe "when release message initialised" do
+    before do
+      # We will test prop value other than just strings
+      @message = Message::XML::Message.create(:release, {}, { res_id: 'bob', guard: { p1: 'p1_value' } })
+    end
+
+    it "must to be validated using relaxng schema" do
+      @message.valid?.must_equal true
+    end
+
+    it "must be able to be serialised as XML" do
+      @message.to_xml.must_match /^<release(.+)release>$/m
+      @message.to_xml.must_match /<res_id>bob<\/res_id>/m
+      @message.to_xml.must_match /<guard(.+)guard>/m
+    end
+  end
+
+  describe "when asked to parse a XML element into Message::XML::Message object" do
+    before do
+      @xml = Message::XML::Message.create(
+        :create,
+        { type: 'vm',
+          os: 'debian',
+          memory: { value: 1024, unit: 'mb', precision: 0 },
+          devices: [{ name: 'w0', driver: 'mod_bob'}, { name: 'w1', driver: ['mod1', 'mod2']} ],
+          true: true,
+          false: false,
+          empty: nil,
+          boolean_array: [false, true] },
+        { rtype: 'vm', guard: { os_type: 'linux' } }).to_xml
+
+      @message = Message::XML::Message.parse(@xml)
+    end
+
+    it "must create the object correctly" do
+      @message.must_be_kind_of Message::XML::Message
+      @message.operation.must_equal :create
+    end
+
+    it "must provide normal xml xpath query" do
+      @message.read_element("props").first.element_children.size.must_equal 8
+      # TODO how to handle complext xpath??? with ns...
+      # @message.read_content("//memory/unit").must_equal 'mb'
+    end
+
+    it "must provide unified message property access" do
+      @message["type"].must_equal 'vm'
+      @message[:type].must_equal 'vm'
+    end
+
+    it "must provide guard information" do
+      @message.guard[:os_type].must_equal 'linux'
+    end
+
+    it "must be able reconstruct complicate data" do
+      # Each property iterator
+      @message.each_property do |k, v|
+        %w(type os memory devices true false empty boolean_array).must_include k
+      end
+
+      memory = @message[:memory]
+      memory.must_be_kind_of Hashie::Mash
+      memory.value.must_equal 1024
+      memory.unit.must_equal 'mb'
+      memory.precision.must_equal 0
+
+      devices = @message[:devices]
+      devices.must_be_kind_of Array
+      devices.size.must_equal 2
+      devices.find { |v| v.name == 'w1'}.driver.size.must_equal 2
+    end
+
+    it "must be able ducktype string xml content for numbers, boolean, empty string" do
+      @message[:true].must_equal true
+      @message[:false].must_equal false
+      @message[:boolean_array].must_equal [false, true]
+      @message[:empty].must_equal nil
+    end
+
+    it "must fail if parse an empty xml" do
+      lambda { Message::XML::Message.parse("") }.must_raise ArgumentError
+      lambda { Message::XML::Message.parse(nil) }.must_raise ArgumentError
+    end
+  end
+
+  describe "when creating request messages" do
+    it "must accept an array of properties instead of hash" do
+      request_m = Message::XML::Message.create(:request, [:p1, :p2])
+      request_m.valid?.must_equal true
+      request_m[:p1].must_be_nil
+    end
+  end
+
+  describe "when parsing inform message" do
+    it "must validate against inform message schema" do
+      msg = Message::XML::Message.parse <<-XML
+        <inform xmlns="http://schema.mytestbed.net/omf/6.0/protocol" mid="bob">
+          <src>xmpp://bob@localhost</src>
+          <ts>100</ts>
+          <itype>CREATION.OK</itype>
+        </inform>
+      XML
+
+      msg.ts.must_equal "100"
+      msg.itype.must_equal "CREATION.OK"
+
+      msg.valid?.must_equal true
+    end
+  end
+end

data/test/omf_common/message_spec.rb

@@ -1,151 +1,57 @@
 require 'test_helper'
 
-include OmfCommon
-
-PROP_ELEMENTS = %w(p1 p2 p3)
-
 describe OmfCommon::Message do
-  describe "when constructing valid messages" do
-    it "must return a create or configure XML element without failing" do
-      %w(create configure).each do |msg_name|
-        message = Message.__send__(msg_name) do |m|
-
-          PROP_ELEMENTS.each_with_index do |prop_element, index|
-            if index == 0
-              m.property(prop_element, rand(100))
-            else
-              m.property(prop_element, rand(100)) do |p|
-                p.element('unit', 'test')
-                p.element('precision', 'test')
-              end
-
-            end
-          end
-
-          # Guard element optional
-          m.element(:guard) do |g|
-            g.property('p1', 1)
-            g.property('p2', 2)
-          end
-        end
-        message.valid?.must_equal true
-      end
+  describe "when initialised" do
+    before do
+      @internal_attr = %w(type operation guard mid ts replyto cid itype)
+      @message = OmfCommon::Message.create(:create, { p1: 'p1_value', p2: 'p2_value' }, { rtype: :bob })
     end
 
-    it "must return a request XML element without failing" do
-      request = Message.request('foo@bar') do |m|
-        PROP_ELEMENTS.each do |prop_element|
-          m.property(prop_element, {min_value: 'test', max_value: 'test'})
-        end
-      end
-      request.valid?.must_equal true
+    it "must be able to query internal properties" do
+      @message.type.must_equal :create
+      @message.operation.must_equal :create
+      @message.mid.wont_be_nil
+      @message.ts.wont_be_nil
     end
 
-    it "must return a release XML element without failing" do
-      release = Message.release { |v| v.element('resource_id', 'test') }
-      release.valid?.must_equal true
+    it "must be able to get property value"  do
+      @message[:p1].must_equal 'p1_value'
+      @message.read_property(:p1).must_equal 'p1_value'
     end
 
-    it "must return a inform XML element without failing" do
-      inform = Message.inform('CREATED', '9012c3bc-68de-459a-ac9f-530cc7168e22') do |m|
-        m.element('resource_id', 'test')
-        m.element('resource_address', 'test')
-        PROP_ELEMENTS.each do |prop_element|
-          m.property(prop_element, { current: 'test', target: 'test'})
-        end
-      end
-      inform.valid?.must_equal true
+    it "must be able to set property value" do
+      @message[:p1] = 'new_value'
+      @message[:p1].must_equal 'new_value'
+      @message.write_property(:p2, 'new_value')
+      @message[:p2].must_equal 'new_value'
     end
 
-    it "context_id & resource_id shortcut must work too" do
-      m = Message.inform('CREATED', '9012c3bc-68de-459a-ac9f-530cc7168e22') do |m|
-        m.element('resource_id', 'test')
+    it "must be able to query internal message properties" do
+      @internal_attr.each do |name|
+        @message.must_respond_to name
       end
-      m.resource_id.must_equal 'test'
-      m.context_id.must_equal '9012c3bc-68de-459a-ac9f-530cc7168e22'
     end
 
-    it "must escape erb code in property" do
-      m = Message.inform('CREATED', '9012c3bc-68de-459a-ac9f-530cc7168e22') do |m|
-        m.property('bob', "hello <%= world %>")
-        m.property('alice', "hello <%= 1 % 2 %>")
-      end
-      m.read_property('bob').must_equal "hello <%= world %>"
-      world = 'world'
-      m.read_property('bob', binding).must_equal "hello world"
-      m.read_property('alice', binding).must_equal "hello 1"
+    it "must evaluate erb code when read property with evaluate option is true" do
+      skip
+      @message[:p3] = "1 + 1 = <%= 1 + 1 %>"
+      @message[:p4] = "1 + 1 = <%= two %>"
+      @message.read_property(:p3, binding).must_equal "1 + 1 = 2"
+      @message[:p3].must_equal "1 + 1 = <%= 1 + 1 %>"
+      two = 2
+      @message[:p4, binding].must_equal "1 + 1 = 2"
+      @message[:p4].must_equal "1 + 1 = <%= two %>"
     end
 
     it "must be able to pretty print an app_event message" do
-      Message.inform('STATUS') do |m|
-        m.property('status_type', 'APP_EVENT')
-        m.property('event', 'DONE.OK')
-        m.property('app', 'app100')
-        m.property('msg', 'Everything will be OK')
-        m.property('seq', 1)
-      end.print_app_event.must_equal "APP_EVENT (app100, #1, DONE.OK): Everything will be OK"
-    end
-  end
-
-  describe "when asked to parse a XML element into Message object" do
-    it "must create the message object correctly " do
-      xml = Message.create do |m|
-        m.property('type', 'vm')
-        m.property('os', 'debian')
-        m.property('memory', { value: 1024, unit: 'mb', precision: 0 })
-        m.property('devices', [{ name: 'w0', driver: 'mod_bob'}, { name: 'w1', driver: ['mod1', 'mod2']} ])
-        m.property('true', true)
-        m.property('false', false)
-        m.property('boolean_array', [false, true])
-      end.canonicalize
-
-      message = Message.parse(xml)
-
-      message.must_be_kind_of Message
-      message.operation.must_equal :create
-      message.read_element("property").size.must_equal 7
-      message.read_content("property[@key='memory']/unit").must_equal 'mb'
-      message.read_element("property").size.must_equal 7
-      message.read_property("type").must_equal 'vm'
-      message.read_property(:type).must_equal 'vm'
-
-      memory = message.read_property(:memory)
-      memory.must_be_kind_of Hashie::Mash
-      memory.value.must_equal 1024
-      memory.unit.must_equal 'mb'
-      memory.precision.must_equal 0
-
-      devices = message.read_property(:devices)
-      devices.must_be_kind_of Array
-      devices.size.must_equal 2
-      devices.find { |v| v.name == 'w1'}.driver.size.must_equal 2
-      # Each property iterator
-      message.each_property do |v|
-        %w(type os memory devices true false boolean_array).must_include v.attr('key')
-      end
-
-      message.read_property(:true).must_equal true
-      message.read_property(:false).must_equal false
-      message.read_property('boolean_array').must_equal [false, true]
-    end
-
-    it "must fail if parse an empty xml" do
-      lambda { Message.parse("") }.must_raise ArgumentError
-      lambda { Message.parse(nil) }.must_raise ArgumentError
-    end
-  end
-
-  describe "when query the message object" do
-    it "must return nil if content of a property is empty string" do
-      xml = Message.request do |m|
-        m.property('type', 'vm')
-        m.property('empty')
-        m.element('empty')
-      end
-
-      xml.read_property('type').must_equal 'vm'
-      xml.read_property('empty').must_equal nil
-      xml.read_content('empty').must_equal nil
+      @message = OmfCommon::Message.create(:inform,
+                     { status_type: 'APP_EVENT',
+                       event: 'DONE.OK',
+                       app: 'app100',
+                       msg: 'Everything will be OK',
+                       seq: 1 },
+                     { itype: 'STATUS' })
+      @message.print_app_event.must_equal "APP_EVENT (app100, #1, DONE.OK): Everything will be OK"
     end
   end
 end

data/test/test_helper.rb

@@ -4,9 +4,12 @@ SimpleCov.start { add_filter "/test" }
 gem 'minitest'
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'minitest/spec'
+require 'minitest/mock'
 
 require 'omf_common'
 
+OmfCommon::Message.init(type: :xml)
+
 # Shut up all the loggers
 Logging.logger.root.clear_appenders
-