blix-rest 0.1.30

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'

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,207 @@
+#========== 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

@@ -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,273 @@
+# 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').first
+  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
+      if @resp.header['Content-Type'] == 'application/json'
+        begin
+          @h = MultiJson.load(@resp.body) || {}
+        rescue Exception => e
+          puts 'INVALID RESPONSE BODY=>' + @resp.body
+          raise
+        end
+      else
+        @h = { 'html' => @resp.body }
+      end
+
+      # get_ids_from_hash
+    end
+
+    def [](k)
+      @h[k]
+    end
+
+    def body
+      @resp.body
+    end
+
+    def data
+      @h['data']
+    end
+
+    def error
+      @h['error']
+    end
+
+    def status
+      @resp.status.to_i
+    end
+
+    def header
+      @resp.header || {}
+    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
+    puts "request ==> #{@_verb} #{@_request}"
+    puts "cookies ==> #{cookies.join('; ')}" if cookies.length > 0
+    puts "body ==> #{@_body}" if @_body
+    puts "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"]
+      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