sphero_pwn 0.0.0 → 0.0.1

data/test/command_test.rb

@@ -10,6 +10,16 @@ describe SpheroPwn::Command do
     assert_equal Encoding::BINARY, bytes.encoding
   end
 
+  it 'stringifies a command with data correctly' do
+    set_device_mode = SpheroPwn::Command.new 0x02, 0x42, [0x00]
+    sequence = 0x52
+
+    bytes = set_device_mode.to_bytes sequence
+    assert_equal [0xFF, 0xFF, 0x02, 0x42, 0x52, 0x02, 0x00, 0x67],
+                 bytes.unpack('C*')
+    assert_equal Encoding::BINARY, bytes.encoding
+  end
+
   it 'clears the response bit correctly' do
     ping = SpheroPwn::Command.new 0x00, 0x01, nil
     assert_equal true, ping.expects_response?

data/test/commands/boot_main_app_test.rb

@@ -0,0 +1,11 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::BootMainApp do
+  it 'stringifies correctly' do
+    set_device_mode = SpheroPwn::Commands::BootMainApp.new
+    sequence = 0x52
+
+    assert_equal [0xFF, 0xFF, 0x01, 0x04, 0x52, 0x01, 0xA7],
+                 set_device_mode.to_bytes(sequence).unpack('C*')
+  end
+end

data/test/commands/enter_bootloader_test.rb

@@ -0,0 +1,33 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::EnterBootloader do
+  it 'stringifies correctly' do
+    set_device_mode = SpheroPwn::Commands::EnterBootloader.new
+    sequence = 0x52
+
+    assert_equal [0xFF, 0xFF, 0x00, 0x30, 0x52, 0x01, 0x7C],
+                 set_device_mode.to_bytes(sequence).unpack('C*')
+  end
+
+  describe 'when sent to the robot' do
+    before do
+      @session = new_test_session :enter_bootloader
+    end
+    after do
+      @session.send_command SpheroPwn::Commands::BootMainApp.new
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not boot back into the main application'
+      end
+
+      @session.close
+    end
+
+    it 'gets an ok response' do
+      @session.send_command SpheroPwn::Commands::EnterBootloader.new
+      response = @session.recv_until_response
+      assert_kind_of SpheroPwn::Commands::EnterBootloader::Response, response
+      assert_equal :ok, response.code
+    end
+  end
+end

data/test/commands/get_device_mode_test.rb

@@ -0,0 +1,40 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::GetDeviceMode do
+  it 'parses a normal mode response correctly' do
+    response = SpheroPwn::Commands::GetDeviceMode::Response.new 0x00, 0x00,
+        [0x00]
+
+    assert_equal :ok, response.code
+    assert_equal :normal, response.mode
+  end
+
+  it 'parses a user hack mode response correctly' do
+    response = SpheroPwn::Commands::GetDeviceMode::Response.new 0x00, 0x00,
+        [0x01]
+
+    assert_equal :ok, response.code
+    assert_equal :user_hack, response.mode
+  end
+
+  it 'does not crash when parsing an error response' do
+    response = SpheroPwn::Commands::GetDeviceMode::Response.new 0x05, 0x00,
+        [0x00]
+
+    assert_equal :unsupported, response.code
+    assert_equal :error, response.mode
+  end
+
+  describe 'when sent to the robot' do
+    before { @session = new_test_session :get_device_mode }
+    after { @session.close }
+
+    it 'receives a response' do
+      @session.send_command SpheroPwn::Commands::GetDeviceMode.new
+      response = @session.recv_until_response
+      assert_kind_of SpheroPwn::Commands::GetDeviceMode::Response, response
+
+      assert_equal :ok, response.code
+    end
+  end
+end

data/test/commands/get_flash_block_test.rb

@@ -0,0 +1,101 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::GetFlashBlock do
+  it 'stringifies get soul correctly' do
+    get_block = SpheroPwn::Commands::GetFlashBlock.new :soul
+    sequence = 0x52
+
+    bytes = get_block.to_bytes sequence
+    assert_equal [0xFF, 0xFF, 0x02, 0x46, 0x52, 0x01, 0x64], bytes.unpack('C*')
+    assert_equal Encoding::BINARY, bytes.encoding
+  end
+
+  it 'stringifies get factory config correctly' do
+    get_block = SpheroPwn::Commands::GetFlashBlock.new :factory_config
+    sequence = 0x52
+
+    bytes = get_block.to_bytes sequence
+    assert_equal [0xFF, 0xFF, 0x02, 0x40, 0x52, 0x02, 0x00, 0x69],
+                 bytes.unpack('C*')
+    assert_equal Encoding::BINARY, bytes.encoding
+  end
+
+  it 'stringifies get user config correctly' do
+    get_block = SpheroPwn::Commands::GetFlashBlock.new :user_config
+    sequence = 0x52
+
+    bytes = get_block.to_bytes sequence
+    assert_equal [0xFF, 0xFF, 0x02, 0x40, 0x52, 0x02, 0x01, 0x68],
+                 bytes.unpack('C*')
+    assert_equal Encoding::BINARY, bytes.encoding
+  end
+
+  it 'stringifies a custom block number correctly' do
+    get_block = SpheroPwn::Commands::GetFlashBlock.new :block_01_42_ff
+    sequence = 0x52
+
+    bytes = get_block.to_bytes sequence
+    assert_equal [0xFF, 0xFF, 0x02, 0x40, 0x52, 0x04, 0x01, 0x42, 0xff, 0x25],
+                 bytes.unpack('C*')
+    assert_equal Encoding::BINARY, bytes.encoding
+  end
+
+  describe 'when get soul is sent to the robot' do
+    before { @session = new_test_session :get_soul }
+    after { @session.close }
+
+    it 'receives a response and an async result' do
+      @session.send_command SpheroPwn::Commands::GetFlashBlock.new :soul
+
+      response = nil
+      async = nil
+      while response.nil? || async.nil?
+        message = @session.recv_message
+        if message.nil?
+          sleep 0.05
+          next
+        end
+
+        if message.kind_of? SpheroPwn::Response
+          response = message
+          assert_kind_of SpheroPwn::Commands::GetFlashBlock::Response, response
+          assert_equal :ok, response.code
+        else
+          async = message
+          assert_kind_of SpheroPwn::Asyncs::FlashBlock::Soul, async
+          assert_equal 0x400, async.data_bytes.length
+        end
+      end
+    end
+  end
+
+  describe 'when get factory config is sent to the robot' do
+    before { @session = new_test_session :get_factory_config }
+    after { @session.close }
+
+    it 'receives a response and an async result' do
+      @session.send_command(
+          SpheroPwn::Commands::GetFlashBlock.new(:factory_config))
+
+      response = nil
+      async = nil
+      while response.nil? || async.nil?
+        message = @session.recv_message
+        if message.nil?
+          sleep 0.05
+          next
+        end
+
+        if message.kind_of? SpheroPwn::Response
+          response = message
+          assert_kind_of SpheroPwn::Commands::GetFlashBlock::Response, response
+          assert_equal :ok, response.code
+        else
+          async = message
+          assert_kind_of SpheroPwn::Asyncs::FlashBlock::Config, async
+          assert_equal 0x400, async.data_bytes.length
+        end
+      end
+    end
+  end
+end

data/test/commands/get_permanent_flags_test.rb

@@ -0,0 +1,48 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::GetPermanentFlags do
+  it 'parses a response correctly' do
+    response = SpheroPwn::Commands::GetPermanentFlags::Response.new 0x00, 0x00,
+        [0x00, 0x00, 0x01, 0x5A]
+
+    assert_equal :ok, response.code
+    assert_equal false, response.flags[:no_sleep_while_charging]
+    assert_equal true, response.flags[:vector_drive]
+    assert_equal false, response.flags[:no_leveling_while_charging]
+    assert_equal true, response.flags[:tail_led_always_on]
+    assert_equal true, response.flags[:motion_timeouts]
+    assert_equal false, response.flags[:demo_mode]
+    assert_equal true, response.flags[:light_double_tap]
+    assert_equal false, response.flags[:heavy_double_tap]
+    assert_equal true, response.flags[:gyro_max_async]
+  end
+
+  it 'does not crash when parsing an error response' do
+    response = SpheroPwn::Commands::GetPermanentFlags::Response.new 0x05, 0x00,
+        []
+
+    assert_equal :unsupported, response.code
+    assert_equal nil, response.flags[:no_sleep_while_charging]
+    assert_equal nil, response.flags[:vector_drive]
+    assert_equal nil, response.flags[:no_leveling_while_charging]
+    assert_equal nil, response.flags[:tail_led_always_on]
+    assert_equal nil, response.flags[:motion_timeouts]
+    assert_equal nil, response.flags[:demo_mode]
+    assert_equal nil, response.flags[:light_double_tap]
+    assert_equal nil, response.flags[:heavy_double_tap]
+    assert_equal nil, response.flags[:gyro_max_async]
+  end
+
+  describe 'when sent to the robot' do
+    before { @session = new_test_session :get_permanent_flags }
+    after { @session.close }
+
+    it 'gets an ok response' do
+      @session.send_command SpheroPwn::Commands::GetPermanentFlags.new
+      response = @session.recv_until_response
+      assert_kind_of SpheroPwn::Commands::GetPermanentFlags::Response, response
+      assert_equal :ok, response.code
+    end
+  end
+end
+

data/test/commands/get_versions_test.rb

@@ -2,9 +2,11 @@ require_relative '../helper.rb'
 
 describe SpheroPwn::Commands::GetVersions do
   it 'parses a v1 response record correctly' do
-    response = SpheroPwn::Commands::GetVersions::Response.new 0x01, 0x00,
+    response = SpheroPwn::Commands::GetVersions::Response.new 0x00, 0x00,
         [0x02, 0x03, 0x01, 0xaa, 0xbb, 0x51, 0x67, 0x89]
 
+    assert_equal :ok, response.code
+
     assert_equal 3, response.versions[:model]
     assert_equal 1, response.versions[:hardware]
     assert_equal({ version: 0xaa, revision: 0xbb },
@@ -14,6 +16,13 @@ describe SpheroPwn::Commands::GetVersions do
     assert_equal({ major: 8, minor: 9}, response.versions[:macros])
   end
 
+  it 'does not crash when receiving an error' do
+    response = SpheroPwn::Commands::GetVersions::Response.new 0x05, 0x00, []
+
+    assert_equal :unsupported, response.code
+    refute_nil response.versions
+  end
+
   describe 'when sent to the robot' do
     before { @session = new_test_session :get_version }
     after { @session.close }

data/test/commands/is_page_blank_test.rb

@@ -0,0 +1,65 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::IsPageBlank do
+  it 'stringifies correctly' do
+    is_page_blank = SpheroPwn::Commands::IsPageBlank.new 0x67
+    sequence = 0x52
+
+    assert_equal [0xFF, 0xFF, 0x01, 0x05, 0x52, 0x02, 0x67, 0x3E],
+                 is_page_blank.to_bytes(sequence).unpack('C*')
+  end
+
+  it 'parses a yes response correctly' do
+    response = SpheroPwn::Commands::IsPageBlank::Response.new 0x00, 0x00,
+        [0x01]
+
+    assert_equal :ok, response.code
+    assert_equal true, response.is_blank
+    assert_equal true, response.is_blank?
+  end
+
+  it 'parses a no response correctly' do
+    response = SpheroPwn::Commands::IsPageBlank::Response.new 0x00, 0x00,
+        [0x00]
+
+    assert_equal :ok, response.code
+    assert_equal false, response.is_blank
+    assert_equal false, response.is_blank?
+  end
+
+  it 'does not crash when parsing an error response' do
+    response = SpheroPwn::Commands::IsPageBlank::Response.new 0x32, 0x00,
+        [0x01]
+
+    assert_equal :bad_page, response.code
+    assert_equal nil, response.is_blank
+    assert_equal nil, response.is_blank?
+  end
+
+  describe 'when sent to the robot' do
+    before do
+      @session = new_test_session :is_page_blank
+      @session.send_command SpheroPwn::Commands::EnterBootloader.new
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not jump into bootloader'
+      end
+    end
+    after do
+      @session.send_command SpheroPwn::Commands::BootMainApp.new
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not boot back into the main application'
+      end
+
+      @session.close
+    end
+
+    it 'gets an ok response' do
+      @session.send_command SpheroPwn::Commands::IsPageBlank.new(16)
+      response = @session.recv_until_response
+      assert_kind_of SpheroPwn::Commands::IsPageBlank::Response, response
+      assert_equal :ok, response.code
+    end
+  end
+end

data/test/commands/l2_diagnostics_test.rb

@@ -0,0 +1,58 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::L2Diagnostics do
+  it 'parses a v1 response record correctly' do
+    # TODO(pwnall): Find a device tht implements this command.
+  end
+
+  it 'does not crash when receiving an error' do
+    response = SpheroPwn::Commands::L2Diagnostics::Response.new 0x05, 0x00, []
+
+    assert_equal :unsupported, response.code
+    refute_nil response.counters
+  end
+
+  describe 'when sent to the robot' do
+    before do
+      @session = new_test_session :l2_diagnostics
+
+      @session.send_command SpheroPwn::Commands::GetDeviceMode.new
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not retrieve initial mode from device'
+      end
+      @old_mode = response.mode
+
+      @session.send_command SpheroPwn::Commands::SetDeviceMode.new :user_hack
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not set user hack mode'
+      end
+    end
+    after do
+      @session.send_command SpheroPwn::Commands::SetDeviceMode.new(@old_mode)
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError,
+            "Could not restore initial device mode #{@old_mode}"
+      end
+
+      @session.close
+    end
+
+    it 'receives a response with counters' do
+      @session.send_command SpheroPwn::Commands::L2Diagnostics.new
+      response = @session.recv_until_response
+      assert_kind_of SpheroPwn::Commands::L2Diagnostics::Response, response
+
+      # TODO(pwnall): Find a device that implements this command so we can
+      #               test it.
+      # assert_equal :ok, response.code
+      # assert_operator response.counters[:received_good], :>, 0
+      # assert_operator response.counters[:seconds_on], :>, 0
+      # refute_nil response.counters[:i2c_failures]
+      # refute_nil response.counters[:gyro_adjusts]
+    end
+  end
+end
+

data/test/commands/set_device_mode_test.rb

@@ -0,0 +1,56 @@
+require_relative '../helper.rb'
+
+describe SpheroPwn::Commands::SetDeviceMode do
+  it 'stringifies a normal mode request correctly' do
+    set_device_mode = SpheroPwn::Commands::SetDeviceMode.new :normal
+    sequence = 0x52
+
+    assert_equal [0xFF, 0xFF, 0x02, 0x42, 0x52, 0x02, 0x00, 0x67],
+                 set_device_mode.to_bytes(sequence).unpack('C*')
+  end
+
+  it 'stringifies a user hack mode request correctly' do
+    set_device_mode = SpheroPwn::Commands::SetDeviceMode.new :user_hack
+    sequence = 0x52
+
+    assert_equal [0xFF, 0xFF, 0x02, 0x42, 0x52, 0x02, 0x01, 0x66],
+                 set_device_mode.to_bytes(sequence).unpack('C*')
+  end
+
+  describe 'when sent to the robot' do
+    before do
+      @session = new_test_session :set_device_mode
+
+      @session.send_command SpheroPwn::Commands::GetDeviceMode.new
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError, 'Could not retrieve initial mode from device'
+      end
+      @old_mode = response.mode
+    end
+    after do
+      @session.send_command SpheroPwn::Commands::SetDeviceMode.new(@old_mode)
+      response = @session.recv_until_response
+      unless response.code == :ok
+        raise RuntimeError,
+            "Could not restore initial device mode #{@old_mode}"
+      end
+
+      @session.close
+    end
+
+    it 'impacts the result of the get device mode command' do
+      [:normal, :user_hack].each do |mode|
+        @session.send_command SpheroPwn::Commands::SetDeviceMode.new(mode)
+        response = @session.recv_until_response
+        assert_kind_of SpheroPwn::Commands::SetDeviceMode::Response, response
+        assert_equal :ok, response.code
+
+        @session.send_command SpheroPwn::Commands::GetDeviceMode.new
+        response = @session.recv_until_response
+        assert_equal :ok, response.code
+        assert_equal mode, response.mode
+      end
+    end
+  end
+end