mollie-sms 0.2.1 → 1.0.0

data/README.rdoc

@@ -0,0 +1,104 @@
+A Ruby client that allows you to send SMS messages via
+{http://www.mollie.nl/sms-diensten/sms-gateway Mollie.nl}.
+
+See {Mollie::SMS} for the API documentation. Or, if you are reading this as
+plain text, on {http://rdoc.info/projects/Fingertips/Mollie-SMS rdoc.info}.
+
+See the Mollie.nl API
+{http://www.mollie.nl/support/documentatie/sms-diensten/sms/http/en documentation}
+for more info.
+
+*Note* that it currently only does what we need, for our app, at this point in
+time. Which means that it connects to the webservice via SSL, and only sends a
+message to *one* recipient at a time. Finally, it assumes ActiveSupport is
+available for XML parsing. (A patch that adds a fallback, to REXML, is much
+appreciated.)
+
+= Install
+
+  $ gem install mollie-sms
+
+Or if you have a checkout of the source and have installed Jeweler:
+
+  $ rake install
+
+= Configuration
+
+The minimum required settings are:
+* {Mollie::SMS.username username}
+* {Mollie::SMS.password password}
+* {Mollie::SMS.originator originator}
+
+For example, a Rails initializer might look like:
+
+  module Mollie
+    SMS.username   = 'Fingertips'
+    SMS.password   = 'secret'
+    SMS.originator = 'fngtps.nl'
+  end
+
+= Examples
+
+== Normal usage
+
+  require 'mollie/sms'
+  
+  sms = Mollie::SMS.new('+31681664814', 'You have won a bowl of chicken noodle soup!')
+  => #<Mollie::SMS from: <fngtps.nl> to: <+31681664814> body: "You have won a bowl of chicken noodle soup!">
+  
+  response = sms.deliver # => #<Mollie::SMS::Response succeeded (10) `Message successfully sent.'>
+  
+  response.success? # => true
+  response.result_code # => 10
+  response.message # => "Message successfully sent."
+
+== Test usage
+
+  require 'mollie/sms'
+  require 'mollie/sms/test_helper'
+  
+  Mollie::SMS.http_failure!
+  
+  response = sms.deliver # => #<Mollie::SMS::Response failed (400) `[HTTP: 400] Bad request'>
+  response.success? # => false
+  response.result_code # => 400
+  response.message # => "[HTTP: 400] Bad request"
+  
+  Mollie::SMS.gateway_failure! # => #<Mollie::SMS::Response failed (20) `No username given.'>
+  
+  response = sms.deliver # => #<Mollie::SMS::Response failed (20) `No username given.'>
+  response.success? # => false
+  response.result_code # => 20
+  response.message # => "No username given."
+  
+  Mollie::SMS.deliveries
+  => [#<Mollie::SMS from: <fngtps.nl> to: <+31681664814> body: "You have won a bowl of chicken noodle soup!">,
+      #<Mollie::SMS from: <fngtps.nl> to: <+31681664814> body: "You have won a bowl of chicken noodle soup!">]
+
+= Rails
+
+If you are using Rails and load the Mollie::SMS gem, it will automatically
+require the test helper in test mode.
+
+It also requires the test helper in development mode, so no actual SMS
+messages can be send. Instead, the messages are logged to the
+development.log.
+
+= Contributing
+
+Once you've made your great commits:
+
+1. {http://help.github.com/forking Fork} Mollie-SMS
+2. Create a topic branch
+     git checkout -b my_branch
+3. Push to your branch
+     git push origin my_branch
+4. Create an {http://github.com/Fingertips/Mollie-SMS/issues issue} with a link
+   to your branch
+5. That's it!
+
+= Copyright
+
+Copyright (c) 2010 Eloy Duran, Fingertips <eloy@fngtps.com>
+
+This software is MIT licensed. See {file:LICENSE} for more info.

data/Rakefile

@@ -5,8 +5,18 @@ task :spec do
   sh "ruby ./spec/functional_sms_deliver_spec.rb"
 end
 
+desc "Run the specs with Kicker"
+task :kick do
+  sh "kicker -c -e rake"
+end
+
 task :default => :spec
 
+desc "Generate the docs with YARD"
+task :doc do ||
+  sh "yardoc - README.rdoc LICENSE"
+end
+
 begin
   require 'rubygems'
   require 'jeweler'

data/VERSION

@@ -1 +1 @@
-0.2.1
+1.0.0

data/lib/mollie/sms.rb

@@ -8,10 +8,56 @@ rescue LoadError
 end
 require "active_support"
 
+# The namespace for the Mollie.nl webservices.
+#
+# @see Mollie::SMS
 module Mollie
+  # A class that allows you to send SMS messages through the Mollie.nl SMS
+  # webservice.
+  #
+  # See the {file:README.rdoc README} for examples on how to use this.
+  #
   class SMS
+    # A collection of exception classes raised by Mollie::SMS.
+    module Exceptions
+      # The base class for Mollie::SMS exceptions.
+      class StandardError   < ::StandardError; end
+
+      # The exception class which is used to indicate a validation error of one
+      # of the {SMS#params parameters} that would be send to the gateway.
+      class ValidationError < StandardError; end
+
+      # The exception class which is used to indicate a delivery failure, when
+      # the {SMS#deliver!} method is used and delivery fails.
+      class DeliveryFailure < StandardError
+        # @return [SMS] The Mollie::SMS instance.
+        attr_reader :sms
+
+        # @return [Response] The Mollie::SMS::Response instance.
+        attr_reader :response
+
+        # @param [SMS] sms The Mollie::SMS instance.
+        # @param [Response] response The Mollie::SMS::Response instance.
+        def initialize(sms, response)
+          @sms, @response = sms, response
+        end
+
+        # @return [String] A string representation of the exception.
+        def message
+          "(#{@response.message}) #{@sms.to_s}"
+        end
+      end
+    end
+
+    # The SSL URI to which the parameters of a SMS are posted.
+    #
+    # Note that the certificate is *not* verified.
     GATEWAY_URI = URI.parse("https://secure.mollie.nl/xml/sms")
 
+    # The possible values that indicate which {SMS.gateway= SMS gateway} should
+    # be used.
+    #
+    # @see http://www.mollie.nl/sms-diensten/sms-gateway/gateways
     GATEWAYS = {
       'basic'     => '2',
       'business'  => '4',
@@ -19,31 +65,69 @@ module Mollie
       'landline'  => '8'
     }
 
-    class StandardError        < ::StandardError; end
-    class ValidationError      < StandardError; end
-    class MissingRequiredParam < StandardError; end
-
-    class DeliveryFailure < StandardError
-      attr_reader :sms, :response
-
-      def initialize(sms, response)
-        @sms, @response = sms, response
-      end
-
-      def message
-        "(#{@response.message}) #{@sms.to_s}"
-      end
-    end
-
+    # A list of paramaters that *must* to be included in the
+    # {SMS#params parameters} send to the gateway.
     REQUIRED_PARAMS = %w{ username md5_password originator gateway charset type recipients message }
 
     class << self
-      attr_accessor :username, :password, :originator, :charset, :type, :gateway
+      # @return [String] Your username for the Mollie.nl SMS webservice.
+      attr_accessor :username
 
+      # @return [String] A MD5 hashed version of your password for the
+      #                  Mollie.nl SMS webservice.
+      attr_reader :password
       def password=(password)
         @password = Digest::MD5.hexdigest(password)
       end
 
+      # The number, or display name, that will be used to indicate the
+      # originator of a message.
+      #
+      # It should be upto either fourteen numerical characters, or eleven
+      # alphanumerical characters.
+      #
+      # @see SMS#validate_params!
+      #
+      # @return [String] The originator
+      attr_accessor :originator
+
+      # @return [String] A character set name, describing the message’s body
+      #                  encoding. Defaults to ‘UTF-8’.
+      attr_accessor :charset
+
+      # The type of messages that will be send. Possible values are:
+      # * normal
+      # * wappush
+      # * vcard
+      # * flash
+      # * binary
+      # * long
+      #
+      # Defaults to ‘normal’
+      #
+      # @return [String] The message type.
+      attr_accessor :type
+
+      # The gateway that should be used to send messages. Possible values are:
+      # * {GATEWAYS GATEWAYS['basic']}
+      # * {GATEWAYS GATEWAYS['business']}
+      # * {GATEWAYS GATEWAYS['business+']}
+      # * {GATEWAYS GATEWAYS['landline']}
+      #
+      # Defaults to ‘basic’.
+      #
+      # @see http://www.mollie.nl/sms-diensten/sms-gateway/gateways
+      #
+      # @return [String] The gateway ID.
+      attr_accessor :gateway
+
+      # Returns the default parameters that will be we merged with each
+      # instance’s params.
+      #
+      # This includes +username+, +md5_password+, +originator+, +gateway+,
+      # +charset+, and +type+.
+      #
+      # @return [Hash]
       def default_params
         {
           'username'     => @username,
@@ -60,42 +144,78 @@ module Mollie
     self.type    = 'normal'
     self.gateway = GATEWAYS['basic']
 
+    # @return [Hash] The parameters that will be send to the gateway.
     attr_reader :params
 
+    # Initializes a new Mollie::SMS instance.
+    #
+    # You can either specify the recipient’s telephone number and message
+    # body here, or later on through the accessors for these attributes.
+    #
+    # @param [String] telephone_number The recipient’s telephone number.
+    #
+    # @param [String] body The message body.
+    #
+    # @param [Hash] extra_params Optional parameters that are to be merged with
+    #                            the {SMS.default_params default parameters}.
     def initialize(telephone_number = nil, body = nil, extra_params = {})
       @params = self.class.default_params.merge(extra_params)
       self.telephone_number = telephone_number if telephone_number
       self.body = body if body
     end
 
+    # @return [String] The recipient’s telephone number.
     def telephone_number
       @params['recipients']
     end
 
+    # Assigns the recipient’s telephone number.
+    #
+    # @param [String] telephone_number The recipient’s telephone number.
+    # @return [String] The recipient’s telephone number.
     def telephone_number=(telephone_number)
       @params['recipients'] = telephone_number
     end
 
+    # @return [String] The message body.
     def body
       @params['message']
     end
 
+    # Assigns the message’s body.
+    #
+    # @param [String] body The message’s body.
+    # @return [String] The message’s body.
     def body=(body)
       @params['message'] = body
     end
 
+    # Compares whether or not this and the +other+ Mollie::SMS instance are
+    # equal in recipient, body, and other parameters.
+    #
+    # @param [SMS] other The Mollie::SMS instance to compare against.
+    # @return [Boolean]
     def ==(other)
       other.is_a?(SMS) && other.params == params
     end
 
+    # @return [String] A string representation of this instance.
     def to_s
       %{from: <#{params['originator']}> to: <#{telephone_number}> body: "#{body}"}
     end
 
+    # @return [String] A `inspect' string representation of this instance.
     def inspect
       %{#<#{self.class.name} #{to_s}>}
     end
 
+    # Posts the {#params parameters} to the gateway, through SSL.
+    # 
+    # The params are validated before attempting to post them.
+    # @see #validate_params!
+    #
+    # @return [Response] A response object which encapsulates the result of the
+    #                    request.
     def deliver
       validate_params!
 
@@ -103,60 +223,120 @@ module Mollie
       post.form_data = params
       request = Net::HTTP.new(GATEWAY_URI.host, GATEWAY_URI.port)
       request.use_ssl = true
+      request.verify_mode = OpenSSL::SSL::VERIFY_NONE
       request.start do |http|
         response = http.request(post)
         Response.new(response)
       end
     end
 
+    # Posts the {#params parameters} through {#deliver}, but raises a
+    # DeliveryFailure in case the request fails.
+    #
+    # This happens if an HTTP error occurs, or the gateway didn’t accept the
+    # {#params parameters}.
+    #
+    # @return [Response] Upon success, a response object which encapsulates the
+    #                    result of the request.
+    #
+    # @raise [DeliveryFailure] An exception which encapsulates this {SMS SMS}
+    #                          instance and the {Response} object.
     def deliver!
       response = deliver
-      raise DeliveryFailure.new(self, response) unless response.success?
+      raise Exceptions::DeliveryFailure.new(self, response) unless response.success?
       response
     end
 
+    # Checks if all {REQUIRED_PARAMS required parameters} are present and if
+    # the {SMS.originator} is of the right size.
+    #
+    # @see SMS.originator
+    #
+    # @raise [ValidationError] If any of the validations fail.
+    #
+    # @return [nil]
     def validate_params!
       params.slice(*REQUIRED_PARAMS).each do |key, value|
-        raise MissingRequiredParam, "The required parameter `#{key}' is missing." if value.blank?
+        raise Exceptions::ValidationError, "The required parameter `#{key}' is missing." if value.blank?
       end
 
       originator = params['originator']
       if originator =~ /^\d+$/
         if originator.size > 14
-          raise ValidationError, "Originator may have a maximimun of 14 numerical characters."
+          raise Exceptions::ValidationError, "Originator may have a maximimun of 14 numerical characters."
         end
       elsif originator.size > 11
-        raise ValidationError, "Originator may have a maximimun of 11 alphanumerical characters."
+        raise Exceptions::ValidationError, "Originator may have a maximimun of 11 alphanumerical characters."
       end
     end
 
+    # This class encapsulates the HTTP response and the response from the
+    # gateway. Put shortly, instances of this class return whether or not a SMS
+    # message has been delivered.
     class Response
+      # @return [Net::HTTPResponse] The raw HTTP response object.
       attr_reader :http_response
 
+      # Initializes a new Mollie::SMS::Response instance.
+      #
+      # @param [Net::HTTPResponse] http_response The HTTP response object.
       def initialize(http_response)
         @http_response = http_response
       end
 
+      # @return [Hash] The response parameters from the gateway. Or an empty
+      #                Hash if a HTTP error occurred.
       def params
         @params ||= http_failure? ? {} : Hash.from_xml(@http_response.read_body)['response']['item']
       end
 
+      # Upon success, returns the result code from the gateway. Otherwise the
+      # HTTP response code.
+      #
+      # The possible gateway result codes are:
+      # * 10 - message sent
+      # * 20 - no ‘username’
+      # * 21 - no ‘password’
+      # * 22 - no, or incorrect, ‘originator’
+      # * 23 - no ‘recipients’
+      # * 24 - no ‘message’
+      # * 25 - incorrect ‘recipients’
+      # * 26 - incorrect ‘originator’
+      # * 27 - incorrect ‘message’
+      # * 28 - charset failure
+      # * 29 - parameter failure
+      # * 30 - incorrect ‘username’ or ‘password’
+      # * 31 - not enough credits to send message
+      # * 38 - binary UDH parameter misformed
+      # * 39 - ‘deliverydate’ format is not correct
+      # * 98 - gateway unreachable
+      # * 99 - unknown error
+      #
+      # @return [Integer] The result code from the gateway or HTTP response
+      #                   code.
       def result_code
         (http_failure? ? @http_response.code : params['resultcode']).to_i
       end
 
+      # @return [String] The message from the gateway, or the HTTP message in
+      #                  case of a HTTP error.
+      #
+      # @see #result_code #result_code for a list of possible messages.
       def message
         http_failure? ? "[HTTP: #{@http_response.code}] #{@http_response.message}" : params['resultmessage']
       end
 
+      # @return [Boolean] Whether or not the SMS message has been delivered.
       def success?
         !http_failure? && params['success'] == 'true'
       end
 
+      # @return [Boolean] Whether or not the HTTP request was a success.
       def http_failure?
         !@http_response.is_a?(Net::HTTPSuccess)
       end
 
+      # @return [String] A `inspect' string representation of this instance.
       def inspect
         "#<#{self.class.name} #{ success? ? 'succeeded' : 'failed' } (#{result_code}) `#{message}'>"
       end

data/lib/mollie/sms/test_helper.rb

@@ -1,44 +1,13 @@
 module Mollie
   class SMS
-    def self.deliveries
-      @deliveries ||= []
-    end
-
-    def self.reset!
-      @deliveries = []
-      success!
-    end
-
-    def self.success!
-      http_response = Net::HTTPOK.new('1.1', '200', 'OK')
-      http_response.add_field('Content-type', 'application/xml')
-      def http_response.read_body; TestHelper::SUCCESS_BODY; end
-      @stubbed_response = Mollie::SMS::Response.new(http_response)
-    end
-
-    def self.gateway_failure!
-      http_response = Net::HTTPOK.new('1.1', '200', 'OK')
-      http_response.add_field('Content-type', 'application/xml')
-      def http_response.read_body; TestHelper::FAILURE_BODY; end
-      @stubbed_response = Mollie::SMS::Response.new(http_response)
-    end
-
-    def self.http_failure!
-      @stubbed_response = Mollie::SMS::Response.new(Net::HTTPBadRequest.new('1.1', '400', 'Bad request'))
-    end
-
-    def self.stubbed_response
-      @stubbed_response || success!
-    end
-
-    def deliver
-      validate_params!
-      self.class.deliveries << self
-      self.class.stubbed_response
-    end
-
+    # A collection of helpers for testing the delivery of SMS messages.
+    #
+    # This includes:
+    # * a couple of Test::Unit {Mollie::SMS::TestHelper::Assertions assertions}
+    # * {Mollie::SMS::TestHelper::SMSExt Mollie::SMS} class extensions and
+    #   overrides
     module TestHelper
-        SUCCESS_BODY = %{
+      SUCCESS_BODY = %{
 <?xml version="1.0" ?>
 <response>
     <item type="sms">
@@ -49,7 +18,7 @@ module Mollie
     </item>
 </response>}
 
-        FAILURE_BODY = %{
+      FAILURE_BODY = %{
 <?xml version="1.0"?>
 <response>
   <item type="sms">
@@ -60,17 +29,175 @@ module Mollie
   </item>
 </response>}
 
-      def assert_sms_messages(number_of_messages)
-        before = Mollie::SMS.deliveries.length
-        yield
-        diff = Mollie::SMS.deliveries.length - before
-        assert(diff == number_of_messages, "expected `#{number_of_messages}' SMS messages to be sent, actually sent `#{diff}'")
+      # A couple of Test::Unit assertions, to test the amount of sent messages.
+      module Assertions
+        # Asserts that a specific number of SMS messages have been sent, for the
+        # duration of the given block.
+        #
+        #   def test_invitation_message_is_sent
+        #     assert_sms_messages(1) do
+        #       Account.create(:telephone_number => "+31621212121")
+        #     end
+        #   end
+        #
+        # @yield The context that will be used to check the number of sent
+        #        messages.
+        #
+        # @return [nil]
+        #
+        # @see Mollie::SMS::TestHelper::SMSExt::ClassMethods#deliveries
+        #      Mollie::SMS.deliveries
+        def assert_sms_messages(number_of_messages)
+          before = Mollie::SMS.deliveries.length
+          yield
+          diff = Mollie::SMS.deliveries.length - before
+          assert(diff == number_of_messages, "expected `#{number_of_messages}' SMS messages to be sent, actually sent `#{diff}'")
+        end
+
+        # Asserts that *no* SMS messages have been sent, for the duration of the
+        # given block.
+        #
+        #   def test_no_invitation_message_is_sent_when_account_is_invalid
+        #     assert_no_sms_messages do
+        #       Account.create(:telephone_number => "invalid")
+        #     end
+        #   end
+        #
+        # @yield The context that will be used to check the number of sent
+        #        messages.
+        #
+        # @return [nil]
+        #
+        # @see Mollie::SMS::TestHelper::SMSExt::ClassMethods#deliveries
+        #      Mollie::SMS.deliveries
+        def assert_no_sms_messages
+          assert_sms_messages(0) { yield }
+        end
       end
 
-      def assert_no_sms_messages
-        assert_sms_messages(0) { yield }
+      # Extensions and overrides of the Mollie::SMS class for testing purposes.
+      #
+      # The class method extensions are defined on the
+      # {Mollie::SMS::TestHelper::SMSExt::ClassMethods ClassMethods} module.
+      module SMSExt
+        # @private
+        def self.included(klass)
+          klass.class_eval do
+            undef_method :deliver
+            alias_method :deliver, :test_deliver
+            extend ClassMethods
+          end
+        end
+
+        # Overrides the normal {Mollie::SMS#deliver deliver} method to *never*
+        # make an actual request.
+        #
+        # Instead, the SMS message, that’s to be delivered, is added to the
+        # {Mollie::SMS::TestHelper::SMSExt::ClassMethods#deliveries
+        # Mollie::SMS.deliveries} list for later inspection.
+        #
+        # The parameters are still validated.
+        #
+        # @return [Response] The stubbed Response instance.
+        #
+        # @see Mollie::SMS::TestHelper::SMSExt::ClassMethods#stubbed_response
+        #      Mollie::SMS.stubbed_response
+        def deliver
+          validate_params!
+          self.class.deliveries << self
+          self.class.stubbed_response
+        end
+
+        alias_method :test_deliver, :deliver
+
+        module ClassMethods
+          # @return [Array<Mollie::SMS>] A list of sent SMS messages.
+          #
+          # @see Mollie::SMS::TestHelper::SMSExt#deliver
+          #      Mollie::SMS#deliver
+          def deliveries
+            @deliveries ||= []
+          end
+
+          # Clears the {#deliveries deliveries} list and stubs a {#success!
+          # ‘success’} Response instance.
+          #
+          # @return [Response] The stubbed ‘success’ Response instance.
+          def reset!
+            @deliveries = []
+            success!
+          end
+
+          # Stubs a ‘success’ Response instance.
+          #
+          # This means that any following calls to {Mollie::SMS#deliver} will
+          # succeed and return the stubbed ‘success’ Response instance.
+          #
+          #   Mollie::SMS.success!
+          #   response = Mollie::SMS.new(number, body).deliver
+          #   response.success? # => true
+          #   response.result_code # => 10
+          #   response.message # => "Message successfully sent."
+          #
+          # @return [Response] The stubbed ‘success’ Response instance.
+          def success!
+            http_response = Net::HTTPOK.new('1.1', '200', 'OK')
+            http_response.add_field('Content-type', 'application/xml')
+            # @private
+            def http_response.read_body; TestHelper::SUCCESS_BODY; end
+            @stubbed_response = Mollie::SMS::Response.new(http_response)
+          end
+
+          # Stubs a ‘gateway failure’ Response instance.
+          #
+          # This means that any following calls to {Mollie::SMS#deliver} will
+          # fail at the gateway and return the stubbed ‘gateway failure’
+          # Response instance.
+          #
+          #   Mollie::SMS.gateway_failure!
+          #   response = Mollie::SMS.new(number, body).deliver
+          #   response.success? # => false
+          #   response.result_code # => 20
+          #   response.message # => "No username given."
+          #
+          # @return [Response] The stubbed ‘gateway failure’ Response
+          #                    instance.
+          def gateway_failure!
+            http_response = Net::HTTPOK.new('1.1', '200', 'OK')
+            http_response.add_field('Content-type', 'application/xml')
+            # @private
+            def http_response.read_body; TestHelper::FAILURE_BODY; end
+            @stubbed_response = Mollie::SMS::Response.new(http_response)
+          end
+
+          # Stubs a ‘HTTP failure’ Response instance.
+          #
+          # This means that any following calls to {Mollie::SMS#deliver} will
+          # fail at the HTTP level and return the stubbed ‘HTTP failure’
+          # Response instance.
+          #
+          #   Mollie::SMS.http_failure!
+          #   response = Mollie::SMS.new(number, body).deliver
+          #   response.success? # => false
+          #   response.result_code # => 400
+          #   response.message # => "[HTTP: 400] Bad request"
+          #
+          # @return [Response] The stubbed ‘HTTP failure’ Response
+          #                    instance.
+          def http_failure!
+            @stubbed_response = Mollie::SMS::Response.new(Net::HTTPBadRequest.new('1.1', '400', 'Bad request'))
+          end
+
+          # @return [Response] The stubbed Response instance that will be
+          #                    returned for all requests from
+          #                    {Mollie::SMS#deliver}.
+          def stubbed_response
+            @stubbed_response || success!
+          end
+        end
       end
     end
   end
 end
 
+Mollie::SMS.send(:include, Mollie::SMS::TestHelper::SMSExt)

data/mollie-sms.gemspec

@@ -5,20 +5,20 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mollie-sms}
-  s.version = "0.2.1"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Eloy Duran"]
-  s.date = %q{2010-08-03}
+  s.date = %q{2010-08-06}
   s.description = %q{Send SMS text messages via the Mollie.nl SMS gateway.}
   s.email = ["eloy@fngtps.com"]
   s.extra_rdoc_files = [
     "LICENSE",
-     "README"
+     "README.rdoc"
   ]
   s.files = [
     "LICENSE",
-     "README",
+     "README.rdoc",
      "Rakefile",
      "VERSION",
      "lib/mollie/sms.rb",

data/rails/init.rb

@@ -2,7 +2,7 @@ case Rails.env
 when "test"
   require 'mollie/sms/test_helper'
   require 'active_support/test_case'
-  ActiveSupport::TestCase.send(:include, Mollie::SMS::TestHelper)
+  ActiveSupport::TestCase.send(:include, Mollie::SMS::TestHelper::Assertions)
 when "development"
   require 'mollie/sms/test_helper'
   class Mollie::SMS

data/spec/sms_spec.rb

@@ -110,7 +110,7 @@ describe "When sending a Mollie::SMS message" do
     exception = nil
     begin
       @sms.deliver!
-    rescue Mollie::SMS::DeliveryFailure => exception
+    rescue Mollie::SMS::Exceptions::DeliveryFailure => exception
     end
 
     exception.message.should == "(No username given.) #{@sms.to_s}"
@@ -210,7 +210,7 @@ describe "Mollie::SMS, concerning validation" do
     @sms.params['originator'] = "000000000011112"
     lambda do
       @sms.deliver
-    end.should.raise(Mollie::SMS::ValidationError, "Originator may have a maximimun of 14 numerical characters.")
+    end.should.raise(Mollie::SMS::Exceptions::ValidationError, "Originator may have a maximimun of 14 numerical characters.")
   end
 
   it "accepts an originator of upto 11 alphanumerical characters" do
@@ -222,6 +222,6 @@ describe "Mollie::SMS, concerning validation" do
     @sms.params['originator'] = "0123456789AB"
     lambda do
       @sms.deliver
-    end.should.raise(Mollie::SMS::ValidationError, "Originator may have a maximimun of 11 alphanumerical characters.")
+    end.should.raise(Mollie::SMS::Exceptions::ValidationError, "Originator may have a maximimun of 11 alphanumerical characters.")
   end
 end

data/spec/test_helper_spec.rb

@@ -44,8 +44,8 @@ describe "Mollie::SMS ext" do
   end
 end
 
-describe "Mollie::SMS::TestHelper" do
-  extend Mollie::SMS::TestHelper
+describe "Mollie::SMS::TestHelper::Assertions" do
+  extend Mollie::SMS::TestHelper::Assertions
 
   before do
     Mollie::SMS.reset!

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mollie-sms
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 23
   prerelease: false
   segments: 
-  - 0
-  - 2
   - 1
-  version: 0.2.1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Eloy Duran
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-03 00:00:00 +02:00
+date: 2010-08-06 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,10 +43,10 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README
+- README.rdoc
 files: 
 - LICENSE
-- README
+- README.rdoc
 - Rakefile
 - VERSION
 - lib/mollie/sms.rb

data/README

@@ -1,7 +0,0 @@
-A Ruby client that allows you to send SMS messages via http://mollie.nl.
-
-It does only what we need, for our app, at this point in time. Which means that
-connects to the webservice via SSL, and only sends a message to one recipient
-at a time.
-
-Patches are accepted.