triglav-client 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 62815a4e1f4c19e2f9ae358eb292871715a03347
+  data.tar.gz: 1b03f93401193af97d27d35307d89948b4d9a5a7
+SHA512:
+  metadata.gz: 83a12fe20133acfe8be4d0a974dd0e1c60a92fb32fee14ad63d4f9f2e2a7113194d0700c09c41246fe462e72e4521d97df47c0c74c35b6f3e99eeddace6d0a0f
+  data.tar.gz: 980cedd1d2c412898564ea130a160a89ada98e37c51812b896c21675e274639e1e86a090f08c0ba62d1314bacccc36a87073543f4ab80a0a888d211f0b148342

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGES.md

@@ -0,0 +1,9 @@
+# Changes for triglav-client-ruby
+
+## 0.0.2
+
+  * Supported CRUD APIs.
+
+## 0.0.1
+
+  * Initial release.

data/README.md

@@ -1,4 +1,4 @@
-# Triglav::Client
+# Triglav::Client [![BuildStatus](https://secure.travis-ci.org/kentaro/triglav-client-ruby.png)](http://travis-ci.org/kentaro/triglav-client-ruby)
 
 Triglav::Client is a Ruby interface to [Triglav](http://github.com/kentaro/triglav) API.
 
@@ -9,25 +9,25 @@ require 'triglav/client'
 
 client = Triglav::Client.new(
   base_url:  'http://example.com/',  # Base URL which your Triglav is located at
-  api_token: 'xxxxxxxxxx'            # You can get it from your page on Triglav
+  api_token: 'xxxxxxxxxxxxxxxxxxx'   # You can get it from your page on Triglav
 )
 
 # Services
-client.services #=> Returns all the services registered on Triglav
+client.services                      #=> Returns all the services registered on Triglav
 
 # Roles
-client.roles    #=> Returns all the roles registered on Triglav
-client.roles_in('service') #=> Only roles in the service
+client.roles                         #=> Returns all the roles registered on Triglav
+client.roles_in('sqale')             #=> Only roles in the service
 
-# Active Hosts (default behaviour)
-client.hosts    #=> Returns all the hosts registered on Triglav
-client.hosts_in('service')         #=> Only hosts in the service
-client.hosts_in('service', 'role') #=> Only hosts in the service and which have the role
+# Active hosts (default behaviour)
+client.hosts                         #=> Returns all the hosts registered on Triglav
+client.hosts_in('sqale')             #=> Only hosts in the service
+client.hosts_in('sqale', 'users')    #=> Only hosts in the service and which have the role
 
-# Inactive Hosts
+# All hosts including inactive ones
 client.hosts(with_inactive: true)
-client.hosts_in('service', nil, with_inactive: true)
-client.hosts_in('service', 'role', with_inactive: true)
+client.hosts_in('sqale',     nil, with_inactive: true)
+client.hosts_in('sqale', 'users', with_inactive: true)
 ```
 
 ## Installation

data/lib/triglav/client/version.rb

@@ -1,5 +1,5 @@
 module Triglav
   class Client
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/triglav/client.rb

@@ -18,28 +18,82 @@ module Triglav
       end
     end
 
+    API_ENDPOINT_MAP = {
+      services: { method: :get, path: '/api/services.json'            },
+      roles:    { method: :get, path: '/api/roles.json'               },
+      roles_in: { method: :get, path: ['/api/services/%s/roles.json'] },
+      hosts:    { method: :get, path: '/api/hosts.json'               },
+      hosts_in: {
+        method: :get,
+        path: [
+          '/api/services/%s/hosts.json',
+          '/api/services/%s/roles/%s/hosts.json',
+        ]
+      },
+    }
+
+    def endpoint_for (type, *args)
+      endpoint = API_ENDPOINT_MAP[type]
+
+      unless endpoint
+        raise ArgumentError.new("No endpoint found for #{type}")
+      end
+
+      if args.empty?
+        endpoint
+      else
+        path = endpoint[:path][args.size - 1]
+
+        {
+          method: endpoint[:method],
+          path:   path % args,
+        }
+      end
+    end
+
+    def create (model, params)
+      case model
+        when :service; Model::Service.create(self, params)
+        when :role;    Model::Role.create(self, params)
+        when :host;    Model::Host.create(self, params)
+        else raise ArgumentError.new("No such model for #{model}")
+      end
+    end
+
     def services
-      response = dispatch_request('get', '/api/services.json')
-      response.map { |e| e['service'] }
+      endpoint = endpoint_for(:services)
+      response = dispatch_request(endpoint[:method], endpoint[:path])
+      response.map do |e|
+        Model::Service.new(client: self, info: e['service'])
+      end
     end
 
     def roles
-      response = dispatch_request('get', '/api/roles.json')
-      response.map { |e| e['role'] }
+      endpoint = endpoint_for(:roles)
+      response = dispatch_request(endpoint[:method], endpoint[:path])
+      response.map do |e|
+        Model::Role.new(client: self, info: e['role'])
+      end
     end
 
     def roles_in (service)
-      response = dispatch_request('get', "/api/services/#{service}/roles.json")
-      response.map { |e| e['role'] }
+      endpoint = endpoint_for(:roles_in, service)
+      response = dispatch_request(endpoint[:method], endpoint[:path])
+      response.map do |e|
+        Model::Role.new(client: self, info: e['role'])
+      end
     end
 
     def hosts (options = {})
-      response = dispatch_request('get', '/api/hosts.json')
-      response.map { |e| e['host'] }.select do |h|
+      endpoint = endpoint_for(:hosts)
+      response = dispatch_request(endpoint[:method], endpoint[:path])
+      response.map do |e|
+        Model::Host.new(client: self, info: e['host'])
+      end.select do |h|
         if options[:with_inactive]
           true
         else
-          h['active']
+          h.info.active
         end
       end
     end
@@ -52,16 +106,20 @@ module Triglav
       end
 
       if (role)
-        response = dispatch_request('get', "/api/services/#{service}/roles/#{role}/hosts.json")
+        endpoint = endpoint_for(:hosts_in, service, role)
+        response = dispatch_request(endpoint[:method], endpoint[:path])
       else
-        response = dispatch_request('get', "/api/services/#{service}/hosts.json")
+        endpoint = endpoint_for(:hosts_in, service)
+        response = dispatch_request(endpoint[:method], endpoint[:path])
       end
 
-      response.map { |e| e['host'] }.select do |h|
+      response.map do |e|
+        Model::Host.new(client: self, info: e['host'])
+      end.select do |h|
         if options[:with_inactive]
           true
         else
-          h['active']
+          h.info.active
         end
       end
     end
@@ -80,9 +138,16 @@ module Triglav
     def do_request(method, path, params = {})
       uri = URI.parse(base_url)
       uri.path  = path
+      path = "#{uri.path}?api_token=#{api_token}"
+
+      req = case method
+            when :get;    Net::HTTP::Get.new(path)
+            when :post;   req = Net::HTTP::Post.new(path); req.set_form_data(params); req
+            when :delete; Net::HTTP::Delete.new(path)
+            end
 
       response = Net::HTTP.start(uri.host, uri.port) do |http|
-        http.__send__(method, "#{uri.path}?api_token=#{api_token}")
+        http.request(req)
       end
 
       if response.code.to_i >= 300

data/lib/triglav/model.rb

@@ -0,0 +1,109 @@
+require 'uri'
+require 'ostruct'
+
+module Triglav
+  module Model
+    class Base
+      attr_reader :client, :info
+
+      def initialize(args)
+        @client = args[:client]
+        @info   = OpenStruct.new(args[:info])
+      end
+
+      API_ENDPOINT_MAP = {
+        create:  { method: :post,   path: '/api/%s.json'           },
+        show:    { method: :get,    path: '/api/%s/%s.json'        },
+        update:  { method: :post,   path: '/api/%s/%s.json'        },
+        destroy: { method: :delete, path: '/api/%s/%s.json'        },
+        revert:  { method: :get,    path: '/api/%s/%s/revert.json' },
+      }
+
+      def self.endpoint_for (type, *args)
+        endpoint = API_ENDPOINT_MAP[type]
+        endpoint_path = endpoint[:path] % [self.path, *args.map { |e| URI.encode(e) }]
+
+        { method: endpoint[:method], path: endpoint_path }
+      end
+
+      def self.param
+        self.to_s.split('::').last.downcase
+      end
+
+      def self.build_params(params)
+        build_params = {}
+        params.each do |key, value|
+          build_params["#{self.param}[#{key}]"] = value
+        end
+        build_params
+      end
+
+      def self.create(client, params = {})
+        endpoint = endpoint_for(:create)
+        result   = client.dispatch_request(
+          endpoint[:method],
+          endpoint[:path],
+          build_params(params),
+        )
+        new(client: client, info: result[param])
+      end
+
+      def show
+        endpoint = self.class.endpoint_for(:show, info.name)
+        result   = client.dispatch_request(endpoint[:method], endpoint[:path])
+        self.class.new(client: client, info: result[self.class.param])
+      end
+
+      def update(params = {})
+        endpoint = self.class.endpoint_for(:update, info.name)
+        result   = client.dispatch_request(
+          endpoint[:method],
+          endpoint[:path],
+          self.class.build_params(params),
+        )
+        self.class.new(client: client, info: result[self.class.param])
+      end
+
+      def destroy
+        endpoint = self.class.endpoint_for(:destroy, info.name)
+        result   = client.dispatch_request(endpoint[:method], endpoint[:path])
+        self.class.new(client: client, info: result[self.class.param])
+      end
+
+      def revert
+        endpoint = self.class.endpoint_for(:revert, info.name)
+        result   = client.dispatch_request(endpoint[:method], endpoint[:path])
+        self.class.new(client: client, info: result[self.class.param])
+      end
+    end
+
+    class Service < Base
+      def self.path
+        'services'
+      end
+    end
+
+    class Role < Base
+      def self.path
+        'roles'
+      end
+    end
+
+    class Host < Base
+      def self.path
+        'hosts'
+      end
+
+      def add_relation(service, role)
+        endpoint = self.class.endpoint_for(:update, info.name)
+        result   = client.dispatch_request(
+          endpoint[:method],
+          endpoint[:path],
+          'host[host_relations_attributes][0][service_id]' => service.info.id,
+          'host[host_relations_attributes][0][role_id]'    => role.info.id,
+        )
+        self.class.new(client: client, info: result[self.class.param])
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -18,13 +18,82 @@ describe Triglav::Client do
 
     context 'when only `base_url` is passed' do
       it {
-        expect { Triglav::Client.new }.to raise_error(ArgumentError)
+        expect { Triglav::Client.new(base_url: 'http://example.com/') }.to raise_error(ArgumentError)
       }
     end
 
     context 'when `api_token` is passed' do
       it {
-        expect { Triglav::Client.new }.to raise_error(ArgumentError)
+        expect { Triglav::Client.new(api_token: 'xxxxxxxxxxxxxxxxxxx') }.to raise_error(ArgumentError)
+      }
+    end
+  end
+
+  describe 'endpoint_for' do
+    context 'when no arguments except `:type` are passed' do
+      include_context 'initialize client'
+
+      it {
+        expect(subject.endpoint_for(:services)).to be == {
+          method: :get,
+          path:   '/api/services.json',
+        }
+      }
+    end
+
+    context 'when an arguments except `:type` are passed' do
+      include_context 'initialize client'
+
+      it {
+        expect(subject.endpoint_for(:roles_in, 'triglav')).to be == {
+          method: :get,
+          path:   '/api/services/triglav/roles.json',
+        }
+      }
+    end
+
+    context 'when two arguments except `:type` are passed' do
+      include_context 'initialize client'
+
+      it {
+        expect(subject.endpoint_for(:hosts_in, 'triglav', 'app')).to be == {
+          method: :get,
+          path:   '/api/services/triglav/roles/app/hosts.json',
+        }
+      }
+    end
+
+    context 'when no endpoint is found' do
+      include_context 'initialize client'
+
+      it {
+        expect {
+          subject.endpoint_for(:no_such_type).to raise_error(ArgumentError)
+        }
+      }
+    end
+  end
+
+  describe '#create' do
+    include_context 'initialize client with model fixtures'
+
+    let(:fixture)  { fixture_for('service') }
+    let(:endpoint) { Triglav::Model::Service.endpoint_for(:create) }
+    let(:res_code) { 204 }
+    let(:res_body) { fixture.to_json }
+
+    context 'when model is successfully created' do
+      it {
+        result = client.create(:service, name: fixture['service']['name'])
+        expect(result).to be_an_instance_of(Triglav::Model::Service)
+      }
+    end
+
+    context 'when an invalid model name is passed' do
+      it {
+        expect {
+          client.create(:no_such_model)
+        }.to raise_error(ArgumentError)
       }
     end
   end
@@ -32,9 +101,9 @@ describe Triglav::Client do
   describe '#services' do
     include_context 'initialize client with fixtures'
 
-    before {
-      subject.stub(:dispatch_request).and_return(services)
-    }
+    let(:endpoint) { subject.endpoint_for(:services) }
+    let(:res_code) { 204 }
+    let(:res_body) { services.to_json }
 
     it {
       response = subject.services
@@ -47,9 +116,9 @@ describe Triglav::Client do
   describe '#roles' do
     include_context 'initialize client with fixtures'
 
-    before {
-      subject.stub(:dispatch_request).and_return(roles)
-    }
+    let(:endpoint) { subject.endpoint_for(:roles) }
+    let(:res_code) { 204 }
+    let(:res_body) { roles.to_json }
 
     it {
       response = subject.roles
@@ -62,9 +131,9 @@ describe Triglav::Client do
   describe '#roles_in' do
     include_context 'initialize client with fixtures'
 
-    before {
-      subject.stub(:dispatch_request).and_return(roles)
-    }
+    let(:endpoint) { subject.endpoint_for(:roles_in, 'triglav') }
+    let(:res_code) { 204 }
+    let(:res_body) { roles.to_json }
 
     it {
       response = subject.roles_in('triglav')
@@ -72,22 +141,14 @@ describe Triglav::Client do
       expect(response).to be_an_instance_of Array
       expect(response.size).to be == roles.size
     }
-
-    context 'when `service` is not passed' do
-      include_context 'initialize client with fixtures'
-
-      it {
-        expect { subject.roles_in }.to raise_error(ArgumentError)
-      }
-    end
   end
 
   describe '#hosts' do
     include_context 'initialize client with fixtures'
 
-    before {
-      subject.stub(:dispatch_request).and_return(hosts)
-    }
+    let(:endpoint) { subject.endpoint_for(:hosts) }
+    let(:res_code) { 204 }
+    let(:res_body) { hosts.to_json }
 
     context 'and `with_inactive` option is not passed' do
       it {
@@ -111,11 +172,11 @@ describe Triglav::Client do
   describe '#hosts_in' do
     include_context 'initialize client with fixtures'
 
-    before {
-      subject.stub(:dispatch_request).and_return(hosts)
-    }
-
     context 'when `role` is passed' do
+      let(:endpoint) { subject.endpoint_for(:hosts_in, 'triglav', 'app') }
+      let(:res_code) { 204 }
+      let(:res_body) { hosts.to_json }
+
       context 'and `with_inactive` option is not passed' do
         it {
           response = subject.hosts_in('triglav', 'app')
@@ -136,6 +197,10 @@ describe Triglav::Client do
     end
 
     context 'when `role` is not passed' do
+      let(:endpoint) { subject.endpoint_for(:hosts_in, 'triglav') }
+      let(:res_code) { 204 }
+      let(:res_body) { hosts.to_json }
+
       context 'and `with_inactive` option is not passed' do
         it {
           response = subject.hosts_in('triglav')

data/spec/model_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+[
+  Triglav::Model::Service,
+  Triglav::Model::Role,
+  Triglav::Model::Host,
+].each do |klass|
+  describe klass do
+    let!(:klass_name) { klass }
+    let!(:model_name) { klass.to_s.split('::').last.downcase }
+
+    include_context 'initialize client with model fixtures'
+
+    describe '.create' do
+      context 'when a model is successfully created' do
+        let(:fixture)  { fixture_for(model_name) }
+        let(:endpoint) { klass.endpoint_for(:create) }
+        let(:res_code) { 204 }
+        let(:res_body) { fixture.to_json }
+
+        it {
+          result = klass_name.create(client, name: fixture[model_name]['name'])
+          expect(result).to be_an_instance_of(klass)
+        }
+      end
+    end
+
+    describe '#show' do
+      context 'when a model is successfully shown' do
+        let(:fixture)  { fixture_for(model_name) }
+        let(:endpoint) { model.class.endpoint_for(:show, model.info.name) }
+        let(:res_code) { 200 }
+        let(:res_body) { fixture.to_json }
+
+        it {
+          result = model.show
+          expect(result).to be_an_instance_of(klass)
+        }
+      end
+    end
+
+    describe '#update' do
+      context 'when a model is successfully updated' do
+        let(:fixture)  { fixture_for(model_name) }
+        let(:endpoint) { model.class.endpoint_for(:update, model.info.name) }
+        let(:res_code) { 200 }
+        let(:res_body) { fixture.to_json }
+
+        it {
+          result = model.update(name: fixture[model_name]['name'])
+          expect(result).to be_an_instance_of(klass)
+        }
+      end
+    end
+
+    describe '#destroy' do
+      context 'when a model is successfully destroyed' do
+        let(:fixture)  { fixture_for(model_name) }
+        let(:endpoint) { model.class.endpoint_for(:destroy, model.info.name) }
+        let(:res_code) { 200 }
+        let(:res_body) { fixture.to_json }
+
+        it {
+          result = model.destroy
+          expect(result).to be_an_instance_of(klass)
+        }
+      end
+    end
+
+    describe '#revert' do
+      context 'when a model is successfully reverted' do
+        let(:fixture)  { fixture_for(model_name) }
+        let(:endpoint) { model.class.endpoint_for(:revert, model.info.name) }
+        let(:res_code) { 200 }
+        let(:res_body) { fixture.to_json }
+
+        it {
+          result = model.revert
+          expect(result).to be_an_instance_of(klass)
+        }
+      end
+    end
+
+    if klass == Triglav::Model::Host
+      describe '#add_relation' do
+        context 'when a relation is successfully added to model' do
+          let(:fixture)  { fixture_for(model_name) }
+          let(:endpoint) { model.class.endpoint_for(:update, model.info.name) }
+          let(:res_code) { 200 }
+          let(:res_body) { fixture.to_json }
+
+          it {
+            result = model.add_relation(service_model, role_model)
+            expect(result).to be_an_instance_of(klass)
+          }
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,18 +1,41 @@
 require 'triglav/client'
+require 'triglav/model'
 
 require 'rspec'
+
+unless ENV['LIVE_TEST']
+  require 'webmock/rspec'
+end
+
 RSpec.configure do |config|
 end
 
 shared_context 'initialize client' do
   let(:client) {
-    Triglav::Client.new(base_url: 'http://example.com/', api_token: 'xxxxxxxxxx')
+    Triglav::Client.new(
+      base_url:  ENV['TRIGLAV_BASE_URL'] ||'http://127.0.0.1:3000',
+      api_token: ENV['TRIGLAV_API_KEY']  || 'xxxxxxxxxxxxxxxxxxx',
+    )
   }
   subject { client }
 end
 
+shared_context 'setup request' do
+  before {
+    if !ENV['LIVE_TEST']
+      stub_request(
+        endpoint[:method],
+        "#{client.base_url}#{endpoint[:path]}?api_token=#{client.api_token}").to_return(
+        status: res_code,
+        body:   res_body,
+      )
+    end
+  }
+end
+
 shared_context 'initialize client with fixtures' do
   include_context 'initialize client'
+  include_context 'setup request'
 
   let(:services) {
     [
@@ -36,3 +59,51 @@ shared_context 'initialize client with fixtures' do
     ]
   }
 end
+
+shared_context 'initialize client with model fixtures' do
+  include_context 'initialize client'
+  include_context 'setup request'
+
+  let(:model) {
+    info = fixture_for(model_name)[model_name]
+
+    klass_name.new(
+      client: client,
+      info:   info
+    )
+  }
+
+  let(:service_model) {
+    info = fixture_for(:service)['service']
+
+    klass_name.new(
+      client: client,
+      info:   info
+    )
+  }
+
+  let(:role_model) {
+    info = fixture_for(:role)['role']
+
+    klass_name.new(
+      client: client,
+      info:   info
+    )
+  }
+
+  def fixture_for(model_name)
+    __send__(model_name)
+  end
+
+  let(:service) {
+    { 'service' => { 'id' => 1, 'name' => 'test service' } }
+  }
+
+  let(:role) {
+    { 'role' => { 'id' => 1, 'name' => 'test role' } }
+  }
+
+  let(:host) {
+    { 'host' => { 'id' => 1, 'name' => 'test host', 'active' => true }  }
+  }
+end

data/triglav-client.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'webmock'
 end

metadata

@@ -1,46 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: triglav-client
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Kentaro Kuribayashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
 description: A Ruby interface to Triglav API.
@@ -52,45 +61,43 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/triglav/client.rb
 - lib/triglav/client/version.rb
+- lib/triglav/model.rb
 - spec/client_spec.rb
+- spec/model_spec.rb
 - spec/spec_helper.rb
 - triglav-client.gemspec
 homepage: http://github.com/kentaro/triglav-client-ruby
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1294770554663767277
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1294770554663767277
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Ruby interface to Triglav API.
 test_files:
 - spec/client_spec.rb
+- spec/model_spec.rb
 - spec/spec_helper.rb