haveapi-client 0.26.4 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 990c16577799341bfe013e588b33b15e52c3acf973869a84ba3b051b99de57fd
-  data.tar.gz: 14d4be7d907a1ef7857f5e7fc56cf39a408958e20aa1d7f0e10f4737d9cc3309
+  metadata.gz: a6231f3629c9e015d7e916dc7cf97466b30849db2a1fe86a521f5fd1b99fbb72
+  data.tar.gz: 46cb500d05af0f1bdd25f4a2749d7d459ff8460d1477dea59b64e816162dc9e7
 SHA512:
-  metadata.gz: 28eefedb8c494cf33f0b81729b34dfcc558affdcb9d3acabf8c58f49b6a0ec9cb55a9f6e8b4c32ad72da42e4f66a78125710aa861284bcc1fbe119f230998306
-  data.tar.gz: d42f140abba3ffa5851bb68a410061e64e23fd7a7e312d20ed82f36d6a143a1016e496773beb675aaf86248bf33809de994d0a55aba4d1d48324f4f119346325
+  metadata.gz: 5afb270a053317c22c6a5748739423690743a02a1b3f8e58d1e045d33b4446bd0d96f5427ffc7c37f6cfbb3266b2cfd8801692d9f3c557843fe586e4a60a9535
+  data.tar.gz: e42801e205282f72038c3777d819799be33569e63a9864ef13786e7346785cca469dd6128f9c3241f257d098bd089c9f9b3d8d47473f778019b8c30361833207

data/Gemfile

@@ -6,3 +6,7 @@ group :development do
   gem 'bundler'
   gem 'rake'
 end
+
+group :test do
+  gem 'rspec'
+end

data/lib/haveapi/cli/action_state.rb

@@ -26,9 +26,9 @@ module HaveAPI::CLI
       id ||= @id
 
       if cancel
-        puts 'Waiting for the action to cancel (hit Ctrl+C to skip)...'
+        warn 'Waiting for the action to cancel (hit Ctrl+C to skip)...'
       else
-        puts 'Waiting for the action to complete (hit Ctrl+C to skip)...'
+        warn 'Waiting for the action to complete (hit Ctrl+C to skip)...'
       end
 
       last_status = false
@@ -47,11 +47,11 @@ module HaveAPI::CLI
         end
       rescue Interrupt
         @pb && @pb.stop
-        puts
+        warn
 
         cancel_action(timeout: timeout) if can_cancel && !cancel && last_status
 
-        puts
+        warn
         print_help(id)
         exit(false)
       end
@@ -81,7 +81,7 @@ module HaveAPI::CLI
       end
 
       if res.is_a?(HaveAPI::Client::Response) && res.ok?
-        puts 'Cancelled'
+        warn 'Cancelled'
         exit
 
       elsif res
@@ -102,11 +102,11 @@ module HaveAPI::CLI
     def print_help(id = nil)
       id ||= @id
 
-      puts 'Run'
-      puts "  #{$0} action_state show #{id}"
-      puts 'or'
-      puts "  #{$0} action_state wait #{id}"
-      puts "to check the action's progress."
+      warn 'Run'
+      warn "  #{$0} action_state show #{id}"
+      warn 'or'
+      warn "  #{$0} action_state wait #{id}"
+      warn "to check the action's progress."
     end
 
     protected
@@ -121,7 +121,8 @@ module HaveAPI::CLI
                   '%t: [%B]'
                 end,
         starting_at: state.progress.current,
-        autofinish: false
+        autofinish: false,
+        output: $stderr
       )
 
       @pb.title = if state.status

data/lib/haveapi/cli/cli.rb

@@ -112,7 +112,7 @@ module HaveAPI::CLI
       @input_params[:meta] = { includes: includes } if includes
 
       begin
-        ret = action.execute(@input_params, raw: @opts[:raw])
+        ret = action.execute(@input_params)
       rescue HaveAPI::Client::ValidationError => e
         format_errors(action, 'input parameters not valid', e.errors)
         exit(false)
@@ -508,7 +508,7 @@ module HaveAPI::CLI
 
     def format_output(action, response, out = $>)
       if @opts[:raw]
-        puts JSON.generate(response)
+        puts JSON.pretty_generate(response)
         return
       end
 

data/lib/haveapi/client/action.rb

@@ -16,7 +16,7 @@ module HaveAPI::Client
       "#<#{self.class.name} @name=#{@name}>"
     end
 
-    def execute(data, raw: false)
+    def execute(data)
       params_arg = {}
 
       if input
@@ -29,7 +29,7 @@ module HaveAPI::Client
         params_arg = params.to_api
       end
 
-      ret = @api.call(self, params_arg, raw: raw)
+      ret = @api.call(self, params_arg)
       reset
       ret
     end

data/lib/haveapi/client/communicator.rb

@@ -117,7 +117,7 @@ module HaveAPI::Client
       end
     end
 
-    def call(action, params = {}, raw: false)
+    def call(action, params = {})
       args = []
       input_namespace = action.input && action.namespace(:input)
       meta = nil
@@ -164,11 +164,7 @@ module HaveAPI::Client
       end
 
       if response[:status]
-        if raw
-          ok(JSON.pretty_generate(response[:response]))
-        else
-          ok(response[:response])
-        end
+        ok(response[:response])
 
       else
         error(response[:message], response[:errors])

data/lib/haveapi/client/exceptions.rb

@@ -5,7 +5,11 @@ module HaveAPI::Client
     attr_reader :response
 
     def initialize(response)
-      super("#{response.action.name} failed: #{response.message}")
+      if response.respond_to?(:action)
+        super("#{response.action.name} failed: #{response.message}")
+      else
+        super(response.to_s)
+      end
 
       @response = response
     end

data/lib/haveapi/client/parameters/resource.rb

@@ -18,6 +18,8 @@ module HaveAPI::Client
     protected
 
     def coerce(v)
+      return nil if v.nil?
+
       if !v.is_a?(::Integer) && /\A\d+\z/ !~ v
         @errors << 'not a valid resource id'
         nil

data/lib/haveapi/client/parameters/typed.rb

@@ -2,20 +2,6 @@ require 'date'
 
 module HaveAPI::Client
   class Parameters::Typed
-    module Boolean
-      def self.to_b(str)
-        return true if str === true
-        return false if str === false
-
-        if str.respond_to?(:=~)
-          return true if str =~ /^(true|t|yes|y|1)$/i
-          return false if str =~ /^(false|f|no|n|0)$/i
-        end
-
-        false
-      end
-    end
-
     attr_reader :errors, :value
 
     def initialize(params, desc, value)
@@ -26,6 +12,8 @@ module HaveAPI::Client
     end
 
     def valid?
+      return false unless @errors.empty?
+
       ret = Validator.validate(@desc[:validators], @value, @params)
 
       @errors.concat(ret) unless ret === true
@@ -44,39 +32,146 @@ module HaveAPI::Client
     protected
 
     def coerce(raw)
+      return nil if raw.nil?
+
       type = @desc[:type]
 
-      if type == 'Integer'
-        raw.to_i
+      case type
+      when 'Integer'
+        coerce_integer(raw)
+      when 'Float'
+        coerce_float(raw)
+      when 'Boolean'
+        coerce_boolean(raw)
+      when 'Datetime'
+        coerce_datetime(raw)
+      when 'String', 'Text'
+        coerce_string(raw)
+      else
+        raw
+      end
+    end
+
+    private
+
+    def coerce_integer(raw)
+      case raw
+      when ::Integer
+        raw
+
+      when ::Float
+        return raw.to_i if raw.finite? && raw == raw.to_i
+
+        invalid_integer
+
+      when ::String
+        s = raw.strip
+        return invalid_integer if s.empty?
+        return invalid_integer unless s.match?(/\A[+-]?\d+\z/)
 
-      elsif type == 'Float'
-        raw.to_f
+        Integer(s, 10)
 
-      elsif type == 'Boolean'
-        Boolean.to_b(raw)
+      else
+        invalid_integer
+      end
+    rescue ArgumentError
+      invalid_integer
+    end
 
-      elsif type == 'Datetime'
-        if raw.is_a?(::Time)
-          raw
+    def coerce_float(raw)
+      if raw.is_a?(::Numeric)
+        value = raw.to_f
+        return value if value.finite?
 
-        elsif raw.is_a?(::Date) || raw.is_a?(::DateTime)
-          raw.to_time
+        @errors << 'not a valid float'
+        nil
 
-        else
-          begin
-            DateTime.iso8601(raw).to_time
-          rescue ArgumentError
-            @errors << 'not in ISO 8601 format'
-            nil
-          end
-        end
+      elsif raw.is_a?(::String)
+        s = raw.strip
+        return invalid_float if s.empty?
 
-      elsif %w[String Text].include?(type)
-        raw.to_s
+        value = Float(s)
+        return value if value.finite?
+
+        invalid_float
 
       else
+        invalid_float
+      end
+    rescue ArgumentError
+      invalid_float
+    end
+
+    def coerce_boolean(raw)
+      return raw if [true, false].include?(raw)
+
+      if raw.is_a?(::Integer)
+        return true if raw == 1
+        return false if raw == 0
+
+        return invalid_boolean
+      end
+
+      if raw.is_a?(::String)
+        s = raw.strip.downcase
+        return invalid_boolean if s.empty?
+
+        return true if %w[true t yes y 1].include?(s)
+        return false if %w[false f no n 0].include?(s)
+      end
+
+      invalid_boolean
+    end
+
+    def coerce_datetime(raw)
+      case raw
+      when ::Time
         raw
+
+      when ::Date, ::DateTime
+        raw.to_time
+
+      when ::String
+        return invalid_datetime if raw.strip.empty?
+
+        DateTime.iso8601(raw).to_time
+
+      else
+        invalid_datetime
       end
+    rescue ArgumentError
+      invalid_datetime
+    end
+
+    def coerce_string(raw)
+      return invalid_string if raw.is_a?(::Array) || raw.is_a?(::Hash)
+
+      raw.to_s
+    end
+
+    def invalid_integer
+      @errors << 'not a valid integer'
+      nil
+    end
+
+    def invalid_float
+      @errors << 'not a valid float'
+      nil
+    end
+
+    def invalid_boolean
+      @errors << 'not a valid boolean'
+      nil
+    end
+
+    def invalid_datetime
+      @errors << 'not in ISO 8601 format'
+      nil
+    end
+
+    def invalid_string
+      @errors << 'not a valid string'
+      nil
     end
   end
 end

data/lib/haveapi/client/params.rb

@@ -29,9 +29,12 @@ module HaveAPI::Client
       @action.input_params.each do |name, p|
         next if p[:validators].nil?
 
-        if p[:validators][:presence] && @params[name].nil?
-          error(name, 'required parameter missing')
+        presence_validator =
+          p[:validators][:presence] || p[:validators][:present] || p[:validators][:required]
 
+        if presence_validator && @params[name].nil?
+          error(name, 'required parameter missing')
+          next
         elsif @params[name].nil?
           next
         end

data/lib/haveapi/client/version.rb

@@ -1,6 +1,6 @@
 module HaveAPI
   module Client
     PROTOCOL_VERSION = '2.0'.freeze
-    VERSION = '0.26.4'.freeze
+    VERSION = '0.27.0'.freeze
   end
 end

data/spec/integration/client_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe HaveAPI::Client::Client do
+  let(:base_url) { TEST_SERVER.base_url }
+
+  it 'exposes versions and compatibility' do
+    client = described_class.new(base_url)
+
+    versions = client.versions
+    expect(versions[:default]).to eq('1.0')
+    expect(versions[:versions]).to include('1.0')
+    expect(client.compatible?).to(
+      satisfy { |value| [:compatible, :imperfect, false].include?(value) }
+    )
+  end
+
+  it 'filters docs until authenticated' do
+    unauthenticated = described_class.new(base_url)
+    unauthenticated.setup
+
+    expect { unauthenticated.project }.to raise_error(NoMethodError)
+
+    authenticated = described_class.new(base_url)
+    authenticated.authenticate(:basic, user: 'user', password: 'pass')
+
+    expect { authenticated.project }.not_to raise_error
+    expect(authenticated.project).to be_a(HaveAPI::Client::Resource)
+  end
+
+  it 'supports CRUD flow for projects' do
+    client = described_class.new(base_url)
+    client.authenticate(:basic, user: 'user', password: 'pass')
+
+    projects = client.project.list
+    expect(projects).to be_a(Array)
+    expect(projects.size).to be >= 2
+
+    project = client.project.find(projects.first.id)
+    expect(project.id).to eq(projects.first.id)
+
+    created = client.project.create(name: 'Gamma')
+    expect(created.id).to be_a(Integer)
+    expect(created.name).to eq('Gamma')
+  end
+
+  it 'handles nested task resources' do
+    client = described_class.new(base_url)
+    client.authenticate(:basic, user: 'user', password: 'pass')
+
+    project = client.project.list.first
+    tasks = client.project.task.list(project.id)
+    expect(tasks).to be_a(Array)
+
+    task = client.project(project.id).task.create(label: 'Do it')
+    expect(task.id).to be_a(Integer)
+    expect(task.label).to eq('Do it')
+  end
+
+  it 'raises validation error on missing required params' do
+    client = described_class.new(base_url)
+    client.authenticate(:basic, user: 'user', password: 'pass')
+
+    expect { client.project.create({}) }
+      .to raise_error(HaveAPI::Client::ValidationError)
+  end
+
+  it 'supports blocking actions and action state polling' do
+    client = described_class.new(base_url)
+    client.authenticate(:basic, user: 'user', password: 'pass')
+
+    project = client.project.create(name: 'Blocky')
+    task = client.project(project.id).task.create(label: 'Run me')
+
+    response = client.project.task.run(project.id, task.id, meta: { block: false })
+    expect(response.meta[:action_state_id]).to be_a(Integer)
+
+    result = response.wait_for_completion(interval: 0.05, update_in: 0.05, timeout: 2)
+    expect(result).to be(true)
+  end
+
+  it 'surfaces HaveAPI errors as ActionFailed' do
+    client = described_class.new(base_url)
+
+    expect { client.test.fail }
+      .to raise_error(HaveAPI::Client::ActionFailed) do |err|
+        expect(err.response.message).to eq('forced failure')
+        expect(err.response.errors).to include(:base)
+      end
+  end
+end

data/spec/integration/typed_input_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe HaveAPI::Client::Client do
+  let(:client) { described_class.new(TEST_SERVER.base_url) }
+  let(:valid_params) do
+    {
+      i: 1,
+      f: 1.0,
+      b: true,
+      dt: '2020-01-01T00:00:00Z',
+      s: 'x',
+      t: 'y'
+    }
+  end
+
+  it 'coerces valid typed inputs' do
+    res = client.test.echo(
+      i: ' 42 ',
+      f: 5,
+      b: 'yes',
+      dt: '2020-01-01T00:00:00Z',
+      s: 123,
+      t: false
+    )
+
+    expect(res).to be_a(HaveAPI::Client::Response)
+    expect(res[:i]).to eq(42)
+    expect(res[:f]).to eq(5.0)
+    expect(res[:b]).to be(true)
+    expect(res[:dt]).to match(/\A2020-01-01T00:00:00(?:Z|\+00:00)\z/)
+    expect(res[:s]).to eq('123')
+    expect(res[:t]).to eq('false')
+  end
+
+  it 'accepts exponent float strings' do
+    res = client.test.echo(
+      i: 1,
+      f: '1e3',
+      b: true,
+      dt: '2020-01-01',
+      s: 'ok',
+      t: 'ok'
+    )
+
+    expect(res[:f]).to eq(1000.0)
+  end
+
+  it 'rejects invalid integer strings' do
+    expect { client.test.echo(valid_params.merge(i: 'abc')) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:i)
+        expect(err.errors[:i]).to include(a_string_matching(/not a valid integer/))
+      end
+  end
+
+  it 'rejects non-integral floats for integers' do
+    expect { client.test.echo(valid_params.merge(i: 12.3)) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:i)
+        expect(err.errors[:i]).to include(a_string_matching(/not a valid integer/))
+      end
+  end
+
+  it 'rejects invalid floats' do
+    expect { client.test.echo(valid_params.merge(f: 'abc')) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:f)
+        expect(err.errors[:f]).to include(a_string_matching(/not a valid float/))
+      end
+  end
+
+  it 'rejects invalid boolean strings' do
+    expect { client.test.echo(valid_params.merge(b: 'maybe')) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:b)
+        expect(err.errors[:b]).to include(a_string_matching(/not a valid boolean/))
+      end
+  end
+
+  it 'rejects invalid boolean integers' do
+    expect { client.test.echo(valid_params.merge(b: 2)) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:b)
+        expect(err.errors[:b]).to include(a_string_matching(/not a valid boolean/))
+      end
+  end
+
+  it 'rejects invalid datetimes' do
+    expect { client.test.echo(valid_params.merge(dt: 'yesterday')) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:dt)
+        expect(err.errors[:dt]).to include(a_string_matching(/ISO 8601/))
+      end
+  end
+
+  it 'rejects arrays for string params' do
+    expect { client.test.echo(valid_params.merge(s: [1, 2])) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:s)
+        expect(err.errors[:s]).to include(a_string_matching(/not a valid string/))
+      end
+  end
+
+  it 'rejects hashes for text params' do
+    expect { client.test.echo(valid_params.merge(t: { a: 1 })) }
+      .to raise_error(HaveAPI::Client::ValidationError) do |err|
+        expect(err.errors).to include(:t)
+        expect(err.errors[:t]).to include(a_string_matching(/not a valid string/))
+      end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'haveapi/client'
+
+require_relative 'support/test_server'
+
+TEST_SERVER = ClientTestServer.new
+
+RSpec.configure do |config|
+  config.order = :random
+
+  config.before(:suite) do
+    TEST_SERVER.start
+  end
+
+  config.after(:suite) do
+    TEST_SERVER.stop!
+  end
+
+  config.before do
+    TEST_SERVER.reset!
+  end
+end

data/spec/support/test_server.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+class ClientTestServer
+  READY_PREFIX = 'HAVEAPI_TEST_SERVER_READY'
+
+  attr_reader :base_url
+
+  def initialize
+    @root = File.expand_path('../../../..', __dir__)
+    @server_script = File.join(@root, 'servers', 'ruby', 'test_support', 'client_test_server.rb')
+    @gemfile = File.join(@root, 'servers', 'ruby', 'Gemfile')
+    @cwd = File.join(@root, 'clients', 'ruby')
+  end
+
+  def start
+    return if @wait_thr
+
+    env = { 'BUNDLE_GEMFILE' => @gemfile }
+    cmd = ['bundle', 'exec', 'ruby', @server_script, '--port', '0']
+    @stdin, @stdout, @wait_thr = Open3.popen2e(env, *cmd, chdir: @cwd)
+
+    read_ready!
+    wait_for_health!
+  end
+
+  def reset!
+    ensure_started!
+
+    uri = URI.join(@base_url, '/__reset')
+    req = Net::HTTP::Post.new(uri)
+    req['Content-Type'] = 'application/json'
+    res = Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
+
+    return if res.is_a?(Net::HTTPSuccess)
+
+    raise "reset failed: #{res.code} #{res.body}"
+  end
+
+  def stop!
+    return unless @wait_thr
+
+    Process.kill('TERM', @wait_thr.pid)
+    @wait_thr.value
+  rescue Errno::ESRCH
+    nil
+  ensure
+    @stdin&.close
+    @stdout&.close
+    @wait_thr = nil
+  end
+
+  private
+
+  def ensure_started!
+    start unless @wait_thr
+  end
+
+  def read_ready!
+    Timeout.timeout(10) do
+      while (line = @stdout.gets)
+        next unless line.include?(READY_PREFIX)
+
+        @base_url = line.split.last&.strip
+        break
+      end
+    end
+
+    raise 'server did not start' unless @base_url
+  rescue Timeout::Error
+    raise 'server did not start in time'
+  end
+
+  def wait_for_health!
+    Timeout.timeout(5) do
+      loop do
+        begin
+          uri = URI.join(@base_url, '/__health')
+          res = Net::HTTP.get_response(uri)
+          return if res.is_a?(Net::HTTPSuccess)
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, IOError
+          # retry
+        end
+
+        sleep 0.05
+      end
+    end
+  rescue Timeout::Error
+    raise 'server did not become healthy in time'
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haveapi-client
 version: !ruby/object:Gem::Version
-  version: 0.26.4
+  version: 0.27.0
 platform: ruby
 authors:
 - Jakub Skokan
@@ -151,6 +151,10 @@ files:
 - lib/haveapi/client/version.rb
 - lib/restclient_ext/resource.rb
 - shell.nix
+- spec/integration/client_spec.rb
+- spec/integration/typed_input_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_server.rb
 homepage: ''
 licenses:
 - MIT