wot_api 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1fde6a4c40567dfc6ea8e99dc1ee523a6679c4c
-  data.tar.gz: 2bf93cb39e4d3cf24136ef4803464da523e9b05c
+  metadata.gz: 3e826f62809406bc30070f6f9419724caf6e4741
+  data.tar.gz: 40f59f007e5e725b862214079cd892a520438ddd
 SHA512:
-  metadata.gz: d42151882278a2dcad9ba63d810f7d34d3901eaf8d2668179b57bdcc8fb4a380d09701d301f32f5996e772293ff8dddde002ecd5e36a3854a9de2c785be50e6b
-  data.tar.gz: aa61846e095267d40cd6ec8d79a464fa52cc064dc277af7f4656677cf652a66adc1263bffab0c8dba3add74bca04ec52fb702552f5dc3145b277d152ab827908
+  metadata.gz: 95dc8341de126a4553908b08f2a99f20be6be49980f278053f646e1e18548d89968b50751625066ea30c787ba0a4b9b0df481d76fe9e392f649a3238aed80554
+  data.tar.gz: 5381e7853d8fd3fdb6b425c6af946ee1272572c357bfeffe69dff2acabfc7064b4c71db0bce942296bf1fd3b3dc2044d2ea0ea46021dfcb628b77a800590d248

data/README.md

@@ -28,7 +28,7 @@ NOTE: Other WoT geographical regions require different Application IDs
 
 Initialize the gem with your Application ID(s):
 
-    WotApi::Base.config({na: '123456'})
+    WotApi.config({na: '123456'})
 
 The available regions are: :na, :ru, :eu, :asia, :kr
 
@@ -36,7 +36,7 @@ The first region specified becomes the default if no region is specified in endp
 
 If using Rails, it is recommended to create an initializer that looks something like:
 
-    WotApi::Base.config(YAML.load_file("#{::Rails.root}/config/wot_api.yml"))
+    WotApi.config(YAML.load_file("#{::Rails.root}/config/wot_api.yml"))
 
 Along with a yaml file, config/wot_api.yml:
 
@@ -45,13 +45,21 @@ Along with a yaml file, config/wot_api.yml:
 
 Call endpoints like such:
 
-    WotApi::Base.account_list(search: 'tank', region: :ru)
+    WotApi.account_list(search: 'tank', region: :ru)
+
+Which wraps the '/wot/account/list' endpoint, with 'search' params and in the :ru region
 
 Will return an array or hash with the results, or throw an error with a message on a failure.
 
-## Future plans
+NOTE: Version 1.2.0 removes the need for all api methods to be called with "WotApi::Base.method", instead can just use "WotApi.method" for less keystrokes. However, the existing methods are still available at WotApi::Base for compatibility. 
+
+## Clan member resources
+
+There is an additional endpoint used to list clan member resource counts:
+
+    WotApi.clans_accounts(clan_id: "12345")
 
-Add class wrappers for endpoints with convenience methods for class relationships and such. 
+This will return an array of the clan members with their recent and total resource counts
 
 ## Contributing
 

data/lib/wot_api/base.rb

@@ -1,102 +1,25 @@
-require "httparty"
-
+# WotApi::Base wrapper for WotApi for compatibility, moved all real functionality directly to WotApi module
+# This need never change - any future methods added do not need to be added here
 module WotApi
 
   class Base
-    include HTTParty
-
-    REGIONS = {
-      na: 'https://api.worldoftanks.com',
-      ru: 'https://api.worldoftanks.ru',
-      eu: 'https://api.worldoftanks.eu',
-      asia: 'https://api.worldoftanks.asia',
-      kr: 'https://api.worldoftanks.kr'
-    }
-
-    REGIONS2 = {
-      na: 'http://na.wargaming.net',
-      ru: 'http://ru.wargaming.net',
-      eu: 'http://eu.wargaming.net',
-      asia: 'http://asia.wargaming.net',
-      kr: 'http://kr.wargaming.net',
-    }
-
-    class << self
-      attr_reader :configuration
-      attr_reader :default_region
-
-      def config(params={})
-        @configuration = {}
-        @default_region = nil
-        params.each do |conf|
-          region = conf[0].to_sym
-          application_id = conf[1]
-          if REGIONS[region] && application_id
-            @default_region ||= region
-            @configuration[region] = {base_uri: REGIONS[region], application_id: application_id.to_s}
-          else
-            raise WotApi::InvalidConfigError
-          end
-        end
-      end
 
-      def clans_accounts(params)
-        params ||= {}
-        raise WotApi::InvalidArguments unless params[:clan_id]
-        if region = params.delete(:region).to_sym rescue nil
-          base_uri = REGIONS2[region]
-        else
-          base_uri = REGIONS2[@default_region]
-        end
-        raise WotApi::InvalidRegionError unless base_uri
-        self.base_uri base_uri
-        response = WotApi::Base.get("/clans/#{params[:clan_id]}/accounts", headers: {"X-Requested-With"=> "XMLHttpRequest"})
-        JSON.parse(response||"{}")['items']
-      end
-
-      def pathname(path)
-        path.gsub(/(\/)+$/,'').gsub('/wot/','').gsub('/', '_')
-      end
+    def self.config(params={})
+      WotApi.config(params)
+    end
 
-      def merged_params(params)
-        params ||= {}
-        raise WotApi::InvalidConfigError unless @configuration.class == Hash
-        if region = params.delete(:region).to_sym rescue nil
-          config = @configuration[region]
-        else
-          config = @configuration[@default_region]
-        end
-        base_uri = config[:base_uri] rescue nil
-        application_id = config[:application_id] rescue nil
-        raise WotApi::InvalidRegionError unless base_uri && application_id
-        self.base_uri base_uri
-        params.merge({application_id: application_id})
-      end
+    def self.method_missing(method_sym, *params, &block)
+      WotApi.method_missing(method_sym, *params, &block)
+    end
 
-      def merged_post(endpoint, params={})
-        WotApi::Base.post(endpoint, body: merged_params(params))
-      end
+    def self.respond_to?(method_sym, include_private = false)
+      WotApi.respond_to?(method_sym, include_private)
+    end
 
-      def method_missing(method_sym, *arguments, &block)
-        if !self.methods.include?(method_sym) && method_sym.to_s =~ /^([^_]*)_([^_]*)$/
-          endpoint = "/wot/" + method_sym.to_s.gsub('_','/') + "/"
-          begin
-            response = merged_post(endpoint, arguments.first)
-          rescue
-            raise WotApi::ConnectionError
-          end
-          if response && response['data']
-            return response['data']
-          else
-            message = 'Unknown Error'
-            message = response['error']['message'] if response && response['error'] && response['error']['message']
-            raise WotApi::ResponseError, message
-          end
-        else
-          super
-        end
-      end
+    def self.clans_accounts(params={})
+      WotApi.clans_accounts(params)
     end
+
   end
 
 end

data/lib/wot_api/version.rb

@@ -1,3 +1,3 @@
 module WotApi
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/wot_api/wot_api.rb

@@ -0,0 +1,43 @@
+require "httparty"
+
+module WotApi
+
+  def self.config(params={})
+    WotApi::Wrapper.configuration = {}
+    WotApi::Wrapper.default_region = nil
+    params.each do |region, id|
+      region = region.to_sym
+      if WotApi::Wrapper::REGIONS[region] && id
+        WotApi::Wrapper.default_region ||= region
+        WotApi::Wrapper.configuration[region] = id.to_s
+      else
+        raise WotApi::InvalidConfigError, "Region: #{region} or ID: #{id} is invalid"
+      end
+    end
+  end
+
+  def self.method_missing(method_sym, *params, &block)
+    if WotApi::Wrapper.valid_endpoint?(method_sym)
+      return WotApi::Wrapper.wot_api_post(method_sym, params.first)
+    else
+      super
+    end
+  end
+
+  def self.respond_to?(method_sym, include_private = false)
+    if WotApi::Wrapper.valid_endpoint?(method_sym)
+      return true
+    else
+      super
+    end
+  end
+
+  # methods outside of 'typical' WoT API calls:
+
+  def self.clans_accounts(params={})
+    raise WotApi::InvalidArguments, ":clan_id required" unless params[:clan_id]
+    response = WotApi::Wrapper.wot_web_get("/clans/#{params[:clan_id]}/accounts", headers: {"X-Requested-With"=> "XMLHttpRequest"})
+    JSON.parse(response||"{}")['items']
+  end
+
+end

data/lib/wot_api/wrapper.rb

@@ -0,0 +1,106 @@
+require "httparty"
+
+module WotApi
+
+  class Wrapper
+    include HTTParty
+
+    REGIONS = {
+      na: 'https://api.worldoftanks.com',
+      ru: 'https://api.worldoftanks.ru',
+      eu: 'https://api.worldoftanks.eu',
+      asia: 'https://api.worldoftanks.asia',
+      kr: 'https://api.worldoftanks.kr'
+    }
+
+    REGIONS_WEB = {
+      na: 'http://na.wargaming.net',
+      ru: 'http://ru.wargaming.net',
+      eu: 'http://eu.wargaming.net',
+      asia: 'http://asia.wargaming.net',
+      kr: 'http://kr.wargaming.net',
+    }
+
+    class << self
+
+      attr_accessor :configuration, :default_region
+
+      def wot_api_post(method_sym, params)
+        endpoint = method_to_endpoint(method_sym)
+        region = params.delete(:region).to_sym rescue get_default_region
+        set_base_uri(region)
+        begin
+          response = merged_post(endpoint, region, params)
+        rescue
+          raise WotApi::ConnectionError, "Could not connect to WoT endpoint #{endpoint.to_s}"
+        end
+        return format_response(response)
+      end
+
+      def wot_web_get(endpoint, params={})
+        region = params.delete(:region).to_sym rescue get_default_region
+        set_base_uri(region, true)
+        begin
+          return self.get(endpoint, params).parsed_response
+        rescue Exception => e
+          raise WotApi::ConnectionError, "ERROR with WoT web endpoint #{endpoint.to_s}"
+        end
+      end
+
+      def valid_endpoint?(method_sym)
+        !(method_sym.to_s =~ /^([^_]*)_([^_]*)$/).nil?
+      end
+
+      private
+
+      def method_to_endpoint(method_sym)
+        "/wot/" + method_sym.to_s.gsub('_','/') + "/"
+      end
+
+      def set_base_uri(region, web=false)
+        base_uri = web ? get_web_base_uri_for_region(region) : get_base_uri_for_region(region)
+        raise WotApi::InvalidRegionError unless base_uri
+        self.base_uri base_uri
+      end
+
+      def merged_params(params, region)
+        application_id = get_application_id_for_region(region)
+        raise WotApi::InvalidRegionError, "Invalid region specified: #{region}" unless application_id
+        params.merge({application_id: application_id})
+      end
+
+      def get_application_id_for_region(region)
+        raise WotApi::InvalidConfigError unless @configuration.class == Hash
+        return @configuration[region]
+      end
+
+      def merged_post(endpoint, region, params={})
+        self.post(endpoint, body: merged_params(params, region))
+      end
+
+      def get_web_base_uri_for_region(region)
+        return REGIONS_WEB[region]
+      end
+
+      def get_base_uri_for_region(region)
+        return REGIONS[region]
+      end
+
+      def get_default_region
+        raise WotApi::InvalidConfigError unless @default_region
+        return @default_region
+      end
+
+      def format_response(response)
+        if response && response['data']
+          return response['data']
+        end
+        message = 'Unknown Error'
+        message = response['error']['message'] if response && response['error'] && response['error']['message']
+        raise WotApi::ResponseError, "WoT API response error: #{message}"
+      end
+
+    end
+  end
+
+end

data/lib/wot_api.rb

@@ -1,5 +1,7 @@
 require "wot_api/version"
+require "wot_api/wot_api"
 require "wot_api/base"
+require "wot_api/wrapper"
 require "wot_api/exceptions"
 
 module WotApi; end

data/spec/base_spec.rb

@@ -2,173 +2,103 @@ require 'spec_helper'
 
 describe WotApi::Base do
 
-  it "has an empty base_uri" do
-    # NOTE: may remove this entirely if base_uri is just going to be set dynamically
-    expect(WotApi::Base.base_uri).to eq nil
-  end
-
-  it "includes HTTParty" do
-    expect(WotApi::Base.new).to be_a_kind_of(HTTParty)
-  end
-
-  describe "REGIONS" do
-    WotApi::Base::REGIONS.each do |region, url|
-      describe "#{region}" do
-        it "has a sym region key" do
-          expect(region).to be_a Symbol
-        end
-
-        it "has a string value" do
-          expect(url).to be_a String
-        end
-
-        it "uses https" do
-          expect(URI.parse(url).scheme).to eq 'https'
-        end
-      end
-    end
-  end
-
-  describe "REGIONS2" do
-    WotApi::Base::REGIONS2.each do |region, url|
-      describe "#{region}" do
-        it "has a sym region key" do
-          expect(region).to be_a Symbol
-        end
-
-        it "has a string value" do
-          expect(url).to be_a String
-        end
-
-        it "uses http" do
-          expect(URI.parse(url).scheme).to eq 'http'
-        end
-      end
-    end
-  end
-
-  describe ".clans_accounts" do
-    it "calls WotApi::Base.get with endpoint and clan_id" do
-      WotApi::Base.config({'na' => '123456'})
-      expect(WotApi::Base).to receive(:get).with("/clans/12345/accounts", headers: {"X-Requested-With"=> "XMLHttpRequest"})
-      WotApi::Base.clans_accounts(clan_id: "12345")
-    end
-  end
-
-  describe ".merged_post" do
-    it "calls WotApi::Base.post with endpont and merged_params output" do
-      params1 = {random: 'hash'}
-      params2 = {misc: 'data'}
-      endpoint = '/test/endpoint/'
-      expect(WotApi::Base).to receive(:merged_params).with(params1).and_return(params2)
-      expect(WotApi::Base).to receive(:post).with(endpoint, {body: params2})
-      WotApi::Base.merged_post(endpoint, params1)
-    end
-    it "has default empty hash for params" do
-      expect(WotApi::Base).to receive(:merged_params).with({}).and_return({})
-      allow(WotApi::Base).to receive(:post)
-      WotApi::Base.merged_post('/test/nothing')
-    end
-  end
-
   describe ".config" do
     context "with a valid config" do
-      it "creates hash of regions with base_uri and application_id" do
+      it "writes valid configuration to WotApi::Wrapper.configuration" do
         WotApi::Base.config({'na' => '123456'})
-        expect(WotApi::Base.configuration).to eq({na: {base_uri: 'https://api.worldoftanks.com', application_id: '123456'}})
+        expect(WotApi::Wrapper.configuration).to eq({na: '123456'})
       end
 
       it "sets first item as default region" do
         WotApi::Base.config({'na' => '123456'})
-        expect(WotApi::Base.default_region).to eq :na
+        expect(WotApi::Wrapper.default_region).to eq :na
         WotApi::Base.config({'ru' => '444444','na' => '123456'})
-        expect(WotApi::Base.default_region).to eq :ru
+        expect(WotApi::Wrapper.default_region).to eq :ru
       end
     end
 
     context "with an invalid config" do
       it "raises an error" do
-        expect{WotApi::Base.config({lalala: 'fake'})}.to raise_error
+        expect{WotApi::Base.config({lalala: 'fake'})}.to raise_error WotApi::InvalidConfigError
       end
     end
   end
 
-  describe ".merged_params" do
-    context "with a valid region parameter" do
-      it "merges the params hash argument with the application_id from the specified region" do
-        arguments = {a: 'hi', b: 'test', c: 3, region: 'na'}
-        WotApi::Base.config(na: 'abc123')
-        expect(WotApi::Base.merged_params(arguments)).to eq({a: 'hi', b: 'test', c: 3}.merge(application_id: 'abc123'))
-      end
+  describe ".method_missing" do
+    it "checks WotApi::Wrapper for valid_endpoint" do
+      expect(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      allow(WotApi::Wrapper).to receive(:wot_api_post)
+      WotApi::Base.fake_method
     end
 
-    context "with an invalid region parameter" do
-      it "raises an exception" do
-        arguments = {a: 'hi', b: 'test', c: 3, region: 'banana'}
-        WotApi::Base.config(na: 'abc123')
-        expect{WotApi::Base.merged_params(arguments)}.to raise_error
+    context "valid_endpoint true" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
       end
-    end
 
-    context "with no region parameter" do
-      it "merges the params hash argument with the application_id from the default first region" do
-        arguments = {a: 'hi', b: 'test', c: 3}
-        WotApi::Base.config(na: 'abc123')
-        expect(WotApi::Base.merged_params(arguments)).to eq arguments.merge(application_id: 'abc123')
+      it "calls WotApi::Wrapper.wot_api_post" do
+        expect(WotApi::Wrapper).to receive(:wot_api_post)
+        WotApi::Base.fake_method
+      end
+
+      it "calls WotApi::Wrapper.wot_api_post with method symbol and parameters" do
+        expect(WotApi::Wrapper).to receive(:wot_api_post).with(:fake_method, {hi: true})
+        WotApi::Base.fake_method(hi: true)
       end
     end
 
-    it "sets base_uri" do
-      WotApi::Base.config(na: 'abc123')
-      WotApi::Base.merged_params({})
-      expect(WotApi::Base.base_uri).to eq WotApi::Base::REGIONS[:na]
+    context "valid_endpoint false" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(false)
+      end
 
-      WotApi::Base.config(ru: 'abc123')
-      WotApi::Base.merged_params({})
-      expect(WotApi::Base.base_uri).to eq WotApi::Base::REGIONS[:ru]
+      it "raises NoMethodError" do
+        expect{ WotApi::Base.fake_method(stuff: true) }.to raise_error NoMethodError
+      end
     end
   end
 
-  describe "endpoint methods via method_missing" do
-    before(:example) do
-      WotApi::Base.config({na: '123456'})
-    end
-
-    it "posts to the specified endpoint" do
-      expect(WotApi::Base).to receive(:post).with("/wot/thing/stuff/", kind_of(Hash)).and_return({'data' => true})
-      WotApi::Base.thing_stuff(a: 'test')
+  describe ".respond_to?" do
+    it "checks WotApi::Wrapper for valid_endpoint" do
+      expect(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      WotApi::Base.respond_to?(:fake_method)
     end
 
-    it "accepts a hash of arguments to post to the endpoint and merges them with the application_id" do
-      arguments = {a: 'hi', b: 'test', c: 3}
-      expect(WotApi::Base).to receive(:post).with("/wot/thing/stuff/", body: arguments.merge(application_id: '123456')).and_return({'data' => true})
-      WotApi::Base.thing_stuff(arguments)
-    end
+    context "valid_endpoint true" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      end
 
-    context "with a valid response" do
-      it "receives a response from api with data in an Array or Hash" do
-        FakeWeb.register_uri(:post, "#{WotApi::Base.base_uri}/wot/thing/stuff/", :response => File.join(File.dirname(__FILE__), 'fixtures', "success.json"))
-        expect(WotApi::Base.thing_stuff).to be_a_kind_of(Array)
+      it "returns true" do
+        expect(WotApi::Base.respond_to?(:fake_method)).to eq true
       end
     end
 
-    context "with an invalid response" do
-      it "raises an exception" do
-        FakeWeb.register_uri(:post, "#{WotApi::Base.base_uri}/wot/thing/stuff/", :response => File.join(File.dirname(__FILE__), 'fixtures', "error.json"))
-        expect{WotApi::Base.thing_stuff}.to raise_error(WotApi::ResponseError)
+    context "valid_endpoint false" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(false)
       end
 
-      it "includes the error message from WoT in the exception" do
-        FakeWeb.register_uri(:post, "#{WotApi::Base.base_uri}/wot/thing/stuff/", :response => File.join(File.dirname(__FILE__), 'fixtures', "error.json"))
-        expect{WotApi::Base.thing_stuff}.to raise_error(WotApi::ResponseError, 'APPLICATION_ID_NOT_SPECIFIED')
+      it "returns false" do
+        expect(WotApi::Base.respond_to?(:fake_method)).to eq false
       end
     end
+  end
 
-    context "with an invalid endpoint" do
-      it "raises connection exception" do
-        allow(WotApi::Base).to receive(:post).and_raise(HTTParty::Error)
-        expect{WotApi::Base.thing_fake}.to raise_error(WotApi::ConnectionError)
-      end
+  describe ".clans_accounts" do
+    it "raises WotApi::InvalidArguments if clan_id not in arguments" do
+      expect{ WotApi::Base.clans_accounts }.to raise_error WotApi::InvalidArguments
+    end
+
+    it "calls WotApi::Wrapper.wot_web_get with endpoint and clan_id" do
+      expect(WotApi::Wrapper).to receive(:wot_web_get).with("/clans/12345/accounts", headers: {"X-Requested-With"=> "XMLHttpRequest"})
+      WotApi::Base.clans_accounts(clan_id: "12345")
+    end
+
+    it "returns parsed JSON" do
+      allow(WotApi::Wrapper).to receive(:wot_web_get).and_return({items: [1,2,3]}.to_json)
+      expect(WotApi::Base.clans_accounts(clan_id: "12345")).to eq [1,2,3]
     end
   end
+
 end

data/spec/fixtures/connection_error.json

@@ -0,0 +1,10 @@
+HTTP/1.1 200 OK
+Server: nginx
+Date: Tue, 05 Aug 2014 21:48:28 GMT
+Content-Type: application/json
+Transfer-Encoding: chunked
+Connection: keep-alive
+Vary: Accept-Encoding
+Access-Control-Allow-Origin: *
+
+{"status":"error","error":{"field":"application_id","message":"APPLICATION_ID_NOT_SPECIFIED","code":402,"value":null}}

data/spec/spec_helper.rb

@@ -1,5 +1,11 @@
+require 'simplecov'
 require 'coveralls'
-Coveralls.wear!
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
 
 require 'bundler/setup'
 Bundler.setup

data/spec/wot_api_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe WotApi do
+
+  describe ".config" do
+    context "with a valid config" do
+      it "writes valid configuration to WotApi::Wrapper.configuration" do
+        WotApi.config({'na' => '123456'})
+        expect(WotApi::Wrapper.configuration).to eq({na: '123456'})
+      end
+
+      it "sets first item as default region" do
+        WotApi.config({'na' => '123456'})
+        expect(WotApi::Wrapper.default_region).to eq :na
+        WotApi.config({'ru' => '444444','na' => '123456'})
+        expect(WotApi::Wrapper.default_region).to eq :ru
+      end
+    end
+
+    context "with an invalid config" do
+      it "raises an error" do
+        expect{WotApi.config({lalala: 'fake'})}.to raise_error WotApi::InvalidConfigError
+      end
+    end
+  end
+
+  describe ".method_missing" do
+    it "checks WotApi::Wrapper for valid_endpoint" do
+      expect(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      allow(WotApi::Wrapper).to receive(:wot_api_post)
+      WotApi.fake_method
+    end
+
+    context "valid_endpoint true" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      end
+
+      it "calls WotApi::Wrapper.wot_api_post" do
+        expect(WotApi::Wrapper).to receive(:wot_api_post)
+        WotApi.fake_method
+      end
+
+      it "calls WotApi::Wrapper.wot_api_post with method symbol and parameters" do
+        expect(WotApi::Wrapper).to receive(:wot_api_post).with(:fake_method, {hi: true})
+        WotApi.fake_method(hi: true)
+      end
+    end
+
+    context "valid_endpoint false" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(false)
+      end
+
+      it "raises NoMethodError" do
+        expect{ WotApi.fake_method(stuff: true) }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  describe ".respond_to?" do
+    it "checks WotApi::Wrapper for valid_endpoint" do
+      expect(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      WotApi.respond_to?(:fake_method)
+    end
+
+    context "valid_endpoint true" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(true)
+      end
+
+      it "returns true" do
+        expect(WotApi.respond_to?(:fake_method)).to eq true
+      end
+    end
+
+    context "valid_endpoint false" do
+      before(:example) do
+        allow(WotApi::Wrapper).to receive(:valid_endpoint?).with(:fake_method).and_return(false)
+      end
+
+      it "returns false" do
+        expect(WotApi.respond_to?(:fake_method)).to eq false
+      end
+    end
+  end
+
+  describe ".clans_accounts" do
+    it "raises WotApi::InvalidArguments if clan_id not in arguments" do
+      expect{ WotApi.clans_accounts }.to raise_error WotApi::InvalidArguments
+    end
+
+    it "calls WotApi::Wrapper.wot_web_get with endpoint and clan_id" do
+      expect(WotApi::Wrapper).to receive(:wot_web_get).with("/clans/12345/accounts", headers: {"X-Requested-With"=> "XMLHttpRequest"})
+      WotApi.clans_accounts(clan_id: "12345")
+    end
+
+    it "returns parsed JSON" do
+      allow(WotApi::Wrapper).to receive(:wot_web_get).and_return({items: [1,2,3]}.to_json)
+      expect(WotApi.clans_accounts(clan_id: "12345")).to eq [1,2,3]
+    end
+  end
+
+end

data/spec/wrapper_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe WotApi::Wrapper do
+
+  it { is_expected.to be_a_kind_of(HTTParty) }
+
+  describe ".wot_api_post" do
+    context "with a connection error" do
+      before(:example) do
+        FakeWeb.clean_registry
+        WotApi.config({'na' => '123456'})
+      end
+      it "raises WotApi::ConnectionError" do
+        expect{ WotApi::Wrapper.wot_api_post(:thing_stuff, {}) }.to raise_error WotApi::ConnectionError
+      end
+    end
+
+    context "with invalid endpoint" do
+      before(:example) do
+        FakeWeb.register_uri(:post, "https://api.worldoftanks.com/wot/thing/stuff/", :response => File.join(File.dirname(__FILE__), 'fixtures', "error.json"))
+        WotApi.config({'na' => '123456'})
+      end
+      it "raises WotApi::ResponseError" do
+        expect{ WotApi::Wrapper.wot_api_post(:thing_stuff, {}) }.to raise_error WotApi::ResponseError
+      end
+    end
+
+    context "with valid endpoint" do
+      before(:example) do
+        FakeWeb.register_uri(:post, "https://api.worldoftanks.com/wot/thing/stuff/", :response => File.join(File.dirname(__FILE__), 'fixtures', "success.json"))
+        WotApi.config({'na' => '123456'})
+      end
+      it "raises WotApi::ResponseError" do
+        expect(WotApi::Wrapper.wot_api_post(:thing_stuff, {})).to be_an Array
+      end
+    end
+  end
+
+  describe ".wot_web_get" do
+    context "with a connection error" do
+      before(:example) do
+        FakeWeb.clean_registry
+        WotApi.config({'na' => '123456'})
+      end
+      it "raises WotApi::ConnectionError" do
+        expect{ WotApi::Wrapper.wot_web_get('/endpoint', {}) }.to raise_error WotApi::ConnectionError
+      end
+    end
+    
+    context "with a valid endpoint" do
+      before(:example) do
+        FakeWeb.register_uri(:get, "http://na.wargaming.net/endpoint", :response => File.join(File.dirname(__FILE__), 'fixtures', "success.json"))
+        WotApi.config({'na' => '123456'})
+      end
+      it "returns result of get" do
+        expect(WotApi::Wrapper.wot_web_get('/endpoint', {})).to eq({"status"=>"ok","count"=>0,"data"=>[]})
+      end
+    end
+  end
+
+  describe ".valid_endpoint?" do
+    it "returns true for endponts like prefix _underscore_ suffix" do
+      expect(WotApi::Wrapper.valid_endpoint?(:test_things)).to eq true
+    end
+  end
+
+end

data/wot_api.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.3.0"
   spec.add_development_dependency "fakeweb", "~> 1.3"
   spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "simplecov"
 
   spec.add_runtime_dependency "httparty", "~> 0.13"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wot_api
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jesse Cantara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-02 00:00:00.000000000 Z
+date: 2015-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -112,10 +126,15 @@ files:
 - lib/wot_api/base.rb
 - lib/wot_api/exceptions.rb
 - lib/wot_api/version.rb
+- lib/wot_api/wot_api.rb
+- lib/wot_api/wrapper.rb
 - spec/base_spec.rb
+- spec/fixtures/connection_error.json
 - spec/fixtures/error.json
 - spec/fixtures/success.json
 - spec/spec_helper.rb
+- spec/wot_api_spec.rb
+- spec/wrapper_spec.rb
 - wot_api.gemspec
 homepage: https://github.com/jcantara/wot_api
 licenses:
@@ -144,6 +163,9 @@ specification_version: 4
 summary: API wrapper for 'World of Tanks'.
 test_files:
 - spec/base_spec.rb
+- spec/fixtures/connection_error.json
 - spec/fixtures/error.json
 - spec/fixtures/success.json
 - spec/spec_helper.rb
+- spec/wot_api_spec.rb
+- spec/wrapper_spec.rb