mote_sms 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - jruby-19mode
+  - rbx-19mode
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mobiletechnics_client.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 at-point ag, Lukas Westermann, http://at-point.ch/
+
+MIT License
+
+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.md

@@ -0,0 +1,59 @@
+# MobileTechnics SMS API Client
+
+Unofficial ruby adapter for MobileTechnics HTTP Bulk SMS API. Tries to mimick
+mail API, so users can switch e.g. ActionMailer with this SMS provider. Requires
+Ruby 1.9.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mote_sms'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mote_sms
+
+## Usage
+
+```ruby
+# Quick and dirty
+MoteSMS.transport = MoteSMS::MobileTechnicsTransport.new 'https://endpoint.com:1234', 'username', 'password'
+MoteSMS.deliver do
+  body 'Quick hello world'
+  to '+41 79 111 22 33'
+  from 'ARUBYGEM'
+end
+```
+
+```ruby
+# Using global transport
+MoteSMS.transport = MoteSMS::MobileTechnicsTransport.new 'https://endpoint.com:1234', 'username', 'password'
+sms = MoteSMS.Message.new do
+ to '+41 79 111 22 33'
+ from 'ARUBYGEM'
+ body 'Hello world, you know.'
+end
+sms.deliver
+```
+
+```ruby
+# Using client instance
+transport = MoteSMS::MobileTechnicsTransport.new 'https://endpoint.com:1234', 'username', 'password'
+sms = MoteSMS.Message.new do
+  # create message
+end
+sms.deliver(transport: transport)
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec)

data/lib/mote_sms/message.rb

@@ -0,0 +1,102 @@
+require 'mote_sms/number'
+require 'mote_sms/number_list'
+
+module MoteSMS
+
+  # Represents an SMS message, currently only provides the
+  # tools to build new messages, not parse incoming messages or
+  # similar stuff.
+  #
+  class Message
+
+    # The transport instance to use, if not defined
+    # falls back to use global MoteSMS.transport instance.
+    attr_accessor :transport
+
+    # Public: Create a new SMS message instance.
+    #
+    # Examples:
+    #
+    #    sms = MoteSMS::Message.new do
+    #      from '41791112233'
+    #      to '41797776655'
+    #      body 'Hi there.'
+    #    end
+    #    sms.from # => '41791112233'
+    #    sms.to # => ['41797776655']
+    #    sms.body # => 'Hi there.'
+    #
+    # Returns a new instance.
+    def initialize(transport = nil, &block)
+      @transport = transport
+      @to = MoteSMS::NumberList.new
+      instance_eval(&block) if block_given?
+    end
+
+    # Public: Returns current SMS message body, which should
+    # be something stringish.
+    #
+    # Returns value of body.
+    attr_writer :body
+    def body(val = nil)
+      @body = val if val
+      @body
+    end
+
+    # Public: Returns string of sender, the sender should
+    # either be 11 alphanumeric characters or 20 numbers.
+    #
+    # Examples:
+    #
+    #    sms.from = '41791231234'
+    #    sms.from # => '41791231234'
+    #
+    # Returns value of sender.
+    def from(val = nil)
+      self.from = val if val
+      @from
+    end
+
+    # Public: Asign an instance of Number instead of the direct
+    # string, so only vanity numbers are allowed.
+    def from=(val)
+      @from = val ? Number.new(val, :vanity => true) : nil
+    end
+
+    # Public: Set to multiple arguments or array, or whatever.
+    #
+    # Examples:
+    #
+    #   sms.to = '41791231212'
+    #   sms.to # => ['41791231212']
+    #
+    #   sms.to = ['41791231212', '41791231212']
+    #   sms.to # => ['41791231212', '41791231212']
+    #
+    # Returns nothing.
+    def to=(*args)
+      @to = MoteSMS::NumberList.new.push(*args)
+    end
+
+    # Public: Returns NumberList for this message.
+    #
+    # Returns NumberList instance.
+    def to(*numbers)
+      @to.push(*numbers) unless numbers.empty?
+      @to
+    end
+
+    # Public: Deliver message using defined transport, to select the correct
+    # transport method uses any of these values:
+    #
+    # 1. if options[:transport] is defined
+    # 2. falls back to self.transport
+    # 3. falls back to use MoteSMS.transport (global transport)
+    #
+    # Returns result of transport#deliver.
+    def deliver(options = {})
+      transport = options.delete(:transport) || self.transport || MoteSMS.transport
+      transport.deliver(self, options)
+    end
+  end
+end

data/lib/mote_sms/number.rb

@@ -0,0 +1,53 @@
+require 'phony'
+
+module MoteSMS
+
+  # MoteSMS::Number handles all the number parsing and formatting
+  # issues, also a number is immutable.
+  class Number
+
+    # Access the E164 normalized value of the number.
+    attr_reader :number
+    alias :to_number :number
+
+    def initialize(value, options = {})
+      @options = options || {}
+      @raw_number = value.to_s
+      parse_raw_number
+    end
+
+    # Public: Returns true if this **could** represent a vanity number.
+    #
+    # Returns Boolean, true if this is a vanity number, else false.
+    def vanity?
+      !!@options[:vanity]
+    end
+
+    # Public: Prints formatted number, i.e. the human readable
+    # variant.
+    #
+    # Returns formatted number.
+    def to_s
+      @formatted_number ||= vanity? ? number : Phony.formatted(number)
+    end
+
+    protected
+
+    # Internal: Parse raw number with the help of Phony. Automatically
+    # adds the country code if missing.
+    #
+    def parse_raw_number
+      unless vanity?
+        raise ArgumentError, "Unable to parse #{@raw_number} as number" unless Phony.plausible?(@raw_number)
+        normalized = Phony.normalize(@raw_number)
+        normalized = "#{@options[:cc]}#{normalized}" unless @options[:cc] && normalized.start_with?(@options[:cc])
+        raise ArgumentError, "Wrong national destination code #{@raw_number}" unless Phony.plausible?(normalized, @options)
+
+        @number = Phony.normalize normalized
+      else
+        @number = @raw_number.gsub(/[^A-Z0-9]/i, '').upcase.strip
+        raise ArgumentError, "Invalid vanity number #{@raw_number}" if @number.length == 0 || @number.length > 11
+      end
+    end
+  end
+end

data/lib/mote_sms/number_list.rb

@@ -0,0 +1,84 @@
+require 'mote_sms/number'
+
+module MoteSMS
+
+  # List of Number instances, which transparantly is able to add
+  # new Number instances from strings, or whatever.
+  #
+  # Implements Enumerable, thus can be used like any regular array.
+  #
+  # Examples:
+  #
+  #    list << '+41 79 123 12 12'
+  #    list.push '044 123 12 12', cc: '41'
+  #    list.push Number.new('0800 123 12 12')
+  #    list.normalized_numbers
+  #    # => ['41791231212', '41441231212', '08001231212']
+  #
+  class NumberList
+
+    # Load ruby enumerable support.
+    include ::Enumerable
+
+    # Internal numbers array.
+    attr_reader :numbers
+
+    # Public: Create a new number list instance.
+    def initialize
+      @numbers = ::Array.new
+    end
+
+    # Public: Count of numbers in the list.
+    def length
+      numbers.length
+    end
+    alias :size :length
+
+    # Public: Conform to arrayish behavior.
+    def empty?
+      numbers.empty?
+    end
+    alias :blank? :empty?
+
+    # Public: Add number to internal list, use duck typing to detect if
+    # it appears to be a number instance or not. So everything which does
+    # not respond to `to_number` is converted into a Number instance.
+    #
+    # number - The Number or String to add.
+    #
+    # Returns nothing.
+    def <<(number)
+      self.push(number)
+    end
+
+    # Public: Add multiple numbers, with optional options hash which can
+    # be used to set country options etc.
+    #
+    # Returns self.
+    def push(*numbers)
+      options = numbers.last.is_a?(Hash) ? numbers.pop : {}
+      numbers.flatten.each do |number|
+        number = Number.new(number, options) unless number.respond_to?(:to_number)
+        self.numbers << number
+      end
+      self
+    end
+
+    # Public: Yields each Number instance from this number list
+    # to the provided block. This interface is also required to be
+    # implemeneted for Enumerable support.
+    #
+    # Returns self.
+    def each(&block)
+      numbers.each(&block)
+      self
+    end
+
+    # Public: Fetch numbers using to_number.
+    #
+    # Returns Array of E164 normalized numbers.
+    def normalized_numbers
+      numbers.map(&:to_number)
+    end
+  end
+end

data/lib/mote_sms/transports/mobile_technics_transport.rb

@@ -0,0 +1,185 @@
+require 'uri'
+require 'net/http'
+require 'phony'
+require 'logger'
+
+module MoteSMS
+
+  # MoteSMS::MobileTechnicsTransport provides the implementation to
+  # send messages using nth.ch bulk SMS HTTP/S API. Each customer has
+  # custom endpoint (with port) and username/password.
+  #
+  # Examples:
+  #
+  #    transport = MoteSMS::MobileTechnicsTransport.new 'https://mygateway.nth.ch', 'username', 'password'
+  #    transport.deliver message
+  #    # => ['000-791234', '001-7987324']
+  #
+  class MobileTechnicsTransport
+
+    # Maximum recipients allowed by API
+    MAX_RECIPIENT = 100
+
+    # Custom exception subclass.
+    ServiceError = Class.new(::Exception)
+
+    # Accessible attributes
+    attr_accessor :endpoint, :username, :password, :logger
+
+    # Options are readable as hash
+    attr_reader :options
+
+    # Public: Global default parameters for sending messages, Procs/lambdas
+    # are evaluated on #deliver. Ensure to use only symbols as keys. Contains
+    # `allow_adaption: true` as default.
+    #
+    # Examples:
+    #
+    #    MoteSMS::MobileTechnicsTransports.defaults[:messageid] = ->(msg) { "#{msg.from}-#{SecureRandom.hex}" }
+    #
+    # Returns Hash with options.
+    def self.defaults
+      @@options ||= {
+        allow_adaption: true
+      }
+    end
+
+    # Public: Logger used to log HTTP requests to mobile
+    # technics API endpoint.
+    #
+    # Returns Logger instance.
+    def self.logger
+      @@logger ||= ::Logger.new($stdout)
+    end
+
+    # Public: Change the logger used to log all HTTP requests to
+    # the endpoint.
+    #
+    # logger - The Logger instance, should at least respond to #debug, #error.
+    #
+    # Returns nothing.
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+    # Public: Create a new instance using specified endpoint, username
+    # and password.
+    #
+    # endpoint - The String with the URL (with protocol et all) to nth gateway.
+    # username - The String with username.
+    # password - The String with password.
+    # options - The Hash with additional options.
+    #
+    # Returns a new instance.
+    def initialize(endpoint, username, password, options = nil)
+      self.endpoint = endpoint
+      self.username = username
+      self.password = password
+      @options = options || {}
+    end
+
+    # Public: Delivers message using mobile technics HTTP/S API.
+    #
+    # message - The MoteSMS::Message instance to send.
+    # options - The Hash with service specific options.
+    #
+    # Returns Array with sender ids.
+    def deliver(message, options = {})
+      raise ArgumentError, "Too many recipients, max. is #{MAX_RECIPIENT} (current: #{message.to.length})" if message.to.length > MAX_RECIPIENT
+
+      # Prepare request
+      uri = URI.parse endpoint
+      http = http_client uri
+      request = http_request uri, post_params(message, options)
+
+      # Log
+      self.class.logger.debug "curl -X#{request.method} #{http.use_ssl? ? '-k ' : ''}'#{endpoint}' -d '#{request.body}'"
+
+      # Perform request
+      resp = http.request request
+
+      # Handle errors
+      raise ServiceError, "Endpoint did respond with #{resp.code}" unless resp.code.to_i == 200
+      raise ServiceError, "Endpoint was unable to deliver message to all recipients" unless resp.body.split("\n").all? { |l| l =~ /Result_code: 00/ }
+
+      # extract Nth-SmsIds
+      resp['X-Nth-SmsId'].split(',')
+    end
+
+    protected
+
+    # Internal: Prepare request including body, headers etc.
+    #
+    # uri - The URI from the endpoint.
+    # params - The Array with the attributes.
+    #
+    # Returns Net::HTTP::Post instance.
+    def http_request(uri, params)
+      Net::HTTP::Post.new(uri.request_uri).tap do |request|
+        request.body = URI.encode_www_form params
+        request.content_type = 'application/x-www-form-urlencoded; charset=utf-8'
+      end
+    end
+
+    # Internal: Build new Net::HTTP instance, enables SSL if requested.
+    # FIXME: Add ability to change verify_mode, so e.g. certificates can be
+    # verified!
+    #
+    # uri - The URI from the endpoint.
+    #
+    # Returns Net::HTTP client instance.
+    def http_client(uri)
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        # SSL support
+        if uri.instance_of?(URI::HTTPS)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+    end
+
+    # Internal: Merge defaults from class and instance with options
+    # supplied to #deliver.
+    #
+    # options - The Hash to merge with #defaults and #options.
+    #
+    # Returns Hash.
+    def prepare_options(options)
+      self.class.defaults.merge(self.options).merge(options)
+    end
+
+    # Internal: Convert NumberList instance to ; separated string with international
+    # relative formatted numbers. Formatting is done using phony.
+    #
+    # number_list - The NumberList instance.
+    #
+    # Returns String with numbers separated by ;.
+    def prepare_numbers(number_list)
+      number_list.normalized_numbers.map { |n| Phony.formatted(n, format: :international_relative, spaces: '') }.join(';')
+    end
+
+    # Internal: Prepare parameters for sending POST to endpoint, merges defaults,
+    # local and per call options, adds message related informations etc etc.
+    #
+    # message - The MoteSMS::Message to create the POST body for.
+    # options - The Hash with additional, per delivery options.
+    #
+    # Returns Array with params.
+    def post_params(message, options)
+      params = prepare_options options
+      params.merge! username: self.username,
+                    password: self.password,
+                    origin: message.from ? message.from.to_number : params[:origin],
+                    text: message.body,
+                    :'call-number' => prepare_numbers(message.to)
+
+      # Post process params (Procs & allow_adaption)
+      params.map do |param, value|
+        value = value.call(message) if value.respond_to?(:call)
+        value = value ? 1 : 0 if param == :allow_adaption
+
+        [param.to_s, value.to_s]
+      end
+    end
+  end
+end

data/lib/mote_sms/transports/test_transport.rb

@@ -0,0 +1,40 @@
+module MoteSMS
+
+  # Public: Provide access to global array of delivered
+  # messages, this can be used in testing to assert sent
+  # SMS messages, test their contents, recipients etc.
+  #
+  # Must be cleared manually (!)
+  @@deliveries = []
+  def self.deliveries
+    @@deliveries
+  end
+
+  # MoteSMS::TestTransport provides a transport implementation which
+  # can be used in test cases. This allows to test sending SMSes
+  # et all without depending on an API or accidentally sending out
+  # messages to real people.
+  #
+  # It works similar to testing ActionMailers, all delivered messages
+  # will be appended to `MoteSMS.deliveries`. This array must be
+  # cleared manually, so it makes sense to add a before hook to
+  # your favorite testing framework:
+  #
+  #    before do
+  #      MoteSMS.transport = MoteSMS::TestTransport
+  #      MoteSMS.deliveries.clear
+  #    end
+  #
+  module TestTransport
+
+    # Public: Appends supplied message to global deliveries array.
+    #
+    # message - The MoteSMS::Message instance to deliver.
+    # options - The Hash with additional, transport specific options.
+    #
+    # Returns nothing.
+    def self.deliver(message, options = {})
+      MoteSMS.deliveries << message
+    end
+  end
+end

data/lib/mote_sms/transports.rb

@@ -0,0 +1,7 @@
+module MoteSMS
+
+  # All transports live within mote_sms/transports, though should be
+  # available in ruby as `MoteSMS::<Some>Transport`.
+  autoload :TestTransport, 'mote_sms/transports/test_transport'
+  autoload :MobileTechnicsTransport, 'mote_sms/transports/mobile_technics_transport'
+end

data/lib/mote_sms/version.rb

@@ -0,0 +1,3 @@
+module MoteSMS
+  VERSION = "1.0.0"
+end

data/lib/mote_sms.rb

@@ -0,0 +1,45 @@
+require 'mote_sms/transports'
+
+module MoteSMS
+  autoload :Number,     'mote_sms/number'
+  autoload :NumberList, 'mote_sms/number_list'
+  autoload :Message,    'mote_sms/message'
+
+  autoload :VERSION,    'mote_sms/version'
+
+  # No default transport.
+  @@transport = nil
+
+  # Public: Get globally defined transport method, if any.
+  # Defaults to `nil`.
+  #
+  # Returns global SMS transport method.
+  def self.transport
+    @@transport
+  end
+
+  # Public: Set global transport method to use.
+  #
+  # transport - Any object which implements `#deliver(message, options)`.
+  #
+  # Returns nothing.
+  def self.transport=(transport)
+    @@transport = transport
+  end
+
+  # Public: Directly deliver a message using global transport.
+  #
+  # Examples:
+  #
+  #    MoteSMS.deliver do
+  #      to '0041 79 123 12 12'
+  #      from 'SENDER'
+  #      body 'Hello world'
+  #    end
+  #
+  # Returns result of #deliver.
+  def self.deliver(&block)
+    raise ArgumentError, 'Block missing' unless block_given?
+    Message.new(&block).deliver
+  end
+end

data/mote_sms.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mote_sms/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mote_sms'
+  gem.authors       = ['Lukas Westermann']
+  gem.email         = ['lukas.westermann@at-point.ch']
+  gem.summary       = %q{Deliver SMS using MobileTechnics HTTP API.}
+  gem.description   = %q{Unofficial ruby adapter for MobileTechnics HTTP Bulk SMS API.
+                         Tries to mimick mail API, so users can switch e.g. ActionMailer
+                         with this SMS provider.}
+  gem.homepage      = 'https://at-point.ch/opensource'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = %w{lib}
+  gem.version       = MoteSMS::VERSION
+
+  gem.required_ruby_version = '>= 1.9'
+
+  gem.add_dependency 'phony', ['~> 1.7.0']
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec', ['~> 2.10']
+  gem.add_development_dependency 'webmock', ['~> 1.8.0']
+end

data/spec/mote_sms/message_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'mote_sms/message'
+
+describe MoteSMS::Message do
+  it 'can be constructed using a block' do
+    msg = described_class.new do
+      from 'SENDER'
+      to '+41 79 123 12 12'
+      body 'This is the SMS content'
+    end
+    msg.from.number.should == 'SENDER'
+    msg.to.normalized_numbers.should == %w{41791231212}
+    msg.body.should == 'This is the SMS content'
+  end
+
+  context '#to' do
+    it 'behaves as accessor' do
+      subject.to = '41791231212'
+      subject.to.normalized_numbers.should == %w{41791231212}
+    end
+
+    it 'behaves as array' do
+      subject.to << '41791231212'
+      subject.to << '41797775544'
+      subject.to.normalized_numbers.should == %w{41791231212 41797775544}
+    end
+
+    it 'normalizes numbers' do
+      subject.to = '+41 79 123 12 12'
+      subject.to.normalized_numbers.should == %w{41791231212}
+    end
+  end
+
+  context "#deliver" do
+    let(:transport) { double("Some Transport") }
+    subject { described_class.new(transport) }
+
+    it "sends messages to transport" do
+      transport.should_receive(:deliver).with(subject, {})
+      subject.deliver
+    end
+
+    it "can pass additional attributes to transport" do
+      transport.should_receive(:deliver).with(subject, serviceid: "myapplication")
+      subject.deliver serviceid: "myapplication"
+    end
+
+    it "can override per message transport using :transport option" do
+      transport.should_not_receive(:deliver)
+      subject.deliver transport: double(deliver: true)
+    end
+
+    it "uses global MoteSMS.transport if no per message transport defined" do
+      message = described_class.new
+      transport.should_receive(:deliver).with(message, {})
+      MoteSMS.should_receive(:transport) { transport }
+      message.deliver
+    end
+  end
+end

data/spec/mote_sms/number_list_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'mote_sms/number_list'
+
+describe MoteSMS::NumberList do
+  it 'has length' do
+    subject.length.should == 0
+    subject << '+41 79 111 22 33'
+    subject.length.should == 1
+    5.times { subject << '+41 79 222 33 44' }
+    subject.length.should == 6
+  end
+
+  it 'has empty?' do
+    subject.empty?.should be_true
+    subject << '+41 79 111 22 33'
+    subject.empty?.should be_false
+  end
+
+  it 'can add numbers by string' do
+    subject << '+41 79 111 22 33'
+    subject.normalized_numbers.should == %w{41791112233}
+  end
+
+  it 'can multiple numbers using push' do
+    subject.push '+41 79 111 22 33', '+41 44 111 22 33'
+    subject.normalized_numbers.should == %w{41791112233 41441112233}
+  end
+
+  it 'can push multiple numbers with adding country codes' do
+    subject.push '079 111 22 33', '0041 44 111 22 33', cc: '41', ndc: /(44|79)/
+    subject.normalized_numbers.should == %w{41791112233 41441112233}
+  end
+end

data/spec/mote_sms/number_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'mote_sms/number'
+
+describe MoteSMS::Number do
+  context 'normalized number' do
+    subject { described_class.new('41443643533') }
+
+    its(:to_s) { should == '+41 44 364 35 33' }
+    its(:number) { should == '41443643533' }
+    its(:to_number) { should == '41443643533' }
+  end
+
+  context 'E164 conforming number' do
+    subject { described_class.new('+41 44 3643533') }
+
+    its(:to_s) { should == '+41 44 364 35 33' }
+    its(:number) { should == '41443643533' }
+    its(:to_number) { should == '41443643533' }
+  end
+
+  context 'E164 conforming number with name' do
+    subject { described_class.new('Frank: +41 44 3643533', cc: '41') }
+
+    its(:to_s) { should == '+41 44 364 35 33' }
+    its(:number) { should == '41443643533' }
+    its(:to_number) { should == '41443643533' }
+  end
+
+  context 'handles local numbers' do
+    subject { described_class.new('079 700 50 90', cc: '41') }
+
+    its(:to_s) { should == '+41 79 700 50 90' }
+    its(:number) { should == '41797005090'}
+    its(:to_number) { should == '41797005090' }
+  end
+
+  context 'non conforming number' do
+    it 'raises error when creating' do
+      Proc.new { described_class.new('what ever?') }.should raise_error(ArgumentError, /unable to parse/i)
+      Proc.new { described_class.new('0000') }.should raise_error(ArgumentError, /unable to parse/i)
+      Proc.new { described_class.new('123456789012345678901') }.should raise_error(ArgumentError, /unable to parse/i)
+    end
+  end
+
+  context 'wrong cc/ndc' do
+    it 'raises error when creating instance with wrong ndc' do
+      Proc.new { described_class.new('+41 44 364 35 33', cc: '41', ndc: '43') }.should raise_error(ArgumentError, /national destination/i)
+    end
+  end
+
+  context 'vanity numbers' do
+    subject { described_class.new('0800-vanity', vanity: true) }
+
+    its(:to_s) { should == '0800VANITY' }
+    its(:number) { should == '0800VANITY' }
+    its(:to_number) { should == '0800VANITY' }
+    its(:vanity?) { should be_true }
+
+    it 'raises error if more than 11 alpha numeric chars' do
+      Proc.new { described_class.new('1234567890AB', vanity: true) }.should raise_error(ArgumentError, /invalid vanity/i)
+    end
+
+    it 'can also be normal phone number' do
+      num = described_class.new('0800 123 12 12', vanity: true)
+      num.to_s.should == '08001231212'
+      num.to_number.should == '08001231212'
+    end
+  end
+end

data/spec/mote_sms/transports/mobile_technics_transport_spec.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'cgi'
+require 'mote_sms/message'
+require 'mote_sms/transports/mobile_technics_transport'
+
+describe MoteSMS::MobileTechnicsTransport do
+  before do
+    @logger = described_class.logger
+    described_class.logger = stub(debug: true, info: true, error: true)
+  end
+
+  after do
+    described_class.logger = @logger
+  end
+
+  subject { described_class.new(endpoint, "example", "123456") }
+
+  let(:endpoint) { "http://test.nth.ch" }
+  let(:message) {
+    MoteSMS::Message.new do
+      to '0041 079 123 12 12'
+      from 'SENDER'
+      body 'Hello World, with äöü.'
+    end
+  }
+
+  let(:success) {
+    { body: "Result_code: 00, Message OK", status: 200, headers: { 'X-Nth-SmsId' => '43797917' } }
+  }
+
+  context "#deliver" do
+    it "sends POST to endpoint with URL encoded body" do
+      stub_request(:post, endpoint).with do |req|
+        params = CGI.parse(req.body)
+        params['username'].should == %w{example}
+        params['password'].should == %w{123456}
+        params['text'].should == ['Hello World, with äöü.']
+        params['call-number'].should == ['0041791231212']
+      end.to_return(success)
+      subject.deliver message
+    end
+
+    it 'sends message in single request to multiple recipients' do
+      message.to << '+41 79 333 44 55'
+      message.to << '+41 78 111 22 33'
+
+      stub_request(:post, endpoint).with(body: hash_including('call-number' => '0041791231212;0041793334455;0041781112233')).to_return(success)
+      subject.deliver message
+    end
+
+    it 'raises exception if required parameter is missing' do
+      stub_request(:post, endpoint).to_return(body: 'Result_code: 02, call-number')
+      Proc.new { subject.deliver message }.should raise_error(MoteSMS::MobileTechnicsTransport::ServiceError)
+    end
+
+    it 'raises exception if status code is not 200' do
+      stub_request(:post, endpoint).to_return(status: 500)
+      Proc.new { subject.deliver message }.should raise_error(MoteSMS::MobileTechnicsTransport::ServiceError)
+    end
+
+    it 'returns message id' do
+      stub_request(:post, endpoint).to_return(success)
+      subject.deliver(message).should == %w{43797917}
+    end
+
+    it 'logs curl compatible output' do
+      io = StringIO.new
+      described_class.logger = Logger.new(io)
+      stub_request(:post, endpoint).to_return(success)
+      subject.deliver message
+      io.rewind
+      io.read.should =~ %r{curl -XPOST 'http://test.nth.ch' -d 'allow_adaption=1&}
+    end
+  end
+
+  context "#options" do
+    it 'can be passed in as last item in the constructor' do
+      transport = described_class.new endpoint, 'user', 'pass', allow_adaption: false, validity: 30
+      transport.options[:allow_adaption].should be_false
+      transport.options[:validity].should == 30
+      transport.options[:something].should be_nil
+    end
+
+    it 'should be exposed as hash' do
+      subject.options[:messageid] = "test"
+      subject.options[:messageid].should == "test"
+    end
+
+    it 'overrides settings from #defaults' do
+      described_class.defaults[:something] = 'global'
+      subject.options[:something] = 'local'
+
+      stub_request(:post, endpoint).with(body: hash_including('something' => 'local')).to_return(success)
+      subject.deliver message
+    end
+
+    it 'is overriden by options passed to #deliver' do
+      subject.options[:something] = 'local'
+
+      stub_request(:post, endpoint).with(body: hash_including('something' => 'deliver')).to_return(success)
+      subject.deliver message, something: 'deliver'
+    end
+
+    it 'evaluates Procs & lambdas' do
+      subject.options[:messageid] = Proc.new { "test" }
+
+      stub_request(:post, endpoint).with(body: hash_including('messageid' => 'test')).to_return(success)
+      subject.deliver message
+    end
+
+    it 'converts allow_adaption to 1 when true' do
+      subject.options[:allow_adaption] = true
+      stub_request(:post, endpoint).with(body: hash_including('allow_adaption' => '1')).to_return(success)
+      subject.deliver message
+    end
+
+    it 'converts allow_adaption to 0 when false' do
+      subject.options[:allow_adaption] = nil
+      stub_request(:post, endpoint).with(body: hash_including('allow_adaption' => '0')).to_return(success)
+      subject.deliver message
+    end
+  end
+end

data/spec/mote_sms/transports/test_transport_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'mote_sms/transports/test_transport'
+
+describe MoteSMS::TestTransport do
+  subject { described_class }
+  before { MoteSMS.deliveries.clear }
+
+  it 'defines global #deliveries' do
+    MoteSMS.should respond_to(:deliveries)
+  end
+
+  it 'appends deliveries' do
+    subject.deliver "firstMessage"
+    subject.deliver "secondMessage"
+    MoteSMS.deliveries.should == %w{firstMessage secondMessage}
+  end
+end

data/spec/mote_sms_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'mote_sms'
+
+describe MoteSMS do
+  subject { described_class }
+
+  it 'has a version' do
+    subject::VERSION.should =~ /\d/
+  end
+
+  context "transport" do
+    before { @current_transport = subject.transport }
+    after { subject.transport = @current_transport }
+    let(:transport) { double("transport") }
+
+    it "has no default transport" do
+      subject.transport.should be_nil
+    end
+
+    it "can change global transport" do
+      subject.transport = transport
+      subject.transport.should == transport
+    end
+
+    context "#deliver" do
+      it 'delivers quick and dirty using global transport' do
+        transport.should_receive(:deliver).with(kind_of(MoteSMS::Message), {})
+        subject.transport = transport
+        subject.deliver { body 'Hello World' }
+      end
+
+      it 'raises error if block is missing' do
+        Proc.new { subject.deliver }.should raise_error(ArgumentError, /block missing/i)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'webmock/rspec'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: mote_sms
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Lukas Westermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: phony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: ! "Unofficial ruby adapter for MobileTechnics HTTP Bulk SMS API.\n                         Tries
+  to mimick mail API, so users can switch e.g. ActionMailer\n                         with
+  this SMS provider."
+email:
+- lukas.westermann@at-point.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mote_sms.rb
+- lib/mote_sms/message.rb
+- lib/mote_sms/number.rb
+- lib/mote_sms/number_list.rb
+- lib/mote_sms/transports.rb
+- lib/mote_sms/transports/.gitkeep
+- lib/mote_sms/transports/mobile_technics_transport.rb
+- lib/mote_sms/transports/test_transport.rb
+- lib/mote_sms/version.rb
+- mote_sms.gemspec
+- spec/mote_sms/message_spec.rb
+- spec/mote_sms/number_list_spec.rb
+- spec/mote_sms/number_spec.rb
+- spec/mote_sms/transports/mobile_technics_transport_spec.rb
+- spec/mote_sms/transports/test_transport_spec.rb
+- spec/mote_sms_spec.rb
+- spec/spec_helper.rb
+homepage: https://at-point.ch/opensource
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3261538551323079383
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Deliver SMS using MobileTechnics HTTP API.
+test_files:
+- spec/mote_sms/message_spec.rb
+- spec/mote_sms/number_list_spec.rb
+- spec/mote_sms/number_spec.rb
+- spec/mote_sms/transports/mobile_technics_transport_spec.rb
+- spec/mote_sms/transports/test_transport_spec.rb
+- spec/mote_sms_spec.rb
+- spec/spec_helper.rb