blix-rest-cucumber 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fdb6d0885fdf71c075002990b46dd4d441993c0c1247246a3bb0cb4685dc8d5d
+  data.tar.gz: c9e5b74dec7dc77e9cf6b331d52bb2727d8aa1a1445b9caa0d3948d2aafcb041
+SHA512:
+  metadata.gz: 54935eb63992297fb9747f8fc4a4a5135fcdfa21ae4e9ef0b1d698d3c81ab307b8fa1d3b8553805722ba26261f425677b53b25a2d84e5f4794c78483e468c7b7
+  data.tar.gz: f3de2494d7f77ed6bf4ca1ca5ad9a1f02f9e65dc4a911a9501034c37f5ec88a318e6aeae2ae886d664a1812ce54a125011a360ee61c1b2959cf456f9bde7e4a3

data/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2020 Clive Andrews
+
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+## INSTALLATION
+
+    gem install blix-rest-cucumber
+
+
+
+
+## Testing a Service with cucumber
+
+
+in features/support/setup.rb
+
+   require 'blix/rest/cucumber'
+
+   and setup your database connections etc
+
+
+in features/support/hooks.rb
+
+   reset your database
+
+
+
+now you can use the following in scenarios ........
+
+        Given user guest gets "/info"
+
+        Given the following users exist:
+              | name  | level |
+              | anon  | guest |
+              | bob   | user  |
+              | mary  | provider  |
+              | paul  | user  |
+              | admin | admin |
+
+        Given user mary posts "/worlds" with {"name":"narnia"}    [..or gets/puts/deletes]
+        Then store the "id" as "world_id"
+
+        Given user bob posts "/worlds/:world_id" with  {"the_world_id"::world_id }
+
+        Then the status should be 200
+        Then the data type should be "r_type"
+        Then the data length should be 3
+        Then there should be an error
+        Then the error message should include "unique"
+        Then the data "name" should == "bob"
+        Then the data should include "name"
+
+        And explain
+
+
+NOTE : if you need to set up your database with users then you can use the following hook ..
+
+in features/support/world.rb .........
+
+
+    require 'blix/rest/cucumber'
+
+    class RestWorld
+
+      # add a hook to create the user in the  database -
+      #
+      def before_user_create(user,hash)
+        name = hash["name"]
+        u = MyUser.new
+        u.set(:user_wid, name)
+        u.set(:name,name)
+        u.set(:is_super,true) if hash["level"] == "super"
+        u.save
+        store["myuser_#{name}_id"] = u.id.to_s
+      end
+    end
+
+now you can also use eg  `@myuser_foo_id` within a request path/json.

data/lib/blix/rest/cucumber/hooks.rb

@@ -0,0 +1,5 @@
+Before do
+  #@_app = Blix::Rest::Server.new
+  #@_srv = Rack::MockRequest.new(@_app)
+  Blix::Rest::RequestMapper.set_path_root(nil)
+end

data/lib/blix/rest/cucumber/request_steps.rb

@@ -0,0 +1,229 @@
+#========== requests with tokens
+
+Given(/^(.*?) requests token for service "(.*?)"$/) do |user,service|
+  path = "/myservices/" + service + "/token"
+  send_request('POST',user,path,nil)
+  @_token = valid_response.data["token"]
+end
+
+Given(/^(.*?) validates the token for service "(.*?)"$/) do |user,service|
+  path = "/services/" + service + "/validate/" + @_token
+  send_request('GET',user,path,nil)
+end
+
+
+# Given(/^guest gets "(.*?)"( .*)?$/) do |path,condition|
+#   path = add_token_to_path(path,@_token) if condition == " with token"
+#   send_request('GET',"guest",path,nil)
+# end
+
+# general requests
+
+Given(/^(.*?) gets ["'](.*?)["']( with token)?$/) do |user, path, condition|
+  path = add_token_to_path(path,@_token) if condition == " with token"
+  send_request('GET',user,path,nil)
+end
+
+Given(/^(.*?) options ["'](.*?)["']( with token)?$/) do |user, path, condition|
+  path = add_token_to_path(path,@_token) if condition == " with token"
+  send_request('OPTIONS',user,path,nil)
+end
+
+Given(/^(.*?) posts ["'](.*?)["'] with (.*?)$/) do |user, path, json|
+  send_request('POST',user,path,json)
+end
+
+# doc string version
+Given(/^(.*?) posts ["'](.*?)["'] with$/) do |user, path, json|
+  send_request('POST',user,path,json)
+end
+
+Given(/^(.*?) deletes ["'](.*?)["']$/) do |user, path|
+  send_request('DELETE',user,path,nil)
+end
+
+Given(/^(.*?) puts ["'](.*?)["'] with (.*?)$/) do |user, path, json|
+  send_request('PUT',user,path,json)
+end
+
+# doc string version
+Given(/^(.*?) puts ["'](.*?)["'] with$/) do |user, path, json|
+  send_request('PUT',user,path,json)
+end
+
+# alternative format
+
+Given(/^I am (.*?)$/) do | string |
+  @_current_user = string.split(' ')[-1]
+end
+
+Given(/^I get ["'](.*?)["']$/) do |path|
+  send_request('GET',@_current_user,path,nil)
+end
+
+Given(/^I post ["'](.*?)["'] with (.*?)$/) do |path, json|
+  send_request('POST',@_current_user,path,json)
+end
+
+Given(/^I delete ["'](.*?)["']$/) do | path|
+  send_request('DELETE',@_current_user,path,nil)
+end
+
+Given(/^I put ["'](.*?)["'] with (.*?)$/) do |path, json|
+  send_request('PUT',@_current_user,path,json)
+end
+
+# response steps ==============================
+
+Then(/^the status should be (\d+)$/) do |code|
+  expect(valid_response.status).to eq code.to_i
+end
+
+Then(/^there should be an error$/) do
+  expect(valid_response.status.to_s[0,1]).not_to eq '2'
+  expect(valid_response.error).not_to be_nil
+end
+
+Then(/^the error message should include ["'](.*?)["']$/) do |field|
+  expect(valid_response.error && (valid_response.error =~ %r/#{field}/)).to_not be nil
+end
+
+Given(/^explain$/) do
+  explain
+end
+
+Then(/^the data type should be ["'](.*?)["']$/) do |type|
+  if valid_response.data.kind_of? Array
+    expect(valid_response.data[0]["_type"]).to eq type
+  else
+    expect(valid_response.data["_type"]).to eq type
+  end
+end
+
+
+Then(/^the data length should be (\d+)$/) do |len|
+  if valid_response.data.kind_of? Array
+    expect(valid_response.data.length).to eq len.to_i
+  else
+    log "data is not an array"
+    1
+  end
+end
+
+Then(/^the data length should equal (\d+)$/) do |len|
+  if valid_response.data.kind_of? Array
+    expect(valid_response.data.length).to eq len.to_i
+  else
+    expect(valid_response.data.kind_of?(Array) ).to eq true
+  end
+end
+
+Then(/^the data "(.*?)" should == (.*?)$/) do |field,val|
+  check_data_value(field,val)
+end
+
+Then(/^the data "(.*?)" should be (.*?)$/) do |field,val|
+  check_data_value(field,val)
+end
+
+
+def check_data_value(field,val)
+  if valid_data.kind_of? Array
+    data = valid_data[0]
+  else
+    data = valid_data
+  end
+  v = data[field].to_s
+  if val =~ %r{^@([^@]*)$}
+     expect(v).to eq store[$1].to_s
+  elsif val =~ %r{^(::)?[A-Z][A-z_a-z:]*$}
+     expect(v).to eq Module.const_get(val).to_s
+  elsif val =~ %r{^['"](.*)['"]$}
+     expect(v).to eq $1
+  end
+end
+
+Then(/^the data "(.*?)" should equal ["'](.*?)["']$/) do |field,val|
+  # if valid_response.data.kind_of? Array
+  #   data = valid_response.data[0]
+  # else
+  #   data = valid_response.data
+  # end
+  # check = String.new(data[field].to_s)
+  # check.force_encoding('UTF-8')
+  # expect(check).to eq val
+  check_data_value(field,val)
+end
+
+Then(/^the data "(.*?)" should include ["'](.*?)["']$/) do |field,val|
+  if valid_response.data.kind_of? Array
+    data = valid_response.data[0]
+  else
+    data = valid_response.data
+  end
+  check = String.new(data[field].to_s)
+  check.force_encoding('UTF-8')
+  expect(check).to include val
+end
+
+Then(/^the data ["'](.*?)["'] should == nil$/) do |field|
+  if valid_response.data.kind_of? Array
+    data = valid_response.data[0]
+  else
+    data = valid_response.data
+  end
+  expect(data[field]).to be nil
+end
+
+Then(/^the data ["'](.*?)["'] should equal nil$/) do |field|
+  if valid_response.data.kind_of? Array
+    data = valid_response.data[0]
+  else
+    data =valid_response.data
+  end
+  expect(data[field]).to be nil
+end
+
+Then(/^the body should eq ["'](.*?)["']$/) do |val|
+  val.gsub!("\\n","\n")
+  expect(valid_response.body).to eq val
+end
+
+
+
+Then(/^the data should( not)? include ["'](.*?)["']$/) do |state, field|
+  if valid_response.data.kind_of? Array
+    data = valid_response.data[0]
+  else
+    data = valid_response.data
+  end
+  if state == " not"
+     expect(data.key?(field)).to eq false
+  else
+     expect(data.key?(field)).to eq true
+  end
+end
+
+
+
+Then(/^store the ["'](.*?)["'] as ["'](.*?)["']$/) do |name,key|
+  if valid_response.data.kind_of?(Array)
+    data = valid_response.data[0]
+  else
+    data  = valid_response.data
+  end
+  if data.kind_of?(Hash) && data.key?(name)
+    store[key] =  data[name]
+  end
+end
+
+Given(/^save the "([^"]*)"$/) do |name|
+  if valid_response.data.kind_of?(Array)
+    data = valid_response.data[0]
+  else
+    data  = valid_response.data
+  end
+  if data.kind_of?(Hash) && data.key?(name)
+    store[name] =  data[name]
+  end
+end

data/lib/blix/rest/cucumber/resource_steps.rb

@@ -0,0 +1,28 @@
+class UserHash < Hash
+  def set(k,v)
+    self[k.to_s] = v
+  end
+
+  def get(k)
+    self[k.to_s]
+  end
+end
+
+Given(/^the following users exist:$/) do |table|
+  table.hashes.each do |h|
+
+    name = h["name"] || h["login"]
+
+    next if name=="guest"
+
+    u = UserHash.new.merge!(h)
+
+
+
+    u.set(:pw,h["secret"] || h["password"] || name+"@12345678")
+
+    before_user_create(u,h)
+    users[name] = u
+    after_user_create(u,h)
+  end
+end

data/lib/blix/rest/cucumber/world.rb

@@ -0,0 +1,276 @@
+# the step definitions are executed in an instance of world so
+# we can add helper methods for use in the step definitions.
+
+class RestWorld
+  # the entry point to the rack application to be tested
+  def self.app
+    @_app ||= begin
+      [Rack::Builder.parse_file('config.ru')].flatten.first
+    end
+  end
+
+  # a dummy request to sent to the server
+  def self.request
+    @_req ||= Rack::MockRequest.new(app)
+  end
+
+  # a class to represent a response from the server
+  class Response
+    def initialize(resp)
+      @resp = resp
+      content_type = @resp.headers['Content-Type'] || @resp.headers['content-type']
+      if content_type == 'application/json'
+        begin
+          @h = MultiJson.load(body) || {}
+        rescue Exception => e
+          log 'INVALID RESPONSE BODY=>' + body
+          raise
+        end
+      else
+        @h = { 'html' => body }
+      end
+
+      # get_ids_from_hash
+    end
+
+    def [](k)
+      @h[k]
+    end
+
+    def body
+      [@resp.body].flatten.join('')
+    end
+
+    def data
+      @h['data']
+    end
+
+    def error
+      @h['error']
+    end
+
+    def status
+      @resp.status.to_i
+    end
+
+    def header
+      @resp.headers || {}
+    end
+
+    def content_type
+      header['Content-Type']
+    end
+
+    def inspect
+      @resp.inspect
+    end
+  end
+
+  # store cookies for each user here
+  def cookies
+    @_cookies ||= {}
+    @_cookies[@_current_user] ||= []
+  end
+
+  # store current user information here
+  def users
+    @_users ||= {}
+  end
+
+  # store current user tokens here
+  def tokens
+    @_tokens ||= {}
+  end
+
+  # store general information here
+  def store
+    @_store ||= {}
+  end
+
+  def valid_response
+    @_response || raise('no valid response from service')
+  end
+
+  def valid_data
+    @_response && @_response.data || raise("no valid data returned from service:#{@_response.error}")
+  end
+
+  def explain
+    log "request ==> #{@_verb} #{@_request}"
+    log "cookies ==> #{cookies.join('; ')}" if cookies.length > 0
+    log "body ==> #{@_body}" if @_body
+    log "response ==> #{@_response.inspect}"
+  end
+
+  def before_parse_path(path); end
+
+  def before_parse_body(json); end
+
+  def parse_path(path)
+    path = path.dup
+
+    before_parse_path(path)
+
+    path = path.gsub /\/(@[a-z0-9_]+)/ do |str|
+      str = str[2..-1]
+      id  = store[str]
+      raise ":#{str} has not been stored" unless id
+      if id[0] == '/'
+        "#{id}"
+      else
+        "/#{id}"
+      end
+    end
+    # and the query part
+    path.gsub /\=(@[a-z0-9_]+)/ do |str|
+      str = str[2..-1]
+      id  = store[str]
+      raise ":#{str} has not been stored" unless id
+
+      "=#{id}"
+    end
+  end
+
+  def parse_json(json)
+    # replace original format
+    json = json.gsub /:@([a-z0-9_]+)/ do |str|
+      str = str[2..-1]
+      id = store[str]
+      raise ":#{str} has not been stored" unless id
+
+      if id.is_a?(String)
+        ":\"#{id}\""
+      else
+        ":#{id}"
+      end
+    end
+
+    # replace alternative format
+    json = json.gsub /#\{([a-z0-9_]+)\}/ do |str|
+      str = str[2..-2]
+      id = store[str]
+      raise ":#{str} has not been stored" unless id
+
+      if id.is_a?(String)
+        "\"#{id}\""
+      else
+        "#{id}"
+      end
+    end
+  end
+
+  def parse_body(json)
+    json = json.dup
+    before_parse_body(json)
+    parse_json(json)
+  end
+
+  def add_token_to_request
+    return if @_request.include?('token=')
+    if @_user
+      token = @_user.get(:token) || "token12345678-#{@_user.get(:login)}"
+      @_request = if @_request.include?('?')
+                    @_request + "&token=#{token}"
+                  else
+                    @_request + "?token=#{token}"
+                  end
+    end
+  end
+
+  def add_token_to_path(path,token)
+    return unless token
+    if path.include?('?')
+      path + "&token=" + token
+    else
+      path + "?token=" + token
+    end
+  end
+
+  def rack_request_headers
+    env = {}
+    env['REMOTE_ADDR'] = '10.0.0.1'
+    env['HTTP_COOKIE'] = cookies.join('; ')
+    env["HTTP_AUTHORIZATION"] = @_auth if @_auth
+    env["HTTP_HOST"] = @_host if @_host
+    env
+  end
+
+  def request
+    RestWorld.request
+  end
+
+  def set_host(name)
+    @_host = name
+  end
+
+  def set_auth_headers(user)
+    raise "invalid user name:#{user}" unless u = users[user]
+    pw = u.get(:pw)
+    raise "iuser name:#{user} has no password!" unless pw
+    str = user + ":" + pw
+    str = Base64.encode64(str)
+    str = "Basic " + str
+    #Rack::MockRequest::DEFAULT_ENV["HTTP_AUTHORIZATION"] = str
+    @_auth  = str
+  end
+
+  # save the response for furthur enquiries and store any cookies.
+  def handle_response(raw_response)
+    @_auth = nil
+    @_response = Response.new(raw_response)
+    # add cookies to the cookie jar.
+    #unless @_current_user=="guest"
+    if cookie = @_response.header["Set-Cookie"] || @_response.header["set-cookie"]
+      parts = cookie.split(';')
+      cookies << parts[0].strip
+    end
+    #end
+  end
+
+  def parse_user(user)
+    user.split(' ')[-1]
+  end
+
+  def send_request(verb, username, path, json)
+    username = parse_user(username)
+    @_verb = verb
+    @_body = json && parse_body(json)
+    @_request = parse_path(path)
+    @_current_user  = username
+
+    if username == 'guest'
+      @_user = nil
+    else
+      @_user = users[username]
+      raise "user :#{username} has not been initialized" unless @_user
+
+      pw = @_user.get(:pw)
+      add_token_to_request
+      set_auth_headers(username)
+    end
+    case verb
+    when 'GET'
+      handle_response(request.get(@_request, rack_request_headers))
+    when 'OPTIONS'
+      handle_response(request.options(@_request, rack_request_headers))
+    when 'POST'
+      handle_response(request.post(@_request, rack_request_headers.merge(input: @_body)))
+    when 'PUT'
+      handle_response(request.put(@_request, rack_request_headers.merge(input: @_body)))
+    when 'DELETE'
+      handle_response(request.delete(@_request, rack_request_headers.merge(input: @_body)))
+    end
+  end
+
+  # a hook that is called before creating a user
+  def before_user_create(user, hash); end
+
+  # a hook that is called before creating a user
+  def after_user_create(user, hash); end
+end
+
+
+
+World do
+  RestWorld.new
+end

data/lib/blix/rest/cucumber.rb

@@ -0,0 +1,8 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'cucumber'
+require 'blix/rest'
+require 'blix/rest/cucumber/world'
+require 'blix/rest/cucumber/hooks'
+require 'blix/rest/cucumber/request_steps'
+require 'blix/rest/cucumber/resource_steps'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: blix-rest-cucumber
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Clive Andrews
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: blix-rest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+description: Cucumber testing support for blix/rest
+email:
+- gems@realitybites.eu
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/blix/rest/cucumber.rb
+- lib/blix/rest/cucumber/hooks.rb
+- lib/blix/rest/cucumber/request_steps.rb
+- lib/blix/rest/cucumber/resource_steps.rb
+- lib/blix/rest/cucumber/world.rb
+homepage: https://github.com/realbite/blix-rest
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: Test Blix/Rest Server with Cucumber
+test_files: []