rubix 0.4.3 → 0.5.0

data/lib/rubix/models/user_macro.rb

@@ -5,25 +5,24 @@ module Rubix
     #
     # == Properties & Finding ==
     #
+
+    attr_reader :name
+    def set_name n, validate=true
+      return if n.nil? || n.empty?
+      raise ValidationError.new("Cannot change the name of a UserMacro once it's created.") if validate && @name && (!new_record?)
+      @name = n
+    end
     
-    attr_accessor :value
+    zabbix_attr :value, :required => true
     
     def initialize properties={}
       super(properties)
-      self.name  = properties[:name] || self.class.unmacro_name(properties[:macro])
-      @value = properties[:value]
-
+      set_name(properties[:name]  || self.class.unmacro_name(properties[:macro]), false)
+      
       self.host    = properties[:host]
       self.host_id = properties[:host_id]
     end
 
-    attr_reader :name
-    def name= n
-      return if n.nil? || n.empty?
-      raise ValidationError.new("Cannot change the name of a UserMacro once it's created.") if @name && (!new_record?)
-      @name = n
-    end
-
     def self.unmacro_name name
       (name || '').gsub(/^\{\$/, '').gsub(/\}$/, '').upcase
     end
@@ -50,15 +49,6 @@ module Rubix
     
     include Associations::BelongsToHost
 
-    #
-    # == Validation ==
-    #
-    
-    def validate
-      raise ValidationError.new("A user macro must have both a 'name' and a 'value'") if name.nil? || name.strip.empty? || value.nil? || value.strip.empty?
-      true
-    end
-    
     #
     # == Requests ==
     #

data/spec/requests/action_request_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "Actions" do
+
+  before do
+    integration_test
+    @user_group = ensure_save(Rubix::UserGroup.new(:name => 'rubix_spec_user_group_1'))
+    @user       = ensure_save(Rubix::User.new(:username => 'rubix_spec_user_1', :first_name => 'rubix', :last_name => 'user', :password => 'pass'))
+  end
+
+  after do
+    truncate_all_tables
+  end
+
+  describe "when not existing" do
+
+    it "returns nil on find" do
+      Rubix::Action.find(:name => 'rubix_spec_action_1').should be_nil
+    end
+
+    it "can be created" do
+      a = Rubix::Action.new(:name => 'rubix_spec_action_1', :operations => [{:user_group => @user_group}])
+      a.save.should be_true
+
+      na = Rubix::Action.find(:name => 'rubix_spec_action_1')
+      na.should_not be_nil
+      na.name.should == 'rubix_spec_action_1'
+      na.operations.size.should == 1
+    end
+
+  end
+
+  describe "when existing" do
+    before do
+      @action = ensure_save(Rubix::Action.new(:name => 'rubix_spec_action_1', :operations => [{:user_group => @user_group}]))
+    end
+
+    it "can be destroyed" do
+      @action.destroy
+      Rubix::Action.find(:name => 'rubix_spec_action_1').should be_nil
+    end
+
+  end
+  
+end

data/spec/requests/connection_request_spec.rb

@@ -15,7 +15,7 @@ describe Rubix::Connection do
     response.should_not be_nil
     response.code.to_i.should == 200
     response.body.should_not include('guest')
-    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+    response.body.should     include(Rubix::IntegrationHelper::INTEGRATION_USER)
   end
 
   it "can perform an authorized POST request to the homepage" do
@@ -23,7 +23,7 @@ describe Rubix::Connection do
     response.should_not be_nil
     response.code.to_i.should == 200
     response.body.should_not include('guest')
-    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+    response.body.should     include(Rubix::IntegrationHelper::INTEGRATION_USER)
   end
 
   it "can perform an authorized multipart POST request to the homepage" do
@@ -31,7 +31,7 @@ describe Rubix::Connection do
     response.should_not be_nil
     response.code.to_i.should == 200
     response.body.should_not include('guest')
-    response.body.should     include($RUBIX_INTEGRATION_TEST['username'])
+    response.body.should     include(Rubix::IntegrationHelper::INTEGRATION_USER)
   end
   
 end

data/spec/requests/media_type_request_spec.rb

@@ -13,11 +13,11 @@ describe "MediaTypes" do
   describe "when not existing" do
     
     it "returns nil on find" do
-      Rubix::MediaType.find(:description => 'rubix_spec_media_type_1').should be_nil
+      Rubix::MediaType.find(:name => 'rubix_spec_media_type_1').should be_nil
     end
 
     it "can be created" do
-      mt = Rubix::MediaType.new(:description => 'rubix_spec_media_type_1', :path => 'foo')
+      mt = Rubix::MediaType.new(:name => 'rubix_spec_media_type_1', :path => 'foo')
       mt.save.should be_true
     end
     
@@ -26,20 +26,20 @@ describe "MediaTypes" do
   describe "when existing" do
 
     before do
-      @mt = ensure_save(Rubix::MediaType.new(:description => 'rubix_spec_media_type_1', :path => 'foo'))
+      @mt = ensure_save(Rubix::MediaType.new(:name => 'rubix_spec_media_type_1', :path => 'foo'))
     end
     
     it "can be found" do
-      Rubix::MediaType.find(:description => 'rubix_spec_media_type_1').should_not be_nil
+      Rubix::MediaType.find(:name => 'rubix_spec_media_type_1').should_not be_nil
     end
 
     it "can have its properties changed" do
-      @mt.description = 'rubix_spec_media_type_2'
+      @mt.name = 'rubix_spec_media_type_2'
       @mt.type        = :sms
       @mt.modem       = '/foo/bar'
       @mt.save
-      Rubix::MediaType.find(:description => 'rubix_spec_media_type_1').should be_nil
-      new_mt = Rubix::MediaType.find(:description => 'rubix_spec_media_type_2')
+      Rubix::MediaType.find(:name => 'rubix_spec_media_type_1').should be_nil
+      new_mt = Rubix::MediaType.find(:name => 'rubix_spec_media_type_2')
       new_mt.should_not be_nil
       new_mt.type.should == :sms
       new_mt.modem.should == '/foo/bar'
@@ -47,7 +47,7 @@ describe "MediaTypes" do
 
     it "can be destroyed" do
       @mt.destroy
-      Rubix::MediaType.find(:description => 'rubix_spec_media_type_1').should be_nil
+      Rubix::MediaType.find(:name => 'rubix_spec_media_type_1').should be_nil
     end
   end
   

data/spec/requests/script_request_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe "Scripts" do
+
+  before do
+    integration_test
+  end
+
+  after do
+    truncate_all_tables
+  end
+
+  describe "when not existing" do
+    
+    it "returns nil on find" do
+      Rubix::Script.find(:name => 'rubix_spec_script_1').should be_nil
+    end
+
+    it "can be created" do
+      s = Rubix::Script.new(:name => 'rubix_spec_script_1', :command => 'foo')
+      s.save.should be_true
+    end
+    
+  end
+
+  describe "when existing" do
+
+    before do
+      @s = ensure_save(Rubix::Script.new(:name => 'rubix_spec_script_1', :command => 'foo'))
+    end
+    
+    it "can be found" do
+      Rubix::Script.find(:name => 'rubix_spec_script_1').should_not be_nil
+    end
+
+    it "can have its properties changed" do
+      @s.name    = 'rubix_spec_script_2'
+      @s.command = 'bar'
+      @s.access  = :write
+      @s.save
+      Rubix::Script.find(:name => 'rubix_spec_script_1').should be_nil
+      new_s = Rubix::Script.find(:name => 'rubix_spec_script_2')
+      new_s.should_not be_nil
+      new_s.command.should == 'bar'
+      new_s.access.should == :write
+    end
+
+    it "can be destroyed" do
+      @s.destroy
+      Rubix::Script.find(:name => 'rubix_spec_script_1').should be_nil
+    end
+  end
+  
+end

data/spec/requests/user_group_request_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "UserGroups" do
+
+  before do
+    integration_test
+  end
+
+  after do
+    truncate_all_tables
+  end
+
+  describe "when not existing" do
+    
+    it "returns nil on find" do
+      Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1').should be_nil
+    end
+
+    it "can be created" do
+      ug = Rubix::UserGroup.new(:name => 'rubix_spec_user_group_1')
+      ug.save.should be_true
+    end
+    
+  end
+
+  describe "when existing" do
+
+    before do
+      @ug = ensure_save(Rubix::UserGroup.new(:name => 'rubix_spec_user_group_1'))
+    end
+    
+    it "can be found" do
+      Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1').should_not be_nil
+    end
+
+    it "can have its name and settings changed" do
+      @ug.name       = 'rubix_spec_user_group_2'
+      @ug.banned     = true
+      @ug.api_access = true
+      @ug.debug_mode = true
+      @ug.gui_access = :disabled
+      @ug.save
+      Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1').should     be_nil
+      nug = Rubix::UserGroup.find(:name => 'rubix_spec_user_group_2')
+      nug.should_not be_nil
+      nug.name.should == 'rubix_spec_user_group_2'
+      nug.banned.should == true
+      nug.api_access.should == true
+      nug.gui_access.should == :disabled
+      nug.debug_mode.should == true
+    end
+
+    it "can be destroyed" do
+      @ug.destroy
+      Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1').should be_nil
+    end
+  end
+
+  describe "linking users to user groups" do
+
+    before do
+      @u1 = ensure_save(Rubix::User.new(:username => 'rubix_spec_user_1', :first_name => 'rubix1', :last_name => 'user1', :password => 'pass1'))
+      @u2 = ensure_save(Rubix::User.new(:username => 'rubix_spec_user_2', :first_name => 'rubix2', :last_name => 'user2', :password => 'pass2'))
+      @u3 = ensure_save(Rubix::User.new(:username => 'rubix_spec_user_3', :first_name => 'rubix3', :last_name => 'user3', :password => 'pass3'))
+    end
+
+    it "can add users on create" do
+      ug = Rubix::UserGroup.new(:name => 'rubix_spec_user_group_1', :users => [@u1, @u2, @u3])
+      ug.save
+      nug = Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1')
+      nug.users.map(&:username).should include(*[@u1, @u2, @u3].map(&:username))
+    end
+
+    describe "with existing users" do
+
+      before do
+        Rubix::UserGroup.new(:name => 'rubix_spec_user_group_1', :users => [@u1, @u2]).save
+        @ug = Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1')
+      end
+      
+      it "can will not mess with existing users if it doesn't need to" do
+        @ug.name = 'rubix_spec_user_group_2'
+        @ug.save
+        nug = Rubix::UserGroup.find(:name => 'rubix_spec_user_group_2')
+        nug.users.map(&:username).should include(*[@u1, @u2].map(&:username))
+      end
+
+      it "will replace users" do
+        @ug.users = [@u2, @u3]
+        @ug.save
+        nug = Rubix::UserGroup.find(:name => 'rubix_spec_user_group_1')
+        nug.users.map(&:username).should include(*[@u2, @u3].map(&:username))
+      end
+
+    end
+  end
+end

data/spec/requests/user_request_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe "Users" do
+
+  before do
+    integration_test
+  end
+
+  after do
+    truncate_all_tables
+  end
+
+  describe "when not existing" do
+    
+    it "returns nil on find" do
+      Rubix::User.find(:username => 'rubix_spec_user_1', :first_name => 'rubix1', :last_name => 'user1').should be_nil
+    end
+
+    it "can be created" do
+      hg = Rubix::User.new(:username => 'rubix_spec_user_1', :first_name => 'rubix1', :last_name => 'user1', :password => 'pass1')
+      hg.save.should be_true
+    end
+    
+  end
+
+  describe "when existing" do
+
+    before do
+      @u = ensure_save(Rubix::User.new(:username => 'rubix_spec_user_1', :first_name => 'rubix1', :last_name => 'user1', :password => 'pass1'))
+    end
+    
+    it "can be found" do
+      Rubix::User.find(:username => 'rubix_spec_user_1').should_not be_nil
+    end
+
+    it "can have its name and settings changed" do
+      @u.username   = 'rubix_spec_user_2'
+      @u.first_name = 'rubix2'
+      @u.last_name  = 'user2'
+      @u.url        = 'http://foobar.com'
+      @u.auto_login = true
+      @u.type       = :super_admin
+      @u.lang       = 'fo_ba'
+      @u.theme      = 'foo.css'
+      @u.refresh_period = 10
+      @u.rows_per_page = 10
+      @u.password   = 'pass2'
+      @u.save
+      Rubix::User.find(:username => 'rubix_spec_user_1').should be_nil
+      nu = Rubix::User.find(:username => 'rubix_spec_user_2')
+      nu.should_not be_nil
+      nu.username.should           == 'rubix_spec_user_2'
+      nu.first_name.should         == 'rubix2'
+      nu.last_name.should          == 'user2'
+      nu.url.should                == 'http://foobar.com'
+      nu.auto_login.should         == true
+      nu.type.should               == :super_admin
+      nu.lang.should               == 'fo_ba'
+      nu.theme.should              == 'foo.css'
+      nu.refresh_period.should     == 10
+      nu.rows_per_page.should      == 10
+    end
+
+    it "can be destroyed" do
+      @u.destroy
+      Rubix::User.find(:username => 'rubix_spec_user_1').should be_nil
+    end
+  end
+
+  describe "handling media" do
+
+    before do
+      @media_type   = ensure_save(Rubix::MediaType.new(:name => 'rubix_spec_media_type_1'))
+      @media_params = [{:media_type_id => @media_type.id, :address => "XXX"}]
+    end
+
+    it "can add media to a user when creating" do
+      Rubix::User.new(:username => 'rubix_spec_user_1', :first_name => 'rubix1', :last_name => 'user1', :password => 'pass1', :media => @media_params).save.should be_true
+      # FIXME no facility to fetch media!!
+    end
+
+    
+  end
+end

data/spec/support/integration_helper.rb

@@ -1,9 +1,108 @@
+require 'digest/md5'
+
 module Rubix
   module IntegrationHelper
 
+    INTEGRATION_USER     = 'rubix_spec_user'
+    INTEGRATION_GROUP    = 'rubix_spec_group'
+    INTEGRATION_PASSWORD = 'rubix'
+
+    # Parse the information we need to find the database and Zabbix
+    # server we're going to need for any integration tests.  Also set
+    # a global variable for easy use of this information when testing.
+    def self.setup_integration_tests test_yml_path
+      unless parse_integration_settings(test_yml_path)
+        puts "Could not parse integration settings in #{test_yml_path}.  Integration tests will be skipped."
+        return
+      end
+      unless connect_to_database
+        puts "Could not connect to a MySQL database using: #{$RUBIX_MYSQL_CREDENTIALS.inspect}.  Integration tests will be skipped."
+        return
+      end
+      unless truncate_all_tables
+        puts "Could not truncate tables.  Integration tests will be skipped."
+        return
+      end
+      unless create_integration_test_user_and_group
+        puts "Could not create integration test user #{INTEGRATION_USER} or group #{INTEGRATION_GROUP}.  Integration tests will be skipped."
+        return
+      end
+      unless connect_to_api
+        puts "Could not connect to Zabbix API using: #{$RUBIX_API_CREDENTIALS.inspect}.  Integration tests will be skipped."
+        return
+      end
+      $RUBIX_INTEGRATION = true
+    end
+      
+    def self.parse_integration_settings test_yml_path
+      return unless File.exist?(test_yml_path)
+      
+      require 'yaml'
+      test_data = YAML.load(open(test_yml_path))
+      return if test_data['disable_integration_tests']
+      
+      $RUBIX_API_CREDENTIALS   = test_data['api']
+      $RUBIX_MYSQL_CREDENTIALS = test_data['mysql']
+    end
+
+    def self.connect_to_database
+      begin
+        require 'mysql2'
+        $RUBIX_MYSQL = Mysql2::Client.new(:host => $RUBIX_MYSQL_CREDENTIALS['host'], :username => $RUBIX_MYSQL_CREDENTIALS['username'], :password => $RUBIX_MYSQL_CREDENTIALS['password'], :database => $RUBIX_MYSQL_CREDENTIALS['database'])
+      rescue => e
+        puts "Could not connect to MySQL database: #{e.class} -- #{e.message}"
+        puts e.backtrace
+        false
+      end
+    end
+
+    # These are the tables we'll truncate in the database.
+    RUBIX_TABLES_TO_TRUNCATE = %w[actions conditions operations opconditions opmediatypes applications groups hostmacro hosts hosts_groups hosts_profiles hosts_profiles_ext hosts_templates items items_applications profiles triggers trigger_depends history sessions media_type scripts users usrgrp users_groups]
+
+    def self.truncate_all_tables
+      return unless $RUBIX_MYSQL
+      begin
+        RUBIX_TABLES_TO_TRUNCATE.each { |table| $RUBIX_MYSQL.query("TRUNCATE TABLE #{table}") }
+        true
+      rescue => e
+        puts "Could not truncate tables in MySQL: #{e.class} -- #{e.message}"
+        puts e.backtrace
+        false
+      end
+    end
+
+    def self.create_integration_test_user_and_group
+      return unless $RUBIX_MYSQL
+      begin
+        $RUBIX_MYSQL.query(%Q{INSERT INTO users        (`alias`, `name`, surname, passwd, type) VALUES ("#{INTEGRATION_USER}", "Rubix", "Spec User", "#{Digest::MD5.hexdigest('rubix')}", 3)})
+        $RUBIX_MYSQL.query(%Q{INSERT INTO usrgrp       (`name`, api_access)                     VALUES ("#{INTEGRATION_GROUP}", 1)})
+        $RUBIX_MYSQL.query(%Q{INSERT INTO users_groups (usrgrpid, userid)                       SELECT users.userid, usrgrp.usrgrpid FROM users, usrgrp WHERE users.alias = '#{INTEGRATION_USER}' AND usrgrp.name = '#{INTEGRATION_GROUP}'})
+        true
+      rescue => e
+        puts "Could not create integraiton user or group: #{e.class} -- #{e.message}"
+        puts e.backtrace
+        false
+      end
+    end
+
+    def self.connect_to_api
+      return unless $RUBIX_API_CREDENTIALS
+      begin
+        $RUBIX_API = Rubix::Connection.new($RUBIX_API_CREDENTIALS['url'], INTEGRATION_USER, INTEGRATION_PASSWORD)
+        $RUBIX_API.authorize!
+        Rubix.connection = $RUBIX_API
+      rescue => e
+        puts "Could not connect to Zabbix API: #{e.class} -- #{e.message}"
+        puts e.backtrace
+        false
+      end
+    end
+
     def integration_test
-      if $RUBIX_INTEGRATION_TEST
-        Rubix.connect($RUBIX_INTEGRATION_TEST['url'], $RUBIX_INTEGRATION_TEST['username'], $RUBIX_INTEGRATION_TEST['password'])
+      if $RUBIX_INTEGRATION
+        raise Rubix::Error.new("Could not truncate tables in MySQL.")         unless IntegrationHelper.truncate_all_tables
+        raise Rubix::Error.new("Could not create integration user or group.") unless IntegrationHelper.create_integration_test_user_and_group
+        raise Rubix::Error.new("Could not connect to Zabbixi API.")           unless IntegrationHelper.connect_to_api
       else
         pending("A live Zabbix API to test against")
       end
@@ -11,7 +110,7 @@ module Rubix
 
     def ensure_save(obj)
       begin
-        raise Rubix::Error.new(Rubix.connection.last_response.error_message) unless obj.save
+        raise Rubix::Error.new(Rubix.connection.last_response.body) unless obj.save
         obj
       rescue => e
         puts "#{e.class} -- #{e.message}"
@@ -27,7 +126,7 @@ module Rubix
         else
           errors = []
           objs.each do |obj|
-            errors << Rubix.connection.last_response.error_message unless obj.destroy
+            errors << Rubix.connection.last_response.body unless obj.destroy
           end
           raise Rubix::Error.new(errors.join("\n")) if errors.size > 0
         end
@@ -48,41 +147,14 @@ module Rubix
     end
     
     def create_history item
+      raise Rubix::Error.new("Not connected to MySQL") unless $RUBIX_MYSQL
       (1..10).to_a.collect do |i|
         history = { "itemid" => item.id.to_s, "clock" => (Time.now.to_i - 5*i).to_s, "value" => rand(100).to_s }
-        $RUBIX_MYSQL_CLIENT.query("INSERT INTO history_uint (#{history.keys.join(', ')}) VALUES (#{history.values.join(', ')})")
+        $RUBIX_MYSQL.query("INSERT INTO history_uint (#{history.keys.join(', ')}) VALUES (#{history.values.join(', ')})")
         history
       end
     end
 
-    def self.setup_integration_tests test_yml_path
-      return unless File.exist?(test_yml_path)
-      
-      require 'yaml'
-      test_data = YAML.load(open(test_yml_path))
-      return if test_data['disable_integration_tests']
-      
-      api_connection = test_data['api']
-      mysql_connection = test_data['mysql']
-      return unless api_connection && mysql_connection
-
-      Rubix.connect(api_connection['url'], api_connection['username'], api_connection['password'])
-      
-      require 'mysql2'
-      $RUBIX_MYSQL_CLIENT = Mysql2::Client.new(:host => mysql_connection['host'], :username => mysql_connection['username'], :password => mysql_connection['password'], :database => mysql_connection['database'])
-
-      truncate_all_tables
-
-      $RUBIX_INTEGRATION_TEST = api_connection
-    end
-
-    RUBIX_TABLES_TO_TRUNCATE = %w[applications groups hostmacro hosts hosts_groups hosts_profiles hosts_profiles_ext hosts_templates items items_applications profiles triggers trigger_depends history sessions media_type]
-    
-    def self.truncate_all_tables
-      return unless $RUBIX_INTEGRATION_TEST
-      RUBIX_TABLES_TO_TRUNCATE.each { |table| $RUBIX_MYSQL_CLIENT.query("TRUNCATE TABLE #{table}") }
-    end
-
     def truncate_all_tables
       IntegrationHelper.truncate_all_tables
     end