textmagic 0.2.0

data/lib/textmagic.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+gem 'httparty'
+require 'httparty'
+require 'charset'
+require 'validation'
+require 'api'
+require 'response'
+require 'executor'
+require 'error'
+
+module TextMagic #:nodoc:
+end

data/lib/validation.rb

@@ -0,0 +1,34 @@
+module TextMagic
+
+  class API
+
+    module Validation
+
+      MAX_LENGTH_GSM = [160, 306, 459]
+      MAX_LENGTH_UNICODE = [70, 134, 201]
+
+      # Validates message text length. Returns +true+ if the text length is
+      # within the limits for the unicode/parts combination, otherwise it
+      # returns +false+.
+      #
+      # Note: <em>Maximum lengths for 1, 2 and 3-part GSM 03.38 messages are
+      # 160, 306 and 459 respectively.
+      # Maximum lengths for 1, 2 and 3-part unicode messages are
+      # 70, 134 and 201 respectively.</em>
+      def validate_text_length(text, unicode, parts = 3)
+        max_text_length = (unicode ? MAX_LENGTH_UNICODE : MAX_LENGTH_GSM)[parts - 1]
+        text.size <= max_text_length
+      end
+
+      # Validates a list of phone numbers. Returns +true+ if the list is not empty
+      # and all phone numbers are digit-only strings of maximum length of 15,
+      # otherwise it returns +false+.
+      def validate_phones(*phones)
+        phones.flatten!
+        return false if phones.empty?
+        phones.each { |phone| return false unless phone =~ /^\d{1,15}$/ }
+        true
+      end
+    end
+  end
+end

data/test/test_api.rb

@@ -0,0 +1,246 @@
+require 'test_helper'
+
+class APITest < Test::Unit::TestCase
+
+  context 'Initialization' do
+
+    should 'require username and password' do
+      lambda { TextMagic::API.new }.should raise_error(ArgumentError)
+      TextMagic::API.new(random_string, random_string)
+    end
+  end
+
+  context 'Account command' do
+
+    setup do
+      @balance = 0.01 * rand(1e4)
+      @username, @password = random_string, random_string
+      @api = TextMagic::API.new(@username, @password)
+    end
+
+    should 'call Executor execute with correct arguments' do
+      TextMagic::API::Executor.expects(:execute).with('account', @username, @password).returns({})
+      @api.account
+    end
+
+    should 'return a hash extended with TextMagic::API::Response::Account' do
+      TextMagic::API::Executor.expects(:execute).returns({ 'balance' => @balance.to_s })
+      response = @api.account
+      response.class.should == Hash
+      response.is_a?(TextMagic::API::Response::Account).should == true
+    end
+
+    should 'return a hash with balance value' do
+      TextMagic::API::Executor.expects(:execute).returns({ 'balance' => @balance.to_s })
+      response = @api.account
+      response['balance'].should be_close(@balance, 1e-10)
+    end
+  end
+
+  context 'Send command' do
+
+    setup do
+      @username, @password = random_string, random_string
+      @text, @phone = random_string, random_phone
+      @api = TextMagic::API.new(@username, @password)
+      TextMagic::API::Executor.stubs(:execute)
+    end
+
+    should 'call Executor execute with correct arguments' do
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0)
+      @api.send(@text, @phone)
+    end
+
+    should 'join multiple phone numbers supplied as an array' do
+      phones = Array.new(3) { random_phone }
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0)
+      @api.send(@text, phones)
+    end
+
+    should 'join multiple phone numbers supplied as arguments' do
+      phones = Array.new(3) { random_phone }
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => phones.join(','), :unicode => 0)
+      @api.send(@text, *phones)
+    end
+
+    should 'replace true with 1 for unicode' do
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 1)
+      @api.send(@text, @phone, :unicode => true)
+    end
+
+    should 'set unicode value to 0 if it is not set to by user and text contains only characters from GSM 03.38 charset' do
+      TextMagic::API::Executor.expects(:execute).with('send', @username, @password, :text => @text, :phone => @phone, :unicode => 0).times(2)
+      @api.send(@text, @phone)
+      @api.send(@text, @phone, :unicode => false)
+    end
+
+    should 'raise an error if unicode is set to 0 and text contains characters outside of GSM 03.38 charset' do
+      text = 'Вильма Привет'
+      lambda { @api.send(text, @phone, :unicode => false) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'raise an error if unicode value is not valid' do
+      lambda { @api.send(@text, @phone, :unicode => 2 + rand(10)) }.should raise_error(TextMagic::API::Error)
+      lambda { @api.send(@text, @phone, :unicode => random_string) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'raise an error if no phone numbers are specified' do
+      lambda { @api.send(@text) }.should raise_error(TextMagic::API::Error)
+      lambda { @api.send(@text, []) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'raise an error if format of any of the specified phone numbers is invalid' do
+      TextMagic::API.expects(:validate_phones).returns(false)
+      lambda { @api.send(@text, random_string) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'raise an error if text is empty' do
+      lambda { @api.send('', @phone) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'raise an error if text is too long' do
+      TextMagic::API.expects(:validate_text_length).returns(false)
+      lambda { @api.send(@text, @phone) }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'return a hash extended with TextMagic::API::Response::Send' do
+      message_id = random_string
+      TextMagic::API::Executor.expects(:execute).returns({ 'message_id' => { message_id => @phone }, 'sent_text' => @text, 'parts_count' => 1 })
+      response = @api.send(@text, @phone)
+      response.class.should == Hash
+      response.is_a?(TextMagic::API::Response::Send).should == true
+    end
+
+    should 'return a hash with message_id_hash, message_ids, sent_text and parts_count values' do
+      message_id = random_string
+      TextMagic::API::Executor.expects(:execute).returns({ 'message_id' => { message_id => @phone }, 'sent_text' => @text, 'parts_count' => 1 })
+      response = @api.send(@text, @phone)
+      response['message_id_hash'].should == { @phone => message_id }
+      response['message_ids'].should == [message_id]
+      response['parts_count'].should == 1
+    end
+  end
+
+  context 'Message status command' do
+
+    setup do
+      @username, @password = random_string, random_string
+      @api = TextMagic::API.new(@username, @password)
+    end
+
+    should 'call Executor execute with correct arguments' do
+      id = random_string
+      TextMagic::API::Executor.expects(:execute).with('message_status', @username, @password, :ids => id)
+      @api.message_status(id)
+    end
+
+    should 'join ids supplied as array' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).with('message_status', @username, @password, :ids => ids.join(','))
+      @api.message_status(ids)
+    end
+
+    should 'join ids supplied as arguments' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).with('message_status', @username, @password, :ids => ids.join(','))
+      @api.message_status(*ids)
+    end
+
+    should 'not call execute and should raise an exception if no ids are specified' do
+      TextMagic::API::Executor.expects(:execute).never
+      lambda { @api.message_status }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'return a hash extended with TextMagic::API::Response::MessageStatus' do
+      TextMagic::API::Executor.expects(:execute).returns({ '8659912' => {} })
+      response = @api.message_status(random_string)
+      response.class.should == Hash
+      response.is_a?(TextMagic::API::Response::MessageStatus).should == true
+    end
+
+    should 'return a hash with message ids as keys' do
+      TextMagic::API::Executor.expects(:execute).returns({ '8659912' => {} })
+      response = @api.message_status(random_string)
+      response['8659912'].should == {}
+    end
+  end
+
+  context 'Receive command' do
+
+    setup do
+      @username, @password = random_string, random_string
+      @api = TextMagic::API.new(@username, @password)
+    end
+
+    should 'call Executor execute with correct arguments' do
+      TextMagic::API::Executor.expects(:execute).with('receive', @username, @password, :last_retrieved_id => nil)
+      @api.receive
+    end
+
+    should 'accept last_retrieved_id optional value' do
+      last_retrieved_id = rand(1e10)
+      TextMagic::API::Executor.expects(:execute).with('receive', @username, @password, :last_retrieved_id => last_retrieved_id)
+      @api.receive(last_retrieved_id)
+    end
+
+    should 'return a hash extended with TextMagic::API::Response::Receive' do
+      TextMagic::API::Executor.expects(:execute).returns({ 'messages' => [], 'unread' => 0 })
+      response = @api.receive
+      response.class.should == Hash
+      response.is_a?(TextMagic::API::Response::Receive).should == true
+    end
+
+    should 'return a hash with unread and messages values' do
+      TextMagic::API::Executor.expects(:execute).returns({ 'messages' => [], 'unread' => 0 })
+      response = @api.receive
+      response['unread'].should == 0
+      response['messages'].should == []
+    end
+  end
+
+  context 'Delete reply command' do
+
+    setup do
+      @username, @password = random_string, random_string
+      @api = TextMagic::API.new(@username, @password)
+    end
+
+    should 'call Executor execute with correct arguments' do
+      id = random_string
+      TextMagic::API::Executor.expects(:execute).with('delete_reply', @username, @password, :ids => id)
+      @api.delete_reply(id)
+    end
+
+    should 'join ids supplied as array' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).with('delete_reply', @username, @password, :ids => ids.join(','))
+      @api.delete_reply(ids)
+    end
+
+    should 'join ids supplied as arguments' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).with('delete_reply', @username, @password, :ids => ids.join(','))
+      @api.delete_reply(*ids)
+    end
+
+    should 'not call execute and should raise an exception if no ids are specified' do
+      TextMagic::API::Executor.expects(:execute).never
+      lambda { @api.delete_reply }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'return a hash extended with TextMagic::API::Response::DeleteReply' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).returns({ 'deleted' => ids })
+      response = @api.delete_reply(ids)
+      response.class.should == Hash
+      response.is_a?(TextMagic::API::Response::DeleteReply).should == true
+    end
+
+    should 'return a hash with deleted value' do
+      ids = Array.new(3) { random_string }
+      TextMagic::API::Executor.expects(:execute).returns({ 'deleted' => ids })
+      response = @api.delete_reply(ids)
+      response.deleted.should == ids
+    end
+  end
+end

data/test/test_charset.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+require 'json'
+
+class CharsetTest < Test::Unit::TestCase
+
+  context 'is_gsm method' do
+
+    should 'return true if all characters are in GSM 03.38 charset' do
+      TextMagic::API.is_gsm(('a'..'z').to_a.join).should == true
+      TextMagic::API.is_gsm(('A'..'Z').to_a.join).should == true
+      TextMagic::API.is_gsm(('0'..'9').to_a.join).should == true
+      TextMagic::API.is_gsm("@£$¥€").should == true
+      TextMagic::API.is_gsm("\n\r\e\f\\\"").should == true
+      TextMagic::API.is_gsm("èéùìòÇØøÅåÉÆæß").should == true
+      TextMagic::API.is_gsm("ΔΦΓΛΩΠΨΣΘΞ").should == true
+      TextMagic::API.is_gsm("^{}[~]| !#¤%&'()").should == true
+      TextMagic::API.is_gsm("*+,-./_:;<=>?¡¿§").should == true
+      TextMagic::API.is_gsm("ÖÑÜöñüàäÄ").should == true
+    end
+
+    should 'return false if some characters are outside of GSM 03.38 charset' do
+      TextMagic::API.is_gsm('Arabic: مرحبا فيلما').should == false
+      TextMagic::API.is_gsm('Chinese: 您好').should == false
+      TextMagic::API.is_gsm('Cyrilic: Вильма Привет').should == false
+      TextMagic::API.is_gsm('Thai: สวัสดี').should == false
+    end
+  end
+end

data/test/test_error.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class ErrorTest < Test::Unit::TestCase
+
+  context 'Initialization' do
+
+    setup do
+      @code = rand(1e3)
+      @message = random_string
+    end
+
+    should 'accept a hash with error_code and error_message' do
+      e = TextMagic::API::Error.new('error_code' => @code, 'error_message' => @message)
+      e.code.should == @code
+      e.message.should == @message
+    end
+
+    should 'accept error_code and error_message' do
+      e = TextMagic::API::Error.new(@code, @message)
+      e.code.should == @code
+      e.message.should == @message
+    end
+  end
+end

data/test/test_executor.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+require 'json'
+
+class ExecutorTest < Test::Unit::TestCase
+
+  context "execute method" do
+
+    setup do
+      FakeWeb.allow_net_connect = false
+
+      @username, @password = random_string, random_string
+      @command, @options = random_string, random_hash
+      @uri = build_uri(@command, @username, @password, @options)
+    end
+
+    should 'not send HTTP request without command' do
+      TextMagic::API::Executor.expects(:get).never
+      lambda {
+        TextMagic::API::Executor.execute(nil, @username, @password, @options)
+      }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'not send HTTP request without username' do
+      TextMagic::API::Executor.expects(:get).never
+      lambda {
+        TextMagic::API::Executor.execute(@command, nil, @password, @options)
+      }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'not send HTTP request without password' do
+      TextMagic::API::Executor.expects(:get).never
+      lambda {
+        TextMagic::API::Executor.execute(@command, @username, nil, @options)
+      }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'send a GET request to proper uri' do
+      response = random_string
+      FakeWeb.register_uri(:get, @uri, :string => response)
+      TextMagic::API::Executor.execute(@command, @username, @password, @options)
+    end
+
+    should 'not send parameters with empty keys' do
+      options_with_empty_values = @options.merge(nil => random_string, '' => random_string)
+      TextMagic::API::Executor.expects(:get).with('/api', :query => @options, :format => :json)
+      TextMagic::API::Executor.execute(@command, @username, @password, options_with_empty_values)
+    end
+
+    should 'not send parameters with empty values' do
+      options_with_empty_values = @options.merge(random_string => nil, random_string => '')
+      TextMagic::API::Executor.expects(:get).with('/api', :query => @options, :format => :json)
+      TextMagic::API::Executor.execute(@command, @username, @password, options_with_empty_values)
+    end
+
+    should 'raise an error if the response contains error_code' do
+      response = "{error_code:#{1 + rand(10)}}"
+      FakeWeb.register_uri(:get, @uri, :string => response)
+      lambda {
+        TextMagic::API::Executor.execute(@command, @username, @password, @options)
+      }.should raise_error(TextMagic::API::Error)
+    end
+
+    should 'return a hash with values from the response' do
+      hash = random_hash
+      FakeWeb.register_uri(:get, @uri, :string => hash.to_json)
+      response = TextMagic::API::Executor.execute(@command, @username, @password, @options)
+      response.should == hash
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'matchy'
+require 'fakeweb'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'textmagic'
+
+class Test::Unit::TestCase
+end
+
+def random_string(legth = 5)
+  Array.new(legth) { rand(36).to_s(36) }.join
+end
+
+def random_phone
+  rand(10 ** 12).to_s
+end
+
+def random_hash
+  hash = {}
+  3.times { hash[random_string] = random_string }
+  hash
+end
+
+def build_uri(command, username, password, options = {})
+  options.merge!(:cmd => command, :username => username, :password => password)
+  uri = "http://www.textmagic.com/app/api?"
+  uri << options.collect { |key, value| "#{key}=#{value}"}.join('&')
+end
+
+def load_response(filename)
+  File.read(File.join(File.dirname(__FILE__), 'fixtures', filename) + '.json')
+end