omf_rc 6.0.0.pre.5 → 6.0.0.pre.6

data/test/omf_rc/resource_proxy/generic_application_spec.rb

@@ -0,0 +1,347 @@
+require 'test_helper'
+require 'omf_rc/resource_proxy/generic_application'
+
+
+
+describe OmfRc::ResourceProxy::GenericApplication do
+
+  before do
+    @app_test = OmfRc::ResourceFactory.new(:generic_application, { hrn: 'an_application' })
+    @app_test.comm = MiniTest::Mock.new
+    @app_test.comm.expect :publish, nil, [String,OmfCommon::Message]
+  end
+
+  describe "when initialised" do
+    it "must respond to an 'on_app_event' call back" do
+      #OmfRc::ResourceProxy::GenericApplication.method_defined?(:on_app_event).must_equal true
+      @app_test.must_respond_to :on_app_event
+    end
+
+    it "must have its properties set to sensible initial values" do
+      @app_test.request_state.to_sym.must_equal :stop
+      @app_test.request_tarball_install_path.must_equal '/'
+      @app_test.request_force_tarball_install.must_equal 'false'
+      @app_test.request_installed.must_equal 'false'
+      @app_test.request_map_err_to_out.must_equal 'false'
+    end
+
+    it "must be able to configure/request its basic properties" do
+      basic_prop = %w(binary_path pkg_tarball pkg_ubuntu pkg_fedora force_tarball_install map_err_to_out tarball_install_path)
+      basic_prop.each do |p|
+        @app_test.method("configure_#{p}".to_sym).call('foo')
+        @app_test.method("request_#{p}".to_sym).call.must_equal 'foo'
+      end
+    end
+
+    it "must be able to tell which platform it is running on (either: unknown | ubuntu | fedora)" do
+      @app_test.request_platform.must_match /unknown|ubuntu|fedora/
+    end
+
+    it "must be able to configure its environments property" do
+      # First give it a valid environment property
+      test_environments = { 'foo' => 123, 'bar_bar' => 'bar_123' }
+      @app_test.method(:configure_environments).call(test_environments)
+      # Then give it an invalid one, which it should ignore
+      @app_test.method(:configure_environments).call(nil)
+      @app_test.property.environments.must_be_kind_of Hash
+      @app_test.property.environments['foo'].must_equal 123
+      @app_test.property.environments['bar_bar'].must_equal 'bar_123'
+    end
+  end
+
+  describe "when configuring its parameters property" do
+    it "must be able to set its parameters property" do
+      # First give it a valid parameter property
+      test_params = { :p1 => { :cmd => '--foo', :value => 'foo'} }
+      @app_test.method(:configure_parameters).call(test_params)
+      # Then give it a couple of invalid ones, which it should ignore
+      @app_test.stub :log_inform_error, nil do
+        @app_test.method(:configure_parameters).call(nil)
+       @app_test.method(:configure_parameters).call( { :p1 => nil } )
+     end
+      @app_test.property.parameters.must_be_kind_of Hash
+      @app_test.property.parameters[:p1].must_be_kind_of Hash
+      @app_test.property.parameters[:p1][:cmd].must_equal '--foo'
+      @app_test.property.parameters[:p1][:value].must_equal 'foo'
+    end
+
+    it "must be able to merge new parameters into existing ones" do
+      old_params = { :p1 => { :cmd => '--foo', :default => 'old_foo'} }
+      @app_test.property.parameters = old_params
+      new_params = { :p1 => { :default => 'new_foo', :value => 'val_foo'},
+                     :p2 => { :cmd => 'bar', :default => 'bar_bar'} }
+      @app_test.method(:configure_parameters).call(new_params)
+      @app_test.property.parameters[:p1][:cmd].must_equal '--foo'
+      @app_test.property.parameters[:p1][:default].must_equal 'new_foo'
+      @app_test.property.parameters[:p1][:value].must_equal 'val_foo'
+      @app_test.property.parameters[:p2][:cmd].must_equal 'bar'
+      @app_test.property.parameters[:p2][:default].must_equal 'bar_bar'
+    end
+
+    it "must be able to sanitize its parameters property" do
+      test_params = { :p1 => { :mandatory => 'true', :dynamic => false},
+                      :p2 => { :mandatory => true, :dynamic => 'false'},
+                      :p3 => { :type => 'Boolean', :default => true, :value => 'false'},
+                      :p4 => { :type => 'Boolean', :default => 'true', :value => false} }
+      @app_test.method(:configure_parameters).call(test_params)
+      @app_test.property.parameters[:p1][:mandatory].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p1][:dynamic].must_be_kind_of FalseClass
+      @app_test.property.parameters[:p2][:mandatory].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p2][:dynamic].must_be_kind_of FalseClass
+      @app_test.property.parameters[:p3][:default].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p3][:value].must_be_kind_of FalseClass
+      @app_test.property.parameters[:p4][:default].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p4][:value].must_be_kind_of FalseClass
+    end
+
+    it "must be able to validate the correct type of a defined parameter" do
+      test_params = { :p1 => { :type => 'String', :default => 'foo', :value => 'bar'},
+                      :p2 => { :type => 'Numeric', :default => 123, :value => 456},
+                      :p3 => { :type => 'Boolean', :default => true, :value => true},
+                      :p4 => { :type => 'Boolean'},
+                      :p5 => { :type => 'Boolean', :default => true},
+                      :p6 => { :type => 'Boolean', :value => true},
+                      :p7 => { :type => 'Numeric'},
+                      :p8 => { :type => 'Numeric', :default => 123},
+                      :p9 => { :type => 'Numeric', :value => 123} }
+      @app_test.method(:configure_parameters).call(test_params)
+      @app_test.property.parameters[:p1][:default].must_be_kind_of String
+      @app_test.property.parameters[:p1][:value].must_be_kind_of String
+      @app_test.property.parameters[:p2][:default].must_be_kind_of Numeric
+      @app_test.property.parameters[:p2][:value].must_be_kind_of Numeric
+      @app_test.property.parameters[:p3][:default].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p3][:value].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p4][:default].must_be_nil
+      @app_test.property.parameters[:p4][:value].must_be_nil
+      @app_test.property.parameters[:p5][:default].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p6][:value].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p7][:default].must_be_nil
+      @app_test.property.parameters[:p7][:value].must_be_nil
+      @app_test.property.parameters[:p8][:default].must_be_kind_of Numeric
+      @app_test.property.parameters[:p9][:value].must_be_kind_of Numeric
+    end
+
+    it "must be able to detect incorrect type setting for a defined parameter, and DO NOT update the parameter in that case" do
+      old_params = { :p1 => { :type => 'String', :value => 'foo'},
+                     :p2 => { :type => 'Numeric', :default => 123, :value => 456 },
+                     :p3 => { :type => 'Boolean', :default => true, :value => true} }
+      @app_test.property.parameters = old_params
+      new_params = { :p1 => { :type => 'String', :value => true},
+                     :p2 => { :type => 'Numeric', :default => 456, :value => '456' },
+                     :p3 => { :type => 'Boolean', :default => 123, :value => false} }
+      @app_test.stub :log_inform_error, nil do
+        @app_test.method(:configure_parameters).call(new_params)
+      end
+      @app_test.property.parameters[:p1][:value].must_equal 'foo'
+      @app_test.property.parameters[:p2][:default].must_equal 123
+      @app_test.property.parameters[:p2][:value].must_equal 456
+      @app_test.property.parameters[:p3][:default].must_be_kind_of TrueClass
+      @app_test.property.parameters[:p3][:value].must_be_kind_of TrueClass
+    end
+
+    it "must update any valid dynamic parameter with the given value" do
+      # set the parameter as dynamic
+      params1 = { :p1 => { :cmd => '--foo', :default => 'old_foo', :dynamic => true} }
+      @app_test.method(:configure_parameters).call(params1)
+      # then update it
+      params2 = { :p1 => { :value => 'bar'} }
+      @app_test.property.state = :run
+      class ExecApp
+        def initialize(app_id, res, cmd_line, err_out_map); end
+        def ExecApp.[](id); return ExecApp.new(nil,nil,nil,nil) end
+        def stdin(msg); msg.must_equal '--foo bar' end
+      end
+      @app_test.method(:configure_parameters).call(params2)
+    end
+
+  end
+
+  describe "when receiving an event from a running application instance" do
+    it "must publish an INFORM message to relay that event" do
+      @app_test.on_app_event('STDOUT', 'app_instance_id', 'Some text here').must_be_nil
+      assert @app_test.comm.verify
+    end
+
+    it "must increments its event_sequence after publishig that INFORM message" do
+      i = @app_test.property.event_sequence
+      @app_test.on_app_event('STDOUT', 'app_instance_id', 'Some text here')
+      @app_test.property.event_sequence.must_equal i+1
+    end
+
+    it "must switch its state to 'stop' if the event is of a type 'DONE'" do
+      @app_test.on_app_event('DONE.OK', 'app_instance_id', 'Some text here')
+      @app_test.request_state.to_sym.must_equal :stop
+    end
+
+    it "must set installed property to true if the event is 'DONE.OK' and the app_id's suffix is '_INSTALL'" do
+      @app_test.on_app_event('DONE.OK', 'app_instance_id_INSTALL', 'Some text here')
+      @app_test.request_state.to_sym.must_equal :stop
+      @app_test.request_installed.must_equal "true"
+    end
+  end
+
+  describe "when configuring its state property to :install" do
+    it "must do nothing if its original state is not :stop" do
+      @app_test.property.state = :run
+      @app_test.method(:configure_state).call(:install)
+      @app_test.property.state.must_equal :run
+    end
+
+    it "must do nothing if its original state is :stop and it is already installed" do
+      @app_test.property.state = :stop
+      @app_test.property.installed = true
+      @app_test.method(:configure_state).call(:install)
+      @app_test.property.state.must_equal :stop
+    end
+
+    it "must use the tarball install method if it does not know its OS platform or if force_tarball_install is set" do
+      @app_test.property.pkg_tarball = 'foo'
+      @app_test.property.tarball_install_path = '/bar/'
+      @stub_tarball_tasks = Proc.new do |pkg,path|
+        pkg.must_equal 'foo'
+        path.must_equal '/bar/'
+        @did_call_install_tarball = true
+      end
+      def call_configure
+        @app_test.stub :install_tarball, @stub_tarball_tasks do
+          @app_test.method(:configure_state).call(:install).must_equal :install
+          @did_call_install_tarball.must_equal true
+        end
+      end
+      # Unknown Platform...
+      @did_call_install_tarball = false
+      @app_test.property.state = :stop
+      @app_test.property.installed = false
+      @app_test.property.platform = :unknown
+      call_configure
+      # Force Install Tarball...
+      @did_call_install_tarball = false
+      @app_test.property.state = :stop
+      @app_test.property.installed = false
+      @app_test.property.platform = :ubuntu
+      @app_test.property.force_tarball_install = true
+      call_configure
+    end
+
+    it "must use the ubuntu install method if its OS platform is ubuntu" do
+      @did_call_install_ubuntu = false
+      @app_test.property.state = :stop
+      @app_test.property.installed = false
+      @app_test.property.platform = :ubuntu
+      @app_test.property.pkg_ubuntu = 'foo'
+      @stub_ubuntu_tasks = Proc.new do |pkg|
+        pkg.must_equal 'foo'
+        @did_call_install_ubuntu = true
+      end
+      @app_test.stub :install_ubuntu, @stub_ubuntu_tasks do
+        @app_test.method(:configure_state).call(:install).must_equal :install
+        @did_call_install_ubuntu.must_equal true
+      end
+    end
+
+    it "must use the fedora install method if its OS platform is fedora" do
+      @did_call_install_fedora = false
+      @app_test.property.state = :stop
+      @app_test.property.installed = false
+      @app_test.property.platform = :fedora
+      @app_test.property.pkg_fedora = 'foo'
+      @stub_fedora_tasks = Proc.new do |pkg|
+        pkg.must_equal 'foo'
+        @did_call_install_fedora = true
+      end
+      @app_test.stub :install_fedora, @stub_fedora_tasks do
+        @app_test.method(:configure_state).call(:install).must_equal :install
+        @did_call_install_fedora.must_equal true
+      end
+    end
+  end
+
+  describe "when configuring its state property to :run" do
+    it "must do nothing if its original state is :install" do
+      @app_test.property.state = :install
+      @app_test.method(:configure_state).call(:run)
+      @app_test.property.state.must_equal :install
+    end
+
+    it "must get back to the :run state if its original state is :pause" do
+      @app_test.property.state = :pause
+      @app_test.method(:configure_state).call(:run)
+      @app_test.property.state.must_equal :run
+    end
+
+    it "must do nothing if its binary path is not set" do
+      @app_test.property.state = :stop
+      @app_test.method(:configure_state).call(:run)
+      @app_test.property.state.must_equal :stop
+    end
+
+    it "must start an app using ExecApp and a correct command line if its original state is :stop" do
+      class ExecApp
+        def initialize(app_id, res, cmd_line, err_out_map)
+          app_id.must_equal "an_application"
+          res.must_be_kind_of OmfRc::ResourceProxy::AbstractResource
+          cmd_line.must_equal "env -i FOO=123 BAR_BAR='bar_123' my_cmd  123 -param1 bar p3  hello "
+          err_out_map.must_equal false
+        end
+      end
+      @app_test.property.state = :stop
+      @app_test.property.binary_path = "my_cmd"
+      test_env = { 'foo' => 123, 'bar_bar' => 'bar_123' }
+      test_params = { :p1 => { :type => 'String', :mandatory => true, :cmd => '-param1', :default => 'foo', :value => 'bar', :order => 2},
+                      :p2 => { :type => 'Numeric', :mandatory => true, :default => 123, :order => 1 },
+                      :p3 => { :type => 'Boolean', :cmd => 'p3', :default => false, :value => true},
+                      :p4 => { :type => 'String', :default => 'hi', :value => 'hello'},
+                      :p5 => { :type => 'Numeric', :default => 456}, }
+      @app_test.method(:configure_environments).call(test_env)
+      @app_test.method(:configure_parameters).call(test_params)
+      @app_test.method(:configure_state).call(:run)
+      @app_test.property.state.must_equal :run
+    end
+  end
+
+  describe "when configuring its state property to :pause" do
+    it "must do nothing if its original state is :stop or :install" do
+      @app_test.property.state = :stop
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :stop
+      @app_test.property.state = :install
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :install
+    end
+
+    it "must do switch its state to :pause if its original state is :run or :pause" do
+      @app_test.property.state = :run
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :pause
+      @app_test.property.state = :pause
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :pause
+    end
+  end
+
+  describe "when configuring its state property to :stop" do
+    it "must do nothing if its original state is :stop or :install" do
+      @app_test.property.state = :stop
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :stop
+      @app_test.property.state = :install
+      @app_test.method(:configure_state).call(:pause)
+      @app_test.property.state.must_equal :install
+    end
+
+    it "must stop its running application if its original state is :run or :pause" do
+      @app_test.property.state = :run
+      class ExecApp
+        def initialize(app_id, res, cmd_line, err_out_map); end
+        def ExecApp.[](id); return ExecApp.new(nil,nil,nil,nil) end
+        def stdin(msg); msg.must_equal 'exit' end
+        def signal(sig); sig.must_equal 'TERM' end
+        def kill(sig); sig.must_equal 'KILL' end
+      end
+      @app_test.method(:configure_state).call(:stop)
+      @app_test.property.state.must_equal :stop
+    end
+  end
+
+
+end

data/test/omf_rc/resource_proxy/mock_spec.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+require 'omf_rc/resource_proxy/mock'
+
+describe OmfRc::ResourceProxy::Mock do
+  before do
+    @mock = OmfRc::ResourceFactory.new(:mock, hrn: 'mock_test')
+  end
+
+  describe "when included in the resource instance" do
+    it "must provide hooks" do
+      @mock.before_ready
+      @mock.before_release
+    end
+  end
+end

data/test/omf_rc/resource_proxy/node_spec.rb

@@ -2,9 +2,40 @@ require 'test_helper'
 require 'omf_rc/resource_proxy/node'
 
 describe OmfRc::ResourceProxy::Node do
+  before do
+    @node = OmfRc::ResourceFactory.new(:node, hrn: 'node_test')
+  end
+
   describe "when included in the resource instance" do
     it "must be able to tell registered proxies" do
-      OmfRc::ResourceFactory.new(:node, hrn: 'node_test').request_proxies.must_include :node
+      @node.request_proxies.must_include :node
+    end
+
+    it "must provide a list of supported network devices" do
+      devices = [
+        { name: 'eth0', driver: 'e1000e', category: 'net', proxy: 'net' },
+        { name: 'phy0', driver: 'iwlwifi', category: 'net', subcategory: 'wlan', proxy: 'wlan' }
+      ]
+
+      Dir.stub :chdir, proc { |*args, &block| block.call } do
+        glob_proc = proc do |pattern|
+          sys_dir = "#{File.dirname(__FILE__)}/../../fixture/sys/class"
+          case pattern
+          when "net"
+            ["#{sys_dir}/net"]
+          when "ieee80211"
+            ["#{sys_dir}/ieee80211"]
+          when "ieee80211/*"
+            ["#{sys_dir}/ieee80211/phy0"]
+          when "net/eth*"
+            ["#{sys_dir}/net/eth0"]
+          end
+        end
+        Dir.stub :glob, glob_proc do
+          @node.request_devices.must_be_kind_of Array
+          @node.request_devices.must_equal devices
+        end
+      end
     end
   end
 end

data/test/omf_rc/resource_proxy_dsl_spec.rb

@@ -5,20 +5,57 @@ describe OmfRc::ResourceProxyDSL do
   before do
     module OmfRc::Util::MockUtility
       include OmfRc::ResourceProxyDSL
+
       configure :alpha
-      request :alpha
+
+      request :alpha do |resource|
+        resource.uid
+      end
+
+      work :bravo do |resource, *random_arguments, block|
+        if block
+          block.call("working on #{random_arguments.first}")
+        else
+          random_arguments.first
+        end
+      end
+
+      request :zulu do |resource, options|
+        "You called zulu with: #{options.keys.join('|')}"
+      end
+    end
+
+    module OmfRc::ResourceProxy::MockRootProxy
+      include OmfRc::ResourceProxyDSL
+
+      register_proxy :mock_root_proxy
     end
 
     module OmfRc::ResourceProxy::MockProxy
       include OmfRc::ResourceProxyDSL
 
-      register_proxy :mock_proxy
+      register_proxy :mock_proxy, :create_by => :mock_root_proxy
+
       utility :mock_utility
 
       hook :before_ready
       hook :before_release
-      configure :bravo
-      request :bravo
+
+      bravo("printing") do |v|
+        request :charlie do
+          v
+        end
+      end
+
+      request :delta do
+        bravo("printing")
+      end
+    end
+
+    module OmfRc::ResourceProxy::UselessProxy
+      include OmfRc::ResourceProxyDSL
+
+      register_proxy :useless_proxy
     end
   end
 
@@ -28,12 +65,46 @@ describe OmfRc::ResourceProxyDSL do
     end
 
     it "must be able to define methods" do
-      OmfRc::Util::MockUtility.method_defined?(:configure_alpha).must_equal true
-      OmfRc::Util::MockUtility.method_defined?(:request_alpha).must_equal true
-      OmfRc::ResourceProxy::MockProxy.method_defined?(:configure_alpha).must_equal true
-      OmfRc::ResourceProxy::MockProxy.method_defined?(:request_alpha).must_equal true
-      OmfRc::ResourceProxy::MockProxy.method_defined?(:before_ready).must_equal true
-      OmfRc::ResourceProxy::MockProxy.method_defined?(:before_release).must_equal true
+      %w(configure_alpha request_alpha bravo).each do |m|
+        OmfRc::Util::MockUtility.method_defined?(m.to_sym).must_equal true
+      end
+
+      %w(configure_alpha request_alpha before_ready before_release bravo).each do |m|
+        OmfRc::ResourceProxy::MockProxy.method_defined?(m.to_sym).must_equal true
+      end
+
+      mock_proxy = OmfRc::ResourceFactory.new(:mock_proxy)
+      mock_proxy.request_alpha.must_equal mock_proxy.uid
+      mock_proxy.request_delta.must_equal "printing"
+      mock_proxy.request_charlie.must_equal "working on printing"
+      mock_proxy.bravo("magic", "second parameter") do |v|
+        v.must_equal "working on magic"
+      end
+      mock_proxy.bravo("something", "something else").must_equal "something"
+      mock_proxy.request_zulu(country: 'uk').must_equal "You called zulu with: country"
+    end
+
+    it "must be able to include utility" do
+      Class.new do
+        include OmfRc::ResourceProxyDSL
+        utility :mock_utility
+      end.new.must_respond_to :request_alpha
+    end
+
+    it "must log error if utility can't be found" do
+      Class.new do
+        include OmfRc::ResourceProxyDSL
+        utility :wont_be_found_utility
+        stub :require, true do
+          utility :wont_be_found_utility
+        end
+      end
+    end
+
+    it "must check new proxy's create_by option when ask a proxy create a new proxy" do
+      OmfRc::ResourceFactory.new(:mock_root_proxy).create(:mock_proxy)
+      OmfRc::ResourceFactory.new(:mock_root_proxy).create(:useless_proxy)
+      lambda { OmfRc::ResourceFactory.new(:useless_proxy).create(:mock_proxy) }.must_raise StandardError
     end
   end
 end

data/test/omf_rc/util/common_tools_spec.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'omf_rc/util/common_tools'
+
+describe OmfRc::Util::CommonTools do
+  
+  describe "when included in the resource proxy" do
+    before do
+      module OmfRc::ResourceProxy::Test
+        include OmfRc::ResourceProxyDSL
+        register_proxy :test
+        utility :common_tools
+      end
+      # Mocking communicator
+      @client = Blather::Client.new
+      @stream = MiniTest::Mock.new
+      @stream.expect(:send, true, [Blather::Stanza])
+      @client.post_init @stream, Blather::JID.new('n@d/r')
+    end
+
+    it "must be able to log and inform error/warn messages" do
+      Blather::Client.stub :new, @client do
+        @test = OmfRc::ResourceFactory.new(:test)
+        @client.stub :write, true do
+          @test.log_inform_error "bob"
+          @test.log_inform_warn "bob"
+        end
+      end
+    end
+  end
+end

data/test/omf_rc/util/ip_spec.rb

@@ -0,0 +1,51 @@
+require 'minitest/mock'
+require 'test_helper'
+
+require 'omf_rc/util/ip'
+
+describe OmfRc::Util::Ip do
+  describe "when included in the resource instance" do
+    before do
+      module OmfRc::ResourceProxy::IpTest
+        include OmfRc::ResourceProxyDSL
+        register_proxy :ip_test
+        utility :ip
+      end
+
+      @wlan00 = OmfRc::ResourceFactory.new(:ip_test, hrn: 'wlan00')
+      @command = MiniTest::Mock.new
+    end
+
+    it "must provide features defined in proxy" do
+      %w(request_ip_addr request_mac_addr configure_ip_addr).each do |m|
+        OmfRc::Util::Ip.method_defined?(m).must_equal true
+      end
+    end
+
+    it "could request ip address of the device" do
+      Cocaine::CommandLine.stub(:new, @command) do
+        @command.expect(:run, fixture("ip/addr_show"))
+        @wlan00.request_ip_addr.must_equal "192.168.1.124/24"
+        @command.verify
+      end
+    end
+
+    it "could request mac address of the device" do
+      Cocaine::CommandLine.stub(:new, @command) do
+        @command.expect(:run, fixture("ip/addr_show"))
+        @wlan00.request_mac_addr.must_equal "00:00:00:29:00:00"
+        @command.verify
+      end
+    end
+
+    it "could configure the device's prorperty" do
+      lambda { @wlan00.configure_ip_addr("192.168.1.124/24") }.must_raise Cocaine::ExitStatusError
+      Cocaine::CommandLine.stub(:new, @command) do
+        @command.expect(:run, "")
+        @command.expect(:run, fixture("ip/addr_show"))
+        @wlan00.configure_ip_addr("192.168.1.124/24")
+        @command.verify
+      end
+    end
+  end
+end