chatty_crow 1.2.1

data/lib/chatty_crow/response/notification.rb

@@ -0,0 +1,19 @@
+module ChattyCrow
+  module Response
+    # Notification response
+    class Notification < Base
+      attr_accessor :success, :total, :failed_contacts
+
+      # Initialize notification response
+      # @param response [RestClient::Response] Response from server
+      def initialize(response)
+        super response
+
+        # Parse response
+        @success         = @body.delete('success')
+        @total           = @body.delete('total')
+        @failed_contacts = @body.delete('contacts')
+      end
+    end
+  end
+end

data/lib/chatty_crow/version.rb

@@ -0,0 +1,4 @@
+# Version
+module ChattyCrow
+  VERSION = '1.2.1'.freeze
+end

data/lib/chattycrow.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/chatty_crow.rb'

data/test/android_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path '../helper', __FILE__
+
+# Test to send android push notification
+class AndroidTest < MiniTest::Should::TestCase
+  should 'Create notification' do
+    request = { status: 'OK', msg: 'Success', sucess: 15, total: 15, contacts: [] }
+    mock_notification body: request.to_json
+
+    # Create request
+    response = ChattyCrow.send_android payload: { data: { key1: 'Data1', data_test: 'Data Test' } }
+
+    # Expect response
+    expect(response).to_be_kind_of ChattyCrow::Response::Notification
+    expect(response.status).to_equal request[:status]
+    expect(response.msg).to_equal request[:msg]
+    expect(response.success).to_equal request[:success]
+    expect(response.total).to_equal request[:total]
+
+    # Clear mock
+    clear_mock_url
+  end
+
+  should 'Raise error when payload is empty' do
+    expect { ChattyCrow::Request::Android.new(contacts: %w(test1 test2)) }.to_raise ::ArgumentError
+  end
+
+  should 'Raise error when payload data is nil' do
+    expect { ChattyCrow::Request::Android.new(payload: { time_to_live: 5 }, contacts: %w(test1 test2)) }.to_raise ::ArgumentError
+  end
+
+  should 'Raise error when payload data is empty' do
+    expect { ChattyCrow::Request::Android.new(payload: { data: {}, time_to_live: 5 }, contacts: %w(test1 test2)) }.to_raise ::ArgumentError
+  end
+
+  should 'Raise error when payload data is string' do
+    expect { ChattyCrow::Request::Android.new(payload: { data: 'string', time_to_live: 5 }, contacts: %w(test1 test2)) }.to_raise ::ArgumentError
+  end
+
+  should 'Create partial notification' do
+    request = { status: 'PERROR', msg: 'Success partial', sucess: 12, total: 15, contacts: %w(test1 test2) }
+    mock_notification body: request.to_json, status: %(201 Created)
+
+    # Create request
+    response = ChattyCrow.send_android payload: { data: { key1: 'Data1', data_test: 'Data Test' } }
+
+    # Expect response
+    expect(response).to_be_instance_of ChattyCrow::Response::Notification
+    expect(response.status).to_equal request[:status]
+    expect(response.msg).to_equal request[:msg]
+    expect(response.success).to_equal request[:success]
+    expect(response.total).to_equal request[:total]
+    expect(response.failed_contacts).to_equal request[:contacts]
+
+    # Clear mock
+    clear_mock_url
+  end
+end

data/test/attachment_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path '../helper', __FILE__
+
+# Test for attachments
+class AttachmentTest < MiniTest::Should::TestCase
+  let(:file) { File.open('test/factories/stewie.jpeg', 'rb') }
+  let(:attachment) { ChattyCrow::Request::Attachment.new(file: file, filename: 'stewie.jpeg', mime_type: 'image/jpeg', inline: false) }
+
+  should 'valid attachment' do
+    expect(attachment.filename).to_equal 'stewie.jpeg'
+    expect(attachment.mime_type).to_equal 'image/jpeg'
+    expect(attachment.inline).to_equal false
+  end
+end

data/test/base_parser_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path '../helper', __FILE__
+
+# Base parser test
+class BaseParserTest < MiniTest::Should::TestCase
+  should 'Raise UnauthorizedRequest when invalid channel or token was send' do
+    # Fake URL for contacts
+    mock_contacts status: %w(401 Unauthorized)
+
+    # Call for Contacts!
+    expect { ChattyCrow.add_contacts 'test1', 'test2' }.to_raise ChattyCrow::Error::UnauthorizedRequest
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Raise ChannelNotFound when invalid channel or token was send' do
+    # Fake URL for contacts
+    mock_contacts status: ['404', 'Not Found']
+
+    # Call for Contacts!
+    expect { ChattyCrow.add_contacts 'test1', 'test2' }.to_raise ChattyCrow::Error::ChannelNotFound
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Raise InvalidReturn when invalid response accepted' do
+    # Fake URL for contacts
+    mock_contacts status: ['500', 'Internal Server Error']
+
+    # Call for Contacts!
+    expect { ChattyCrow.add_contacts 'test1', 'test2' }.to_raise ChattyCrow::Error::InvalidReturn
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Raise InvalidAttributes when attributes missing' do
+    body = {
+      status: 'ERROR',
+      parameters: %w(subject text_body),
+      msg: 'Missing parameters'
+    }
+
+    # Fake URL for notification
+    mock_notification status: ['400', 'Bad Request'], body: body.to_json
+
+    # Get error
+    error = nil
+    begin
+      ChattyCrow.send_ios payload: 'Welcome users'
+    rescue => e
+      error = e
+    end
+
+    expect(error).to_be_instance_of ChattyCrow::Error::InvalidAttributes
+    expect(error.attributes).to_include 'subject'
+    expect(error.attributes).to_include 'text_body'
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Use token from configuration' do
+    # Fake URL for notification
+    mock_notification status: ['400', 'Bad Request'], body: {}.to_json
+
+    # Send !
+    ChattyCrow.send_ios payload: 'Welcome users' rescue nil
+
+    # Get last request
+    expect(last_headers['token']).to_equal ChattyCrow.configuration.token
+
+    # Clear
+    clear_mock_url
+  end
+
+  should 'Use token from parameters' do
+    # Fake URL for notification
+    mock_notification status: ['400', 'Bad Request'], body: {}.to_json
+
+    # New token
+    token = 'test_token'
+
+    # Send !
+    ChattyCrow.send_ios payload: 'Welcome users', token: token rescue nil
+
+    # Get last request
+    expect(last_headers['token']).to_equal token
+
+    # Clear
+    clear_mock_url
+  end
+
+  should 'Use contact configuration token' do
+    # Fake URL for contacts
+    mock_contacts status: %w(401 Unauthorized)
+
+    # Call for Contacts!
+    ChattyCrow.add_contacts 'test1' rescue nil
+
+    # Get last request
+    expect(last_headers['token']).to_equal ChattyCrow.configuration.token
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Use contact token from parameters' do
+    # Fake URL for contacts
+    mock_contacts status: %w(401 Unauthorized)
+
+    # New token
+    token = 'test_token'
+
+    # Call for Contacts!
+    ChattyCrow.add_contacts('test1', token: token) rescue nil
+
+    # Get last request
+    expect(last_headers['token']).to_equal token
+
+    # Remove mock
+    clear_mock_url
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path '../helper', __FILE__
+
+# Test for proper gem configuration
+class ConfigurationTest < MiniTest::Should::TestCase
+  should 'provide defaults' do
+    assert_config_default :host, 'https://chatty-crow.com/api/v1/'
+    assert_config_default :notification_url, 'https://chatty-crow.com/api/v1/notification'
+    assert_config_default :contacts_url, 'https://chatty-crow.com/api/v1/contacts'
+    assert_config_default :token, nil
+    assert_config_default :default_channel, nil
+    assert_config_default :http_open_timeout, 2
+    assert_config_default :http_read_timeout, 5
+  end
+
+  should 'use correct url wihtout backslash' do
+    config = ChattyCrow::Configuration.new
+    url    = 'http://test.com/api/v1'
+    config.host = url
+    assert_equal url, config.host
+    assert_equal "#{url}/notification", config.notification_url
+    assert_equal "#{url}/contacts", config.contacts_url
+  end
+
+  should 'use correct url with backslash' do
+    config = ChattyCrow::Configuration.new
+    url    = 'http://test.com/api/v1/'
+    config.host = url
+    assert_equal url, config.host
+    assert_equal "#{url}notification", config.notification_url
+    assert_equal "#{url}contacts", config.contacts_url
+  end
+
+  def assert_config_default(option, default_value, config = nil)
+    config ||= ChattyCrow::Configuration.new
+    assert_equal default_value, config.send(option)
+  end
+end

data/test/contacts_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path '../helper', __FILE__
+
+# Unit test for contact methods
+class ContactsTest < MiniTest::Should::TestCase
+  should 'Raise invalid argument when no contact list is present' do
+    expect { ChattyCrow.add_contacts }.to_raise ArgumentError
+    expect { ChattyCrow.remove_contacts }.to_raise ArgumentError
+    expect { ChattyCrow.add_contacts(test_option: 'option') }.to_raise ArgumentError
+    expect { ChattyCrow.remove_contacts(test_option: 'option') }.to_raise ArgumentError
+  end
+
+  should 'Return contact add list' do
+    # Prepare response
+    request = {
+      status: 'OK',
+      msg: 'Status message',
+      stats: {
+        success: 15,
+        exists: 28,
+        failed: 12
+      },
+      contacts: {
+        exists: %w(franta1 franta5),
+        failed: %w(franta2 franta3)
+      }
+    }
+
+    # Fake URL contacts
+    mock_contacts method: :post, body: request.to_json
+
+    # Get contacts
+    response = ChattyCrow.add_contacts('test1', 'test2')
+
+    # Validate
+    expect(response).to_be_kind_of ChattyCrow::Response::ContactsAdd
+    expect(response.status).to_equal request[:status]
+    expect(response.msg).to_equal request[:msg]
+
+    # Statistics
+    expect(response.success_count).to_equal request[:stats][:success]
+    expect(response.exists_count).to_equal request[:stats][:exists]
+    expect(response.failed_count).to_equal request[:stats][:failed]
+
+    # Failed & Exists contacts
+    expect(response.exists).to_include 'franta1'
+    expect(response.exists).to_include 'franta5'
+    expect(response.failed).to_include 'franta2'
+    expect(response.failed).to_include 'franta3'
+
+    # Remove mock
+    clear_mock_url
+  end
+
+  should 'Return contact remove list' do
+    # Prepare response
+    request = {
+      status: 'OK',
+      msg: 'Status message',
+      stats: {
+        success: 15,
+        failed: 12
+      },
+      contacts: {
+        failed: %w(franta2 franta3)
+      }
+    }
+
+    # Fake URL contacts
+    mock_contacts method: :delete, status: %w(201 Created), body: request.to_json
+
+    # Get contacts
+    response = ChattyCrow.remove_contacts('test12', 'test15')
+
+    # Validate
+    expect(response).to_be_kind_of ChattyCrow::Response::ContactsRemove
+    expect(response.status).to_equal request[:status]
+    expect(response.msg).to_equal request[:msg]
+
+    # Statistics
+    expect(response.success_count).to_equal request[:stats][:success]
+    expect(response.failed_count).to_equal request[:stats][:failed]
+
+    # Failed & Exists contacts
+    expect(response.failed).to_include 'franta2'
+    expect(response.failed).to_include 'franta3'
+
+    # Remove mock
+    clear_mock_url
+  end
+end

data/test/helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'fakeweb'
+require 'minitest/autorun'
+require 'minitest/should'
+require 'minitest/spec/expect'
+require 'simplecov'
+require 'coveralls'
+
+# Start Coveralls
+SimpleCov.start do
+  add_filter '/test/'
+end
+Coveralls.wear!
+
+# Require Gem
+require 'chatty_crow'
+
+# Set chatty_crow by block
+ChattyCrow.configure do |config|
+  config.token           = 'temporary_token'
+  config.default_channel = 'default_channel'
+end
+
+# Usefull test helpers
+module TestHelpers
+  def configuration
+    ChattyCrow.configuration
+  end
+
+  # Mock default notification url
+  def mock_notification(options)
+    method = options.delete(:method) || :post
+    options[:status] ||= %w(200 OK)
+
+    FakeWeb.register_uri(method, configuration.notification_url, options)
+  end
+
+  # Mock default URL for contacts
+  def mock_contacts(options)
+    method = options.delete(:method) || :post
+    options[:status] ||= %w(200 OK)
+
+    FakeWeb.register_uri(method, configuration.contacts_url, options)
+  end
+
+  # Get last headers
+  def last_headers
+    ret = {}
+    FakeWeb.last_request.each_header do |key, value|
+      ret[key] = value
+    end
+    ret
+  end
+
+  def clear_mock_url
+    FakeWeb.clean_registry
+  end
+end
+
+# Include test helper methods to minitest!
+class MiniTest::Should::TestCase
+  include ::TestHelpers
+end

data/test/mail_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path '../helper', __FILE__
+require 'base64'
+
+# Mail test
+class MailTest < MiniTest::Should::TestCase
+  let(:valid_mail) { ChattyCrow.create_mail subject: 'test', text_body: 'text body', contacts: 'test@netbrick.eu' }
+  let(:invalid_mail) { ChattyCrow.create_mail subject: 'test' }
+  let(:mail) { ChattyCrow.create_mail subject: 'test', text_body: 'text_body', html_body: 'html_body', contacts: 'test@netbrick.eu' }
+
+  should 'create mail' do
+    expect(valid_mail).to_be_instance_of ChattyCrow::Request::Mail
+    expect(valid_mail.subject).to_equal 'test'
+    expect(valid_mail.text_body).to_equal 'text body'
+    expect(valid_mail.contacts).to_include 'test@netbrick.eu'
+  end
+
+  should 'raise error when trying deliver without body' do
+    expect { invalid_mail.deliver! }.to_raise ::ArgumentError
+  end
+
+  should 'return false when trying deliver without body' do
+    expect(invalid_mail.deliver).to_equal false
+  end
+
+  should 'serializer payload test' do
+    json = mail.payload
+    expect(json[:subject]).to_equal 'test'
+    expect(json[:text_body]).to_equal Base64.encode64('text_body')
+    expect(json[:html_body]).to_equal Base64.encode64('html_body')
+  end
+
+  should 'raise error unless file is present' do
+    expect { mail.add_file {} }.to_raise ::ArgumentError
+  end
+
+  should 'raise error if file is string but not filename provided' do
+    expect { mail.add_file file: 'base64data', mime_type: 'image/jpeg' }.to_raise ::ArgumentError
+  end
+
+  should 'raise error if file is string but not mime-type provided' do
+    expect { mail.add_file file: 'base64data', filename: 'test.jpeg' }.to_raise ::ArgumentError
+  end
+
+  should 'decide mime type and filename from factory' do
+    file = File.open('test/factories/stewie.jpeg')
+    attachment = mail.add_file file: file
+    expect(attachment).to_be_instance_of ChattyCrow::Request::Attachment
+    expect(attachment.filename).to_equal 'stewie.jpeg'
+    expect(attachment.mime_type).to_equal 'image/jpeg'
+  end
+
+  should 'test attachment serializer' do
+    file = File.open('test/factories/stewie.jpeg')
+    attachment = mail.add_file file: file
+    json  = attachment.to_json
+    file.seek(0)
+    expect(json[:name]).to_equal 'stewie.jpeg'
+    expect(json[:mime_type]).to_equal 'image/jpeg'
+    expect(json[:inline]).to_equal false
+    expect(json[:base64data]).to_equal Base64.encode64(file.read)
+  end
+end