textmagic 0.5.0 → 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c810998c9e416e69841a07869dc802818d1a4a65
+  data.tar.gz: 3c5c28da54b76a1d939b15ae2edecec92c313a42
+SHA512:
+  metadata.gz: 4041fbd28087e80983118b69ab1e5abae41ba8ea9a846844df83d81696f20c8765ecf18ef48e634a821ff8e4006214583b9c8c4bea27e33712ddf3f30abcb9c5
+  data.tar.gz: 40968523dc18f0c1c6816d8eb64c4713291e5f52bcef386ebc87189868377c878302f36ed24b716fb374e22a942c8ac2cd42886737eb5bf92a259bd39dc5ea69

data/Gemfile

@@ -1,2 +1,9 @@
 source "http://rubygems.org"
+
 gemspec
+
+gem "minitest", :require => "minitest/autorun"
+gem "mocha", :require => "mocha/mini_test"
+gem "fakeweb"
+gem "mcmire-matchy"
+gem "rake"

data/History.txt

@@ -1,3 +1,7 @@
+== 0.6.0 2014-08-19
+
+* Switched to https
+
 == 0.3.3 2009-06-13
 
 * Added support for send_time parameter for send command.

data/README.md

@@ -0,0 +1,131 @@
+# TextMagic
+
+`textmagic` gem is a Ruby interface to the [TextMagic](http://www.textmagic.com)
+Bulk SMS Gateway.
+It can be used to easily integrate SMS features into your application.
+It supports sending messages, receiving replies and more. You need to have
+a valid [TextMagic](http://www.textmagic.com) account to use this gem.
+
+To learn more about the TextMagic Bulk SMS Gateway, visit the official
+[API documentation](http://api.textmagic.com)
+or [Google group](http://groups.google.com/group/textmagic-api).
+
+This document will give you a good overview of the gem's functionality. For
+more information consult the detailed [documentation](http://tuzinsky.com/textmagic/rdoc/).
+
+
+## Basic usage
+
+First create an API instance with your credentials:
+
+    api = TextMagic::API.new(username, password)
+
+These credentials will be used in all requests to the SMS gateway.
+
+
+### Account balance
+
+Check your account's balance:
+
+    api.account.balance
+    # => 314.15
+
+
+### Sending messages
+
+To send a message to a single phone number, run:
+
+    api.send 'Hi Wilma!', '999314159265'
+
+You can even specify multiple phone numbers:
+
+    api.send 'Hello everybody', '999314159265', '999271828182'
+
+Unicode messages are supported as well:
+
+    api.send 'Вильма Привет!', '999314159265'
+
+Long messages will be split to up to 3 parts. To limit maximum number
+of parts, specify an optional `max_length` parameter:
+
+    api.send 'Very very long message...', '999314159265', :max_length => 2
+
+If you want to postpone message delivery, specify a `send_time` parameter:
+
+    api.send 'Two hours later', '999314159265', :send_time => Time.now.to_i + 7200
+
+
+### Checking sent message status
+
+If you want to check sent message status, you have to use `message_id`
+returned in response to `send` command.
+
+    api.send('Hi Wilma!', '999314159265')
+    # => '141421'
+    status = api.message_status('141421')
+    # => 'd'
+    status.completed_time
+    # => Fri May 22 10:10:18 +0200 2009
+
+You can also check statuses of several messages at once, in which case
+you'll get a hash with message ids as keys:
+
+    api.send('Hi Wilma!', '999314159265', '999271828182').message_id
+    # => { '999314159265' => '141421', '999271828182' => '173205' }
+    statuses = api.message_status('141421', '173205')
+    # => { '141421' => 'r', '173205' => 'd' }
+    statuses['173205'].created_time
+    # => Thu May 28 16:41:45 +0200 2009
+
+**It is strongly recommended to setup callbacks to receive updates on message status
+instead of using this method. Learn more about callbacks at
+[TextMagic API](http://api.textmagic.com/https-api) site**
+
+
+### Receiving replies
+
+To receive all available replies, run:
+
+    replies = api.receive
+    # => ['999271828182: Hello Fred!', '999314159265: Good day!']
+    replies.first.text
+    # => 'Hello Fred!'
+    replies.last.from
+    # => '999314159265'
+    replies.last.message_id
+    # => '178082'
+
+To prevent receiving old replies again, supply `last_retrieved_id` argument:
+
+    api.receive('178082')
+    # => []
+
+**It is strongly recommended to setup callbacks to receive replies instead of
+using this method. Learn more about callbacks at
+[TextMagic API](http://api.textmagic.com/https-api) site**
+
+
+### Deleting retrieved replies
+
+After you retrieve replies, you can delete them from server by running:
+
+    api.delete_reply '141421', '178082'
+    # => true
+
+
+## Command-line utility
+
+The `textmagic` gem also features a handy command-line utility. It gives you access
+to all of the gem's features. Run
+
+    tm
+
+from your console to see help on its usage.
+
+*Note: This gem has been tested with Ruby versions 1.9.3 to 2.1.2.
+If you have any troubles using this gem, contact the author (or submit a patch).*
+
+
+## Copyright
+
+Copyright (c) 2009-2014 Vladimír Bobeš Tužinský. See LICENSE for details.

data/Rakefile

@@ -1,7 +1,5 @@
-require "rubygems"
-require "rake"
 require "rake/testtask"
-require "rake/rdoctask"
+require "rdoc/task"
 
 Rake::TestTask.new(:test) do |test|
   test.libs << "lib" << "test"

data/bin/tm

@@ -67,9 +67,9 @@ api = TextMagic::API.new(options['username'], options['password'])
 
 begin
   case command
-  when 'account':
+  when 'account'
     puts "Your account's balance: #{api.account.balance} credits"
-  when 'send':
+  when 'send'
     unless phones = ARGV.shift
       puts "Phone number(s) and message not specified. Use --help option to find out details"
       exit 1
@@ -84,7 +84,7 @@ begin
     response.each do |phone, message_id|
       puts "Message id (#{phone}): #{message_id}"
     end
-  when   'status':
+  when   'status'
     if ARGV.empty?
       puts "Message id(s) not specified. Use --help option to find out details"
       exit 1
@@ -92,13 +92,13 @@ begin
     api.status(ARGV).each do |message_id, status|
       puts "Status (#{message_id}): #{status}"
     end
-  when   'receive':
+  when   'receive'
     response = api.receive(ARGV.first)
     response.each do |message|
       puts "#{message} [#{message.message_id}, #{message.timestamp}]"
     end
     puts 'No new messages' if response.empty?
-  when   'delete':
+  when   'delete'
     api.delete(ARGV)
     puts 'Message(s) deleted'
   else

data/lib/textmagic/executor.rb

@@ -1,11 +1,10 @@
 module TextMagic
-
   class API
 
     class Executor
 
       include HTTParty
-      base_uri "http://www.textmagic.com/app"
+      base_uri "https://www.textmagic.com/app"
 
       # Executes a command by sending a request to the TextMagic's Bulk
       # SMS gateway. This is a low-level generic method used by methods

data/lib/textmagic/version.rb

@@ -1,3 +1,3 @@
 module Textmagic
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/test/test_api.rb

@@ -2,19 +2,21 @@
 
 require "test_helper"
 
-class APITest < Test::Unit::TestCase
+describe "API" do
 
-  context "Initialization" do
+  describe "Initialization" do
 
-    should "require username and password" do
-      lambda { TextMagic::API.new }.should raise_error(ArgumentError)
+    it " should require username and password" do
+      assert_raises ArgumentError do
+        TextMagic::API.new
+      end
       TextMagic::API.new(random_string, random_string)
     end
   end
 
-  context "Account command" do
+  describe "Account command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
       @response = random_string
@@ -23,21 +25,21 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:account).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "should call Executor execute with correct arguments" do
       TextMagic::API::Executor.expects(:execute).with("account", @username, @password).returns(@response)
       @api.account
     end
 
-    should "call Response.account method to process the response hash" do
+    it "should call Response.account method to process the response hash" do
       processed_response = rand
       TextMagic::API::Response.expects(:account).with(@response).returns(processed_response)
-      @api.account.should == processed_response
+      assert_equal processed_response, @api.account
     end
   end
 
-  context "Send command" do
+  describe "Send command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @text, @phone = random_string, random_phone
       @api = TextMagic::API.new(@username, @password)
@@ -47,92 +49,108 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:send).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "should call Executor execute with correct arguments" do
       TextMagic::API::Executor.expects(:execute).with("send", @username, @password, :text => @text, :phone => @phone, :unicode => 0).returns(@response)
       @api.send(@text, @phone)
     end
 
-    should "join multiple phone numbers supplied as an array" do
+    it "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).returns(@response)
       @api.send(@text, phones)
     end
 
-    should "join multiple phone numbers supplied as arguments" do
+    it "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).returns(@response)
       @api.send(@text, *phones)
     end
 
-    should "replace true with 1 for unicode" do
+    it "should replace true with 1 for unicode" do
       TextMagic::API::Executor.expects(:execute).with("send", @username, @password, :text => @text, :phone => @phone, :unicode => 1).returns(@response)
       @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
+    it "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).returns(@response).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
+    it "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)
+      assert_raises TextMagic::API::Error do
+        @api.send(text, @phone, :unicode => false)
+      end
     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)
+    it "should raise an error if unicode value is not valid" do
+      assert_raises TextMagic::API::Error do
+        @api.send(@text, @phone, :unicode => 2 + rand(10))
+      end
+      assert_raises TextMagic::API::Error do
+        @api.send(@text, @phone, :unicode => random_string)
+      end
     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)
+    it "should raise an error if no phone numbers are specified" do
+      assert_raises TextMagic::API::Error do
+        @api.send(@text)
+      end
+      assert_raises TextMagic::API::Error do
+        @api.send(@text, [])
+      end
     end
 
-    should "raise an error if format of any of the specified phone numbers is invalid" do
+    it "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)
+      assert_raises TextMagic::API::Error do
+        @api.send(@text, random_string)
+      end
     end
 
-    should "raise an error if text is nil" do
-      lambda { @api.send(nil, @phone) }.should raise_error(TextMagic::API::Error)
+    it "should raise an error if text is nil" do
+      assert_raises TextMagic::API::Error do
+        @api.send(nil, @phone)
+      end
     end
 
-    should "raise an error if text is too long" do
+    it "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)
+      assert_raises TextMagic::API::Error do
+        @api.send(@text, @phone)
+      end
     end
 
-    should "support send_time option" do
+    it "should support send_time option" do
       time = Time.now + rand
       TextMagic::API::Executor.expects(:execute).with("send", @username, @password, :text => @text, :phone => @phone, :unicode => 0, :send_time => time.to_i).returns(@response)
       @api.send(@text, @phone, :send_time => time.to_i)
     end
 
-    should "convert send_time to Fixnum" do
+    it "should convert send_time to Fixnum" do
       time = Time.now + rand
       TextMagic::API::Executor.expects(:execute).with("send", @username, @password, :text => @text, :phone => @phone, :unicode => 0, :send_time => time.to_i).returns(@response)
       @api.send(@text, @phone, :send_time => time)
     end
 
-    should "call Response.send method to process the response hash (single phone)" do
+    it "should call Response.send method to process the response hash (single phone)" do
       processed_response = rand
       TextMagic::API::Response.expects(:send).with(@response, true).returns(processed_response)
-      @api.send(@text, random_phone).should == processed_response
+      assert_equal processed_response, @api.send(@text, random_phone)
     end
 
-    should "call Response.send method to process the response hash (multiple phones)" do
+    it "should call Response.send method to process the response hash (multiple phones)" do
       processed_response = rand
       TextMagic::API::Response.expects(:send).with(@response, false).returns(processed_response).twice
-      @api.send(@text, [random_phone]).should == processed_response
-      @api.send(@text, random_phone, random_phone).should == processed_response
+      assert_equal processed_response, @api.send(@text, [random_phone])
+      assert_equal processed_response, @api.send(@text, random_phone, random_phone)
     end
   end
 
-  context "Message status command" do
+  describe "Message status command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
       @response = random_string
@@ -141,44 +159,46 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:message_status).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "should call Executor execute with correct arguments" do
       id = random_string
       TextMagic::API::Executor.expects(:execute).with("message_status", @username, @password, :ids => id).returns(@response)
       @api.message_status(id)
     end
 
-    should "join ids supplied as array" do
+    it "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
+    it "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
+    it "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)
+      assert_raises TextMagic::API::Error do
+        @api.message_status
+      end
     end
 
-    should "call Response.message_status method to process the response hash (single id)" do
+    it "should call Response.message_status method to process the response hash (single id)" do
       TextMagic::API::Response.expects(:message_status).with(@response, true).returns(@processed_response)
-      @api.message_status(random_string).should == @processed_response
+      assert_equal @processed_response, @api.message_status(random_string)
     end
 
-    should "call Response.message_status method to process the response hash (multiple ids)" do
+    it "should call Response.message_status method to process the response hash (multiple ids)" do
       TextMagic::API::Response.expects(:message_status).with(@response, false).returns(@processed_response).twice
-      @api.message_status([random_string]).should == @processed_response
-      @api.message_status(random_string, random_string).should == @processed_response
+      assert_equal @processed_response, @api.message_status([random_string])
+      assert_equal @processed_response, @api.message_status(random_string, random_string)
     end
   end
 
-  context "Receive command" do
+  describe "Receive command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
       @response = random_string
@@ -187,26 +207,26 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:receive).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "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
+    it "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 "call Response.receive method to process the response hash" do
+    it "should call Response.receive method to process the response hash" do
       TextMagic::API::Response.expects(:receive).with(@response).returns(@processed_response)
-      @api.receive(random_string).should == @processed_response
+      assert_equal @processed_response, @api.receive(random_string)
     end
   end
 
-  context "Delete reply command" do
+  describe "Delete reply command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
       @response = random_string
@@ -215,37 +235,39 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:delete_reply).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "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
+    it "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
+    it "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
+    it "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)
+      assert_raises TextMagic::API::Error do
+        @api.delete_reply
+      end
     end
 
-    should "return true" do
-      @api.delete_reply(random_string).should == true
+    it "should return true" do
+      assert_equal true, @api.delete_reply(random_string)
     end
   end
 
-  context "Check number command" do
+  describe "Check number command" do
 
-    setup do
+    before do
       @username, @password = random_string, random_string
       @api = TextMagic::API.new(@username, @password)
       @response = random_string
@@ -254,38 +276,40 @@ class APITest < Test::Unit::TestCase
       TextMagic::API::Response.stubs(:check_number).returns(@processed_response)
     end
 
-    should "call Executor execute with correct arguments" do
+    it "should call Executor execute with correct arguments" do
       phone = random_phone
       TextMagic::API::Executor.expects(:execute).with("check_number", @username, @password, :phone => phone)
       @api.check_number(phone)
     end
 
-    should "join phones supplied as array" do
+    it "should join phones supplied as array" do
       phones = Array.new(3) { random_phone }
       TextMagic::API::Executor.expects(:execute).with("check_number", @username, @password, :phone => phones.join(","))
       @api.check_number(phones)
     end
 
-    should "join phones supplied as arguments" do
+    it "should join phones supplied as arguments" do
       phones = Array.new(3) { random_phone }
       TextMagic::API::Executor.expects(:execute).with("check_number", @username, @password, :phone => phones.join(","))
       @api.check_number(*phones)
     end
 
-    should "not call execute and should raise an exception if no phones are specified" do
+    it "should not call execute and should raise an exception if no phones are specified" do
       TextMagic::API::Executor.expects(:execute).never
-      lambda { @api.check_number }.should raise_error(TextMagic::API::Error)
+      assert_raises TextMagic::API::Error do
+        @api.check_number
+      end
     end
 
-    should "call Response.check_number method to process the response hash (single phone)" do
+    it "should call Response.check_number method to process the response hash (single phone)" do
       TextMagic::API::Response.expects(:check_number).with(@response, true).returns(@processed_response)
-      @api.check_number(random_string).should == @processed_response
+      assert_equal @processed_response, @api.check_number(random_string)
     end
 
-    should "call Response.check_number method to process the response hash (mulitple phones)" do
+    it "should call Response.check_number method to process the response hash (mulitple phones)" do
       TextMagic::API::Response.expects(:check_number).with(@response, false).returns(@processed_response).twice
-      @api.check_number([random_string]).should == @processed_response
-      @api.check_number(random_string, random_string).should == @processed_response
+      assert_equal @processed_response, @api.check_number([random_string])
+      assert_equal @processed_response, @api.check_number(random_string, random_string)
     end
   end
 end