ardtweeno 0.0.2 → 0.2.5

data/test/node_test.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack/test'
+require 'ardtweeno'
+require 'logger'
+require 'json'
+
+ENV['RACK_ENV'] = 'test'
+
+
+class NodeTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+  
+  attr_accessor :node
+  
+  
+  # Test suite fixtures
+  def setup
+    
+    Ardtweeno.setup({:test=>true, :log=>Logger.new(STDOUT), :level=>Logger::DEBUG})
+    
+    nodename = "node01"
+    nodekey = "0123456789abcdef"
+    
+    @node = Ardtweeno::Node.new(nodename, nodekey, {:version=>"0.5.0"})
+    @packetArray = Array.new
+    
+    # Create 20 packets and add to the node
+    20.times do |i|
+      newKey = "0123456789abcdef"
+      newData = [23.5, 997.8, 30]    
+      newPacket = Ardtweeno::Packet.new(i, newKey, newData)
+      
+      @packetArray << newPacket
+    end
+
+  end
+  
+
+  # tear down the test fixtures between each test
+  def teardown
+    @node = nil
+    @packetArray = nil
+  end
+  
+  
+  # Test to ensure the Ardtweeno::Node#enqueue is working correctly
+  def test_enqueue
+    
+    # Add the packets to the queue to test the enqueue method
+    begin
+      @packetArray.each {|i| @node.enqueue(i)}
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace
+    end
+     
+    # Test to ensure an attempt to queue an object other than an Ardtweeno::Node raises exception
+    assert_raise Ardtweeno::NotAPacket do
+      @node.enqueue(Hash.new)
+    end
+    
+  end
+  
+  
+  # Test to ensure the Ardtweeno::Node#dequeue is working correctly
+  def test_dequeue
+    
+    # Test to ensure an attempt to call dequeue on a Node with an empty list raises exception
+    assert_raise Ardtweeno::PacketListEmpty do
+      @node.dequeue
+    end
+    
+    # Add the packets to the queue to test the enqueue method
+    begin
+      @packetArray.each {|i| @node.enqueue(i)}
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace
+    end
+    
+    # Ensure the packets dequeued are the same as the ones we enqueued
+    begin
+      @packetArray.each {|i| assert_equal(i, @node.dequeue)}
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace
+    end
+    
+    # Test to ensure an attempt to call dequeue on a Node with an empty list raises exception
+    assert_raise Ardtweeno::PacketListEmpty do
+      @node.dequeue
+    end    
+    
+  end
+  
+  
+  # Test to ensure the Ardtweeno::Node#to_s method is working correctly
+  def test_to_s
+    assert_equal(["node01, 0123456789abcdef, Default Description, 0.5.0, []", "[]"], @node.to_s)
+  end
+  
+
+end

data/test/nodemanager_test.rb

@@ -0,0 +1,167 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack/test'
+require 'ardtweeno'
+require 'logger'
+require 'json'
+
+ENV['RACK_ENV'] = 'test'
+
+
+class NodeManagerTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+  
+  attr_accessor :dispatch
+  
+  
+  # Test suite fixtures
+  def setup
+    
+    Ardtweeno.setup({:test=>true, :log=>Logger.new(STDOUT), :level=>Logger::DEBUG})
+    
+    @init = Array.new
+    
+    6.upto(10) do |i|
+      @init << Ardtweeno::Node.new("node#{i}", "abcdef#{i}")
+    end
+    
+    @nodeList = Array.new
+    
+    5.times do |i|
+      @nodeList << Ardtweeno::Node.new("node#{i}", "abcdef#{i}")
+    end
+    
+    @nodemanager = Ardtweeno::NodeManager.new({:nodelist => @init})
+    
+    @removeTest = Ardtweeno::Node.new("removetest", "testremove")
+
+    @watch = { :node=>@init[2], :notifyURL=> "http://example.org/",
+      :method=>"POST", :timeout=>"60" }
+
+  end
+  
+
+  # tear down the test fixtures between each test
+  def teardown
+    @nodemanager = nil
+    @init = nil
+    @nodeList = nil
+    @removeTest = nil
+    @watch = nil
+  end
+  
+  
+  # Test to ensure the Ardtweeno::NodeManager#addNode method can successfully add
+  # an Ardtweeno::Node to the nodelist field. 
+  def test_addNode
+    
+    # Check to ensure each Node is successfully added to the system
+    @nodeList.each do |i|
+      assert_equal(true, @nodemanager.addNode(i))   
+    end
+    
+    finalArray = @init #+ @nodeList
+    # nodeList should contain the initial values and the ones we just added    
+    assert_equal(finalArray, @nodemanager.nodeList)
+    
+    # Test to ensure it will raise an exception if we try to add something other than an
+    # Ardtweeno::Node
+    assert_raise Ardtweeno::NotANode do
+      @nodemanager.addNode(Hash.new)
+    end
+  end
+  
+  
+  # Test to ensure the Ardtweeno::NodeManager#removeNode can successfully find and then
+  # delete the specified Ardtweeno::Node from the managed nodeList
+  def test_remove
+    
+    # Add the testNode    
+    @nodemanager.addNode(@removeTest)
+    # Before the removal
+    assert_equal(6, @nodemanager.nodeList.size)
+    testNode = @nodemanager.removeNode({:node => "removetest"})
+    assert_equal(testNode, @removeTest)
+    # After the removal
+    assert_equal(5, @nodemanager.nodeList.size)
+    
+    # Add the testNode    
+    @nodemanager.addNode(@removeTest)
+    # Before the removal
+    assert_equal(6, @nodemanager.nodeList.size)
+    testNode = @nodemanager.removeNode({:key => "testremove"})
+    assert_equal(testNode, @removeTest)
+    # After the removal
+    assert_equal(5, @nodemanager.nodeList.size)
+    
+    # Test to ensure a search for a node not in the list raises an exception
+    assert_raise Ardtweeno::NotInNodeList do
+      @nodemanager.search({})
+    end
+    
+  end
+  
+  
+  # Test to ensure the Ardtweeno::NodeManager#search method can successfully find
+  # an Ardtweeno::Node in the nodeList
+  def test_search
+    
+    # Search using key
+    @init.each do |i|
+      assert_equal(i, @nodemanager.search({:key => i.key}))
+    end
+    
+    # Search using node name
+    @init.each do |i|
+      assert_equal(i, @nodemanager.search({:node => i.node}))
+    end
+    
+    # Test to ensure a search for a node not in the list raises an exception
+    assert_raise Ardtweeno::NotInNodeList do
+      @nodemanager.search({:key => @nodeList[0].key})
+    end
+    
+    # Test to ensure a search for a node not in the list raises an exception
+    assert_raise Ardtweeno::NotInNodeList do
+      @nodemanager.search({:node => @nodeList[0].node})
+    end
+    
+    # Test to ensure a search for a node not in the list raises an exception
+    assert_raise Ardtweeno::NotInNodeList do
+      @nodemanager.search({})
+    end
+    
+  end
+  
+  
+  # Test to ensure the watched? works correctly
+  def test_watched?
+    # Check to ensure they are all unwatched initially
+    @init.each do |i|
+      assert_equal(false, @nodemanager.watched?(i))
+    end
+    
+    # Add a watch and retest
+    @nodemanager.addWatch({ :node=>"node6", 
+                            :notifyURL=>"http://example.com", 
+                            :timeout=>"60", 
+                            :method=>"POST"
+                          })
+    
+    assert_nothing_raised do
+      assert_equal(true, @nodemanager.watched?(@init[0]))  
+    end
+    
+    assert_nothing_raised do
+      @nodemanager.removeWatch("node6")  
+    end
+    
+    assert_nothing_raised do
+      assert_equal(false, @nodemanager.watched?(@init[0]))  
+    end
+    
+  end
+  
+
+end

data/test/packet_test.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack/test'
+require 'ardtweeno'
+require 'logger'
+require 'json'
+
+ENV['RACK_ENV'] = 'test'
+
+
+class PacketTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+  
+  attr_accessor :packetArray
+  
+  
+  # Test suite fixtures, setup before each test is executed
+  def setup
+    
+    Ardtweeno.setup({:test=>true, :log=>Logger.new(STDOUT), :level=>Logger::DEBUG})
+    
+    # Create a DateTime instance
+    today = DateTime.now
+    @theDate = today.year.to_s() + "-" + "%02d" % today.month.to_s() + "-" + "%02d" % today.day.to_s()
+    @newHour = ("%02d" % today.hour).to_s
+    @newMinute = ("%02d" % today.min).to_s
+    
+    # Instantiate the packetArray
+    @packetArray = Array.new
+    
+    # Create 20 packets and add to the packetList
+    20.times do |i|
+      newKey = "0123456789abcdef"
+      newData = [23.5, 997.8, 30]    
+      newPacket = Ardtweeno::Packet.new(i, newKey, newData)
+      
+      @packetArray << newPacket
+    end
+
+  end
+  
+
+  # tear down the test fixtures between each test
+  def teardown
+    @packetArray = nil
+  end
+
+
+  # Test the Ardtweeno::Packet#to_s method
+  def test_to_s
+    @packetArray.each do |i|
+      assert_equal(
+      "Packet No: #{i.seqNo} Key: 0123456789abcdef Node: defaultNode Date: #{@theDate} #{@newHour}:#{@newMinute} Data: [23.5, 997.8, 30]",
+      i.to_s
+      )
+    end
+  end
+  
+  # Test the Ardtweeno::Packet#to_json method
+  def test_to_json
+    str = "{\"date\":\"#{@theDate}\",\"hour\":\"#{@newHour}\",\"minute\":\"#{@newMinute
+    }\",\"node\":\"defaultNode\",\"key\":\"0123456789abcdef\",\"seqNo\":0,\"data\":[23.5,997.8,30]}"
+    
+    assert_equal(str, @packetArray.first.to_json)
+    
+    # Create JSON objects and compare
+    json1 = JSON.parse(str)
+    json2 = JSON.parse(@packetArray.first.to_json)
+    
+    assert_equal(json1, json2)
+  end
+  
+
+end

data/test/parser_test.rb

@@ -0,0 +1,147 @@
+require 'rubygems'
+require 'test/unit'
+require 'rack/test'
+require 'ardtweeno'
+require 'logger'
+require 'json'
+
+ENV['RACK_ENV'] = 'test'
+
+
+class ParserTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+  
+  attr_accessor :parser, :mock, :modem, :validdata, :invaliddata, :validdata_invalidnode, :thenode,
+                :themanager
+  
+  
+  # Test suite fixtures
+  def setup
+    
+    Ardtweeno.setup({:test=>true, :log=>Logger.new(STDOUT), :level=>Logger::DEBUG})
+    
+    @modem = fork do
+      Signal.trap("SIGTERM") { `killall tty0tty`; exit }
+      `test/tty0tty-1.1/pts/tty0tty`
+    end
+    
+    sleep(1)
+        
+    one = "/dev/pts/2"
+    two = "/dev/pts/3"
+    
+    begin
+      @mock = SerialDeviceMock.new(one, 9600, 100)
+      @parser = Ardtweeno::SerialParser.new(two, 9600, 100)
+    rescue Exception => e
+      puts e.message
+      `killall tty0tty`
+      exit
+    end
+    
+    @validdata = Ardtweeno::Packet.new(1, "abcvalidkey", [1,2,3])
+    @validdata_invalidnode = Ardtweeno::Packet.new(2, "abcinvalidkey", [1,2,3])
+    @invaliddata = {}
+    
+    @thenode = Ardtweeno::Node.new("validnode", "abcvalidkey", {:sensors=>["a", "b", "c"]})
+    @themanager = Ardtweeno::NodeManager.new
+    @themanager.addNode(thenode)
+    
+  end
+  
+
+  # tear down the test fixtures between each test
+  def teardown
+    @validdata = nil
+    @validdata_invalidnode = nil
+    @invaliddata = nil
+    @themanager = nil
+    @thenode = nil
+    @mock.close
+    @parser.close
+    Process.kill("SIGTERM", @modem)
+    Process.wait
+  end
+
+
+  # Test Ardtweeno::SerialParser#store can store data correctly
+  def test_parser_store
+    
+    # Valid data, with no NodeManager should raise Ardtweeno::ManagerNotDefined
+    assert_raise Ardtweeno::ManagerNotDefined do
+      @parser.store(@validdata)
+      
+    end
+    
+    # Now add the manager to the SerialParser
+    @parser.manager = @themanager
+
+    # Valid data, with valid NodeManager, but invalid node should raise Ardtweeno::NodeNotAuthorised
+    assert_raise Ardtweeno::NodeNotAuthorised do
+      @parser.store(@validdata_invalidnode)
+    end
+      
+    # Valid data, with valid NodeManager, and valid node should store successfully
+    assert_equal(true, @parser.store(@validdata))
+      
+    # Invalid data, should raise Ardtweeno::InvalidData exception
+    assert_raise Ardtweeno::InvalidData do
+      @parser.store(@invaliddata)
+    end
+    
+  end
+
+
+  # Check Ardtweeno::SerialParser#write operates correctly
+  def test_parser_write
+    
+    #Valid output
+    testData = {"seqNo" => 5, "data" => [23.5, 997.5, 65], "key" => "1234567890abcdef" }.to_json
+    assert_equal(true, @parser.write(testData))
+    val = @mock.read
+    assert_equal('{"seqNo":5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}', val)
+    
+    # Invalid Input
+    testData2 = '{seqNo:5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}'
+    assert_equal(false, @parser.write(testData2))
+
+  end  
+
+
+  # Check Ardtweeno::SerialParser#read can read data on serial device correctly
+  def test_parser_read
+    
+    # Valid input
+    testData = {"seqNo" => 5, "data" => [23.5, 997.5, 65], "key" => "1234567890abcdef" }.to_json
+    @mock.write(testData)
+    val = @parser.read
+    assert_equal('{"seqNo":5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}', val)
+    
+    # Invalid Input
+    testData2 = '{seqNo:5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}'
+    @mock.write(testData2)
+    val2 = @parser.read
+    assert_equal('{}', val2)
+
+  end
+
+
+  # Check Ardtweeno::SerialParser#valid_json? can validate JSON data correctly
+  def test_parser_validate_input 
+    valid = '{"seqNo":5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}'
+    assert_equal(true, Ardtweeno::SerialParser.valid_json?(valid))
+    
+    invalid = '{seqNo:5,"data":[23.5,997.5,65],"key":"1234567890abcdef"}' 
+    assert_equal(false, Ardtweeno::SerialParser.valid_json?(invalid))  
+  end
+  
+  
+  # Check Ardtweeno::SerialParser#nextSeq returns unique values each call
+  def test_parser_next_seq 
+    20.times do |i|
+      assert_equal(i, @parser.nextSeq)  
+    end
+  end
+
+end

data/test/post_watch

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'typhoeus'
+require 'json' 
+
+
+body = {:key=> "1230aea77d7bd38898fec74a75a87738dea9f657", 
+		:notifyURL=>"", 
+		:method=>"POST", 
+		:timeout=>"60"}
+
+puts Typhoeus::Request.post("http://localhost:4567/api/v1/watch/node2", :body=>body)