xednese 0.0.1 → 0.1.0

data/spec/xednese/account_spec.rb

@@ -0,0 +1,93 @@
+require 'helper'
+
+describe Esendex::Account do
+  let(:response)   { mock }
+  let(:credentials) { dummy_credentials }
+  subject { Esendex::Account.new(credentials, response) }
+
+  [:id, :reference, :address, :messages_remaining,
+   :type, :expires_on, :role].each do |value|
+    describe "##{value}" do
+      before     {
+        @value = mock
+        response.expects(value).returns(@value)
+      }
+
+      it "returns the #{value} from the response" do
+        subject.send(value).must_equal @value
+      end
+    end
+  end
+
+  describe '#label' do
+    let(:label) { mock }
+    before      { response.expects(:label).returns(label) }
+
+    it 'returns the label from the response' do
+      subject.label.must_equal label
+    end
+  end
+
+  describe '#label=' do
+    let(:id)        { "587329572387275372" }
+    let(:new_label) { "this is my account" }
+    let(:request)   { mock }
+
+    before {
+      subject
+        .expects(:id)
+        .returns(id)
+
+      Esendex::Requests::Account
+        .expects(:new)
+        .with(label: new_label)
+        .returns(request)
+
+      Esendex::Client
+        .expects(:put)
+        .with(credentials, "v1.0/accounts/#{id}", request)
+        .yields(200)
+    }
+
+    it 'sets the label for the account' do
+      (subject.label = new_label).must_equal new_label
+    end
+
+    it 'makes #label return the new label' do
+      subject.label = new_label
+      subject.label.must_equal new_label
+    end
+  end
+
+  describe '#dispatcher' do
+    let(:reference)  { mock }
+    let(:dispatcher) { mock }
+
+    it 'returns a new Dispatcher instance' do
+      subject.expects(:reference).returns(reference)
+
+      Esendex::Account::Dispatcher
+        .expects(:new)
+        .with(credentials, reference)
+        .returns(dispatcher)
+
+      subject.dispatcher.must_equal dispatcher
+    end
+  end
+
+  describe '#messages' do
+    let(:reference) { mock }
+    let(:messages)  { mock }
+
+    it 'returns a new Messages instance' do
+      subject.expects(:reference).returns(reference)
+
+      Esendex::Account::Messages
+        .expects(:new)
+        .with(credentials, reference)
+        .returns(messages)
+
+      subject.messages.must_equal messages
+    end
+  end
+end

data/spec/xednese/accounts_spec.rb

@@ -1,19 +1,14 @@
-require_relative '../helper'
+require 'helper'
 
 describe Esendex::Accounts do
-  let(:credentials) { Esendex::Credentials.new('user', 'pass', 'ref') }
+  let(:credentials) { dummy_credentials }
   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(:data_list) { [mock, mock] }
+    let(:accounts) { stub(accounts: data_list) }
     let(:account_list) { [mock, mock] }
-    let(:accounts) { stub(accounts: account_list) }
 
     before {
       Esendex::Client
@@ -29,7 +24,11 @@ describe Esendex::Accounts do
 
       accounts
         .expects(:accounts)
-        .returns(account_list)
+        .returns(data_list)
+
+      data_list.zip(account_list).each do |d, a|
+        Esendex::Account.expects(:new).with(credentials, d).returns(a)
+      end
     }
 
     it 'retrieves all accounts' do
@@ -43,9 +42,10 @@ describe Esendex::Accounts do
   end
 
   describe '#get' do
-    let(:id) { "heyohid" }
-    let(:data) { mock }
-    let(:account) { mock }
+    let(:id)       { SecureRandom.uuid }
+    let(:data)     { mock }
+    let(:response) { mock }
+    let(:account)  { mock }
 
     before {
       Esendex::Client
@@ -57,10 +57,15 @@ describe Esendex::Accounts do
       Esendex::Responses::Account
         .expects(:deserialise)
         .with(data)
+        .returns(response)
+
+      Esendex::Account
+        .expects(:new)
+        .with(credentials, response)
         .returns(account)
     }
 
-    it 'retrieves the specified accounts' do
+    it 'retrieves the specified account' do
       subject.get(id).must_equal account
     end
   end

data/spec/xednese/batch_spec.rb

@@ -0,0 +1,121 @@
+require 'helper'
+
+describe Esendex::Batch do
+  let(:credentials) { dummy_credentials }
+  let(:response) { mock }
+  subject { Esendex::Batch.new(credentials, response) }
+
+  [:id, :created_at, :batch_size, :persisted_batch_size,
+   :account_reference, :created_by, :name].each do |thing|
+    describe "##{thing}" do
+      before {
+        @value = mock
+        response.expects(thing).returns(@value)
+      }
+
+      it "returns the #{thing} from the response" do
+        subject.send(thing).must_equal @value
+      end
+    end
+  end
+
+  describe '#status' do
+    let(:status) { mock(acknowledged: 0,
+                        authorisation_failed: 0,
+                        connecting: 0,
+                        delivered: 0,
+                        failed: 0,
+                        partially_delivered: 0,
+                        rejected: 0,
+                        scheduled: 0,
+                        sent: 0,
+                        submitted: 0,
+                        validity_period_expired: 0,
+                        cancelled: 1) }
+
+    before {
+      response.expects(:status).returns(status)
+    }
+
+    it 'returns the status that is set to 1' do
+      subject.status.must_equal :cancelled
+    end
+  end
+
+  describe '#name=' do
+    let(:id)       { SecureRandom.uuid }
+    let(:new_name) { "this is my batch" }
+    let(:request)  { mock }
+
+    before {
+      subject
+        .expects(:id)
+        .returns(id)
+
+      Esendex::Requests::Batch
+        .expects(:new)
+        .with(name: new_name)
+        .returns(request)
+
+      Esendex::Client
+        .expects(:put)
+        .with(credentials, "v1.1/messagebatches/#{id}", request)
+        .yields(204)
+    }
+
+    it 'sets the name of the batch' do
+      (subject.name = new_name).must_equal new_name
+    end
+
+    it 'makes #name return the new name' do
+      subject.name = new_name
+      subject.name.must_equal new_name
+    end
+  end
+
+  describe '#cancel!' do
+    let(:id)      { SecureRandom.uuid }
+    let(:request) { mock }
+
+    before {
+      subject.expects(:id).returns(id)
+
+      Esendex::Client
+        .expects(:delete)
+        .with(credentials, "v1.1/messagebatches/#{id}/schedule")
+        .yields(204)
+    }
+
+    it 'cancels the message batch' do
+      subject.cancel!
+    end
+  end
+
+  describe '#messages' do
+    let(:id) { SecureRandom.uuid }
+    let(:xml) { mock }
+    let(:first_message) { mock }
+    let(:parsed_messages) { stub(message_headers: [first_message]) }
+
+    before {
+      subject.expects(:id).returns(id)
+
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, "v1.0/messagebatches/#{id}/messages",
+              startIndex: 0, count: 25)
+        .yields(200, xml)
+        .returns(parsed_messages.message_headers)
+
+      Esendex::Responses::MessageHeaders
+        .expects(:deserialise)
+        .with(xml)
+        .returns(parsed_messages)
+    }
+
+    it 'returns the messages in the batch' do
+      messages = subject.messages
+      messages.first.must_equal first_message
+    end
+  end
+end

data/spec/xednese/batches_spec.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+describe Esendex::Batches do
+  let(:credentials) { dummy_credentials }
+  subject { Esendex::Batches.new(credentials) }
+
+  describe '#each' do
+    let(:data) { mock }
+    let(:data_list) { [mock, mock] }
+    let(:batches) { stub(batches: data_list) }
+    let(:batch_list) { [mock, mock] }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, 'v1.1/messagebatches')
+        .yields(200, data)
+        .returns(batch_list)
+
+      Esendex::Responses::Batches
+        .expects(:deserialise)
+        .with(data)
+        .returns(batches)
+
+      batches.expects(:batches).returns(data_list)
+
+      data_list.zip(batch_list).each do |d, b|
+        Esendex::Batch.expects(:new).with(credentials, d).returns(b)
+      end
+    }
+
+    it 'retrieves all batches' do
+      returned_batches = []
+      subject.each do |batch|
+        returned_batches << batch
+      end
+
+      returned_batches.must_equal batch_list
+    end
+  end
+
+  describe '#get' do
+    let(:id)       { SecureRandom.uuid }
+    let(:data)     { mock }
+    let(:response) { mock }
+    let(:batch)    { mock }
+
+    before {
+      Esendex::Client
+        .expects(:get)
+        .with(credentials, "v1.1/messagebatches/#{id}")
+        .yields(200, data)
+        .returns(batch)
+
+      Esendex::Responses::Batch
+        .expects(:deserialise)
+        .with(data)
+        .returns(response)
+
+      Esendex::Batch
+        .expects(:new)
+        .with(credentials, response)
+        .returns(batch)
+    }
+
+    it 'retrieves the specified message batch' do
+      subject.get(id).must_equal batch
+    end
+  end
+end

data/spec/xednese/client_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../helper'
+require 'helper'
 
 describe Esendex::Client do
   subject { Esendex::Client }
@@ -39,6 +39,38 @@ describe Esendex::Client do
       body.must_equal expected_body
     end
   end
+  describe '.get' do
+    let(:credentials) { dummy_credentials }
+    let(:path) { "some/url/path" }
+
+    let(:expected_code) { 418 }
+    let(:expected_body) { "Hi I'm a body" }
+
+    let(:uri) { mock }
+    let(:http) { mock }
+    let(:get_request) { mock }
+
+    before {
+      subject.expects(:url).with(path).returns(uri)
+
+      subject
+        .expects(:execute)
+        .with(credentials, get_request)
+        .returns([expected_code, expected_body])
+
+      Net::HTTP::Delete.expects(:new).with(uri).returns(get_request)
+    }
+
+    it 'returns the expected status code' do
+      code, _ = subject.delete(credentials, path)
+      code.must_equal expected_code
+    end
+
+    it 'returns the expected body' do
+      _, body = subject.delete(credentials, path)
+      body.must_equal expected_body
+    end
+  end
 
   describe '.post' do
     let(:credentials) { dummy_credentials }
@@ -83,11 +115,53 @@ describe Esendex::Client do
     end
   end
 
+  describe '.put' 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::Put
+        .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.put(credentials, path, serialisable_object)
+      code.must_equal expected_code
+    end
+
+    it 'returns the expected body' do
+      _, body = subject.put(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(:credentials) { Esendex::Credentials.new(username, password) }
 
     let(:expected_code) { 418 }
     let(:expected_body) { "Hi I'm a body" }