gs_phone 0.0.2 → 0.0.3

data/CHANGES.txt

@@ -1,7 +1,18 @@
+Version 0.0.3
+(25 March 2007)
+
+	* Added installation instructions
+        * Added unit tests to cover the majority of the current codebase
+        * Moved the control flow out of the class and into gs_phone
+        * Running gs_phone with no arguements will show the help
+        * Added a simple mock gsutil program for testing
+        * Cleaned up the message from the program
+        * Implemented a -v option to print out more status information
+
 Version 0.0.2
 (23 March 2007)
 
-	* Changed the option parsing to use Subverion style commands
+	* Changed the option parsing to use Subversion style commands
 	* Added context based help to each command
 	* Setup a hidden folder in the HOME to store our configuration files
 	* Added a basic generated template file used by gsutil

data/Rakefile

@@ -60,7 +60,7 @@ namespace :test do
   task :coverage do
     rm_f  "coverage"
     rm_f  "coverage.data"
-    file_list = FileList.new("test/**/*.rb")
+    file_list = FileList.new("test/**/*_test.rb")
     system("rcov --sort coverage #{file_list.to_s}")
   end
 end

data/TODO.txt

@@ -4,12 +4,8 @@ This is the list of tasks that need to be done or have been completed.
 
 = CURRENT
 
-* Add an INSTALL file
-* Add unit tests
 * Announce package
 * Get a list of the ip addresses currently assigned (Currently this works: grep -i '^ip' users.yml | awk '// {print $2}' | sort)
-* Cleanup the option parser
-* Cleanup the output from the program (e.g. remove "GS >")
 * Allow asterisk intregration
   * Read user list from extensions.conf and/or sip.conf
 
@@ -26,3 +22,9 @@ This is the list of tasks that need to be done or have been completed.
 * Create a RubyForge Project
 * Rework commandline passing to be like Subversion (svn command options)
 * Make --help the default command if no option is given
+* Add an INSTALL file
+* BUG: help is still not the default command if no option is given
+* BUG: If gsutil is not found the program acts as if everything is ok.  It should error out.
+* Add unit tests
+* Cleanup the option parser
+* Cleanup the output from the program (e.g. remove "GS >")

data/bin/gs_phone

@@ -8,5 +8,41 @@ require 'rubygems'
 require_gem 'gs_phone'
 require 'gs_phone' 
 
-GrandStream.new(ARGV)
 
+gs = GrandStream.new
+
+if not ARGV.nil? and ARGV.include?("-v")
+  gs.verbose = true
+  ARGV.delete_if { |a| a == "-v"}
+end
+
+@command = ARGV[0]
+@ip = ARGV[1]
+@current_ip = ARGV[2]
+@admin = ARGV[3]
+
+case @command
+when "help"
+  response = gs.help(ARGV[1])
+when "new"
+  # Don't use response because we want to give feeback throughout this process
+  puts gs.add_user(@ip)
+  puts gs.make(@ip)
+  puts gs.update_config(@ip, @current_ip, @admin)
+  puts gs.reboot_phone(@ip)
+when "add"
+  response = gs.add_user(@ip)
+when "make"
+  response = gs.make(@ip)
+when "update"
+  response = gs.update_config(@ip, @current_ip, @admin)
+when "reboot"
+  response = gs.reboot_phone(@ip)
+when "find"
+  response = gs.find_ip
+else
+  response = gs.help  
+end
+
+# Print out any responses, used for verbose options
+puts response unless response.nil?

data/lib/gs_phone/version.rb

@@ -2,7 +2,7 @@ module GsPhone #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/gs_phone.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby -w
+#!/usr/bin/ruby
 # This is used to manage the Grandstream phones.
 # It is a wrapper over Charles Howes (gsutil@ch.pkts.ca)'s gsutil
 # utility (http://www.pkts.ca/gsutil.shtml)
@@ -24,52 +24,43 @@ require 'yaml'
 
 class GrandStream
 
+  attr_reader :user_file
+  attr_reader :admin_password
+  attr_reader :gsutil
+  attr_reader :template_files
+  attr_reader :config_file
+  attr_accessor :verbose
+  
   # Default configurations
   @user_file = "#{ENV["HOME"]}/.gs_phone/users.yml"
   @admin_password = "admin"
   @gsutil = "#{ENV["HOME"]}/.gs_phone/gsutil"
-  @config_file = "#{ENV["HOME"]}/.gs_phone/settings.yml"
   @template_files = "#{ENV["HOME"]}/.gs_phone/templates/"
-
-  # Setup the help messages with the optparse library
-  def initialize(args)
-    read_configuration
-    @command = args[0]
-    @ip = args[1]
-    @current_ip = args[2]
-    @admin = args[3]
-
-    case @command
-    when "help"
-      help_command = args[1]
-      puts usage_summary(help_command)
-    when "new"
-      self.add_user(@ip)
-      self.make(@ip)
-      self.update_config(@ip, @current_ip, @admin)
-      self.reboot_phone(@ip)
-    when "add"
-      self.add_user(@ip)
-    when "make"
-      self.make(@ip)
-    when "update"
-      self.update_config(@ip, @current_ip, @admin)
-    when "reboot"
-      self.reboot_phone(@ip)
-    when "find"
-      self.find_ip
+  @new_config_created = ""
+  
+  def initialize
+    @verbose = false
+    # Use the GS_PHONE_CONFIG environnment to set the data directory
+    if not ENV["GS_PHONE_CONFIG"].nil?
+      @config_file = ENV["GS_PHONE_CONFIG"]
     else
-      
+      @config_file = "#{ENV["HOME"]}/.gs_phone/"
     end
+    read_configuration
+    # TODO: need to find a way to stop printing this in TEST
+    # puts @new_config_created unless @new_config_created.nil?
   end
 
+  def help(command=nil)
+    usage_summary(command)
+  end
   
   # Read the gs_phone configuration file to get the settings
   def read_configuration
-
-    if File.exists?("#{ENV["HOME"]}/.gs_phone/settings.yml")
+    
+    if File.exists?(@config_file + "/settings.yml")
       settings = Hash.new
-      settings = YAML::load(File.open("#{ENV["HOME"]}/.gs_phone/settings.yml"))
+      settings = YAML::load(File.open(@config_file + "/settings.yml"))
       
       @user_file = settings["user_file"] if settings.include?("user_file")
       @admin_password = settings["admin_password"]
@@ -77,46 +68,57 @@ class GrandStream
       @config_file = settings["config_file"]
       @template_files = settings["template_files"]
     else
-      puts "You have no default configuration file.  We will create one for you"
+      # No settings found so we need to follow a differnt logic path
+      # using the @new_config_created to hold our info messages
+      @new_config_created = "You have no default configuration file.  We will create one for you\n"
       settings = {
         "admin_password" => "admin",
-        "user_file" => "#{ENV["HOME"]}/.gs_phone/users.yml",
-        "gsutil" => "#{ENV["HOME"]}/.gs_phone/gsutil",
-        "config_file" => "#{ENV["HOME"]}/.gs_phone/settings.yml",
-        "template_files" => "#{ENV["HOME"]}/.gs_phone/templates/"
+        "user_file" => "#{@config_file}/users.yml",
+        "gsutil" => "#{@config_file}/gsutil",
+        "config_file" => "#{@config_file}/settings.yml",
+        "template_files" => "#{@config_file}/templates/"
       }
 
-      Dir.mkdir("#{ENV["HOME"]}/.gs_phone")
-      Dir.mkdir("#{ENV["HOME"]}/.gs_phone/templates")
-      cfg_template = File.new("#{ENV["HOME"]}/.gs_phone/templates/template.cfg", "w")
+      Dir.mkdir(@config_file)
+      Dir.mkdir("#{@config_file}/templates")
+      cfg_template = File.new("#{@config_file}/templates/template.cfg", "w")
       cfg_template.puts add_template
       cfg_template.close
       
-      file = File.new("#{ENV["HOME"]}/.gs_phone/settings.yml","w")
+      file = File.new("#{@config_file}/settings.yml","w")
       file.puts settings.to_yaml
       file.close
 
-      puts "File #{ENV["HOME"]}/.gs_phone/ has been created.  Please make sure the"
-      puts " settings are correct."
-      exit
+      @new_config_created << "File #{@config_file}/ has been created.  Please make sure the\n"
+      @new_config_created << " settings are correct."
 
     end
   end
 
   # Add a user to the configuration file
-  def add_user(ip_addr=nil)
+  def add_user(ip_addr=nil,username=nil,password=nil,mac_addy=nil)
     # Lets get some details for the new user
-    puts "GS> Username?"
-    username = STDIN.gets.chomp
-    puts "GS> Extension Number?"
-    password = STDIN.gets.chomp
+    if username.nil?
+      puts "Username?"
+      username = STDIN.gets.chomp
+    end
+    
+    # TODO: assuming password and extensions are the same.
+    if password.nil?
+      puts "Extension Number?"
+      password = STDIN.gets.chomp
+    end
+
     # Skip the ip address if they already passed it in.
     if ip_addr.nil?
-      puts "GS> Phone IP Address (i.e. 192.168.1.1)"
+      puts "Phone IP Address (i.e. 192.168.1.1)"
       ip_addr = STDIN.gets.chomp
     end
-    puts "GS> MAC Address?"
-    mac_addy = STDIN.gets.chomp
+
+    if mac_addy.nil?
+      puts "MAC Address?"
+      mac_addy = STDIN.gets.chomp
+    end
     
     # Open the user file and enter the data
     users = File.open(@user_file, 'a')
@@ -127,54 +129,54 @@ class GrandStream
     users.puts "mac: " + mac_addy
     users.close
 
-    # Set this so we can use it in other parts of the script if "--new" was called
-    @ip = ip_addr    
+    # Set this so we can use it in other parts of the script if "new" was called
+    @ip = ip_addr
   end
 
   # Generate a config file from the template
   def make(ip_address=@ip)
     # Skip the ip address if they already passed it in.
     if ip_address.nil?
-      puts "GS> What ip address?  "
+      puts "What ip address?  "
       ip_address = STDIN.gets.chomp
     end
 
-    @user_list = Hash.new
-    @phone = Array.new
-
+    exten = ""
+    
     # Open the user file and find the user who has the ip address that matches
     # the one we are looking for
-    users = File.open(@user_file)
-    data = YAML::load_documents(users) do |element|
-      if element['ip'] == ip_address and not element['skip'] == 'y'
-        name = element['name']
-        password = element['ext'].to_s
-        exten = element['ext'].to_s
-        ip = element['ip']
-        
-        # Split the ip address into each octal, the Grandstream config files
-        # needs it this way
-        ip1, ip2, ip3, ip4 = ip.split('.')
-        
-        templated = IO.readlines(@template_files + "template.cfg")
-        phone_config = ""
-
-        # Substitue in the user fields into their config 
-        # a.k.a. Magic REGEX section
-        templated.each do |line|
-          phone_config << line.gsub(/<<ext>>/, exten).gsub(/<<name>>/, name).gsub(/<<password>>/, password).gsub(/<<ip1>>/, ip1).gsub(/<<ip2>>/, ip2).gsub(/<<ip3>>/, ip3).gsub(/<<ip4>>/, ip4)
-        end
-        # Write out the string to a file now
-        File.open("#{@template_files}#{ip}.cfg", "w+") do |file|
-          file.puts phone_config
-        end
-        puts "GS< Made config for extension #{exten.to_s}"
-      end # IF
-    end # DO
+    File.open(@user_file) do |users|
+      data = YAML::load_documents(users) do |element|
+        if element['ip'] == ip_address and not element['skip'] == 'y'
+          name = element['name']
+          password = element['ext'].to_s
+          exten = element['ext'].to_s
+          ip = element['ip']
+          
+          # Split the ip address into each octal, the Grandstream config files
+          # needs it this way
+          ip1, ip2, ip3, ip4 = ip.split('.')
+          
+          templated = IO.readlines(@template_files + "template.cfg")
+          phone_config = ""
+
+          # Substitue in the user fields into their config 
+          # a.k.a. Magic REGEX section
+          templated.each do |line|
+            phone_config << line.gsub(/<<ext>>/, exten).gsub(/<<name>>/, name).gsub(/<<password>>/, password).gsub(/<<ip1>>/, ip1).gsub(/<<ip2>>/, ip2).gsub(/<<ip3>>/, ip3).gsub(/<<ip4>>/, ip4)
+          end
+          # Write out the string to a file now
+          File.open("#{@template_files}#{ip}.cfg", "w+") do |file|
+            file.puts phone_config
+          end
+        end # IF
+      end # DO
+    end # File
+    return "Made config for extension #{exten.to_s}"
   end
   
   def make_all
-    puts "GS< Making all configs"
+    puts "Making all configs" if @verbose
     @user_list = Hash.new
 
     users = File.open(@user_file)
@@ -183,7 +185,6 @@ class GrandStream
       @user_list[element['ext']] = element['ip']
     end
     @user_list.each do |ext,ip|
-      puts "GS< Making config for #{ext} (#{ip})"
       make(ip)
     end
   end
@@ -193,7 +194,7 @@ class GrandStream
   def update_config(ip_address=@ip, current_ip=nil, admin=nil)
     # Skip the ip address if they already passed it in.
     if ip_address.nil?
-      puts "GS> What ip address?  "
+      puts "What ip address?  "
       ip_address = STDIN.gets.chomp
     end
     if admin.nil?
@@ -202,15 +203,19 @@ class GrandStream
     if current_ip.nil?
       current_ip = ip_address
     end
-    # Setup the string to shell out to the gsutil script to scrape the webforms
-    cmd = "#{@gsutil} -p '#{admin}' -r '#{current_ip}' < #{@template_files}#{ip_address}.cfg"
-    `#{cmd}`.to_s    # Evil eval().
-    puts "GS< Config sent to phone"
+
+    # Shell out to the gsutil script to scrape the webforms
+    if system("#{@gsutil} -p '#{admin}' -r '#{current_ip}' < #{@template_files}#{ip_address}.cfg")
+      return "Config sent to phone" if @verbose
+    else
+      # TODO: This path is never reached, even if gsutil has an error.
+      return "ERROR: Failed to send config"
+    end
   end
 
   # Make a config file for each phone and push it to the phone
   def update_all
-    puts "GS< Updating all phones"
+    puts "Updating all phones" if @verbose
     @user_list = Hash.new
 
     users = File.open(@user_file)
@@ -220,10 +225,15 @@ class GrandStream
         @user_list[element['ext']] = element['ip']
       end
     end
+
+    responses = String.new
     @user_list.each do |ext,ip|
-      puts "GS< Making config for #{ext} (#{ip})"
-      update_config(ip)
+      response = update_config(ip)
+      if response
+        responses << response
+      end
     end
+    return responses if @verbose
   end
 
 
@@ -231,21 +241,23 @@ class GrandStream
   def reboot_phone(ip_address=@ip)
     # Skip the ip address if they already passed it in.
     if ip_address.nil?
-      puts "GS> What ip address?  "
+      puts "What ip address?  "
       ip_address = STDIN.gets.chomp
     end
     # Need a delay, if we just uploaded the new config then the phone will give a 500 
     # error if we try to reboot it too soon
     sleep(3) 
     # Setup the string to shell out to the gsutil script to scrape the webforms
-    cmd = "#{@gsutil} -p '#{@admin_password}' -b '#{ip_address}'"
-    `#{cmd}` # Evil eval() two
-    puts "GS< Phone rebooted"
+    if system("#{@gsutil} -p '#{@admin_password}' -b '#{ip_address}'")
+      return "Phone rebooted" if @verbose
+    else
+      return "ERROR: Failed to reboot phone"
+    end
   end
 
   # Reboot all phones
   def reboot_all_phones
-    puts "GS< Rebooting all phones"
+    puts "Rebooting all phones" if @verbose
     @user_list = Hash.new
 
     users = File.open(@user_file)
@@ -255,32 +267,36 @@ class GrandStream
         @user_list[element['ext']] = element['ip']
       end
     end
-    # Need a delay, if we just uploaded the new config then the phone will give a 500 
-    # error if we try to reboot it too soon
-    sleep(3) 
-    # Go-go BOFH method, this will reboot every phone in the user list.
+    
+    responses = String.new
     @user_list.each do |ext,ip|
-      puts "GS< Rebooting phone #{ext} (#{ip})"
-      cmd = "#{@gsutil} -p '#{@admin_password}' -b '#{ip}'"
-      `#{cmd}`
+      response = reboot_phone(ip)
+      if response
+        responses << response
+      end
     end
+
+    return responses if @verbose
   end
 
   # Finds the ip address of the phone if you know the extension.
-  def find_ip
-    print "What extension?  "
-    exten_in = STDIN.gets.chomp.to_i
+  def find_ip(extension=nil)
+    if extension.nil?
+      print "What extension?  "
+      extension = STDIN.gets.chomp
+    end
 
     # Go thorugh config file loking for the extension
     data = YAML::load_documents(File.open(@user_file)) do |element|
-      if element['ext'] == exten_in
+      if element['ext'] == extension.to_i
         @ip = element['ip']
-        puts "GS< #{element['ip']}"
+        puts "#{element['ip']}" if @verbose
+        return element['ip']
       end        
     end
   end
 
-    def usage_summary(command)
+  def usage_summary(command)
     usage = ""
     case command
     when "new"
@@ -320,7 +336,7 @@ Usage: update IP_ADDRESS [CURRENT_ADDRESS] [ADMIN_PASSWORD]
       
 Sends the updated configuration file for IP_ADDRESS to the phone.
 
-Optionaly, a phone configuration can be sent to a phone that currently has
+Optionally, a phone configuration can be sent to a phone that currently has
 a different ip address by using CURRENT_ADDRESS
 
 The admin password from the configuration file can also be overridden
@@ -358,9 +374,6 @@ EOFIND
       usage =<<EOHELP
 Usage: COMMAND [options]
       
-IP is the ip address you want the phone to use crtIP is the ip address
-the phone currently has pass is the current phone password
-
 COMMANDS       DESCRIPTION
 new            Add new user and setup their phone 
 add            Adds a user to the phone database

data/test/gs_phone_test.rb

@@ -1,11 +1,352 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
-class GsPhoneTest < Test::Unit::TestCase
+class GrandstreamTest < Test::Unit::TestCase
 
   def setup
+    # Recreate the base config files
+    ENV["GS_PHONE_CONFIG"] = "tmp"
+  end
+  
+  def teardown
+    # Remove the base config files
+    system("rm -Rf tmp")
   end
   
   def test_truth
     assert true
   end
+
+  def create_new_settings
+    GrandStream.new()    
+    # Copy in my ruby gsutil script so it can be used as a mock of the real gsutil.
+    system("cp test/mock_gsutil.rb tmp/gsutil")
+  end
+  
+  def change_admin_password
+    settings = ""
+    File.open("tmp/settings.yml", "r") do |file|
+      settings = file.readlines
+    end
+    
+    settings.each do |line|
+      line.gsub!(": admin",": gs_phone")
+    end
+    
+    File.open("tmp/settings.yml", "w") do |file|
+      file.puts settings
+    end
+  end
+  
+  def test_new_config
+    create_new_settings
+    
+    # Make sure the files are there
+    assert File.exists?( "tmp/settings.yml")
+    assert File.exists?( "tmp/templates")
+    assert File.exists?( "tmp/templates/template.cfg") 
+    
+    # Make sure the settings file is correct
+    settings = YAML::load(File.open("tmp/settings.yml"))
+    assert_equal "admin",              settings["admin_password"]
+    assert_equal "tmp/users.yml",      settings["user_file"]
+    assert_equal "tmp/gsutil",         settings["gsutil"]
+    assert_equal "tmp/settings.yml",   settings["config_file"]
+    assert_equal "tmp/templates/",     settings["template_files"]
+    
+  end
+  
+  # Reading an existing settings file
+  def test_read_settings
+    create_new_settings
+    gs = GrandStream.new()
+    assert_equal "admin",              gs.admin_password
+    assert_equal "tmp/users.yml",      gs.user_file
+    assert_equal "tmp/gsutil",         gs.gsutil
+    assert_equal "tmp/settings.yml",   gs.config_file
+    assert_equal "tmp/templates/",     gs.template_files
+  end
+
+  # Adding a new user
+  def test_add_user
+    create_new_settings
+    gs = GrandStream.new
+    gs.add_user("192.168.100.23","John Doe","200","000B820B0A7C")
+
+    assert File.exists?("tmp/users.yml")
+    users = YAML::load(File.open("tmp/users.yml"))
+    assert_equal "John Doe", users["name"]
+    assert_equal 200, users["ext"]
+    assert_equal "192.168.100.23", users["ip"]
+    assert_equal "000B820B0A7C", users["mac"]
+    
+  end
+
+  # Making a configuration file
+  def test_make
+    create_new_settings
+    gs = GrandStream.new
+    gs.add_user("192.168.100.23","John Doe","200","000B820B0A7C")
+    
+    # Make the file and check that it is correct
+    gs.make("192.168.100.23")
+    assert File.exists?("tmp/templates/192.168.100.23.cfg")
+    
+    config = File.read("tmp/templates/192.168.100.23.cfg")
+    
+    assert config.match("name = John Doe"), "Could not find the name in the file"
+    assert config.match("end_user_password = 200"), "Could not find the password in the file"
+    assert config.match("sip_userid = 200"), "Could not find the extension in the file"
+    assert config.match("authenticate_id = 200"), "Could not find the extension in the file"
+    assert config.match("static_ipaddress_1 = 192"), "Could not find the ip address in the file"
+    assert config.match("static_ipaddress_2 = 168"), "Could not find the ip address in the file"
+    assert config.match("static_ipaddress_3 = 100"), "Could not find the ip address in the file"
+    assert config.match("static_ipaddress_4 = 23"), "Could not find the ip address in the file"
+    
+
+  end
+
+  # Making all of the configuration files
+  def test_make_all
+    create_new_settings
+    gs = GrandStream.new
+
+    # Users
+    userlist = { 
+      "192.168.100.23" => "John Doe1",
+      "192.168.100.24" => "John Doe2",
+      "192.168.100.25" => "John Doe3",
+      "192.168.100.26" => "John Doe4",
+      "192.168.100.27" => "John Doe5",
+      "192.168.100.28" => "John Doe6"
+    }
+
+    # Create some users
+    userlist.each do |ip,user|
+      gs.add_user(ip,user,rand(300).to_s,"000B820B0A7C")
+    end
+
+    # Make all of the files
+    gs.make_all
+
+    # Check that they are all there and correct
+    userlist.each do |ip, user|
+      assert File.exists?("tmp/templates/#{ip}.cfg")
+      config = File.read("tmp/templates/#{ip}.cfg")
+      assert config.match("name = #{user}"), "Could not find the name in the file"
+    end
+  end
+
+  # Finding the ip address of one phone
+  def test_find_ip
+    create_new_settings
+    gs = GrandStream.new
+    gs.add_user("192.168.100.23","John Doe","200","000B820B0A7C")
+
+    assert_equal "192.168.100.23", gs.find_ip("200")
+  end
+
+  # Reboot the phone
+  def test_reboot
+    create_new_settings
+    # Change the admin password so the mock will work
+    change_admin_password
+    gs = GrandStream.new
+    assert_nil gs.reboot_phone("192.168.1.25") # a nil return means no error
+
+  end
+
+  # Reboot the phone with an incorrect password
+  def test_reboot_incorrect_password
+    create_new_settings
+    gs = GrandStream.new
+    assert_equal "ERROR: Failed to reboot phone", gs.reboot_phone("192.168.1.25")
+
+  end
+
+  
+  # Rebooting all of the phones
+  def test_reboot_all
+    create_new_settings
+    # Change the admin password so the mock will work
+    change_admin_password
+    gs = GrandStream.new
+    gs.add_user("192.168.1.25","John Doe1","200","000B820B0A7C")
+    gs.add_user("192.168.1.25","John Doe2","201","000B820B0A7C")
+    
+    assert_nil gs.reboot_all_phones # a nil return means no error
+
+  end
+
+  # Sending the update
+  def test_update
+    create_new_settings
+    # Change the admin password so the mock will work
+    change_admin_password
+    gs = GrandStream.new
+    gs.add_user("192.168.1.25","John Doe","200","000B820B0A7C")
+    gs.make("192.168.1.25")
+    
+    assert_nil gs.update_config("192.168.1.25") # nil means no error
+    
+  end
+
+  # Send the update with an incorrect password
+  def test_update_incorrect_password
+    create_new_settings
+    gs = GrandStream.new
+    gs.add_user("192.168.1.25","John Doe","200","000B820B0A7C")
+    gs.make("192.168.1.25")
+    
+    assert_equal "ERROR: Failed to send config", gs.update_config("192.168.1.25")
+    
+  end
+
+  # Sending all of the updates
+  def test_update_all
+    create_new_settings
+    # Change the admin password so the mock will work
+    change_admin_password
+    gs = GrandStream.new
+    
+    userlist = { 
+      "192.168.1.25" => "John Doe1",
+      "192.168.1.26" => "John Doe2"
+    }
+
+    # Create some users
+    userlist.each do |ip,user|
+      gs.add_user(ip,user,rand(300).to_s,"000B820B0A7C")
+    end
+
+    # Make all of the files
+    gs.make_all
+    
+    assert_nil gs.update_all # nil means no error
+    
+  end
+
+  
+  #####
+  # Help sections
+  #####
+  def test_help
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOHELP
+Usage: COMMAND [options]
+      
+COMMANDS       DESCRIPTION
+new            Add new user and setup their phone 
+add            Adds a user to the phone database
+make           Generates a config file from the template
+update         Uploads the configuration file to the phone
+reboot         Reboots a phone 
+find           Find the ip address in the configuration file
+
+EOHELP
+    
+    assert_equal help, gs.help
+  end
+
+    def test_help_new
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EONEW
+Usage: new
+      
+Goes through all the steps to setup a new phone:
+  "add", "make", "update", "reboot"
+
+EONEW
+    
+    assert_equal help, gs.help("new")
+  end
+
+  def test_help_add
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOADD
+Usage: add IP_ADDRESS
+      
+Adds a user who has a phone at IP_ADDRESS
+
+Ex:
+  add 192.168.1.200
+
+EOADD
+
+    assert_equal help, gs.help("add")
+  end
+
+  def test_help_make
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOMAKE
+Usage: make IP_ADDRESS
+      
+Creates the configuration file for the phone at IP_ADDRESS
+
+Ex:
+  make 192.168.1.200
+
+EOMAKE
+
+    assert_equal help, gs.help("make")
+  end
+    
+  def test_help_update
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOUPDATE
+Usage: update IP_ADDRESS [CURRENT_ADDRESS] [ADMIN_PASSWORD]
+      
+Sends the updated configuration file for IP_ADDRESS to the phone.
+
+Optionally, a phone configuration can be sent to a phone that currently has
+a different ip address by using CURRENT_ADDRESS
+
+The admin password from the configuration file can also be overridden
+
+Ex:
+  update 192.168.1.200
+  update 192.168.1.200 192.168.1.10  <= Send '200's update to the phone at '10'
+  update 192.168.1.200 192.168.1.10 admin <= Also uses the factory password
+
+
+EOUPDATE
+    
+    assert_equal help, gs.help("update")
+  end
+  
+  def test_help_reboot
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOREBOOT
+Usage: reboot COMMAND IP_ADDRESS
+      
+Reboots the phone at IP_ADDRESS.
+
+CAUTION: Some firmware will allow the phone to be rebooted while it is in use!
+
+Ex:
+  reboot 192.168.1.200
+
+EOREBOOT
+
+    assert_equal help, gs.help("reboot")
+  end
+
+  def test_help_find
+    create_new_settings
+    gs = GrandStream.new
+    help =<<EOFIND
+Usage: find
+      
+Searches the user.yml file to get the ipaddress of an extension.
+
+EOFIND
+
+    assert_equal help, gs.help("find")
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: gs_phone
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2007-03-23 00:00:00 -07:00
+  version: 0.0.3
+date: 2007-03-25 00:00:00 -07:00
 summary: Application to mange and configure a group of Grandstream Voip phones
 require_paths: 
 - lib