squall 0.0.3 → 1.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+require 'rspec'
+require 'vcr'
+require 'squall'
+
+VCR.config do |c|
+  c.cassette_library_dir = 'spec/vcr_cassettes'
+  c.stub_with :fakeweb
+  c.default_cassette_options = {:record => :new_episodes}
+end
+
+RSpec.configure do |c|
+  c.extend VCR::RSpec::Macros
+  c.after(:each) do
+    Squall.reset_config
+  end
+end
+
+def default_config
+  yaml = File.join(ENV['HOME'], '.squall.yml')
+  if ENV['SQUALL_LIVE'] && File.exists?(yaml)
+    config = YAML::load_file(yaml)
+    uri  = config['base_uri']
+    user = config['username']
+    pass = config['password']
+  else
+    uri  = 'http://www.example.com'
+    user = 'user'
+    pass = 'pass'
+  end
+  Squall.config do |c|
+    c.base_uri uri
+    c.username user
+    c.password pass
+  end
+end
+
+def requires_attr(attr, &block)
+  expect { block.call }.to raise_error(ArgumentError, /Missing required params: #{attr}/i)
+end
+
+def mock_request(meth, path, options = {})
+  config = Squall.config
+  uri    = URI.parse(Squall.config[:base_uri])
+  url    = "#{uri.scheme}://#{config[:username]}:#{config[:password]}@#{uri.host}:#{uri.port}#{path}"
+  FakeWeb.register_uri(meth, url, {:content_type => 'application/json'}.merge(options))
+end

data/spec/squall/base_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+class CamelTest < Squall::Base;end;
+class Nocamel < Squall::Base;end;
+module Subclass
+  class Test < Squall::Base;end;
+  class CamelTest < Squall::Base;end;
+end
+
+describe Squall::Base do
+  before(:each) do
+    default_config
+    @base = Squall::Base.new
+  end
+
+  describe "#initialize" do
+    it "sets the base_uri" do
+      @base.class.base_uri.should == 'http://www.example.com'
+    end
+
+    it "sets credentials" do
+      @base.class.default_options[:basic_auth].should include(:username => 'user', :password => 'pass')
+    end
+
+    it "uses JSON" do
+      @base.class.default_options[:format].should == :json
+    end
+
+    it "sets JSON headers" do
+      @base.class.default_options[:headers].should include('Content-Type' => 'application/json')
+    end
+  end
+
+  describe "#request" do
+    it "200-207 returns success" do
+      (200..207).each do |i|
+        mock_request(:get, "/#{i}", :status => [i, "OK"])
+        base = Squall::Base.new
+        base.request(:get, "/#{i}")
+        base.success.should be_true
+      end
+    end
+
+    it "raises NotFound for 404s" do
+      mock_request(:get, '/404', :status => [404, "NotFound"])
+      expect { @base.request(:get, '/404') }.to raise_error(Squall::NotFound)
+      @base.success.should be_false
+    end
+
+    it "raises ServerError on errors" do
+      mock_request(:get, '/500', :status => [500, "Internal Server Error"])
+      expect { @base.request(:get, '/500') }.to raise_error(Squall::ServerError)
+      @base.success.should be_false
+    end
+
+    it "raises RequestError on errors" do
+      mock_request(:get, '/422', :status => [422, "Unprocessable"])
+      expect { @base.request(:get, '/422') }.to raise_error(Squall::RequestError)
+      @base.success.should be_false
+    end
+
+    it "is a sad panda when the config hasn't been specified" do
+      Squall.reset_config
+      expect { @base.request(:get, '/money') }.to raise_error(Squall::NoConfig, "Squall.config must be specified")
+    end
+  end
+
+  describe "#errors" do
+    it "is empty on success" do
+      mock_request(:get, '/200_errors', :status => [200, "OK"], :body => '"{\"something\":[\"OK\"]}"')
+      @base.request(:get, '/200_errors')
+      @base.errors.should be_empty
+    end
+
+    it "returns an error hash" do
+      mock_request(:get, '/500_errors', :status => [500, "Internal Server Error"], :body => '"{\"something\":[\"errors\"]}"')
+      expect { @base.request(:get, '/500_errors') }.to raise_error(Squall::ServerError)
+      @base.errors.should_not be_empty
+    end
+  end
+
+  describe "#params" do
+    it "returns Params.new" do
+      @base.params.should be_a(Squall::Params)
+    end
+  end
+
+  describe "#default_params" do
+    it "sets the default options" do
+      @base.default_params.should == {}
+    end
+
+    it "merges the query in" do
+      expected = {
+        :query => { 
+          :base => {:one => 1, :two => 2}
+        }
+      }
+      @base.default_params(:one => 1, :two => 2).should include(expected)
+    end
+
+    it "uses the subclass name as the key" do
+      base_test = CamelTest.new
+      base_test.default_params.should == {}
+      expected = {
+        :query => { 
+          :camel_test => {:one => 1, :two => 2}
+        }
+      }
+      base_test.default_params(:one => 1, :two => 2).should include(expected)
+    end
+  end
+
+  describe "#key_for_class" do
+    it "converts CamelTest to :camel_test" do
+      camel_test = CamelTest.new
+      camel_test.key_for_class.should == :camel_test
+    end
+
+    it "converts Nocamel to :nocamel" do
+      nocamel = Nocamel.new
+      nocamel.key_for_class.should == :nocamel
+    end
+
+    it "converts Subclass::Test to :test" do
+      sub_class = Subclass::Test.new
+      sub_class.key_for_class.should == :test
+    end 
+
+    it "converts Subclass::CamelTest to :camel_test" do
+      camel_test = Subclass::CamelTest.new
+      camel_test.key_for_class.should == :camel_test
+    end 
+  end
+end

data/spec/squall/config_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Squall::Config do
+  before(:each) do
+    @config = Squall::Config.new
+  end
+
+  describe "#new" do
+    it "sets up the @config hash" do
+      @config.config.should == {}
+    end
+  end
+
+  describe "#[]" do
+    it "behaves like an array" do
+      @config.config[:something] = 1
+      @config[:something].should == 1
+    end
+  end
+
+  describe "#base_uri" do
+    it "sets the base_uri" do
+      @config.config[:base_uri].should be_nil
+      @config.base_uri 'url'
+      @config.config[:base_uri].should == 'url'     
+    end
+  end
+
+  describe "#username" do
+    it "sets the username" do
+      @config.config[:username].should be_nil     
+      @config.username 'user'
+      @config.config[:username].should == 'user'      
+    end
+  end
+
+  describe "#password" do
+    it "sets the password" do
+      @config.config[:password].should be_nil           
+      @config.password 'pass'
+      @config.config[:password].should == 'pass'
+    end
+  end
+end

data/spec/squall/hypervisor_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Squall::Hypervisor do
+  before(:each) do
+    default_config
+    @hv = Squall::Hypervisor.new
+  end
+
+  describe "#list" do
+    use_vcr_cassette 'hypervisor/list'
+    it "returns hypervisors" do
+      hvs = @hv.list
+      hvs.size.should be(2)
+
+      keys = ["label", "called_in_at", "spare", "created_at", "hypervisor_type",
+              "updated_at", "xen_info", "id", "hypervisor_group_id", "enabled", "health",
+              "failure_count", "memory_overhead", "online", "locked", "ip_address"]
+      first = hvs.first
+      first.keys.should include(*keys)
+      first['label'].should == 'Testing'
+      first['hypervisor_type'].should == 'xen'
+    end
+  end
+
+  describe "#show" do
+    use_vcr_cassette "hypervisor/show"
+    it "requires an id" do
+      expect { @hv.show }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid hvs" do
+      expect { @hv.show(5) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns a hv" do
+      hv = @hv.show(1)
+      hv['label'].should == 'Testing'
+    end
+  end
+
+  describe "#create" do
+    use_vcr_cassette "hypervisor/create"
+    it "requires label" do
+      requires_attr(:label) { @hv.create }
+      @hv.success.should be_false
+    end
+
+    it "requires ip_address" do
+      requires_attr(:ip_address) { @hv.create(:label => 'Brand New') }
+      @hv.success.should be_false
+    end
+
+    it "requires hypervisor_type" do
+      requires_attr(:hypervisor_type) { @hv.create(:label => 'Brand New', :ip_address => '222.222.222.222') }
+      @hv.success.should be_false
+    end
+
+    # The API allows you to commit this value but subsequent
+    # saves do not work because of this missing value.
+    it "requires memory_overhead" do
+      pending "Broken in OnApp"
+      requires_attr(:memory_overhead) { @hv.create(:label => 'Brand New', :ip_address => '222.222.222.222', :hypervisor_type => 'xen') }
+    end
+
+    it "raises error on duplicate account" do
+      expect {
+        @hv.create(:label => 'Testing', :ip_address => '123.123.123.123', :hypervisor_type => 'xen')
+      }.to raise_error(Squall::RequestError)
+      @hv.errors['label'].should include("has already been taken")
+      @hv.errors['ip_address'].should include("has already been taken")
+      @hv.success.should be_false
+    end
+
+    it "creates a hypervisor" do
+      create = @hv.create(:label => 'Brand new', :ip_address => '126.126.126.126', :hypervisor_type => 'xen')
+      @hv.success.should be_true
+
+      create['label'].should == 'Brand new'
+      create['ip_address'].should == '126.126.126.126'
+      create['hypervisor_type'].should == 'xen'
+    end
+  end
+
+  describe "#edit" do
+    use_vcr_cassette 'hypervisor/edit'
+    it "requires an id" do
+      expect { @hv.edit }.to raise_error(ArgumentError)
+      @hv.success.should be_false
+    end
+
+    it "raises an error with unknown param " do
+      expect { @hv.edit(3, :blah => 1)}.to raise_error(ArgumentError)
+      @hv.success.should be_false
+    end
+
+    it "edits the label" do
+      edit = @hv.edit(3, :label => 'Old Gregg')
+      @hv.success.should be_true
+    end
+
+    it "edits the ip_address" do
+      edit = @hv.edit(3, :ip_address => '120.120.120.120')
+      @hv.success.should be_true
+    end
+  end
+
+  describe "#reboot" do
+    use_vcr_cassette 'hypervisor/reboot'
+    it "requires an id" do
+      expect { @hv.reboot }.to raise_error(ArgumentError)
+      @hv.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @hv.reboot(404) }.to raise_error(Squall::NotFound)
+      @hv.success.should be_false
+    end
+
+    it "reboots the hypervisor" do
+      reboot = @hv.reboot(1)
+      @hv.success.should be_true
+
+      reboot['label'].should == 'Testing'
+    end
+  end
+
+  describe "#delete" do
+    use_vcr_cassette "hypervisor/delete"
+    it "requires an id" do
+      expect { @hv.delete }.to raise_error(ArgumentError)
+    end
+
+    it "404s on not found" do
+      expect { @hv.delete(404) }.to raise_error(Squall::NotFound)
+      @hv.success.should be_false
+    end
+
+    it "returns a hv" do
+      @hv.delete(3)
+      @hv.success.should be_true
+    end
+  end
+end

data/spec/squall/ip_address_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Squall::IpAddress do
+  before(:each) do
+    default_config
+    @ip = Squall::IpAddress.new
+    @keys = ["netmask", "disallowed_primary", "address", "created_at", "updated_at", "network_id", 
+    "network_address", "broadcast", "id", "gateway"]
+  end
+
+  describe "#list" do
+    use_vcr_cassette 'ipaddress/list'
+
+    it "requires network_id" do
+      expect { @ip.list }.to raise_error(ArgumentError)
+    end
+
+    it "404s on invalid network" do
+      expect { @ip.list(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns ip_addresses" do
+      ips = @ip.list(1)
+      ips.size.should be(2)
+
+      first = ips.first
+      first.keys.should include(*@keys)
+      first['netmask'].should == '255.255.255.0'
+      first['address'].should == '127.2.2.2'
+    end
+  end
+end

data/spec/squall/network_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Squall::Network do
+  before(:each) do
+    default_config
+    @network = Squall::Network.new
+    @keys = ["label", "created_at", "updated_at", "network_group_id", "vlan", "id", "identifier"]
+  end
+
+  describe "#list" do
+    use_vcr_cassette "network/list"
+    it "returns a network list" do
+      networks = @network.list
+      networks.size.should be(2)
+    end
+
+    it "contains first networks data" do
+      network = @network.list.first
+      network.keys.should include(*@keys)
+      network['label'].should == 'Test'
+    end
+  end
+
+  describe "#edit" do
+    use_vcr_cassette 'network/edit'
+    it "requires an id" do
+      expect { @network.edit }.to raise_error(ArgumentError)
+      @network.success.should be_false
+    end
+
+    it "errors on invalid params" do
+      expect { @network.edit(1, :what => 1) }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "accepts valid params" do
+      @network.edit(1, :label => 'one')
+      @network.success.should be_true
+
+      @network.edit(1, :network_group_id => 1)
+      @network.success.should be_true
+
+      @network.edit(1, :identifier => 'lolzsdfds')
+      @network.success.should be_true
+
+      @network.edit(1, :vlan => 1)
+      @network.success.should be_true
+
+      @network.edit(1, :label => 'two', :vlan => 2, :identifier => 'woah')
+      @network.success.should be_true
+    end
+
+    it "404s on not found" do
+      expect { @network.edit(404) }.to raise_error(Squall::NotFound)
+      @network.success.should be_false
+    end
+  end
+
+  describe "#create" do
+    use_vcr_cassette "network/create"
+    it "requires label" do
+      requires_attr(:label) { @network.create }
+    end
+
+    it "raises error on duplicate account" do
+      pending "Broken in OnApp" do
+        expect { 
+          @network.create(:label => 'networktaken')
+        }.to raise_error(Squall::RequestError)
+        @network.errors['label'].should include("has already been taken")
+      end
+    end
+
+    it "raises error on invalid params" do
+      expect { 
+        @network.create(:what => 'networktaken', :label => 'wut')
+      }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "creates a network" do
+      network = @network.create(:label => 'newnetwork', :vlan => 1, :identifier => 'newnetworkid')
+      @network.success.should be_true
+
+      network['label'].should == 'newnetwork'
+      network['vlan'].should == 1
+      network['identifier'].should == 'newnetworkid'
+
+      network = @network.create(:label => 'newnetwork')
+      network['label'].should == 'newnetwork'
+      network['vlan'].should be_nil
+      @network.success.should be_true
+
+      network = @network.create(:label => 'newnetwork', :vlan => 2)
+      network['label'].should == 'newnetwork'
+      network['vlan'].should == 2
+      @network.success.should be_true
+
+      network = @network.create(:label => 'newnetwork', :identifier => 'something')
+      network['label'].should == 'newnetwork'
+      network['identifier'].should == 'something'
+      @network.success.should be_true
+    end
+  end
+
+  describe "#delete" do
+    use_vcr_cassette 'network/delete'
+    it "requires an id" do
+      expect { @network.delete }.to raise_error(ArgumentError)
+      @network.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @network.delete(404) }.to raise_error(Squall::NotFound)
+      @network.success.should be_false
+    end
+
+    it "deletes the network" do
+      delete = @network.delete(16)
+      @network.success.should be_true
+    end
+  end
+end

data/spec/squall/role_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Squall::Role do
+  before(:each) do
+    default_config
+    @role = Squall::Role.new
+    @keys = ["label", "created_at", "updated_at", "id", "permissions", "identifier"]
+  end
+
+  describe "#list" do
+    use_vcr_cassette "role/list"
+    it "returns roles" do
+      roles = @role.list
+      roles.size.should be(2)
+    end
+
+    it "contains the role of a user" do
+      role = @role.list.first
+      role.keys.should include(*@keys)
+      role['label'].should == "Administrator"
+    end
+  end
+
+  describe "#show" do
+    use_vcr_cassette "role/show"
+    it "requires an id" do
+      expect { @role.show }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid user" do
+      expect { @role.show(5) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns a role" do
+      role = @role.show(1)
+      role.keys.should include(*@keys)
+      role['label'].should == "Administrator"
+    end
+  end
+
+  describe "#edit" do
+    use_vcr_cassette "role/edit"
+    it "requires an id" do
+      expect { @role.edit }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid user" do
+      expect { @role.edit(5) }.to raise_error(Squall::NotFound)
+    end
+
+    it "allows :label and/or :permission" do
+      expect { @role.edit(3, :missing => 1) }.to raise_error(ArgumentError, /Unknown.*missing/)
+    end
+
+    it "updates the role" do
+      pending "OnApp is returning an empty response" do
+        old_role = @role.show(3)
+        old_role['label'].should == "Other"
+
+        new_role = @role.edit(3, :label => 'New')
+        new_role['label'].should == 'New'
+      end
+    end
+  end
+
+  describe "#delete" do
+    use_vcr_cassette "role/delete"
+    it "requires an id" do
+      expect { @role.delete }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid user" do
+      expect { @role.delete(5) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns a role" do
+      role = @role.delete(3)
+      @role.success.should be_true
+    end
+  end
+
+  describe "#permissions" do
+    use_vcr_cassette "role/permissions"
+    it "returns permissions" do
+      permissions = @role.permissions
+      permissions.size.should be(229)
+
+      keys = ["label", "created_at", "updated_at", "id", "identifier"]
+      first = permissions.first
+      first.keys.should include(*keys)
+
+      keys.each do |key| 
+        first[key].should_not be_nil
+        first[key].to_s.size.should be >= 1
+      end
+    end
+  end
+
+  describe "#create" do
+    use_vcr_cassette "role/create"
+    it "requires login" do
+      requires_attr(:label) { @role.create }
+    end
+
+    it "requires label" do
+      requires_attr(:identifier) { @role.create(:label => 'my-label') }
+    end
+
+    it "raises error on duplicate" do
+      expect { 
+        @role.create(:label => 'Test', :identifier => 'testing')
+      }.to raise_error(Squall::RequestError)
+      @role.errors['identifier'].should include("has already been taken")
+    end
+
+    it "creates a role" do
+      value = {:label => 'Test Create', :identifier => 'testing-create'}
+      role = @role.create(value)
+      role['label'].should  == value[:label]
+      role['identifier'].should == value[:identifier]
+    end
+  end
+end

data/spec/squall/statistic_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Squall::Statistic do
+  before(:each) do
+    default_config
+    @statistic = Squall::Statistic.new
+  end
+
+  describe "#usage_statistic" do
+    use_vcr_cassette "statistic/usage_statistics"
+
+    it "requires an id" do
+      expect { @statistic.daily_stats }.to raise_error(ArgumentError)
+      @statistic.success.should be_false
+    end
+
+    it "returns the daily statistics" do
+      result = @statistic.daily_stats(1)
+      result['id'].to_i.should == 1
+      result['cost'].to_f.should == 0.0
+    end
+  end
+end