elk 0.0.13 → 0.5.0

data/lib/elk/sms.rb

@@ -1,8 +1,10 @@
+require "time"
+
 module Elk
   # Used to send SMS through 46elks SMS-gateway
   class SMS
-    attr_reader :from, :to, :message, :message_id, :created_at, 
-                :loaded_at, :direction, :status #:nodoc:
+    attr_reader :from, :to, :message, :message_id, :created_at,
+                :loaded_at, :direction, :status, :client #:nodoc:
 
     def initialize(parameters) #:nodoc:
       set_parameters(parameters)
@@ -12,71 +14,94 @@ module Elk
       @from       = parameters[:from]
       @to         = parameters[:to]
       @message    = parameters[:message]
-      @message_id = parameters[:id]      
+      @message_id = parameters[:id]
       @created_at = Time.parse(parameters[:created]) if parameters[:created]
       @loaded_at  = Time.now
       @direction  = parameters[:direction]
       @status     = parameters[:status]
+      @client     = parameters.fetch(:client) { Elk.client }
     end
 
     # Reloads a SMS from server
     def reload
-      response = Elk.get("/SMS/#{self.message_id}")
-      self.set_parameters(Elk.parse_json(response.body))
+      response = @client.get("/SMS/#{self.message_id}")
+      self.set_parameters(Elk::Util.parse_json(response.body))
       response.code == 200
     end
 
     class << self
       include Elk::Util
-      
+
       # Send SMS
       # Required parameters
       #
       # * :from - Either the one of the allocated numbers or arbitrary alphanumeric string of at most 11 characters
       # * :to - Any phone number capable of receiving SMS. Multiple numbers can be given as Array or comma separated String
       # * :message - Any UTF-8 text Splitting and joining multi-part SMS messages are automatically handled by the API
-      # 
+      #
       # Optional parameters
       # * :flash - if set to non-false value SMS is sent as a "Flash SMS"
+      # * :client - `Elk::Client` instance
+      # * :whendelivered - Callback URL that will receive a POST after delivery
       #
       def send(parameters)
         verify_parameters(parameters, [:from, :message, :to])
 
-        parameters[:to] = Array(parameters[:to]).join(',')
+        client = parameters.fetch(:client) { Elk.client }
+
+        arguments = {}
+        arguments[:from]     = parameters.fetch(:from)
+        arguments[:to]       = Array(parameters.fetch(:to)).join(",")
+        arguments[:message]  = parameters.fetch(:message)
         
-        if parameters[:flash]
-          parameters.delete(:flash)
-          parameters[:flashsms] = 'yes'
+        if parameters.fetch(:flash) { false }
+          arguments[:flashsms] = "yes"
         end
 
-        # Warn if the from string will be capped by the sms gateway
-        if parameters[:from] && parameters[:from].match(/^(\w{11,})$/)
-          warn "SMS 'from' value #{parameters[:from]} will be capped at 11 chars"
+        if parameters.key?(:whendelivered)
+          arguments[:whendelivered] = parameters.fetch(:whendelivered)
         end
 
-        response = Elk.post('/SMS', parameters)
-        parsed_response = Elk.parse_json(response.body)
-        
-        if multiple_recipients?(parameters[:to])
+        check_sender_limit(arguments[:from])
+
+        response = client.post("/SMS", arguments)
+        parsed_response = Elk::Util.parse_json(response.body)
+
+        if multiple_recipients?(arguments[:to])
+          parsed_response.each { |m| m[:client] = client }
           instantiate_multiple(parsed_response)
         else
+          parsed_response[:client] = client
           self.new(parsed_response)
         end
       end
 
       # Get outgoing and incomming messages. Limited by the API to 100 latest
-      def all
-        response = Elk.get('/SMS')
-        instantiate_multiple(Elk.parse_json(response.body)[:data])
+      #
+      # Optional parameters
+      # * :client - Elk::Client instance
+      #
+      def all(parameters = {})
+        client = parameters.fetch(:client) { Elk.client }
+        response = client.get("/SMS")
+        messages = Elk::Util.parse_json(response.body).fetch(:data).each { |m| m[:client] = client }
+        instantiate_multiple(messages)
       end
 
       private
-      def instantiate_multiple(multiple)
-        multiple.collect { |n| self.new(n) }
+      def instantiate_multiple(messages)
+        messages.map { |message| self.new(message) }
       end
 
       def multiple_recipients?(to)
-        to.split(',').length > 1
+        to.split(",").length > 1
+      end
+
+      # Warn if the from string will be capped by the sms gateway
+      def check_sender_limit(from)
+        if from.to_s.match(/^(\w{11,})$/)
+          warn "SMS 'from' value #{from} will be capped at 11 chars"
+        end
       end
     end
   end

data/lib/elk/util.rb

@@ -1,10 +1,20 @@
+require "json"
+
 module Elk
   module Util
     def verify_parameters(parameters, required_parameters)
       missing_parameters = (required_parameters - parameters.keys)
       unless missing_parameters.empty?
-        raise Elk::MissingParameter, "Requires #{missing_parameters.collect {|s| ":#{s}"}.join(', ')} parameters"
-      end    
+        message = missing_parameters.map { |s| ":#{s}" }.join(', ')
+        raise Elk::MissingParameter, "Requires #{message} parameters"
+      end
+    end
+
+    # Wrapper around MultiJson.load, symbolize names
+    def self.parse_json(body)
+      JSON.parse(body, :symbolize_names => true)
+    rescue JSON::ParserError
+      raise BadResponse, "Can't parse JSON"
     end
   end
-end
+end

data/lib/elk/version.rb

@@ -1,3 +1,3 @@
 module Elk
-  VERSION = '0.0.13'
+  VERSION = "0.5.0"
 end

data/spec/fixtures/sends_a_sms_to_multiple_recipients.txt

@@ -5,4 +5,4 @@ Content-Type: application/json
 Connection: keep-alive
 Content-Length: 135
 
-[{"to": "+46704508449", "id": "sb326c7a214f9f4abc90a11bd36d6abc3"}, { "to": "+46704508449", "id": "s47a89d6cc51d8db395d45ae7e16e86b7"}]
+[{"to": "+46704508448", "id": "sb326c7a214f9f4abc90a11bd36d6abc3"}, { "to": "+46704508449", "id": "s47a89d6cc51d8db395d45ae7e16e86b7"}]

data/spec/fixtures/sends_a_sms_with_long_sender.txt

@@ -3,6 +3,6 @@ Server: nginx/0.7.67
 Date: Tue, 05 Jul 2011 15:32:45 GMT
 Content-Type: application/json
 Connection: keep-alive
-Content-Length: 197
+Content-Length: 245
 
-{"to": "+46704508449", "message": "Your order #171 has now been sent!", "from": "VeryVeryVeryVeryLongSenderName", "id": "scbc6667592e7245fa1abcdc74682f690", "created": "2011-07-05T15:32:45.296367"}
+{"to": "+46704508449", "message": "Your order #171 has now been sent!", "from": "VeryVeryVeryVeryLongSenderName", "id": "scbc6667592e7245fa1abcdc74682f690", "created": "2011-07-05T15:32:45.296367", "direction": "outgoing", "status": "delivered"}

data/spec/integration/number_spec.rb

@@ -0,0 +1,191 @@
+require "spec_helper"
+require "elk"
+
+describe Elk::Number do
+  before { configure_elk }
+  let(:url) { "https://USERNAME:PASSWORD@api.46elks.com/a1/Numbers" }
+
+  describe ".allocate" do
+    context "swedish sms number" do
+      let(:sms_url)   { 'http://localhost/receive' }
+      let(:country)   { 'se' }
+      let(:arguments) { { sms_url: sms_url, country: country } }
+
+      subject(:number) { described_class.allocate(arguments) }
+
+      before(:each) do
+        stub_request(:post, url).
+          with(body: arguments,
+               headers: post_headers).
+          to_return(fixture('allocates_a_number.txt'))
+      end
+
+      it { is_expected.to have_attributes(arguments) }
+
+      it "should be active" do
+        expect(number.status).to eq(:active)
+      end
+
+      it "should have a new swedish number" do
+        expect(number.number).to match(/\+46\d+/)
+      end
+
+      it "should have sms capabilities" do
+        expect(number.capabilities).to include(:sms)
+      end
+    end
+
+    context "without arguments" do
+      it 'should raise exception' do
+        expect {
+          described_class.allocate({})
+        }.to raise_error(Elk::MissingParameter)
+      end
+    end
+  end
+
+  describe ".all" do
+    context "with two allocated numbers" do
+      before(:each) do
+        stub_request(:get, url).
+          with(headers: get_headers).
+          to_return(fixture('gets_allocated_numbers.txt'))
+      end
+
+      subject(:numbers) { described_class.all }
+
+      it "should return two numbers" do
+        expect(numbers.size).to eq(2)
+      end
+
+      it "should have different number id:s" do
+        expect(numbers.first.number_id).to_not be eq(numbers.last.number_id)
+      end
+
+      it "should have different phone numbers" do
+        expect(numbers.first.number).to_not be eq(numbers.last.number)
+      end
+
+      context "first numbers sms_url" do
+        subject(:number) { numbers[0].sms_url }
+        it { is_expected.to eq('http://localhost/receive1') }
+      end
+
+      context "second numbers sms_url" do
+        subject(:number) { numbers[1].sms_url }
+        it { is_expected.to eq('http://localhost/receive2') }
+      end
+    end
+
+    context "with wrong password" do
+      let(:url) { "https://USERNAME:WRONG@api.46elks.com/a1/Numbers" }
+
+      before(:each) do
+        stub_request(:get, url).
+          with(headers: get_headers).
+          to_return(fixture('auth_error.txt'))
+
+        Elk.configure do |config|
+          config.username = 'USERNAME'
+          config.password = 'WRONG'
+        end
+      end
+
+      it 'should raise authentication error' do
+        expect {
+          described_class.all
+        }.to raise_error(Elk::AuthError)
+      end
+    end
+
+    context "when server is broken" do
+      before(:each) do
+        stub_request(:get, url).
+          with(headers: get_headers).
+          to_return(fixture('server_error.txt'))
+      end
+
+      it 'should raise server error' do
+        expect {
+          described_class.all
+        }.to raise_error(Elk::ServerError)
+      end
+    end
+  end
+
+  describe "#save" do
+    before(:each) do
+      stub_request(:get, url).
+        with(headers: get_headers).
+        to_return(fixture('gets_allocated_numbers.txt'))
+
+      stub_request(:post, "#{url}/nea19c8e291676fb7003fa1d63bba7899").
+        with(body: {"sms_url" => "http://otherhost/receive", "voice_start" => ""},
+        headers: post_headers).
+        to_return(fixture('updates_a_number.txt'))
+    end
+
+    subject(:number) { described_class.all.first }
+
+    it 'should update a number' do
+      number.country = 'no'
+      number.sms_url = 'http://otherhost/receive'
+
+      expect(number.save).to be(true)
+    end
+  end
+
+  describe "#deallocate!" do
+    before(:each) do
+      stub_request(:get, url).
+        with(headers: get_headers).
+        to_return(fixture('gets_allocated_numbers.txt'))
+
+      stub_request(:post, "#{url}/nea19c8e291676fb7003fa1d63bba7899").
+        with(body: {"active" => "no"},
+        headers: post_headers).
+        to_return(fixture('deallocates_a_number.txt'))
+    end
+
+    subject(:number) { described_class.all.first }
+
+    it "should return true" do
+      expect(number.deallocate!).to be(true)
+    end
+
+    it "should update loaded_at" do
+      expect { number.deallocate! }.to change { number.status }.to(:deallocated)
+    end
+  end
+
+  describe "#reload" do
+    before(:each) do
+      stub_request(:get, url).
+        with(headers: get_headers).
+        to_return(fixture('gets_allocated_numbers.txt'))
+
+      stub_request(:get, "#{url}/nea19c8e291676fb7003fa1d63bba7899").
+        with(headers: get_headers).
+        to_return(fixture('reloads_a_number.txt'))
+    end
+
+    subject(:number) { described_class.all.first }
+
+    it "should return true" do
+      expect(number.reload).to be(true)
+    end
+
+    it "should not change object_id" do
+      expect { number.reload }.to_not change { number.object_id }
+    end
+
+    it "should update loaded_at" do
+      expect { number.reload }.to change { number.loaded_at }
+    end
+
+    it "should reset mutations" do
+      number.country = "blah"
+      expect { number.reload }.to change { number.country }.to("se")
+    end
+  end
+end

data/spec/integration/sms_spec.rb

@@ -0,0 +1,241 @@
+require "spec_helper"
+require "elk"
+
+describe Elk::SMS do
+  before { configure_elk }
+  let(:url) { "https://USERNAME:PASSWORD@api.46elks.com/a1/SMS" }
+
+  describe ".send" do
+    let(:from)    { "+46761042247" }
+    let(:to)      { "+46704508449" }
+    let(:message) { "Your order #171 has now been sent!" }
+
+    context "ordinary SMS" do
+      before(:each) do
+        stub_request(:post, url).
+          with(body: { from: from, message: message, to: to }, headers: post_headers).
+          to_return(fixture('sends_a_sms.txt'))
+      end
+
+      subject(:sms) { described_class.send(from: from, to: to, message: message) }
+
+      it "should not create warnings" do
+        expect { sms }.to_not output.to_stderr
+      end
+
+      describe "#from" do
+        subject { sms.from }
+        it { is_expected.to eq(from) }
+      end
+
+      describe "#to" do
+        subject { sms.to }
+        it { is_expected.to eq(to) }
+      end
+
+      describe "#message" do
+        subject { sms.message }
+        it { is_expected.to eq(message) }
+      end
+
+      describe "#direction" do
+        subject { sms.direction }
+        it { is_expected.to eq("outgoing") }
+      end
+
+      describe "#status" do
+        subject { sms.status }
+        it { is_expected.to eq("delivered") }
+      end
+    end
+
+    context "flash SMS" do
+      before(:each) do
+        @stub = stub_request(:post, url).
+          with(body: { from: from, message: message, to: to, flashsms: "yes" },
+               headers: post_headers).
+          to_return(fixture('sends_a_sms.txt'))
+      end
+
+      it "should send flash SMS through API" do
+        described_class.send(from: from, to: to, message: message, flash: true)
+
+        expect(@stub).to have_been_requested
+      end
+    end
+
+    context 'multiple recipients' do
+      before do
+        stub_request(:post, url).
+          with(body: { from: from, message: message, to: to.join(",") },
+               headers: post_headers).
+          to_return(fixture('sends_a_sms_to_multiple_recipients.txt'))
+      end
+
+      let(:to) { ["+46704508448", "+46704508449"] }
+
+      subject(:messages) { described_class.send(from: from, to: to, message: message) }
+
+      it "should create two messages" do
+        expect(messages.size).to eq(2)
+      end
+
+      context "first sms" do
+        subject(:sms) { messages[0] }
+
+        it "should contain first message" do
+          expect(sms.to).to eq(to[0])
+          expect(sms.message_id).to eq("sb326c7a214f9f4abc90a11bd36d6abc3")
+        end
+      end
+
+      context "second sms" do
+        subject(:sms) { messages[1] }
+
+        it "should contain second message" do
+          expect(sms.to).to eq(to[1])
+          expect(sms.message_id).to eq("s47a89d6cc51d8db395d45ae7e16e86b7")
+        end
+      end
+
+      context "with recipients as array and comma separated string" do
+        subject(:as_comma) { described_class.send(from: from, to: to.join(","), message: message) }
+        subject(:as_array) { described_class.send(from: from, to: to, message: message) }
+
+        it "response should send the same messages" do
+          expect(as_comma.map(&:message_id)).to eq(as_array.map(&:message_id))
+        end
+      end
+    end
+
+    context "with too long sender" do
+      before(:each) do
+        stub_request(:post, url).
+          with(body: { from: from, message: message, to: to }, headers: post_headers).
+          to_return(fixture('sends_a_sms_with_long_sender.txt'))
+      end
+
+      subject(:sms) { described_class.send(from: from, to: to, message: message) }
+
+      let(:from) { "VeryVeryVeryVeryLongSenderName" }
+
+      it "should create warning" do
+        expect { sms }.to output("SMS 'from' value #{from} will be capped at 11 chars\n").to_stderr
+      end
+
+      describe "#from" do
+        subject { sms.from }
+        it { is_expected.to eq(from) }
+      end
+
+      describe "#to" do
+        subject { sms.to }
+        it { is_expected.to eq(to) }
+      end
+
+      describe "#message" do
+        subject { sms.message }
+        it { is_expected.to eq(message) }
+      end
+
+      describe "#direction" do
+        subject { sms.direction }
+        it { is_expected.to eq("outgoing") }
+      end
+
+      describe "#status" do
+        subject { sms.status }
+        it { is_expected.to eq("delivered") }
+      end
+    end
+
+    context "with invalid number" do
+      before(:each) do
+        stub_request(:post, url).
+          with(body: { from: from, message: message, to: to }, headers: post_headers).
+          to_return(fixture('invalid_to_number.txt'))
+      end
+
+      let(:from) { "+46761042247" }
+      let(:to)   { "monkey" }
+
+      it 'should handle invalid to number' do
+        expect {
+          described_class.send(from: from, to: to, message: message)
+        }.to raise_error(Elk::BadRequest, "Invalid to number")
+      end
+    end
+
+    context "without parameters" do
+      it 'should handle no parameters' do
+        expect {
+          described_class.send({})
+        }.to raise_error(Elk::MissingParameter)
+      end
+    end
+  end
+
+  describe ".all" do
+    before(:each) do
+      stub_request(:get, url).
+        with(headers: get_headers).
+        to_return(fixture('sms_history.txt'))
+    end
+
+    subject(:history) { described_class.all }
+
+    it "should have return all messages" do
+      expect(history.size).to eq(3)
+    end
+
+    context "first item" do
+      subject(:sms) { history[0] }
+
+      it "should contain the correct message" do
+        expect(sms.message).to eq("Your order #171 has now been sent!")
+      end
+    end
+
+    context "second item" do
+      subject(:sms) { history[1] }
+
+      it "should contain the correct message" do
+        expect(sms.message).to eq("I'd like to order a pair of elks!")
+      end
+    end
+
+    context "third item" do
+      subject(:sms) { history[2] }
+
+      it "should contain the correct message" do
+        expect(sms.message).to eq("Want an elk?")
+      end
+    end
+  end
+
+  describe "#reload" do
+    before(:each) do
+      stub_request(:get, url).
+        with(headers: get_headers).
+        to_return(fixture('sms_history.txt'))
+
+      stub_request(:get, "https://USERNAME:PASSWORD@api.46elks.com/a1/SMS/s8952031bb83bf3e64f8e13b071c131c0").
+        with(headers: get_headers).
+        to_return(fixture('reloads_a_sms.txt'))
+    end
+
+    subject(:sms) { described_class.all.first }
+
+    it "should return true" do
+      expect(sms.reload).to be(true)
+    end
+
+    it "should not change object_id" do
+      expect { sms.reload }.to_not change { sms.object_id }
+    end
+
+    it "should update loaded_at" do
+      expect { sms.reload }.to change { sms.loaded_at }
+    end
+  end
+end