solusvm 0.10.1 → 1.0.0.beta

data/test/cli/test_client_cli.rb

@@ -0,0 +1,80 @@
+require 'helper'
+require 'solusvm/cli'
+
+class TestClientCli < Test::Unit::TestCase
+
+  def setup
+    # Prevents mocha from stubbing non existent methods so that we now if the CLI is failing because
+    # something was moved around.
+    Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  end
+
+  def test_should_delegate_client_create_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:create).with() do |options|
+      expected = {
+        :username => "theusername",
+        :password => "thepassword",
+        :email => "theemail",
+        :firstname => "thefirstname",
+        :lastname => "thelastname",
+        :company => "thecompany"
+      }
+
+      expected.all? { |k,v| options[k] == v }
+
+      end.returns("theresult") 
+    })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments([
+      "client", "create", 
+      "--username", "theusername",
+      "--password", "thepassword",
+      "--email", "theemail",
+      "--firstname", "thefirstname",
+      "--lastname", "thelastname",
+      "--company", "thecompany"
+    ]))
+  end
+
+  def test_should_delegate_client_change_password_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:change_password).with("theusername", "thepassword").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["client", "change-password", "theusername", "thepassword"]))
+  end
+
+  def test_should_delegate_client_authenticate_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:authenticate).with("theusername", "thepassword").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["client", "authenticate", "theusername", "thepassword"]))
+  end
+
+  def test_should_delegate_client_check_exists_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:exists?).with("theusername").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["client", "check-exists", "theusername"]))
+  end
+
+  def test_should_delegate_client_delete_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:delete).with("theusername").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["client", "delete", "theusername"]))
+  end
+
+  def test_should_delegate_client_list_to_client
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Client.stubs(:new => mock{ expects(:list).returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["client", "list"]))
+  end
+end

data/test/cli/test_general_cli.rb

@@ -0,0 +1,35 @@
+require 'helper'
+require 'solusvm/cli'
+
+class TestGeneralCli < Test::Unit::TestCase
+
+  def setup
+    # Prevents mocha from stubbing non existent methods so that we now if the CLI is failing because
+    # something was moved around.
+    Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  end
+
+  def test_should_delegate_templates_to_general
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::General.stubs(:new => mock{ expects(:templates).with("type").returns("thetemplates")})
+
+    $stdout.expects(:puts).with("thetemplates")
+    Solusvm::Cli.start(cli_expand_base_arguments(["general", "templates", "type"]))
+  end
+
+  def test_should_delegate_plans_to_general
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::General.stubs(:new => mock{ expects(:plans).with("type").returns("theplans")})
+
+    $stdout.expects(:puts).with("theplans")
+    Solusvm::Cli.start(cli_expand_base_arguments(["general", "plans", "type"]))
+  end
+
+  def test_should_delegate_isos_to_general
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::General.stubs(:new => mock{ expects(:isos).with("type").returns("theisos")})
+
+    $stdout.expects(:puts).with("theisos")
+    Solusvm::Cli.start(cli_expand_base_arguments(["general", "isos", "type"]))
+  end
+end

data/test/cli/test_node_cli.rb

@@ -0,0 +1,64 @@
+require 'helper'
+require 'solusvm/cli'
+
+class TestNodeCli < Test::Unit::TestCase
+
+  def setup
+    # Prevents mocha from stubbing non existent methods so that we now if the CLI is failing because
+    # something was moved around.
+    Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  end
+
+  def test_should_delegate_node_available_ips_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:available_ips).with("thevserverid").returns(["ip1", "ip2"]) })
+
+    $stdout.expects(:puts).with("ip1\nip2")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "available-ips", "thevserverid"]))
+  end
+
+  def test_should_delegate_node_stats_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:statistics).with("thevserverid").returns({
+      :stat1 => "val1", :stat2 => "val2"
+    })})
+
+    $stdout.expects(:puts).with("stat1 => val1\nstat2 => val2")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "stats", "thevserverid"]))
+  end
+
+  def test_should_delegate_node_xenresources_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:xenresources).with("thevserverid").returns({
+      :stat1 => "val1", :stat2 => "val2"
+    })})
+
+    $stdout.expects(:puts).with("stat1 => val1\nstat2 => val2")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "xenresources", "thevserverid"]))
+  end
+
+  def test_should_delegate_node_virtualservers_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:virtualservers).with("thevserverid").returns("thedata")})
+
+    $stdout.expects(:puts).with("thedata")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "virtualservers", "thevserverid"]))
+  end
+
+  def test_should_delegate_nodes_list_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:list).with("type").returns("thenodes")})
+
+    $stdout.expects(:puts).with("thenodes")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "list", "type"]))
+  end
+
+  def test_should_delegate_nodes_ids_to_node
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Node.stubs(:new => mock{ expects(:ids).with("type").returns("thenodes")})
+
+    $stdout.expects(:puts).with("thenodes")
+    Solusvm::Cli.start(cli_expand_base_arguments(["node", "list-ids", "type"]))
+  end
+
+end

data/test/cli/test_reseller_cli.rb

@@ -0,0 +1,139 @@
+require 'helper'
+require 'solusvm/cli'
+
+class TestResellerCli < Test::Unit::TestCase
+
+  def setup
+    # Prevents mocha from stubbing non existent methods so that we now if the CLI is failing because
+    # something was moved around.
+    Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  end
+
+  def test_should_delegate_reseller_create_to_reseller
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Reseller.stubs(:new => mock{ expects(:create).with() do |options|
+      expected = {
+        :username => "theusername",
+        :password => "thepassword",
+        :email => "theemail",
+        :firstname => "thefirstname",
+        :lastname => "thelastname",
+        :company => "thecompany",
+        :usernameprefix => "theusernameprefix",
+        :maxvps => "themaxvps",
+        :maxusers => "themaxusers",
+        :maxmem => "themaxmem",
+        :maxburst => "themaxburst",
+        :maxdisk => "themaxdisk",
+        :maxbw => "themaxbw",
+        :maxipv4 => "themaxipv4",
+        :maxipv6 => "themaxipv6",
+        :nodegroups => "thenodegroups",
+        :mediagroups => "themediagroups",
+        :openvz => "theopenvz",
+        :xenpv => "thexenpv",
+        :xenhvm => "thexenhvm",
+        :kvm => "thekvm"
+      }
+
+      expected.all? { |k,v| options[k] == v }
+
+      end.returns("theresult") 
+    })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments([
+      "reseller", "create", 
+      "--username", "theusername",
+      "--password", "thepassword",
+      "--email", "theemail",
+      "--firstname", "thefirstname",
+      "--lastname", "thelastname",
+      "--company", "thecompany",
+      "--usernameprefix", "theusernameprefix",
+      "--maxvps", "themaxvps",
+      "--maxusers", "themaxusers",
+      "--maxmem", "themaxmem",
+      "--maxburst", "themaxburst",
+      "--maxdisk", "themaxdisk",
+      "--maxbw", "themaxbw",
+      "--maxipv4", "themaxipv4",
+      "--maxipv6", "themaxipv6",
+      "--nodegroups", "thenodegroups",
+      "--mediagroups", "themediagroups",
+      "--openvz", "theopenvz",
+      "--xenpv", "thexenpv",
+      "--xenhvm", "thexenhvm",
+      "--kvm", "thekvm"
+    ]))
+  end
+
+  def test_should_delegate_reseller_change_resources_to_reseller
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Reseller.stubs(:new => mock{ expects(:change_resources).with() do |options|
+      expected = {
+        :maxvps => "themaxvps",
+        :maxusers => "themaxusers",
+        :maxmem => "themaxmem",
+        :maxburst => "themaxburst",
+        :maxdisk => "themaxdisk",
+        :maxbw => "themaxbw",
+        :maxipv4 => "themaxipv4",
+        :maxipv6 => "themaxipv6",
+        :nodegroups => "thenodegroups",
+        :mediagroups => "themediagroups",
+        :openvz => "theopenvz",
+        :xenpv => "thexenpv",
+        :xenhvm => "thexenhvm",
+        :kvm => "thekvm"
+      }
+
+      expected.all? { |k,v| options[k] == v }
+
+      end.returns("theresult") 
+    })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments([
+      "reseller", "change-resources", 
+      "--maxvps", "themaxvps",
+      "--maxusers", "themaxusers",
+      "--maxmem", "themaxmem",
+      "--maxburst", "themaxburst",
+      "--maxdisk", "themaxdisk",
+      "--maxbw", "themaxbw",
+      "--maxipv4", "themaxipv4",
+      "--maxipv6", "themaxipv6",
+      "--nodegroups", "thenodegroups",
+      "--mediagroups", "themediagroups",
+      "--openvz", "theopenvz",
+      "--xenpv", "thexenpv",
+      "--xenhvm", "thexenhvm",
+      "--kvm", "thekvm"
+    ]))
+  end
+
+  def test_should_delegate_reseller_info_to_reseller
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Reseller.stubs(:new => mock{ expects(:info).with("theusername").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["reseller", "info", "theusername"]))
+  end
+
+  def test_should_delegate_reseller_delete_to_reseller
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Reseller.stubs(:new => mock{ expects(:delete).with("theusername").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["reseller", "delete", "theusername"]))
+  end
+
+  def test_should_delegate_reseller_list_to_reseller
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Reseller.stubs(:new => mock{ expects(:list).returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["reseller", "list"]))
+  end  
+end

data/test/cli/test_server_cli.rb

@@ -0,0 +1,267 @@
+require 'helper'
+require 'solusvm/cli'
+
+class TestServerCli < Test::Unit::TestCase
+
+  def setup
+    # Prevents mocha from stubbing non existent methods so that we now if the CLI is failing because
+    # something was moved around.
+    Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  end
+
+  def test_should_delegate_server_status_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:status).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "status", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_change_plan_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_plan).with("thevserverid", "thenewplan").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-plan", "thevserverid", "thenewplan"]))
+  end
+
+  def test_should_delegate_server_change_owner_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_owner).with("thevserverid", "thenewowner").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-owner", "thevserverid", "thenewowner"]))
+  end
+
+  def test_should_delegate_server_change_consolepass_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_consolepass).with("thevserverid", "thenewpass").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-consolepass", "thevserverid", "thenewpass"]))
+  end
+
+  def test_should_delegate_server_change_vncpass_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_vncpass).with("thevserverid", "thenewpass").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-vncpass", "thevserverid", "thenewpass"]))
+  end
+
+  def test_should_delegate_server_change_rootpass_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_rootpassword).with("thevserverid", "thenewpass").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-rootpass", "thevserverid", "thenewpass"]))
+  end
+
+  def test_should_delegate_server_change_bootorder_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_bootorder).with("thevserverid", "theneworder").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-bootorder", "thevserverid", "theneworder"]))
+  end
+
+  def test_should_delegate_server_change_hostname_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:change_hostname).with("thevserverid", "thenewhostname").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "change-hostname", "thevserverid", "thenewhostname"]))
+  end
+
+  def test_should_delegate_server_add_ip_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:add_ip).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "addip", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_boot_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:boot).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "boot", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_reboot_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:reboot).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "reboot", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_shutdown_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:shutdown).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "shutdown", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_suspend_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:suspend).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "suspend", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_resume_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:resume).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "resume", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_check_exists_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:check_exists).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "check-exists", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_terminate_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:terminate).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "terminate", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_rebuild_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:rebuild).with(
+      "thevserverid", :template => "thetemplate").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "rebuild", "thevserverid", "--template", "thetemplate"]))
+  end
+
+  def test_should_delegate_server_tun_switcher_on_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:tun_enable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "tun-switcher", "thevserverid", "on"]))
+  end
+
+  def test_should_delegate_server_tun_switcher_off_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:tun_disable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "tun-switcher", "thevserverid", "off"]))
+  end
+
+  def test_should_delegate_server_network_switcher_on_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:network_enable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "network-switcher", "thevserverid", "on"]))
+  end
+
+  def test_should_delegate_server_network_switcher_off_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:network_disable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "network-switcher", "thevserverid", "off"]))
+  end
+
+  def test_should_delegate_server_pae_switcher_on_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:pae_enable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "pae-switcher", "thevserverid", "on"]))
+  end
+
+  def test_should_delegate_server_pae_switcher_off_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:pae_disable).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "pae-switcher", "thevserverid", "off"]))
+  end
+
+  def test_should_delegate_server_info_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:info).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "info", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_vnc_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:vnc).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "vnc", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_console_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:console).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "console", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_info_all_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:info_all).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "info-all", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_mountiso_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:mountiso).with("thevserverid", "theiso").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "mountiso", "thevserverid", "theiso"]))
+  end
+
+  def test_should_delegate_server_unmountiso_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:unmountiso).with("thevserverid").returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments(["server", "unmountiso", "thevserverid"]))
+  end
+
+  def test_should_delegate_server_create_to_server
+    Solusvm.expects(:config).with("thelogin", "thekey", { :url => "theurl" })
+    Solusvm::Server.stubs(:new => mock{ expects(:create).with(
+      "thehostname", "thepassword", 
+      :plan => "theplan", :ips => "theips", :type => "thekind", 
+      :username => "theusername", :template => "thetemplate", :node => "thenode"
+    ).returns("theresult") })
+
+    $stdout.expects(:puts).with("theresult")
+    Solusvm::Cli.start(cli_expand_base_arguments([
+      "server", "create", 
+      "thehostname", 
+      "thepassword", 
+      "--plan", "theplan",
+      "--ips", "theips",
+      "--kind", "thekind",
+      "--username", "theusername",
+      "--template", "thetemplate",
+      "--node", "thenode"
+    ]))
+  end
+
+end

data/test/fixtures/client_delete_success.txt

@@ -0,0 +1,2 @@
+<status>success</status>
+<statusmsg>Client deleted</statusmsg>

data/test/fixtures/client_list_success.txt

@@ -0,0 +1,14 @@
+<clients>
+  <client>
+    <id>1</id> 
+    <username>vps123</username> 
+    <email>vps123@email.com</email> 
+    <firstname>phill</firstname> 
+    <lastname>smith</lastname> 
+    <company>VPS Co</company> 
+    <level>Client</level> 
+    <status>Active</status> 
+    <created>2009-01-01</created> 
+    <lastlogin>2010-04-23</lastlogin> 
+  </client>
+</clients>

data/test/fixtures/client_list_success_empty.txt

@@ -0,0 +1,2 @@
+<clients>
+</clients>

data/test/fixtures/general_isos_success.txt

@@ -0,0 +1,3 @@
+<status>success</status>
+<statusmsg></statusmsg>
+<iso>iso1,iso2,iso3</iso>

data/test/fixtures/general_node_virtualservers_success.txt

@@ -0,0 +1,15 @@
+<virtualservers>
+    <virtualserver>                              
+        <vserverid>theid</vserverid>
+        <ctid-xid>thexid</ctid-xid>
+        <clientid>theclientid</clientid>
+        <ipaddress>theip</ipaddress>
+        <hostname>thehostname</hostname>
+        <template>thetemplate</template>
+        <hdd>thediskspace</hdd>
+        <memory>thememory</memory>
+        <swap-burst>theswap</swap-burst>
+        <type>thetype</type>
+        <mac>themac</mac>
+    </virtualserver>
+</virtualservers> 

data/test/fixtures/general_node_virtualservers_success_empty.txt

@@ -0,0 +1,2 @@
+<virtualservers>
+</virtualservers> 

data/test/fixtures/general_node_xenresources_success.txt

@@ -0,0 +1,4 @@
+<status>success</status>
+<statusmsg></statusmsg>
+<freememory>thefreememory</freememory>
+<freehdd>thefreehdd</freehdd>

data/test/fixtures/general_nodes_ids_success.txt

@@ -0,0 +1,3 @@
+<status>success</status>
+<statusmsg></statusmsg>
+<nodes>nodeid1,nodeid2,nodeid3,nodeid4</nodes>

data/test/fixtures/general_plans_success.txt

@@ -0,0 +1,3 @@
+<status>success</status>
+<statusmsg></statusmsg>
+<plans>plan1,plan2,plan3,plan4</plans>