wialon_api 0.0.1

data/lib/wialon_api/result.rb

@@ -0,0 +1,20 @@
+module WialonApi
+  class Result
+    def self.process(response, block = nil)
+      result = extract_result(response)
+      if result.respond_to?(:each)
+        block.nil? ? result : result.map(&block)
+      else
+        block.nil? ? result : block.call(result)
+      end
+    end
+
+    def self.extract_result(response)
+      if response.error
+        fail WialonApi::Error.new(response)
+      else
+        response
+      end
+    end
+  end
+end

data/lib/wialon_api/version.rb

@@ -0,0 +1,3 @@
+module WialonApi
+  VERSION = "0.0.1"
+end

data/lib/wialon_api.rb

@@ -0,0 +1,23 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday_middleware/parse_oj'
+require 'yaml'
+require 'hashie'
+
+require 'wialon_api/version'
+require 'wialon_api/error'
+require 'wialon_api/configuration'
+require 'wialon_api/authorization'
+require 'wialon_api/api'
+require 'wialon_api/resolver'
+require 'wialon_api/resolvable'
+require 'wialon_api/client'
+require 'wialon_api/namespace'
+require 'wialon_api/method'
+require 'wialon_api/result'
+require 'wialon_api/logger'
+
+module WialonApi
+  extend WialonApi::Authorization
+  extend WialonApi::Configuration
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'wialon_api'
+require 'pry'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+end
+
+RSpec::Matchers.define :log_requests do
+  match do |logger|
+    logger.log_requests?
+  end
+end
+
+RSpec::Matchers.define :log_errors do
+  match do |logger|
+    logger.log_errors?
+  end
+end
+
+RSpec::Matchers.define :log_responses do
+  match do |logger|
+    logger.log_responses?
+  end
+end

data/spec/wialon_api/api_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe WialonApi::Api do
+  def create_connection
+    @result = { 'response' => { 'key' => 'value' } }
+
+    @connection = Faraday.new do |builder|
+      builder.response :mashify
+      builder.response :oj, preserve_raw: true
+      builder.adapter :test do |stub|
+        stub.post('/wialon/ajax.html') do
+          [200, {}, Oj.dump(@result)]
+        end
+      end
+    end
+    allow(subject).to receive(:connection).and_return(@connection)
+  end
+
+  describe '.call' do
+    before(:each) do
+      WialonApi.reset
+      create_connection
+    end
+
+    it 'sends a sid if it was passed with parameter' do
+      expect(subject).to receive(:connection).with(url: WialonApi.wialon_host, sid: 'sid')
+      subject.call('core/search_items', { params: :value }, 'sid')
+    end
+  end
+
+  describe '.connection' do
+    it 'uses the :url parameter and WialonApi.faraday_options' do
+      faraday_options = double('Faraday options')
+      allow(WialonApi).to receive(:faraday_options).and_return(faraday_options)
+      url = double('URL')
+
+      expect(Faraday).to receive(:new).with(url, faraday_options)
+      subject.connection(url: url)
+    end
+  end
+end

data/spec/wialon_api/authorization_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe WialonApi::Authorization do
+  describe '.authorize' do
+    let(:success) { Hashie::Mash.new(eid: 'sid') }
+    let(:error) { Hashie::Mash.new(error: '8') }
+    let(:credentials) { ['user', 'password'] }
+
+    it 'bulds a WialonApi client if the credentials are correct' do
+      allow(WialonApi::Api).to receive(:call).and_return(success)
+      expect(WialonApi::Client).to receive(:new).with('sid')
+      WialonApi.authorize(*credentials)
+    end
+
+    it 'raises an error if password or login do not match' do
+      allow(WialonApi::Api).to receive(:call).and_return(error)
+      expect { WialonApi.authorize(*credentials) }.to raise_error(WialonApi::Error)
+    end
+  end
+end

data/spec/wialon_api/client_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe WialonApi::Client do
+  let(:sid) { 'sid' }
+
+  describe '#authorized?' do
+    context 'with an unauthorized client' do
+      let(:client) { WialonApi::Client.new }
+
+      it 'returns false' do
+        expect(client).not_to be_authorized
+      end
+    end
+
+    context 'with an authorized client' do
+      let(:client) { WialonApi::Client.new(sid) }
+
+      it 'returns true' do
+        expect(client).to be_authorized
+      end
+    end
+  end
+end

data/spec/wialon_api/configuration_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+# Dummy class
+class TestConfiguration
+  extend WialonApi::Configuration
+end
+
+describe WialonApi::Configuration do
+  describe '#configure' do
+    it 'yields self' do
+      expect(TestConfiguration).to receive(:wialon_host)
+      TestConfiguration.configure(&:wialon_host)
+    end
+
+    it 'returns self' do
+      expect(TestConfiguration.configure).to eq(TestConfiguration)
+    end
+  end
+
+  describe '#reset' do
+    it 'resets all the values to their default values' do
+      TestConfiguration.reset
+      expect(TestConfiguration.wialon_host).to eq('https://hst-api.wialon.com/wialon/ajax.html')
+      expect(TestConfiguration.http_verb).to eq(:post)
+      expect(TestConfiguration.max_retries).to eq(1)
+      expect(TestConfiguration.faraday_options).to eq({})
+      expect(TestConfiguration.faraday_options).to eq({})
+      expect(TestConfiguration.adapter).to eq(Faraday.default_adapter)
+      expect(TestConfiguration.logger).to be_a(Logger)
+      expect(TestConfiguration.log_requests?).to eq(true)
+      expect(TestConfiguration.log_errors).to eq(true)
+      expect(TestConfiguration.log_responses).not_to eq(true)
+    end
+  end
+end

data/spec/wialon_api/error_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe WialonApi::Error do
+  let(:error_data) { Hashie::Mash.new('error' => 4) }
+  let(:error) { WialonApi::Error.new(error_data) }
+
+  it '#message returns error message by it\'s code' do
+    message = "Wialon server #{WialonApi.wialon_host} returned error 4: Invalid input"
+    expect { fail error }.to raise_error(error.class, message)
+  end
+end

data/spec/wialon_api/logger_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe WialonApi::Logger do
+  before(:each) do
+    WialonApi.logger = double('Logger').as_null_object
+
+    WialonApi.log_requests  = false
+    WialonApi.log_responses = false
+    WialonApi.log_errors    = false
+  end
+
+  let(:success_response) { Oj.dump('a' => 1, 'b' => 2) }
+  let(:fail_response) { Oj.dump('error' => 404) }
+
+  let(:connection) do
+    Faraday.new(url: 'http://example.com') do |builder|
+      builder.request :url_encoded
+      builder.response :wialon_logger
+      builder.response :mashify
+      builder.response :oj, preserve_raw: true
+
+      builder.adapter :test do |stub|
+        stub.get('/success') do
+          [200, {}, success_response]
+        end
+
+        stub.post('/success') do
+          [200, {}, success_response]
+        end
+
+        stub.get('/fail') do
+          [200, {}, fail_response]
+        end
+      end
+    end
+  end
+
+  context 'with WialonApi.log_requests?' do
+    before(:each) do
+      WialonApi.log_requests = true
+    end
+
+    it 'logs the request URL' do
+      expect(WialonApi.logger).to receive(:debug).with('GET http://example.com/success')
+      connection.get('/success')
+    end
+
+    context 'with a POST request' do
+      it 'logs the request URL and the request body' do
+        expect(WialonApi.logger).to receive(:debug).with('POST http://example.com/success')
+        expect(WialonApi.logger).to receive(:debug).with('body: "param=1"')
+        connection.post('/success', param: 1)
+      end
+    end
+  end
+
+  context 'without WialonApi.log_requests?' do
+    it 'does not log the request' do
+      expect(WialonApi.logger).not_to receive(:debug)
+      connection.get('/success')
+    end
+  end
+
+  context 'with a successful response' do
+    context 'with WialonApi.log_responses?' do
+      before(:each) do
+        WialonApi.log_responses = true
+      end
+
+      it 'logs the response body' do
+        expect(WialonApi.logger).to receive(:debug).with(success_response)
+        connection.get('/success')
+      end
+    end
+
+    context 'without WialonApi.log_responses?' do
+      it 'does not log the response body' do
+        expect(WialonApi.logger).not_to receive(:debug)
+        connection.get('/success')
+      end
+    end
+  end
+
+  context 'with an error response' do
+    context 'with WialonApi.log_errors?' do
+      before(:each) do
+        WialonApi.log_errors = true
+      end
+
+      it 'logs the response body' do
+        expect(WialonApi.logger).to receive(:warn).with(fail_response)
+        connection.get('/fail')
+      end
+    end
+
+    context 'without WialonApi.log_errors?' do
+      it 'does not log the response body' do
+        expect(WialonApi.logger).not_to receive(:warn)
+        connection.get('/fail')
+      end
+    end
+  end
+end

data/spec/wialon_api/method_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe WialonApi::Method do
+  describe '#call' do
+    let(:full_name) { double('Full method name') }
+    let(:args) { double('Method arguments') }
+    let(:sid) { double('Session\'s id') }
+
+    let(:method) do
+      WialonApi::Method.new('some_name').tap do |method|
+        allow(method).to receive(:full_name).and_return(full_name)
+        allow(method).to receive(:sid).and_return(sid)
+      end
+    end
+
+    before(:each) do
+      allow(WialonApi::Result).to receive(:process)
+    end
+
+    it 'calls API.call with full name, args and sid' do
+      expect(WialonApi::Api).to receive(:call).with(full_name, args, sid)
+      method.call(args)
+    end
+
+    it 'sends the response to Result.process' do
+      response = double('WialonApi response')
+      allow(WialonApi::Api).to receive(:call).and_return(response)
+
+      expect(WialonApi::Result).to receive(:process).with(response, nil)
+      method.call(args)
+    end
+  end
+
+  describe '#full_name' do
+    let(:method) do
+      resolver = Hashie::Mash.new(name: 'name_space')
+      WialonApi::Method.new('name', resolver: resolver)
+    end
+
+    it 'sends each part to #camelize' do
+      expect(method.send(:full_name)).to eq('name_space/name')
+    end
+  end
+end

data/spec/wialon_api/namespace_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe WialonApi::Namespace do
+  describe '.names' do
+    before(:each) do
+      WialonApi::Namespace.instance_variable_set(:@names, nil)
+    end
+
+    context 'on first call' do
+      it 'loads namespaces from a file' do
+        filename = double('Filename')
+        expect(File).to receive(:expand_path).and_return(filename)
+        namespaces = double('Namespaces list')
+        expect(YAML).to receive(:load_file).with(filename).and_return(namespaces)
+
+        WialonApi::Namespace.names
+      end
+    end
+
+    context 'on subsequent calls' do
+      before(:each) do
+        WialonApi::Namespace.names
+      end
+
+      it 'returns the cached list' do
+        expect(YAML).not_to receive(:load_file)
+        WialonApi::Namespace.names
+      end
+    end
+  end
+
+  describe '.exists?' do
+    context 'with an existing namespace' do
+      it 'returns true' do
+        expect(WialonApi::Namespace).to exist('core')
+      end
+    end
+
+    context 'with a non-existent namespace' do
+      it 'returns false' do
+        expect(WialonApi::Namespace).not_to exist('wrong')
+      end
+    end
+
+    context 'with an existing symbol namespace' do
+      it 'returns true' do
+        expect(WialonApi::Namespace).to exist(:user)
+      end
+    end
+  end
+end

data/spec/wialon_api/resolvable_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe WialonApi::Resolvable do
+  before(:each) do
+    @class = Class.new do
+      include WialonApi::Resolvable
+    end
+  end
+
+  describe '#initialize' do
+    it 'saves the name and the resolver' do
+      resolver   = Hashie::Mash.new(sid: 'sid')
+      resolvable = @class.new(:name, resolver: resolver)
+
+      expect(resolvable.name).to eq('name')
+      expect(resolvable.sid).to eq('sid')
+    end
+  end
+end

data/spec/wialon_api/resolver_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe WialonApi::Resolver do
+  before(:each) do
+    @class = Class.new do
+      include WialonApi::Resolver
+
+      attr_accessor :sid
+
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+
+  describe '#send' do
+    before(:each) do
+      @resolver = @class.new('trololo')
+      @sid = double('sid')
+      allow(@resolver).to receive(:sid).and_return(@sid)
+    end
+
+    it 'gets into #method_missing' do
+      expect(@resolver).to receive(:method_missing).with(:send, message: 'hello')
+      @resolver.send(message: 'hello')
+    end
+  end
+
+  describe '#resolver' do
+    before(:each) do
+      @name     = double('Name')
+      @resolver = @class.new(@name)
+      @sid    = double('sid')
+      allow(@resolver).to receive(:sid).and_return(@sid)
+    end
+
+    let(:resolver) { @resolver.resolver }
+
+    it 'returns a Hashie::Mash with a name and a sid' do
+      expect(resolver.name).to eq(@name)
+      expect(resolver.sid).to eq(@sid)
+    end
+
+    it 'caches the result' do
+      @mash = double('Mash', name: @name, sid: @sid)
+      expect(Hashie::Mash).to receive(:new).once.and_return(@mash)
+      5.times { @resolver.resolver }
+    end
+  end
+end

data/spec/wialon_api/result_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe WialonApi::Result do
+  describe '.process' do
+    let(:response) { double('Response') }
+    let(:result) { double('Result') }
+
+    before(:each) do
+      allow(WialonApi::Result).to receive(:extract_result).and_return(result)
+    end
+
+    it 'calls .extract_result passing it the response' do
+      expect(WialonApi::Result).to receive(:extract_result).with(response)
+      WialonApi::Result.process(response, nil)
+    end
+
+    context 'with a non-enumerable result' do
+      let(:type) { double('Type') }
+      let(:value) { double('value') }
+
+      context 'when block_given?' do
+        it 'yields the #typecast-ed value and returns the result of the block' do
+          block_result = double('Block result')
+          expect(result).to receive(:result_method).and_return(block_result)
+          block = proc(&:result_method)
+
+          expect(WialonApi::Result.process(response, block)).to eq(block_result)
+        end
+      end
+    end
+
+    context 'with an enumerable result' do
+      let(:element1) { double('First element') }
+      let(:element2) { double('Second element') }
+      let(:enumerable_result) { [element1, element2] }
+
+      before(:each) do
+        allow(WialonApi::Result).to receive(:extract_result).and_return(enumerable_result)
+      end
+
+      it 'returns the untouched value' do
+        expect(WialonApi::Result.process(enumerable_result, nil)).to eq(enumerable_result)
+      end
+
+      context 'when block_given?' do
+        it 'yields each element untouched to the block' do
+          result1 = double('First element after result_method')
+          result2 = double('Second element after result_method')
+          expect(element1).to receive(:result_method).and_return(result1)
+          expect(element2).to receive(:result_method).and_return(result2)
+          block = proc(&:result_method)
+
+          expect(WialonApi::Result.process(enumerable_result, block)).to eq([result1, result2])
+        end
+      end
+    end
+  end
+
+  describe '.extract_result' do
+    let(:result_response) do
+      { 'key' => 'value' }
+    end
+
+    let(:result_error) do
+      {
+        'request_params' => [
+          {
+            'key'   => 'error',
+            'value' => 'description'
+          }
+        ]
+      }
+    end
+
+    context 'with a success response' do
+      let(:result) { Hashie::Mash.new(result_response) }
+      it 'returns plain result' do
+        expect(WialonApi::Result.send(:extract_result, result)).to eq(result)
+      end
+    end
+
+    context 'with an error response' do
+      let(:result) { Hashie::Mash.new(error: result_error) }
+
+      it 'raises a WialonApi::Error' do
+        expect do
+          WialonApi::Result.send(:extract_result, result)
+        end.to raise_error(WialonApi::Error)
+      end
+    end
+  end
+end

data/spec/wialon_api_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe WialonApi do
+  it 'should return current version' do
+    expect(WialonApi::VERSION).to eq('0.0.1')
+  end
+end

data/wialon_api.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wialon_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wialon_api"
+  spec.version       = WialonApi::VERSION
+  spec.authors       = ["Arsen Shamkhalov"]
+  spec.email         = ["thornu731@gmail.com"]
+  spec.summary       = %q{Simple to use WialonPro API client. http://sdk.wialon.com/wiki/ru/pro/pro}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/thorn/wialon_api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'guard-rspec'
+
+  spec.add_development_dependency 'curb'
+  spec.add_development_dependency 'hashie'
+  spec.add_development_dependency 'faraday'
+  spec.add_development_dependency 'faraday_middleware'
+  spec.add_development_dependency 'faraday_middleware-parse_oj'
+
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'guard-yard'
+end