xednese 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0655d51c18e3166feda964a5401798ec46d59900
+  data.tar.gz: 31a7d981298f71cf23da411388eb4920aa5291b4
+SHA512:
+  metadata.gz: 28015566c69de2d862a79ecff04434badaa1ae2e354ce1dddfbf9b1c28f9b2c3ac37152663879285f78db37b5c1aafb72bdae7c75d01120372fc0a59be59acbc
+  data.tar.gz: afa21575f1230639c5a5da75808081638568d8d8b8dc67ac1b886de9567b3179ec07e635fcd1ad412816a3a1f250ebea9ad7e0b8e980727474f480e867143c13

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'seq', '~> 0.2.0'
+gem 'serialisable', '~> 0.0.0'
+gem 'nokogiri', '~> 1.6'
+
+gem 'rake', '~> 10.1'
+gem 'minitest', '~> 5.2'
+gem 'mocha', '~> 1.0'

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Joshua Hawxwell
+
+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,13 @@
+# Xednese
+
+``` ruby
+require 'xednese'
+
+esendex = Esendex.new('me@company.com', 'password', 'account reference')
+p esendex.messages.sent.first.body
+#=> "..."
+
+response = esendex.dispatcher.send('Hey guys', '445275XXX')
+p response.message_headers.map(&:id)
+#=> ["..."]
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/lib/xednese/accounts.rb

@@ -0,0 +1,25 @@
+class Esendex
+  class Accounts
+    def initialize(credentials)
+      @credentials = credentials
+    end
+
+    def reference
+      @credentials.account_reference
+    end
+
+    def each(&block)
+      Client.get(@credentials, 'v1.0/accounts') {|status, data|
+        Responses::Accounts.deserialise(data).accounts
+      }.each(&block)
+    end
+
+    include Enumerable
+
+    def get(id)
+      Client.get(@credentials, "v1.0/accounts/#{id}") do |status, data|
+        Responses::Account.deserialise(data)
+      end
+    end
+  end
+end

data/lib/xednese/client.rb

@@ -0,0 +1,48 @@
+class Esendex
+  class Client
+    ROOT = URI('https://api.esendex.com/')
+    USER_AGENT = "ruby/xednese-#{VERSION}"
+    CONTENT_TYPE = "application/xml"
+
+    def self.get(credentials, path, args={})
+      uri = url(path)
+      uri.query = URI.encode_www_form(args)
+      request = Net::HTTP::Get.new(uri)
+
+      code, body = execute(credentials, request)
+
+      block_given? ? yield(code, body) : [code, body]
+    end
+
+    def self.post(credentials, path, object)
+      request = Net::HTTP::Post.new(url(path))
+      request.body = object.serialise
+      request.content_type = CONTENT_TYPE
+
+      code, body = execute(credentials, request)
+
+      block_given? ? yield(code, body) : [code, body]
+    end
+
+    private
+
+    def self.url(path)
+      URI.join(ROOT.to_s, path)
+    end
+
+    def self.execute(credentials, request)
+      request["User-Agent"] = USER_AGENT
+      request.basic_auth credentials.username, credentials.password
+
+      code, body = nil, nil
+
+      Net::HTTP.start(ROOT.host, ROOT.port, use_ssl: true) do |http|
+        resp = http.request(request)
+        code = resp.code
+        body = resp.body
+      end
+
+      [code, body]
+    end
+  end
+end

data/lib/xednese/dispatcher.rb

@@ -0,0 +1,20 @@
+class Esendex
+  class Dispatcher
+    def initialize(credentials)
+      @credentials = credentials
+    end
+
+    def send(body, to)
+      args = {
+        account_reference: @credentials.account_reference,
+        messages: [{to: to, body: body}]
+      }
+
+      messages = Requests::Messages.new(args)
+
+      Client.post(@credentials, 'v1.0/messagedispatcher', messages) do |code, body|
+        Responses::MessageDispatcherHeaders.deserialise(body)
+      end
+    end
+  end
+end

data/lib/xednese/messages.rb

@@ -0,0 +1,28 @@
+class Esendex
+  class Messages
+    PAGE_COUNT = 25
+
+    def initialize(credentials)
+      @credentials = credentials
+    end
+
+    def sent
+      Seq::Paged.new do |page|
+        params = {
+          startIndex: PAGE_COUNT * page,
+          count: PAGE_COUNT
+        }
+
+        Client.get(@credentials, 'v1.0/messageheaders', params) do |status, data|
+          Responses::MessageHeaders.deserialise(data).messageheaders
+        end
+      end
+    end
+
+    def get(id)
+      Client.get(@credentials, "v1.0/messageheaders/#{id}") do |status, data|
+        Responses::MessageHeader.deserialise(data)
+      end
+    end
+  end
+end

data/lib/xednese/requests/messages.rb

@@ -0,0 +1,24 @@
+class Esendex
+  module Requests
+    class Messages
+      def initialize(args)
+        @args = args
+      end
+
+      def serialise
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.messages {
+            xml.accountreference @args[:account_reference]
+
+            @args[:messages].each do |message|
+              xml.message {
+                xml.to message[:to]
+                xml.body message[:body]
+              }
+            end
+          }
+        end.to_xml
+      end
+    end
+  end
+end

data/lib/xednese/responses/account.rb

@@ -0,0 +1,25 @@
+class Esendex
+  module Responses
+    class Account
+      extend Serialisable
+
+      root 'account'
+
+      attribute :id, 'id'
+      attribute :uri, 'uri'
+
+      element :reference, 'reference'
+      element :label, 'label'
+      element :address, 'address'
+      element :type, 'type'
+      element :messages_remaining, 'messagesremaining', Parser.for(&:to_i)
+      element :expires_on, 'expireson'
+      element :role, 'role'
+      element :settings, Class.new {
+        extend Serialisable
+        root 'settings'
+        attribute :uri, 'uri'
+      }
+    end
+  end
+end

data/lib/xednese/responses/accounts.rb

@@ -0,0 +1,10 @@
+class Esendex
+  module Responses
+    class Accounts
+      extend Serialisable
+
+      root 'accounts'
+      elements :accounts, Account
+    end
+  end
+end

data/lib/xednese/responses/message_dispatcher_headers.rb

@@ -0,0 +1,18 @@
+class Esendex
+  module Responses
+    class MessageDispatcherHeaders
+      extend Serialisable
+
+      root 'messageheaders'
+
+      attribute :batch_id, 'batchid'
+      elements :message_headers, Class.new {
+        extend Serialisable
+
+        root 'messageheader'
+        attribute :uri, 'uri'
+        attribute :id, 'id'
+      }
+    end
+  end
+end

data/lib/xednese/responses/message_header.rb

@@ -0,0 +1,33 @@
+class Esendex
+  module Responses
+    class MessageHeader
+      extend Serialisable
+
+      root 'messageheader'
+
+      attribute :id, 'id'
+      attribute :uri, 'uri'
+
+      element :status,       'status'
+      element :last_status_at, 'laststatusat', Time
+      element :submitted_at,  'submittedat', Time
+      element :type,         'type'
+      element :to,           Class.new { extend Serialisable
+        root 'to'
+        element :phonenumber, 'phonenumber'
+      }
+      element :from,         Class.new { extend Serialisable
+        root 'from'
+        element :phonenumber, 'phonenumber'
+      }
+      element :summary,      'summary'
+      element :body,         Class.new { extend Serialisable
+        root 'body'
+        attribute :uri, 'uri'
+      }
+      element :direction,    'direction'
+      element :parts,        'parts', Parser.for(&:to_i)
+      element :username,     'username'
+    end
+  end
+end

data/lib/xednese/responses/message_headers.rb

@@ -0,0 +1,15 @@
+class Esendex
+  module Responses
+    class MessageHeaders
+      extend Serialisable
+
+      root 'messageheaders'
+
+      attribute :start_index, 'startindex', Parser.for(&:to_i)
+      attribute :count,       'count',      Parser.for(&:to_i)
+      attribute :total_count, 'totalcount', Parser.for(&:to_i)
+
+      elements :message_headers, MessageHeader
+    end
+  end
+end

data/lib/xednese/responses/parser.rb

@@ -0,0 +1,11 @@
+class Esendex
+  module Responses
+    module Parser
+      def self.for(&block)
+        Class.new.tap {|klass|
+          klass.singleton_class.send(:define_method, :parse) {|s| block.call(s) }
+        }
+      end
+    end
+  end
+end

data/lib/xednese/users.rb

@@ -0,0 +1,15 @@
+class Esendex
+  class Users
+    def initialize(credentials)
+      @credentials = credentials
+    end
+
+    def username
+      @credentials.username
+    end
+
+    def password
+      @credentials.password
+    end
+  end
+end

data/lib/xednese/version.rb

@@ -0,0 +1,3 @@
+class Esendex
+  VERSION = '0.0.0'
+end

data/lib/xednese.rb

@@ -0,0 +1,46 @@
+require 'net/http'
+require 'nokogiri'
+require 'seq/paged'
+require 'serialisable'
+require 'time'
+
+require_relative 'xednese/version'
+require_relative 'xednese/client'
+
+require_relative 'xednese/requests/messages'
+
+require_relative 'xednese/responses/parser'
+require_relative 'xednese/responses/account'
+require_relative 'xednese/responses/accounts'
+require_relative 'xednese/responses/message_dispatcher_headers'
+require_relative 'xednese/responses/message_header'
+require_relative 'xednese/responses/message_headers'
+
+require_relative 'xednese/accounts'
+require_relative 'xednese/dispatcher'
+require_relative 'xednese/messages'
+require_relative 'xednese/users'
+
+class Esendex
+  Credentials = Struct.new(:username, :password, :account_reference)
+
+  def initialize(username, password, account_reference)
+    @credentials = Credentials.new(username, password, account_reference)
+  end
+
+  def account
+    Accounts.new(@credentials)
+  end
+
+  def dispatcher
+    Dispatcher.new(@credentials)
+  end
+
+  def user
+    Users.new(@credentials)
+  end
+
+  def messages
+    Messages.new(@credentials)
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,13 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/mini_test'
+
+require_relative '../lib/xednese'
+
+def dummy_esendex
+  Esendex.new('what', 'when', 'really?')
+end
+
+def dummy_credentials
+  Esendex::Credentials.new('user', 'pass', 'what?')
+end

data/spec/xednese/accounts_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../helper'
+
+describe Esendex::Accounts do
+  let(:credentials) { Esendex::Credentials.new('user', 'pass', 'ref') }
+  subject { Esendex::Accounts.new(credentials) }
+
+  describe '#reference' do
+    it 'returns the account reference' do
+      subject.reference.must_equal credentials.account_reference
+    end
+  end
+
+  describe '#each' do
+    let(:data) { mock }
+    let(:account_list) { [mock, mock] }
+    let(:accounts) { stub(accounts: account_list) }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, 'v1.0/accounts')
+        .yields(200, data)
+        .returns(account_list)
+
+      Esendex::Responses::Accounts
+        .expects(:deserialise)
+        .with(data)
+        .returns(accounts)
+
+      accounts
+        .expects(:accounts)
+        .returns(account_list)
+    }
+
+    it 'retrieves all accounts' do
+      returned_accounts = []
+      subject.each do |account|
+        returned_accounts << account
+      end
+
+      returned_accounts.must_equal account_list
+    end
+  end
+
+  describe '#get' do
+    let(:id) { "heyohid" }
+    let(:data) { mock }
+    let(:account) { mock }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, "v1.0/accounts/#{id}")
+        .yields(200, data)
+        .returns(account)
+
+      Esendex::Responses::Account
+        .expects(:deserialise)
+        .with(data)
+        .returns(account)
+    }
+
+    it 'retrieves the specified accounts' do
+      subject.get(id).must_equal account
+    end
+  end
+end

data/spec/xednese/client_spec.rb

@@ -0,0 +1,130 @@
+require_relative '../helper'
+
+describe Esendex::Client do
+  subject { Esendex::Client }
+
+  describe '.get' do
+    let(:credentials) { dummy_credentials }
+    let(:path) { "some/url/path" }
+    let(:args) { { query: "what", thing: "yep" } }
+
+    let(:expected_code) { 418 }
+    let(:expected_body) { "Hi I'm a body" }
+
+    let(:uri) { mock }
+    let(:form_params) { mock }
+    let(:http) { mock }
+    let(:get_request) { mock }
+
+    before {
+      URI.expects(:encode_www_form).with(args).returns(form_params)
+      uri.expects(:query=).with(form_params)
+      subject.expects(:url).with(path).returns(uri)
+
+      subject
+        .expects(:execute)
+        .with(credentials, get_request)
+        .returns([expected_code, expected_body])
+
+      Net::HTTP::Get.expects(:new).with(uri).returns(get_request)
+    }
+
+    it 'returns the expected status code' do
+      code, _ = subject.get(credentials, path, args)
+      code.must_equal expected_code
+    end
+
+    it 'returns the expected body' do
+      _, body = subject.get(credentials, path, args)
+      body.must_equal expected_body
+    end
+  end
+
+  describe '.post' do
+    let(:credentials) { dummy_credentials }
+
+    let(:path) { "some/url/path?query=yah" }
+
+    let(:expected_code) { 418 }
+    let(:expected_body) { "Hi I'm a body" }
+
+    let(:xml) { "</xml>" }
+    let(:serialisable_object) { stub(serialise: xml) }
+    let(:post_request) { mock }
+
+    before {
+      subject
+        .expects(:execute)
+        .with(credentials, post_request)
+        .returns([expected_code, expected_body])
+
+      Net::HTTP::Post
+        .expects(:new)
+        .with(subject::ROOT + path)
+        .returns(post_request)
+
+      post_request
+        .expects(:body=)
+        .with(xml)
+
+      post_request
+        .expects(:content_type=)
+        .with('application/xml')
+    }
+
+    it 'returns the expected status code' do
+      code, _ = subject.post(credentials, path, serialisable_object)
+      code.must_equal expected_code
+    end
+
+    it 'returns the expected body' do
+      _, body = subject.post(credentials, path, serialisable_object)
+      body.must_equal expected_body
+    end
+  end
+
+
+  describe '.execute' do
+    let(:username) { 'myusername' }
+    let(:password) { 'mypassword' }
+    let(:credentials) { Esendex::Credentials.new(username, password, 'EX00') }
+
+    let(:expected_code) { 418 }
+    let(:expected_body) { "Hi I'm a body" }
+
+    let(:http) { mock }
+    let(:request) { mock }
+    let(:response) { stub(body: expected_body, code: expected_code) }
+
+    before {
+      Net::HTTP
+        .expects(:start)
+        .with(subject::ROOT.host, subject::ROOT.port, use_ssl: true)
+        .yields(http)
+        .returns(expected_code, expected_body)
+
+      request
+        .expects(:[]=)
+        .with("User-Agent", subject::USER_AGENT)
+
+      request
+        .expects(:basic_auth)
+        .with(username, password)
+
+      http
+        .expects(:request)
+        .with(request)
+        .returns(response)
+    }
+
+    it 'returns the expected status code' do
+      code, _ = subject.send(:execute, credentials, request)
+      code.must_equal expected_code
+    end
+
+    it 'returns the expected body' do
+      _, body = subject.send(:execute, credentials, request)
+      body.must_equal expected_body
+    end
+  end
+end

data/spec/xednese/dispatcher_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../helper'
+
+describe Esendex::Dispatcher do
+  let(:credentials) { dummy_credentials }
+  subject { Esendex::Dispatcher.new(credentials) }
+
+  describe '.send' do
+    let(:body) { 'Hey I am message' }
+    let(:to) { '44123456789' }
+    let(:messages) { mock }
+    let(:response_xml) { mock }
+    let(:response_message_headers) { mock }
+
+    before {
+      args = {
+        account_reference: credentials.account_reference,
+        messages: [{ to: to, body: body }]
+      }
+
+      Esendex::Requests::Messages
+        .expects(:new)
+        .with(args)
+        .returns(messages)
+
+      Esendex::Responses::MessageDispatcherHeaders
+        .expects(:deserialise)
+        .with(response_xml)
+        .returns(response_message_headers)
+
+      Esendex::Client
+        .expects(:post)
+        .with(credentials, 'v1.0/messagedispatcher', messages)
+        .yields(200, response_xml)
+        .returns(response_message_headers)
+    }
+
+    it 'sends a single message' do
+      subject.send(body, to).must_equal response_message_headers
+    end
+  end
+end

data/spec/xednese/messages_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../helper'
+
+describe Esendex::Messages do
+  subject { dummy_esendex }
+  let(:credentials) { subject.instance_variable_get(:@credentials) }
+
+  describe '#sent' do
+    let(:xml) { "Hey I'm xml" }
+    let(:first_message) { Object.new }
+    let(:parsed_messages) { stub(messageheaders: [first_message]) }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, 'v1.0/messageheaders', startIndex: 0, count: 25)
+        .yields(200, xml)
+        .returns(parsed_messages.messageheaders)
+
+      Esendex::Responses::MessageHeaders
+        .expects(:deserialise)
+        .with(xml)
+        .returns(parsed_messages)
+    }
+
+    it 'returns the messages sent by the user on the account' do
+      sent = subject.messages.sent
+      sent.first.must_equal first_message
+    end
+  end
+
+  describe '#get' do
+    let(:message_id) { "guid" }
+    let(:xml) { "Hey I'm xml" }
+    let(:parsed_message) { Object.new }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, "v1.0/messageheaders/#{message_id}")
+        .yields(200, xml)
+        .returns(parsed_message)
+
+      Esendex::Responses::MessageHeader
+        .expects(:deserialise)
+        .with(xml)
+        .returns(parsed_message)
+    }
+
+    it 'returns the message sent with the given id' do
+      sent = subject.messages.get(message_id)
+      sent.must_equal parsed_message
+    end
+  end
+end

data/spec/xednese/requests/messages_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../helper'
+
+describe Esendex::Requests::Messages do
+  subject { Esendex::Requests::Messages }
+
+  describe '#serialise' do
+    let(:reference) { 'EX0000' }
+    let(:first) { { to: 'someone', body: 'yo' } }
+    let(:second) { { to: 'other', body: 'what?' } }
+
+    it 'returns an xml representation of the instance' do
+      messages = subject.new({
+        account_reference: reference,
+        messages: [first, second]
+      })
+
+      messages.serialise.must_equal <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<messages>
+  <accountreference>#{reference}</accountreference>
+  <message>
+    <to>#{first[:to]}</to>
+    <body>#{first[:body]}</body>
+  </message>
+  <message>
+    <to>#{second[:to]}</to>
+    <body>#{second[:body]}</body>
+  </message>
+</messages>
+EOS
+    end
+  end
+end

data/spec/xednese/responses/account_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../../helper'
+
+describe Esendex::Responses::Account do
+  describe '.deserialise' do
+
+    let(:id) { "A00F0218-510D-423D-A74E-5A65342FE070" }
+    let(:uri) { "http://api.esendex.com/v1.0/accounts/A00F0218-510D-423D-A74E-5A65342FE070" }
+    let(:reference) { "EX0000000" }
+    let(:label) { "label" }
+    let(:address) { "447700900654" }
+    let(:type) { "Professional" }
+    let(:messagesremaining) { 2000 }
+    let(:expireson) { "2999-02-25T00:00:00" }
+    let(:role) { "PowerUser" }
+    let(:settings_uri) { "http://api.esendex.com/v1.0/accounts/A00F0218-510D-423D-A74E-5A65342FE070/settings" }
+
+    let(:xml) {
+      <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<account id="#{id}" uri="#{uri}" xmlns="http://api.esendex.com/ns/">
+  <reference>#{reference}</reference>
+  <label>#{label}</label>
+  <address>#{address}</address>
+  <type>#{type}</type>
+  <messagesremaining>#{messagesremaining}</messagesremaining>
+  <expireson>#{expireson}</expireson>
+  <role>#{role}</role>
+  <settings uri="#{settings_uri}" />
+</account>
+EOS
+    }
+
+    it 'deserialises xml into an Account instance' do
+      account = Esendex::Responses::Account.deserialise(xml)
+
+      account.id.must_equal id
+      account.uri.must_equal uri
+      account.reference.must_equal reference
+      account.label.must_equal label
+      account.address.must_equal address
+      account.type.must_equal type
+      account.messages_remaining.must_equal messagesremaining
+      account.expires_on.must_equal expireson
+      account.role.must_equal role
+      account.settings.uri.must_equal settings_uri
+    end
+  end
+end

data/spec/xednese/responses/accounts_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../../helper'
+
+describe Esendex::Responses::Accounts do
+  describe '.deserialise' do
+
+    let(:id) { "A00F0218-510D-423D-A74E-5A65342FE070" }
+    let(:uri) { "http://api.esendex.com/v1.0/accounts/A00F0218-510D-423D-A74E-5A65342FE070" }
+    let(:reference) { "EX0000000" }
+    let(:label) { "label" }
+    let(:address) { "447700900654" }
+    let(:type) { "Professional" }
+    let(:messagesremaining) { 2000 }
+    let(:expireson) { "2999-02-25T00:00:00" }
+    let(:role) { "PowerUser" }
+    let(:settings_uri) { "http://api.esendex.com/v1.0/accounts/A00F0218-510D-423D-A74E-5A65342FE070/settings" }
+
+    let(:xml) {
+      <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<accounts xmlns="http://api.esendex.com/ns/">
+  <account id="#{id}" uri="#{uri}">
+    <reference>#{reference}</reference>
+    <label>#{label}</label>
+    <address>#{address}</address>
+    <type>#{type}</type>
+    <messagesremaining>#{messagesremaining}</messagesremaining>
+    <expireson>#{expireson}</expireson>
+    <role>#{role}</role>
+    <settings uri="#{settings_uri}" />
+  </account>
+</accounts>
+EOS
+    }
+
+    it 'deserialises xml into an Accounts instance' do
+      accounts = Esendex::Responses::Accounts.deserialise(xml)
+      account = accounts.accounts.first
+
+      account.id.must_equal id
+      account.uri.must_equal uri
+      account.reference.must_equal reference
+      account.label.must_equal label
+      account.address.must_equal address
+      account.type.must_equal type
+      account.messages_remaining.must_equal messagesremaining
+      account.expires_on.must_equal expireson
+      account.role.must_equal role
+      account.settings.uri.must_equal settings_uri
+    end
+  end
+end

data/spec/xednese/responses/message_dispatcher_headers_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../../helper'
+
+describe Esendex::Responses::MessageDispatcherHeaders do
+  subject { Esendex::Responses::MessageDispatcherHeaders }
+
+  describe '.deserialise' do
+    let(:batch_id) { "F8BF9867-FF81-49E4-ACC5-774DE793B776" }
+    let(:header_uri) { "https://api.esendex.com/v1.0/MessageHeaders/1183C73D-2E62-4F60-B610-30F160BDFBD5" }
+    let(:header_id) { "1183C73D-2E62-4F60-B610-30F160BDFBD5" }
+
+    let(:xml) {
+      <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<messageheaders batchid="#{batch_id}"
+    xmlns="http://api.esendex.com/ns/">
+  <messageheader uri="#{header_uri}" id="#{header_id}" />
+</messageheaders>
+EOS
+    }
+
+    it 'deserialises xml into a MessageDispatcherHeaders instance' do
+      headers = subject.deserialise(xml)
+
+      headers.batch_id.must_equal batch_id
+      headers.message_headers.first.uri.must_equal header_uri
+      headers.message_headers.first.id.must_equal header_id
+    end
+  end
+end

data/spec/xednese/responses/message_header_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../../helper'
+
+describe Esendex::Responses::MessageHeader do
+  describe '.deserialise' do
+
+    let(:id) { "CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC" }
+    let(:uri) { "http://api.esendex.com/v1.0/messageheaders/CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC/" }
+    let(:status) { "Delivered" }
+    let(:laststatusat) { "2010-01-01T12:00:05.000" }
+    let(:submittedat) { "2010-01-01T12:00:02.000" }
+    let(:type) { "SMS" }
+    let(:to) { "447700900123" }
+    let(:from) { "447700900654" }
+    let(:summary) { "Testing REST API" }
+    let(:body) { "http://api.esendex.com/v1.0/messageheaders/CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC/body" }
+    let(:direction) { "Outbound" }
+    let(:parts) { 1 }
+    let(:username) { "user@example.com" }
+
+    let(:xml) {
+      <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<messageheader id="#{id}" uri="#{uri}" xmlns="http://api.esendex.com/ns/">
+  <status>#{status}</status>
+  <laststatusat>#{laststatusat}</laststatusat>
+  <submittedat>#{submittedat}</submittedat>
+  <type>#{type}</type>
+  <to>
+    <phonenumber>#{to}</phonenumber>
+  </to>
+  <from>
+    <phonenumber>#{from}</phonenumber>
+  </from>
+  <summary>#{summary}</summary>
+  <body uri="#{body}"/>
+  <direction>#{direction}</direction>
+  <parts>#{parts}</parts>
+  <username>#{username}</username>
+</messageheader>
+EOS
+      }
+
+    it 'deseralises xml into a MessageHeader instance' do
+      message_header = Esendex::Responses::MessageHeader.deserialise(xml)
+
+      message_header.id.must_equal id
+      message_header.uri.must_equal uri
+      message_header.status.must_equal status
+      message_header.last_status_at.must_equal Time.parse(laststatusat)
+      message_header.submitted_at.must_equal Time.parse(submittedat)
+      message_header.type.must_equal type
+      message_header.to.phonenumber.must_equal to
+      message_header.from.phonenumber.must_equal from
+      message_header.summary.must_equal summary
+      message_header.body.uri.must_equal body
+      message_header.direction.must_equal direction
+      message_header.parts.must_equal parts
+      message_header.username.must_equal username
+    end
+  end
+end

data/spec/xednese/responses/message_headers_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../helper'
+
+describe Esendex::Responses::MessageHeaders do
+  describe '.deserialise' do
+
+    let(:startindex) { 5 }
+    let(:count) { 15 }
+    let(:totalcount) { 200 }
+
+    let(:id) { "CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC" }
+    let(:uri) { "http://api.esendex.com/v1.0/messageheaders/CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC/" }
+    let(:status) { "Delivered" }
+    let(:laststatusat) { "2010-01-01T12:00:05.000" }
+    let(:submittedat) { "2010-01-01T12:00:02.000" }
+    let(:type) { "SMS" }
+    let(:to) { "447700900123" }
+    let(:from) { "447700900654" }
+    let(:summary) { "Testing REST API" }
+    let(:body) { "http://api.esendex.com/v1.0/messageheaders/CDEB3533-1F76-46D7-A2A9-0DAF8290F7FC/body" }
+    let(:direction) { "Outbound" }
+    let(:parts) { 1 }
+    let(:username) { "user@example.com" }
+
+    let(:xml) {
+      <<EOS
+<?xml version="1.0" encoding="utf-8"?>
+<messageheaders startindex="#{startindex}" count="#{count}" totalcount="#{totalcount}" xmlns="http://api.esendex.com/ns/">
+  <messageheader id="#{id}" uri="#{uri}" xmlns="http://api.esendex.com/ns/">
+    <status>#{status}</status>
+    <laststatusat>#{laststatusat}</laststatusat>
+    <submittedat>#{submittedat}</submittedat>
+    <type>#{type}</type>
+    <to>
+      <phonenumber>#{to}</phonenumber>
+    </to>
+    <from>
+      <phonenumber>#{from}</phonenumber>
+    </from>
+    <summary>#{summary}</summary>
+    <body uri="#{body}"/>
+    <direction>#{direction}</direction>
+    <parts>#{parts}</parts>
+    <username>#{username}</username>
+  </messageheader>
+</messageheaders>
+EOS
+      }
+
+    it 'deserialises xml into a MessageHeaders instance' do
+      message_headers = Esendex::Responses::MessageHeaders.deserialise(xml)
+
+      message_headers.start_index.must_equal startindex
+      message_headers.count.must_equal count
+      message_headers.total_count.must_equal totalcount
+
+      message_header = message_headers.message_headers.first
+
+      message_header.id.must_equal id
+      message_header.uri.must_equal uri
+      message_header.status.must_equal status
+      message_header.last_status_at.must_equal Time.parse(laststatusat)
+      message_header.submitted_at.must_equal Time.parse(submittedat)
+      message_header.type.must_equal type
+      message_header.to.phonenumber.must_equal to
+      message_header.from.phonenumber.must_equal from
+      message_header.summary.must_equal summary
+      message_header.body.uri.must_equal body
+      message_header.direction.must_equal direction
+      message_header.parts.must_equal parts
+      message_header.username.must_equal username
+    end
+  end
+end

data/spec/xednese/users_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../helper'
+
+describe Esendex::Users do
+  let(:credentials) { Esendex::Credentials.new('user', 'pass', 'ref') }
+  subject { Esendex::Users.new(credentials) }
+
+  describe '#username' do
+    it 'returns the username' do
+      subject.username.must_equal credentials.username
+    end
+  end
+
+  describe '#password' do
+    it 'returns the password' do
+      subject.password.must_equal credentials.password
+    end
+  end
+end

data/spec/xednese_spec.rb

@@ -0,0 +1,59 @@
+require_relative 'helper'
+
+describe Esendex do
+
+  subject { dummy_esendex }
+  let(:credentials) { subject.instance_variable_get(:@credentials) }
+
+  describe '#account' do
+    let(:account) { Object.new }
+
+    it 'returns a new Accounts instance' do
+      Esendex::Accounts
+        .expects(:new)
+        .with(credentials)
+        .returns(account)
+
+      subject.account.must_equal account
+    end
+  end
+
+  describe '#dispatcher' do
+    let(:dispatcher) { Object.new }
+
+    it 'returns a new Dispatcher instance' do
+      Esendex::Dispatcher
+        .expects(:new)
+        .with(credentials)
+        .returns(dispatcher)
+
+      subject.dispatcher.must_equal dispatcher
+    end
+  end
+
+  describe '#messages' do
+    let(:messages) { Object.new }
+
+    it 'returns a new Messages instance' do
+      Esendex::Messages
+        .expects(:new)
+        .with(credentials)
+        .returns(messages)
+
+      subject.messages.must_equal messages
+    end
+  end
+
+  describe '#user' do
+    let(:user) { Object.new }
+
+    it 'returns a new Users instance' do
+      Esendex::Users
+        .expects(:new)
+        .with(credentials)
+        .returns(user)
+
+      subject.user.must_equal user
+    end
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: xednese
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Joshua Hawxwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: seq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: serialisable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |2
+      Xednese provides an easy to use client for interacting with the Esendex
+      REST API.
+email: m@hawx.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Gemfile
+- Rakefile
+- LICENSE
+- lib/xednese.rb
+- lib/xednese/accounts.rb
+- lib/xednese/client.rb
+- lib/xednese/messages.rb
+- lib/xednese/version.rb
+- lib/xednese/users.rb
+- lib/xednese/responses/accounts.rb
+- lib/xednese/responses/message_headers.rb
+- lib/xednese/responses/parser.rb
+- lib/xednese/responses/message_header.rb
+- lib/xednese/responses/account.rb
+- lib/xednese/responses/message_dispatcher_headers.rb
+- lib/xednese/dispatcher.rb
+- lib/xednese/requests/messages.rb
+- spec/helper.rb
+- spec/xednese_spec.rb
+- spec/xednese/accounts_spec.rb
+- spec/xednese/responses/message_header_spec.rb
+- spec/xednese/responses/message_dispatcher_headers_spec.rb
+- spec/xednese/responses/accounts_spec.rb
+- spec/xednese/responses/account_spec.rb
+- spec/xednese/responses/message_headers_spec.rb
+- spec/xednese/dispatcher_spec.rb
+- spec/xednese/messages_spec.rb
+- spec/xednese/requests/messages_spec.rb
+- spec/xednese/client_spec.rb
+- spec/xednese/users_spec.rb
+homepage: http://github.com/hawx/xednese
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Client library for interacting with the Esendex API
+test_files:
+- spec/helper.rb
+- spec/xednese_spec.rb
+- spec/xednese/accounts_spec.rb
+- spec/xednese/responses/message_header_spec.rb
+- spec/xednese/responses/message_dispatcher_headers_spec.rb
+- spec/xednese/responses/accounts_spec.rb
+- spec/xednese/responses/account_spec.rb
+- spec/xednese/responses/message_headers_spec.rb
+- spec/xednese/dispatcher_spec.rb
+- spec/xednese/messages_spec.rb
+- spec/xednese/requests/messages_spec.rb
+- spec/xednese/client_spec.rb
+- spec/xednese/users_spec.rb