rubicante 0.0.3 → 0.0.4

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.0.4 / 200-04-10
+
+* More gem manifest fixes
+
 === 0.0.3 / 2009-04-10
 
 * Fix broken gem

data/Manifest.txt

@@ -8,3 +8,20 @@ lib/os_functions.rb
 lib/rubicante.rb
 lib/rubicante/cli.rb
 lib/rubicante/environment.rb
+lib/rubicante/host.rb
+lib/rubicante/host_error.rb
+lib/rubicante/host_group.rb
+lib/rubicante/type.rb
+lib/rubicante/type_group.rb
+lib/rubicante/website.rb
+lib/rubicante/website_error.rb
+spec/environment_spec.rb
+spec/helper.rb
+spec/host_error_spec.rb
+spec/host_group_spec.rb
+spec/host_spec.rb
+spec/type_group_spec.rb
+spec/type_spec.rb
+spec/website_error_spec.rb
+spec/website_spec.rb
+test/test_rubicante.rb

data/lib/rubicante.rb

@@ -2,5 +2,5 @@
 #require 'rubicante/type_group'
 
 class Rubicante
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/rubicante/host.rb

@@ -0,0 +1,183 @@
+require 'rubicante/website'
+require 'rubicante/host_error'
+
+require 'logging'
+require 'ping'
+require 'socket'
+
+require 'os_functions'
+include OsFunctions
+require 'win32ole' if is_windows?
+
+module Rubicante
+  class Host
+    include OsFunctions
+
+    attr_reader :name
+    attr_accessor :ports, :services, :types, :websites
+
+    def initialize(name)
+      @name     = name
+      @ports    = []
+      @services = []
+      @types    = []
+      @websites = []
+
+      @log = Logging::Logger[self]
+
+      # Prepare Website logger
+      @appender = Logging::Appender['rubicante']
+      Logging::Logger['Rubicante::Website'].add_appenders(Logging::Appender['rubicante']) if not @appender.nil?
+      Logging::Logger['Rubicante::Website'].level = @log.level
+    end
+
+    def ping
+      @log.debug "Performing TCP echo ping on host '#{@name}'"
+      Ping.pingecho @name
+    end
+
+    def port(port_number)
+      @ports << port_number
+      self
+    end
+
+    def service(service_name)
+      @services << service_name
+      self
+    end
+
+    def type(type_name)
+      @types << type_name
+      self
+    end
+
+    def website(website_url)
+      @websites << Website.new(website_url)
+      self
+    end
+
+    # Check if the specified port is active by connecting to it
+    def check_port(port)
+      port_output = "#{@name}:#{port}"
+
+      @log.debug "Checking port #{port_output}..."
+
+      begin
+        test = TCPSocket.open(@name, port)
+        @log.debug "Port #{port_output} looks good"
+        return true # if we get here, the socket opened
+      rescue
+        @log.debug "Port #{port_output} raised an exception when opening"
+        return false  # if we get here, there are problems with the port
+      end
+    end
+
+    # Iterates through all the ports in the Host and runs check_port(port)
+    # against them.
+    #
+    # == Yields: port, is_alive
+    #
+    # Each registered port is yielded along with the boolean result from
+    # check_port(port).
+    #
+    # == Example:
+    #
+    #   host = Rubicante::Host.new("test-host")
+    #   host.port(80)
+    #   host.port(443)
+    #
+    #   host.check_ports do |port, response|
+    #     puts "Port #{port} is UP" if response
+    #     puts "Port #{port} is DOWN" if not response
+    #   end
+    def check_ports
+      @ports.each do |port|
+        yield port, check_port(port)
+      end
+    end
+
+    # Iterates through all the websites in the Host and runs
+    # wrong? against them looking for problems.  If a problem is
+    # found, a Hash of the URL and the HTTP Status code is yielded.
+    #
+    # == Yields: a Hash
+    #
+    #   {
+    #     :url    => String,  # the URL of the current website in the block
+    #     :code   => String   # the HTTP Status code of the check (i.e., 404, 500, etc.)
+    #   }
+    #
+    # == Example
+    #
+    #   host = Rubicante::Host.new("test-host")
+    #   host.website('www.exmaple.com')
+    #   host.website('www.rubicante.com')
+    #   host.website('www.openbsd.org')
+    #
+    #   host.check_websites do |result|
+    #     puts "Website #{result[:url]} failed with code #{result[:code]}!"
+    #   end
+    def check_websites
+      @log.debug "Checking websites registered to host '#{@name}'"
+      @websites.each do |website|
+        yield website.wrong?
+      end
+    end
+
+    def wrong?
+      @log.debug "Determing what is wrong with host '#{@name}'"
+      result = HostError.new(@name)
+      result.ping = self.ping
+
+      # If the host is alive, continue testing
+      if result.ping
+        check_ports do |port, response|
+          result.bad_ports << port if not response
+        end
+
+        check_websites do |website_error|
+          result.add(website_error)
+        end
+
+        if is_windows?
+          check_services do |service, response|
+            result.bad_services << service if not response
+          end
+        end
+      end
+
+      return result
+    end
+
+    ###
+    # Windows-specific functions
+    ###
+    if is_windows?
+      def get_wmi
+        WIN32OLE.connect("winmgmts://#{@name}")
+      end
+
+      # Checks the host to see if the specified service is running
+      def is_running?(service)
+        query = "SELECT Name, State FROM Win32_Service WHERE Name='#{service}'"
+
+        result = false
+        service_label = "#{@name}->#{service}"
+
+        @log.debug "Checking services #{service_label}..."
+        get_wmi.ExecQuery(query).each do |result|
+          @log.debug "#{service_label}.State == #{result.State}"
+          result = true if result.State = 'Running'
+        end
+
+        return result
+      end
+
+      def check_services
+        @services.each do |service|
+          yield service, is_running?(service)
+        end
+      end
+    end
+  end
+end

data/lib/rubicante/host_error.rb

@@ -0,0 +1,22 @@
+require 'rubicante/website_error'
+
+module Rubicante
+  class HostError
+    attr_reader :hostname, :website_errors
+    attr_accessor :bad_ports, :bad_services, :ping
+
+    def initialize(hostname)
+      @hostname = hostname
+      @ping = false
+      @bad_ports      = []
+      @bad_services   = []
+      @website_errors = []
+    end
+
+    def add(error)
+      if error.kind_of? WebsiteError
+        @website_errors << error
+      end
+    end
+  end
+end

data/lib/rubicante/host_group.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+require 'rubicante/host'
+
+module Rubicante
+  class HostGroup
+    include Singleton
+
+    attr_reader :hosts
+
+    def initialize
+      @hosts = {}
+    end
+
+    def [](hostname)
+      @hosts[hostname] ||= Host.new(hostname)
+    end
+  end
+end

data/lib/rubicante/type.rb

@@ -0,0 +1,20 @@
+module Rubicante
+  class Type
+    attr_reader :name
+    attr_accessor :ports, :services
+
+    def initialize(name)
+      @name     = name
+      @ports    = []
+      @services = []
+    end
+
+    def port(new_port)
+      @ports << new_port
+    end
+
+    def service(new_service)
+      @services << new_service
+    end
+  end
+end

data/lib/rubicante/type_group.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+require 'rubicante/type'
+
+module Rubicante
+  class TypeGroup
+    include Singleton
+
+    attr_accessor :types
+
+    def initialize
+      @types  = {}
+    end
+
+    def [](type_name)
+      @types[type_name] ||= Type.new(type_name)
+    end
+  end
+end

data/lib/rubicante/website.rb

@@ -0,0 +1,54 @@
+require 'rubicante/website_error'
+
+require 'logging'
+require 'net/http'
+
+module Rubicante
+  class Website
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+
+      @log = Logging::Logger[self]
+    end
+
+    # Determines whether or not the site OK based on the HTTP Status code
+    #
+    # == DETERMINING IF A SITE IS OK
+    #
+    # When performing an HTTP GET on the root, if a 2xx (HTTP OK) or
+    # 3xx (HTTP Redirect) response is received, the method considers the
+    # site to be workinging nominally and returns *true*
+    #
+    # However, if a 4xx (HTTP Client Error) or 5xx (HTTP Server Error)
+    # response is received, the method considers the site to be working
+    # abnormally and returns *false*
+    def is_ok?
+      result = false
+
+      result = true if response_code.match(/^(2|3)/)
+
+      return result
+    end
+
+    # Performs and HTTP GET on the URL's root ('/') and returns the
+    # HTTP Status code
+    def response_code
+      @log.debug "Retreiving HTTP Code for website '#{@url}'"
+      result = Net::HTTP.get_response(@url, '/').code
+      @log.debug "Received HTTP Code #{result} for website '#{@url}'"
+
+      return result
+    end
+
+    # Checks to see if the site is OK.  If it is not, it returns
+    # a Rubicante::WebsiteError
+    def wrong?
+      @log.debug "Checking website '#{@url}' for problems"
+      if not self.is_ok?
+        WebsiteError.new(@url, self.response_code)
+      end
+    end
+  end
+end

data/lib/rubicante/website_error.rb

@@ -0,0 +1,10 @@
+module Rubicante
+  class WebsiteError
+    attr_reader :code, :url
+
+    def initialize(url, code)
+      @url  = url
+      @code = code
+    end
+  end
+end

data/spec/environment_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/environment" 
+
+describe "A Rubicante environment" do
+  before :all do
+    Net::HTTP.stub!(:get_response).and_return(Net::HTTPServerError.new('1', '500', 'Internal Server Error'))
+  end
+
+  before :each do
+    @env = Rubicante::Environment.new
+  end
+
+  it "should exist" do
+    @env.should_not be_nil
+    @env.should be_an_instance_of(Rubicante::Environment)
+  end
+
+  it "should have a HostGroup" do
+    @env.host.should be_an_instance_of(Rubicante::HostGroup)
+  end
+
+  it "should have an empty HostGroup by default" do
+    @env.host.hosts.should == {}
+  end
+
+  it "should have a wrong? method" do
+    @env.respond_to?('wrong?').should == true
+  end
+
+  it "should return an array of HostErrors" do
+    @env.wrong? do |result|
+      result.should be_an_instance_of(Array)
+      result[0].should be_an_instance_of(Rubicante::HostError)
+    end
+  end
+
+  it "should have an eval_host method" do
+    @env.respond_to?('eval_host').should == true
+  end
+
+  it "should handle 'Host webservice provides website ...'" do
+    hostname = 'webservice'
+    url = 'www.rubicante-example.com'
+    cmd = "Host #{hostname} provides website #{url}"
+    @env.eval_host(cmd)
+    @env.host[hostname].websites[0].url.should == url
+  end
+
+  it "should handle specifying multiple websites" do
+    hostname = 'www2'
+    url0 = 'test1'
+    url1 = 'test2'
+    cmd = "Host #{hostname} provides website #{url0}, provides website #{url1}"
+    @env.eval_host(cmd)
+    @env.host[hostname].websites[0].url.should == url0
+    @env.host[hostname].websites[1].url.should == url1
+  end
+
+  it "should have an eval_command method" do
+    @env.respond_to?('eval_command').should == true
+  end
+
+  it "should raise a NotImplementedError for unknown commands" do
+    lambda { @env.eval_command('whumpus frumpus') }.should raise_error(NotImplementedError)
+  end
+
+  it "should handle 'host' commands" do
+    lambda { @env.eval_command('host frank') }.should_not raise_error(NotImplementedError)
+  end
+
+  it "should have an eval_what method" do
+    @env.respond_to?('eval_what').should == true
+  end
+
+  it "should handle 'what' commands" do
+    lambda { @env.eval_command('What is wrong') }.should_not raise_error(NotImplementedError)
+  end
+
+  after :each do
+    # Clean up the HostGroup instance's hash so that other specs will
+    # run properly
+    @env.host.hosts.clear
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,3 @@
+require "spec" 
+
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)), *%w[.. lib rubicante])

data/spec/host_error_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/host_error" 
+
+describe "An error with a host" do
+  before :all do
+    @url = "http://www.rubicante-example.com/"
+    @code = "500"
+    @website_error = Rubicante::WebsiteError.new(@url, @code)
+  end
+
+  before :each do
+    @host_error = Rubicante::HostError.new("test-host")
+  end
+
+  it "should exist" do
+    @host_error.should_not be_nil
+    @host_error.should be_an_instance_of(Rubicante::HostError)
+  end
+
+  it "should require an argument at initialization" do
+    lambda { Rubicante::HostError.new }.should raise_error(ArgumentError)
+  end
+
+  it "should now allow changing of hostname after initialization" do
+    lambda { @host_error.hostname = "new-host-name" }.should raise_error(NoMethodError)
+  end
+
+  it "should have an empty array of website errors" do
+    @host_error.website_errors.should == []
+  end
+
+  it "should allow adding of new website errors with add" do
+    @host_error.add(@website_error)
+    @host_error.website_errors.include?(@website_error).should == true
+  end
+
+  it "should have an ping value" do
+    @host_error.respond_to?('ping').should == true
+  end
+
+  it "ping should be false by default" do
+    @host_error.ping.should == false
+  end
+
+  it "should allow changin the ping value" do
+    @new_ping = true
+    @host_error.ping.should_not == @new_ping
+    @host_error.ping = @new_ping
+    @host_error.ping.should == @new_ping
+  end
+
+  it "should have an empty array of bad_ports by default" do
+    @host_error.bad_ports.should == []
+  end
+
+  it "should allow appending to bad_ports" do
+    new_bad_port = 80
+    @host_error.bad_ports << new_bad_port
+    @host_error.bad_ports.include?(new_bad_port).should == true
+  end
+
+  it "should have an empty array of bad_services by default" do
+    @host_error.bad_services.should == []
+  end
+
+  it "should allow appending to bad_services" do
+    new_bad_service = 'W32Time'
+    @host_error.bad_services << new_bad_service
+    @host_error.bad_services.include?(new_bad_service).should == true
+  end
+end

data/spec/host_group_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/host_group" 
+
+describe "A group of hosts" do
+  before :each do
+    @host_group = Rubicante::HostGroup.instance
+  end
+
+  it "should exist" do
+    @host_group.should_not be_nil
+    @host_group.should be_an_instance_of(Rubicante::HostGroup)
+  end
+
+  it "should have an empty hash of hosts by default" do
+    @host_group.hosts.should == {}
+  end
+
+  it "should create a new host in hosts if it doesn't exist" do
+    hostname = "new-host"
+    @host_group[hostname].name.should == hostname
+  end
+
+  it "should allow for modifying previously defined hosts" do
+    hostname    = "new-host"
+    new_port    = 80
+    new_service = "new-service"
+
+    @host_group[hostname].port(new_port).service(new_service)
+
+    @host_group[hostname].ports.include?(new_port).should == true
+    @host_group[hostname].services.include?(new_service).should == true
+  end
+end

data/spec/host_spec.rb

@@ -0,0 +1,159 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/host" 
+
+describe "A newtork host" do
+  before :each do
+    @host_name = "spec-host"
+    @host = Rubicante::Host.new(@host_name)
+
+    @host_with_sites = Rubicante::Host.new(@host_name)
+    @sites = [
+      'www.rubicante-good-site.com',
+      'www.rubicante-bad-site.com',
+      'www.rubicante-worse-site.com',
+      'www.rubicante-redirect.com'
+    ]
+    @sites.each do |site|
+      @host_with_sites.website(site)
+    end
+
+    @host_with_ports = Rubicante::Host.new(@host_name)
+    @ports = [80, 22, 443]
+    @ports.each do |port|
+      @host_with_ports.port(port)
+    end
+
+    Net::HTTP.stub!(:get_response).and_return(Net::HTTPServerError.new('1', '500', 'Internal Server Error'))
+    Ping.stub!(:pingecho).and_return(true)
+  end
+
+  it "should exist" do
+    @host.should_not be_nil
+    @host.should be_an_instance_of(Rubicante::Host)
+  end
+
+  it "should require a name parameter for initialization" do
+    lambda { Host.new.should raise_error(ArgumentError) }
+  end
+
+  it "should have an empty array of ports by default" do
+    @host.ports.should == []
+  end
+
+  it "should allow adding more ports with port()" do
+    port = 12345
+    @host.port(port)
+    @host.ports.include?(port).should == true
+  end
+
+  it "should return self for port()" do
+    @host.port(12345).should be_an_instance_of(Rubicante::Host)
+  end
+
+  it "should have an empty array of services by default" do
+    @host.services.should == []
+  end
+
+  it "should allow adding more services with service()" do
+    service = "W32Time"
+    @host.service(service)
+    @host.services.include?(service).should == true
+  end
+
+  it "should return self for service()" do
+    @host.service("test").should be_an_instance_of(Rubicante::Host)
+  end
+
+  it "should have an empty array of types" do
+    @host.types.should == []
+  end
+
+  it "should allow adding more types with type()" do
+    type = "SQL Server"
+    @host.type(type)
+    @host.types.include?(type).should == true
+  end
+
+  it "should return self for type()" do
+    @host.type("testing").should be_an_instance_of(Rubicante::Host)
+  end
+
+  it "should have an empty array of websites by default" do
+    @host.websites.should == []
+  end
+
+  it "should allow adding more webistes with site()" do
+    url = "http://www.example.com/"
+    @host.website(url)
+    @host.websites.size.should == 1
+  end
+
+  it "should return self for site()" do
+    @host.website("http://www.example.com/").should be_an_instance_of(Rubicante::Host)
+  end
+
+  it "should check all websites" do
+    @host_with_sites.check_websites do |result|
+      @sites.include?(result.url).should == true
+    end
+  end
+
+  it "should return a HostError for wrong?" do
+    @host.wrong?.should be_an_instance_of(Rubicante::HostError)
+  end
+
+  it "should return website errors with the HostError" do
+    host_error = @host.wrong?
+
+    host_error.website_errors.should_not be_nil
+    host_error.website_errors.each do |website_error|
+      website_error.should be_an_instance_of(Rubicante::WebsiteError)
+      @sites.include?(website_error.url).should == true
+    end
+  end
+
+  it "should support pinging" do
+    @host.respond_to?('ping').should == true
+  end
+
+  it "should update HostError.ping to true for alive hosts" do
+    host_error = @host.wrong?
+    host_error.ping.should == true
+  end
+
+  it "should update HostError.ping to false for down hosts" do
+    Ping.stub!(:pingecho).and_return(false)
+    host_error = @host.wrong?
+    host_error.ping.should == false
+  end
+
+  it "should skip website processing for downed hosts" do
+    Ping.stub!(:pingecho).and_return(false)
+    host_error = @host_with_sites.wrong?
+    host_error.ping.should == false
+    host_error.website_errors.should == []
+  end
+
+  it "should check a specified port" do
+    @host.respond_to?('check_port').should == true
+    TCPSocket.stub!(:open).and_return(true)
+    @host.check_port(80).should == true
+    TCPSocket.stub!(:open).and_raise(ArgumentError)
+    @host.check_port(443).should == false
+  end
+
+  it "should check all registered ports" do
+    TCPSocket.stub!(:open).and_raise(ArgumentError)
+    @host_with_ports.check_ports do |port, is_alive|
+      @ports.include?(port).should == true
+    end
+  end
+
+  it "should update HostError.bad_ports for all down ports" do
+    TCPSocket.stub!(:open).and_raise(ArgumentError)
+    host_error = @host_with_ports.wrong?
+    host_error.bad_ports.each do |bad_port|
+      @ports.include?(bad_port).should == true
+    end
+  end
+end

data/spec/type_group_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/type_group" 
+
+describe "A group of server types" do
+  before :each do
+    @type_group = Rubicante::TypeGroup.instance
+  end
+
+  it "should exist" do
+    @type_group.should_not be_nil
+    @type_group.should be_an_instance_of(Rubicante::TypeGroup)
+  end
+
+  it "should have an empty hash of types by default" do
+    @type_group.types.should == {}
+  end
+
+  it "should create a new type in types if it doesn't exist" do
+    type_name = "new-type"
+    @type_group[type_name].name.should == type_name
+  end
+
+  it "should allow for modifying previously defined types" do
+    type_name   = "new-type"
+    new_port    = 80
+    new_service = "new-service"
+    @type_group[type_name]
+
+    @type_group[type_name].port(new_port)
+    @type_group[type_name].ports.include?(new_port).should == true
+
+    @type_group[type_name].service(new_service)
+    @type_group[type_name].services.include?(new_service).should == true
+  end
+end

data/spec/type_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/type" 
+
+describe "A server type" do
+  before :each do
+    @type_name = "spec-type"
+    @type = Rubicante::Type.new(@type_name)
+  end
+
+  it "should exist" do
+    @type.should_not be_nil
+    @type.should be_an_instance_of(Rubicante::Type)
+  end
+
+  it "should require a name when initializing" do
+    lambda { @new_type = Rubicante::Type.new }.should raise_error(ArgumentError)
+  end
+
+  it "should have a name" do
+    @type.name.should == @type_name
+  end
+
+  it "should have an empty array of ports by default" do
+    @type.ports.should == []
+  end
+
+  it "should have an empty array of services by default" do
+    @type.services.should == []
+  end
+
+  it "should allow appending of ports" do
+    new_port = 80
+    @type.port(new_port)
+    @type.ports.include?(new_port).should == true
+  end
+
+  it "should allow appending of services" do
+    new_service = "W32Time"
+    @type.service(new_service)
+    @type.services.include?(new_service).should == true
+  end
+end

data/spec/website_error_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/website_error" 
+
+describe "An error with a website" do
+  before :each do
+    @url = "http://www.rubicante-example.com/"
+    @code = "500"
+    @website_error = Rubicante::WebsiteError.new(@url, @code)
+  end
+
+  it "should exist" do
+    @website_error.should_not be_nil
+    @website_error.should be_an_instance_of(Rubicante::WebsiteError)
+  end
+
+  it "should require parameters to be created" do
+    lambda { Rubicante::WebsiteError.new }.should raise_error(ArgumentError)
+  end
+
+  it "should have a URL" do
+    @website_error.url.should == @url
+  end
+
+  it "should have an HTTP code" do
+    @website_error.code.should == @code
+  end
+
+  it "should not allow modification to the URL" do
+    lambda { @website_error.url = "http://www.rubyforge-example.org/" }.should raise_error(NoMethodError)
+  end
+
+  it "should not allow modification to the HTTP code" do
+    lambda { @website_error.code = "301" }.should raise_error(NoMethodError)
+  end
+end

data/spec/website_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),"helper")
+require "#{LIB_DIR}/website" 
+
+describe "A website" do
+  before :each do
+    @url = 'http://www.rubicante-test.com/'
+    @website = Rubicante::Website.new(@url)
+
+    @http_ok           = Net::HTTPOK.new('1', '200', 'OK')
+    @http_redirect     = Net::HTTPMovedPermanently.new('1', '301', 'Moved Permanently')
+    @http_client_error = Net::HTTPNotFound.new('1', '404', 'File Not Found')
+    @http_server_error = Net::HTTPInternalServerError.new('1', '500', 'Internal Server Error')
+  end
+
+  it "should exist" do
+    @website.should_not be_nil
+    @website.should be_an_instance_of(Rubicante::Website)
+  end
+
+  it "should require a name parameter for initialization" do
+    lambda { Website.new.should raise_error(ArgumentError) }
+  end
+
+  it "should return the HTTP code number for a site" do
+    Net::HTTP.stub!(:get_response).and_return(@http_redirect)
+    @website.response_code.should == "301"
+  end
+
+  it "should return true for good websites" do
+    Net::HTTP.stub!(:get_response).and_return(@http_ok)
+    @website.is_ok?.should == true
+  end
+
+  it "should return true for redirected websites" do
+    Net::HTTP.stub!(:get_response).and_return(@http_redirect)
+    @website.is_ok?.should == true
+  end
+
+  it "should return false for websites having problems" do
+    Net::HTTP.stub!(:get_response).and_return(@http_server_error)
+    @website.is_ok?.should == false
+  end
+
+  it "should return false for missing files" do
+    Net::HTTP.stub!(:get_response).and_return(@http_client_error)
+    @website.is_ok?.should == false
+  end
+
+  it "should return a WebsiteError for bad sites" do
+    Net::HTTP.stub!(:get_response).and_return(@http_server_error)
+    @website.wrong?.should be_an_instance_of(Rubicante::WebsiteError)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubicante
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Adam VanderHook
@@ -64,6 +64,23 @@ files:
 - lib/rubicante.rb
 - lib/rubicante/cli.rb
 - lib/rubicante/environment.rb
+- lib/rubicante/host.rb
+- lib/rubicante/host_error.rb
+- lib/rubicante/host_group.rb
+- lib/rubicante/type.rb
+- lib/rubicante/type_group.rb
+- lib/rubicante/website.rb
+- lib/rubicante/website_error.rb
+- spec/environment_spec.rb
+- spec/helper.rb
+- spec/host_error_spec.rb
+- spec/host_group_spec.rb
+- spec/host_spec.rb
+- spec/type_group_spec.rb
+- spec/type_spec.rb
+- spec/website_error_spec.rb
+- spec/website_spec.rb
+- test/test_rubicante.rb
 has_rdoc: true
 homepage: RubyForge http://rubicante.rubyforge.org
 post_install_message: