libastag 0.0.1 → 0.0.2

data/lib/violet/response.rb

@@ -48,13 +48,16 @@ if you want to access to the REXML::Document object of a ServerRsp you can eithe
 
 =end
 
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) or $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'helpers.rb'
+
 module Response
-  require File.join(File.dirname(__FILE__), 'helpers.rb')
 
   # ProtocolExcepion are raised if server return a unknown response.
   #
   # see http://api.nabaztag.com/docs/home.html#messages
-  class ProtocolExcepion < Exception; end
+  class ProtocolExcepion < StandardError; end
 
 
   # contains some basic stuff, abstract class etc. they're used internaly and you should not access this module.

data/test/fake_violet_srv.rb

@@ -70,7 +70,7 @@ module FakeVioletSrv
 
 
 
-  def FakeVioletSrv.start(port=3000, logfile=false)
+  def FakeVioletSrv.start(port=3_000, logfile=false)
     if logfile
       log = File.open(logfile, 'w')
       $stderr = log

data/test/test_helpers.rb

@@ -1,12 +1,10 @@
 #!/usr/bin/ruby
 
-
-def from_this_file_path *args
-  File.join( File.dirname(__FILE__), *args )
-end
+MY_PATH = File.join( File.dirname(__FILE__), '..', 'lib', 'violet' )
+$:.unshift(MY_PATH) unless $:.include?(MY_PATH)
 
 
-require from_this_file_path('..', 'lib', 'violet', 'helpers.rb')
+require 'helpers.rb'
 
 require 'rexml/document'
 require 'test/unit'

data/test/{test_send.rb → test_query_and_actions.rb}

@@ -1,14 +1,12 @@
 #!/usr/bin/ruby
 
-
-def from_this_file_path *args
-  File.join( File.dirname(__FILE__), *args )
-end
+MY_PATH = File.join( File.dirname(__FILE__), '..', 'lib', 'violet' )
+$:.unshift(MY_PATH) unless $:.include?(MY_PATH)
 
 
-require from_this_file_path('fake_violet_srv.rb')
-require from_this_file_path('..', 'lib', 'violet', 'request.rb')
-require from_this_file_path('..', 'lib', 'violet', 'response.rb')
+require File.join( File.dirname(__FILE__), 'fake_violet_srv.rb' )
+require 'request.rb'
+require 'response.rb'
 
 require 'test/unit'
 require 'open-uri'
@@ -20,12 +18,12 @@ require 'open-uri'
 #
 
 t = Thread.new do
-  FakeVioletSrv.start 3000, from_this_file_path('testsend_log.tmp')
+  FakeVioletSrv.start 3_000, File.join( File.dirname(__FILE__), 'testsend_log.tmp' )
 end
 sleep 1 # wait for server start.
 
 
-class ActionTest < Test::Unit::TestCase
+class QueryAndActionTest < Test::Unit::TestCase
   require 'rexml/document'
 
   GOOD_SERIAL   = '1234567890AB'
@@ -33,7 +31,7 @@ class ActionTest < Test::Unit::TestCase
   BAD_SERIAL    = '1X34U67890AB'
   BAD_TOKEN     = '123456789A'
 
-  LOCAL_URI     = 'http://localhost:3000/api.jsp?'
+  LOCAL_URI     = 'http://localhost:3000/api.jsp'
 
   # Hacky ! yes !
   Request::API_URL = LOCAL_URI
@@ -46,6 +44,25 @@ class ActionTest < Test::Unit::TestCase
   end
 
 
+  def test_query_new
+    assert_nothing_raised { Request::Query.new :token => GOOD_TOKEN, :serial => GOOD_SERIAL, :event => Request::GET_SIGNATURE }
+    assert_raise(ArgumentError) { Request::Query.new :serial => GOOD_SERIAL, :event => Request::GET_SIGNATURE }
+    assert_raise(ArgumentError) { Request::Query.new :token => GOOD_TOKEN, :event => Request::GET_SIGNATURE }
+    assert_raise(ArgumentError) { Request::Query.new :token => GOOD_TOKEN, :serial => GOOD_SERIAL }
+  end
+
+
+  def test_query_to_url
+    [ Request::GET_RABBIT_NAME,
+      Request::GET_FRIENDS_LIST,
+      Request::GET_EARS_POSITION
+    ].each do |e|
+      q = Request::Query.new :event => e, :serial => GOOD_SERIAL, :token => GOOD_TOKEN
+      assert_equal "#{Request::API_URL}?sn=#{GOOD_SERIAL}&token=#{GOOD_TOKEN}&#{e.to_url}", q.to_url
+    end
+  end
+
+
   def test_xml_response
     rsp = Request::Query.new(:event => Request::GET_RABBIT_NAME, :serial => GOOD_SERIAL, :token => GOOD_TOKEN).send!(:xml)
     assert_nothing_raised { REXML::Document.new(rsp) }

data/test/test_request_base.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/ruby
+
+
+MY_PATH = File.join( File.dirname(__FILE__), '..', 'lib', 'violet' )
+$:.unshift(MY_PATH) unless $:.include?(MY_PATH)
+
+
+require 'request.rb'
+require 'response.rb'
+
+require 'test/unit'
+
+
+
+
+class RequestBaseTest < Test::Unit::TestCase
+  include Request
+
+  class EventTestFake < Base::Event
+    # nothin'
+  end
+
+  class EventTestSimple < Base::Event
+    def initialize str
+      @val = str
+    end
+    def to_url
+      @val.to_s
+    end
+  end
+
+  # make sure that Event is an abstract class and that all class that
+  # inherit of Event has to redefine initialize and to_url.
+  def test_class_Event
+    assert_raise(NotImplementedError) { Base::Event.new }
+    assert_raise(NotImplementedError) { EventTestFake.new }
+
+    EventTestFake.class_eval do
+      def initialize
+      end
+    end
+    assert_nothing_raised { EventTestFake.new }
+    assert_raise(NotImplementedError) { EventTestFake.new.to_url }
+  end
+
+  
+  def test_EventCollection_new_and_add
+    assert_raise(ArgumentError) { Base::EventCollection.new(1,2) }
+
+    class << (s = String.new)
+      def to_url
+        self
+      end
+    end
+    assert_nothing_raised { Base::EventCollection.new(s,s) }
+    assert_nothing_raised { Base::EventCollection.new(EventTestSimple.new(1),EventTestSimple.new(2)) }
+
+    gou = EventTestSimple.new 'gou'
+    foo = EventTestSimple.new 'foo'
+    assert_equal Base::EventCollection.new(gou,foo).to_url, (gou+foo).to_url
+                 
+  end
+
+
+  def test_EventCollection_to_url
+    one     = EventTestSimple.new 1
+    two     = EventTestSimple.new 2
+    three   = EventTestSimple.new 3
+    all     = nil
+
+    assert_nothing_raised { all = one + two + three }
+
+    expected_uri = [ one.to_url, two.to_url, three.to_url ]
+    assert_equal expected_uri, all.to_url
+  end
+end

data/test/test_request_chor.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/ruby
+
+
+MY_PATH = File.join( File.dirname(__FILE__), '..', 'lib', 'violet' )
+$:.unshift(MY_PATH) unless $:.include?(MY_PATH)
+
+
+require 'request.rb'
+require 'response.rb'
+
+require 'test/unit'
+
+
+
+
+class ChorTrinity < Struct.new :code, :strcode, :result
+end
+
+class ChoregraphyTest < Test::Unit::TestCase
+  include Request
+
+  SIMPLES_CHORS = [
+    ChorTrinity.new(Proc.new { set top led red },
+                    'set top led red',
+                    'chor=10,0,led,4,255,0,0'),
+    ChorTrinity.new(Proc.new { move right ear forward of degrees 10 },
+                    'move right ear forward of degrees 10',
+                    'chor=10,0,motor,0,10,0,0')
+  ]
+
+  ALL_CHORS = SIMPLES_CHORS
+
+
+  def test_creating_simple_choregraphy
+    SIMPLES_CHORS.each do |chor|
+      assert_equal [chor.result], Choregraphy.new(&chor.code).to_url
+      assert_equal [chor.result, 'chortitle=foo'], Choregraphy.new({:name => :foo},&chor.code).to_url
+    end
+    # <bugfix:001>
+    c = Choregraphy.new { set left right off }
+    assert_equal 'chor=10,0,led,1,0,0,0,0,led,3,0,0,0', c.to_url.first
+  end
+
+
+  def test_protected_and_private_methods
+    c = Choregraphy.new
+    %w[chor __choreval__ at time right left both all top bottom middle led leds ear ears to rgb red green blue cyan magenta yellow white off forward backward of degrees].each do |sym|
+      assert_raise(NoMethodError) { eval "c.#{sym}" }
+    end
+  end
+
+
+  def test_creating_with_strings
+    ALL_CHORS.each do |chor|
+      assert_equal Choregraphy.new(&chor.code), Choregraphy.new(:code => chor.strcode)
+    end
+  end
+
+
+  def test_creating_with_multiple_args
+    chors = ALL_CHORS.collect { |c| c.strcode }
+    assert_equal Choregraphy.new(:code => chors), Choregraphy.new(:code => chors.join("\n"))
+  end
+
+
+  def test_at_time_syntax
+    ary = Array.new
+    ary << Choregraphy.new do
+      at time 0
+        set right led to green
+      at time 1
+        set left  led to red
+    end
+    ary << Choregraphy.new do
+      at time 0 do set right led to green   end
+      at time 1 do set left  led to red     end
+    end
+    ary << Choregraphy.new do
+      set right led to green at time 0
+      set left  led to red   at time 1
+    end
+
+    element = ary.pop
+    ary.each { |e| assert_equal element, e }
+  end
+
+
+  def test_move_syntax
+    ary = Array.new
+    ary << Choregraphy.new { move both ears forward degrees 130 }
+    ary << Choregraphy.new { move both forward degrees 130 }
+    ary << Choregraphy.new { move both forward of degrees 130 }
+    ary << Choregraphy.new { move both ears forward of degrees 130 }
+    ary << Choregraphy.new { move left  ear forward of degrees 130
+                             move right ear forward of degrees 130 }
+
+    element = ary.pop
+    ary.each { |e| assert_equal element, e }
+  end
+
+  
+  def test_set_syntax
+    ary = Array.new
+    ary << Choregraphy.new {  set left  led green
+                              set right led green }
+    ary << Choregraphy.new { set left right led to green }
+    ary << Choregraphy.new { set right left rgb(0,255,0) }
+    ary << Choregraphy.new { set right left to 0,255,0 }
+
+    element = ary.pop
+    ary.each { |e| assert_equal element, e }
+  end
+
+
+  def test_operators
+    one     = Choregraphy.new { move left ear forward of degrees 42 }
+    two     = Choregraphy.new { move right ear forward of degrees 42 }
+    onetwo  = Choregraphy.new { move both ears forward of degrees 42 }
+
+    assert_equal one | two, one + two
+    assert_equal one & two, Choregraphy.new
+    assert_equal one - two, one
+    assert_equal two - one, two
+    assert_equal onetwo, one + two
+    assert_equal onetwo & two, two
+    assert_equal onetwo & one, one
+    assert_equal onetwo - two, one
+    assert_equal onetwo - one, two
+    assert_equal onetwo | two, onetwo
+    assert_equal onetwo | one, onetwo
+  end
+
+
+  def test_low_level_EarCommandStruct
+    expected = Choregraphy.new { at time 0 do move left ear forward of degrees 120 end }
+
+    e = Choregraphy::EarCommandStruct.new
+    e.element   = Choregraphy::Ears::Positions::LEFT
+    e.direction = Choregraphy::Ears::Directions::FORWARD
+    e.angle     = 120
+    e.time      = 0 * 10
+    
+    c = Choregraphy.new
+    c.move(e)
+    assert_equal expected, c
+  end
+
+
+  def test_low_level_LedCommandStruct
+    expected = Choregraphy.new { at time 2 do set right top red end }
+
+    l = Choregraphy::LedCommandStruct.new
+    l.elements  = [ Choregraphy::Leds::Positions::RIGHT,
+                    Choregraphy::Leds::Positions::TOP ]
+    l.color     = Choregraphy::Leds::Colors::RED
+    l.time      = 2 * 10
+    
+    c = Choregraphy.new
+    c.set(l)
+    assert_equal expected, c
+  end
+end

data/test/test_request_stuff.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/ruby
+
+
+MY_PATH = File.join( File.dirname(__FILE__), '..', 'lib', 'violet' )
+$:.unshift(MY_PATH) unless $:.include?(MY_PATH)
+
+
+require 'request.rb'
+require 'response.rb'
+
+require 'test/unit'
+
+
+
+
+class RequestStuffTest < Test::Unit::TestCase
+  include Request
+
+  def test_SetEarsPosition_new
+    assert_equal 0,  SetEarsPosition::MIN_POS
+    assert_equal 16, SetEarsPosition::MAX_POS
+
+    min, max = SetEarsPosition::MIN_POS, SetEarsPosition::MAX_POS
+
+
+    [:posleft, :posright].each do |sym|
+      assert_raise(ArgumentError) { SetEarsPosition.new }
+      assert_raise(ArgumentError) { SetEarsPosition.new sym => (min-1) }
+      assert_raise(ArgumentError) { SetEarsPosition.new sym => (max+1) }
+    end
+
+    assert_nothing_raised do
+      SetEarsPosition.new :posleft  => min
+      SetEarsPosition.new :posright => max
+      SetEarsPosition.new :posright => min, :posleft => max
+    end
+  end
+
+  
+  def test_SetEarsPosition
+    e = SetEarsPosition.new :posleft => 12, :posright => 1.1
+    assert_equal ['posleft=12','posright=1'], e.to_url
+  end
+
+
+  def test_TtsMessage_new
+    assert_equal 1,     TtsMessage::MIN_PITCH
+    assert_equal 32000, TtsMessage::MAX_PITCH
+    assert_equal 1,     TtsMessage::MIN_PITCH
+    assert_equal 32000, TtsMessage::MAX_PITCH
+
+    assert_raise(ArgumentError) { TtsMessage.new }
+    assert_raise(ArgumentError) { TtsMessage.new :tts => '', :speed => (TtsMessage::MAX_SPEED) +1 }
+    assert_raise(ArgumentError) { TtsMessage.new :tts => '', :speed => (TtsMessage::MIN_SPEED) -1 }
+    assert_raise(ArgumentError) { TtsMessage.new :tts => '', :pitch => (TtsMessage::MAX_PITCH) +1 }
+    assert_raise(ArgumentError) { TtsMessage.new :tts => '', :pitch => (TtsMessage::MIN_PITCH) -1 }
+
+    assert_nothing_raised do
+      TtsMessage.new :tts => 'foo'
+      TtsMessage.new :tts => 'foo', :pitch => TtsMessage::MIN_PITCH
+      TtsMessage.new :tts => 'foo', :pitch => TtsMessage::MAX_PITCH
+      TtsMessage.new :tts => 'foo', :speed => TtsMessage::MIN_PITCH
+      TtsMessage.new :tts => 'foo', :speed => TtsMessage::MAX_PITCH
+    end
+  end
+
+
+  def test_TtsMessage
+    e     = nil
+    tts   = 'Hello world'
+    assert_nothing_raised { e = TtsMessage.new :tts => tts }
+    assert_equal ["tts=#{URI.escape(tts)}"], e.to_url
+
+    pitch = 12
+    speed = 11.1
+    assert_nothing_raised do
+      e = TtsMessage.new    :tts    => tts,
+                            :speed  => speed,
+                            :pitch  => pitch
+    end
+    assert_equal ["pitch=#{pitch}","speed=#{speed.to_i}","tts=#{URI.escape(tts)}"], e.to_url
+  end
+
+
+  def test_TtsMessage_with_nabcast
+    title = 'this is a test'
+    msg   = 'wow ! a message !'
+    t     = nil
+
+    assert_nothing_raised do
+      TtsMessage.new :tts => msg, :nabcast => 12
+      TtsMessage.new :tts => msg, :nabcast => 12, :nabcasttitle => title
+      t = TtsMessage.new :tts => msg, :nabcast => 12, :nabcasttitle => title, :pitch => 42, :speed => 120
+    end
+
+    expected = ['nabcast=12',"nabcasttitle=#{URI.escape(title)}",'pitch=42','speed=120',"tts=#{URI.escape(msg)}"]
+    assert_equal expected, t.to_url
+  end
+
+
+  def test_IdMessage_new
+    assert_equal 1, IdMessage::MIN_IDMESSAGE
+
+    assert_raise(ArgumentError) { IdMessage.new }
+    assert_raise(ArgumentError) { IdMessage.new :idmessage => (IdMessage::MIN_IDMESSAGE)-1 }
+    assert_nothing_raised { IdMessage.new :idmessage => IdMessage::MIN_IDMESSAGE }
+  end
+
+
+  def test_IdMessage_with_nabcast
+    id      = 1337
+    nabcast = 118218
+    title   = "it's gonna rain"
+
+    assert_equal ['idmessage=1337'], IdMessage.new(:idmessage => id).to_url
+
+    i = IdMessage.new :idmessage => id, :nabcast => nabcast, :nabcasttitle => title
+    assert_equal [ 'idmessage=1337', "nabcast=#{nabcast}", "nabcasttitle=#{URI.escape(title)}"].sort, i.to_url.sort
+  end
+
+
+  def test_AudioStream_new
+    assert_raise(ArgumentError) { AudioStream.new }
+    assert_raise(ArgumentError) { AudioStream.new('') }
+    assert_raise(ArgumentError) { AudioStream.new([]) }
+    assert_raise(ArgumentError) { AudioStream.new(Hash.new) }
+    assert_raise(ArgumentError) { AudioStream.new(:foo => "bar") }
+
+    assert_nothing_raised { AudioStream.new 'foo' }
+    assert_nothing_raised { AudioStream.new %w[foo] }
+    assert_nothing_raised { AudioStream.new :url_list => 'foo' }
+    assert_nothing_raised { AudioStream.new :url_list => %w[foo] }
+  end
+
+
+  def test_AudioStream_to_url
+    assert_equal 'urlList=one', AudioStream.new('one').to_url
+    assert_equal 'urlList=two', AudioStream.new('two').to_url
+    assert_equal 'urlList=two|one', AudioStream.new(%w[two one]).to_url
+    assert_equal 'urlList=one|two', AudioStream.new(%w[one two]).to_url
+    assert_equal 'urlList=one|two|three', AudioStream.new(%w[one two], 'three').to_url
+    assert_equal 'urlList=one|two|three', AudioStream.new(%w[one], 'two', ['three']).to_url
+  end
+
+
+  def test_AudioStream_equals
+    one = AudioStream.new('one')
+    assert_equal one, AudioStream.new('one')
+    assert_equal one, AudioStream.new(%w[one])
+    assert_equal one, AudioStream.new(:url_list => %w[one])
+    assert_equal one, AudioStream.new(:url_list => 'one')
+    assert_not_equal one, AudioStream.new('two')
+
+    onetwo = AudioStream.new('one', 'two')
+    assert_equal onetwo, AudioStream.new('one', 'two')
+    assert_equal onetwo, AudioStream.new(['one', 'two'])
+    assert_equal onetwo, AudioStream.new('one', %w[two])
+    assert_equal onetwo, AudioStream.new(:url_list => ['one', 'two'])
+    assert_not_equal onetwo, AudioStream.new('two' 'one')
+  end
+
+
+  def test_AudioStream_add
+    one = AudioStream.new('one')
+    two = AudioStream.new('two')
+
+    assert_equal one + two, AudioStream.new('one', 'two')
+    assert_equal two + one, AudioStream.new('two', 'one')
+  end
+end
+