tsig_api 1.0.5

data/lib/tsig_api/remote_actions.rb

@@ -0,0 +1,71 @@
+require 'net/http'
+require 'net/https'
+
+module TsigApi
+  module RemoteActions
+    
+    class Response
+      attr_accessor :status
+      attr_accessor :body
+      attr_accessor :raw_response
+      
+      def initialize(ret_val, resp)
+        self.status = ret_val
+        self.raw_response = resp
+        self.body = resp.body
+      end
+    end
+    
+    class Request
+      attr_accessor :headers
+      attr_accessor :proxy
+      attr_accessor :proxy_port
+      attr_accessor :body
+      attr_accessor :http_process
+      attr_accessor :url
+
+      def initialize(options={})
+        default_options = {
+          :body       => nil,
+          :headers    => {'Content-Type' => 'application/xml', 'Accept' => 'application/xml'},
+          :proxy      => nil,
+          :proxy_port => nil,
+          :url        => '/api/parser'
+        }
+        default_options.merge!(options)
+        
+        self.proxy      = default_options[:proxy]
+        self.proxy_port = default_options[:proxy_port]
+        self.headers    = default_options[:headers]
+        self.body       = default_options[:body]
+        self.url        = default_options[:url]
+
+        self.http_process = Net::HTTP.new( TsigApi::TXTSIG_HOST, TsigApi::TXTSIG_PORT, self.proxy, self.proxy_port )
+        
+        if TsigApi::TXTSIG_PORT.to_i == 443
+          self.http_process.use_ssl = true
+
+          # We know we're under SSL, but motherfucking openssl won't 
+          # stop complaining about our cert since we upgraded to 
+          # higher SHA2 hashing 
+          self.http_process.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+      
+      def send_request
+        http_process.start
+        resp = http_process.post(self.url, self.body, self.headers)
+        ret_val = false
+        case resp
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          ret_val = true
+        else
+          ret_val = false
+        end
+        return TsigApi::RemoteActions::Response.new(ret_val, resp)
+      end
+    end
+
+  end
+  
+end

data/lib/tsig_api/team.rb

@@ -0,0 +1,79 @@
+require 'tsig_api/base'
+
+module TsigApi
+  class Team < TsigApi::Base
+    self.remote_type = :team
+    
+    # this might be somewhat redundant to query(:all_teams => true), but
+    # it seems that that will only return the ids, not id => name
+    #
+    def list
+      xml = group_id_node
+      TsigApi::RemoteActions::Request.new(:body => request_xml(:list, xml))
+    end
+
+    def create(options = {:name => nil, :add_contacts => nil})
+      contact_xml = ""
+      if options[:add_contacts]
+      	contact_xml += "<param name='add_contacts'>"
+        options[:add_contacts].each do |ac|
+          contact_xml += "<contact>#{ac}</contact>"
+        end
+        contact_xml += "</param>"
+      end
+      xml = "
+      #{group_id_node}
+      #{param_node('team_name', options[:name])}
+    	#{contact_xml}
+      "
+      TsigApi::RemoteActions::Request.new(:body => request_xml(:create, xml))
+    end
+    
+    def query(options = {:name => nil, :team_id => nil, :all_teams => nil})
+      xml = group_id_node
+      if options[:team_id]
+        xml += "<param name='team_id'>#{options[:team_id]}</param>"
+      elsif options[:name]
+        xml += "<param name='team_name'>#{options[:name]}</param>"
+      elsif options[:all_teams] 
+        xml += "<param name='all_teams'>1</param>"
+      end
+      TsigApi::RemoteActions::Request.new(:body => request_xml(:query, xml))
+    end
+    
+    def update(team_id, options = {:name => nil, :add_contacts => nil, :del_contacts => nil})
+      xml = group_id_node
+      xml += param_node('team_id', team_id)
+      xml += param_node('team_name', options[:name]) if options[:name]
+      if options[:add_contacts]
+        add_contact_xml = "<param name='add_contacts'>"
+        options[:add_contacts].each do |ac|
+          add_contact_xml += "<contact>#{ac}</contact>"
+        end
+        add_contact_xml += "</param>"
+        xml += add_contact_xml
+      end
+      if options[:del_contacts]
+        del_contact_xml = "<param name='del_contacts'>"
+        options[:del_contacts].each do |dc|
+          del_contact_xml += "<contact>#{dc}</contact>"
+        end
+        del_contact_xml += "</param>"
+        xml += del_contact_xml
+      end
+      TsigApi::RemoteActions::Request.new(:body => request_xml(:update, xml))
+    end
+    
+    def delete(options = {:team_id => nil, :name => nil})
+      xml = group_id_node
+      
+      if options[:team_id]
+        xml+= param_node('team_id', options[:team_id])
+      elsif options[:name]
+        xml+= "<param name='team_id'></param>#{param_node('team_name', options[:name])}"
+      end
+      TsigApi::RemoteActions::Request.new(:body => request_xml(:delete, xml))
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+
+ENV["RAILS_ENV"] = "test"
+require File.dirname(__FILE__) + '/../../../../config/environment'
+require 'test_help'
+require 'rexml/document'
+require File.dirname(__FILE__) + '/../lib/tsig_api'
+
+class ActiveSupport::TestCase
+  require 'rr'
+  include RR::Adapters::TestUnit
+end
+
+
+# dummy: lets me rename a test as xtest to prevent it from running
+def xtest(*args)
+  file = File.basename(caller.first)
+  puts "Disabled test [#{file}]: #{args.first}"
+end

data/test/tsig_api_authorize_test.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '/test_helper')
+
+class TsigApiAuthorizeTest < ActiveSupport::TestCase
+
+  def setup
+    response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="user">
+          <element name='success'>true</element>
+          <element name='client_id'>1234</element>
+          <element name='api_password'>abcde01234abcde01234abcde01234ab</element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    error_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="error">
+        <item  type="error_description">
+          <element name="error_code">10</element>
+          <element name="error_text"><![CDATA[General Fault]]></element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    net_response = stub("net_response")
+    net_response.body{response_xml}
+    net_error = stub("net_error")
+    net_error.body{error_xml}
+    
+    @valid_response = TsigApi::RemoteActions::Response.new(true, net_response)
+    stub(@valid_response).body{response_xml}
+    @error_response = TsigApi::RemoteActions::Response.new(true, net_error)
+    stub(@error_response).body{error_xml}
+
+    TsigApi::Base.establish_connection(1234, 'joe', 'clear-text-pass')
+  end
+  
+  def test_should_initialize
+    a = TsigApi::Authorize.new
+    assert_equal a.class, TsigApi::Authorize
+    assert_equal a.class.remote_type, :authorize
+  end
+  
+  def test_should_build_query_xml
+    a = TsigApi::Authorize.new
+    request = a.query
+    assert request.body.include?('<api_username><![CDATA[joe')
+  end
+  
+  def test_should_send_request_and_parse_response
+    a = TsigApi::Authorize.new
+    request = a.query
+    stub(request).send_request{@valid_response}
+    content_type, response_hash = a.parse_response(request.send_request)
+    assert_equal content_type, "response"
+    assert_equal response_hash["client_id"], '1234'
+    assert_equal response_hash["api_password"], 'abcde01234abcde01234abcde01234ab'
+    # now we fake an error response
+    stub(request).send_request{@error_response}
+    content_type, response_hash = a.parse_response(request.send_request)
+    assert_equal content_type, "error"
+    assert_equal response_hash["error_code"], "10"
+  end
+    
+end

data/test/tsig_api_carrier_test.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), '/test_helper')
+
+class TsigApiCarrierTest < ActiveSupport::TestCase
+
+  def setup
+    response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="carriers">
+          <element name='cingular'>
+              Cingular
+          </element>
+          <element name='att'>
+              AT&amp;T
+          </element>
+          <element name='alltel'>
+              Alltel
+          </element>
+          <element name='verizon'>
+              Verizon
+          </element>
+          <element name='nextel'>
+              Nextel
+          </element>
+          <element name='sprint'>
+              Sprint
+          </element>
+          <element name='tmobile'>
+              T-Mobile
+          </element>
+          <element name='boostmobile'>
+              Boost Mobile
+          </element>
+          <element name='virginmobile'>
+              Virgin Mobile
+          </element>
+          <element name='uscellular'>
+              US Cellular
+          </element>
+          <element name='suncom'>
+              SunCom
+          </element>
+          <element name='centennial'>
+              Centennial Wireless
+          </element>
+          <element name='fido_ca'>
+              Fido (Canada)
+          </element>
+          <element name='bellmobility_ca'>
+              Bell Mobility (Canada)
+          </element>
+          <element name='rogers_ca'>
+              Rogers (Canada)
+          </element>
+          <element name='virginmobile_ca'>
+              Virgin Mobile (Canada)
+          </element>
+          <element name='telus_ca'>
+              Telus (Canada)
+          </element>
+          <element name='cellularone'>
+              Cellular One
+          </element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    error_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="error">
+        <item  type="error_description">
+          <element name="error_code">10</element>
+          <element name="error_text"><![CDATA[General Fault]]></element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    net_response = stub("net_response")
+    net_response.body{response_xml}
+    net_error = stub("net_error")
+    net_error.body{error_xml}
+    
+    @valid_response = TsigApi::RemoteActions::Response.new(true, net_response)
+    stub(@valid_response).body{response_xml}
+    @error_response = TsigApi::RemoteActions::Response.new(true, net_error)
+    stub(@error_response).body{error_xml}
+
+    TsigApi::Base.establish_connection(1234, 'joe', '123456789012345678901234567890ab')
+  end
+  
+  def test_should_initialize_carrier
+    c = TsigApi::Carrier.new("Group A")
+    assert_equal c.class, TsigApi::Carrier
+    assert_equal c.class.remote_type, :carriers
+  end
+  
+  def test_should_build_query_xml
+    c = TsigApi::Carrier.new("Group A")
+    request = c.query
+    assert request.body.include?('<action type="list_carriers">')
+    assert request.body.include?('<client_id><![CDATA[1234]]></client_id>')
+    assert request.body.include?('<api_username><![CDATA[joe]]></api_username>')
+    assert request.body.include?('<api_password><![CDATA[123456789012345678901234567890ab]]></api_password>')
+  end
+  
+  def test_should_send_request_and_parse_response
+    c = TsigApi::Carrier.new("Group A")
+    request = c.query
+    stub(request).send_request{@valid_response}
+    content_type, response_hash = c.parse_response(request.send_request)
+    assert_equal content_type, "response"
+    assert_equal response_hash["cellularone"], "Cellular One"
+    # now we fake an error response
+    stub(request).send_request{@error_response}
+    content_type, response_hash = c.parse_response(request.send_request)
+    assert_equal content_type, "error"
+    assert_equal response_hash["error_code"], "10"
+  end
+    
+end

data/test/tsig_api_contact_test.rb

@@ -0,0 +1,148 @@
+require File.join(File.dirname(__FILE__), '/test_helper')
+
+class TsigApiContactTest < ActiveSupport::TestCase
+  
+  def setup
+    
+    @tsig_contact = TsigApi::Contact.new("Group A")
+    @valid_contact = {:first_name => "John", :last_name => "Test", :cell_carrier => "verizon", :cell_number => "999-999-9999", :receive_messages => true}
+        
+    create_response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="contact">
+          <element name='success'>1</element>
+          <element name='contact_id'>15</element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    query_response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="contact">
+          <element name='success'>1</element>
+          <element name='contacts'>
+              <contact_id>15</contact_id>
+          </element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    update_response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="contact">
+          <element name='success'>1</element>
+          <element name='contact_id'>15</element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    delete_response_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="response">
+        <item type="contact">
+          <element name='success'>1</element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    error_xml = <<-EOS
+    <?xml version='1.0'?>
+    <txtsig_response version="1.0">
+      <content type="error">
+        <item  type="error_description">
+          <element name="error_code">10</element>
+          <element name="error_text"><![CDATA[General Fault]]></element>
+        </item>
+      </content>
+    </txtsig_response>
+    EOS
+    
+    create_response = stub("create_response")
+    create_response.body{create_response_xml}
+    query_response = stub("query_response")
+    query_response.body{query_response_xml}
+    update_response = stub("update_response")
+    update_response.body{update_response_xml}
+    delete_response = stub("delete_response")
+    delete_response.body{delete_response_xml}
+    error_response = stub("net_error")
+    error_response.body{error_xml}
+    
+    @valid_create_response = TsigApi::RemoteActions::Response.new(true, create_response)
+    stub(@valid_create_response).body{create_response_xml}
+    @valid_query_response = TsigApi::RemoteActions::Response.new(true, query_response)
+    stub(@valid_query_response).body{query_response_xml}
+    @valid_update_response = TsigApi::RemoteActions::Response.new(true, update_response)
+    stub(@valid_update_response).body{update_response_xml}
+    @valid_delete_response = TsigApi::RemoteActions::Response.new(true, delete_response)
+    stub(@valid_delete_response).body{delete_response_xml}
+    @error_response = TsigApi::RemoteActions::Response.new(true, error_response)
+    stub(@error_response).body{error_xml}
+  end
+  
+  def test_should_initialize_contact
+    assert_equal @tsig_contact.class, TsigApi::Contact
+    assert_equal @tsig_contact.class.remote_type, :contact
+  end
+  
+  def test_should_build_create_xml
+    contact_hash = @valid_contact.merge({:add_teams => ['Team A', 'Team B']})
+    request = @tsig_contact.create(contact_hash)
+    doc = REXML::Document.new(request.body)
+    assert_equal "999-999-9999", REXML::XPath.first(doc, "//param[@name='cell_number']").get_text.to_s
+  end
+  
+  def test_should_send_create_request_and_parse_response
+    contact_hash = @valid_contact.merge({:add_teams => ['Team A', 'Team B']})
+    request = @tsig_contact.create(contact_hash)
+    stub(request).send_request{@valid_create_response}
+    content_type, response_hash = @tsig_contact.parse_response(request.send_request)
+    assert_equal content_type, "response"
+    assert_equal response_hash["success"], "1"
+    assert_equal response_hash["contact_id"], "15"
+    # now we fake an error response
+    stub(request).send_request{@error_response}
+    content_type, response_hash = @tsig_contact.parse_response(request.send_request)
+    assert_equal content_type, "error"
+    assert_equal response_hash["error_code"], "10"
+  end
+    
+  def test_should_send_query_and_parse_response
+    request = @tsig_contact.query(:first_name => "John", :last_name => "Test")
+    stub(request).send_request{@valid_query_response}
+    content_type, response_hash = @tsig_contact.parse_response(request.send_request)
+    assert_equal "response", content_type
+    assert_equal response_hash["success"], "1"
+    assert_equal response_hash["contacts"], ["15"]
+  end
+  
+  def test_should_send_delete_and_parse_response
+    request = @tsig_contact.delete(15)
+    stub(request).send_request{@valid_delete_response}
+    content_type, response_hash = @tsig_contact.parse_response(request.send_request)
+    assert_equal "response", content_type
+    assert_equal response_hash["success"], "1"
+  end
+  
+  def test_should_send_update_request_and_parse_response
+    contact_hash = @valid_contact.merge({:add_teams => ['Team A'], :del_teams => ['Team B']})
+    request = @tsig_contact.update(15, contact_hash)
+    stub(request).send_request{@valid_update_response}
+    content_type, response_hash = @tsig_contact.parse_response(request.send_request)
+    assert_equal content_type, "response"
+    assert_equal response_hash["success"], "1"
+    assert_equal response_hash["contact_id"], "15"
+  end
+  
+end