code
stringlengths 12
2.05k
| label_name
stringclasses 5
values | label
int64 0
4
|
|---|---|---|
it "fails when user is suspended" do
user.update!(
suspended_till: 2.days.from_now,
suspended_at: Time.zone.now
)
get "/session/email-login/#{email_token.token}"
expect(response.status).to eq(200)
expect(CGI.unescapeHTML(response.body)).to include(I18n.t("login.suspended",
date: I18n.l(user.suspended_till, format: :date_only)
))
end | Class | 2 |
it "adds the server to the list" do
cluster.sync_server server
cluster.servers.should include server
end | Class | 2 |
def test_attr_wrapper
assert_equal("<p strange=*attrs*></p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
assert_equal("<p escaped='quo\"te'></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
assert_equal("<p escaped=\"quo'te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
assert_equal("<p escaped=\"q'uo"te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"', :format => :xhtml))
end | Base | 1 |
it "returns the query" do
query.limit(5).should eql query
end | Class | 2 |
it "returns the document" do
session.simple_query(query).should eq(a: 1)
end | Class | 2 |
it "doesn't log in the user when not approved" do
SiteSetting.must_approve_users = true
get "/session/email-login/#{email_token.token}"
expect(response.status).to eq(200)
expect(CGI.unescapeHTML(response.body)).to include(
I18n.t("login.not_approved")
)
end | Class | 2 |
def authorized?(request)
origin_host = request.get_header("HTTP_HOST")&.slice(VALID_ORIGIN_HOST, 1) || ""
forwarded_host = request.x_forwarded_host&.slice(VALID_FORWARDED_HOST, 1) || ""
@permissions.allows?(origin_host) && (forwarded_host.blank? || @permissions.allows?(forwarded_host))
end | Base | 1 |
def create
Log.add_info(request, params.inspect)
parent_id = params[:selectedFolderId]
if params[:thetisBoxEdit].nil? or params[:thetisBoxEdit].empty?
@mail_folder = nil
else
@mail_folder = MailFolder.new
@mail_folder.name = params[:thetisBoxEdit]
@mail_folder.parent_id = parent_id
@mail_folder.user_id = @login_user.id
@mail_folder.xtype = nil
@mail_folder.save!
end
render(:partial => 'ajax_folder_entry', :layout => false)
end | Base | 1 |
def find(uuid, options = {})
if uuid.nil? || uuid.to_s.empty?
raise NotFound, "can't find a record with nil identifier"
end
uri = uuid =~ /^http/ ? uuid : member_path(uuid)
begin
from_response API.get(uri, {}, options)
rescue API::NotFound => e
raise NotFound, e.description
end
end | Base | 1 |
it "changes the $orderby" do
query.sort(a: 1)
query.sort(a: 2)
query.operation.selector.should eq(
"$query" => selector,
"$orderby" => { a: 2 }
)
end | Class | 2 |
it "recognizes and generates #index" do
{ :get => "/users" }.should route_to(:controller => "users", :action => "index")
end | Class | 2 |
def self.get_my_folder(user_id)
SqlHelper.validate_token([user_id])
return Folder.where("(owner_id=#{user_id}) and (xtype='#{Folder::XTYPE_USER}')").first
end | Base | 1 |
def update
@campaign.update(campaign_params)
end | Base | 1 |
def self.get_childs(folder_id, conditions, recursive, admin, ret_obj)
SqlHelper.validate_token([folder_id])
arr = []
if recursive
folder_tree = Folder.get_tree(Hash.new, conditions, folder_id, admin)
return [] if folder_tree.nil?
folder_tree.each do |parent_id, childs|
if ret_obj
arr |= childs
else
childs.each do |folder|
folder_id = folder.id.to_s
arr << folder_id unless arr.include?(folder_id)
end
end
end
else
con = Marshal.load(Marshal.dump(conditions))
if con.nil?
con = ''
else
con << ' and '
end
con << "parent_id=#{folder_id}"
unless admin
con << " and (xtype is null or not (xtype='#{Folder::XTYPE_SYSTEM}'))"
end
folders = Folder.where(con).order('xorder ASC').to_a
if ret_obj
arr = folders
else
folders.each do |folder|
arr << folder.id.to_s
end
end
end
return arr
end | Base | 1 |
it "removes the first matching document" do
session.should_receive(:with, :consistency => :strong).
and_yield(session)
session.should_receive(:execute).with do |delete|
delete.flags.should eq [:remove_first]
delete.selector.should eq query.operation.selector
end
query.remove
end | Class | 2 |
def merge(server)
previous = servers.find { |other| other == server }
primary = server.primary?
secondary = server.secondary?
if previous
previous.merge(server)
else
servers << server
end
end | Class | 2 |
it 'supports group' do
topic = Fabricate(:topic, created_at: 3.months.ago)
post = Fabricate(:post, raw: 'hi this is a test 123 123', topic: topic)
group = Group.create!(name: "Like_a_Boss")
GroupUser.create!(user_id: post.user_id, group_id: group.id)
expect(Search.execute('group:like_a_boss').posts.length).to eq(1)
expect(Search.execute('group:"like a brick"').posts.length).to eq(0)
end | Class | 2 |
def schedule_all
Log.add_info(request, params.inspect)
date_s = params[:date]
if date_s.nil? or date_s.empty?
@date = Date.today
else
@date = Date.parse(date_s)
end
if @login_user.nil? or params[:display].nil? or params[:display] == 'all'
params[:display] = 'all'
con = EquipmentHelper.get_scope_condition_for(@login_user)
else
display_type = params[:display].split('_').first
display_id = params[:display].split('_').last
case display_type
when 'group'
if @login_user.get_groups_a(true).include?(display_id)
con = SqlHelper.get_sql_like([:groups], "|#{display_id}|")
end
when 'team'
if @login_user.get_teams_a.include?(display_id)
con = SqlHelper.get_sql_like([:teams], "|#{display_id}|")
end
end
end | Base | 1 |
def stub_dummy_jwks
stub_request(:get, 'https://example.org/.well-known/jwks.json')
.to_return(
headers: { 'Content-Type' => 'application/json' },
body: rsa_token_jwks,
status: 200
)
end | Base | 1 |
def self.get_group_value(group_id, category, key)
SqlHelper.validate_token([group_id, category, key])
con = []
con << "(group_id=#{group_id})"
con << "(category='#{category}')"
con << "(xkey='#{key}')"
setting = Setting.where(con.join(' and ')).first
return setting.xvalue unless setting.nil?
return nil
end | Base | 1 |
def reset_password
@admin_user = Motor::AdminUser.find(params[:admin_user_id])
authorize!(:manage, @admin_user)
Devise::Mailer.default_url_options = { host: request.host, protocol: request.protocol, port: request.port }
@admin_user.send_reset_password_instructions
head :ok
end | Class | 2 |
def apply(operations)
operations.inject(self) do |builder, (name, argument)|
if argument == true || argument == nil
builder.send(name)
elsif argument.is_a?(Array)
builder.send(name, *argument)
elsif argument.is_a?(Hash)
builder.send(name, **argument)
else
builder.send(name, argument)
end
end
end | Base | 1 |
def package_index
valid_http_methods :get
required_parameters :project, :repository, :arch, :package
# read access permission check
if params[:package] == "_repository"
prj = DbProject.get_by_name params[:project], use_source=false
else
pkg = DbPackage.get_by_project_and_name params[:project], params[:package], use_source=false
end
pass_to_backend
end | Class | 2 |
def self.get_tree(folder_tree, conditions, parent, admin)
if parent.instance_of?(Folder)
tree_id = parent.id.to_s
else
tree_id = parent.to_s
parent = nil
if tree_id != '0'
begin
parent = Folder.find(tree_id)
rescue
end
return folder_tree if parent.nil?
end
end
group_obj_cache = {}
folder_tree[tree_id] = []
if !parent.nil? and (parent.xtype == Folder::XTYPE_GROUP)
Group.get_childs(parent.owner_id, false, true).each do |group|
group_obj_cache[group.id] = group
con = Marshal.load(Marshal.dump(conditions)) unless conditions.nil?
if con.nil?
con = ''
else
con << ' and '
end
con << "(xtype='#{Folder::XTYPE_GROUP}') and (owner_id=#{group.id})"
begin
group_folder = Folder.where(con).first
rescue => evar
Log.add_error(nil, evar)
end
unless group_folder.nil?
folder_tree[tree_id] << group_folder
end
end
end
con = Marshal.load(Marshal.dump(conditions)) unless conditions.nil?
if con.nil?
con = ''
else
con << ' and '
end
con << "parent_id=#{tree_id}"
folder_tree[tree_id] += Folder.where(con).order('xorder ASC, id ASC').to_a
delete_ary = []
folder_tree[tree_id].each do |folder|
if !admin and (folder.xtype == Folder::XTYPE_SYSTEM)
delete_ary << folder
next
end
if (tree_id == '0') and (folder.xtype == Folder::XTYPE_GROUP)
group = Group.find_with_cache(folder.owner_id, group_obj_cache)
unless group.nil?
if group.parent_id != 0
delete_ary << folder
next
end
end
end
folder_tree = Folder.get_tree(folder_tree, conditions, folder, admin)
end
folder_tree[tree_id] -= delete_ary
return folder_tree
end | Base | 1 |
def html_postprocess(_field, html)
html
end | Base | 1 |
def get_local_node_id()
if ISRHEL6
out, errout, retval = run_cmd(
PCSAuth.getSuperuserSession, COROSYNC_CMAPCTL, "cluster.cman"
)
if retval != 0
return ""
end
match = /cluster\.nodename=(.*)/.match(out.join("\n"))
if not match
return ""
end
local_node_name = match[1]
out, errout, retval = run_cmd(
PCSAuth.getSuperuserSession,
CMAN_TOOL, "nodes", "-F", "id", "-n", local_node_name
)
if retval != 0
return ""
end
return out[0].strip()
end
out, errout, retval = run_cmd(
PCSAuth.getSuperuserSession,
COROSYNC_CMAPCTL, "-g", "runtime.votequorum.this_node_id"
)
if retval != 0
return ""
else
return out[0].split(/ = /)[1].strip()
end
end | Compound | 4 |
def get_wizard(params, request, session)
if not allowed_for_local_cluster(session, Permissions::READ)
return 403, 'Permission denied'
end
wizard = PCSDWizard.getWizard(params["wizard"])
if wizard != nil
return erb wizard.collection_page
else
return "Error finding Wizard - #{params["wizard"]}"
end
end | Compound | 4 |
def add_acl_remote(params, request, session)
if not allowed_for_local_cluster(session, Permissions::GRANT)
return 403, 'Permission denied'
end
if params["item"] == "permission"
retval = add_acl_permission(
session,
params["role_id"], params["type"], params["xpath_id"], params["query_id"]
)
elsif (params["item"] == "user") or (params["item"] == "group")
retval = add_acl_usergroup(
session, params["role_id"], params["item"], params["usergroup"]
)
else
retval = "Error: Unknown adding request"
end
if retval == ""
return [200, "Successfully added permission to role"]
else
return [
400,
retval.include?("cib_replace failed") ? "Error adding permission" : retval
]
end
end | Compound | 4 |
def test_update_invalid
Subnet.any_instance.stubs(:valid?).returns(false)
put :update, {:id => Subnet.first, :subnet => {:network => nil}}, set_session_user
assert_template 'edit'
end | Class | 2 |
it "yields a session" do
session.with(new_options) do |new_session|
new_session.should be_a Moped::Session
end
end | Class | 2 |
it "returns all other known hosts" do
cluster.sync_server(server).should =~ ["localhost:61085", "localhost:61086", "localhost:61084"]
end | Class | 2 |
def media_type_mismatch?
! supplied_file_media_types.include?(calculated_media_type)
end | Base | 1 |
def accepts?(env)
session = session env
token = session[:csrf] ||= session['_csrf_token'] || random_string
safe?(env) ||
env['HTTP_X_CSRF_TOKEN'] == token ||
Request.new(env).params[options[:authenticity_param]] == token
end | Base | 1 |
def update_groups_order
Log.add_info(request, params.inspect)
order_ary = params[:groups_order]
Research.set_statistics_groups order_ary
render(:text => '')
end | Base | 1 |
it "should raise an error if the image fails to be processed when downloaded" do
stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
expect(running {
@instance.remote_image_url = "http://www.example.com/test.jpg"
}).to raise_error(CarrierWave::ProcessingError)
end | Base | 1 |
def resource_clone(params, request, session)
if not allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
unless params[:resource_id]
return [400, 'resource_id has to be specified.']
end
_, stderr, retval = run_cmd(
session, PCS, 'resource', 'clone', params[:resource_id]
)
if retval != 0
return [400, 'Unable to create clone resource from ' +
"'#{params[:resource_id]}': #{stderr.join('')}"
]
end
return 200
end | Compound | 4 |
def attachments_without_content
return [] if self.id.nil?
sql = 'select id, title, memo, name, size, content_type, comment_id, xorder, location from attachments'
sql << ' where comment_id=' + self.id.to_s
sql << ' order by xorder ASC'
begin
attachments = Attachment.find_by_sql(sql)
rescue => evar
Log.add_error(nil, evar)
end
attachments = [] if attachments.nil?
return attachments
end | Base | 1 |
def self.destroy_by_user(user_id, add_con=nil)
SqlHelper.validate_token([user_id])
con = "user_id=#{user_id}"
con << " and (#{add_con})" unless add_con.nil? or add_con.empty?
emails = Email.where(con).to_a
emails.each do |email|
email.destroy
end
end | Base | 1 |
def resource_change_group(params, request, session)
if not allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
if params[:resource_id].nil? or params[:group_id].nil?
return [400, 'resource_id and group_id have to be specified.']
end
if params[:group_id].empty?
if params[:old_group_id]
_, stderr, retval = run_cmd(
session, PCS, 'resource', 'group', 'remove', params[:old_group_id],
params[:resource_id]
)
if retval != 0
return [400, "Unable to remove resource '#{params[:resource_id]}' " +
"from group '#{params[:old_group_id]}': #{stderr.join('')}"
]
end
end
return 200
end
_, stderr, retval = run_cmd(
session,
PCS, 'resource', 'group', 'add', params[:group_id], params[:resource_id]
)
if retval != 0
return [400, "Unable to add resource '#{params[:resource_id]}' to " +
"group '#{params[:group_id]}': #{stderr.join('')}"
]
end
return 200
end | Compound | 4 |
it "does not re-sync the cluster" do
cluster.should_receive(:sync).never
cluster.socket_for :write
end | Class | 2 |
def mime_magic_content_type(new_file)
content_type = nil
File.open(new_file.path) do |fd|
content_type = Marcel::MimeType.for(fd)
end
content_type
end | Base | 1 |
def generate(time, inc = 0)
pid = Process.pid % 0xFFFF
[
time >> 24 & 0xFF, # 4 bytes time (network order)
time >> 16 & 0xFF,
time >> 8 & 0xFF,
time & 0xFF,
@machine_id[0], # 3 bytes machine
@machine_id[1],
@machine_id[2],
pid >> 8 & 0xFF, # 2 bytes process id
pid & 0xFF,
inc >> 16 & 0xFF, # 3 bytes increment
inc >> 8 & 0xFF,
inc & 0xFF,
]
end | Class | 2 |
def remove_constraint(session, constraint_id)
stdout, stderror, retval = run_cmd(
session, PCS, "constraint", "remove", constraint_id
)
$logger.info stdout
return retval
end | Compound | 4 |
def restrict_user_fields?(user)
user.trust_level == TrustLevel[0] && anonymous?
end | Class | 2 |
def ajax_delete_mails
Log.add_info(request, params.inspect)
folder_id = params[:id]
mail_account_id = params[:mail_account_id]
unless params[:check_mail].blank?
mail_folder = MailFolder.find(folder_id)
trash_folder = MailFolder.get_for(@login_user, mail_account_id, MailFolder::XTYPE_TRASH)
count = 0
params[:check_mail].each do |email_id, value|
next if value != '1'
email = Email.find_by_id(email_id)
next if email.nil? or (email.user_id != @login_user.id)
if trash_folder.nil? \
or folder_id == trash_folder.id.to_s \
or mail_folder.get_parents(false).include?(trash_folder.id.to_s)
email.destroy
flash[:notice] ||= t('msg.delete_success')
else
begin
email.update_attribute(:mail_folder_id, trash_folder.id)
flash[:notice] ||= t('msg.moved_to_trash')
rescue => evar
Log.add_error(request, evar)
email.destroy
flash[:notice] ||= t('msg.delete_success')
end
end
count += 1
end
end
get_mails
end | Base | 1 |
it "executes a count command" do
database.should_receive(:command).with(
count: collection.name,
query: selector
).and_return("n" => 4)
query.count
end | Class | 2 |
def make_hs256_token(payload = nil)
payload = { sub: 'abc123' } if payload.nil?
JWT.encode payload, client_secret, 'HS256'
end | Base | 1 |
def email
user_info['email'] || id_info['email']
end | Base | 1 |
def test_put
uri = URI('http://localhost:6470/makeme')
req = Net::HTTP::Put.new(uri)
# Set the headers the way we want them.
req['Accept-Encoding'] = '*'
req['Accept'] = 'application/json'
req['User-Agent'] = 'Ruby'
req.body = 'hello'
res = Net::HTTP.start(uri.hostname, uri.port) { |h|
h.request(req)
}
assert_equal(Net::HTTPCreated, res.class)
assert_equal('hello', res.body)
end | Base | 1 |
def original_filename
filename = filename_from_header || filename_from_uri
mime_type = MiniMime.lookup_by_content_type(file.content_type)
unless File.extname(filename).present? || mime_type.blank?
filename = "#{filename}.#{mime_type.extension}"
end
filename
end | Base | 1 |
def test_nest
get :nest, {:id => Hostgroup.first.id}, set_session_user
assert_template 'new'
end | Class | 2 |
def self.get_from_name(user_name)
SqlHelper.validate_token([user_name])
begin
user = User.where("name='#{user_name}'").first
rescue => evar
Log.add_error(nil, evar)
end
return user
end | Base | 1 |
def test_extract_symlink_parent
skip 'symlink not supported' if Gem.win_platform?
package = Gem::Package.new @gem
tgz_io = util_tar_gz do |tar|
tar.mkdir 'lib', 0755
tar.add_symlink 'lib/link', '../..', 0644
tar.add_file 'lib/link/outside.txt', 0644 do |io| io.write 'hi' end
end
# Extract into a subdirectory of @destination; if this test fails it writes
# a file outside destination_subdir, but we want the file to remain inside
# @destination so it will be cleaned up.
destination_subdir = File.join @destination, 'subdir'
FileUtils.mkdir_p destination_subdir
e = assert_raises Gem::Package::PathError do
package.extract_tar_gz tgz_io, destination_subdir
end
assert_equal("installing into parent path ../outside.txt of " +
"#{destination_subdir} is not allowed", e.message)
end | Base | 1 |
def self.get_using_size(mail_account_id, add_con=nil)
SqlHelper.validate_token([mail_account_id])
con = []
con << "(mail_account_id=#{mail_account_id})"
con << "(#{add_con})" unless add_con.nil? or add_con.empty?
return (Email.count_by_sql("select SUM(size) from emails where #{con.join(' and ')}") || 0)
end | Base | 1 |
it "has an empty list of dynamic seeds" do
cluster.dynamic_seeds.should be_empty
end | Class | 2 |
def self.get_next_revision(user_id, source_id)
copied_items = Item.where("user_id=#{user_id} and source_id=#{source_id}").order('created_at DESC').to_a
rev = 0
copied_items.each do |item|
rev_ary = item.title.scan(/[#](\d\d\d)$/)
next if rev_ary.nil?
rev = rev_ary.first.to_a.first.to_i
break
end
return '#' + sprintf('%03d', rev+1)
end | Base | 1 |
def fence_device_form(params, request, session)
if not allowed_for_local_cluster(session, Permissions::READ)
return 403, 'Permission denied'
end
@cur_resource = get_resource_by_id(params[:resource], get_cib_dom(session))
if @cur_resource.instance_of?(ClusterEntity::Primitive) and @cur_resource.stonith
@resource_agents = getFenceAgents(session, @cur_resource.agentname)
@existing_resource = true
@fenceagent = @resource_agents[@cur_resource.type]
erb :fenceagentform
else
"Can't find fence device"
end
end | Compound | 4 |
def resource_ungroup(params, request, session)
if not allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
unless params[:group_id]
return [400, 'group_id has to be specified.']
end
_, stderr, retval = run_cmd(
session, PCS, 'resource', 'ungroup', params[:group_id]
)
if retval != 0
return [400, 'Unable to ungroup group ' +
"'#{params[:group_id]}': #{stderr.join('')}"
]
end
return 200
end | Compound | 4 |
it 'should escape the content of removed `plaintext` elements' do
Sanitize.fragment('<plaintext>hello! <script>alert(0)</script>')
.must_equal 'hello! <script>alert(0)</script>'
end | Base | 1 |
it 'should return the right response' do
email_token.update!(created_at: 999.years.ago)
get "/session/email-login/#{email_token.token}"
expect(response.status).to eq(200)
expect(CGI.unescapeHTML(response.body)).to match(
I18n.t('email_login.invalid_token')
)
end | Class | 2 |
def self.get_value(user_id, category, key)
SqlHelper.validate_token([user_id, category, key])
con = []
con << "(user_id=#{user_id})"
con << "(category='#{category}')"
con << "(xkey='#{key}')"
setting = Setting.where(con.join(' and ')).first
return setting.xvalue unless setting.nil?
return nil
end | Base | 1 |
def actions
if params[:media_action] != 'crop_url'
authorize! :manage, :media
end
params[:folder] = params[:folder].gsub("//", "/") if params[:folder].present?
case params[:media_action]
when "new_folder"
params[:folder] = slugify_folder(params[:folder])
render partial: "render_file_item", locals: {files: [cama_uploader.add_folder(params[:folder])]}
when "del_folder"
cama_uploader.delete_folder(params[:folder])
render inline: ""
when "del_file"
cama_uploader.delete_file(params[:folder].gsub("//", "/"))
render inline: ""
when 'crop_url'
unless params[:url].start_with?('data:')
params[:url] = (params[:url].start_with?('http') ? '' : current_site.the_url(locale: nil)) + params[:url]
end
r = cama_tmp_upload( params[:url], formats: params[:formats], name: params[:name])
unless r[:error].present?
params[:file_upload] = r[:file_path]
sett = {remove_source: true}
sett[:same_name] = true if params[:same_name].present?
sett[:name] = params[:name] if params[:name].present?
upload(sett)
else
render inline: r[:error]
end
end | Base | 1 |
def login_success
if params[:ref].blank?
redirect_to default_logged_in_path
elsif params[:ref] =~ /^\//
redirect_to params[:ref]
else
render "sns/login/redirect"
end
end | Base | 1 |
def update_config
Log.add_info(request, params.inspect)
@yaml = ApplicationHelper.get_config_yaml
unless params[:desktop].nil? or params[:desktop].empty?
@yaml[:desktop] = Hash.new if @yaml[:desktop].nil?
params[:desktop].each do |key, val|
@yaml[:desktop][key] = val
end
ApplicationHelper.save_config_yaml(@yaml)
end
flash[:notice] = t('msg.update_success')
render(:partial => 'ajax_user_before_login', :layout => false)
end | Base | 1 |
it "raises a QueryFailure exception" do
expect {
session.query(query)
}.to raise_exception(Moped::Errors::QueryFailure)
end | Class | 2 |
def rs256_decode_key(kid)
jwks_x5c = jwks_key(:x5c, kid)
if jwks_x5c.nil?
raise OmniAuth::Auth0::TokenValidationError.new("Could not find a public key for Key ID (kid) '#{kid}''")
end
jwks_public_cert(jwks_x5c.first)
end | Base | 1 |
def login(database, username, password)
auth[database.to_s] = [username, password]
end | Class | 2 |
it 'should escape the content of removed `xmp` elements' do
Sanitize.fragment('<xmp>hello! <script>alert(0)</script></xmp>')
.must_equal 'hello! <script>alert(0)</script>'
end | Base | 1 |
it "has an empty list of primaries" do
cluster.primaries.should be_empty
end | Class | 2 |
it "drops the collection" do
database.should_receive(:command).with(drop: :users)
collection.drop
end | Class | 2 |
def timeline
unless params[:type].empty?
model = params[:type].camelize.constantize
item = model.find(params[:id])
item.update_attribute(:state, params[:state])
else
comments, emails = params[:id].split("+")
Comment.update_all("state = '#{params[:state]}'", "id IN (#{comments})") unless comments.blank?
Email.update_all("state = '#{params[:state]}'", "id IN (#{emails})") unless emails.blank?
end
render :nothing => true
end | Base | 1 |
it "does not change the original session's options" do
original_options = options.dup
session.with(new_options) do |new_session|
session.options.should eql original_options
end
end | Class | 2 |
def set_node_utilization(params, reqest, session)
unless allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
unless params[:node] and params[:name]
return 400, 'node and name are required'
end
node = params[:node]
name = params[:name]
value = params[:value] || ''
_, stderr, retval = run_cmd(
session, PCS, 'node', 'utilization', node, "#{name}=#{value}"
)
if retval != 0
return [400, "Unable to set utilization '#{name}=#{value}' for node " +
"'#{res_id}': #{stderr.join('')}"
]
end
return 200
end | Compound | 4 |
def update_auth
Log.add_info(request, params.inspect)
return unless request.post?
auth = nil
if params[:check_auth_all] == '1'
auth = User::AUTH_ALL
else
auth_selected = params[:auth_selected]
unless auth_selected.nil? or auth_selected.empty?
auth = '|' + auth_selected.join('|') + '|'
end
if auth_selected.nil? or !auth_selected.include?(User::AUTH_USER)
user_admin_err = false
user_admins = User.where("auth like '%|#{User::AUTH_USER}|%' or auth='#{User::AUTH_ALL}'").to_a
if user_admins.nil? or user_admins.empty?
user_admin_err = true
elsif user_admins.length == 1
if user_admins.first.id.to_s == params[:id]
user_admin_err = true
end
end
if user_admin_err
render(:text => t('user.no_user_auth'))
return
end
end
end
begin
user = User.find(params[:id])
rescue => evar
Log.add_error(request, evar)
end
if user.nil?
render(:text => t('msg.already_deleted', :name => User.model_name.human))
else
user.update_attribute(:auth, auth)
if user.id == @login_user.id
@login_user = user
end
render(:text => '')
end
end | Base | 1 |
def test_attr_wrapper
assert_equal("<p strange=*attrs*></p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
assert_equal("<p escaped='quo\"te'></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
assert_equal("<p escaped=\"quo'te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
assert_equal("<p escaped=\"q'uo"te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"', :format => :xhtml))
end | Base | 1 |
def test_update_valid
Subnet.any_instance.stubs(:valid?).returns(true)
put :update, {:id => Subnet.first, :subnet => {:network => '192.168.100.10'}}, set_session_user
assert_equal '192.168.100.10', Subnet.first.network
assert_redirected_to subnets_url
end | Class | 2 |
def _extend_marshalling(options)
@marshalling = !(options[:marshalling] === false) # HACK - TODO delegate to Factory
extend Marshalling if @marshalling
end | Base | 1 |
it "stores the options provided" do
session.options.should eq(options)
end | Class | 2 |
def __bson_dump__(io, key)
io << Types::OBJECT_ID
io << key
io << NULL_BYTE
io << data.pack('C12')
end | Class | 2 |
def set_workflow
Log.add_info(request, params.inspect)
@item = Item.find(params[:id])
orders_hash = params.dup
orders_hash.reject! { |key, value|
key.index(/order-/) != 0
}
orders_hash.sort_by { |key, value|
key.split('-').last.to_i
}
orders = []
orders_hash.each do |key, value|
orders << '|' + value.split(',').join('|') + '|'
end
@item.workflow.update_attribute(:users, orders.join(','))
render(:partial => 'ajax_item_workflow', :layout => false)
rescue => evar
Log.add_error(request, evar)
render(:partial => 'ajax_item_workflow', :layout => false)
end | Base | 1 |
def edit
Log.add_info(request, params.inspect)
@group_id = params[:group_id]
official_title_id = params[:id]
unless official_title_id.nil? or official_title_id.empty?
@official_title = OfficialTitle.find(official_title_id)
end
render(:partial => 'ajax_official_title_form', :layout => (!request.xhr?))
end | Base | 1 |
it "returns a session" do
session.with(new_options).should be_a Moped::Session
end | Class | 2 |
def create
Log.add_info(request, params.inspect)
if params[:thetisBoxEdit].nil? or params[:thetisBoxEdit].empty?
@group = nil
else
@group = Group.new
@group.name = params[:thetisBoxEdit]
@group.parent_id = params[:selectedGroupId]
@group.save!
@group.create_group_folder
end
render(:partial => 'ajax_group_entry', :layout => false)
end | Base | 1 |
def check_member
return if params[:id].nil? or params[:id].empty? or @login_user.nil?
if Item.find(params[:id]).user_id != @login_user.id
Log.add_check(request, '[check_member]'+request.to_s)
flash[:notice] = t('team.need_to_be_member')
redirect_to(:controller => 'desktop', :action => 'show')
end
end | Base | 1 |
it "returns a hex string representation of the id" do
Moped::BSON::ObjectId.new(bytes).to_s.should eq "4e4d66343b39b68407000001"
end | Class | 2 |
it "with dofollowify enabled, links should be nofollowed" do
@blog.dofollowify = true
@blog.save
expect(nofollowify_links('<a href="http://myblog.net">my blog</a>')).
to eq('<a href="http://myblog.net">my blog</a>')
end | Base | 1 |
def send_password
Log.add_info(request, params.inspect)
mail_addr = params[:thetisBoxEdit]
SqlHelper.validate_token([mail_addr], ['@-'])
begin
users = User.where("email='#{mail_addr}'").to_a
rescue => evar
end
if users.nil? or users.empty?
Log.add_error(request, evar)
flash[:notice] = 'ERROR:' + t('email.address_not_found')
else
user_passwords_h = {}
users.each do |user|
newpass = UsersHelper.generate_password
user.update_attribute(:pass_md5, UsersHelper.generate_digest_pass(user.name, newpass))
user_passwords_h[user] = newpass
end
NoticeMailer.password(user_passwords_h, ApplicationHelper.root_url(request)).deliver;
flash[:notice] = t('email.sent')
end
render(:controller => 'login', :action => 'index')
end | Base | 1 |
def self.find_term(user_id, start_date, end_date)
con = "(user_id=#{user_id}) and (date >= '#{start_date}') and (date <= '#{end_date}')"
ary = Timecard.where(con).order('date ASC').to_a
timecards_h = Hash.new
unless ary.nil?
ary.each do |timecard|
timecards_h[timecard.date.strftime(Schedule::SYS_DATE_FORM)] = timecard
end
end
return timecards_h
end | Base | 1 |
def logout(database)
auth.delete(database.to_s)
end | Class | 2 |
it "unmemoizes the current database" do
db = session.current_database
session.with(new_options) do |new_session|
new_session.current_database.should_not eql db
end
end | Class | 2 |
def __bson_dump__(io, key)
io << Types::OBJECT_ID
io << key
io << NULL_BYTE
io << data.pack('C12')
end | Class | 2 |
def get_users
if params[:action] == 'get_users'
Log.add_info(request, params.inspect)
end
@group_id = params[:id]
=begin
# @users = Group.get_users(params[:id])
=end
# FEATURE_PAGING_IN_TREE >>>
con = ['User.id > 0']
unless @group_id.nil?
if @group_id == '0'
con << "((groups like '%|0|%') or (groups is null))"
else
con << ApplicationHelper.get_sql_like([:groups], "|#{@group_id}|")
end
end
unless params[:keyword].blank?
key_array = params[:keyword].split(nil)
key_array.each do |key|
con << SqlHelper.get_sql_like([:name, :email, :fullname, :address, :organization, :tel1, :tel2, :tel3, :fax, :url, :postalcode, :title], key)
end
end
where = ''
unless con.empty?
where = ' where ' + con.join(' and ')
end
order_by = nil
@sort_col = params[:sort_col]
@sort_type = params[:sort_type]
if @sort_col.blank? or @sort_type.blank?
@sort_col = 'OfficialTitle.xorder'
@sort_type = 'ASC'
end
SqlHelper.validate_token([@sort_col, @sort_type])
order_by = @sort_col + ' ' + @sort_type
if @sort_col == 'OfficialTitle.xorder'
order_by = '(OfficialTitle.xorder is null) ' + @sort_type + ', ' + order_by
else
order_by << ', (OfficialTitle.xorder is null) ASC, OfficialTitle.xorder ASC'
end
if @sort_col != 'name'
order_by << ', name ASC'
end
sql = 'select distinct User.* from (users User left join user_titles UserTitle on User.id=UserTitle.user_id)'
sql << ' left join official_titles OfficialTitle on UserTitle.official_title_id=OfficialTitle.id'
sql << where + ' order by ' + order_by
@user_pages, @users, @total_num = paginate_by_sql(User, sql, 50)
# FEATURE_PAGING_IN_TREE <<<
session[:group_id] = @group_id
session[:group_option] = 'user'
render(:partial => 'ajax_group_users', :layout => false)
end | Base | 1 |
def get_group_equipment
Log.add_info(request, params.inspect)
@group_id = nil
if !params[:thetisBoxSelKeeper].nil?
@group_id = params[:thetisBoxSelKeeper].split(':').last
elsif !params[:group_id].nil? and !params[:group_id].empty?
@group_id = params[:group_id]
end
submit_url = url_for(:controller => 'schedules', :action => 'get_group_equipment')
render(:partial => 'common/select_equipment', :layout => false, :locals => {:target_attr => :id, :submit_url => submit_url})
end | Base | 1 |
it "returns the socket" do
cluster.stub(:sync) { cluster.servers << server }
cluster.socket_for(:write).should eq socket
end | Class | 2 |
def self.get_for(user_id, category=nil)
SqlHelper.validate_token([user_id, category])
con = []
con << "(user_id=#{user_id})"
con << "(category='#{category}')" unless category.nil?
settings = Setting.where(con.join(' and ')).to_a
return nil if settings.nil? or settings.empty?
hash = Hash.new
settings.each do |setting|
hash[setting.xkey] = setting.xvalue
end
return hash
end | Base | 1 |
it "returns false" do
indexes.drop(other: 1).should be_false
end | Class | 2 |
it "renders email addresses in the body" do
comment = build_stubbed(:comment, body: "[email protected]")
expect(comment.generate_html(:body)).to match(/mailto:/)
end | Base | 1 |
def read_lines(filename, selector)
if selector
IO.foreach(filename).select.with_index(1, &selector)
else
URI.open(filename, &:read)
end
end | Base | 1 |
def test_update_valid
SmartProxy.any_instance.stubs(:valid?).returns(true)
put :update, {:id => SmartProxy.first,:smart_proxy => {:url => "http://elsewhere.com:8443"}}, set_session_user
assert_equal "http://elsewhere.com:8443", SmartProxy.first.url
assert_redirected_to smart_proxies_url
end | Class | 2 |
def node_restart(params, request, session)
if params[:name]
code, response = send_request_with_token(
session, params[:name], 'node_restart', true
)
else
if not allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
$logger.info "Restarting Node"
output = `/sbin/reboot`
$logger.debug output
return output
end
end | Compound | 4 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.