sztywny-smsonrails 0.1.2

data/tasks/sms_on_rails_tasks.rake

@@ -0,0 +1,68 @@
+require 'active_support'
+require 'active_support/inflector'
+require File.dirname(__FILE__) + '/../lib/sms_on_rails/schema_helper'
+
+namespace :sms do
+  desc 'Reset the Sms data'
+  task :reset => [ :teardown, :setup ]
+
+  desc 'Create Tables and seed them'
+  task :setup => [ :create_tables, :seed_tables ]
+
+  desc 'Teardown'
+  task :teardown => [:drop_tables]
+  schema_tables = %w(sms_on_rails_carrier_tables sms_on_rails_phone_number_tables sms_on_rails_model_tables)
+
+  [:create, :drop].each do |command|
+    schema_tables.each do |table|
+    
+      desc "#{command.to_s.titleize} #{table.titleize}"
+      task "#{command}_#{table}".to_sym => :environment do
+        eval SmsOnRails::SchemaHelper.schema(command, table, :safe => true)
+      end
+
+    end
+    desc '#{command.to_s.titleize} All SMS database tables'
+    task "#{command}_tables".to_sym => schema_tables.collect{|t| "sms:#{command}_#{t}"}
+  end
+
+  
+  desc 'Seed tables'
+  task :seed_tables => :environment do
+    puts "Seeding SMS tables..."
+    load File.dirname(__FILE__) + '/../db/seed_data.rb'
+  end
+  
+  desc 'Create New Specialized Gateway Template'
+  task :create_email_template => :environment do
+    raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+
+    default_path = 'sms_on_rails/service_providers/email_gateway_support/sms_mailer'
+    default_template_name = 'sms_through_gateway.erb'
+    dest_path = File.join(ActionMailer::Base.template_root, default_path)
+    FileUtils.mkdir_p(dest_path)
+
+    dest = File.join(dest_path, default_template_name)
+    unless File.exists?(dest)
+      src = File.join(File.dirname(__FILE__), '../lib', default_path, 'sms_through_gateway.erb')
+      FileUtils.cp(src, dest)
+    end
+
+    config = "\n# Place email gateway templates in the default view directory"
+    config << "\n# To configure your sms messages, edit file:"
+    config << "\n#  #{dest.gsub(RAILS_ROOT, '')} "
+
+    #relative_root = File.expand_path(ActionMailer::Base.template_root.to_s)
+    #relative_root.gsub!(RAILS_ROOT+'/', '/..')
+    #config << "File.dirname(__FILE__) + #{relative_root.inspect}\n\n"
+    config << "\nSmsOnRails::ServiceProviders::EmailGatewaySupport::SmsMailer.template_root= "
+    config << "ActionMailer::Base.template_root\n\n"
+    
+    File.open(File.join(RAILS_ROOT, 'config/environment.rb'), 'a') {|file| file.puts config }
+
+    puts "environment.rb has been updated to set your new template path."
+    puts "Please edit the template in the file:\n #{dest}"
+    
+  end
+
+end

data/test/active_record_extensions/delivery_and_locking_test.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__)+'/../test_helper'
+
+#require 'ruby-debug'
+
+class SmsOnRails::Outbound < ActiveRecord::Base
+  def deliver_message_with_exception(options={})
+    raise Exception.new('asdf')
+  end
+end
+
+class SmsOnRails::DeliveryAndLockingTest  < Test::Unit::TestCase
+
+  def setup
+    super
+    SmsOnRails::ServiceProviders::Base.default_service_provider = SmsOnRails::ServiceProviders::Dummy.instance
+  end
+
+  def test_failed_delivery_with_exception
+    SmsOnRails::Outbound.send :alias_method_chain, :deliver_message, :exception
+    SmsOnRails::Outbound.delete_all
+
+    sms = nil
+    assert_raises(Exception) {
+      sms = SmsOnRails::Outbound.send_immediately! 'hi', '2065552476'
+    }
+    
+    sms = SmsOnRails::Outbound.find :first
+    assert(sms)
+
+    assert_equal('FAILED', sms.status)
+    #assert(sms.processed_on.to_i <= Time.now.to_i)
+  ensure
+    SmsOnRails::Outbound.send :alias_method, :deliver_message, :deliver_message_without_exception
+  end
+
+
+  def test_failed_delivery_with_errors
+    SmsOnRails::Outbound.send :alias_method_chain, :deliver_message, :exception
+    SmsOnRails::Outbound.delete_all
+
+    sms = SmsOnRails::Outbound.send_immediately 'hi', '2065552476'
+    assert(sms, "SHOULD create and SMS object")
+    assert(sms.errors.any?, "Expecting deliver errors.")
+
+    assert_equal(sms.errors.on(:base), 'Unable to send message.')
+    sms = SmsOnRails::Outbound.find :first
+    assert(sms)
+
+    assert_equal('FAILED', sms.status)
+    assert(sms.processed_on.to_i <= Time.now.to_i)
+  ensure
+    SmsOnRails::Outbound.send :alias_method, :deliver_message, :deliver_message_without_exception
+  end
+
+  def test_deliver_stale_record_should_raise_unlockable_error
+     SmsOnRails::Outbound.delete_all
+
+     #get the sms instance
+     sms = SmsOnRails::Outbound.create_sms 'hi', '2065552476'
+
+     #change the lock id
+     same_sms = SmsOnRails::Outbound.find :first
+     same_sms.notes = 'something fun'
+     same_sms.save!
+
+     #attempt to deliver should catch stale record and raise unable to lock
+     assert_raises(SmsOnRails::LockableRecord::UnableToLockRecord) { sms.deliver! }
+  end
+
+  def test_deliver_already_processed_record_should_raise_already_processed_error
+
+     SmsOnRails::Outbound.delete_all
+
+     #get the sms instance
+     sms = SmsOnRails::Outbound.create_sms 'hi', '2065552476'
+
+     sms.status = 'PROCESSING'
+     sms.save!
+
+     #should be unlockable because status is not set to NOT_PROCESSED
+     assert_raises(SmsOnRails::LockableRecord::AlreadyProcessed) { sms.deliver! }
+  end
+end
+

data/test/models/draft_test.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__)+'/../test_helper'
+
+#require 'ruby-debug'
+
+class SmsOnRails::DraftTest  < Test::Unit::TestCase
+
+  def setup
+    super
+    SmsOnRails::PhoneNumber.delete_all
+  end
+
+  def test_create_draft_with_nested_params_with_existing_phone
+    phone = SmsOnRails::PhoneNumber.create!(:number => '12065557777')
+    test_create_draft_with_nested_params
+  end
+
+  def test_create_draft_with_nested_params
+    draft = SmsOnRails::Draft.create_sms(test_params)
+
+    validate_draft draft
+  end
+
+  def test_create_draft_with_exception
+    args = test_params.dup
+    args['outbounds_attributes']['0']['phone_number_attributes'].update('number' => 'ss' )
+    assert_raises(ActiveRecord::RecordInvalid) { SmsOnRails::Draft.create_sms!(args) }
+
+  end
+
+  def test_create_draft_with_nested_params_with_error
+    args = test_params.dup
+    args['outbounds_attributes']['0']['phone_number_attributes'].update('number' => 'ss' )
+
+    draft = SmsOnRails::Draft.create_sms(args)
+
+    assert(draft)
+    assert(draft.errors.any?)
+    assert(draft.new_record?)
+    assert('Test Draft', draft.message)
+
+    assert(draft.outbounds)
+    assert_equal(1, draft.outbounds.length)
+    assert('NOT PROCESSED', draft.outbounds.first.status)
+    assert(draft.outbounds.first.new_record?)
+
+    assert(draft.outbounds.first.phone_number)
+    assert(draft.outbounds.first.phone_number.new_record?)
+    assert('12065557777', draft.outbounds.first.phone_number.number)
+    
+  end
+  
+  def test_params
+    params = {"draft"=>{"deliver_after(1i)"=>"", "message"=>"Test Draft", "deliver_after(2i)"=>"", "outbounds_attributes"=>{"0"=>{"phone_number_attributes"=>{"number"=>"12065557777", "carrier_id"=>"5"}}}, "deliver_after(3i)"=>"", "deliver_after(4i)"=>"", "deliver_after(5i)"=>""}, "commit"=>"Send Sms", "authenticity_token"=>"XGchwHjmN2j77X27pgxhxOq/hOKWmouy27oMrPWhlUA=", "send_immediately"=>"true", "previous_action"=>"new"}
+    params['draft']
+  end
+
+  protected
+  def validate_draft(draft, options={})
+    assert(draft)
+    assert(!draft.new_record?)
+    assert('Test Draft', draft.message)
+
+    assert(draft.outbounds)
+    assert_equal(1, draft.outbounds.length)
+    assert('NOT PROCESSED', draft.outbounds.first.status)
+    assert(!draft.outbounds.first.new_record?)
+
+    assert(draft.outbounds.first.phone_number)
+    assert(!draft.outbounds.first.phone_number.new_record?)
+    assert('12065557777', draft.outbounds.first.phone_number.number)
+  end
+end

data/test/models/outbound_test.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__)+'/../test_helper'
+
+#require 'ruby-debug'
+
+class SmsOnRails::OutboundTest  < Test::Unit::TestCase
+
+  def test_outbound_create_sms_simple
+    SmsOnRails::Outbound.delete_all
+    sms = SmsOnRails::Outbound.create_sms 'hi', '2065552476'
+    assert(sms)
+    assert(sms.is_a?(ActiveRecord::Base))
+
+    validate_new_sms('12065552476', 'hi')
+  end
+
+
+  def test_outbound_create_sms_multiple
+    SmsOnRails::Outbound.delete_all
+    smses = SmsOnRails::Outbound.create_sms 'multi test', ['2065552476', '206.555.1234', '1(415)5551234']
+    assert(smses)
+    assert_equal(3, smses.length)
+
+    ['12065552476', '12065551234', '14155551234'].each do |number|
+      validate_new_sms(number, 'multi test')
+    end
+  end
+
+  def test_outbound_send_immediately
+    SmsOnRails::Outbound.delete_all
+    sms = SmsOnRails::Outbound.send_immediately 'hi', '2065552476'
+
+    sms = SmsOnRails::Outbound.find :first
+    assert(sms)
+    assert_equal('PROCESSED', sms.status)
+    assert(sms.processed_on.to_i <= Time.now.to_i)
+  end
+
+  def test_outbound_send_immediately_for_multiple
+    SmsOnRails::Outbound.delete_all
+    smses = SmsOnRails::Outbound.send_immediately 'hi', ['2065552476', '4155553456']
+
+    smses = SmsOnRails::Outbound.find :all
+    assert(smses.length, 2)
+    smses.each{|sms| assert('PROCESSED', sms.status)
+      assert(sms.processed_on.to_i <= Time.now.to_i)
+      assert_equal(SmsOnRails::ServiceProviders::Base.default_service_provider, 
+        sms.sms_service_provider)
+      }
+  end
+
+
+  def test_outbound_substitution
+    SmsOnRails::Outbound.delete_all
+    time = Time.now
+    sms = SmsOnRails::Outbound.create_sms '$TIME$', '2065552476'
+    time_sub = Time.parse sms.full_message
+    assert(time_sub.to_i >= time.to_i)
+
+    sms = SmsOnRails::Outbound.create_sms 'Format phone: $PHONE_NUMBER_DIGITS$ end', '2065552476'
+    assert_equal('Format phone: 12065552476 end', sms.full_message)
+
+    sms = SmsOnRails::Outbound.create_sms 'Format phone human: $PHONE_NUMBER$ end', '2065552476'
+    assert_equal('Format phone human: (206) 555-2476 end', sms.full_message)
+    
+  end
+  
+  def test_send_to_invalid_number
+    assert_raise(ActiveRecord::RecordInvalid){
+      sms = SmsOnRails::Outbound.create_sms 'some test message #{Time.now.to_s(:db)}', 'ss', :find => {:create => :create!}
+    }
+  end
+
+  protected
+
+  def validate_new_sms(phone_number, message)
+    phone = SmsOnRails::PhoneNumber.find_by_number phone_number
+    assert(phone)
+
+    outbound = SmsOnRails::Outbound.find_by_sms_phone_number_id phone
+    assert(outbound)
+    assert(outbound.draft)
+    assert(SmsOnRails::ServiceProviders::Dummy.provider_id, outbound.sms_service_provider_id)
+    assert_nil(outbound.sms_service_provider)
+    assert_equal(message, outbound.draft.message)
+    assert_equal('NOT_PROCESSED', outbound.status)
+    outbound
+  end
+end
+

data/test/models/phone_number_test.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__)+'/../test_helper'
+
+class SmsOnRails::OutboundTest < Test::Unit::TestCase
+
+  def test_phone_number_saves_digits
+    SmsOnRails::PhoneNumber.delete_all
+    sms = SmsOnRails::PhoneNumber.create!(:number => '206.555.1234')
+    sms.reload
+    assert('12065551234', sms.number)
+
+    sms = SmsOnRails::PhoneNumber.create!(:number => '(206)555 - 1235 ')
+    sms.reload
+    assert('12065551235', sms.number)
+
+    sms = SmsOnRails::PhoneNumber.create!(:number => '1 206)555 - 2222 ')
+    sms.reload
+    assert('12065552222', sms.number)
+
+    #international
+    sms = SmsOnRails::PhoneNumber.create!(:number => '44 206)555 - 3333 ')
+    sms.reload
+    assert('442065553333', sms.number)
+
+    #international with plus
+    sms = SmsOnRails::PhoneNumber.create!(:number => '+206.555.4444')
+    sms.reload
+    assert('2065554444', sms.number)
+  end
+
+  def test_find_and_create_all_by_numbers
+    SmsOnRails::PhoneNumber.delete_all
+    test_phone_number_saves_digits
+
+    smses = SmsOnRails::PhoneNumber.find_and_create_all_by_numbers(['+206.555.4444', '44 206)555 - 3333 ', '415.555.4444', '14155554444'], :create => :create!)
+    assert_equal(3, smses.length)
+
+    # These are sorted when creating new ones
+    ['2065554444', '442065553333', '14155554444'].each_with_index do |number, idx|
+      assert(number, smses[idx].number)
+    end
+  end
+
+
+  def test_find_and_create_all_by_numbers_with_ar
+    SmsOnRails::PhoneNumber.delete_all
+    SmsOnRails::PhoneNumber.create!(:number => '44 206)555 - 3333 ')
+
+    list = [SmsOnRails::PhoneNumber.new(:number => '206.555.4444', :carrier_id => 1),
+            SmsOnRails::PhoneNumber.new(:number => '44 206)555 - 3333 ', :carrier_id => 2)]
+
+    smses = SmsOnRails::PhoneNumber.find_and_create_all_by_numbers(list, :create => :new)
+    assert_equal(2, smses.length)
+    
+    assert(smses.first.new_record?)
+
+    # These are sorted when creating new ones
+    ['12065554444', '442065553333'].each_with_index do |number, idx|
+      assert_equal(number, smses[idx].number)
+      assert_equal(idx + 1, smses[idx].carrier_id)
+    end
+  end
+
+    def test_find_and_create_all_by_numbers_with_hash
+    SmsOnRails::PhoneNumber.delete_all
+    SmsOnRails::PhoneNumber.create!(:number => '44 206)555 - 3333 ')
+
+    list = [SmsOnRails::PhoneNumber.new(:number => '206.555.4444', :carrier_id => 1),
+            SmsOnRails::PhoneNumber.new(:number => '44 206)555 - 3333 ', :carrier_id => 2)]
+    list.collect!{|x| x.attributes }
+    
+    smses = SmsOnRails::PhoneNumber.find_and_create_all_by_numbers(list, :create => :new)
+    assert_equal(2, smses.length)
+
+    assert(smses.first.new_record?)
+
+    # These are sorted when creating new ones
+    ['12065554444', '442065553333'].each_with_index do |number, idx|
+      assert_equal(number, smses[idx].number)
+      assert_equal(idx + 1, smses[idx].carrier_id)
+    end
+  end
+
+
+
+  def test_sms_carrier_email
+    phone = SmsOnRails::PhoneNumber.create!(:carrier_id => 1, :number => '12065557777')
+    assert_equal('12065557777', phone.number)
+    assert_equal('2065557777@vtext.com', phone.sms_email_address)
+  end
+
+
+  def test_find_and_create_all_by_numbers_with_duplicates
+    SmsOnRails::PhoneNumber.delete_all
+    test_phone_number_saves_digits
+
+    smses = SmsOnRails::PhoneNumber.find_and_create_all_by_numbers(['+206.555.4444', '44 206)555 - 3333 ', '415.555.4444', '+442065553333'], :create => :create!, :keep_duplicates => true)
+    assert_equal(4, smses.length)
+
+    # These are sorted when creating new ones
+    ['12065554444', '442065553333', '14155554444', '442065553333'].each_with_index do |number, idx|
+      assert_equal(number, smses[idx].number)
+    end
+  end
+
+  def test_find_all_by_numbers
+    SmsOnRails::PhoneNumber.delete_all
+    test_phone_number_saves_digits
+
+    smses = SmsOnRails::PhoneNumber.find_all_by_numbers(['+206.555.4444', '44 206)555 - 3333 ', '415.555.4444'])
+    assert_equal(2, smses.length)
+
+    ['2065554444', '442065553333'].each do |number|
+      assert(smses.select{|x| x.number == number })
+    end
+  end
+
+  def test_find_by_number_with_finder_options
+    SmsOnRails::PhoneNumber.delete_all
+    test_phone_number_saves_digits
+
+    sms = SmsOnRails::PhoneNumber.find_by_number('+206.555.4444', :conditions => 'id is not null')
+    assert_equal('12065554444', sms.number)
+  end
+
+
+  def test_human_display
+    assert_equal('(206) 555-4444', SmsOnRails::PhoneNumber.human_display('206.555.4444'))
+    assert_equal('+442065554444',  SmsOnRails::PhoneNumber.human_display('44-206.555.4444'))
+  end
+
+end