blix-rest 0.9.3 → 0.11.1

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

@@ -1,5 +0,0 @@
-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

@@ -1,207 +0,0 @@
-#========== 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
-    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
-    1
-  end
-end
-
-Then(/^the data "(.*?)" should == (.*?)$/) do |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
-  expect(data[field].to_s).to eq 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

@@ -1,28 +0,0 @@
-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

@@ -1,274 +0,0 @@
-# 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 ||= Rack::Builder.parse_file('config.ru')
-  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

@@ -1,8 +0,0 @@
-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'