squall 1.0.2 → 1.1.0

data/spec/squall/role_spec.rb

@@ -2,22 +2,14 @@ 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"
+      roles.all?{|r| r.first == "role"}
     end
   end
 
@@ -27,14 +19,13 @@ describe Squall::Role 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)
+    it "returns 404 for invalid id" do
+      expect { @role.show(404) }.to raise_error(Squall::NotFound)
     end
 
     it "returns a role" do
       role = @role.show(1)
-      role.keys.should include(*@keys)
-      role['label'].should == "Administrator"
+      role.should be_a(Hash)
     end
   end
 
@@ -44,21 +35,23 @@ describe Squall::Role 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)
+    it "returns 404 for invalid id" do
+      expect { @role.edit(404) }.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/)
+    it "allows all optional params" do
+      optional = [:label, :permission_ids]
+      optional.each do |param|
+        args = [:put, '/roles/1.json', @role.default_params(param => 1)]
+        @role.should_receive(:request).with(*args).once.and_return([])
+        @role.edit(1, param => 1 )
+      end
     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'
+        role = @role.edit(1, :label => 'New')
+        role['label'].should == 'New'
       end
     end
   end
@@ -81,43 +74,35 @@ describe Squall::Role do
 
   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
+      permissions.should be_an(Array)
+    end
+    
+    it "contains role data" do
+      permissions = @role.permissions
+      permissions.all?.should be_true
     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') }
+      requires_attr(:label) { @role.create }
     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")
+    
+    it "allows permission_ids" do
+      @role.should_receive(:request).once.and_return Hash.new('role' => [])
+      @role.create(:label => "test", :permission_ids => 1)
     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]
+      response = @role.create({:label => 'Test Create', :permission_ids => 1})
+      response["role"]['label'].should  == 'Test Create'
+      response["role"]['permissions'].should_not be_empty
     end
   end
 end

data/spec/squall/statistic_spec.rb

@@ -2,22 +2,20 @@ 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
+      result = @statistic.daily_stats
+      result.should be_an(Array)
+    end
+    
+    it "contains the statistic data" do
+      result = @statistic.daily_stats
+      result.all?.should be_true
     end
   end
 end

data/spec/squall/{base_spec.rb → support/base_spec.rb}

@@ -9,17 +9,16 @@ 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'
+      @base.class.base_uri.should_not be_nil
     end
 
     it "sets credentials" do
-      @base.class.default_options[:basic_auth].should include(:username => 'user', :password => 'pass')
+      @base.class.default_options[:basic_auth].should include(:username, :password)
     end
 
     it "uses JSON" do
@@ -34,11 +33,10 @@ describe Squall::Base do
   describe "#request" do
     it "200-207 returns success" do
       (200..207).each do |i|
-        mock_request(:get, "/#{i}", :status => [i, "OK"], :body => "Body is OK")
+        mock_request(:get, "/#{i}", :status => [i, "OK"], :body => "{\"something\":[\"OK\"]}")
         base = Squall::Base.new
         base.request(:get, "/#{i}")
         base.success.should be_true
-        base.result.should match(/OK/)
       end
     end
 
@@ -68,13 +66,13 @@ describe Squall::Base do
 
   describe "#errors" do
     it "is empty on success" do
-      mock_request(:get, '/200_errors', :status => [200, "OK"], :body => '"{\"something\":[\"OK\"]}"')
+      mock_request(:get, '/200_errors', :status => [200, "OK"], :body => "{\"something\":[\"errors\"]}")
       @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\"]}"')
+      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

data/spec/squall/template_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe Squall::Template do
   before(:each) do
-    default_config
     @template = Squall::Template.new
     @keys = ["label", "operating_system_distro", "operating_system_arch", "created_at", 
       "operating_system_tail", "operating_system", "updated_at", "operating_system_edition", 

data/spec/squall/transaction_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe Squall::Transaction do
   before(:each) do
-    default_config
     @transaction = Squall::Transaction.new
     @keys = ["pid", "created_at", "updated_at", "actor", "priority", 
       "parent_type", "action", "id", "user_id", "dependent_transaction_id", 

data/spec/squall/user_group_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Squall::UserGroup do
+  before(:each) do
+    @keys = ["amount"]
+    @user_group = Squall::UserGroup.new
+    @valid = {:label => "My new group"}
+  end
+
+  describe "#list" do
+    use_vcr_cassette "user_group/list"
+    
+    it "returns a list of user groups" do
+      user_groups = @user_group.list
+      user_groups.should be_an(Array)
+    end
+
+    it "contains first user group's data" do
+      user_group = @user_group.list.first
+      user_group.should be_a(Hash)
+    end
+  end
+  
+  describe "#create" do
+    use_vcr_cassette "user_group/create"
+    it "requires label" do
+      invalid = @valid.reject{|k,v| k == :label }
+      requires_attr(:label) { @user_group.create(invalid) }
+    end
+    
+    it "raises error on unknown params" do
+      expect { @user_group.create(@valid.merge(:what => 'what')) }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "creates a user group" do
+      @user_group.create(@valid)
+      @user_group.success.should be_true
+    end
+  end
+  
+  describe "#edit" do
+    use_vcr_cassette "user_group/edit"
+    
+    it "raises error on unknown params" do
+      expect { @user_group.edit(1, :what => 'what') }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "edits a user group" do
+      @user_group.edit(1, @valid)
+      @user_group.success.should be_true
+    end
+    
+    it "raises an error for an invalid user group id" do
+      expect { @user_group.edit(404, @valid) }.to raise_error(Squall::NotFound)
+    end
+  end
+  
+  describe "#delete" do
+    use_vcr_cassette "user_group/delete"
+    it "requires an id" do
+      expect { @user_group.delete }.to raise_error(ArgumentError)
+    end
+
+    it "deletes a user group" do
+      @user_group.delete(1)
+      @user_group.success.should be_true
+    end
+
+    it "returns NotFound for missing user" do
+      expect { @user_group.delete(404) }.to raise_error(Squall::NotFound)
+    end
+  end
+
+end

data/spec/squall/user_spec.rb

@@ -2,46 +2,83 @@ require 'spec_helper'
 
 describe Squall::User do
   before(:each) do
-    default_config
     @keys = ["total_amount", "activated_at", "created_at", "memory_available", "remember_token_expires_at",
             "used_disk_size", "deleted_at", "updated_at", "used_ip_addresses", "activation_code", "used_cpu_shares",
             "used_cpus", "group_id", "id", "used_memory", "payment_amount", "last_name", "remember_token",
             "disk_space_available", "time_zone", "outstanding_amount", "login", "roles", "email", "first_name"]
     @user = Squall::User.new
-    @valid = {:login => 'user', :email => 'me@example.com', :password => 'CD2480A3413F',
-              :first_name => 'John', :last_name => 'Doe', :group_id => 10 }
+    @valid = {:login => 'johndoe', :email => 'johndoe@example.com', :password => 'CD2480A3413F',
+              :password_confirmation => 'CD2480A3413F', :first_name => 'John', :last_name => 'Doe' }
   end
 
   describe "#create" do
     use_vcr_cassette "user/create"
     it "requires login" do
-      requires_attr(:login) { @user.create }
+      invalid = @valid.reject{|k,v| k == :login }
+      requires_attr(:login) { @user.create(invalid) }
     end
 
     it "requires email" do
-      requires_attr(:email) { @user.create(:login => @valid[:login]) }
+      invalid = @valid.reject{|k,v| k == :email }
+      requires_attr(:email) { @user.create(invalid) }
     end
 
     it "requires password" do
-      requires_attr(:password) {
-        @user.create(:login => @valid[:login], :email => @valid[:email])
-      }
+      invalid = @valid.reject{|k,v| k == :password }
+      requires_attr(:password) { @user.create(invalid) }
     end
-
-    it "raises error on duplicate account" do
-      expect {
-        @user.create(@valid.merge(:login => 'usertaken', :email => 'metaken@example.com'))
-      }.to raise_error(Squall::RequestError)
-      @user.errors['login'].should include("has already been taken")
-      @user.errors['email'].should include("has already been taken")
+    
+    it "requires password confirmation" do
+      invalid = @valid.reject{|k,v| k == :password_confirmation }
+      requires_attr(:password_confirmation) { @user.create(invalid) }
+    end
+    
+    it "requires first name" do
+      invalid = @valid.reject{|k,v| k == :first_name }
+      requires_attr(:first_name) { @user.create(invalid) }
+    end
+    
+    it "requires last name" do
+      invalid = @valid.reject{|k,v| k == :last_name }
+      requires_attr(:last_name) { @user.create(invalid) }
+    end
+    
+    it "allows all optional params" do
+      optional = [:role, :time_zone, :locale, :status, :billing_plan_id, :role_ids, :suspend_after_hours, :suspend_at]
+      @user.should_receive(:request).exactly(optional.size).times.and_return Hash.new("user" => {})
+      optional.each do |param|
+        @user.create(@valid.merge(param => "test"))
+      end
+    end
+    
+    it "raises error on unknown params" do
+      expect { @user.create(@valid.merge(:what => 'what')) }.to raise_error(ArgumentError, 'Unknown params: what')
     end
 
     it "creates a user" do
       user = @user.create(@valid)
-      user['email'].should      == @valid['email']
-      user['first_name'].should == @valid['first_name']
-      user['last_name'].should  == @valid['last_name']
-      user['group_id'].should   == @valid['group_id']
+      @user.success.should be_true
+    end
+  end
+  
+  describe "#edit" do
+    use_vcr_cassette "user/edit"
+    
+    it "allows select params" do
+      optional = [:email, :password, :password_confirmation, :first_name, :last_name, :user_group_id, :billing_plan_id, :role_ids, :suspend_at]
+      @user.should_receive(:request).exactly(optional.size).times.and_return Hash.new()
+      optional.each do |param|
+        @user.edit(1, param => "test")
+      end
+    end
+    
+    it "raises error on unknown params" do
+      expect { @user.edit(1, :what => 'what') }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "edits a user" do
+      user = @user.edit(1, :first_name => "Test")
+      @user.success.should be_true
     end
   end
 
@@ -49,13 +86,12 @@ describe Squall::User do
     use_vcr_cassette "user/list"
     it "returns a user list" do
       users = @user.list
-      users.size.should be(2)
+      users.should be_an(Array)
     end
 
     it "contains first users data" do
       user = @user.list.first
-      user.keys.should include(*@keys)
-      user['email'].should == "user@example.com"
+      user.should be_a(Hash)
     end
   end
 
@@ -66,12 +102,12 @@ describe Squall::User do
     end
 
     it "returns not found for invalid users" do
-      expect { @user.show(5) }.to raise_error(Squall::NotFound)
+      expect { @user.show(404) }.to raise_error(Squall::NotFound)
     end
 
     it "returns a user" do
       user = @user.show(1)
-      user['login'].should == 'user'
+      user.should be_a(Hash)
     end
   end
 
@@ -82,10 +118,8 @@ describe Squall::User do
     end
 
     it "generates a new key" do
-      pending "Broken in OnApp" do
-        user = @user.generate_api_key(1)
-        user['api_key'].should == '7d97e98f8af710c7e7fe703abc8f639e0ee507c4'
-      end
+      user = @user.generate_api_key(1)
+      user.should be_a(Hash)
     end
   end
 
@@ -96,7 +130,7 @@ describe Squall::User do
     end
 
     it "suspends a user" do
-      user = @user.suspend(2)
+      user = @user.suspend(1)
       user['status'].should == "suspended"
     end
   end
@@ -108,7 +142,7 @@ describe Squall::User do
     end
 
     it "activates a user" do
-      user = @user.activate(2)
+      user = @user.activate(1)
       user['status'].should == "active"
     end
 
@@ -123,13 +157,13 @@ describe Squall::User do
       expect { @user.delete }.to raise_error(ArgumentError)
     end
 
-    it "deltes a user" do
-      delete = @user.delete(6)
-      delete.should be_true
+    it "deletes a user" do
+      @user.delete(1)
+      @user.success.should be_true
     end
 
     it "returns NotFound for missing user" do
-      expect { @user.delete(22222) }.to raise_error(Squall::NotFound)
+      expect { @user.delete(404) }.to raise_error(Squall::NotFound)
     end
   end
 
@@ -141,10 +175,19 @@ describe Squall::User do
 
     it "returns stats" do
       stats = @user.stats(1)
-      stats['virtual_machine_id'].should == 55
-      keys = ["created_at", "cost", "updated_at", "stat_time", "id",
-        "user_id", "vm_billing_stat_id", "billing_stats", "virtual_machine_id"]
-      stats.keys.should include *keys
+      stats.should be_an(Array)
+    end
+  end
+  
+  describe "#monthly_bills" do
+    use_vcr_cassette "user/monthly_bills"
+    it "requires an id" do
+      expect { @user.monthly_bills }.to raise_error(ArgumentError)
+    end
+
+    it "returns an array of bills for the user" do
+      stats = @user.monthly_bills(1)
+      stats.should be_an(Array)
     end
   end
 
@@ -155,41 +198,81 @@ describe Squall::User do
     end
 
     it "404s on not found" do
-      pending "Broken in OnApp" do
-        expect { @user.virtual_machines(500) }.to raise_error(Squall::NotFound)
-      end
+      expect { @user.virtual_machines(404) }.to raise_error(Squall::NotFound)
     end
 
     it "returns the virtual_machines" do
       virtual_machines = @user.virtual_machines(1)
-      virtual_machines.size.should be(2)
-      keys = ["monthly_bandwidth_used", "cpus", "label", "created_at", "operating_system_distro", "cpu_shares",
-              "operating_system", "template_id", "allowed_swap", "local_remote_access_port", "memory", "updated_at",
-              "allow_resize_without_reboot", "recovery_mode", "hypervisor_id", "id", "xen_id", "user_id", "total_disk_size",
-              "booted", "hostname", "template_label", "identifier", "initial_root_password", "min_disk_size",
-              "remote_access_password", "built", "locked", "ip_addresses"]
-      virtual_machines.first.should include(*keys)
+      virtual_machines.should be_an(Array)
     end
   end
+  
+  describe "#hypervisors" do
+    use_vcr_cassette "user/hypervisors"
+    it "requires an id" do
+      expect { @user.hypervisors }.to raise_error(ArgumentError)
+    end
 
-  describe "#edit_role" do
-    use_vcr_cassette "user/edit_role"
+    it "404s on not found" do
+      expect { @user.hypervisors(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns the virtual_machines" do
+      hypervisors = @user.hypervisors(1)
+      hypervisors.should be_an(Array)
+    end
+  end
+  
+  describe "#data_store_zones" do
+    use_vcr_cassette "user/data_store_zones"
     it "requires an id" do
-      expect { @user.edit_role }.to raise_error(ArgumentError)
+      expect { @user.data_store_zones }.to raise_error(ArgumentError)
     end
 
     it "404s on not found" do
-      expect { @user.edit_role(500, nil) }.to raise_error(Squall::NotFound)
+      pending "Broken on OnApp: returns success despite non-existent user" do
+        expect { @user.data_store_zones(2532564353245) }.to raise_error(Squall::NotFound)
+      end
     end
 
-    it "edits one role for a user" do
-      @user.edit_role(7, 4)
-      @user.success.should be_true
+    it "returns the virtual_machines" do
+      data_store_zones = @user.data_store_zones(1)
+      data_store_zones.should be_an(Array)
     end
+  end
 
-    it "edits two roles for a user" do
-      @user.edit_role(7, 4, 2)
-      @user.success.should be_true
+  describe "#network_zones" do
+    use_vcr_cassette "user/network_zones"
+    it "requires an id" do
+      expect { @user.network_zones }.to raise_error(ArgumentError)
+    end
+
+    it "404s on not found" do
+      pending "Broken on OnApp: returns success despite non-existent user" do
+        expect { @user.network_zones(2532564353245) }.to raise_error(Squall::NotFound)
+      end
+    end
+
+    it "returns the network_zones" do
+      network_zones = @user.network_zones(1)
+      network_zones.should be_an(Array)
+    end
+  end
+
+  describe "#limits" do
+    use_vcr_cassette "user/limits"
+    it "requires an id" do
+      expect { @user.limits }.to raise_error(ArgumentError)
+    end
+
+    it "404s on not found" do
+      expect { @user.limits(438768534623) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns the limits" do
+      limits = @user.limits(1)
+      limits.should be_a(Hash)
     end
   end
-end
+  
+end