foundationapi 0.9.9

data/lib/foundation_api/test_helper.rb

@@ -0,0 +1,53 @@
+require 'net/http'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'foundation_api'))
+
+# Mock around Net::HTTP so we don't need a real connection.
+# We just verify whether the correct data is posted and return
+# know test data
+
+class Net::HTTP < Net::Protocol
+  def connect
+  end
+end
+
+class Net::HTTPResponse
+  def body=(content)
+    @body = content
+    @read = true
+  end
+end
+
+class Net::HTTP < Net::Protocol
+
+  def self.raw_response_data
+    @raw_response_data
+  end
+
+  def self.raw_response_data=(data)
+    @raw_response_data = data
+  end
+
+  def self.raw_post_body=(body)
+    @raw_post_body = body
+  end
+
+  def self.raw_post_body
+    @raw_post_body
+  end
+
+  def self.raw_post_path=(path)
+    @raw_post_path = path
+  end
+
+  def self.raw_post_path
+    @raw_post_path
+  end
+
+  def post(path, body, headers = {})
+    res = Net::HTTPSuccess.new('1.2', '200', 'OK')
+    self.class.raw_post_path = path
+    self.class.raw_post_body = body
+    res.body = self.class.raw_response_data
+    res
+  end
+end

data/lib/foundation_api/version.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2012 Bingo Entreprenøren AS
+# Copyright (c) 2012 Teknobingo Scandinavia AS
+# Copyright (c) 2012 Knut I. Stenmark
+# Copyright (c) 2012 Patrick Hanevold
+#
+# 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.
+
+module FoundationApi
+  VERSION = "0.9.9"
+end

data/test/foundation_api_test.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2012 Bingo Entreprenøren AS
+# Copyright (c) 2012 Teknobingo Scandinavia AS
+# Copyright (c) 2012 Knut I. Stenmark
+# Copyright (c) 2012 Patrick Hanevold
+#
+# 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.
+
+require 'test_helper'
+
+class FoundationApiTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, FoundationApi
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'simplecov'
+require 'active_support/testing/autorun'
+require 'active_support/test_case'
+require 'active_support/benchmarkable'
+require 'shoulda'
+SimpleCov.start
+require 'foundation_api'
+
+class Nada
+  def do_nothing(*args)
+  end
+  alias :debug    :do_nothing
+  alias :notice   :do_nothing
+  alias :info   :do_nothing
+  alias :error   :do_nothing
+end
+
+class CacheNada
+  def self.fetch(*args)
+    yield
+  end
+end
+
+class Rails
+  def self.logger
+    @logger ||= Nada.new
+  end
+  def self.cache
+    CacheNada
+  end
+end

data/test/unit/foundation_api/event/client_test.rb

@@ -0,0 +1,129 @@
+require 'test_helper'
+require 'foundation_api/test_helper'
+
+class FoundationApi::Event::ClientTest < ActiveSupport::TestCase
+  setup do
+    class TestClient < FoundationApi::Event::Client
+      self.site = "http://localhost:5555"
+    end
+    FoundationApi::JsonRPC::Client.site =  "http://cyber:arts@localhost:4444/api"
+  end
+
+  context 'when authenticatiing it' do
+    should 'request token from api server' do
+      FoundationApi::JsonRPC::Client.expects(:authenticate).returns('auth_token')
+      assert_equal 'auth_token', TestClient.authenticate
+    end
+  end
+  
+  context 'when requesting it' do
+    setup do
+      TestClient.auth_token = 'token'
+    end
+    should 'post the request correctly' do
+      TestClient.expects(:authenticate).never
+      TestClient.expects(:post_request).with('event', {:apitoken => 'token', :type => '/something/weird', :number => 2}).returns(:anything)
+      assert_equal = TestClient.request('event', {:type => '/something/weird', :number => 2})
+    end
+    should 'authenticate if no token' do
+      TestClient.auth_token = nil
+      TestClient.expects(:authenticate).once
+      TestClient.expects(:post_request).with('event', {:apitoken => nil, :type => '/something/weird', :number => 2}).returns(:anything)
+      assert_equal :anything, TestClient.request('event', {:type => '/something/weird', :number => 2})
+    end
+    should 'reauthenticate if token has expired' do
+      TestClient.expects(:authenticate).once
+      TestClient.stubs(:post_request).
+        raises(FoundationApi::Event::AuthenticationFailed).then.returns(:anything)
+      assert_equal :anything, TestClient.request('event', {:type => '/something/weird', :number => 2})
+    end
+    should 'reauthenticate if token has expired, but only once' do
+      TestClient.expects(:authenticate).once
+      TestClient.stubs(:post_request).raises(FoundationApi::Event::AuthenticationFailed)
+      assert_raises FoundationApi::Event::AuthenticationFailed do
+        assert_equal :anything, TestClient.request('event', {:type => '/something/weird', :number => 2})
+      end
+    end
+    should 'leave other exceptions to be handled by the caller' do
+      TestClient.expects(:authenticate).never
+      TestClient.stubs(:post_request).raises(NoMethodError)
+      assert_raises NoMethodError do
+        assert_equal :anything, TestClient.request('event', {:type => '/something/weird', :number => 2})
+      end
+    end
+  end
+  
+  context 'when posting to the server it' do
+    setup do
+      @http = stub('http')
+      TestClient.stubs(:http).returns(@http)
+    end
+    should 'call post correctly' do
+      @conn = stub('connection')
+      @http.expects(:start).yields(@conn)
+      
+      @conn.expects(:post).with('/event', '{"type":"/the/type","number":1}', {'Content-Type' => 'application/json', 'Accept' => '*/*'})
+        .returns(stub(:body =>'{"status":"SUCCESS"}'))
+      TestClient.post_request('event', {:type => '/the/type', :number => 1})
+    end    
+  end
+  
+  context 'when successful it' do
+    setup do
+      Net::HTTP.stubs(:raw_response_data).returns('{"status": "SUCCESS"}')
+      TestClient.auth_token = 'tns5ddd7cc5271c8c6b5fab8aaf9ec492ed'
+      @result = TestClient.request("geneate_event", :type => '/something/weird', :number => 3 )
+    end
+    
+    should 'receive the correct call at the http level' do
+      assert_equal JSON.parse(
+      '{"apitoken":"tns5ddd7cc5271c8c6b5fab8aaf9ec492ed","type":"/something/weird","number":3}'), 
+        JSON.parse(Net::HTTP.raw_post_body)
+    end
+    
+    should 'correctly parse the response from the server' do
+      assert_equal "SUCCESS", @result
+    end
+  end
+  
+  def expect_exception(status, exception)
+    assert_raises exception do
+      Net::HTTP.stubs(:raw_response_data).returns(%Q/{"status": "#{status}"}/)
+      @result = TestClient.request("geneate_event", :type => '/something/weird', :number => 3 )
+    end
+  end
+  
+
+  context 'when failing it' do
+    setup do
+      TestClient.auth_token = 'tns5ddd7cc5271c8c6b5fab8aaf9ec492ed'
+    end
+    should 'generate the appropriate exception' do
+      expect_exception 'INVALID_ARGUMENT',      FoundationApi::Event::InvalidArgument
+      expect_exception 'AUTHENTICATION_FAILED', FoundationApi::Event::AuthenticationFailed
+      expect_exception 'MALFORMED_REQUEST',     FoundationApi::Event::MalformedRequest
+      expect_exception 'OPERATION_ERROR',       FoundationApi::Event::OperationError
+      expect_exception 'TIMEOUT',               FoundationApi::Event::Timeout
+    end
+    should 'generate exception if status unknown' do
+      expect_exception 'SWADA',                 FoundationApi::Event::UnknownResponseError
+    end
+    should 'log exception if status unknown' do
+      Rails.logger.expects(:error).twice
+      expect_exception 'SWADA', FoundationApi::Event::UnknownResponseError
+    end
+  end
+
+  context 'when logging it' do
+    should 'strip password from message' do
+      s = '{"username":"test5","password":"my22secret","phone":"error prone"}'
+      expected = '{"username":"test5","password":"[FILTERED]","phone":"error prone"}'
+      assert_equal expected, TestClient.send(:password_filter, s)
+      s = '{"username":"test5","password": "my22secret","phone":"error prone"}'
+      assert_equal expected, TestClient.send(:password_filter, s)
+    end
+  end
+
+
+
+end

data/test/unit/foundation_api/json_rpc/client_test.rb

@@ -0,0 +1,143 @@
+require 'test_helper'
+require 'foundation_api/test_helper'
+
+class FoundationApi::JsonRPC::ClientTest < ActiveSupport::TestCase
+  setup do
+    @client = FoundationApi::JsonRPC::Client
+    @client.site = "http://cyber:arts@localhost:4444/api"
+  end
+
+  should 'respond to post' do
+    assert @client.respond_to?(:post_request)
+  end
+
+  should 'respond to request' do
+    assert @client.respond_to?(:request)
+  end
+
+  should 'respond to authenticate' do
+    assert @client.respond_to?(:authenticate)
+  end
+
+  should 'generate unique id' do
+    t = Time.now
+    Time.stubs(:now).returns(t)
+    assert_equal "#{t.to_f}.1", @client.unique_id(1)
+  end
+  
+  should 'create key value pear' do
+    # if you do not understand this joke, there are plenty of books to read
+    assert_equal [['key', 'value'],['pear', 'banana']], @client.key_value_array(:key => 'value', :pear => 'banana')
+  end
+    
+  context 'when authenticating' do
+    setup do
+      Net::HTTP.stubs(:raw_response_data).returns('{"result": "abc", "id": "jsonrpc", "error": null}')
+      @client.authenticate
+    end
+    
+    should 'receive the correct call at the http level' do
+      assert_equal JSON.parse('{"params":[{"username":"cyber","password":"arts"}],"method":"APIAuthenticate","id":"jsonrpc"}'), 
+        JSON.parse(Net::HTTP.raw_post_body)
+    end
+    
+    should 'set auth_token' do
+      assert_equal 'abc', @client.auth_token
+    end
+  end
+    
+
+  context 'when successful it' do
+    setup do
+      Net::HTTP.stubs(:raw_response_data).returns('{"result": 9901014, "id": "jsonrpc", "error": null}')
+      @client.auth_token = 'tns5ddd7cc5271c8c6b5fab8aaf9ec492ed'
+      @result = @client.request("CreatePlayerAccount", :username => 'richard', :attributes => @client.key_value_array({:nickname => "rick", :mobile => "555-555-5555" }))
+    end
+    
+    should 'receive the correct call at the http level' do
+      assert_equal JSON.parse(
+      '{"params":[{"authorization":"tns5ddd7cc5271c8c6b5fab8aaf9ec492ed","username":"richard","attributes":[["mobile","555-555-5555"],["nickname","rick"]]}],"method":"CreatePlayerAccount","id":"jsonrpc"}'), 
+        JSON.parse(Net::HTTP.raw_post_body)
+    end
+    
+    should 'correctly parse the response from the server' do
+      assert_equal 9901014, @result
+    end
+  end
+  
+  context 'when unsuccessful it' do
+    setup do
+      Net::HTTP.stubs(:raw_response_data).returns('{"result": null, "error": {"code": 1, "message": "INVALID_SECURITY_TOKEN"} , "id": "jsonrpc"}' )
+    end
+    
+    should 'raise an exception when a call went wrong' do
+      assert_raise FoundationApi::JsonRPC::JsonRPCError do
+        @result = @client.post_request("test_method", {:param1 => "value1", :param2 => "value2" })
+      end
+    end
+    
+    should 'set exception properly' do
+      begin
+        @result = @client.post_request("test_method", {:param1 => "value1", :param2 => "value2" })
+      rescue => e
+        assert_equal 1, e.code
+        assert_equal "INVALID_SECURITY_TOKEN", e.message
+      end
+    end
+    
+  end
+
+  context 'when calling authenticated request' do
+    setup do
+      @client.auth_token = nil
+      Net::HTTP.stubs(:raw_response_data).returns(
+        '{"result": "tnsc0d764cb2555b26c8d5e0fbca439c07c", "id": "jsonrpc", "error": null}',
+        '{"result": "some data", "id": "jsonrpc", "error": null}')
+      @result = @client.request('ASimpleMethod', :with => 'a parameter')
+    end
+    
+    should 'set auth_token' do
+      assert_equal 'tnsc0d764cb2555b26c8d5e0fbca439c07c', @client.auth_token
+    end
+    
+    should 'return data' do
+      assert_equal "some data", @result
+    end
+  end
+
+  context 'when security token has expired it' do
+    setup do
+      @client.auth_token = 'kmsikss'
+    end
+    should 'try to authenticate again' do
+      Net::HTTP.stubs(:raw_response_data).returns(
+        '{"result": null, "error": {"code": 1, "message": "INVALID_SECURITY_TOKEN"} , "id": "jsonrpc"}',
+        '{"result": "tnsc0d764cb2555b26c8d5e0fbca439c07c", "id": "jsonrpc", "error": null}',
+        '{"result": "some data", "id": "jsonrpc", "error": null}')
+      @result = @client.request('ASimpleMethod', :with => 'a parameter')
+      assert_equal "some data", @result
+    end
+    should 'only try to authenticate once' do
+      Net::HTTP.stubs(:raw_response_data).returns(
+        '{"result": null, "error": {"code": 1, "message": "INVALID_SECURITY_TOKEN"} , "id": "jsonrpc"}',
+        '{"result": null, "error": {"code": 1, "message": "INVALID_SECURITY_TOKEN"} , "id": "jsonrpc"}')
+        begin
+          @result = @client.request("test_method", {:param1 => "value1", :param2 => "value2" })
+        rescue => e
+          assert_equal 1, e.code
+          assert_equal :invalid_security_token, e.response
+        end
+      
+    end
+  end
+  
+  
+  context 'when logging it' do
+    should 'strip password from message' do
+      s = '{"method":"CreatePlayerAccount","id":"jsonrpc","params":[{"username":"test5","attributes":[["clubhouse_token","ZpXEtiIKHoVA6kyieXQ7yw"],["email","test@tecnobingo.no"],["firstName","Test"],["lastName","One"],["password","my22secret"],["phone","90909090"]],"authorization":"tec-t-ca001.osl.basefarm.net:000-813793a81974dab06b9095a820691135"}]}'
+      expected = '{"method":"CreatePlayerAccount","id":"jsonrpc","params":[{"username":"test5","attributes":[["clubhouse_token","ZpXEtiIKHoVA6kyieXQ7yw"],["email","test@tecnobingo.no"],["firstName","Test"],["lastName","One"],["password","[FILTERED]"],["phone","90909090"]],"authorization":"tec-t-ca001.osl.basefarm.net:000-813793a81974dab06b9095a820691135"}]}'
+      assert_equal expected, @client.send(:password_filter, s)
+    end
+  end
+    
+end

data/test/unit/foundation_api/model/attribute_methods_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class FoundationApi::Model::AttributeMethodsTest < ActiveSupport::TestCase
+  class Model
+    include FoundationApi::Model::AttributeMethods
+    
+    alias_attribute :ip_subnet, :IPSubnet
+    
+    attr_accessor :attributes
+    
+    def initialize(attrs)
+      @attributes = HashWithIndifferentAccess.new attrs
+    end
+    
+  end
+  
+  context 'class method' do
+    context 'alias_attribute' do
+      should 'populate attribute_aliases' do
+        assert_equal ({'ip_subnet' => 'IPSubnet'}), Model.attribute_aliases
+      end
+    end
+    context 'map_attribute' do
+      should 'map attribute if known' do
+        assert_equal 'IPSubnet', Model.send(:map_attribute, :ip_subnet)
+      end
+      should 'return definition if unknown' do
+        assert_equal 'gurba', Model.send(:map_attribute, :gurba)
+      end
+    end
+    context 'reverse_map_attribute' do
+      should 'map attribute if known' do
+        assert_equal 'ip_subnet', Model.send(:reverse_map_attribute, :IPSubnet)
+      end
+      should 'return definition if unknown' do
+        assert_equal 'gurba', Model.send(:reverse_map_attribute, :gurba)
+      end
+    end
+    context 'translate_attributes' do
+      should 'return translated hash' do
+        expected = HashWithIndifferentAccess.new 'IPSubnet' => '123.234.56.0/24', 'melon' => :office
+        assert_equal expected, Model.send(:translate_attributes, :ip_subnet => '123.234.56.0/24', :melon => :office)
+      end
+    end
+  end
+  
+  context 'instance method' do
+    setup do
+      @model = Model.new(:boolean => true, :string => 'string', 'IPSubnet' => 'subnet')
+    end
+    context 'matching method' do
+      should 'return specified attribute if attribute exists' do
+        assert_equal :IPSubnet, @model.send(:matching_attribute, :IPSubnet)
+      end
+      should 'map attribute unless attribute exists' do
+        assert_equal 'IPSubnet', @model.send(:matching_attribute, :ip_subnet)
+      end
+      should 'return nil if attribute does not exist' do
+        assert_nil @model.send(:matching_attribute, :foo)
+      end
+    end
+    context 'accessing attributes' do
+      should 'give access through [] operator' do
+        assert_equal 'string', @model[:string]
+        assert_equal 'subnet', @model[:ip_subnet]
+        @model[:mood] = 'smiley'
+        assert_equal 'smiley', @model.mood
+        @model[:ip_subnet] = 'ugh'
+        assert_equal 'ugh', @model.ip_subnet
+        @model[:IPSubnet] = 'argh'
+        assert_equal 'argh', @model.ip_subnet
+      end
+    end
+    context 'method missing' do
+      should 'handle boolean methods' do
+        assert @model.boolean?
+      end
+      should 'handle assignments' do
+        assert !(@model.boolean = false)
+        assert !@model.boolean
+      end
+      should 'handle anythin else :p' do
+        assert_equal 'subnet', @model.ip_subnet
+      end
+      should 'allow to use unmapped attribute' do
+        assert_equal 'subnet', @model.IPSubnet
+      end
+      should 'raise exception if bad attribute name' do
+        assert_raises NoMethodError do
+          @model.bad
+        end
+      end
+    end
+  end
+  
+end