cell_force 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6fd8af7240d36472b094418d8ef3fd322e3178f5
+  data.tar.gz: e790f1469e248b37b5e40d4ff89bf36aaee875d9
+SHA512:
+  metadata.gz: 91037b7369f21e6311686dc279be5204e69d53a49ddaa7cbc0e1d27497763552d53acd6b518b3fb6fa302dba9870d1292db8bfb5b3b1f9dfaf85fc34fd5c1e15
+  data.tar.gz: 0746e22d1759e817fb9b1757f61c2a09267156aeeec44108b5b84fc72cfa5cc3bfbc6c86bd7cb494eb72d0d3fabc08b3ec7bade64bb252c216de28687963499c

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+secrets.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Isaac Betesh
+
+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,97 @@
+# CellForce
+
+We use HTTParty to send SMS messages using the CellForce API.  See USAGE below for details.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cell_force'
+```
+
+And then execute:
+
+``` bash
+$ bundle
+```
+
+Or install it yourself as:
+
+``` bash
+$ gem install cell_force
+```
+
+## Usage
+
+#### Configuration
+
+cell_force requires you to provide a username, password and API key.  Configure them before attempting to post to any AOI resource.
+
+```ruby
+CellForce.configure do |config|
+  config.username = "Me"
+  config.password = "MyPassword"
+  config.api_key = "ReallyLongRandomString1234567789"
+end
+```
+
+Since cell_force depends on sms_validation (https://github.com/betesh/sms_validation/), it is also recommended that you configure sms_validation.
+cell_force uses sms_validation's logger.  In a Rails environment, you will probably want to rely on the default configuration,
+but outside of Rails, you will need to configure it if you want any logging:
+
+```ruby
+SmsValidation.configure do |config|
+  config.logger = ::Logger.new(STDOUT)
+end
+```
+
+#### Sending an SMS
+
+Once configured, cell_force will automatically log you in before the first API call and will store your credentials for all subsequent API calls.
+cell_force transparently logs in again whenever you session expires (i.e. if you log out or if 1 hours has elapsed since your last API call).
+
+So once configured, just fire away with API calls, which are done using CellForce::Api#post:
+
+```ruby
+api = CellForce::Api
+api.post("shortcode/getusershortcodes")
+api.post("shortcode/getshortcodecarriers", shortcode_id: ENV['SHORT_CODE'])
+```
+
+But don't use CellForce::Api#post to send an SMS.  If you do, you'll bypass sms_validation.  Instead, use CellForce::MobileDevice#send_mt, so that everything gets validated.
+
+```ruby
+mobile_device = CellForce::MobileDevice.new(my_phone_number)
+mobile_device.send_mt(my_phone_number, "Hi, How are you?")
+```
+sms_validation allows you to configure what to do when a message is too long.  cell_force is only designed to work with the default behavior: :raise_error
+
+If you need the :truncate or :split behavior instead, instantiate an SmsValidation::Sms and iterate through its messages:
+
+```ruby
+mobile_device = CellForce::MobileDevice.new(my_phone_number)
+
+SmsValidation::Sms.new(my_phone_number, "Hi, How are you?"*387).messages.each do |message|
+  mobile_device.send_mt(message)
+end
+```
+
+CellForce's documentation does recommend that you log out at the end of your activity
+```ruby
+CellForce::Api.log_out
+```
+
+## Testing
+
+Copy spec/secrets.yml.example to spec/secrets.yml and modify it to set appropriate credentails.  Then run `rspec`.
+
+Note that none of the tests set any expectations.  If you run them and they all pass, it only verifies that nothing through an exception.  So make sure to check your phone after running the tests to make sure you received all the expected text messages.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/cell_force/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,43 @@
+require "bundler/gem_tasks"
+
+$LOAD_PATH << File.expand_path("#{File.dirname(__FILE__)}/lib") << File.expand_path(File.dirname(__FILE__))
+require "cell_force"
+
+namespace :cell_force do
+  desc "configure CellForce API"
+  task :configure do
+    require "sms_validation"
+    SmsValidation.configure do |config|
+      require "logger"
+      config.logger = ::Logger.new(STDOUT)
+      config.logger.level = Logger::INFO
+      config.log_at :info
+    end
+
+    require "yaml"
+    secrets = YAML::load(File.open('spec/secrets.yml'))
+    CellForce.configure do |config|
+      config.username, config.password, config.api_key = secrets["username"], secrets["password"], secrets["api_key"]
+    end
+  end
+
+  desc "Reserve a keyword (KEYWORD=XXX rake cell_force:reserve_keyword)"
+  task reserve_keyword: :configure do
+    CellForce::TcpaOptInCampaign.new(ENV['KEYWORD']).keyword_id
+  end
+
+  desc "Enable a keyword (KEYWORD=XXX rake cell_force:enable_keyword)"
+  task enable_keyword: :configure do
+    CellForce::Api.post("keyword/enable", row_id: CellForce::TcpaOptInCampaign.new(ENV['KEYWORD']).keyword_id)
+  end
+
+  desc "List all keywords associated with the account"
+  task list_keywords: :configure do
+    puts CellForce::Api.post("keyword/list").data.collect { |k| "#{k["keyword"]}#{" (campaign: '#{k["campaign"]}')" unless "N/A" == k["campaign"] }" }.join(", ")
+  end
+
+  desc "Send an MT (PHONE=NNNNNNNNNN rake cell_force:send_mt)"
+  task send_mt: :configure do
+    CellForce::MobileDevice.new(ENV['PHONE']).send_mt("Test message via CellForce. Sent at #{Time.now}")
+  end
+end

data/cell_force.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cell_force/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cell_force"
+  spec.version       = CellForce::VERSION
+  spec.authors       = ["Isaac Betesh"]
+  spec.email         = ["iybetesh@gmail.com"]
+  spec.description   = "Send SMS messages using the CellForce API"
+  spec.summary       = `cat README.md`
+  spec.homepage      = "https://github.com/betesh/cell_force/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "sms_validation"
+  spec.add_dependency "httparty"
+end

data/lib/cell_force.rb

@@ -0,0 +1,6 @@
+require "cell_force/version"
+require "cell_force/mobile_device"
+
+module CellForce
+  # Your code goes here...
+end

data/lib/cell_force/api.rb

@@ -0,0 +1,82 @@
+require "httparty"
+require "sms_validation"
+require "cell_force/configuration"
+
+module CellForce
+  class Api
+    class Http
+      include HTTParty
+      base_uri "https://www.mycellforce.com"
+    end
+
+    module Util
+      class << self
+        def filtered(hash)
+          hash.is_a?(Hash) ? hash.reject{ |k,v| PARAMETER_FILTER.include?(k.to_sym) } : hash
+        end
+
+        def hash_to_log(hash)
+          hash.sort_by{ |k,v| k }.collect{|k,v| "\t\t\t#{k}:#{" " * (15 - k.length)}\t#{v}" }.join("\n")
+        end
+
+        def parse_response(response)
+          body = JSON.parse(response.body)
+          SmsValidation.log { "CellForce API: #{response.code}:#{response.message}" }
+          SmsValidation.configuration.logger.debug { "\n\t\tHeaders:\n#{hash_to_log(response.headers)}" }
+          SmsValidation.log { "\n\t\tBody:\n#{hash_to_log(body.inject({}) { |hash, (k,v)| hash[k] = filtered(v); hash })}" }
+          raise Failure, body["error"] if "failure" == body["status"]
+          Struct.new(*body.keys.collect(&:to_sym)).new(*body.values)
+        end
+
+        def convert_sms_args(args)
+          validation = args.delete(:sms_validation)
+          unless validation.is_a?(SmsValidation::Sms)
+            raise StandardError, "You cannot send an SMS by calling #{CellForce::Api}#post directly.  Use #{CellForce::Api}#send_sms(phone, message) instead."
+          end
+          args.merge(cellnumber: validation.phone[1..-1], message: validation.message)
+        end
+      end
+    end
+
+    class Failure < StandardError; end
+
+    LOG_IN_RESOURCE = "users/login"
+    SEND_SMS_RESOURCE = "member/sendsms"
+    PARAMETER_FILTER = [:password, :user_key]
+
+    class << self
+      def post(resource, body={})
+        body = Util.convert_sms_args(body.dup) if SEND_SMS_RESOURCE == resource
+        Util.parse_response(post_with_automatic_login(resource, body))
+      end
+
+      def log_out
+        post("users/logout").tap { @login_data = nil }
+      end
+
+      private
+      def post_with_automatic_login(resource, body)
+        body = body.merge(login_data) unless LOG_IN_RESOURCE == resource
+        SmsValidation.log { "CellForce API: POST #{resource}#{filtered_body = Util.filtered(body); " -- #{filtered_body.inspect}" unless filtered_body.empty?}" }
+        result = Http.post("/exlapiservice/#{resource}", headers: configuration.headers, body: body )
+        if "The user key is invalid" == JSON.parse(result.body)["error"]
+          @login_data = nil
+          post_with_automatic_login(resource, body)
+        else
+          result
+        end
+      end
+
+      def configuration
+        CellForce.configuration
+      end
+
+      def login_data
+        @login_data ||= begin
+          SmsValidation.log { "CellForce API: Logged out.  Logging in again..." }
+          post(LOG_IN_RESOURCE, configuration.credentials).data
+        end
+      end
+    end
+  end
+end

data/lib/cell_force/configuration.rb

@@ -0,0 +1,37 @@
+module CellForce
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+  end
+
+  class Configuration
+    class Error < ::StandardError; end
+    [:username, :password, :api_key].each do |accessor|
+      define_method(:"#{accessor}=") do |arg|
+        raise Error, "#{accessor} must be a String" unless arg.nil? || arg.is_a?(String)
+        raise Error, "#{accessor} cannot be blank" if arg.nil? || arg.empty?
+        @credentials = @headers = nil
+        instance_variable_set("@#{accessor}", arg)
+      end
+
+      define_method(accessor) do
+        instance_variable_get("@#{accessor}").tap do |result|
+          raise Error, "#{accessor} has not been set.  Set it with `CellForce.configuration.#{accessor} = ...`" if result.nil?
+        end
+      end
+    end
+
+    def credentials
+      @credentials ||= { username: username, password: password }
+    end
+
+    def headers
+      @headers ||= { "apikey" => api_key }
+    end
+  end
+end

data/lib/cell_force/default_short_code.rb

@@ -0,0 +1,17 @@
+require "cell_force/api"
+
+module CellForce
+  module DefaultShortCode
+    def short_code_id
+      @short_code_id ||= begin
+        data = Api.post("shortcode/getusershortcodes").data
+        if short_code
+          data.find{ |e| short_code.to_s == e["shortcode"].to_s }
+        else
+          # If the instance was not initialized with a short_code, we use the first one we find
+          data[0].tap { |s| @short_code = s["shortcode"] }
+        end["shortcode_id"]
+      end
+    end
+  end
+end

data/lib/cell_force/mobile_device.rb

@@ -0,0 +1,30 @@
+require "cell_force/default_short_code"
+require "cell_force/tcpa_opt_in_campaign"
+
+module CellForce
+  class MobileDevice
+    include DefaultShortCode
+
+    attr_reader :phone, :short_code
+    def initialize(phone, short_code=nil)
+      @phone, @short_code = phone, short_code
+    end
+
+    def send_mt(message)
+      Api.post(Api::SEND_SMS_RESOURCE, sms_validation: SmsValidation::Sms.new(phone, message), shortcode_id: short_code_id).data["mt_id"]
+    end
+
+    def simulate_mo(keyword, campaign_options={})
+      tcpa_opt_in_campaign = TcpaOptInCampaign.new(keyword)
+      if tcpa_opt_in_campaign.campaign_ids.empty?
+        tcpa_opt_in_campaign.create_campaign(campaign_options)
+      end
+      Api.post("sms/mo", cellnumber: phone, message: keyword, shortcode_id: short_code_id, carrier_id: carrier_id, trigger: "DOUBLEOPTIN")
+    end
+
+    private
+    def carrier_id
+      @carrier_id ||= Api.post("member/networklookup", cellphone: phone).data["id"]
+    end
+  end
+end

data/lib/cell_force/tcpa_opt_in_campaign.rb

@@ -0,0 +1,41 @@
+require "cell_force/default_short_code"
+
+module CellForce
+  class TcpaOptInCampaign
+    include DefaultShortCode
+
+    REQUIRED_KEYS_TO_CREATE_CAMPAIGN = [:name, :first_message, :second_message, :error_message]
+
+    attr_reader :keyword, :short_code
+    def initialize(keyword, short_code=nil)
+      @keyword, @short_code = keyword, short_code
+    end
+
+    def keyword_id
+      @keyword_id ||= begin
+        begin
+          Api.post("keyword/create", keyword: keyword, shortcodes: short_code_id, action: "check").data["message"]
+          Api.post("keyword/create", keyword: keyword, shortcodes: short_code_id).data["row_id"]
+        rescue CellForce::Api::Failure => e
+          raise e unless e.to_s == "Keyword is already Exist"
+          if (keyword_record = Api.post("keyword/list").data.find{ |r| keyword == r["keyword"] }) #Intentional assignment operator
+            keyword_record["id"]
+          else
+            raise StandardError, "This keyword is already in use by another consumer of the short_code #{short_code}"
+          end
+        end
+      end
+    end
+
+    def campaign_ids
+      @campaign_ids ||= Api.post("campaign/list").data.collect do |campaign|
+        campaign["campaign_id"] if keyword_id == Api.post("campaign/detail", row_id: campaign["campaign_id"]).data["keyword_id"]
+      end.compact
+    end
+
+    def create_campaign(options)
+      raise ArgumentError, "Some options were missing for creating a campaign: #{REQUIRED_KEYS_TO_CREATE_CAMPAIGN - options.keys}" unless (REQUIRED_KEYS_TO_CREATE_CAMPAIGN - options.keys).empty?
+      Api.post("campaign/tcpaoptin", keyword_id: keyword_id, shortcode_id: short_code_id, optinkeyword: "Y", name: options[:name], message: options[:first_message], doubleoptinmessage: options[:second_message], errormessage: options[:error_message]).data["campaign_id"]
+    end
+  end
+end

data/lib/cell_force/version.rb

@@ -0,0 +1,3 @@
+module CellForce
+  VERSION = "0.0.1"
+end

data/spec/api_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "cell_force/api"
+require "support/configuration_from_yaml"
+
+describe CellForce::Api do
+  include ConfigurationFromYaml
+
+  subject { described_class }
+
+  it "should log_out" do
+    subject.log_out
+  end
+
+  describe "with the wrong API key" do
+    before(:each) do
+      CellForce.configuration.api_key = "12345"
+    end
+
+    after(:each) do
+      CellForce.configuration.api_key = api_key
+    end
+
+    it "should raise an Api::Failure" do
+      expect{subject.post("shortcode/getusershortcodes")}.to raise_error(CellForce::Api::Failure, "Invalid API Key")
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "cell_force/configuration"
+
+describe CellForce::Configuration do
+  subject { CellForce.configuration }
+
+  before(:each) { reset_configuration }
+
+  describe "#username" do
+    it "cannot be nil" do
+      expect{subject.username = nil}.to raise_error(CellForce::Configuration::Error, "username cannot be blank")
+    end
+
+    it "cannot be an empty String" do
+      expect{subject.username = ""}.to raise_error(CellForce::Configuration::Error, "username cannot be blank")
+    end
+
+    it "cannot be a Hash" do
+      expect{subject.username = {}}.to raise_error(CellForce::Configuration::Error, "username must be a String")
+    end
+
+    describe "when password and api_key are already set" do
+      before(:each) do
+        subject.password = "VerySecret"
+        subject.api_key = "LongApiKey"
+      end
+
+      it "must be set before calling #credentials" do
+        expect{subject.credentials}.to raise_error(CellForce::Configuration::Error, "username has not been set.  Set it with `CellForce.configuration.username = ...`")
+      end
+
+      it "need not be set before calling #headers" do
+        expect{subject.headers}.not_to raise_error
+      end
+    end
+  end
+
+  describe "#password" do
+    it "cannot be nil" do
+      expect{subject.password = nil}.to raise_error(CellForce::Configuration::Error, "password cannot be blank")
+    end
+
+    it "cannot be an empty String" do
+      expect{subject.password = ""}.to raise_error(CellForce::Configuration::Error, "password cannot be blank")
+    end
+
+    it "cannot be a Hash" do
+      expect{subject.password = {}}.to raise_error(CellForce::Configuration::Error, "password must be a String")
+    end
+
+    describe "when username and api_key are already set" do
+      before(:each) do
+        subject.username = "Placeholder"
+        subject.api_key = "LongApiKey"
+      end
+
+      it "must be set before calling #credentials" do
+        expect{subject.credentials}.to raise_error(CellForce::Configuration::Error, "password has not been set.  Set it with `CellForce.configuration.password = ...`")
+      end
+
+      it "need not be set before calling #headers" do
+        expect{subject.headers}.not_to raise_error
+      end
+    end
+  end
+
+  describe "#api_key" do
+    it "cannot be nil" do
+      expect{subject.api_key = nil}.to raise_error(CellForce::Configuration::Error, "api_key cannot be blank")
+    end
+
+    it "cannot be an empty String" do
+      expect{subject.api_key = ""}.to raise_error(CellForce::Configuration::Error, "api_key cannot be blank")
+    end
+
+    it "cannot be a Hash" do
+      expect{subject.api_key = {}}.to raise_error(CellForce::Configuration::Error, "api_key must be a String")
+    end
+
+    describe "when username and password are already set" do
+      before(:each) do
+        subject.username = "Placeholder"
+        subject.password = "VerySecret"
+      end
+
+      it "need not be set before calling #credentials" do
+        expect{subject.credentials}.not_to raise_error
+      end
+
+      it "must be set before calling #headers" do
+        expect{subject.headers}.to raise_error(CellForce::Configuration::Error, "api_key has not been set.  Set it with `CellForce.configuration.api_key = ...`")
+      end
+    end
+  end
+
+  describe "#credentials" do
+    let(:username) { "PercyWeasley" }
+    let(:password) { "FredWeasley" }
+
+    let(:new_username) { "GeorgeWeasley" }
+    let(:new_password) { "RonaldWeasley" }
+
+    before(:each) do
+      CellForce.configure do |config|
+        config.username = username
+        config.password = password
+      end
+    end
+
+    it "should contain username and password" do
+      expect(subject.credentials).to eq(username: username, password: password)
+    end
+
+    it "should detect changes to username" do
+      expect{subject.username = new_username}.to change{subject.credentials}.from(username: username, password: password).to(username: new_username, password: password)
+    end
+
+    it "should detect changes to password" do
+      expect{subject.password = new_password}.to change{subject.credentials}.from(username: username, password: password).to(username: username, password: new_password)
+    end
+  end
+
+  describe "#headers" do
+    let(:api_key) { "DracoMalfoy" }
+    let(:new_api_key) { "HarryPotter" }
+
+    before(:each) do
+      CellForce.configure do |config|
+        config.api_key = api_key
+      end
+    end
+
+    it "should contain api_key" do
+      expect(subject.headers).to eq("apikey" => api_key)
+    end
+
+    it "should detect changes to username" do
+      expect{subject.api_key = new_api_key}.to change{subject.headers}.from("apikey" => api_key).to("apikey" => new_api_key)
+    end
+  end
+end

data/spec/mobile_device_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+require "cell_force/mobile_device"
+require "support/configuration_from_yaml"
+
+describe CellForce::MobileDevice do
+  include ConfigurationFromYaml
+
+  subject { described_class.new(phone) }
+  let(:api) { CellForce::Api }
+
+  it "should send an sms" do
+    subject.send_mt("Test message via CellForce. Sent at #{Time.now}")
+  end
+
+  describe "simulating an MO" do
+    def clean_up
+      keyword_record = api.post("keyword/list").data.find{ |r| keyword == r["keyword"] }
+      if keyword_record
+        api.post("campaign/list").data.each do |campaign|
+          if keyword_record["id"] == api.post("campaign/detail", row_id: campaign["campaign_id"]).data["keyword_id"]
+            api.post("campaign/delete", row_id: campaign["campaign_id"])
+          end
+        end
+        api.post("keyword/delete", row_id: keyword_record["id"])
+      end
+    end
+
+    let(:keyword) { "CDF" }
+    let(:keyword_id) do
+      api.post("keyword/create", keyword: keyword, shortcodes: subject.send(:short_code_id)).data["row_id"]
+    end
+
+    let(:campaign_id) do
+      api.post(
+        "campaign/tcpaoptin",
+        keyword_id: keyword_id,
+        shortcode_id: subject.send(:short_code_id),
+        optinkeyword: "Y",
+        name: "Opt in to Keyword #{keyword}",
+        message: "Welcome to keyword #{keyword} campaigns.  To join, reply Y",
+        doubleoptinmessage: "Thanks, you have joined keyword #{keyword} campaigns",
+        errormessage: "We could not understand your response.  Please reply Y to join"
+      ).data["campaign_id"]
+    end
+
+    before(:each) do
+      clean_up
+    end
+
+    let(:campaign_options) {
+      {
+        name: "Opt in to Keyword #{keyword}",
+        first_message: "Welcome to keyword #{keyword} campaigns.  To join, reply Y",
+        second_message: "Thanks, you have joined keyword #{keyword} campaigns",
+        error_message: "We could not understand your response.  Please reply Y to join"
+      }
+    }
+
+    after(:each) do
+      tcpa_opt_in = CellForce::TcpaOptInCampaign.new(keyword)
+      tcpa_opt_in.campaign_ids.each do |id|
+        api.post("campaign/delete", row_id: id)
+      end
+      api.post("keyword/delete", row_id: tcpa_opt_in.keyword_id)
+    end
+
+    it "should simulate an MO when the keyword does not already exist" do
+      subject.simulate_mo(keyword, campaign_options)
+    end
+
+    it "should simulate an MO when the keyword exists but the campaign does not" do
+      keyword_id
+      subject.simulate_mo(keyword, campaign_options)
+    end
+
+    it "should simulate an MO when the keyword and campaign already exist" do
+      campaign_id
+      subject.simulate_mo(keyword)
+    end
+  end
+end

data/spec/secrets.yml.example

@@ -0,0 +1,5 @@
+# Use a username and password from the client level of the hierarchy
+username: MyClient
+password: MyClientPassword
+api_key: ReallyLongRandomString1234567789
+phone: [Put a phone number here.  Just digits, no hyphens. That phone number should receive SMS messages during these tests.]

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  def reset_configuration
+    CellForce.instance_variable_set("@configuration", nil)
+  end
+
+  config.after(:all) { reset_configuration }
+end

data/spec/support/configuration_from_yaml.rb

@@ -0,0 +1,21 @@
+require "yaml"
+require "logger"
+require "rspec/core/shared_context"
+
+module ConfigurationFromYaml
+  extend RSpec::Core::SharedContext
+  SECRETS = YAML::load(File.open('spec/secrets.yml'))
+
+  [:phone, :username, :password, :api_key].each do |key|
+    let(key) { SECRETS[key.to_s] }
+  end
+
+  before(:each) do
+    SmsValidation.configure do |config|
+      config.logger = ::Logger.new(STDOUT)
+    end
+    CellForce.configure do |config|
+      config.username, config.password, config.api_key = username, password, api_key
+    end
+  end
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: cell_force
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Isaac Betesh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sms_validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Send SMS messages using the CellForce API
+email:
+- iybetesh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cell_force.gemspec
+- lib/cell_force.rb
+- lib/cell_force/api.rb
+- lib/cell_force/configuration.rb
+- lib/cell_force/default_short_code.rb
+- lib/cell_force/mobile_device.rb
+- lib/cell_force/tcpa_opt_in_campaign.rb
+- lib/cell_force/version.rb
+- spec/api_spec.rb
+- spec/configuration_spec.rb
+- spec/mobile_device_spec.rb
+- spec/secrets.yml.example
+- spec/spec_helper.rb
+- spec/support/configuration_from_yaml.rb
+homepage: https://github.com/betesh/cell_force/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: '# CellForce  We use HTTParty to send SMS messages using the CellForce API.  See
+  USAGE below for details.  ## Installation  Add this line to your application''s
+  Gemfile:  ```ruby gem ''cell_force'' ```  And then execute:  ``` bash $ bundle ```  Or
+  install it yourself as:  ``` bash $ gem install cell_force ```  ## Usage  #### Configuration  cell_force
+  requires you to provide a username, password and API key.  Configure them before
+  attempting to post to any AOI resource.  ```ruby CellForce.configure do |config|
+  config.username = "Me" config.password = "MyPassword" config.api_key = "ReallyLongRandomString1234567789"
+  end ```  Since cell_force depends on sms_validation (https://github.com/betesh/sms_validation/),
+  it is also recommended that you configure sms_validation. cell_force uses sms_validation''s
+  logger.  In a Rails environment, you will probably want to rely on the default configuration,
+  but outside of Rails, you will need to configure it if you want any logging:  ```ruby
+  SmsValidation.configure do |config| config.logger = ::Logger.new(STDOUT) end ```  ####
+  Sending an SMS  Once configured, cell_force will automatically log you in before
+  the first API call and will store your credentials for all subsequent API calls.
+  cell_force transparently logs in again whenever you session expires (i.e. if you
+  log out or if 1 hours has elapsed since your last API call).  So once configured,
+  just fire away with API calls, which are done using CellForce::Api#post:  ```ruby
+  api = CellForce::Api api.post("shortcode/getusershortcodes") api.post("shortcode/getshortcodecarriers",
+  shortcode_id: ENV[''SHORT_CODE'']) ```  But don''t use CellForce::Api#post to send
+  an SMS.  If you do, you''ll bypass sms_validation.  Instead, use CellForce::MobileDevice#send_mt,
+  so that everything gets validated.  ```ruby mobile_device = CellForce::MobileDevice.new(my_phone_number)
+  mobile_device.send_mt(my_phone_number, "Hi, How are you?") ``` sms_validation allows
+  you to configure what to do when a message is too long.  cell_force is only designed
+  to work with the default behavior: :raise_error  If you need the :truncate or :split
+  behavior instead, instantiate an SmsValidation::Sms and iterate through its messages:  ```ruby
+  mobile_device = CellForce::MobileDevice.new(my_phone_number)  SmsValidation::Sms.new(my_phone_number,
+  "Hi, How are you?"*387).messages.each do |message| mobile_device.send_mt(message)
+  end ```  CellForce''s documentation does recommend that you log out at the end of
+  your activity ```ruby CellForce::Api.log_out ```  ## Testing  Copy spec/secrets.yml.example
+  to spec/secrets.yml and modify it to set appropriate credentails.  Then run `rspec`.  Note
+  that none of the tests set any expectations.  If you run them and they all pass,
+  it only verifies that nothing through an exception.  So make sure to check your
+  phone after running the tests to make sure you received all the expected text messages.  ##
+  Contributing  1. Fork it ( https://github.com/[my-github-username]/cell_force/fork
+  ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your
+  changes (`git commit -am ''Add some feature''`) 4. Push to the branch (`git push
+  origin my-new-feature`) 5. Create a new Pull Request'
+test_files:
+- spec/api_spec.rb
+- spec/configuration_spec.rb
+- spec/mobile_device_spec.rb
+- spec/secrets.yml.example
+- spec/spec_helper.rb
+- spec/support/configuration_from_yaml.rb