screenbeacon 0.1.0

data/lib/screenbeacon.rb

@@ -0,0 +1,305 @@
+# Screenbeacon Ruby bindings
+# API spec at https://screenbeacon.readme.io
+require 'cgi'
+require 'openssl'
+require 'rbconfig'
+require 'set'
+require 'socket'
+
+require 'rest-client'
+require 'json'
+
+# Version
+require 'screenbeacon/version'
+
+# API operations
+require 'screenbeacon/api_operations/create'
+require 'screenbeacon/api_operations/update'
+require 'screenbeacon/api_operations/delete'
+require 'screenbeacon/api_operations/list'
+require 'screenbeacon/api_operations/request'
+
+# Resources
+require 'screenbeacon/util'
+require 'screenbeacon/screenbeacon_object'
+require 'screenbeacon/api_resource'
+require 'screenbeacon/project'
+require 'screenbeacon/test'
+require 'screenbeacon/alert'
+
+# Errors
+require 'screenbeacon/errors/screenbeacon_error'
+require 'screenbeacon/errors/api_error'
+require 'screenbeacon/errors/api_connection_error'
+require 'screenbeacon/errors/invalid_request_error'
+require 'screenbeacon/errors/authentication_error'
+
+module Screenbeacon
+  DEFAULT_CA_BUNDLE_PATH = File.dirname(__FILE__) + '/data/ca-certificates.crt'
+  @api_base = 'https://api.screenbeacon.com'
+
+  @ssl_bundle_path  = DEFAULT_CA_BUNDLE_PATH
+  @verify_ssl_certs = true
+
+
+  class << self
+    attr_accessor :api_id, :api_token, :api_base, :verify_ssl_certs, :api_version #, :connect_base, :uploads_base
+  end
+
+  def self.api_url(url='', api_base_url=nil)
+    (api_base_url || @api_base) + url
+  end
+
+  def self.request(method, url, api_id, api_token, params={}, headers={}, api_base_url=nil)
+    api_base_url = api_base_url || @api_base
+
+    unless api_id ||= @api_id
+      raise AuthenticationError.new('No API ID provided. ' \
+        'Set your API ID using "Screenbeacon.api_id = <API-ID>". ' \
+        'You can generate API ID from the Screenbeacon web interface. ' \
+        'See https://screenbeacon.com/dashboard/settings for details, or email support@screenbeacon.com ' \
+        'if you have any questions.')
+    end
+
+    unless api_token ||= @api_token
+      raise AuthenticationError.new('No API token provided. ' \
+        'Set your API token using "Screenbeacon.api_token = <API-TOKEN>". ' \
+        'You can generate API token from the Screenbeacon web interface. ' \
+        'See https://screenbeacon.com/dashboard/settings for details, or email support@screenbeacon.com ' \
+        'if you have any questions.')
+    end
+
+    if api_id =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' \
+        'whitespace. (HINT: You can double-check your API key from the ' \
+        'Screenbeacon web interface. See https://screenbeacon.com/dashboard/settings for details, or ' \
+        'email support@screenbeacon.com if you have any questions.)')
+    end
+
+    if api_token =~ /\s/
+      raise AuthenticationError.new('Your API token is invalid, as it contains ' \
+        'whitespace. (HINT: You can double-check your API token from the ' \
+        'Screenbeacon web interface. See https://screenbeacon.com/dashboard/settings for details, or ' \
+        'email support@screenbeacon.com if you have any questions.)')
+    end
+
+    if verify_ssl_certs
+      request_opts = {:verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+                      :ssl_ca_file => @ssl_bundle_path}
+    else
+      request_opts = {:verify_ssl => false}
+      unless @verify_ssl_warned
+        @verify_ssl_warned = true
+        $stderr.puts("WARNING: Running without SSL cert verification. " \
+          "You should never do this in production. " \
+          "Execute 'Screenbeacon.verify_ssl_certs = true' to enable verification.")
+      end
+    end
+
+    params = Util.objects_to_ids(params)
+    url = api_url(url, api_base_url)
+
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      # Make params into GET parameters
+      url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+      payload = nil
+    else
+      if headers[:content_type] && headers[:content_type] == "multipart/form-data"
+        payload = params
+      else
+        payload = uri_encode(params)
+      end
+    end
+
+    request_opts.update(:headers => request_headers(api_id, api_token).update(headers),
+                        :method => method, :open_timeout => 30,
+                        :payload => payload, :url => url, :timeout => 80)
+
+    begin
+      response = execute_request(request_opts)
+    rescue SocketError => e
+      handle_restclient_error(e, api_base_url)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        e = APIConnectionError.new('Unexpected HTTP response code')
+        handle_restclient_error(e, api_base_url)
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        handle_api_error(rcode, rbody)
+      else
+        handle_restclient_error(e, api_base_url)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      handle_restclient_error(e, api_base_url)
+    end
+
+    [parse(response), api_id, api_token]
+  end
+
+  private
+
+  def self.user_agent
+    @uname ||= get_uname
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+      :bindings_version => Screenbeacon::VERSION,
+      :lang => 'ruby',
+      :lang_version => lang_version,
+      :platform => RUBY_PLATFORM,
+      :engine => defined?(RUBY_ENGINE) ? RUBY_ENGINE : '',
+      :publisher => 'screenbeacon',
+      :uname => @uname,
+      :hostname => Socket.gethostname,
+    }
+
+  end
+
+  def self.get_uname
+    if File.exist?('/proc/version')
+      File.read('/proc/version').strip
+    else
+      case RbConfig::CONFIG['host_os']
+      when /linux|darwin|bsd|sunos|solaris|cygwin/i
+        _uname_uname
+      when /mswin|mingw/i
+        _uname_ver
+      else
+        "unknown platform"
+      end
+    end
+  end
+
+  def self._uname_uname
+    (`uname -a 2>/dev/null` || '').strip
+  rescue Errno::ENOMEM # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+  def self._uname_ver
+    (`ver` || '').strip
+  rescue Errno::ENOMEM # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+
+  def self.uri_encode(params)
+    Util.flatten_params(params).
+      map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+  end
+
+  def self.request_headers(api_id, api_token)
+    headers = {
+      :user_agent => "Screenbeacon/v1 RubyBindings/#{Screenbeacon::VERSION}",
+      # :authorization => "Bearer #{api_id}",
+      :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    headers['Screenbeacon-Version'] = api_version if api_version
+    headers['X-API-ID'] = api_id
+    headers['X-API-TOKEN'] = api_token
+
+    begin
+      headers.update(:x_screenbeacon_client_user_agent => JSON.generate(user_agent))
+    rescue => e
+      headers.update(:x_screenbeacon_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+  end
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      # Would use :symbolize_names => true, but apparently there is
+      # some library out there that makes symbolize_names not work.
+      response = JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise general_api_error(response.code, response.body)
+    end
+
+    Util.symbolize_names(response)
+  end
+
+  def self.general_api_error(rcode, rbody)
+    APIError.new("Invalid response object from API: #{rbody.inspect} " +
+                 "(HTTP response code was #{rcode})", rcode, rbody)
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = JSON.parse(rbody)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj[:error] or raise ScreenbeaconError.new # escape from parsing
+
+    rescue JSON::ParserError, ScreenbeaconError
+      raise general_api_error(rcode, rbody)
+    end
+
+    case rcode
+    when 400, 404
+      raise invalid_request_error error, rcode, rbody, error_obj
+    when 401
+      raise authentication_error error, rcode, rbody, error_obj
+    when 402
+      raise card_error error, rcode, rbody, error_obj
+    else
+      raise api_error error, rcode, rbody, error_obj
+    end
+
+  end
+
+  def self.invalid_request_error(error, rcode, rbody, error_obj)
+    # We're not returning a params as part of the error for now, so set it to nil.
+    InvalidRequestError.new(error, nil, rcode, rbody, error_obj)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error, rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error, rcode, rbody, error_obj)
+  end
+
+  def self.handle_restclient_error(e, api_base_url=nil)
+    api_base_url = @api_base unless api_base_url
+    connection_message = "Please check your internet connection and try again. " \
+        "If this problem persists, you should check Screenbeacon's service status at " \
+        "https://twitter.com/screenbeacon, or let us know at support@screenbeacon.com."
+
+    case e
+    when RestClient::RequestTimeout
+      message = "Could not connect to Screenbeacon (#{api_base_url}). #{connection_message}"
+
+    when RestClient::ServerBrokeConnection
+      message = "The connection to the server (#{api_base_url}) broke before the " \
+        "request completed. #{connection_message}"
+
+    when RestClient::SSLCertificateNotVerified
+      message = "Could not verify Screenbeacon's SSL certificate. " \
+        "Please make sure that your network is not intercepting certificates. " \
+        "(Try going to https://api.screenbeacon.com in your browser.) " \
+        "If this problem persists, let us know at support@screenbeacon.com."
+
+    when SocketError
+      message = "Unexpected error communicating when trying to connect to Screenbeacon. " \
+        "You may be seeing this message because your DNS is not working. " \
+        "To check, try running 'host screenbeacon.com' from the command line."
+
+    else
+      message = "Unexpected error communicating with Screenbeacon. " \
+        "If this problem persists, let us know at support@screenbeacon.com."
+
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+  end
+end

data/screenbeacon.gemspec

@@ -0,0 +1,27 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'screenbeacon/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'screenbeacon'
+  s.version = Screenbeacon::VERSION
+  s.summary = 'Ruby bindings for the Screenbeacon API'
+  s.description = 'Screenbeacon is a visual design testing service.'
+  s.authors = ['Jordan Humphreys']
+  s.email = ['jordan@screenbeacon.com']
+  s.homepage = 'https://screenbeacon.readme.io'
+  s.license = 'MIT'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('json', '~> 1.8.1')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/test/screenbeacon/alert_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class AlertTest < ::Test::Unit::TestCase
+    should "alerts should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_alert_array))
+      c = Screenbeacon::Alert.all
+      assert c.kind_of? Array
+      # TODO: Should be a Screenbeacon::Alert
+      assert c[0].kind_of? Screenbeacon::ScreenbeaconObject
+    end
+
+  end
+end

data/test/screenbeacon/api_resource_test.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class ApiResourceTest < ::Test::Unit::TestCase
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:get).never
+      Screenbeacon::Project.new("someid")
+    end
+
+    should "creating a new APIResource from a hash should not fetch over the network" do
+      @mock.expects(:get).never
+      Screenbeacon::Project.construct_from({
+        :id => "somecustomer",
+        :object => "customer"
+      })
+    end
+
+    should "setting an attribute should not cause a network request" do
+      @mock.expects(:get).never
+      @mock.expects(:post).never
+      c = Screenbeacon::Project.new("test_project");
+      c.card = {:id => "somecard", :object => "card"}
+    end
+
+    should "accessing id should not issue a fetch" do
+      @mock.expects(:get).never
+      c = Screenbeacon::Project.new("test_project")
+      c.id
+    end
+
+    should "not specifying api credentials should raise an exception" do
+      Screenbeacon.api_id = nil
+      Screenbeacon.api_token = nil
+      assert_raises Screenbeacon::AuthenticationError do
+        Screenbeacon::Project.new("test_project").refresh
+      end
+    end
+
+    should "using a nil api key should raise an exception" do
+      assert_raises TypeError do
+        Screenbeacon::Project.all({}, nil)
+      end
+      assert_raises TypeError do
+        Screenbeacon::Project.all({}, { :api_id => nil, :api_token => nil })
+      end
+    end
+
+    should "specifying api credentials containing whitespace should raise an exception" do
+      Screenbeacon.api_id = "id "
+      Screenbeacon.api_token = " token"
+      assert_raises Screenbeacon::AuthenticationError do
+        Screenbeacon::Project.new("test_project").refresh
+      end
+    end
+
+    should "specifying invalid api credentials should raise an exception" do
+      Screenbeacon.api_id = "invalid"
+      Screenbeacon.api_token = "token"
+      response = test_response(test_invalid_api_id_error, 401)
+      assert_raises Screenbeacon::AuthenticationError do
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Screenbeacon::Project.retrieve("failing_project")
+      end
+    end
+
+    should "AuthenticationErrors should have an http status, http body, and JSON body" do
+      Screenbeacon.api_id = "invalid"
+      Screenbeacon.api_token = "token"
+      response = test_response(test_invalid_api_id_error, 401)
+      begin
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Screenbeacon::Project.retrieve("failing_project")
+      rescue Screenbeacon::AuthenticationError => e
+        assert_equal(401, e.http_status)
+        assert_equal(true, !!e.http_body)
+        assert_equal(true, !!e.json_body[:error])
+        assert_equal(test_invalid_api_id_error[:error], e.json_body[:error])
+      end
+    end
+  end
+end

data/test/screenbeacon/project_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class ProjectTest < ::Test::Unit::TestCase
+    should "projects should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_project_array))
+      c = Screenbeacon::Project.all
+      assert c.kind_of? Array
+      assert c[0].kind_of? Screenbeacon::ScreenbeaconObject
+    end
+
+    should "project should be deletable" do
+      @mock.expects(:delete).once.returns(test_response(test_project({:deleted => true})))
+      c = Screenbeacon::Project.new("test_project")
+      c.delete
+      assert c.deleted
+    end
+
+    # should "projects should be updateable" do
+    #   @mock.expects(:get).once.returns(test_response(test_project({:name => "fubu"})))
+    #   @mock.expects(:post).once.returns(test_response(test_project({:name => "barbu"})))
+    #   c = Screenbeacon::Project.new(test_project({:name => "fubu"})).refresh
+    #   assert_equal "fubu", c.name
+    #   c.name = "barbu"
+    #   c.save
+    #   assert_equal "barbu", c.name
+    # end
+
+    should "create should return a new project" do
+      @mock.expects(:post).once.returns(test_response(test_project))
+      c = Screenbeacon::Project.create
+      assert_equal "Screenbeacon", c.name
+    end
+
+  end
+end

data/test/screenbeacon/screenbeacon_object_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class ScreenbeaconObjectTest < ::Test::Unit::TestCase
+    should "implement #respond_to correctly" do
+      obj = Screenbeacon::ScreenbeaconObject.construct_from({ :id => 1, :foo => 'bar' })
+      assert obj.respond_to?(:id)
+      assert obj.respond_to?(:foo)
+      assert !obj.respond_to?(:baz)
+    end
+
+    should "marshal a screenbeacon object correctly" do
+      obj = Screenbeacon::ScreenbeaconObject.construct_from({ :id => 1, :name => 'Screenbeacon' }, {:api_id => 'apiid', :api_token => 'apitoken'})
+      m = Marshal.load(Marshal.dump(obj))
+      assert_equal 1, m.id
+      assert_equal 'Screenbeacon', m.name
+      expected_hash = {:api_id => 'apiid', :api_token => 'apitoken'}
+      assert_equal expected_hash, m.instance_variable_get('@opts')
+    end
+
+    should "recursively call to_hash on its values" do
+      nested = Screenbeacon::ScreenbeaconObject.construct_from({ :id => 7, :foo => 'bar' })
+      obj = Screenbeacon::ScreenbeaconObject.construct_from({ :id => 1, :nested => nested })
+      expected_hash = { :id => 1, :nested => { :id => 7, :foo => 'bar' } }
+      assert_equal expected_hash, obj.to_hash
+    end
+  end
+end

data/test/screenbeacon/test_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class TestTest < ::Test::Unit::TestCase
+    should "tests should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_test_array))
+      c = Screenbeacon::Test.all
+      assert c.kind_of? Array
+      assert c[0].kind_of? Screenbeacon::ScreenbeaconObject
+    end
+
+    should "test should be deletable" do
+      @mock.expects(:delete).once.returns(test_response(test_test({:deleted => true})))
+      c = Screenbeacon::Test.new("test_test")
+      c.delete
+      assert c.deleted
+    end
+
+    # should "tests should be updateable" do
+    #   @mock.expects(:get).once.returns(test_response(test_test({:name => "fubu"})))
+    #   @mock.expects(:post).once.returns(test_response(test_test({:name => "barbu"})))
+    #   c = Screenbeacon::Test.new("test_test").refresh
+    #   assert_equal "fubu", c.name
+    #   c.name = "barbu"
+    #   c.save
+    #   assert_equal "barbu", c.name
+    # end
+
+    should "create should return a new test" do
+      @mock.expects(:post).once.returns(test_response(test_test({:name => "Screenbeacon"})))
+      c = Screenbeacon::Test.create
+      assert_equal "Screenbeacon", c.name
+    end
+
+  end
+end

data/test/screenbeacon/util_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Screenbeacon
+  class UtilTest < ::Test::Unit::TestCase
+    should "symbolize_names should convert names to symbols" do
+      start = {
+        'foo' => 'bar',
+        'array' => [{ 'foo' => 'bar' }],
+        'nested' => {
+          1 => 2,
+          :symbol => 9,
+          'string' => nil
+        }
+      }
+      finish = {
+        :foo => 'bar',
+        :array => [{ :foo => 'bar' }],
+        :nested => {
+          1 => 2,
+          :symbol => 9,
+          :string => nil
+        }
+      }
+
+      symbolized = Screenbeacon::Util.symbolize_names(start)
+      assert_equal(finish, symbolized)
+    end
+
+    should "normalize_opts should reject nil keys" do
+      assert_raise { Screenbeacon::Util.normalize_opts(nil) }
+      assert_raise { Screenbeacon::Util.normalize_opts(:api_id => nil, :api_token => nil) }
+    end
+  end
+end