skles 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+pkg
+.rvm
+.idea
+.rvmrc
+.bundle
+
+## PROJECT::DOCUMENTATION
+.yardoc
+doc

data/.rspec

@@ -0,0 +1 @@
+-cfs

data/Gemfile

@@ -0,0 +1,12 @@
+source :rubygems
+
+# DEPENDENCIES
+gem 'savon'
+
+# DEVELOPMENT
+gem 'jeweler'
+gem 'yard'
+gem 'RedCloth', require: 'redcloth'
+
+# TEST
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    RedCloth (4.2.3)
+    builder (2.1.2)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    savon (0.7.9)
+      builder (>= 2.1.2)
+      crack (>= 0.1.4)
+    yard (0.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  RedCloth
+  jeweler
+  rspec
+  savon
+  yard

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tim Morgan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,22 @@
+h1. SKLES: Ruby interface for StrongKey Lite boxes
+
+| *Author* | Tim Morgan |
+| *Version* | Version 1.0 (Nov 13, 2010) |
+| *License* | Released under the MIT license. |
+
+The SKLES gem is an interface to StrongAuth's StrongKey Lite credit card vault
+system (http://www.strongauth.com/). You will need a StrongKey Lite install to
+make any reasonable use of this gem.
+
+
+Usage is simple:
+
+<pre><code>
+require 'skles'
+skles = StrongKeyLite.new('http://your.strongauth.server', your_domain_id)
+skles.add_user('encrypt_only', 'password', :encrypt)
+skles.add_user('decrypt_only', 'password', :decrypt)
+
+skles.encrypt('1234123412341234') #=> token
+skles.decrypt(token) #=> credit card number
+</code></pre>

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+begin
+  require 'bundler'
+rescue LoadError
+  puts "Bundler is not installed; install with `gem install bundler`."
+  exit 1
+end
+
+Bundler.require :default
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "skles"
+  gem.summary = %Q{Ruby interface for SKLES (StrongKey Light Encryption System) boxes}
+  gem.description = %Q{A Ruby wrapper around the StrongKey Lite SOAP client API.}
+  gem.email = "git@timothymorgan.info"
+  gem.homepage = "http://github.com/RISCfuture/skles"
+  gem.authors = [ "Tim Morgan" ]
+  gem.add_dependency 'savon'
+  gem.required_ruby_version = '>= 1.9'
+end
+Jeweler::GemcutterTasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+YARD::Rake::YardocTask.new('doc') do |doc|
+  doc.options << "-m" << "textile"
+  doc.options << "--protected"
+  doc.options << "--no-private"
+  doc.options << "-r" << "README.textile"
+  doc.options << "-o" << "doc"
+  doc.options << "--title" << "Ruby SKLES Documentation".inspect
+
+  doc.files = [ 'lib/**/*', 'README.textile' ]
+end
+
+task(default: :spec)

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/skles.rb

@@ -0,0 +1,153 @@
+require 'savon'
+require File.dirname(__FILE__) + '/skles_api'
+
+# can't have plaintext CC #s being logged
+Savon::Request.log = false
+
+# Client for the StrongKey Lite Encryption System (SKLES) SOAP-based API. An
+# instance of this API interfaces with your StrongKey Lite box to encrypt and
+# decrypt credit card numbers into the vault.
+#
+# Since many StrongKey Lite setups use different logins to perform different
+# tasks (e.g., a more secure login/password is used to decrypt credit cards than
+# to encrypt them), this class supports storing multiple sets of credentials,
+# choosing them depending on the operation being performed.
+#
+# @example Single-user SKLES interface for the test domain
+#   skles = StrongKeyLite.new("https://demo.strongauth.com:8181",               # the URL to the demo StrongKey Lite service
+#                             1,                                                # your domain ID
+#                             login: 'mylogin', password: 'mypassword'          # your API user login and password for the demo box
+#                             http: { verify_mode: OpenSSL::SSL::VERIFY_NONE }, # the demo service has an invalid cert, so we override cert verification
+#
+# @example Multi-user SKLES interface for a production domain
+#   skles = StrongKeyLite.new("https://strongauth.company.com:8181", 15)
+#   skles.add_user 'encrypt_only', 'thepassword', :encrypt, :batch_encrypt
+#   skles.add_user 'decrypt', 'anotherpassword', :decrypt, :batch_decrypt
+
+class StrongKeyLite
+  include API
+
+  # The domain ID of the StrongKey service.
+  attr_accessor :domain_id
+
+  # Creates a new client interface.
+  #
+  # @param [String] service_url The protocol, host, and port for your StrongKey
+  #   Lite service; _e.g._, "http://demo.strongauth.com:8181"
+  # @param [Fixnum] domain_id The domain ID.
+  # @param [Hash] options Additional options.
+  # @option options [String] :login You can provide the login of a user who will
+  #   be used for all actions.
+  # @option options [String] :password The password for this user.
+  # @option options [Hash] :http Additional options to be given to the
+  #   @Net::HTTP@ object. The keys will be invoked as setter methods on the HTTP
+  #   object (_e.g._, passing @http: { timeout: 60 }@ will result in a call like
+  #   @http.timeout = 60@).
+
+  def initialize(service_url, domain_id, options={})
+    @client = Savon::Client.new("#{service_url}/strongkeyliteWAR/EncryptionService?wsdl")
+    options[:http].each { |key, val| @client.request.http.send :"#{key}=", val } if options[:http].kind_of?(Hash)
+
+    self.domain_id = domain_id
+
+    @users = {}
+    @users_for_action = {}
+
+    add_user(options[:login], options[:password], :all) if options[:login] and options[:password]
+  end
+
+  # Adds a user by login and password. These users are used to perform API
+  # actions.
+  #
+  # @overload add_user(login, password)
+  #   Adds a user. You can tell the client to use this user for certain actions
+  #   by calling {#set_user_for_actions}.
+  # @overload add_user(login, password, action, ...)
+  #   Adds a user and tells the client to use this user for the given list of
+  #   actions.
+  #   @param [Symbol] action An API action (such as @:ping@) that this user
+  #     should be used to perform. Replaces the previous user assigned to this
+  #     action.
+  #   @raise [ArgumentError] If an unknown action is provided.
+  # @overload add_user(login, password, :all)
+  #   Adds a user and tells the client to use this user for all API actions.
+  # @param [String] login The user's login.
+  # @param [String] password The user's password.
+
+  def add_user(login, password, *actions_for_user)
+    @users[login] = password
+    if actions_for_user == [ :all ] then
+      actions.each { |action| set_user_for_action(login, action) }
+    else
+      actions_for_user.each { |action| set_user_for_action(login, action) }
+    end
+  end
+
+  # @overload set_user_for_actions(login, action, ...)
+  #   Tells the client to use this user for a list of actions. Calls made via
+  #   the API of one of these actions will use this user. Replaces the previous
+  #   user assigned to these actions.
+  #   @param [String] login The user's login.
+  #   @param [Symbol] the API action (such as @:ping@).
+  # @raise [ArgumentError] If an unknown action is provided.
+
+  def set_user_for_actions(login, *actions_for_user)
+    actions.flatten!
+    raise ArgumentError, "Unknown action(s): #{(actions_for_user - actions).join(',' )}" unless (actions_for_user - actions).empty?
+    actions_for_user.each { |action| @users_for_action[action] = login }
+  end
+  alias_method :set_user_for_action, :set_user_for_actions
+
+  # @return [Array<Symbol>] A list of actions that the API can perform.
+
+  def actions
+    @actions ||= @client.wsdl.soap_actions
+  end
+
+  # Makes an API call and returns the result as a hash. This method is the basis
+  # of all the more high-level API methods.
+  #
+  # @param [Symbol] meth The API method.
+  # @param [Hash] options The arguments for the API method. The @:did@,
+  #   @:login@, and @:password@ arguments are set for you automatically.
+  # @return [Hash] The response fields.
+  # @raise [SOAPError] If a SOAP fault occurs.
+  # @raise [HTTPError] If an HTTP error occurs.
+
+  def call(meth, options={})
+    raise ArgumentError, "Unknown action #{meth.inspect}" unless actions.include?(meth)
+
+    login = @users_for_action[meth]
+    raise "No user has been assigned to action #{meth.inspect}" unless login
+    password = @users[login]
+    
+    response = @client.send(meth) { |soap| soap.body = { did: domain_id, username: login, password: password }.merge(options) }
+    raise SOAPError(response.soap_fault, response) if response.soap_fault?
+    raise HTTPError(response.http_error, response) if response.http_error?
+
+    return response.to_hash
+  end
+
+  # Superclass of all {StrongKeyLite} exceptions.
+
+  class ResponseError < StandardError
+
+    # The @Savon::Response@ object resulting from the API call.
+    attr_reader :response
+
+    # @private
+    def initialize(msg, response)
+      super msg
+      @response = response
+    end
+  end
+
+  # Raised when SOAP responses indicate errors.
+
+  class SOAPError < ResponseError; end
+
+  # Raised when @Net::HTTP@ returns a response other than 200 OK, or there is a
+  # socket error.
+
+  class HTTPError < ResponseError; end
+end

data/lib/skles_api.rb

@@ -0,0 +1,113 @@
+class StrongKeyLite
+
+  # Module included into {StrongKeyLite} with higher-level API actions.
+
+  module API
+
+    # Pings the service and returns information about its health. You must have
+    # a user set for the @:ping@ API action.
+    #
+    # @return [Hash] A hash of service status information (see example).
+    # @example Example response
+    #   { :version => "1.0",
+    #     :build => 40,
+    #     :hostname => "demo.strongauth.com",
+    #     :current_time => #<Time Thu Nov 11 18:52:45 PST 2010>,
+    #     :up_since => #<Time Mon Sep 27 20:58:05 PDT 2010>,
+    #     :well_known_pan => 1235711131719230,
+    #     :encryptions_since_startup => 6,
+    #     :encryptions_total => 17,
+    #     :decryptions_since_startup => 9,
+    #     :decryptions_total => 20,
+    #     :deletions_since_startup => 0,
+    #     :deletions_total => 0,
+    #     :searches_since_startup => 1,
+    #     :searches_total => 3,
+    #     :batch_operations_since_startup => 0,
+    #     :batch_operations_total => 0,
+    #     :domain_id => 21
+    #   }
+
+    def ping
+      msg = call(:ping)[:ping_response][:return]
+      info = Hash.new
+      msg.each_line do |line|
+        if line =~ /^SKLES (.+?) \(Build (\d+)\)$/
+          info[:version] = $1
+          info[:build] = $2.to_i
+        elsif line =~ /^Hostname: (.+?)$/ then
+          info[:hostname] = $1
+        elsif line =~ /^Current time: (.+?)$/ then
+          info[:current_time] = Time.parse($1)
+        elsif line =~ /^Up since: (.+?)$/ then
+          info[:up_since] = Time.parse($1)
+        elsif line =~ /^Well-known PAN: (\d+?)$/ then
+          info[:well_known_pan] = $1.to_i
+        elsif line =~ /^ENC: (\d+)\/(\d+)$/ then
+          info[:encryptions_since_startup] = $1.to_i
+          info[:encryptions_total] = $2.to_i
+        elsif line =~ /^DEC: (\d+)\/(\d+)$/ then
+          info[:decryptions_since_startup] = $1.to_i
+          info[:decryptions_total] = $2.to_i
+        elsif line =~ /^DEL: (\d+)\/(\d+)$/ then
+          info[:deletions_since_startup] = $1.to_i
+          info[:deletions_total] = $2.to_i
+        elsif line =~ /^SRC: (\d+)\/(\d+)$/ then
+          info[:searches_since_startup] = $1.to_i
+          info[:searches_total] = $2.to_i
+        elsif line =~ /^BAT: (\d+)\/(\d+)$/ then
+          info[:batch_operations_since_startup] = $1.to_i
+          info[:batch_operations_total] = $2.to_i
+        elsif line =~ /SKLES Domain (\d+) is (.+?)$/ then
+          info[:domain_id] = $1.to_i
+        end
+      end
+
+      return info
+    end
+
+    # Stores a credit card number (or any other plain text content) to the vault
+    # and returns an obscured token for later retrieval.
+    #
+    # @param [String] plaintext The text to encrypt and store.
+    # @return [String] A token that can be used to {#decrypt} the text. The text
+    #   is not derivable from the token without access to the StrongKey Lite
+    #   server.
+
+    def encrypt(plaintext)
+      call(:encrypt, plaintext: plaintext)[:encrypt_response][:return]
+    end
+
+    # Retrieves a credit card number (or any other encrypted content) from the
+    # vault using a ciphered token generated by a call to {#encrypt}.
+    #
+    # @param [String] token The ciphertext returned from @encrypt@.
+    # @return [String] The text that was encrypted.
+
+    def decrypt(token)
+      call(:decrypt, token: token)[:decrypt_response][:return]
+    end
+
+    # Removes a credit card number (or any other encrypted content) from the
+    # vault.
+    #
+    # @param [String] token The ciphertext returned from {#encrypt}.
+    # @return [true, false] Whether or not the encrypted content was
+    #   successfully deleted.
+
+    def delete(token)
+      call(:delete, token: token)[:delete_response][:return]
+    end
+
+    # Determines if a credit card number (or any other plain text content) is
+    # stored in the vault. If so, returns its token.
+    #
+    # @param [String] plaintext The text to search for.
+    # @return [String, nil] The token for the text, if stored, or @nil@ if no
+    #   such text is stored in the vault.
+
+    def search(plaintext)
+      call(:search, plaintext: plaintext)[:search_response][:return]
+    end
+  end
+end

data/skles.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{skles}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Morgan"]
+  s.date = %q{2010-11-13}
+  s.description = %q{A Ruby wrapper around the StrongKey Lite SOAP client API.}
+  s.email = %q{git@timothymorgan.info}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     ".rspec",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "lib/skles.rb",
+     "lib/skles_api.rb",
+     "skles.gemspec",
+     "spec/skles_api_spec.rb",
+     "spec/skles_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/RISCfuture/skles}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9")
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby interface for SKLES (StrongKey Light Encryption System) boxes}
+  s.test_files = [
+    "spec/skles_api_spec.rb",
+     "spec/skles_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<savon>, [">= 0"])
+    else
+      s.add_dependency(%q<savon>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<savon>, [">= 0"])
+  end
+end
+

data/spec/skles_api_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe StrongKeyLite::API do
+  before :each do
+    @client = mock('Savon::Client', request: nil, wsdl: mock('Savon::WSDL', soap_actions: [ :ping ]))
+    Savon::Client.stub!(:new).and_return(@client)
+    @response = mock('Soap::Response', :soap_fault? => false, :http_error? => false, soap_fault: nil, http_error: nil, to_hash: {})
+    @skles = StrongKeyLite.new('http://test.host', 1, login: 'login', password: 'password')
+  end
+
+  describe "#ping" do
+    before :each do
+      @time = mock('Time')
+      Time.stub!(:parse).and_return(@time)
+      @client.should_receive(:ping).once.and_return(@response)
+    end
+
+    it "should parse the ping response" do
+      ping_response = <<-EOF
+SKLES 1.0 (Build 40)
+Hostname: demo.strongauth.com
+Current time: Sat Nov 13 12:44:03 PST 2010
+Up since: Mon Sep 27 20:58:05 PDT 2010
+Well-known PAN: 1235711131719230
+ENC: 8/19
+DEC: 10/21
+DEL: 1/1
+SRC: 11/13
+BAT: 0/0
+SKLES Domain 21 is alive!
+      EOF
+
+      @response.stub(:to_hash).and_return(ping_response: { return: ping_response })
+      @skles.ping.should eql({ version: "1.0", build: 40, hostname: "demo.strongauth.com",
+                               current_time: @time, up_since: @time,
+                               well_known_pan: 1235711131719230,
+                               encryptions_since_startup: 8, encryptions_total: 19,
+                               decryptions_since_startup: 10, decryptions_total: 21,
+                               deletions_since_startup: 1, deletions_total: 1,
+                               searches_since_startup: 11, searches_total: 13,
+                               batch_operations_since_startup: 0, batch_operations_total: 0,
+                               domain_id: 21 })
+    end
+
+    it "should not error if the response is malformed" do
+      ping_response = <<-EOF
+SKLES 1.0 (Build 40)
+Hostname: demo.strongauth.com
+Current time: Sat Nov 13 12:44:03 PST 2010
+Up since: Mon Sep 27 20:58:05 PDT 2010
+Well-known PAN: 1235711131719230
+ENC: 8/19
+DEL: 1/1
+SRC: 11/13
+BAT: 0/0
+SKLES Domain 21 is alive!
+      EOF
+
+      @response.stub(:to_hash).and_return(ping_response: { return: ping_response })
+      @skles.ping.should eql({ version: "1.0", build: 40, hostname: "demo.strongauth.com",
+                               current_time: @time, up_since: @time,
+                               well_known_pan: 1235711131719230,
+                               encryptions_since_startup: 8, encryptions_total: 19,
+                               deletions_since_startup: 1, deletions_total: 1,
+                               searches_since_startup: 11, searches_total: 13,
+                               batch_operations_since_startup: 0, batch_operations_total: 0,
+                               domain_id: 21 })
+    end
+  end
+
+  describe "#encrypt" do
+    it "should make the appropriate API call" do
+      @skles.stub!(:actions).and_return([ :encrypt ])
+      @skles.add_user('login', 'password', :encrypt)
+
+      @response.stub(:to_hash).and_return(encrypt_response: { return: '123456' })
+      soap = mock('Savon::SOAP')
+      soap.should_receive(:body=).once.with(hash_including(plaintext: 'plaintext'))
+
+      @client.should_receive(:encrypt).once.and_yield(soap).and_return(@response)
+
+      @skles.encrypt('plaintext').should eql('123456')
+    end
+  end
+
+  describe "#decrypt" do
+    it "should make the appropriate API call" do
+      @skles.stub!(:actions).and_return([ :decrypt ])
+      @skles.add_user('login', 'password', :decrypt)
+
+      @response.stub(:to_hash).and_return(decrypt_response: { return: 'plaintext' })
+      soap = mock('Savon::SOAP')
+      soap.should_receive(:body=).once.with(hash_including(token: '123456'))
+
+      @client.should_receive(:decrypt).once.and_yield(soap).and_return(@response)
+
+      @skles.decrypt('123456').should eql('plaintext')
+    end
+  end
+
+  describe "#delete" do
+    it "should make the appropriate API call" do
+      @skles.stub!(:actions).and_return([ :delete ])
+      @skles.add_user('login', 'password', :delete)
+
+      @response.stub(:to_hash).and_return(delete_response: { return: true })
+      soap = mock('Savon::SOAP')
+      soap.should_receive(:body=).once.with(hash_including(token: '123456'))
+
+      @client.should_receive(:delete).once.and_yield(soap).and_return(@response)
+
+      @skles.delete('123456').should be_true
+    end
+  end
+
+  describe "#search" do
+    it "should make the appropriate API call" do
+      @skles.stub!(:actions).and_return([ :search ])
+      @skles.add_user('login', 'password', :search)
+
+      @response.stub(:to_hash).and_return(search_response: { return: '123456' })
+      soap = mock('Savon::SOAP')
+      soap.should_receive(:body=).once.with(hash_including(plaintext: 'plaintext'))
+
+      @client.should_receive(:search).once.and_yield(soap).and_return(@response)
+
+      @skles.search('plaintext').should eql('123456')
+    end
+  end
+end

data/spec/skles_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe StrongKeyLite do
+  before :each do
+    @client = mock('Savon::Client', request: nil)
+    Savon::Client.stub!(:new).and_return(@client)
+  end
+
+  describe "#initialize" do
+    it "should accept a host for the WSDL" do
+      Savon::Client.should_receive(:new).once.with("http://test.host/strongkeyliteWAR/EncryptionService?wsdl").and_return(@client)
+      StrongKeyLite.new('http://test.host', 1)
+    end
+
+    it "should set the domain ID" do
+      StrongKeyLite.new('http://test.host', 15).domain_id.should eql(15)
+    end
+
+    it "should accept and apply HTTP options" do
+      http = mock('Net::HTTP')
+      request = mock('Savon::Request', http: http)
+      @client.stub!(:request).and_return(request)
+
+      http.should_receive(:timeout=).once.with(60)
+      StrongKeyLite.new('http://test.host', 1, http: { timeout: 60 })
+    end
+
+    it "should optionally accept a login and password" do
+      pending "Need a good way to test this"
+    end
+  end
+
+  describe "#call" do
+    before :each do
+      @client = mock('Savon::Client', request: nil, wsdl: mock('Savon::WSDL', soap_actions: [ :ping ]))
+      Savon::Client.stub!(:new).and_return(@client)
+      @skles = StrongKeyLite.new('http://test.host', 1)
+
+      @response = mock('Soap::Response', :soap_fault? => false, :http_error? => false, soap_fault: nil, http_error: nil, to_hash: {})
+      @response.stub(:to_hash).and_return(ping_response: { return: '' })
+    end
+
+    it "should raise an error if no user has been assigned to the action" do
+      -> { @skles.ping }.should raise_error(/No user/)
+    end
+
+    it "should invoke the proper action on the Savon client and use the appropriate user" do
+      @skles.add_user('login', 'password', :ping)
+      
+      soap = mock('Savon::Request')
+      soap.should_receive(:body=).once.with({ did: 1, username: 'login', password: 'password' })
+      @client.should_receive(:ping).once.and_yield(soap).and_return(@response)
+      @skles.ping
+    end
+
+    it "should assign a user to all actions when given :all" do
+      @skles.add_user('all', 'password', :all)
+
+      soap = mock('Savon::Request')
+      soap.should_receive(:body=).once.with({ did: 1, username: 'all', password: 'password' })
+      @client.should_receive(:ping).once.and_yield(soap).and_return(@response)
+      @skles.ping
+    end
+
+    it "should replace an older user assigned to an action" do
+      @skles.add_user('all', 'password', :all)
+      @skles.add_user('ping', 'password', :ping)
+
+      soap = mock('Savon::Request')
+      soap.should_receive(:body=).once.with({ did: 1, username: 'ping', password: 'password' })
+      @client.should_receive(:ping).once.and_yield(soap).and_return(@response)
+      @skles.ping
+    end
+  end
+
+  describe "#actions" do
+    before :each do
+      @wsdl = mock('Savon::WSDL')
+      @client = mock('Savon::Client', request: nil, wsdl: @wsdl)
+      Savon::Client.stub!(:new).and_return(@client)
+      @skles = StrongKeyLite.new('http://test.host', 1)
+    end
+
+    it "should return a list of SOAP actions" do
+      @wsdl.should_receive(:soap_actions).once.and_return([ :one, :two, :three ])
+      @skles.actions.should eql([ :one, :two, :three ])
+    end
+
+    it "should cache the list" do
+      @wsdl.should_receive(:soap_actions).once.and_return([ :one, :two, :three ])
+      @skles.actions.should eql([ :one, :two, :three ])
+
+      @wsdl.should_not_receive(:soap_actions)
+      @skles.actions.should eql([ :one, :two, :three ])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+Bundler.require :test
+require 'skles'
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: skles
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-13 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: savon
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+description: A Ruby wrapper around the StrongKey Lite SOAP client API.
+email: git@timothymorgan.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION
+- lib/skles.rb
+- lib/skles_api.rb
+- skles.gemspec
+- spec/skles_api_spec.rb
+- spec/skles_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/RISCfuture/skles
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      version: "1.9"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby interface for SKLES (StrongKey Light Encryption System) boxes
+test_files: 
+- spec/skles_api_spec.rb
+- spec/skles_spec.rb
+- spec/spec_helper.rb