cellcom 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec8f641893a1d5e7056904a055b2ef339b7d82fe
+  data.tar.gz: ebd13684c4f1b3206a0fc62ae7e43641904b1348
+SHA512:
+  metadata.gz: b3ced4b2e2eb4e96d9c5e3b52a35fc3247032228597c3f84be55a49a1eeb7ef6b4f51568cc25c8e22edb97df86bb52a5f36fdc0b7566115c48dcb877d7a023e9
+  data.tar.gz: 0ba304e1e2ec43989fe750f71dba80bb5b17324e36514a517a9707a3eb7a06e2ccb9d87a0c3c50c7d76ae49d4d9b1cba81b6cd2ef5ff8d705d8a7f952c954ea7

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=documentation

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+sudo: false
+cache: bundler
+
+rvm:
+  - jruby-head
+  - ruby-head
+  - rbx-2.2.10
+  - 2.1.5
+  - 2.0.0
+  - 1.9.3
+
+matrix:
+  allow_failures:
+    - rvm: 1.9.3
+    - rvm: rbx-2.2.10
+

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake',  '~> 10.0'
+gem 'rspec', '~> 3.2.0'
+gem 'coveralls', require: false
+#gem 'attestor', git: 'https://github.com/gregory/attestor.git', branch: 'cellcom_dev'
+
+group :extra do
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 gregory
+
+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,61 @@
+# Cellcom
+
+[![Build](https://travis-ci.org/gregory/cellcom.png?branch=master)](https://travis-ci.org/gregory/cellcom)
+[![Code Climate](https://codeclimate.com/github/gregory/cellcom/badges/gpa.svg)](https://codeclimate.com/github/gregory/cellcom)
+[![Coverage Status](https://coveralls.io/repos/gregory/cellcom/badge.svg?branch=master)](https://coveralls.io/r/gregory/cellcom?branch=master)
+
+Cellcom is a ruby wrapper around the [Cellcom](https://www.cellcom.eu/en/) [HTTP API Spec](http://www.cellcom.be/documenten/Technical%20Specification%20HTTP%20gateway%20v8.pdf).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cellcom'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cellcom
+
+## Usage
+
+```rb
+Cellcom::Configure do |config|
+  config.clid = 12345
+  config.gwid = 123
+  config.pwd  = "256ea978c8f8752eaf87e7a"
+end
+
+Cellcom::Sms.new(m: 'my message', to: '32496233133', sid: '3228886991').deliver
+```
+
+If for some reason you want to send from multiple accounts:
+
+```rb
+credentials_hash = {
+  clid: 12345,
+  gwid: 123,
+  pwd : "256ea978c8f8752eaf87e7a"
+}
+Cellcom::Client.new(credentials_hash).deliver(m: 'my message', to: '32496233133', sid: '3228886991')
+
+# or
+
+sms = Cellcom::Sms.new(m: 'my message', to: '32496233133', sid: '3228886991')
+client = Cellcom::Client.new(clid: 12345, gwid: 123, pwd : "256ea978c8f8752eaf87e7a")
+sms.deliver(client)
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/gregory/cellcom/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,11 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'coveralls/rake/task'
+
+RSpec::Core::RakeTask.new
+Coveralls::RakeTask.new
+
+task :test_with_coveralls => [:spec, 'coveralls:push']
+
+task :default => :spec
+

data/cellcom.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cellcom/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cellcom"
+  spec.version       = Cellcom::VERSION
+  spec.authors       = ["gregory"]
+  spec.email         = ["greg2502@gmail.com"]
+  spec.summary       = %q{Ruby Wrapper around the Cellcom api}
+  spec.description   = %q{More info here: https://www.cellcom.eu/en/}
+  spec.homepage      = "https://github.com/gregory/cellcom"
+  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_dependency "attestor", "~> 2.2.1"
+end

data/lib/cellcom.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+require 'attestor'
+require 'cellcom/version'
+require 'cellcom/client'
+
+module Cellcom
+  class Configuration < OpenStruct
+    include Attestor::Validations
+
+    CredentialsPolicy = Attestor::Policy.new(:credentials) do
+      REQUIRED_CREDENTIALS = [:pw, :clid, :gwid ]
+
+      def validate!
+        defined_keys = REQUIRED_CREDENTIALS & credentials.keys
+        unless REQUIRED_CREDENTIALS == defined_keys
+          invalid "#{(REQUIRED_CREDENTIALS-defined_keys).join(', ')} needs to be defined"
+        end
+      end
+    end
+
+    validates {CredentialsPolicy.new(self.to_h) }
+
+    def initialize(h={})
+      super default_attributes.merge(h)
+    end
+
+    private
+
+    def default_attributes
+      {
+        sid: '3228000000'
+      }
+    end
+  end
+
+  module_function
+
+  def client(params=config.to_h)
+    Client.new(params)
+  end
+
+  def config
+    @config ||= Configuration.new
+  end
+
+  def configure
+    config.tap { |configuration| yield(configuration) }
+    config.validate!
+  end
+end

data/lib/cellcom/client.rb

@@ -0,0 +1,36 @@
+require 'cellcom/request'
+require 'cellcom/response'
+require 'cellcom/sms'
+
+module Cellcom
+  class Client
+    Error = Class.new(StandardError)
+
+    attr_reader :credentials
+
+    def initialize(params=Cellcom.config.to_h)
+      Configuration::CredentialsPolicy.new(params).validate!
+      @credentials = params
+    rescue Attestor::InvalidError
+      fail(Error)
+    end
+
+    def deliver(params)
+      Sms::MessagePolicy.new(params).validate!
+      Response.new request(params).get
+    rescue Attestor::InvalidError
+      fail Error
+    end
+
+    private
+
+    def request(params)
+      payload = upcase_keys_of_hash @credentials.merge(params)
+      Request.new payload
+    end
+
+    def upcase_keys_of_hash(params)
+      Hash[params.map { |k,v| [k.upcase, v] }]
+    end
+  end
+end

data/lib/cellcom/request.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+require 'uri'
+
+module Cellcom
+  class Request
+    API_URL = 'http://www.cellcom.be/data/bulkHTTP.php'
+
+    def initialize(params={})
+      @params = params
+    end
+
+    def get(opts={})
+      connection(opts).start { |conn| conn.request(Net::HTTP::Get.new(uri)) }
+    end
+
+    def connection(opts={})
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        http.open_timeout = http.read_timeout = opts[:timeout] if opts.key? :timeout
+      end
+    end
+
+    def uri
+      URI(API_URL).tap do |uri|
+        uri.query = URI.encode_www_form(@params)
+      end
+    end
+  end
+end

data/lib/cellcom/response.rb

@@ -0,0 +1,36 @@
+require 'forwardable'
+module Cellcom
+  class Response
+    extend Forwardable
+
+    ERRORS = {
+      'ERROR 10' => ['WrongCredentials', 'Wrong client id or password'],
+      'ERROR 20' => ['WrongGateway', 'Wrong gateway number (GWID)'],
+      'ERROR 30' => ['NotEnoughCredit', 'Not enough credit left'],
+      'ERROR 40' => ['WrongDestination', 'Recipient number is wrong, or destination not covered'],
+      'ERROR 50' => ['SenderIdNotSupported', 'Sender ID not supported'],
+      'ERROR 60' => ['InvalidMessage', 'Message is too long or invalid'],
+      'ERROR 70' => ['Timeout', 'Timeout, please retry later'],
+      'ERROR 80' => ['InternalError', 'Internal error, please contact Cellcom']
+    }.freeze
+
+    ERRORS.each do |key,(class_name, _)|
+      const_set(class_name, Class.new(StandardError))
+    end
+
+    attr_reader :raw_response
+    def_delegators :@raw_response, :code, :body
+
+    alias_method :status, :code
+
+    def initialize(raw_response)
+      @raw_response = raw_response
+      raise_error(raw_response.body) if ERRORS.keys.include?(raw_response.body)
+    end
+
+    def raise_error(error_key)
+      error_val = ERRORS.fetch(error_key)
+      fail Response.const_get(error_val[0]), error_val[1]
+    end
+  end
+end

data/lib/cellcom/sms.rb

@@ -0,0 +1,69 @@
+require 'forwardable'
+require 'attestor'
+
+module Cellcom
+  class Sms < OpenStruct
+    extend Forwardable
+    include Attestor::Validations
+
+    MessagePolicy = Attestor::Policy.new(:attributes) do
+      REQUIRED_ATTRIBUTES = [:to, :m]
+
+      def validate!
+        validate_require_attributes
+        validate_ttl if attributes[:ttl]
+        validate_mid if attributes[:mid]
+        validate_msg_hexa_encoded if attributes[:cod] == 2
+      end
+
+      private
+
+      def validate_ttl
+        unless 60 <= attributes[:ttl] && attributes[:ttl] <= 10080
+          invalid "invalid ttl: Must be: 60 <= ttl <= 10080(default)"
+        end
+      end
+
+      def validate_mid
+        unless 1 < attributes[:mid] && attributes[:mid] < 4294967295
+          invalid "invalid mid: Must be: 1 < mid < 4294967295"
+        end
+      end
+
+      def validate_require_attributes
+        undefined_keys = REQUIRED_ATTRIBUTES - attributes.keys
+        unless undefined_keys.empty?
+          invalid "invalid message: #{undefined_keys.join(', ')} needs to be defined"
+        end
+      end
+
+      def validate_msg_hexa_encoded
+        unless attributes[:m][/\H/]
+          invalid "message needs to be hexadecimal when cod == 2"
+        end
+      end
+    end
+
+    def initialize(params={})
+      super(default_values.merge(params))
+    end
+
+    validates { MessagePolicy.new(self.to_h) }
+
+    def deliver(client=Cellcom.client)
+      client.deliver(self.to_h)
+    end
+
+    def to_hex
+      message.unpack('H*')[0]
+    end
+
+    private
+
+    def default_values
+      {
+        ttl: 10080
+      }
+    end
+  end
+end

data/lib/cellcom/version.rb

@@ -0,0 +1,3 @@
+module Cellcom
+  VERSION = "0.1.0"
+end

data/spec/lib/cellcom/client_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Cellcom::Client do
+  let(:credentials) do
+    {
+      clid: 'client id',
+      gwid: 'gateway id',
+      pw: 'password'
+    }
+  end
+
+  let(:client) { described_class.new(credentials) }
+
+  context 'when credential missing' do
+    let(:credentials) do
+      {
+        clid: 'client id',
+        gwid: 'gateway id',
+      }
+    end
+
+    it 'fails' do
+      expect { client }.to raise_error(Cellcom::Client::Error)
+    end
+  end
+
+  describe '#deliver(payload)' do
+    let(:message) { 'foo bar' }
+    let(:payload) do
+      {
+        m: message,
+        to: '32496233133',
+        sid: '3228886991'
+      }
+    end
+
+    let(:code) { 200 }
+    let(:response_body) { 'OK 11111111111111111111111' }
+    let(:response) { OpenStruct.new(code: code, body: response_body) }
+
+    before do
+      client.stub_chain(:request, :get).and_return(response)
+    end
+
+    subject { client.deliver(payload) }
+
+    it 'sends the message' do
+      expect(subject.status).to eq code
+      expect(subject.body).to eq response_body
+    end
+
+    context 'when invalid sms' do
+      let(:payload) do
+        {
+          to: '32496233133',
+          sid: '3228886991'
+        }
+      end
+
+      it 'fails exception' do
+        expect { subject }.to raise_error(Cellcom::Client::Error)
+      end
+    end
+  end
+end

data/spec/lib/cellcom/request_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Cellcom::Request do
+  describe '#get(opts={})' do
+    let(:params) do
+      {
+        M: 'foo',
+        SID: 'bar'
+      }
+    end
+    let(:connection) { double(:connection) }
+    let(:http) { double(:http) }
+    let(:request) { described_class.new(params) }
+
+    before do
+      expect(request).to receive(:connection).and_return(http)
+      expect(http).to receive(:start).and_yield(connection)
+    end
+
+    after { request.get }
+
+    it 'makes the request' do
+      expect(connection).to receive(:request).with(an_instance_of(Net::HTTP::Get))
+    end
+  end
+end

data/spec/lib/cellcom/response_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Cellcom::Response do
+  describe '.new(response)' do
+    let(:code) { 200 }
+    let(:response_body) { 'OK 11111111111111111111111' }
+    let(:raw_response) { OpenStruct.new(code: code, body: response_body) }
+    let(:response) { described_class.new(raw_response) }
+
+    it 'sets the response' do
+      expect(response.code).to eq code
+      expect(response.body).to eq response_body
+    end
+
+    described_class::ERRORS.each do |resp_body, (exception, message)|
+      context "#{message}" do
+        let(:response_body) { resp_body }
+
+        it "fails a #{exception} exception" do
+          expect { response }.to raise_error(Cellcom::Response.const_get(exception))
+        end
+      end
+    end
+  end
+end

data/spec/lib/cellcom/sms_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Cellcom::Sms do
+    let(:message) { 'foo bar' }
+    let(:ttl) { 70 }
+    let(:mid) { 70 }
+    let(:payload) do
+      {
+        m: message,
+        to: '32496233133',
+        sid: '3228886991',
+        ttl: ttl,
+        mid: mid
+      }
+    end
+
+  describe '.new(params)' do
+    subject { described_class.new(payload) }
+
+    it 'sets the params' do
+      payload.each { |k,v| expect(subject.send(k)).to eq v }
+    end
+
+    it 'is valid' do
+      expect(subject.validate).to be_valid
+    end
+
+    context 'when invalid ttl' do
+      let(:ttl) { 50 }
+
+      it 'fails at validation' do
+        expect { subject.validate! }.to raise_error(Attestor::InvalidError)
+      end
+    end
+
+    context 'when invalid mid' do
+      let(:mid) { 4294967296 }
+
+      it 'fails at validation' do
+        expect { subject.validate! }.to raise_error(Attestor::InvalidError)
+      end
+    end
+  end
+
+  describe '.deliver(client=Cellcom.client)' do
+    let(:client) { double(:client) }
+    let(:sms) { described_class.new(payload) }
+
+    after { sms.deliver(client) }
+
+    it 'sends calls deliver on the client' do
+      expect(client).to receive(:deliver).with(sms.to_h)
+    end
+  end
+end

data/spec/lib/cellcom_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Cellcom do
+  describe '.configure' do
+    let(:credentials) do
+      {
+        clid: 'client id',
+        gwid: 'gateway id',
+        pw: 'password'
+      }
+    end
+
+    subject do
+      described_class.configure { |c| credentials.each { |k,v| c.send(:"#{k}=", v) } }
+    end
+
+    it 'has the config variables' do
+      subject
+      credentials.each { |k,v| expect(described_class.config.send(k)).to eq v }
+    end
+
+    context 'when credentials missing' do
+      let(:credentials) do
+        {
+          clid: 'client id',
+          gwid: 'gateway id',
+        }
+      end
+
+      before do
+        described_class.instance_variable_set("@config", nil)
+      end
+
+      it 'fails if credentials missing' do
+        expect { subject }.to raise_error(Attestor::InvalidError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+Bundler.setup(:default, :extra)
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'pry'
+require 'cellcom'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.order                            = 'random'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: cellcom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- gregory
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: attestor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+description: 'More info here: https://www.cellcom.eu/en/'
+email:
+- greg2502@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cellcom.gemspec
+- lib/cellcom.rb
+- lib/cellcom/client.rb
+- lib/cellcom/request.rb
+- lib/cellcom/response.rb
+- lib/cellcom/sms.rb
+- lib/cellcom/version.rb
+- spec/lib/cellcom/client_spec.rb
+- spec/lib/cellcom/request_spec.rb
+- spec/lib/cellcom/response_spec.rb
+- spec/lib/cellcom/sms_spec.rb
+- spec/lib/cellcom_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gregory/cellcom
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby Wrapper around the Cellcom api
+test_files:
+- spec/lib/cellcom/client_spec.rb
+- spec/lib/cellcom/request_spec.rb
+- spec/lib/cellcom/response_spec.rb
+- spec/lib/cellcom/sms_spec.rb
+- spec/lib/cellcom_spec.rb
+- spec/spec_helper.rb