one_signal 0.0.6

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+end
+
+desc "Run tests"
+task :default => :test

data/example.rb

@@ -0,0 +1,103 @@
+require 'one_signal'
+require 'dotenv'
+
+Dotenv.load
+api_key = ENV['ONESIGNAL_API_KEY']
+@app_id = ENV['ONESIGNAL_APP_ID']
+@device_token = "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabc3"
+
+OneSignal::OneSignal.api_key = api_key
+
+def create_player
+  params = {
+    app_id: @app_id,
+    device_type: 0,
+    identifier: @device_token,
+    tags: {
+      user_id: 'test2',
+      device_type: 'chrome'
+    }
+  }
+
+  begin 
+    response = OneSignal::Player.create(params: params)
+    puts "code : #{response.code}"
+    puts "message : #{response.message}"
+    puts "body : #{response.body}"
+    puts "id : #{JSON.parse(response.body).class}"
+    return JSON.parse(response.body)["id"]
+  rescue OneSignal::OneSignalError => e
+    puts "-- message : #{e.message}"
+    puts "-- status : #{e.http_status}"
+    puts "-- body : #{e.http_body}"
+  end
+end
+
+def update_player(id:)
+  params = {
+    app_id: @app_id,
+    device_type: 0,
+    identifier: @device_token,
+    tags: {
+      user_id: 'test2updated',
+      device_type: 'chrome'
+    }
+  }
+
+  begin 
+    response = OneSignal::Player.update(id: id, params: params)
+    puts "code : #{response.code}"
+    puts "message : #{response.message}"
+    puts "body : #{response.body}"
+    puts "id : #{JSON.parse(response.body).class}"
+  rescue OneSignal::OneSignalError => e
+    puts "-- message : #{e.message}"
+    puts "-- status : #{e.http_status}"
+    puts "-- body : #{e.http_body}"
+  end
+end
+
+def notify
+  params = {
+    app_id: @app_id,
+    contents: {
+      en: 'hey buddy'
+    },
+    ios_badgeType: 'None',
+    ios_badgeCount: 1,
+    tags: [
+      {
+        key: 'user_id',
+        relation: '=',
+        value: "unknown"
+      },
+      { operator: 'AND' },
+      {
+        key: 'device_type',
+        relation: '=',
+        value: 'ios'
+      }
+    ]
+  }
+
+  begin 
+    response = OneSignal::Notification.create(params: params)
+    puts "code : #{response.code}"
+    puts "message : #{response.message}"
+    puts "body : #{response.body}"
+  rescue OneSignal::NoRecipientsError => e
+    puts "--- NoRecipientsError: #{e.inspect}"
+    puts "-- message : #{e.message}"
+    puts "-- status : #{e.http_status}"
+    puts "-- body : #{e.http_body}"
+  rescue OneSignal::OneSignalError => e
+    puts "--- OneSignalError  : #{e.inspect}"
+    puts "-- message : #{e.message}"
+    puts "-- status : #{e.http_status}"
+    puts "-- body : #{e.http_body}"
+  end
+end
+
+# player_id = create_player
+# update_player(id: player_id)
+notify

data/lib/one_signal/errors/no_recipients_error.rb

@@ -0,0 +1,4 @@
+module OneSignal
+  class NoRecipientsError < OneSignalError
+  end
+end

data/lib/one_signal/errors/one_signal_error.rb

@@ -0,0 +1,17 @@
+module OneSignal
+  class OneSignalError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+
+    def initialize(message: nil, http_status: nil, http_body: nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @message += " - http status : #{@http_status}" unless @http_status.nil?
+      @message += " - http body : #{@http_body}" unless @http_body.nil?
+      super(@message)
+    end
+
+  end
+end

data/lib/one_signal/notification.rb

@@ -0,0 +1,51 @@
+module OneSignal
+
+  class Notification < OneSignal
+
+    def self.create(params: {})
+      uri_string = @@base_uri
+      uri_string += "/notifications"
+      uri = URI.parse(uri_string)
+      
+      response = send_post_request(uri: uri, body: params)
+
+      if response.code != '200'
+        handle_error(uri: uri, params: params, response: response)
+      end
+
+      return response
+    end
+
+    private
+
+    def self.handle_error(uri:, params:, response:)
+      msg = "Create Notification error - uri: #{uri} params: #{params}"
+      if is_no_recipients_error(response: response)
+        raise NoRecipientsError.new(message: msg,
+                                    http_status: response.code,
+                                    http_body: response.body)
+      else
+        raise OneSignalError.new(message: msg,
+                                 http_status: response.code,
+                                 http_body: response.body)
+      end
+    end
+
+    def self.is_no_recipients_error(response:)
+      return false if response.code != '400' ||
+                      response.body.nil?
+
+      body = JSON.parse(response.body)
+      return false unless body['errors'] &&
+                          body['errors'].is_a?(Array) &&
+                          !body['errors'].empty?
+
+      expected_error_msg = "error: 0 recipients."
+      return false unless body['errors'][0].strip.downcase == expected_error_msg
+
+      return true
+    end
+
+  end
+
+end

data/lib/one_signal/one_signal.rb

@@ -0,0 +1,86 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module OneSignal
+
+  class OneSignal
+    @@base_uri = "https://onesignal.com/api/v1"
+    @@api_key = nil
+    @@open_timeout = 30
+    @@read_timeout = 30
+
+    def self.api_key=(new_api_key)
+      @@api_key = new_api_key
+    end
+
+    def self.api_key
+      @@api_key
+    end
+
+    def self.open_timeout=(new_timeout)
+      @@open_timeout = new_timeout
+    end
+
+    def self.open_timeout
+      @@open_timeout
+    end
+
+    def self.read_timeout=(new_timeout)
+      @@read_timeout = new_timeout
+    end
+
+    def self.read_timeout
+      @@read_timeout
+    end
+
+    def self.http_object(uri:)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = @@open_timeout
+      http.read_timeout = @@read_timeout
+      return http
+    end
+
+    def self.send_post_request(uri:, body:)
+      ensure_api_key
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = body.to_json
+      request = request_with_headers(request: request)
+      
+      http = http_object(uri: uri)
+
+      response = http.request(request)
+    end
+
+    def self.send_put_request(uri:, body:)
+      ensure_api_key
+
+      request = Net::HTTP::Put.new(uri.request_uri)
+      request.body = body.to_json
+      request = request_with_headers(request: request)
+      
+      http = http_object(uri: uri)
+
+      response = http.request(request)
+    end
+
+    private
+
+    def self.ensure_api_key
+      unless @@api_key && !@@api_key.strip.empty?
+        msg = "No API key provided"
+        raise OneSignalError.new(message: msg)
+      end
+    end
+
+    def self.request_with_headers(request:)
+      request.add_field("Content-Type", "application/json")
+      request.add_field("Authorization", "Basic #{@@api_key}")
+      return request
+    end
+
+  end
+
+end

data/lib/one_signal/player.rb

@@ -0,0 +1,51 @@
+module OneSignal
+
+  class Player < OneSignal
+
+    def self.create(params: {})
+      uri_string = @@base_uri
+      uri_string += "/players"
+      uri = URI.parse(uri_string)
+      
+      response = send_post_request(uri: uri, body: params)
+
+      ensure_http_status(response: response,
+                         status: '200',
+                         method_name: 'Create',
+                         uri: uri,
+                         params: params)
+
+      return response
+    end
+
+    def self.update(id:, params: {})
+      uri_string = @@base_uri
+      uri_string += "/players"
+      uri_string += "/#{id}"
+      uri = URI.parse(uri_string)
+      
+      response = send_put_request(uri: uri, body: params)
+
+      ensure_http_status(response: response,
+                         status: '200',
+                         method_name: 'Update',
+                         uri: uri,
+                         params: params)
+
+      return response
+    end
+
+    private
+
+    def self.ensure_http_status(response:, status:, method_name:, uri:, params:)
+      if response.code != status.to_s
+        msg = "#{method_name} Player error - uri: #{uri} params: #{params}"
+        raise OneSignalError.new(message: msg,
+                                 http_status: response.code,
+                                 http_body: response.body)
+      end
+    end
+
+  end
+
+end

data/lib/one_signal/version.rb

@@ -0,0 +1,3 @@
+module OneSignal
+  VERSION = "0.0.6"
+end

data/lib/one_signal.rb

@@ -0,0 +1,8 @@
+require 'one_signal/version'
+require 'one_signal/one_signal'
+require 'one_signal/player'
+require 'one_signal/notification'
+
+# Errors
+require 'one_signal/errors/one_signal_error'
+require 'one_signal/errors/no_recipients_error'

data/one_signal.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path('lib/one_signal/version')
+
+Gem::Specification.new do |s|
+  s.add_runtime_dependency 'json', '~> 1.8'
+  s.add_development_dependency 'rake', '~> 10.4'
+  s.add_development_dependency 'mocha', '~> 1.1'
+  s.add_development_dependency 'dotenv', '~> 2.0'
+  s.name        = 'one_signal'
+  s.version     = OneSignal::VERSION
+  s.summary     = "A library which implements the OneSignal API"
+  s.description = "A library which implements the OneSignal API."
+  s.authors     = ["Thomas Balthazar"]
+  s.email       = 'thomas@balthazar.info'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.homepage    = 'https://github.com/tbalthazar/onesignal-ruby'
+  s.license     = 'MIT'
+end

data/test/helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'minitest/autorun'
+require 'mocha/mini_test'
+require 'one_signal'
+
+def mock_response_ok
+  response = mock()
+  response.expects(:code).returns("200")
+  return response
+end
+
+def mock_response_ko
+  response = mock()
+  response.expects(:code).returns("400").at_least_once
+  response.expects(:body).at_least_once
+  return response
+end
+
+def mock_response_no_recipients
+  response = mock()
+  response.expects(:code).returns("400").at_least_once
+  response.expects(:body).returns('{"errors":["  Error: 0 Recipients."]}').at_least_once
+  return response
+end

data/test/notification_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/helper'
+
+class NotificationTest < MiniTest::Test
+
+  def setup
+    @uri = URI.parse("https://onesignal.com/api/v1/notifications")
+    @create_params = {
+      foo: "bar",
+      widget: "acme"
+    }
+    @api_key = "fake api key"
+    OneSignal::OneSignal.api_key = @api_key
+  end
+
+  def test_create_raises_onesignal_error    
+    response = mock_response_ko
+    OneSignal::OneSignal.expects(:send_post_request)
+                        .with(uri: @uri, body: @create_params)
+                        .returns(response)
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::Notification.create(params: @create_params)
+    end
+  end
+
+  def test_create_raises_no_recipients_error    
+    response = mock_response_no_recipients
+    OneSignal::OneSignal.expects(:send_post_request)
+                        .with(uri: @uri, body: @create_params)
+                        .returns(response)
+    assert_raises OneSignal::NoRecipientsError do
+      OneSignal::Notification.create(params: @create_params)
+    end
+  end
+
+  def test_create
+    response = mock_response_ok
+    OneSignal::OneSignal.expects(:send_post_request)
+                        .with(uri: @uri, body: @create_params)
+                        .returns(response)
+    assert_equal response, OneSignal::Notification.create(params: @create_params)
+  end
+
+end

data/test/one_signal_test.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/helper'
+
+class OneSignalTest < MiniTest::Test
+
+  def setup
+    @api_key = "fake_api_123"
+    @body = "fake body"
+    @uri = URI.parse("https://www.example.com/foo/bar")
+    @default_timeout = 30
+  end
+
+  def teardown
+    OneSignal::OneSignal.api_key = nil
+    OneSignal::OneSignal.open_timeout = @default_timeout
+    OneSignal::OneSignal.read_timeout = @default_timeout
+  end
+
+  def build_mock_request
+    request = mock()
+    request.expects(:body=).with(@body.to_json)
+    request.expects(:add_field).with("Content-Type", "application/json")
+    request.expects(:add_field).with("Authorization", "Basic #{@api_key}")
+    return request
+  end
+
+  def build_mock_http_object
+    use_ssl = @uri.scheme == 'https'
+    http = mock()
+    http.expects(:use_ssl=).with(use_ssl)
+    http.expects(:open_timeout=)
+    http.expects(:read_timeout=)
+    return http
+  end
+
+  def test_building_request_with_nil_api_key_raises_error
+    OneSignal::OneSignal.api_key = nil 
+
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::OneSignal.send_post_request(uri: @uri, body: @body)
+    end
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::OneSignal.send_put_request(uri: @uri, body: @body)
+    end
+  end
+  
+  def test_building_request_with_empty_api_key_raises_error
+    OneSignal::OneSignal.api_key = "  "
+
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::OneSignal.send_post_request(uri: @uri, body: @body)
+    end
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::OneSignal.send_put_request(uri: @uri, body: @body)
+    end
+  end
+
+  def test_default_timeout
+    assert_equal @default_timeout, OneSignal::OneSignal.open_timeout
+    assert_equal @default_timeout, OneSignal::OneSignal.read_timeout
+  end
+
+  def test_setting_timeout
+    open_timeout = OneSignal::OneSignal.open_timeout + 1
+    read_timeout = OneSignal::OneSignal.read_timeout + 2
+    OneSignal::OneSignal.open_timeout = open_timeout
+    OneSignal::OneSignal.read_timeout = read_timeout
+
+    assert_equal open_timeout, OneSignal::OneSignal.open_timeout
+    assert_equal read_timeout, OneSignal::OneSignal.read_timeout
+  end
+
+  def test_http_object
+    # test default timeout values
+    http_object = OneSignal::OneSignal.http_object(uri: @uri)
+    assert_equal @default_timeout, http_object.open_timeout
+    assert_equal @default_timeout, http_object.read_timeout
+
+    # change timeout values
+    open_timeout = OneSignal::OneSignal.open_timeout + 1
+    read_timeout = OneSignal::OneSignal.read_timeout + 2
+    OneSignal::OneSignal.open_timeout = open_timeout
+    OneSignal::OneSignal.read_timeout = read_timeout
+    http_object = OneSignal::OneSignal.http_object(uri: @uri)
+
+    assert_equal open_timeout, http_object.open_timeout
+    assert_equal read_timeout, http_object.read_timeout
+  end
+
+  def test_send_post_request
+    # test request creation
+    request = build_mock_request
+    Net::HTTP::Post.expects(:new).with(@uri.request_uri).returns(request)
+
+    # test http object creation
+    http = build_mock_http_object
+    Net::HTTP.expects(:new).with(@uri.host, @uri.port).returns(http)
+
+    # test send request
+    response = mock()
+    http.expects(:request).with(request).returns(response)
+
+    OneSignal::OneSignal.api_key = @api_key
+    assert_equal response, OneSignal::OneSignal.send_post_request(uri: @uri, body: @body)
+  end
+
+  def test_send_put_request
+    # test request creation
+    request = build_mock_request
+    Net::HTTP::Put.expects(:new).with(@uri.request_uri).returns(request)
+
+    # test http object creation
+    http = build_mock_http_object
+    Net::HTTP.expects(:new).with(@uri.host, @uri.port).returns(http)
+
+    # test send request
+    response = mock()
+    http.expects(:request).with(request).returns(response)
+
+    OneSignal::OneSignal.api_key = @api_key
+    assert_equal response, OneSignal::OneSignal.send_put_request(uri: @uri, body: @body)
+  end
+
+end

data/test/player_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper'
+
+class PlayerTest < MiniTest::Test
+
+  def setup
+    base_url = "https://onesignal.com/api/v1/players"
+    @create_uri = URI.parse(base_url)
+
+    @player_id = "fake-id-123"
+    @update_uri = URI.parse(base_url + "/#{@player_id}")
+
+    @params = {
+      foo: "bar",
+      widget: "acme"
+    }
+    @api_key = "fake api key"
+    OneSignal::OneSignal.api_key = @api_key
+  end
+
+  def test_create_raises_error    
+    response = mock_response_ko
+    OneSignal::OneSignal.expects(:send_post_request)
+                        .with(uri: @create_uri, body: @params)
+                        .returns(response)
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::Player.create(params: @params)
+    end
+  end
+
+  def test_create
+    response = mock_response_ok
+    OneSignal::OneSignal.expects(:send_post_request)
+                        .with(uri: @create_uri, body: @params)
+                        .returns(response)
+    assert_equal response, OneSignal::Player.create(params: @params)
+  end
+
+  def test_update_raises_error    
+    response = mock_response_ko
+    OneSignal::OneSignal.expects(:send_put_request)
+                        .with(uri: @update_uri, body: @params)
+                        .returns(response)
+    assert_raises OneSignal::OneSignalError do
+      OneSignal::Player.update(id: @player_id, params: @params)
+    end
+  end
+
+  def test_update
+    response = mock_response_ok
+    OneSignal::OneSignal.expects(:send_put_request)
+                        .with(uri: @update_uri, body: @params)
+                        .returns(response)
+    assert_equal response, OneSignal::Player.update(id: @player_id, params: @params)
+  end
+
+end