tim/fluke
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

without old tests

Browse Source
This commit is contained in:
amartynov 2014-07-14 12:26:16 +04:00
parent 25486edfe5
commit a6f5a6b4bf
18 changed files with 0 additions and 991 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
devops-service/tests/config.rb
View File

@ -1,6 +0,0 @@
USERNAME="<tester>"
PASSWORD="<some password>"
HOST="<devops service host>"
ROOTUSER="root"
ROOTPASS=""
PROVIDERS=["ec2", "openstack"]

61
devops-service/tests/cud_command.rb
View File

@ -1,61 +0,0 @@
module CudCommand
HEADERS = {
"Accept" => "application/json",
"Content-Type" => "application/json"
}
def test_headers path, method="post", accept=true
m = method.downcase
if accept
h = HEADERS.clone
h["Accept"] = "application/xml"
self.send("send_#{m}", path, {}, h, 406)
end
h = HEADERS.clone
h.delete("Content-Type")
self.send("send_#{m}", path, {}, h, 415)
end
def test_request path, obj, method="post", exclude=nil
m = method.downcase
[{}, [], ""].each do |o|
next if o.class == exclude
self.send("send_#{m}", path, o, HEADERS, 400) unless exclude.is_a?(Hash)
end
self.send("send_#{m}", path, nil, HEADERS, 400)
return if exclude == obj.class
obj.keys.each do |key|
buf = obj.clone
buf.delete(key)
self.send("send_#{m}", path, buf, HEADERS, 400)
buf[key] = ""
self.send("send_#{m}", path, buf, HEADERS, 400)
buf[key] = {}
self.send("send_#{m}", path, buf, HEADERS, 400)
buf[key] = []
self.send("send_#{m}", path, buf, HEADERS, 400)
end
end
def test_auth path, obj, empty_obj_code=400, method="post"
m = method.downcase
read_only_privileges
self.send("send_#{m}", path, {}, HEADERS, 401)
self.send("send_#{m}", path, obj, HEADERS, 401)
empty_privileges
self.send("send_#{m}", path, {}, HEADERS, 401)
self.send("send_#{m}", path, obj, HEADERS, 401)
write_only_privileges
self.send("send_#{m}", path, {}, HEADERS, empty_obj_code)
self.username = ROOTUSER
self.send("send_#{m}", path, {}, HEADERS, empty_obj_code)
all_privileges
end
end

55
devops-service/tests/deploy.rb
View File

@ -1,55 +0,0 @@
require "devops_test"
require "cud_command"
class Deploy < DevopsTest
include CudCommand
def title
"Deploy test (invalid queries only)"
end
# tests invalid queries only, valid query in client test
def run
all_privileges
test_headers("deploy", "post", false)
deploy = {
:names => ["foo"],
:tags => ["foo"]
}
test_auth("deploy", deploy)
cnt = 0
headers = HEADERS.clone
headers.delete("Accept")
st = 400
nf_st = 404
begin
[{}, [], "", nil].each do |p|
self.send_post("deploy", p, headers, st)
d = deploy.clone
d.delete(:tags)
d[:names] = p
self.send_post("deploy", d, headers, st)
unless p.nil?
d = deploy.clone
d[:tags] = p
self.send_post("deploy", d, headers, st)
end
end
deploy[:tags] = nil
self.send_post("deploy", deploy, headers, nf_st)
deploy.delete(:tags)
self.send_post("deploy", deploy, headers, nf_st)
if cnt == 0
cnt = 1
write_only_privileges
raise RangeError
end
rescue RangeError
retry
end
end
end

202
devops-service/tests/devops_test.rb
View File

@ -1,202 +0,0 @@
require "json"
require "httpclient"
require "./config"
class DevopsTest
attr_accessor :password, :response, :host
attr_reader :username
def initialize
puts_head " #{self.title} ".center(80, "=")
self.host = HOST
# self.username = USERNAME
# self.password = PASSWORD
end
def submit
http = HTTPClient.new
http.receive_timeout = 0
http.send_timeout = 0
http.set_auth(nil, self.username, self.password)
self.response = yield http
self.response.body
end
def username= user
@username = user
self.password = if user == ROOTUSER
ROOTPASS
else
PASSWORD
end
puts_warn(" - User: " + @username + " - ")
end
def all_privileges
self.username = USERNAME
end
def read_only_privileges
self.username = USERNAME + "_r"
end
def write_only_privileges
self.username = USERNAME + "_w"
end
def empty_privileges
self.username = USERNAME + "_"
end
def get path, params={}, headers={}
url = create_url(path)
m = "GET #{url.path.ljust(30)}"
m += " HEADERS(#{headers.map{|k,v| "#{k}: #{v}" }.join(", ")})" unless headers.empty?
print m.ljust(99)
submit do |http|
http.get(url, convert_params(params), headers)
end
end
def post path, params={}, headers={}
url = create_url(path)
m = "POST #{url.path.ljust(30)}"
m += " HEADERS(#{headers.map{|k,v| "#{k}: #{v}" }.join(", ")})" unless headers.empty?
print m.ljust(99)
submit do |http|
http.post(url, params.to_json, headers)
end
end
def send_post path, params={}, headers={}, status=200
self.post path, params, headers
self.check_status status
self.check_json_response
end
def delete path, params={}, headers={}
url = create_url(path)
m = "DELETE #{url.path.ljust(30)}"
m += " HEADERS(#{headers.map{|k,v| "#{k}: #{v}" }.join(", ")})" unless headers.empty?
print m.ljust(99)
b = (params.nil? ? nil : params.to_json)
submit do |http|
http.delete(url, b, headers)
end
end
def send_delete path, params={}, headers={}, status=200
self.delete path, params, headers
self.check_status status
self.check_json_response
end
def post_chunk path, params={}, headers={}
url = create_url(path)
m = "POST #{url.path.ljust(30)}"
m += " HEADERS(#{headers.map{|k,v| "#{k}: #{v}" }.join(", ")})" unless headers.empty?
print m.ljust(99)
submit do |http|
http.post(url, params.to_json, headers) do |c|
end
end
end
def send_put path, params={}, headers={}, status=200
self.put path, params, headers
self.check_status status
self.check_json_response
end
def put path, params={}, headers={}
url = create_url(path)
m = "PUT #{url.path.ljust(30)}"
m += " HEADERS(#{headers.map{|k,v| "#{k}: #{v}" }.join(", ")})" unless headers.empty?
print m.ljust(99)
submit do |http|
http.put(url, params.to_json, headers)
end
end
def check_status code
if self.response.status == code
self.puts_success
else
self.puts_error "STATUS: #{self.response.status}, but checked with '#{code}'"
end
end
def check_json_response
return if self.response.status == 404
j = begin
JSON.parse(self.response.body)
rescue
self.puts_error "Invalid json, response body: '#{self.response.body}'"
end
self.puts_error "Response in Json format, but without parameter 'message'" unless j.key?("message")
end
def check_type type
res = self.response
if res.ok?
case type
when :json
puts_error("Invalid content-type '#{res.contenttype}'") unless res.contenttype.include?("application/json")
else
puts_error("Unknown type '#{type}'")
end
end
end
def puts_head str
puts "\e[31m#{str}\e[0m"
end
def puts_error str
puts "\t\e[31m#{str}\e[0m"
raise str
end
def puts_warn str
puts "\t\e[33m#{str}\e[0m"
end
def puts_success str="success"
puts "\t\e[32m#{str}\e[0m"
end
private
def create_url path
path = "/" + path unless path.start_with? "/"
URI.join("http://" + self.host, "v2.0" + path)
end
def convert_params params
return nil if params.nil? or params.empty?
params_filter(params).join("&")
end
def params_filter params
r = []
return params if params.kind_of?(String)
params.each do |k,v|
key = k.to_s
if v.kind_of?(Array)
v.each do |val|
r.push "#{key}[]=#{val}"
end
elsif v.kind_of?(Hash)
buf = {}
v.each do |k1,v1|
buf["#{key}[#{k1}]"] = v1
end
r = r + params_filter(buf)
else
r.push "#{key}=#{v}"
end
end
r
end
end

27
devops-service/tests/filter.rb
View File

@ -1,27 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Filter < DevopsTest
include ListCommand
include CudCommand
def title
"Filter test"
end
def run
list_providers("filter/:provider/images")
filters = [
"foo"
]
cmd = "filter/openstack/image"
test_auth cmd, {}, 400, "put"
test_headers cmd, "put"
test_request cmd, filters, "put", Array
test_auth cmd, {}, 400, "delete"
test_headers cmd, "delete"
test_request cmd, filters, "delete", Array
end
end

14
devops-service/tests/flavor.rb
View File

@ -1,14 +0,0 @@
require "devops_test"
require "list_command"
class Flavor < DevopsTest
include ListCommand
def title
"Flavor test"
end
def run
list_providers("flavors/:provider")
end
end

14
devops-service/tests/group.rb
View File

@ -1,14 +0,0 @@
require "devops_test"
require "list_command"
class Group < DevopsTest
include ListCommand
def title
"Group test"
end
def run
list_providers("groups/:provider")
end
end

64
devops-service/tests/image.rb
View File

@ -1,64 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Image < DevopsTest
include ListCommand
include CudCommand
def title
"Image test"
end
def run
list("images")
PROVIDERS.each do |p|
list_send("images", 200, :provider => p)
end
["foo", nil, ["ec2"], {"provider" => "ec2"}].each do |p|
list_send("images", 404, :provider => p)
end
cmd = "images/provider/:provider"
[USERNAME, USERNAME + "_r", ROOTUSER].each do |u|
self.username = u
PROVIDERS.each do |p|
list_send(cmd.gsub(":provider", p), 200)
end
list_send(cmd.gsub(":provider", "foo"), 404)
self.get("images/provider")
self.check_status 404
end
list_deny do
PROVIDERS.each do |p|
list_send(cmd.gsub(":provider", p), 401)
end
list_send(cmd.gsub(":provider", "foo"), 401)
self.get("images/provider")
self.check_status 404
end
image = {
:id => "foo_image",
:provider => "foo_provider",
:name => "foo_name",
:remote_user => "foo_user",
}
all_privileges
test_headers "image"
test_request "image", image
self.send_post "image", image, HEADERS, 400
i = image.clone
i[:provider] = "openstack"
self.send_post "image", i, HEADERS, 400
test_auth "image", image
test_auth "image/foo", {}, 404, "delete"
self.send_delete "image/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "image/foo", nil, h, 404
end
end

38
devops-service/tests/key.rb
View File

@ -1,38 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Key < DevopsTest
include ListCommand
include CudCommand
def title
"Key test"
end
def run
list("keys")
all_privileges
key = {
:content => "content",
:file_name => "key_file.pem",
:key_name => "test_key"
}
test_headers "key"
test_auth "key", key
test_request "key", key
k = key.clone
k[:file_name] = "key*_file.pem"
self.send_post "key", k, HEADERS, 400
test_auth "key/foo", key, 404, "delete"
self.send_delete "key/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "key/foo", nil, h, 404
end
end

86
devops-service/tests/list_command.rb
View File

@ -1,86 +0,0 @@
module ListCommand
def list path, params=nil, status=200
all_privileges
# list_send(path, status, 406, params)
cmd = ""
path.split("/").each do |s|
cmd += "/" + s
if cmd == "/" + path
list_send(cmd, status)
else
self.get cmd
self.check_status 404
end
end
read_only_privileges
list_send(path, status, params)
write_only_privileges
list_send(path, 401, params)
empty_privileges
list_send(path, 401, params)
self.username = ROOTUSER
list_send(path, status, params)
end
def list_deny
empty_privileges
cnt = 0
begin
yield
if cnt == 0
write_only_privileges
cnt = 1
raise RangeError
end
rescue RangeError
retry
end
end
def list_providers cmd, as_ok=401, as_not_found=401
all_privileges
check_provider cmd
read_only_privileges
check_provider cmd
write_only_privileges
check_provider cmd, as_ok, as_not_found, 401
empty_privileges
check_provider cmd, as_ok, as_not_found, 401
self.username = ROOTUSER
check_provider cmd
end
def check_provider cmd, ok_status=200, not_found_status=404, auth_not_found=406
#js = (ok_status == 200 ? 406 : ok_status)
PROVIDERS.each do |p|
list_send(cmd.gsub(":provider", p), ok_status)
end
path = ""
st = not_found_status
cmd.split("/").each do |s|
path += "/" + s
if path == "/" + cmd
list_send(path, st)
else
self.get path
self.check_status 404
end
end
end
def list_send path, status=200, params=nil
self.get path, params, {"Accept" => "application/xml"}
self.check_status 406
self.get path, params, {"Accept" => "application/json"}
self.check_status status
self.check_type :json if status == 200
end
end

14
devops-service/tests/network.rb
View File

@ -1,14 +0,0 @@
require "devops_test"
require "list_command"
class Network < DevopsTest
include ListCommand
def title
"Network test"
end
def run
list_providers("networks/:provider")
end
end

100
devops-service/tests/project.rb
View File

@ -1,100 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Project < DevopsTest
include ListCommand
include CudCommand
def title
"Project test"
end
def run
list("projects")
list("project/foo", nil, 404)
list_send("project/foo/servers", 404)
project = {
:deploy_envs => [
{
:flavor => "c1.large",
:identifier => "test",
:image => "e6f44159-f50a-49a5-bfd5-865d0f68779d",
:run_list => [
"role[solr_test]"
],
:subnets => [
"private"
],
:expires => nil,
:provider => "openstack",
:groups => [
"default"
],
:users => [
USERNAME
]
}
],
:name => "test"
}
test_auth "project", project
test_headers "project"
test_request "project", project
["openstack", "ec2"].each do |provider|
project[:deploy_envs][0].keys.each do |k|
p = project.clone
d = p[:deploy_envs][0]
d[:provider] = provider
if k == :expires
["foo", "", [], {}].each do |v|
d[k] = v
send_post "project", p, HEADERS, 400
end
elsif k == :run_list or k == :groups or k == :users
["", {}, nil].each do |v|
d[k] = v
send_post "project", p, HEADERS, 400
end
elsif k == :subnets and provider == "ec2"
["", {}].each do |v|
d[k] = v
send_post "project", p, HEADERS, 400
end
else
d.delete(k)
send_post "project", p, HEADERS, 400
[nil, "", [], {}].each do |v|
d[k] = v
send_post "project", p, HEADERS, 400
end
end
end
end
test_auth "project/foo", project, 404, "delete"
self.send_delete "project/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "project/foo", nil, h, 415
self.send_delete "project/foo", nil, HEADERS, 404
self.send_delete "project/foo", {:deploy_env => ""}, HEADERS, 400
deploy = {
:servers => ["foo"],
:deploy_env => "foo"
}
test_headers "project/foo/deploy", "post", false
deploy.keys.each do |k|
d = deploy.clone
["", [], {}].each do |v|
d[k] = v
send_post "project/foo/deploy", p, HEADERS, 400
end
end
# test_auth "project/foo/deploy", deploy, 404
end
end

14
devops-service/tests/provider.rb
View File

@ -1,14 +0,0 @@
require "devops_test"
require "list_command"
class Provider < DevopsTest
include ListCommand
def title
"Provider test"
end
def run
list("providers")
end
end

47
devops-service/tests/run_tests.rb
View File

@ -1,47 +0,0 @@
#!/usr/bin/env ruby
dir = File.dirname(__FILE__)
$:.push dir
tests = nil
if ARGV.empty?
tests = %w{flavor group network provider deploy image key script tag filter project user server}
else
tests = ARGV
end
classes = []
tests.each do |f|
require "#{dir}/#{f}.rb"
case f
when "flavor"
classes.push Flavor
when "group"
classes.push Group
when "network"
classes.push Network
when "provider"
classes.push Provider
when "user"
classes.push User
when "key"
classes.push Key
when "script"
classes.push Script
when "image"
classes.push Image
when "project"
classes.push Project
when "server"
classes.push Server
when "deploy"
classes.push Deploy
when "tag"
classes.push Tag
when "filter"
classes.push Filter
end
end
classes.each do |c|
c.new.run
end

33
devops-service/tests/script.rb
View File

@ -1,33 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Script < DevopsTest
include ListCommand
include CudCommand
def title
"Script test"
end
def run
list("scripts")
self.username = USERNAME
# test_headers "script/run/foo"
script = {
:nodes => ["foo"]
}
# test_request "script/run/foo", script, "post", Hash
test_auth "script/run/foo", script, 404
test_auth "script/command/foo", {}, 404
self.send_delete "script/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "script/foo", nil, h, 404
end
end

134
devops-service/tests/server.rb
View File

@ -1,134 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Server < DevopsTest
include ListCommand
include CudCommand
def title
"Server test"
end
def run
list("servers")
cmd = "servers/:provider"
p = PROVIDERS.clone
p.push "chef"
[USERNAME, USERNAME + "_r", ROOTUSER].each do |u|
self.username = u
p.each do |p|
list_send(cmd.gsub(":provider", p), 200)
end
list_send(cmd.gsub(":provider", "foo"), 404)
list_send("server/foo", 404)
end
list_deny do
p.each do |p|
list_send(cmd.gsub(":provider", p), 401)
end
list_send(cmd.gsub(":provider", "foo"), 401)
list_send("server/foo", 401)
end
test_auth "server/foo", {}, 404, "delete"
self.send_delete "server/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "server/foo", nil, h, 415
h = HEADERS.clone
self.send_delete "server/foo", nil, h, 404
all_privileges
server = {
:project => "foo",
:deploy_env => "foo",
:name => "foo",
:without_bootstrap => true,
:force => true,
:groups => [],
:key => "foo"
}
test_headers "server", "post", false
[:project, :deploy_env, :name, :key].each do |k|
s = server.clone
["", nil, [], {}].each do |v|
next if k == :name and v.nil?
s[k] = v
self.send_post "server", s, HEADERS, 400
end
end
[:force, :without_bootstrap].each do |k|
s = server.clone
["", false, [], {}].each do |v|
s[k] = v
self.send_post "server", s, HEADERS, 400
end
end
s = server.clone
["", true, [], [true], [{:foo => "foo"}], {}].each do |v|
s[:groups] = v
self.send_post "server", s, HEADERS, 400
end
test_auth "server", server
["server/foo/pause", "server/foo/unpause"].each do |cmd|
test_auth cmd, nil, 404
test_headers cmd
end
bootstrap = {
:instance_id => "foo",
:name => "foo",
:run_list => ["foo"],
:bootstrap_template => "foo"
}
cmd = "server/bootstrap"
test_auth cmd, bootstrap
test_headers cmd, "post", false
b = bootstrap.clone
["", [], {}].each do |v|
b[:instance_id] = v
self.send_post cmd, b, HEADERS, 400
end
[:name, :bootstrap_template].each do |k|
b = bootstrap.clone
["", [], {}].each do |v|
b[k] = v
self.send_post cmd, b, HEADERS, 400
end
end
b = bootstrap.clone
["", [nil], [{:foo => "foo"}], [true], {}].each do |v|
b[:run_list] = v
self.send_post cmd, b, HEADERS, 400
end
cmd = "server/add"
add = {
:project => "foo",
:deploy_env => "foo",
:key => "foo",
:remote_user => "foo",
:private_ip => "foo",
:public_ip => "foo"
}
test_auth cmd, add
test_headers cmd, "post", false
[:project, :deploy_env, :key, :remote_user, :private_ip, :public_ip].each do |k|
a = add.clone
[nil, "", [], {}].each do |v|
next if k == :public_ip and v.nil?
a[k] = v
self.send_post cmd, a, HEADERS, 400
end
end
end
end

33
devops-service/tests/tag.rb
View File

@ -1,33 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class Tag < DevopsTest
include ListCommand
include CudCommand
def title
"Tag test"
end
def run
self.username = USERNAME
self.get("tags")
self.check_status 404
list("tags/foo", nil, 404)
self.username = USERNAME
tags = {
:tags => ["tag1"]
}
test_headers "tags/foo"
test_request "tags/foo", tags
test_auth "tags/foo", tags
test_headers "tags/foo", "delete"
test_request "tags/foo", tags, "delete", Hash
test_auth "tags/foo", tags, 400, "delete"
end
end

49
devops-service/tests/user.rb
View File

@ -1,49 +0,0 @@
require "devops_test"
require "list_command"
require "cud_command"
class User < DevopsTest
include ListCommand
include CudCommand
def title
"User test"
end
def run
list("users")
self.username = USERNAME
user = {
:username => "foo",
:password => "foo",
}
test_headers "user"
test_request "user", user
test_auth "user", user
test_auth "user/foo", user, 404, "delete"
self.send_delete "user/foo", nil, {}, 406
h = HEADERS.clone
h.delete("Content-Type")
self.send_delete "user/foo", nil, h, 404
privileges = {
:privileges => "foo",
:cmd => "foo"
}
test_auth "user/foo", privileges, 404, "put"
test_headers "user/foo", "put"
test_request "user/foo", privileges, "put", Hash
pass = {
:password => "foo"
}
test_auth "user/foo/password", pass, 400, "put"
test_headers "user/foo/password", "put"
test_request "user/foo/password", pass, "put", Hash
end
end