rainforest 1.0.7 → 2.0.0

data/lib/rainforest/resources/user.rb

@@ -0,0 +1,75 @@
+module Rainforest
+  class User < ApiResource
+    attr_accessor :analytics_id
+    attr_accessor :client_analytics_id
+    attr_accessor :created_at
+    attr_accessor :email
+    attr_accessor :id
+    attr_accessor :name
+    attr_accessor :profiles
+    attr_accessor :role
+    attr_accessor :settings
+    attr_accessor :state
+
+    def self.all(params={}, headers={})
+      res = client.users.all(params, headers)
+      res
+    end
+
+    def self.retrieve(user_id, params={}, headers={})
+      res = client.users.retrieve(user_id, params, headers)
+      res
+    end
+
+    def self.update(user_id, params={}, headers={})
+      res = client.users.update(user_id, params, headers)
+      res
+    end
+
+    def self.create(params={}, headers={})
+      res = client.users.create(params, headers)
+      res
+    end
+
+    def self.reset_password(email, params={}, headers={})
+      res = client.users.reset_password(email, params, headers)
+      res
+    end
+
+    def refresh(params={}, headers={})
+      res = client.users.retrieve(id, params, headers)
+      self.refresh_from(res.json, res.api_method, res.client)
+    end
+
+    def update(params={}, headers={})
+      res = client.users.update(id, params, headers)
+      self.refresh_from(res.json, res.api_method, res.client)
+    end
+
+    def save(params={}, headers={})
+      params = ParamsBuilder.merge(api_attributes, params)
+      res = client.users.update(id, params, headers)
+      self.refresh_from(res.json, res.api_method, res.client)
+    end
+
+    def reset_password(params={}, headers={})
+      res = client.users.reset_password(email, params, headers)
+      res
+    end
+
+    # Everything below here is used behind the scenes.
+    ApiResource.register_api_subclass(self, "user")
+    @api_attributes = {
+      :analytics_id => {},
+      :client_analytics_id => {},
+      :created_at => {},
+      :email => {},
+      :id => {},
+      :name => {},
+      :profiles => {},
+      :role => {},
+      :settings => {},
+      :state => {},
+    }
+  end
+end

data/rainforest.gemspec

@@ -4,16 +4,17 @@ require 'rainforest/version'
 
 spec = Gem::Specification.new do |s|
   s.name = 'rainforest'
+  s.summary = 'Ruby bindings for Rainforest API'
+  s.description = 'Rainforest automates your functional and integration testing with our QA-as-a-Service API.'
+  s.homepage = 'https://docs.rainfroestqa.com'
+  s.authors = ['Apibits.com']
+  s.email = ['libraries@apibits.com']
   s.version = Rainforest::VERSION
-  s.summary = 'Ruby bindings for the Rainforest API'
-  s.description = 'Rainforest allows you to create tests for your website in plain English, then run them across all major browsers with a single click.  See https://www.rainforestqa.com/ for details.'
-  s.authors = ['Jon Calhon']
-  s.email = ['joncalhoun@gmail.com']
-  s.homepage = 'https://github.com/joncalhoun/rainforest-ruby'
   s.license = 'MIT'
 
   s.add_dependency('rest-client', '~> 1.4')
-  s.add_dependency('multi_json', '>= 1.0.4', '< 2')
+  s.add_dependency('mime-types', '>= 1.25', '< 3.0')
+  s.add_dependency('json', '~> 1.8.1')
 
   s.add_development_dependency('mocha', '~> 0.13.2')
   s.add_development_dependency('shoulda', '~> 3.4.0')
@@ -25,3 +26,4 @@ spec = Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 end
+

data/test/rainforest/api_client_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ApiClientTest < ::Test::Unit::TestCase
+    setup do
+      @headers = {
+        :Accept => "application/json",
+        :Authorization => "Fake Auth"
+      }
+      @params = {
+        :customer_id => 123
+      }
+      @client = ApiClient.new(@headers, @params)
+    end
+
+    context '#execute' do
+      setup do
+        @api_method = mock
+        @api_method.stubs(:headers).returns({
+          :fake_header => "fake-header-val"
+        })
+        @api_method.stubs(:headers=)
+        @api_method.stubs(:params).returns({
+          :fake_param => "fake-param"
+        })
+        @api_method.stubs(:params=)
+        @api_method.stubs(:execute)
+      end
+
+      should 'merge the client headers and params into the api_method' do
+        expected_headers = { :hello => true }
+        expected_params = { :goodbye => false }
+
+        ParamsBuilder.expects(:merge).with(@api_method.headers, @headers).returns(expected_headers)
+        ParamsBuilder.expects(:merge).with(@api_method.params, @params).returns(expected_params)
+
+        @api_method.expects(:headers=).with(expected_headers)
+        @api_method.expects(:params=).with(expected_params)
+
+        @client.execute(@api_method)
+      end
+
+      should 'call api_method.execute and return the results' do
+        expected = { :status => "success!" }
+        @api_method.expects(:execute).returns(expected)
+        assert_equal(expected, @client.execute(@api_method))
+      end
+    end
+
+  end
+end

data/test/rainforest/api_endpoint_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ApiEndpointTest < ::Test::Unit::TestCase
+    context '#initialize' do
+      should 'set the client and parent' do
+        ep = ApiEndpoint.new("client", "parent")
+        assert_equal("client", ep.client)
+        assert_equal("parent", ep.parent)
+      end
+    end
+  end
+end

data/test/rainforest/api_list_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ApiListTest < ::Test::Unit::TestCase
+
+    context '#initialize' do
+      setup do
+        @fake_resource = { :data => "fake-data" }
+        @list = ApiList.new(ApiResource, [@fake_resource])
+      end
+
+      should 'set the klass' do
+        assert_equal(ApiResource, @list.klass)
+      end
+
+      should 'convert the data to klass instances' do
+        assert(@list.first.is_a?(ApiResource))
+        assert_equal(@fake_resource, @list.first.json)
+      end
+    end
+
+    context '#refresh_from' do
+      setup do
+        @fake_resource = { :data => "fake-data" }
+        @fake_method = "fake-api-method"
+        @fake_client = "fake-client"
+        @list = ApiList.new(ApiResource, [], "invalid", "invalid")
+      end
+
+      should 'update the api_method' do
+        @list.refresh_from([@fake_resource], @fake_method)
+        assert_equal(@list.api_method, @fake_method)
+      end
+
+      should 'update the client' do
+        @list.refresh_from([@fake_resource], nil, @fake_client)
+        assert_equal(@list.client, @fake_client)
+      end
+
+      should 'clear existing data' do
+        @list.refresh_from(["new-data"])
+
+        assert_nil(@list.api_method)
+        assert_nil(@list.client)
+      end
+    end
+
+  end
+end

data/test/rainforest/api_method_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ApiMethodTest < ::Test::Unit::TestCase
+    setup do
+      @method = :get
+      @path = "/testing"
+      @params = { :param_a => "1" }
+      @headers = { :header_a => "a" }
+      @object = mock
+      @api_method = ApiMethod.new(@method, @path, @params, @headers, @object)
+    end
+
+    context '#initialize' do
+      should 'set the api_base' do
+        assert_equal(Rainforest.api_base, @api_method.api_base)
+      end
+
+      should 'use PathBuilder with path, object, and params' do
+        PathBuilder.expects(:build).with(@path, @object, @params).returns(@path)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+
+      should 'use ParamsBuilder with params' do
+        ParamsBuilder.expects(:build).with(@params).returns(@params)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+
+      should 'use HeadersBuilder with headers, api_key, and nil auth_header' do
+        HeadersBuilder.expects(:build).with(@headers).returns(@headers)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+    end
+
+    context '#execute' do
+      setup do
+        @mock_response = mock
+        @mock_response.stubs(:body).returns('{"status": "success"}')
+        @mock_response.stubs(:code).returns(200)
+      end
+
+      should 'call Requester.request with the set attrs' do
+        Requester.expects(:request).with(@method, @api_method.url, @api_method.params, @api_method.headers).returns(@mock_response)
+        @api_method.execute
+      end
+
+      should 'create an ApiError if the request fails' do
+        Requester.expects(:request).raises(RestClient::RequestTimeout.new)
+
+        assert_raises(ApiError) { @api_method.execute }
+      end
+
+      should 'return the response parsed as json' do
+        Requester.expects(:request).returns(@mock_response)
+        assert_equal({:status => "success"}, @api_method.execute)
+      end
+
+      should 'return an AuthenticationError if the status is 401' do
+        error = RestClient::ExceptionWithResponse.new
+        error.expects(:http_code).returns(401)
+
+        Requester.expects(:request).raises(error)
+        assert_raises(AuthenticationError) { @api_method.execute }
+      end
+    end
+
+    context '#response_json' do
+      setup do
+        @api_method.response_body = 'not-valid-json'
+      end
+
+      should 'throw an error if the response_body isnt valid json' do
+        assert_raises(ApiError) { @api_method.response_json }
+      end
+    end
+
+  end
+end

data/test/rainforest/headers_builder_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class HeadersBuilderTest < ::Test::Unit::TestCase
+
+    setup do
+      @headers = {
+        :dog => "dog-value"
+      }
+      @built_headers = HeadersBuilder.build(@headers)
+    end
+
+    should 'set the user_agent' do
+      assert(@built_headers.has_key?(:user_agent))
+      assert(@built_headers[:user_agent].include?(Rainforest::VERSION))
+      assert(@built_headers[:user_agent].include?(Rainforest.api_version))
+    end
+
+    should 'set a client user agent' do
+      # This can be raw or json encoded depending on various things
+      unless @built_headers.has_key?(:x_rainforest_client_user_agent) ||
+        @built_headers.has_key?(:x_rainforest_client_raw_user_agent)
+        raise "No valid client user agent found"
+      end
+    end
+
+  end
+end

data/test/rainforest/params_builder_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class ParamsBuilderTest < ::Test::Unit::TestCase
+
+    setup do
+      @params = {
+        :dog => "dog-value",
+        "string" => "str-value"
+      }
+    end
+
+    context '#clean' do
+      setup do
+        @built_params = ParamsBuilder.clean(@params)
+      end
+
+      should 'convert keys to symbols' do
+        assert(@built_params.has_key?(:string))
+        assert_equal(@params["string"], @built_params[:string])
+      end
+
+      should 'not have any string keys' do
+        @built_params.each do |k, v|
+          assert(k.is_a?(Symbol))
+        end
+      end
+    end
+
+    context '#merge' do
+      setup do
+        @to_merge = {
+          :string => "other-str-value",
+          "cat" => "cat-value"
+        }
+        @built_params = ParamsBuilder.merge(@params, @to_merge)
+      end
+
+      should 'convert keys to symbols' do
+        assert(@built_params.has_key?(:cat))
+        assert(@built_params.has_key?(:string))
+        assert(!@built_params.has_key?("string"))
+      end
+
+      should 'merge in all values' do
+        assert_equal(@params[:dog], @built_params[:dog])
+        assert_equal(@to_merge[:string], @built_params[:string])
+        assert_equal(@to_merge["cat"], @built_params[:cat])
+      end
+
+      should 'prioritize values in @to_merge' do
+        assert_equal(@to_merge[:string], @built_params[:string])
+      end
+    end
+
+  end
+end

data/test/rainforest/path_builder_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class PathBuilderTest < ::Test::Unit::TestCase
+    class FakeClass
+      def abc; return "abc-value"; end
+      def self.xyz; return "xyz-value"; end
+    end
+
+    setup do
+      @params = {
+        :dog => "dog-value"
+      }
+      @obj = FakeClass.new
+    end
+
+    should 'use instance methods' do
+      path = "/a/:abc/123"
+      expected = "/a/abc-value/123"
+
+      actual = PathBuilder.build(path, @obj, nil)
+      assert_equal(expected, actual)
+    end
+
+    should 'use class methods' do
+      path = "/a/:xyz/123"
+      expected = "/a/xyz-value/123"
+
+      actual = PathBuilder.build(path, FakeClass, nil)
+      assert_equal(expected, actual)
+    end
+
+    should 'use param values' do
+      path = "/a/:dog/123"
+      expected = "/a/dog-value/123"
+
+      actual = PathBuilder.build(path, nil, @params)
+      assert_equal(expected, actual)
+    end
+
+    should 'use both methods and params' do
+      path = "/a/:dog/:abc/123"
+      expected = "/a/dog-value/abc-value/123"
+
+      actual = PathBuilder.build(path, @obj, @params)
+      assert_equal(expected, actual)
+    end
+
+  end
+end

data/test/rainforest/requester_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class RequesterTest < ::Test::Unit::TestCase
+    setup do
+    end
+
+    context '#prepare_params' do
+      setup do
+        @url = "test_url"
+        @params = { :a => 1, :b => [2, 3] }
+      end
+
+      should 'convert :get params to a query string' do
+        url, params = Requester.prepare_params(:get, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :delete params to a query string' do
+        url, params = Requester.prepare_params(:delete, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :head params to a query string' do
+        url, params = Requester.prepare_params(:head, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      context 'method = :post' do
+        setup do
+          @method = :post
+        end
+
+        should 'not convert params to a query string if a file is in them' do
+          expected = { file: File.new(__FILE__) }
+          url, params = Requester.prepare_params(@method, @url, expected)
+          assert_equal(expected, params)
+        end
+
+        should 'convert params to a query string if a file is not present' do
+          url, params = Requester.prepare_params(@method, @url, @params)
+          assert(params.is_a?(String))
+        end
+      end
+    end
+
+    context '#query_string' do
+      should 'join #query_array results with an "&"' do
+        start = { :a => 1, :b => [2, 3] }
+        expected = ["a=1", "b[]=2", "b[]=3"]
+
+        actual = Requester.query_string(start).split('&')
+        actual.each do |str|
+          assert(expected.include?(str))
+        end
+      end
+    end
+
+    context '#query_array' do
+      should 'convert { :a => "value" } to ["a=value"]' do
+        start = { :a => "value" }
+        finish = ["a=value"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+
+      should 'convert { :a => { :b => { :c => "cvalue" } } } to ["a[b][c]=cvalue"]' do
+        start = { :a => { :b => { :c => "cvalue" } } }
+        finish = ["a[b][c]=cvalue"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+
+      should 'convert { :a => [1, 2] } to ["a[]=1", "a[]=2"]' do
+        start = { :a => [1, 2] }
+        finish = ["a[]=1", "a[]=2"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+    end
+
+  end
+end