kinokero 0.0.5

data/test/test/models/jingle_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+require 'test_kinokero'
+
+class JingleTest < ActiveSupport::TestCase
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  setup    :setup_jig
+  teardown :teardown_jig
+
+  context "jingle" do   # test suite for printer.rb
+
+    should 'have active jingle connection' do
+      assert  @proxy.my_devices['test'].cloudprint.jingle
+    end   # should test do
+
+
+    should 'start then close connection' do
+      jingle = @proxy.my_devices['test'].cloudprint.jingle
+
+      #  Kinokero::Jingle.set_verbose
+
+      jingle.gtalk_start_connection do |printerid|
+        
+      end   # do
+
+      assert jingle.is_connection
+
+      jingle.gtalk_close_connection
+
+      assert !jingle.is_connection
+
+    end   # should test do
+
+
+# TODO: add dynamic queue print job and test the asynch notification
+
+
+
+
+  end  # context jingle
+
+# _____________________________________________________________________________    
+
+end  # class test

data/test/test/models/printer_test.rb

@@ -0,0 +1,99 @@
+require 'test_helper'
+require 'test_kinokero'
+
+class PrinterTest < ActiveSupport::TestCase
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  setup    :setup_jig
+  teardown :teardown_jig
+
+  context "printer" do   # test suite for printer.rb
+
+    should 'print gcp registration message' do
+
+      assert   Kinokero::Printer.print_gcp_registration_info(
+        CUPS_NULL_PRINTER,
+        "lime sublime"
+      )
+
+    end  # test
+
+
+    should "verify printer is ready" do
+
+      assert   @proxy.my_devices['test'].is_printer_ready?
+
+    end  # test
+
+
+    should "print a file" do
+
+      assert   @proxy.my_devices['test'].print_file( CUPS_PPD_FILE )
+
+    end  # test
+
+
+    should 'change cups state to sym' do
+
+      printer = @proxy.my_devices['test']
+
+      assert_equal  :idle, printer.cups_state_to_sym( '3' )
+      assert_equal  :processing, printer.cups_state_to_sym( '4' )
+      assert_equal  :stopped, printer.cups_state_to_sym( '5' )
+      assert_equal  :lime, printer.cups_state_to_sym( 'lime' )
+
+    end  # test
+
+
+    should 'change cups reason' do
+
+      printer = @proxy.my_devices['test']
+
+      assert_equal  '', printer.cups_reason( 'none' )
+      assert_equal  'wild blue', printer.cups_reason( 'wild blue' )
+
+    end  # test
+
+    should 'stop poll thread' do
+
+      assert_nil @proxy.my_devices['test'].stop_poll_thread()
+
+    end  # test
+
+
+    should 'start poll thread' do
+
+      assert @proxy.my_devices['test'].start_poll_thread()
+      assert @proxy.my_devices['test'].poll_thread
+
+    end  # test
+
+
+    should 'set up model info' do
+
+      assert @proxy.my_devices['test'].setup_model( {} )
+
+    end  # test
+
+
+    should 'set up gcp info correctly' do
+      assert @proxy.my_devices['test'].setup_gcp( 
+        @proxy.my_devices['test'].gcp_printer_control
+      )
+
+    end  # test
+
+
+    should 'set up gcp info incorrectly' do
+      assert_raise(ArgumentError)  {  
+        @proxy.my_devices['test'].setup_gcp( { cups_alias: 0  } )
+      }
+
+    end  # test
+
+
+  end  # context printer
+
+# _____________________________________________________________________________    
+
+end  # class test

data/test/test/models/proxy_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+require 'test_kinokero'
+
+class ProxyTest < ActiveSupport::TestCase
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  setup    :setup_jig
+  teardown :teardown_jig
+
+  context "proxy" do   # test suite for printer.rb
+
+    should 'print gcp reg info'  do
+      reg_response = {
+        :success => true,
+        :cups_alias => CUPS_NULL_PRINTER,
+        :gcp_printer_reg_token =>  'wild_blue_1' ,
+        :gcp_claim_token_url =>    'wild_blue_2',
+        :gcp_easy_reg_url =>       'wild_blue_3',
+        :swalapala_printer_id =>   'wild_blue_4',
+        :gcp_printer_name =>       'wild_blue_5',
+        :gcp_printer_id   =>       'wild_blue_6'
+      }
+
+      assert  @proxy.print_gcp_registration_info(
+        reg_response
+      )
+
+    end   # should do
+
+
+    should 'get printer list' do
+      list_result = @proxy.do_list( 'test' )
+      assert list_result['success']   # should always return success even if no printers
+    end   # should do
+
+
+    should 'do refresh tokens' do
+      list_result = @proxy.do_refresh( 'test' )
+      assert list_result['success']   # should always return success even if no printers
+    end   # should do
+
+
+    should 'do fetch jobs' do
+      list_result = @proxy.do_fetch_jobs( 'test' )
+      assert !list_result['success']   # should fail since not on-line
+    end   # should do
+
+
+    should 'do print jobs' do
+      list_result = @proxy.do_print_jobs(  
+        @proxy.my_devices['test'].gcp_printer_control[:gcp_printerid]
+      )
+      # TODO: what to assert?
+    end   # should do
+
+
+    should 'not delete printer' do
+      @proxy.do_delete( 'lime' )
+      assert_nil @proxy.my_devices['lime']   
+    end   # should do
+
+
+    should 'do ready state' do
+      list_result = @proxy.do_ready_state( 'test' )
+      assert !list_result['success']   # should fail since not on-line
+    end   # should do
+
+
+    should 'not register a printer'  do
+      
+      item = 'wildblue'
+
+        # build an offshoot request list
+      new_request = build_gcp_request( item )
+
+      list_result = @proxy.do_register( new_request ) do  |gcp_ctl|
+      end  # do register
+
+      assert !list_result['success']  
+
+    end   # should do
+
+
+    should 'connect printer on-line with gcp' do
+      @proxy.do_connect( 'test' )
+      assert @proxy.my_devices['test'].cloudprint.jingle.is_connection
+    end   # should do
+
+    should 'return item given a printerid' do
+      result = @proxy.item_from_printerid(
+        @proxy.my_devices['test'].gcp_printer_control[:gcp_printerid]
+      )
+      assert_equal  'test',result
+
+    end   # should do
+
+
+  end  # context proxy
+
+# _____________________________________________________________________________    
+
+end  # class test

data/test/test/test_helper.rb

@@ -0,0 +1,31 @@
+ENV["RAILS_ENV"] ||= "test"
+
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+
+  ActiveRecord::Migration.check_pending!
+
+# -----------------------------------------------------------------------------
+# any class-level stuff for special handling
+# -----------------------------------------------------------------------------
+  class << self
+    
+  end  #  anon class
+    
+# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  # fixtures :all
+  
+  # Add more helper methods to be used by all tests here...
+
+# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
+end   #  class ActiveSupport::TestCase
+

data/test/test/test_kinokero.rb

@@ -0,0 +1,234 @@
+# ****************************************************************************
+# *****  app configured, initialized, and ruby-prepped here   ****************
+# ****************************************************************************
+# make it so that our lib is at the head of the load/require path array
+#   $:.unshift( File.expand_path('../lib', __FILE__) )
+#   load File.expand_path('../config/application_configuration.rb', __FILE__)
+  
+# ****************************************************************************
+
+  require 'yaml'
+  require 'erb'
+  require 'active_support/core_ext/hash'
+  require 'cups'
+  require 'thread'
+  
+# ****************************************************************************
+# get temporary managed printer data for testing interfaces
+# ****************************************************************************
+
+GCP_SEED_FILE = '../fixtures/gcp_seed.yml'
+CUPS_NULL_PRINTER = 'lp_null'    # expected null printer
+REGISTER_NULL_PRINTER = "lpadmin -p #{CUPS_NULL_PRINTER} -E -v file:///dev/null"
+CUPS_PPD_FILE = '/etc/cups/ppd/laserjet_1102w.ppd'  # also used as a test print file
+CUPS_CDD_FILE = '/etc/cups/cdd/laserjet_1102w.cdd'
+
+# #########################################################################
+# ##########  working with seed data  #####################################
+# #########################################################################
+
+# -----------------------------------------------------------------------------
+
+  def load_gcp_seed()
+    if @seed_data.nil?
+      @seed_data =  YAML.load( 
+          ERB.new(
+            File.read(
+              File.expand_path(GCP_SEED_FILE , __FILE__ ) 
+            )
+          ).result 
+      )
+
+      #  puts "seed_data: #{@seed_data.object_id}"
+
+    end
+  end
+
+# -----------------------------------------------------------------------------
+
+  def write_gcp_seed()
+    unless @seed_data.nil?
+
+      File.open(
+        File.expand_path(GCP_SEED_FILE , __FILE__ ), 
+        'w'
+      ) { |f| 
+        YAML.dump(@seed_data, f) 
+      }
+
+    end   # unless no seed data yet
+  end
+
+# -----------------------------------------------------------------------------
+
+  def update_gcp_seed(gcp_control, item, &block )
+
+    @seed_data[item] ||= {}  # if first time
+    
+    @seed_data[item]['gcp_xmpp_jid'] = gcp_control[:gcp_xmpp_jid]
+    @seed_data[item]['gcp_confirmation_url'] = gcp_control[:gcp_confirmation_url]
+    @seed_data[item]['gcp_owner_email'] = gcp_control[:gcp_owner_email]
+
+    @seed_data[item]['gcp_printer_name'] = gcp_control[:gcp_printer_name]
+    @seed_data[item]['gcp_printerid'] = gcp_control[:gcp_printerid]
+
+    @seed_data[item]['gcp_access_token'] = gcp_control[:gcp_access_token]
+    @seed_data[item]['gcp_refresh_token'] = gcp_control[:gcp_refresh_token]
+    @seed_data[item]['gcp_token_type'] = gcp_control[:gcp_token_type]
+    @seed_data[item]['gcp_token_expiry_time'] = gcp_control[:gcp_token_expiry_time]
+
+    @seed_data[item]['is_active'] = gcp_control[:is_active]
+    @seed_data[item]['virgin_access'] = gcp_control[:virgin_access]
+
+    yield( @seed_data[item] ) if block_given?
+
+    write_gcp_seed()
+
+  end
+
+# -----------------------------------------------------------------------------
+
+
+  def add_gcp_seed_request( seed, new_request )
+
+      # add in some addtional initializing seed info from the request block
+    seed['printer_id']    = new_request[:printer_id]
+    seed['item']          = new_request[:item]
+    seed['cups_alias']    = new_request[:cups_alias]
+    seed['capability_ppd']   = new_request[:capability_ppd]
+    seed['capability_cdd']   = new_request[:capability_cdd]
+    seed['gcp_printer_name'] = new_request[:gcp_printer_name]
+
+    seed['gcp_uuid']     = new_request[:gcp_uuid]
+    seed['gcp_manufacturer']     = new_request[:gcp_manufacturer]
+    seed['gcp_model']     = new_request[:gcp_model]
+    seed['gcp_setup_url']     = new_request[:gcp_setup_url]
+    seed['gcp_support_url']     = new_request[:gcp_support_url]
+    seed['gcp_update_url']     = new_request[:gcp_update_url]
+    seed['gcp_firmware']     = new_request[:gcp_firmware]
+
+    return seed
+  end
+
+# -----------------------------------------------------------------------------
+
+  def update_gcp_seed_tokens( item )
+
+    @seed_data[item] ||= {}  # if first time
+    
+    gcp = @proxy.my_devices[item].gcp_printer_control
+
+    @seed_data[item]['gcp_access_token'] = gcp[:gcp_access_token]
+    @seed_data[item]['gcp_token_expiry_time'] = gcp[:gcp_token_expiry_time]
+    @seed_data[item]['virgin_access'] = gcp[:virgin_access]
+
+    write_gcp_seed()
+  end
+
+# -----------------------------------------------------------------------------
+
+  def build_device_list()
+
+    load_gcp_seed()    # load the seed data
+
+      # prep to build up a hash of gcp_control hashes
+    gcp_control_hash = {}
+
+    @seed_data.each_key do |item|
+      gcp_control_hash[ item ] = @seed_data[ item ].symbolize_keys  # strip item into hash with keys
+    end   # convert each seed to a device object
+
+    return gcp_control_hash
+    
+  end   # convert each seed to a device object
+
+# -----------------------------------------------------------------------------
+
+# if item hasn't yet been defined in seed data, create one out of
+# thin air by using test as a template
+  def build_gcp_request( item )
+
+    use_item = validate_item( item )
+
+    return {
+      item:  item,
+      printer_id:   0,  # will be cue to create new record
+      gcp_printer_name: "gcp_#{item}_printer",
+      capability_ppd: @seed_data[use_item]['capability_ppd'],
+      capability_cdd: @seed_data[use_item]['capability_cdd'],
+      cups_alias: @seed_data[use_item]['cups_alias'],
+      gcp_uuid:         @seed_data[use_item]['gcp_uuid'],
+      gcp_manufacturer: @seed_data[use_item]['gcp_manufacturer'],
+      gcp_model:        @seed_data[use_item]['gcp_model'],
+      gcp_setup_url:    @seed_data[use_item]['gcp_setup_url'],
+      gcp_support_url:  @seed_data[use_item]['gcp_support_url'],
+      gcp_update_url:   @seed_data[use_item]['gcp_update_url'],
+      gcp_firmware:     @seed_data[use_item]['gcp_firmware'],
+    }
+  end
+
+# -----------------------------------------------------------------------------
+
+  def find_or_fail( filename )
+    user_file = Dir.glob(filename).first
+    if user_file.blank? 
+       raise  IOError, "file: '#{filename}' not found"
+    end
+    return user_file
+  end
+
+# -----------------------------------------------------------------------------
+ 
+  def validate_item( item )
+    return ( @seed_data.has_key?(item) ? item : 'test' )
+  end
+
+# -----------------------------------------------------------------------------
+
+# **************************************************************************** 
+# *****  test jig initialization here    *************************************
+# ****************************************************************************
+
+  def validate_pre_conditions()
+    unless  ENV["GCP_PROXY_CLIENT_ID"]  &&  ENV["GCP_PROXY_CLIENT_SECRET"]
+
+      raise ArgumentError, "Missing environment variables for GCP_PROXY_CLIENT_ID, GCP_PROXY_CLIENT_SECRET"
+
+    end   # unless environment variables defined
+
+    find_or_fail( CUPS_PPD_FILE )
+    find_or_fail( CUPS_CDD_FILE )
+    find_or_fail( File.expand_path(GCP_SEED_FILE , __FILE__ ) )
+
+    unless Cups.show_destinations.include?( CUPS_NULL_PRINTER )
+      system( REGISTER_NULL_PRINTER )  # register null printer
+    end   # unless null printer already exists
+
+  end
+
+  def setup_jig()
+    if @proxy.nil?  # start up the GCP proxy
+      validate_pre_conditions()   # validate prerequisite assumptions
+
+         # TODO: make this a command-line option to set
+      full_verbose = false    # ok to change this setting
+
+      Kinokero.verbose = full_verbose  # sets the class-level verbose
+       
+        # read seed file, set up proxy for testing
+      @proxy = Kinokero::Proxy.new(         
+        build_device_list(), 
+        {    # options
+          :verbose => full_verbose,         # log everything?
+          :auto_connect => false,    # automatically connect active devices?
+          :log_truncate => false,    # truncate long responses?
+          :log_response => false     # log the responses?
+        } 
+      )
+    end  # initial @proxy setup
+  end
+
+  def teardown_jig()
+  end
+
+# -----------------------------------------------------------------------------